Immutable branch between MFD, IIO and Power due for the v5.8 merge window

-----BEGIN PGP SIGNATURE-----
 
 iQIzBAABCgAdFiEEdrbJNaO+IJqU8IdIUa+KL4f8d2EFAl7M5H4ACgkQUa+KL4f8
 d2G3zg/8CR/GxzWumuf+N01PJZQI0725lYpLzrk2LdWn01FDv/opOX3M67gs9ZMV
 bYcugrmJJ23NvLYN1/DFz2HZ4g22HqICAZ+gdc4RXlxmYaz6BjrB1pmxdB1GvqCU
 I2htnQR1L1wvhSF7fl1zyZHmRd1V1jkBxp2pdZoFpcAHXpUq4EcyizYEs9ubwT8y
 GTUcVxfPTj6fIg+/OwCDuZXkzbxcvF5QbnkykS3XhRemBEUsPkriDjJ+VSR10opx
 EV0Dd81ZXV1x2gjA5Us4OoVr0RAECd3MrRg8D1tPOYp06NqDZF2qWPXFaT3gLq0w
 A9JELXQMar+e7WzV3VokMECSIaatHugCPwJYz3nVLpDBtHr7TaFu/55ZC9Li7Lgp
 hvowpJ4Q3+BHweWfOmnVY8Ah51tZF9GS1wBTIJcXqXaUnM1bQoV77bGM6M86hHsy
 39zyrPQNOgvwUWmCXWgs1J4K0GB48s02mXuJLYkg3YhGrfU0z3G0ptG03fI7D9/U
 17OUs9f8ZqKk21DBxXYJolj2J5NwqTjX9C0wEmYdalGNgAxj4f7nSrLTrwGiNRvX
 vPdR6ccDKAZScMizbhnv4u+c/seu8XJedei0OZWP+vtZ1j4PIr7exTOhKzPHi3i/
 F1+yyBEHYAPrITQI/j+hXAjwOlwqF1sAhdYsoiqb85O1XibMmHY=
 =89mP
 -----END PGP SIGNATURE-----

Merge tag 'tags/ib-mfd-iio-power-v5.8' into psy-next

This merges the MP2629 battery charge management immutable branch
between MFD, IIO and power-supply due for the v5.8 merge window
into power-supply for-next branch.

Signed-off-by: Sebastian Reichel <sebastian.reichel@collabora.com>
This commit is contained in:
Sebastian Reichel 2020-05-28 09:04:26 +02:00
commit 6c2fe5cae5
13 changed files with 1090 additions and 0 deletions

View file

@ -0,0 +1,8 @@
What: /sys/class/power_supply/mp2629_battery/batt_impedance_compen
Date: April 2020
KernelVersion: 5.7
Description:
Represents a battery impedance compensation to accelerate charging.
Access: Read, Write
Valid values: Represented in milli-ohms. Valid range is [0, 140].

View file

@ -0,0 +1,62 @@
# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause
%YAML 1.2
---
$id: http://devicetree.org/schemas/mfd/mps,mp2629.yaml#
$schema: http://devicetree.org/meta-schemas/core.yaml#
title: MP2629 Battery Charger PMIC from Monolithic Power System.
maintainers:
- Saravanan Sekar <sravanhome@gmail.com>
description: |
MP2629 is a PMIC providing battery charging and power supply for smartphones,
wireless camera and portable devices. Chip is controlled over I2C.
The battery charge management device handles battery charger controller and
ADC IIO device for battery, system voltage
properties:
compatible:
const: mps,mp2629
reg:
maxItems: 1
interrupts:
maxItems: 1
interrupt-controller: true
"#interrupt-cells":
const: 2
description:
The first cell is the IRQ number, the second cell is the trigger type.
required:
- compatible
- reg
- interrupts
- interrupt-controller
- "#interrupt-cells"
additionalProperties: false
examples:
- |
#include <dt-bindings/interrupt-controller/irq.h>
#include <dt-bindings/input/linux-event-codes.h>
i2c {
#address-cells = <1>;
#size-cells = <0>;
pmic@4b {
compatible = "mps,mp2629";
reg = <0x4b>;
interrupt-controller;
interrupt-parent = <&gpio2>;
#interrupt-cells = <2>;
interrupts = <3 IRQ_TYPE_LEVEL_HIGH>;
};
};

View file

@ -11395,10 +11395,15 @@ F: kernel/module.c
MONOLITHIC POWER SYSTEM PMIC DRIVER
M: Saravanan Sekar <sravanhome@gmail.com>
S: Maintained
F: Documentation/devicetree/bindings/mfd/mps,mp2629.yaml
F: Documentation/devicetree/bindings/regulator/mps,mp*.yaml
F: drivers/iio/adc/mp2629_adc.c
F: drivers/mfd/mp2629.c
F: drivers/power/supply/mp2629_charger.c
F: drivers/regulator/mp5416.c
F: drivers/regulator/mpq7920.c
F: drivers/regulator/mpq7920.h
F: include/linux/mfd/mp2629.h
MOTION EYE VAIO PICTUREBOOK CAMERA DRIVER
S: Orphan

