1
0
mirror of https://github.com/torvalds/linux.git synced 2024-12-22 10:56:40 +00:00
linux/drivers/power/lp8727_charger.c
Krzysztof Kozlowski 297d716f62 power_supply: Change ownership from driver to core
Change the ownership of power_supply structure from each driver
implementing the class to the power supply core.

The patch changes power_supply_register() function thus all drivers
implementing power supply class are adjusted.

Each driver provides the implementation of power supply. However it
should not be the owner of power supply class instance because it is
exposed by core to other subsystems with power_supply_get_by_name().
These other subsystems have no knowledge when the driver will unregister
the power supply. This leads to several issues when driver is unbound -
mostly because user of power supply accesses freed memory.

Instead let the core own the instance of struct 'power_supply'.  Other
users of this power supply will still access valid memory because it
will be freed when device reference count reaches 0. Currently this
means "it will leak" but power_supply_put() call in next patches will
solve it.

This solves invalid memory references in following race condition
scenario:

Thread 1: charger manager
Thread 2: power supply driver, used by charger manager

THREAD 1 (charger manager)         THREAD 2 (power supply driver)
==========================         ==============================
psy = power_supply_get_by_name()
                                   Driver unbind, .remove
                                     power_supply_unregister()
                                     Device fully removed
psy->get_property()

The 'get_property' call is executed in invalid context because the driver was
unbound and struct 'power_supply' memory was freed.

This could be observed easily with charger manager driver (here compiled
with max17040 fuel gauge):

$ cat /sys/devices/virtual/power_supply/cm-battery/capacity &
$ echo "1-0036" > /sys/bus/i2c/drivers/max17040/unbind
[   55.725123] Unable to handle kernel NULL pointer dereference at virtual address 00000000
[   55.732584] pgd = d98d4000
[   55.734060] [00000000] *pgd=5afa2831, *pte=00000000, *ppte=00000000
[   55.740318] Internal error: Oops: 80000007 [] PREEMPT SMP ARM
[   55.746210] Modules linked in:
[   55.749259] CPU: 1 PID: 2936 Comm: cat Tainted: G        W       3.19.0-rc1-next-20141226-00048-gf79f475f3c44-dirty 
[   55.760190] Hardware name: SAMSUNG EXYNOS (Flattened Device Tree)
[   55.766270] task: d9b76f00 ti: daf54000 task.ti: daf54000
[   55.771647] PC is at 0x0
[   55.774182] LR is at charger_get_property+0x2f4/0x36c
[   55.779201] pc : [<00000000>]    lr : [<c034b0b4>]    psr: 60000013
[   55.779201] sp : daf55e90  ip : 00000003  fp : 00000000
[   55.790657] r10: 00000000  r9 : c06e2878  r8 : d9b26c68
[   55.795865] r7 : dad81610  r6 : daec7410  r5 : daf55ebc  r4 : 00000000
[   55.802367] r3 : 00000000  r2 : daf55ebc  r1 : 0000002a  r0 : d9b26c68
[   55.808879] Flags: nZCv  IRQs on  FIQs on  Mode SVC_32  ISA ARM  Segment user
[   55.815994] Control: 10c5387d  Table: 598d406a  DAC: 00000015
[   55.821723] Process cat (pid: 2936, stack limit = 0xdaf54210)
[   55.827451] Stack: (0xdaf55e90 to 0xdaf56000)
[   55.831795] 5e80:                                     60000013 c01459c4 0000002a c06f8ef8
[   55.839956] 5ea0: db651000 c06f8ef8 daebac00 c04cb668 daebac08 c0346864 00000000 c01459c4
[   55.848115] 5ec0: d99eaa80 c06f8ef8 00000fff 00001000 db651000 c027f25c c027f240 d99eaa80
[   55.856274] 5ee0: d9a06c00 c0146218 daf55f18 00001000 d99eaa80 db4c18c0 00000001 00000001
[   55.864468] 5f00: daf55f80 c0144c78 c0144c54 c0107f90 00015000 d99eaab0 00000000 00000000
[   55.872603] 5f20: 000051c7 00000000 db4c18c0 c04a9370 00015000 00001000 daf55f80 00001000
[   55.880763] 5f40: daf54000 00015000 00000000 c00e53dc db4c18c0 c00e548c 0000000d 00008124
[   55.888937] 5f60: 00000001 00000000 00000000 db4c18c0 db4c18c0 00001000 00015000 c00e5550
[   55.897099] 5f80: 00000000 00000000 00001000 00001000 00015000 00000003 00000003 c000f364
[   55.905239] 5fa0: 00000000 c000f1a0 00001000 00015000 00000003 00015000 00001000 0001333c
[   55.913399] 5fc0: 00001000 00015000 00000003 00000003 00000002 00000000 00000000 00000000
[   55.921560] 5fe0: 7fffe000 be999850 0000a225 b6f3c19c 60000010 00000003 00000000 00000000
[   55.929744] [<c034b0b4>] (charger_get_property) from [<c0346864>] (power_supply_show_property+0x48/0x20c)
[   55.939286] [<c0346864>] (power_supply_show_property) from [<c027f25c>] (dev_attr_show+0x1c/0x48)
[   55.948130] [<c027f25c>] (dev_attr_show) from [<c0146218>] (sysfs_kf_seq_show+0x84/0x104)
[   55.956298] [<c0146218>] (sysfs_kf_seq_show) from [<c0144c78>] (kernfs_seq_show+0x24/0x28)
[   55.964536] [<c0144c78>] (kernfs_seq_show) from [<c0107f90>] (seq_read+0x1b0/0x484)
[   55.972172] [<c0107f90>] (seq_read) from [<c00e53dc>] (__vfs_read+0x18/0x4c)
[   55.979188] [<c00e53dc>] (__vfs_read) from [<c00e548c>] (vfs_read+0x7c/0x100)
[   55.986304] [<c00e548c>] (vfs_read) from [<c00e5550>] (SyS_read+0x40/0x8c)
[   55.993164] [<c00e5550>] (SyS_read) from [<c000f1a0>] (ret_fast_syscall+0x0/0x48)
[   56.000626] Code: bad PC value
[   56.011652] ---[ end trace 7b64343fbdae8ef1 ]---