View file

@ -692,6 +692,16 @@ config MESON_SARADC
To compile this driver as a module, choose M here: the
module will be called meson_saradc.
config MP2629_ADC
tristate "Monolithic MP2629 ADC driver"
depends on MFD_MP2629
help
Say yes to have support for battery charger IC MP2629 ADC device
accessed over I2C.
This driver provides ADC conversion of system, input power supply
and battery voltage & current information.
config NAU7802
tristate "Nuvoton NAU7802 ADC driver"
depends on I2C

View file

@ -65,6 +65,7 @@ obj-$(CONFIG_MCP3911) += mcp3911.o
obj-$(CONFIG_MEDIATEK_MT6577_AUXADC) += mt6577_auxadc.o
obj-$(CONFIG_MEN_Z188_ADC) += men_z188_adc.o
obj-$(CONFIG_MESON_SARADC) += meson_saradc.o
obj-$(CONFIG_MP2629_ADC) += mp2629_adc.o
obj-$(CONFIG_MXS_LRADC_ADC) += mxs-lradc-adc.o
obj-$(CONFIG_NAU7802) += nau7802.o
obj-$(CONFIG_NPCM_ADC) += npcm_adc.o

View file

@ -0,0 +1,208 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* MP2629 Driver for ADC
*
* Copyright 2020 Monolithic Power Systems, Inc
*
* Author: Saravanan Sekar <sravanhome@gmail.com>
*/
#include <linux/iio/driver.h>
#include <linux/iio/iio.h>
#include <linux/iio/machine.h>
#include <linux/mfd/mp2629.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#define MP2629_REG_ADC_CTRL 0x03
#define MP2629_REG_BATT_VOLT 0x0e
#define MP2629_REG_SYSTEM_VOLT 0x0f
#define MP2629_REG_INPUT_VOLT 0x11
#define MP2629_REG_BATT_CURRENT 0x12
#define MP2629_REG_INPUT_CURRENT 0x13
#define MP2629_ADC_START BIT(7)
#define MP2629_ADC_CONTINUOUS BIT(6)
#define MP2629_MAP(_mp, _mpc) IIO_MAP(#_mp, "mp2629_charger", "mp2629-"_mpc)
#define MP2629_ADC_CHAN(_ch, _type) { \
.type = _type, \
.indexed = 1, \
.datasheet_name = #_ch, \
.channel = MP2629_ ## _ch, \
.address = MP2629_REG_ ## _ch, \
.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
}
struct mp2629_adc {
struct regmap *regmap;
struct device *dev;
};
static struct iio_chan_spec mp2629_channels[] = {
MP2629_ADC_CHAN(BATT_VOLT, IIO_VOLTAGE),
MP2629_ADC_CHAN(SYSTEM_VOLT, IIO_VOLTAGE),
MP2629_ADC_CHAN(INPUT_VOLT, IIO_VOLTAGE),
MP2629_ADC_CHAN(BATT_CURRENT, IIO_CURRENT),
MP2629_ADC_CHAN(INPUT_CURRENT, IIO_CURRENT)
};
static struct iio_map mp2629_adc_maps[] = {
MP2629_MAP(BATT_VOLT, "batt-volt"),
MP2629_MAP(SYSTEM_VOLT, "system-volt"),
MP2629_MAP(INPUT_VOLT, "input-volt"),
MP2629_MAP(BATT_CURRENT, "batt-current"),
MP2629_MAP(INPUT_CURRENT, "input-current")
};
static int mp2629_read_raw(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan,
int *val, int *val2, long mask)
{
struct mp2629_adc *info = iio_priv(indio_dev);
unsigned int rval;
int ret;
switch (mask) {
case IIO_CHAN_INFO_RAW:
ret = regmap_read(info->regmap, chan->address, &rval);
if (ret)
return ret;
if (chan->address == MP2629_INPUT_VOLT)
rval &= GENMASK(6, 0);
*val = rval;
return IIO_VAL_INT;
case IIO_CHAN_INFO_SCALE:
switch (chan->channel) {
case MP2629_BATT_VOLT:
case MP2629_SYSTEM_VOLT:
*val = 20;
return IIO_VAL_INT;
case MP2629_INPUT_VOLT:
*val = 60;
return IIO_VAL_INT;
case MP2629_BATT_CURRENT:
*val = 175;
*val2 = 10;
return IIO_VAL_FRACTIONAL;
case MP2629_INPUT_CURRENT:
*val = 133;
*val2 = 10;
return IIO_VAL_FRACTIONAL;
default:
return -EINVAL;
}
default:
return -EINVAL;
}
}
static const struct iio_info mp2629_adc_info = {
.read_raw = &mp2629_read_raw,
};
static int mp2629_adc_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct mp2629_data *ddata = dev_get_drvdata(dev->parent);
struct mp2629_adc *info;
struct iio_dev *indio_dev;
int ret;
indio_dev = devm_iio_device_alloc(dev, sizeof(*info));
if (!indio_dev)
return -ENOMEM;
info = iio_priv(indio_dev);
info->regmap = ddata->regmap;
info->dev = dev;
platform_set_drvdata(pdev, indio_dev);
ret = regmap_update_bits(info->regmap, MP2629_REG_ADC_CTRL,
MP2629_ADC_START | MP2629_ADC_CONTINUOUS,
MP2629_ADC_START | MP2629_ADC_CONTINUOUS);
if (ret) {
dev_err(dev, "adc enable fail: %d\n", ret);
return ret;
}
ret = iio_map_array_register(indio_dev, mp2629_adc_maps);
if (ret) {
dev_err(dev, "IIO maps register fail: %d\n", ret);
goto fail_disable;
}
indio_dev->name = "mp2629-adc";
indio_dev->dev.parent = dev;
indio_dev->channels = mp2629_channels;
indio_dev->num_channels = ARRAY_SIZE(mp2629_channels);
indio_dev->modes = INDIO_DIRECT_MODE;
indio_dev->info = &mp2629_adc_info;
ret = iio_device_register(indio_dev);
if (ret) {
dev_err(dev, "IIO device register fail: %d\n", ret);
goto fail_map_unregister;
}
return 0;
fail_map_unregister:
iio_map_array_unregister(indio_dev);
fail_disable:
regmap_update_bits(info->regmap, MP2629_REG_ADC_CTRL,
MP2629_ADC_CONTINUOUS, 0);
regmap_update_bits(info->regmap, MP2629_REG_ADC_CTRL,
MP2629_ADC_START, 0);
return ret;
}
static int mp2629_adc_remove(struct platform_device *pdev)
{
struct iio_dev *indio_dev = platform_get_drvdata(pdev);
struct mp2629_adc *info = iio_priv(indio_dev);
iio_device_unregister(indio_dev);
iio_map_array_unregister(indio_dev);
regmap_update_bits(info->regmap, MP2629_REG_ADC_CTRL,
MP2629_ADC_CONTINUOUS, 0);
regmap_update_bits(info->regmap, MP2629_REG_ADC_CTRL,
MP2629_ADC_START, 0);
return 0;
}
static const struct of_device_id mp2629_adc_of_match[] = {
{ .compatible = "mps,mp2629_adc"},
{}
};
MODULE_DEVICE_TABLE(of, mp2629_adc_of_match);
static struct platform_driver mp2629_adc_driver = {
.driver = {
.name = "mp2629_adc",
.of_match_table = mp2629_adc_of_match,
},
.probe = mp2629_adc_probe,
.remove = mp2629_adc_remove,
};
module_platform_driver(mp2629_adc_driver);
MODULE_AUTHOR("Saravanan Sekar <sravanhome@gmail.com>");
MODULE_DESCRIPTION("MP2629 ADC driver");
MODULE_LICENSE("GPL");

View file

@ -434,6 +434,15 @@ config MFD_MC13XXX_I2C
help
Select this if your MC13xxx is connected via an I2C bus.
config MFD_MP2629
tristate "Monolithic Power Systems MP2629 ADC and Battery charger"
depends on I2C
select REGMAP_I2C
help
Select this option to enable support for Monolithic Power Systems
battery charger. This provides ADC, thermal and battery charger power
management functions.
config MFD_MXS_LRADC
tristate "Freescale i.MX23/i.MX28 LRADC"
depends on ARCH_MXS || COMPILE_TEST

View file

@ -170,6 +170,8 @@ obj-$(CONFIG_MFD_MAX8925) += max8925.o
obj-$(CONFIG_MFD_MAX8997) += max8997.o max8997-irq.o
obj-$(CONFIG_MFD_MAX8998) += max8998.o max8998-irq.o
obj-$(CONFIG_MFD_MP2629) += mp2629.o
pcf50633-objs := pcf50633-core.o pcf50633-irq.o
obj-$(CONFIG_MFD_PCF50633) += pcf50633.o
obj-$(CONFIG_PCF50633_ADC) += pcf50633-adc.o

79
drivers/mfd/mp2629.c Normal file
View file

@ -0,0 +1,79 @@
// SPDX-License-Identifier: GPL-2.0+
/*
* MP2629 parent driver for ADC and battery charger
*
* Copyright 2020 Monolithic Power Systems, Inc
*
* Author: Saravanan Sekar <sravanhome@gmail.com>
*/
#include <linux/i2c.h>
#include <linux/kernel.h>
#include <linux/mfd/core.h>
#include <linux/mfd/mp2629.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/slab.h>
static const struct mfd_cell mp2629_cell[] = {
{
.name = "mp2629_adc",
.of_compatible = "mps,mp2629_adc",
},
{
.name = "mp2629_charger",
.of_compatible = "mps,mp2629_charger",
}
};
static const struct regmap_config mp2629_regmap_config = {
.reg_bits = 8,
.val_bits = 8,
.max_register = 0x17,
};
static int mp2629_probe(struct i2c_client *client)
{
struct mp2629_data *ddata;
int ret;
ddata = devm_kzalloc(&client->dev, sizeof(*ddata), GFP_KERNEL);
if (!ddata)
return -ENOMEM;
ddata->dev = &client->dev;
i2c_set_clientdata(client, ddata);
ddata->regmap = devm_regmap_init_i2c(client, &mp2629_regmap_config);
if (IS_ERR(ddata->regmap)) {
dev_err(ddata->dev, "Failed to allocate regmap\n");
return PTR_ERR(ddata->regmap);
}
ret = devm_mfd_add_devices(ddata->dev, PLATFORM_DEVID_AUTO, mp2629_cell,
ARRAY_SIZE(mp2629_cell), NULL, 0, NULL);
if (ret)
dev_err(ddata->dev, "Failed to register sub-devices %d\n", ret);
return ret;
}
static const struct of_device_id mp2629_of_match[] = {
{ .compatible = "mps,mp2629"},
{ }
};
MODULE_DEVICE_TABLE(of, mp2629_of_match);
static struct i2c_driver mp2629_driver = {
.driver = {
.name = "mp2629",
.of_match_table = mp2629_of_match,
},
.probe_new = mp2629_probe,
};
module_i2c_driver(mp2629_driver);
MODULE_AUTHOR("Saravanan Sekar <sravanhome@gmail.com>");
MODULE_DESCRIPTION("MP2629 Battery charger parent driver");
MODULE_LICENSE("GPL");