Signed-off-by: Krzysztof Kozlowski <k.kozlowski@samsung.com>
Reviewed-by: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>

[for the nvec part]
Reviewed-by: Marc Dietrich <marvin24@gmx.de>

[for compal-laptop.c]
Acked-by: Darren Hart <dvhart@linux.intel.com>

[for the mfd part]
Acked-by: Lee Jones <lee.jones@linaro.org>

[for the hid part]
Acked-by: Jiri Kosina <jkosina@suse.cz>

[for the acpi part]
Acked-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

Signed-off-by: Sebastian Reichel <sre@kernel.org>
2015-03-13 23:15:51 +01:00

631 lines
14 KiB
C

/*
* Driver for LP8727 Micro/Mini USB IC with integrated charger
*
* Copyright (C) 2011 Texas Instruments
* Copyright (C) 2011 National Semiconductor
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
*/
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/power_supply.h>
#include <linux/platform_data/lp8727.h>
#include <linux/of.h>
#define LP8788_NUM_INTREGS 2
#define DEFAULT_DEBOUNCE_MSEC 270
/* Registers */
#define LP8727_CTRL1 0x1
#define LP8727_CTRL2 0x2
#define LP8727_SWCTRL 0x3
#define LP8727_INT1 0x4
#define LP8727_INT2 0x5
#define LP8727_STATUS1 0x6
#define LP8727_STATUS2 0x7
#define LP8727_CHGCTRL2 0x9
/* CTRL1 register */
#define LP8727_CP_EN BIT(0)
#define LP8727_ADC_EN BIT(1)
#define LP8727_ID200_EN BIT(4)
/* CTRL2 register */
#define LP8727_CHGDET_EN BIT(1)
#define LP8727_INT_EN BIT(6)
/* SWCTRL register */
#define LP8727_SW_DM1_DM (0x0 << 0)
#define LP8727_SW_DM1_HiZ (0x7 << 0)
#define LP8727_SW_DP2_DP (0x0 << 3)
#define LP8727_SW_DP2_HiZ (0x7 << 3)
/* INT1 register */
#define LP8727_IDNO (0xF << 0)
#define LP8727_VBUS BIT(4)
/* STATUS1 register */
#define LP8727_CHGSTAT (3 << 4)
#define LP8727_CHPORT BIT(6)
#define LP8727_DCPORT BIT(7)
#define LP8727_STAT_EOC 0x30
/* STATUS2 register */
#define LP8727_TEMP_STAT (3 << 5)
#define LP8727_TEMP_SHIFT 5
/* CHGCTRL2 register */
#define LP8727_ICHG_SHIFT 4
enum lp8727_dev_id {
LP8727_ID_NONE,
LP8727_ID_TA,
LP8727_ID_DEDICATED_CHG,
LP8727_ID_USB_CHG,
LP8727_ID_USB_DS,
LP8727_ID_MAX,
};
enum lp8727_die_temp {
LP8788_TEMP_75C,
LP8788_TEMP_95C,
LP8788_TEMP_115C,
LP8788_TEMP_135C,
};
struct lp8727_psy {
struct power_supply *ac;
struct power_supply *usb;
struct power_supply *batt;
};
struct lp8727_chg {
struct device *dev;
struct i2c_client *client;
struct mutex xfer_lock;
struct lp8727_psy *psy;
struct lp8727_platform_data *pdata;
/* Charger Data */
enum lp8727_dev_id devid;
struct lp8727_chg_param *chg_param;
/* Interrupt Handling */
int irq;
struct delayed_work work;
unsigned long debounce_jiffies;
};
static int lp8727_read_bytes(struct lp8727_chg *pchg, u8 reg, u8 *data, u8 len)
{
s32 ret;
mutex_lock(&pchg->xfer_lock);
ret = i2c_smbus_read_i2c_block_data(pchg->client, reg, len, data);
mutex_unlock(&pchg->xfer_lock);
return (ret != len) ? -EIO : 0;
}
static inline int lp8727_read_byte(struct lp8727_chg *pchg, u8 reg, u8 *data)
{
return lp8727_read_bytes(pchg, reg, data, 1);
}
static int lp8727_write_byte(struct lp8727_chg *pchg, u8 reg, u8 data)
{
int ret;
mutex_lock(&pchg->xfer_lock);
ret = i2c_smbus_write_byte_data(pchg->client, reg, data);
mutex_unlock(&pchg->xfer_lock);
return ret;
}
static bool lp8727_is_charger_attached(const char *name, int id)
{
if (!strcmp(name, "ac"))
return id == LP8727_ID_TA || id == LP8727_ID_DEDICATED_CHG;
else if (!strcmp(name, "usb"))
return id == LP8727_ID_USB_CHG;
return id >= LP8727_ID_TA && id <= LP8727_ID_USB_CHG;
}
static int lp8727_init_device(struct lp8727_chg *pchg)
{
u8 val;
int ret;
u8 intstat[LP8788_NUM_INTREGS];
/* clear interrupts */
ret = lp8727_read_bytes(pchg, LP8727_INT1, intstat, LP8788_NUM_INTREGS);
if (ret)
return ret;
val = LP8727_ID200_EN | LP8727_ADC_EN | LP8727_CP_EN;
ret = lp8727_write_byte(pchg, LP8727_CTRL1, val);
if (ret)
return ret;
val = LP8727_INT_EN | LP8727_CHGDET_EN;
return lp8727_write_byte(pchg, LP8727_CTRL2, val);
}
static int lp8727_is_dedicated_charger(struct lp8727_chg *pchg)
{
u8 val;
lp8727_read_byte(pchg, LP8727_STATUS1, &val);
return val & LP8727_DCPORT;
}
static int lp8727_is_usb_charger(struct lp8727_chg *pchg)
{
u8 val;
lp8727_read_byte(pchg, LP8727_STATUS1, &val);
return val & LP8727_CHPORT;
}
static inline void lp8727_ctrl_switch(struct lp8727_chg *pchg, u8 sw)
{
lp8727_write_byte(pchg, LP8727_SWCTRL, sw);
}
static void lp8727_id_detection(struct lp8727_chg *pchg, u8 id, int vbusin)
{
struct lp8727_platform_data *pdata = pchg->pdata;
u8 devid = LP8727_ID_NONE;
u8 swctrl = LP8727_SW_DM1_HiZ | LP8727_SW_DP2_HiZ;
switch (id) {
case 0x5:
devid = LP8727_ID_TA;
pchg->chg_param = pdata ? pdata->ac : NULL;
break;
case 0xB:
if (lp8727_is_dedicated_charger(pchg)) {
pchg->chg_param = pdata ? pdata->ac : NULL;
devid = LP8727_ID_DEDICATED_CHG;
} else if (lp8727_is_usb_charger(pchg)) {
pchg->chg_param = pdata ? pdata->usb : NULL;
devid = LP8727_ID_USB_CHG;
swctrl = LP8727_SW_DM1_DM | LP8727_SW_DP2_DP;
} else if (vbusin) {
devid = LP8727_ID_USB_DS;
swctrl = LP8727_SW_DM1_DM | LP8727_SW_DP2_DP;
}
break;
default:
devid = LP8727_ID_NONE;
pchg->chg_param = NULL;
break;
}
pchg->devid = devid;
lp8727_ctrl_switch(pchg, swctrl);
}
static void lp8727_enable_chgdet(struct lp8727_chg *pchg)
{
u8 val;
lp8727_read_byte(pchg, LP8727_CTRL2, &val);
val |= LP8727_CHGDET_EN;
lp8727_write_byte(pchg, LP8727_CTRL2, val);
}
static void lp8727_delayed_func(struct work_struct *_work)
{
struct lp8727_chg *pchg = container_of(_work, struct lp8727_chg,
work.work);
u8 intstat[LP8788_NUM_INTREGS];
u8 idno;
u8 vbus;
if (lp8727_read_bytes(pchg, LP8727_INT1, intstat, LP8788_NUM_INTREGS)) {
dev_err(pchg->dev, "can not read INT registers\n");
return;
}
idno = intstat[0] & LP8727_IDNO;
vbus = intstat[0] & LP8727_VBUS;
lp8727_id_detection(pchg, idno, vbus);
lp8727_enable_chgdet(pchg);
power_supply_changed(pchg->psy->ac);
power_supply_changed(pchg->psy->usb);
power_supply_changed(pchg->psy->batt);
}
static irqreturn_t lp8727_isr_func(int irq, void *ptr)
{
struct lp8727_chg *pchg = ptr;
schedule_delayed_work(&pchg->work, pchg->debounce_jiffies);
return IRQ_HANDLED;
}
static int lp8727_setup_irq(struct lp8727_chg *pchg)
{
int ret;
int irq = pchg->client->irq;
unsigned delay_msec = pchg->pdata ? pchg->pdata->debounce_msec :
DEFAULT_DEBOUNCE_MSEC;
INIT_DELAYED_WORK(&pchg->work, lp8727_delayed_func);
if (irq <= 0) {
dev_warn(pchg->dev, "invalid irq number: %d\n", irq);
return 0;
}
ret = request_threaded_irq(irq, NULL, lp8727_isr_func,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
"lp8727_irq", pchg);
if (ret)
return ret;
pchg->irq = irq;
pchg->debounce_jiffies = msecs_to_jiffies(delay_msec);
return 0;
}
static void lp8727_release_irq(struct lp8727_chg *pchg)
{
cancel_delayed_work_sync(&pchg->work);
if (pchg->irq)
free_irq(pchg->irq, pchg);
}
static enum power_supply_property lp8727_charger_prop[] = {
POWER_SUPPLY_PROP_ONLINE,
};
static enum power_supply_property lp8727_battery_prop[] = {
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_HEALTH,
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_VOLTAGE_NOW,
POWER_SUPPLY_PROP_CAPACITY,
POWER_SUPPLY_PROP_TEMP,
};
static char *battery_supplied_to[] = {
"main_batt",
};
static int lp8727_charger_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct lp8727_chg *pchg = dev_get_drvdata(psy->dev.parent);
if (psp != POWER_SUPPLY_PROP_ONLINE)
return -EINVAL;
val->intval = lp8727_is_charger_attached(psy->desc->name, pchg->devid);
return 0;
}
static bool lp8727_is_high_temperature(enum lp8727_die_temp temp)
{
switch (temp) {
case LP8788_TEMP_95C:
case LP8788_TEMP_115C:
case LP8788_TEMP_135C:
return true;
default:
return false;
}
}
static int lp8727_battery_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct lp8727_chg *pchg = dev_get_drvdata(psy->dev.parent);
struct lp8727_platform_data *pdata = pchg->pdata;
enum lp8727_die_temp temp;
u8 read;
switch (psp) {
case POWER_SUPPLY_PROP_STATUS:
if (!lp8727_is_charger_attached(psy->desc->name, pchg->devid)) {
val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
return 0;
}
lp8727_read_byte(pchg, LP8727_STATUS1, &read);
val->intval = (read & LP8727_CHGSTAT) == LP8727_STAT_EOC ?
POWER_SUPPLY_STATUS_FULL :
POWER_SUPPLY_STATUS_CHARGING;
break;
case POWER_SUPPLY_PROP_HEALTH:
lp8727_read_byte(pchg, LP8727_STATUS2, &read);
temp = (read & LP8727_TEMP_STAT) >> LP8727_TEMP_SHIFT;
val->intval = lp8727_is_high_temperature(temp) ?
POWER_SUPPLY_HEALTH_OVERHEAT :
POWER_SUPPLY_HEALTH_GOOD;
break;
case POWER_SUPPLY_PROP_PRESENT:
if (!pdata)
return -EINVAL;
if (pdata->get_batt_present)
val->intval = pdata->get_batt_present();
break;
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
if (!pdata)
return -EINVAL;
if (pdata->get_batt_level)
val->intval = pdata->get_batt_level();
break;
case POWER_SUPPLY_PROP_CAPACITY:
if (!pdata)
return -EINVAL;
if (pdata->get_batt_capacity)
val->intval = pdata->get_batt_capacity();
break;
case POWER_SUPPLY_PROP_TEMP:
if (!pdata)
return -EINVAL;
if (pdata->get_batt_temp)
val->intval = pdata->get_batt_temp();
break;
default:
break;
}
return 0;
}
static void lp8727_charger_changed(struct power_supply *psy)
{
struct lp8727_chg *pchg = dev_get_drvdata(psy->dev.parent);
u8 eoc_level;
u8 ichg;
u8 val;
/* skip if no charger exists */
if (!lp8727_is_charger_attached(psy->desc->name, pchg->devid))
return;
/* update charging parameters */
if (pchg->chg_param) {
eoc_level = pchg->chg_param->eoc_level;
ichg = pchg->chg_param->ichg;
val = (ichg << LP8727_ICHG_SHIFT) | eoc_level;
lp8727_write_byte(pchg, LP8727_CHGCTRL2, val);
}
}
static const struct power_supply_desc lp8727_ac_desc = {
.name = "ac",
.type = POWER_SUPPLY_TYPE_MAINS,
.properties = lp8727_charger_prop,
.num_properties = ARRAY_SIZE(lp8727_charger_prop),
.get_property = lp8727_charger_get_property,
};
static const struct power_supply_desc lp8727_usb_desc = {
.name = "usb",
.type = POWER_SUPPLY_TYPE_USB,
.properties = lp8727_charger_prop,
.num_properties = ARRAY_SIZE(lp8727_charger_prop),
.get_property = lp8727_charger_get_property,
};
static const struct power_supply_desc lp8727_batt_desc = {
.name = "main_batt",
.type = POWER_SUPPLY_TYPE_BATTERY,
.properties = lp8727_battery_prop,
.num_properties = ARRAY_SIZE(lp8727_battery_prop),
.get_property = lp8727_battery_get_property,
.external_power_changed = lp8727_charger_changed,
};
static int lp8727_register_psy(struct lp8727_chg *pchg)
{
struct power_supply_config psy_cfg = {}; /* Only for ac and usb */
struct lp8727_psy *psy;
psy = devm_kzalloc(pchg->dev, sizeof(*psy), GFP_KERNEL);
if (!psy)
return -ENOMEM;
pchg->psy = psy;
psy_cfg.supplied_to = battery_supplied_to;
psy_cfg.num_supplicants = ARRAY_SIZE(battery_supplied_to);
psy->ac = power_supply_register(pchg->dev, &lp8727_ac_desc, &psy_cfg);
if (IS_ERR(psy->ac))
goto err_psy_ac;
psy->usb = power_supply_register(pchg->dev, &lp8727_usb_desc,
&psy_cfg);
if (IS_ERR(psy->usb))
goto err_psy_usb;
psy->batt = power_supply_register(pchg->dev, &lp8727_batt_desc, NULL);
if (IS_ERR(psy->batt))
goto err_psy_batt;
return 0;
err_psy_batt:
power_supply_unregister(psy->usb);
err_psy_usb:
power_supply_unregister(psy->ac);
err_psy_ac:
return -EPERM;
}
static void lp8727_unregister_psy(struct lp8727_chg *pchg)
{
struct lp8727_psy *psy = pchg->psy;
if (!psy)
return;
power_supply_unregister(psy->ac);
power_supply_unregister(psy->usb);
power_supply_unregister(psy->batt);
}
#ifdef CONFIG_OF
static struct lp8727_chg_param
*lp8727_parse_charge_pdata(struct device *dev, struct device_node *np)
{
struct lp8727_chg_param *param;
param = devm_kzalloc(dev, sizeof(*param), GFP_KERNEL);
if (!param)
goto out;
of_property_read_u8(np, "eoc-level", (u8 *)&param->eoc_level);
of_property_read_u8(np, "charging-current", (u8 *)&param->ichg);
out:
return param;
}
static int lp8727_parse_dt(struct device *dev)
{
struct device_node *np = dev->of_node;
struct device_node *child;
struct lp8727_platform_data *pdata;
const char *type;
/* If charging parameter is not defined, just skip parsing the dt */
if (of_get_child_count(np) == 0)
goto out;
pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return -ENOMEM;
of_property_read_u32(np, "debounce-ms", &pdata->debounce_msec);
for_each_child_of_node(np, child) {
of_property_read_string(child, "charger-type", &type);
if (!strcmp(type, "ac"))
pdata->ac = lp8727_parse_charge_pdata(dev, child);
if (!strcmp(type, "usb"))
pdata->usb = lp8727_parse_charge_pdata(dev, child);
}
dev->platform_data = pdata;
out:
return 0;
}
#else
static int lp8727_parse_dt(struct device *dev)
{
return 0;
}
#endif
static int lp8727_probe(struct i2c_client *cl, const struct i2c_device_id *id)
{
struct lp8727_chg *pchg;
int ret;
if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
return -EIO;
if (cl->dev.of_node) {
ret = lp8727_parse_dt(&cl->dev);
if (ret)
return ret;
}
pchg = devm_kzalloc(&cl->dev, sizeof(*pchg), GFP_KERNEL);
if (!pchg)
return -ENOMEM;
pchg->client = cl;
pchg->dev = &cl->dev;
pchg->pdata = cl->dev.platform_data;
i2c_set_clientdata(cl, pchg);
mutex_init(&pchg->xfer_lock);
ret = lp8727_init_device(pchg);
if (ret) {
dev_err(pchg->dev, "i2c communication err: %d", ret);
return ret;
}
ret = lp8727_register_psy(pchg);
if (ret) {
dev_err(pchg->dev, "power supplies register err: %d", ret);
return ret;
}
ret = lp8727_setup_irq(pchg);
if (ret) {
dev_err(pchg->dev, "irq handler err: %d", ret);
lp8727_unregister_psy(pchg);
return ret;
}
return 0;
}
static int lp8727_remove(struct i2c_client *cl)
{
struct lp8727_chg *pchg = i2c_get_clientdata(cl);
lp8727_release_irq(pchg);
lp8727_unregister_psy(pchg);
return 0;
}
static const struct of_device_id lp8727_dt_ids[] = {
{ .compatible = "ti,lp8727", },
{ }
};
MODULE_DEVICE_TABLE(of, lp8727_dt_ids);
static const struct i2c_device_id lp8727_ids[] = {
{"lp8727", 0},
{ }
};
MODULE_DEVICE_TABLE(i2c, lp8727_ids);
static struct i2c_driver lp8727_driver = {
.driver = {
.name = "lp8727",
.of_match_table = of_match_ptr(lp8727_dt_ids),
},
.probe = lp8727_probe,
.remove = lp8727_remove,
.id_table = lp8727_ids,
};
module_i2c_driver(lp8727_driver);
MODULE_DESCRIPTION("TI/National Semiconductor LP8727 charger driver");
MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>, Daniel Jeong <daniel.jeong@ti.com>");
MODULE_LICENSE("GPL");