View file

@ -552,6 +552,16 @@ config CHARGER_MAX8998
Say Y to enable support for the battery charger control sysfs and
platform data of MAX8998/LP3974 PMICs.
config CHARGER_MP2629
tristate "Monolithic power system MP2629 Battery charger"
depends on MFD_MP2629
depends on MP2629_ADC
depends on IIO
help
Select this option to enable support for Monolithic power system
Battery charger. This driver provides Battery charger power management
functions on the systems.
config CHARGER_QCOM_SMBB
tristate "Qualcomm Switch-Mode Battery Charger and Boost"
depends on MFD_SPMI_PMIC || COMPILE_TEST

View file

@ -76,6 +76,7 @@ obj-$(CONFIG_CHARGER_MAX77650) += max77650-charger.o
obj-$(CONFIG_CHARGER_MAX77693) += max77693_charger.o
obj-$(CONFIG_CHARGER_MAX8997) += max8997_charger.o
obj-$(CONFIG_CHARGER_MAX8998) += max8998_charger.o
obj-$(CONFIG_CHARGER_MP2629) += mp2629_charger.o
obj-$(CONFIG_CHARGER_QCOM_SMBB) += qcom_smbb.o
obj-$(CONFIG_CHARGER_BQ2415X) += bq2415x_charger.o
obj-$(CONFIG_CHARGER_BQ24190) += bq24190_charger.o

View file

@ -0,0 +1,669 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* MP2629 battery charger driver
*
* Copyright 2020 Monolithic Power Systems, Inc
*
* Author: Saravanan Sekar <sravanhome@gmail.com>
*/
#include <linux/bits.h>
#include <linux/iio/consumer.h>
#include <linux/iio/types.h>
#include <linux/interrupt.h>
#include <linux/mfd/mp2629.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/regmap.h>
#define MP2629_REG_INPUT_ILIM 0x00
#define MP2629_REG_INPUT_VLIM 0x01
#define MP2629_REG_CHARGE_CTRL 0x04
#define MP2629_REG_CHARGE_ILIM 0x05
#define MP2629_REG_PRECHARGE 0x06
#define MP2629_REG_TERM_CURRENT 0x06
#define MP2629_REG_CHARGE_VLIM 0x07
#define MP2629_REG_TIMER_CTRL 0x08
#define MP2629_REG_IMPEDANCE_COMP 0x09
#define MP2629_REG_INTERRUPT 0x0b
#define MP2629_REG_STATUS 0x0c
#define MP2629_REG_FAULT 0x0d
#define MP2629_MASK_INPUT_TYPE GENMASK(7, 5)
#define MP2629_MASK_CHARGE_TYPE GENMASK(4, 3)
#define MP2629_MASK_CHARGE_CTRL GENMASK(5, 4)
#define MP2629_MASK_WDOG_CTRL GENMASK(5, 4)
#define MP2629_MASK_IMPEDANCE GENMASK(7, 4)
#define MP2629_INPUTSOURCE_CHANGE GENMASK(7, 5)
#define MP2629_CHARGING_CHANGE GENMASK(4, 3)
#define MP2629_FAULT_BATTERY BIT(3)
#define MP2629_FAULT_THERMAL BIT(4)
#define MP2629_FAULT_INPUT BIT(5)
#define MP2629_FAULT_OTG BIT(6)
#define MP2629_MAX_BATT_CAPACITY 100
#define MP2629_PROPS(_idx, _min, _max, _step) \
[_idx] = { \
.min = _min, \
.max = _max, \
.step = _step, \
}
enum mp2629_source_type {
MP2629_SOURCE_TYPE_NO_INPUT,
MP2629_SOURCE_TYPE_NON_STD,
MP2629_SOURCE_TYPE_SDP,
MP2629_SOURCE_TYPE_CDP,
MP2629_SOURCE_TYPE_DCP,
MP2629_SOURCE_TYPE_OTG = 7,
};
enum mp2629_field {
INPUT_ILIM,
INPUT_VLIM,
CHARGE_ILIM,
CHARGE_VLIM,
PRECHARGE,
TERM_CURRENT,
MP2629_MAX_FIELD
};
struct mp2629_charger {
struct device *dev;
int status;
int fault;
struct regmap *regmap;
struct regmap_field *regmap_fields[MP2629_MAX_FIELD];
struct mutex lock;
struct power_supply *usb;
struct power_supply *battery;
struct iio_channel *iiochan[MP2629_ADC_CHAN_END];
};
struct mp2629_prop {
int reg;
int mask;
int min;
int max;
int step;
int shift;
};
static enum power_supply_usb_type mp2629_usb_types[] = {
POWER_SUPPLY_USB_TYPE_SDP,
POWER_SUPPLY_USB_TYPE_DCP,
POWER_SUPPLY_USB_TYPE_CDP,
POWER_SUPPLY_USB_TYPE_PD_DRP,
POWER_SUPPLY_USB_TYPE_UNKNOWN
};
static enum power_supply_property mp2629_charger_usb_props[] = {
POWER_SUPPLY_PROP_ONLINE,
POWER_SUPPLY_PROP_USB_TYPE,
POWER_SUPPLY_PROP_VOLTAGE_NOW,
POWER_SUPPLY_PROP_CURRENT_NOW,
POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT,
};
static enum power_supply_property mp2629_charger_bat_props[] = {
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_HEALTH,
POWER_SUPPLY_PROP_CHARGE_TYPE,
POWER_SUPPLY_PROP_VOLTAGE_NOW,
POWER_SUPPLY_PROP_CURRENT_NOW,
POWER_SUPPLY_PROP_CAPACITY,
POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
};
static struct mp2629_prop props[] = {
MP2629_PROPS(INPUT_ILIM, 100000, 3250000, 50000),
MP2629_PROPS(INPUT_VLIM, 3800000, 5300000, 100000),
MP2629_PROPS(CHARGE_ILIM, 320000, 4520000, 40000),
MP2629_PROPS(CHARGE_VLIM, 3400000, 4670000, 10000),
MP2629_PROPS(PRECHARGE, 120000, 720000, 40000),
MP2629_PROPS(TERM_CURRENT, 80000, 680000, 40000),
};
static const struct reg_field mp2629_reg_fields[] = {
[INPUT_ILIM] = REG_FIELD(MP2629_REG_INPUT_ILIM, 0, 5),
[INPUT_VLIM] = REG_FIELD(MP2629_REG_INPUT_VLIM, 0, 3),
[CHARGE_ILIM] = REG_FIELD(MP2629_REG_CHARGE_ILIM, 0, 6),
[CHARGE_VLIM] = REG_FIELD(MP2629_REG_CHARGE_VLIM, 1, 7),
[PRECHARGE] = REG_FIELD(MP2629_REG_PRECHARGE, 4, 7),
[TERM_CURRENT] = REG_FIELD(MP2629_REG_TERM_CURRENT, 0, 3),
};
static char *adc_chan_name[] = {
"mp2629-batt-volt",
"mp2629-system-volt",
"mp2629-input-volt",
"mp2629-batt-current",
"mp2629-input-current",
};
static int mp2629_read_adc(struct mp2629_charger *charger,
enum mp2629_adc_chan ch,
union power_supply_propval *val)
{
int ret;
int chval;
ret = iio_read_channel_processed(charger->iiochan[ch], &chval);
if (ret)
return ret;
val->intval = chval * 1000;
return 0;
}
static int mp2629_get_prop(struct mp2629_charger *charger,
enum mp2629_field fld,
union power_supply_propval *val)
{
int ret;
unsigned int rval;
ret = regmap_field_read(charger->regmap_fields[fld], &rval);
if (ret)
return ret;
val->intval = rval * props[fld].step + props[fld].min;
return 0;
}
static int mp2629_set_prop(struct mp2629_charger *charger,
enum mp2629_field fld,
const union power_supply_propval *val)
{
unsigned int rval;
if (val->intval < props[fld].min || val->intval > props[fld].max)
return -EINVAL;
rval = (val->intval - props[fld].min) / props[fld].step;
return regmap_field_write(charger->regmap_fields[fld], rval);
}
static int mp2629_get_battery_capacity(struct mp2629_charger *charger,
union power_supply_propval *val)
{
union power_supply_propval vnow, vlim;
int ret;
ret = mp2629_read_adc(charger, MP2629_BATT_VOLT, &vnow);
if (ret)
return ret;
ret = mp2629_get_prop(charger, CHARGE_VLIM, &vlim);
if (ret)
return ret;
val->intval = (vnow.intval * 100) / vlim.intval;
val->intval = min(val->intval, MP2629_MAX_BATT_CAPACITY);
return 0;
}
static int mp2629_charger_battery_get_prop(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct mp2629_charger *charger = dev_get_drvdata(psy->dev.parent);
unsigned int rval;
int ret = 0;
switch (psp) {
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
ret = mp2629_read_adc(charger, MP2629_BATT_VOLT, val);
break;
case POWER_SUPPLY_PROP_CURRENT_NOW:
ret = mp2629_read_adc(charger, MP2629_BATT_CURRENT, val);
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
val->intval = 4520000;
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
val->intval = 4670000;
break;
case POWER_SUPPLY_PROP_CAPACITY:
ret = mp2629_get_battery_capacity(charger, val);
break;
case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
ret = mp2629_get_prop(charger, TERM_CURRENT, val);
break;
case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
ret = mp2629_get_prop(charger, PRECHARGE, val);
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
ret = mp2629_get_prop(charger, CHARGE_VLIM, val);
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
ret = mp2629_get_prop(charger, CHARGE_ILIM, val);
break;
case POWER_SUPPLY_PROP_HEALTH:
if (!charger->fault)
val->intval = POWER_SUPPLY_HEALTH_GOOD;
if (MP2629_FAULT_BATTERY & charger->fault)
val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
else if (MP2629_FAULT_THERMAL & charger->fault)
val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
else if (MP2629_FAULT_INPUT & charger->fault)
val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
break;
case POWER_SUPPLY_PROP_STATUS:
ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
if (ret)
break;
rval = (rval & MP2629_MASK_CHARGE_TYPE) >> 3;
switch (rval) {
case 0x00:
val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
break;
case 0x01:
case 0x10:
val->intval = POWER_SUPPLY_STATUS_CHARGING;
break;
case 0x11:
val->intval = POWER_SUPPLY_STATUS_FULL;
}
break;
case POWER_SUPPLY_PROP_CHARGE_TYPE:
ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
if (ret)
break;
rval = (rval & MP2629_MASK_CHARGE_TYPE) >> 3;
switch (rval) {
case 0x00:
val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
break;
case 0x01:
val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
break;
case 0x10:
val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
break;
default:
val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
}
break;
default:
return -EINVAL;
}
return ret;
}
static int mp2629_charger_battery_set_prop(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct mp2629_charger *charger = dev_get_drvdata(psy->dev.parent);
switch (psp) {
case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
return mp2629_set_prop(charger, TERM_CURRENT, val);
case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
return mp2629_set_prop(charger, PRECHARGE, val);
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
return mp2629_set_prop(charger, CHARGE_VLIM, val);
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
return mp2629_set_prop(charger, CHARGE_ILIM, val);
default:
return -EINVAL;
}
}
static int mp2629_charger_usb_get_prop(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct mp2629_charger *charger = dev_get_drvdata(psy->dev.parent);
unsigned int rval;
int ret;
switch (psp) {
case POWER_SUPPLY_PROP_ONLINE:
ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
if (ret)
break;
val->intval = !!(rval & MP2629_MASK_INPUT_TYPE);
break;
case POWER_SUPPLY_PROP_USB_TYPE:
ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
if (ret)
break;
rval = (rval & MP2629_MASK_INPUT_TYPE) >> 5;
switch (rval) {
case MP2629_SOURCE_TYPE_SDP:
val->intval = POWER_SUPPLY_USB_TYPE_SDP;
break;
case MP2629_SOURCE_TYPE_CDP:
val->intval = POWER_SUPPLY_USB_TYPE_CDP;
break;
case MP2629_SOURCE_TYPE_DCP:
val->intval = POWER_SUPPLY_USB_TYPE_DCP;
break;
case MP2629_SOURCE_TYPE_OTG:
val->intval = POWER_SUPPLY_USB_TYPE_PD_DRP;
break;
default:
val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
break;
}
break;
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
ret = mp2629_read_adc(charger, MP2629_INPUT_VOLT, val);
break;
case POWER_SUPPLY_PROP_CURRENT_NOW:
ret = mp2629_read_adc(charger, MP2629_INPUT_CURRENT, val);
break;
case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
ret = mp2629_get_prop(charger, INPUT_VLIM, val);
break;
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
ret = mp2629_get_prop(charger, INPUT_ILIM, val);
break;
default:
return -EINVAL;
}
return ret;
}
static int mp2629_charger_usb_set_prop(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct mp2629_charger *charger = dev_get_drvdata(psy->dev.parent);
switch (psp) {
case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
return mp2629_set_prop(charger, INPUT_VLIM, val);
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
return mp2629_set_prop(charger, INPUT_ILIM, val);
default:
return -EINVAL;
}
}
static int mp2629_charger_battery_prop_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
return (psp == POWER_SUPPLY_PROP_PRECHARGE_CURRENT) ||
(psp == POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT) ||
(psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT) ||
(psp == POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE);
}
static int mp2629_charger_usb_prop_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
return (psp == POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT) ||
(psp == POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT);
}
static irqreturn_t mp2629_irq_handler(int irq, void *dev_id)
{
struct mp2629_charger *charger = dev_id;
unsigned int rval;
int ret;
mutex_lock(&charger->lock);
ret = regmap_read(charger->regmap, MP2629_REG_FAULT, &rval);
if (ret)
goto unlock;
if (rval) {
charger->fault = rval;
if (MP2629_FAULT_BATTERY & rval)
dev_err(charger->dev, "Battery fault OVP\n");
else if (MP2629_FAULT_THERMAL & rval)
dev_err(charger->dev, "Thermal shutdown fault\n");
else if (MP2629_FAULT_INPUT & rval)
dev_err(charger->dev, "no input or input OVP\n");
else if (MP2629_FAULT_OTG & rval)
dev_err(charger->dev, "VIN overloaded\n");
goto unlock;
}
ret = regmap_read(charger->regmap, MP2629_REG_STATUS, &rval);
if (ret)
goto unlock;
if (rval & MP2629_INPUTSOURCE_CHANGE)
power_supply_changed(charger->usb);
else if (rval & MP2629_CHARGING_CHANGE)
power_supply_changed(charger->battery);
unlock:
mutex_unlock(&charger->lock);
return IRQ_HANDLED;
}
static const struct power_supply_desc mp2629_usb_desc = {
.name = "mp2629_usb",
.type = POWER_SUPPLY_TYPE_USB,
.usb_types = mp2629_usb_types,
.num_usb_types = ARRAY_SIZE(mp2629_usb_types),
.properties = mp2629_charger_usb_props,
.num_properties = ARRAY_SIZE(mp2629_charger_usb_props),
.get_property = mp2629_charger_usb_get_prop,
.set_property = mp2629_charger_usb_set_prop,
.property_is_writeable = mp2629_charger_usb_prop_writeable,
};
static const struct power_supply_desc mp2629_battery_desc = {
.name = "mp2629_battery",
.type = POWER_SUPPLY_TYPE_BATTERY,
.properties = mp2629_charger_bat_props,
.num_properties = ARRAY_SIZE(mp2629_charger_bat_props),
.get_property = mp2629_charger_battery_get_prop,
.set_property = mp2629_charger_battery_set_prop,
.property_is_writeable = mp2629_charger_battery_prop_writeable,
};
static ssize_t batt_impedance_compensation_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct mp2629_charger *charger = dev_get_drvdata(dev->parent);
unsigned int rval;
int ret;
ret = regmap_read(charger->regmap, MP2629_REG_IMPEDANCE_COMP, &rval);
if (ret)
return ret;
rval = (rval >> 4) * 10;
return sprintf(buf, "%d mohm\n", rval);
}
static ssize_t batt_impedance_compensation_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
struct mp2629_charger *charger = dev_get_drvdata(dev->parent);
unsigned int val;
int ret;
ret = kstrtouint(buf, 10, &val);
if (ret)
return ret;
if (val > 140)
return -ERANGE;
/* multiples of 10 mohm so round off */
val = val / 10;
ret = regmap_update_bits(charger->regmap, MP2629_REG_IMPEDANCE_COMP,
MP2629_MASK_IMPEDANCE, val << 4);
if (ret)
return ret;
return count;
}
static DEVICE_ATTR_RW(batt_impedance_compensation);
static struct attribute *mp2629_charger_sysfs_attrs[] = {
&dev_attr_batt_impedance_compensation.attr,
NULL
};
ATTRIBUTE_GROUPS(mp2629_charger_sysfs);
static void mp2629_charger_disable(void *data)
{
struct mp2629_charger *charger = data;
regmap_update_bits(charger->regmap, MP2629_REG_CHARGE_CTRL,
MP2629_MASK_CHARGE_CTRL, 0);
}
static int mp2629_charger_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct mp2629_data *ddata = dev_get_drvdata(dev->parent);
struct mp2629_charger *charger;
struct power_supply_config psy_cfg = {};
int ret, i, irq;
charger = devm_kzalloc(dev, sizeof(*charger), GFP_KERNEL);
if (!charger)
return -ENOMEM;
charger->regmap = ddata->regmap;
charger->dev = dev;
platform_set_drvdata(pdev, charger);
irq = platform_get_irq_optional(to_platform_device(dev->parent), 0);
if (irq < 0) {
dev_err(dev, "get irq fail: %d\n", irq);
return irq;
}
for (i = 0; i < MP2629_MAX_FIELD; i++) {
charger->regmap_fields[i] = devm_regmap_field_alloc(dev,
charger->regmap, mp2629_reg_fields[i]);
if (IS_ERR(charger->regmap_fields[i])) {
dev_err(dev, "regmap field alloc fail %d\n", i);
return PTR_ERR(charger->regmap_fields[i]);
}
}
for (i = 0; i < MP2629_ADC_CHAN_END; i++) {
charger->iiochan[i] = devm_iio_channel_get(dev,
adc_chan_name[i]);
if (IS_ERR(charger->iiochan[i])) {
dev_err(dev, "iio chan get %s err\n", adc_chan_name[i]);
return PTR_ERR(charger->iiochan[i]);
}
}
ret = devm_add_action_or_reset(dev, mp2629_charger_disable, charger);
if (ret)
return ret;
charger->usb = devm_power_supply_register(dev, &mp2629_usb_desc, NULL);
if (IS_ERR(charger->usb)) {
dev_err(dev, "power supply register usb failed\n");
return PTR_ERR(charger->usb);
}
psy_cfg.drv_data = charger;
psy_cfg.attr_grp = mp2629_charger_sysfs_groups;
charger->battery = devm_power_supply_register(dev,
&mp2629_battery_desc, &psy_cfg);
if (IS_ERR(charger->battery)) {
dev_err(dev, "power supply register battery failed\n");
return PTR_ERR(charger->battery);
}
ret = regmap_update_bits(charger->regmap, MP2629_REG_CHARGE_CTRL,
MP2629_MASK_CHARGE_CTRL, BIT(4));
if (ret) {
dev_err(dev, "enable charge fail: %d\n", ret);
return ret;
}
regmap_update_bits(charger->regmap, MP2629_REG_TIMER_CTRL,
MP2629_MASK_WDOG_CTRL, 0);
mutex_init(&charger->lock);
ret = devm_request_threaded_irq(dev, irq, NULL, mp2629_irq_handler,
IRQF_ONESHOT | IRQF_TRIGGER_RISING,
"mp2629-charger", charger);
if (ret) {
dev_err(dev, "failed to request gpio IRQ\n");
return ret;
}
regmap_update_bits(charger->regmap, MP2629_REG_INTERRUPT,
GENMASK(6, 5), BIT(6) | BIT(5));
return 0;
}
static const struct of_device_id mp2629_charger_of_match[] = {
{ .compatible = "mps,mp2629_charger"},
{}
};
MODULE_DEVICE_TABLE(of, mp2629_charger_of_match);
static struct platform_driver mp2629_charger_driver = {
.driver = {
.name = "mp2629_charger",
.of_match_table = mp2629_charger_of_match,
},
.probe = mp2629_charger_probe,
};
module_platform_driver(mp2629_charger_driver);
MODULE_AUTHOR("Saravanan Sekar <sravanhome@gmail.com>");
MODULE_DESCRIPTION("MP2629 Charger driver");
MODULE_LICENSE("GPL");

View file

@ -0,0 +1,26 @@
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Copyright 2020 Monolithic Power Systems, Inc
*/
#ifndef __MP2629_H__
#define __MP2629_H__
#include <linux/device.h>
#include <linux/regmap.h>
struct mp2629_data {
struct device *dev;
struct regmap *regmap;
};
enum mp2629_adc_chan {
MP2629_BATT_VOLT,
MP2629_SYSTEM_VOLT,
MP2629_INPUT_VOLT,
MP2629_BATT_CURRENT,
MP2629_INPUT_CURRENT,
MP2629_ADC_CHAN_END
};
#endif