[linux-2.6-block.git] / drivers / power / max8925_power.c

/*
 * Battery driver for Maxim MAX8925
 *
 * Copyright (c) 2009-2010 Marvell International Ltd.
 *	Haojian Zhuang <haojian.zhuang@marvell.com>
 *
 * 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/err.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/i2c.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/mfd/max8925.h>

/* registers in GPM */
#define MAX8925_OUT5VEN			0x54
#define MAX8925_OUT3VEN			0x58
#define MAX8925_CHG_CNTL1		0x7c

/* bits definition */
#define MAX8925_CHG_STAT_VSYSLOW	(1 << 0)
#define MAX8925_CHG_STAT_MODE_MASK	(3 << 2)
#define MAX8925_CHG_STAT_EN_MASK	(1 << 4)
#define MAX8925_CHG_MBDET		(1 << 1)
#define MAX8925_CHG_AC_RANGE_MASK	(3 << 6)

/* registers in ADC */
#define MAX8925_ADC_RES_CNFG1		0x06
#define MAX8925_ADC_AVG_CNFG1		0x07
#define MAX8925_ADC_ACQ_CNFG1		0x08
#define MAX8925_ADC_ACQ_CNFG2		0x09
/* 2 bytes registers in below. MSB is 1st, LSB is 2nd. */
#define MAX8925_ADC_AUX2		0x62
#define MAX8925_ADC_VCHG		0x64
#define MAX8925_ADC_VBBATT		0x66
#define MAX8925_ADC_VMBATT		0x68
#define MAX8925_ADC_ISNS		0x6a
#define MAX8925_ADC_THM			0x6c
#define MAX8925_ADC_TDIE		0x6e
#define MAX8925_CMD_AUX2		0xc8
#define MAX8925_CMD_VCHG		0xd0
#define MAX8925_CMD_VBBATT		0xd8
#define MAX8925_CMD_VMBATT		0xe0
#define MAX8925_CMD_ISNS		0xe8
#define MAX8925_CMD_THM			0xf0
#define MAX8925_CMD_TDIE		0xf8

enum {
	MEASURE_AUX2,
	MEASURE_VCHG,
	MEASURE_VBBATT,
	MEASURE_VMBATT,
	MEASURE_ISNS,
	MEASURE_THM,
	MEASURE_TDIE,
	MEASURE_MAX,
};

struct max8925_power_info {
	struct max8925_chip	*chip;
	struct i2c_client	*gpm;
	struct i2c_client	*adc;

	struct power_supply	*ac;
	struct power_supply	*usb;
	struct power_supply	*battery;
	int			irq_base;
	unsigned		ac_online:1;
	unsigned		usb_online:1;
	unsigned		bat_online:1;
	unsigned		chg_mode:2;
	unsigned		batt_detect:1;	/* detecing MB by ID pin */
	unsigned		topoff_threshold:2;
	unsigned		fast_charge:3;
	unsigned		no_temp_support:1;
	unsigned		no_insert_detect:1;

	int (*set_charger) (int);
};

static int __set_charger(struct max8925_power_info *info, int enable)
{
	struct max8925_chip *chip = info->chip;
	if (enable) {
		/* enable charger in platform */
		if (info->set_charger)
			info->set_charger(1);
		/* enable charger */
		max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 0);
	} else {
		/* disable charge */
		max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
		if (info->set_charger)
			info->set_charger(0);
	}
	dev_dbg(chip->dev, "%s\n", (enable) ? "Enable charger"
		: "Disable charger");
	return 0;
}

static irqreturn_t max8925_charger_handler(int irq, void *data)
{
	struct max8925_power_info *info = (struct max8925_power_info *)data;
	struct max8925_chip *chip = info->chip;

	switch (irq - chip->irq_base) {
	case MAX8925_IRQ_VCHG_DC_R:
		info->ac_online = 1;
		__set_charger(info, 1);
		dev_dbg(chip->dev, "Adapter inserted\n");
		break;
	case MAX8925_IRQ_VCHG_DC_F:
		info->ac_online = 0;
		__set_charger(info, 0);
		dev_dbg(chip->dev, "Adapter removed\n");
		break;
	case MAX8925_IRQ_VCHG_THM_OK_F:
		/* Battery is not ready yet */
		dev_dbg(chip->dev, "Battery temperature is out of range\n");
	case MAX8925_IRQ_VCHG_DC_OVP:
		dev_dbg(chip->dev, "Error detection\n");
		__set_charger(info, 0);
		break;
	case MAX8925_IRQ_VCHG_THM_OK_R:
		/* Battery is ready now */
		dev_dbg(chip->dev, "Battery temperature is in range\n");
		break;
	case MAX8925_IRQ_VCHG_SYSLOW_R:
		/* VSYS is low */
		dev_info(chip->dev, "Sys power is too low\n");
		break;
	case MAX8925_IRQ_VCHG_SYSLOW_F:
		dev_dbg(chip->dev, "Sys power is above low threshold\n");
		break;
	case MAX8925_IRQ_VCHG_DONE:
		__set_charger(info, 0);
		dev_dbg(chip->dev, "Charging is done\n");
		break;
	case MAX8925_IRQ_VCHG_TOPOFF:
		dev_dbg(chip->dev, "Charging in top-off mode\n");
		break;
	case MAX8925_IRQ_VCHG_TMR_FAULT:
		__set_charger(info, 0);
		dev_dbg(chip->dev, "Safe timer is expired\n");
		break;
	case MAX8925_IRQ_VCHG_RST:
		__set_charger(info, 0);
		dev_dbg(chip->dev, "Charger is reset\n");
		break;
	}
	return IRQ_HANDLED;
}

static int start_measure(struct max8925_power_info *info, int type)
{
	unsigned char buf[2] = {0, 0};
	int meas_cmd;
	int meas_reg = 0, ret;

	switch (type) {
	case MEASURE_VCHG:
		meas_cmd = MAX8925_CMD_VCHG;
		meas_reg = MAX8925_ADC_VCHG;
		break;
	case MEASURE_VBBATT:
		meas_cmd = MAX8925_CMD_VBBATT;
		meas_reg = MAX8925_ADC_VBBATT;
		break;
	case MEASURE_VMBATT:
		meas_cmd = MAX8925_CMD_VMBATT;
		meas_reg = MAX8925_ADC_VMBATT;
		break;
	case MEASURE_ISNS:
		meas_cmd = MAX8925_CMD_ISNS;
		meas_reg = MAX8925_ADC_ISNS;
		break;
	default:
		return -EINVAL;
	}

	max8925_reg_write(info->adc, meas_cmd, 0);
	max8925_bulk_read(info->adc, meas_reg, 2, buf);
	ret = ((buf[0]<<8) | buf[1]) >> 4;

	return ret;
}

static int max8925_ac_get_prop(struct power_supply *psy,
			       enum power_supply_property psp,
			       union power_supply_propval *val)
{
	struct max8925_power_info *info = dev_get_drvdata(psy->dev.parent);
	int ret = 0;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = info->ac_online;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		if (info->ac_online) {
			ret = start_measure(info, MEASURE_VCHG);
			if (ret >= 0) {
				val->intval = ret * 2000;	/* unit is uV */
				goto out;
			}
		}
		ret = -ENODATA;
		break;
	default:
		ret = -ENODEV;
		break;
	}
out:
	return ret;
}

static enum power_supply_property max8925_ac_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
};

static int max8925_usb_get_prop(struct power_supply *psy,
				enum power_supply_property psp,
				union power_supply_propval *val)
{
	struct max8925_power_info *info = dev_get_drvdata(psy->dev.parent);
	int ret = 0;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = info->usb_online;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		if (info->usb_online) {
			ret = start_measure(info, MEASURE_VCHG);
			if (ret >= 0) {
				val->intval = ret * 2000;	/* unit is uV */
				goto out;
			}
		}
		ret = -ENODATA;
		break;
	default:
		ret = -ENODEV;
		break;
	}
out:
	return ret;
}

static enum power_supply_property max8925_usb_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
};

static int max8925_bat_get_prop(struct power_supply *psy,
				enum power_supply_property psp,
				union power_supply_propval *val)
{
	struct max8925_power_info *info = dev_get_drvdata(psy->dev.parent);
	int ret = 0;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = info->bat_online;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		if (info->bat_online) {
			ret = start_measure(info, MEASURE_VMBATT);
			if (ret >= 0) {
				val->intval = ret * 2000;	/* unit is uV */
				ret = 0;
				break;
			}
		}
		ret = -ENODATA;
		break;
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		if (info->bat_online) {
			ret = start_measure(info, MEASURE_ISNS);
			if (ret >= 0) {
				/* assume r_sns is 0.02 */
				ret = ((ret * 6250) - 3125) /* uA */;
				val->intval = 0;
				if (ret > 0)
					val->intval = ret; /* unit is mA */
				ret = 0;
				break;
			}
		}
		ret = -ENODATA;
		break;
	case POWER_SUPPLY_PROP_CHARGE_TYPE:
		if (!info->bat_online) {
			ret = -ENODATA;
			break;
		}
		ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
		ret = (ret & MAX8925_CHG_STAT_MODE_MASK) >> 2;
		switch (ret) {
		case 1:
			val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
			break;
		case 0:
		case 2:
			val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
			break;
		case 3:
			val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
			break;
		}
		ret = 0;
		break;
	case POWER_SUPPLY_PROP_STATUS:
		if (!info->bat_online) {
			ret = -ENODATA;
			break;
		}
		ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
		if (info->usb_online || info->ac_online) {
			val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
			if (ret & MAX8925_CHG_STAT_EN_MASK)
				val->intval = POWER_SUPPLY_STATUS_CHARGING;
		} else
			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
		ret = 0;
		break;
	default:
		ret = -ENODEV;
		break;
	}
	return ret;
}

static enum power_supply_property max8925_battery_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_CHARGE_TYPE,
	POWER_SUPPLY_PROP_STATUS,
};

static const struct power_supply_desc ac_desc = {
	.name		= "max8925-ac",
	.type		= POWER_SUPPLY_TYPE_MAINS,
	.properties	= max8925_ac_props,
	.num_properties	= ARRAY_SIZE(max8925_ac_props),
	.get_property	= max8925_ac_get_prop,
};

static const struct power_supply_desc usb_desc = {
	.name		= "max8925-usb",
	.type		= POWER_SUPPLY_TYPE_USB,
	.properties	= max8925_usb_props,
	.num_properties	= ARRAY_SIZE(max8925_usb_props),
	.get_property	= max8925_usb_get_prop,
};

static const struct power_supply_desc battery_desc = {
	.name		= "max8925-battery",
	.type		= POWER_SUPPLY_TYPE_BATTERY,
	.properties	= max8925_battery_props,
	.num_properties	= ARRAY_SIZE(max8925_battery_props),
	.get_property	= max8925_bat_get_prop,
};

#define REQUEST_IRQ(_irq, _name)					\
do {									\
	ret = request_threaded_irq(chip->irq_base + _irq, NULL,		\
				    max8925_charger_handler,		\
				    IRQF_ONESHOT, _name, info);		\
	if (ret)							\
		dev_err(chip->dev, "Failed to request IRQ #%d: %d\n",	\
			_irq, ret);					\
} while (0)

static int max8925_init_charger(struct max8925_chip *chip,
					  struct max8925_power_info *info)
{
	int ret;

	REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_OVP, "ac-ovp");
	if (!info->no_insert_detect) {
		REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_F, "ac-remove");
		REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_R, "ac-insert");
	}
	if (!info->no_temp_support) {
		REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_R, "batt-temp-in-range");
		REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_F, "batt-temp-out-range");
	}
	REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_F, "vsys-high");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_R, "vsys-low");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_RST, "charger-reset");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_DONE, "charger-done");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_TOPOFF, "charger-topoff");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_TMR_FAULT, "charger-timer-expire");

	info->usb_online = 0;
	info->bat_online = 0;

	/* check for power - can miss interrupt at boot time */
	if (start_measure(info, MEASURE_VCHG) * 2000 > 500000)
		info->ac_online = 1;
	else
		info->ac_online = 0;

	ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
	if (ret >= 0) {
		/*
		 * If battery detection is enabled, ID pin of battery is
		 * connected to MBDET pin of MAX8925. It could be used to
		 * detect battery presence.
		 * Otherwise, we have to assume that battery is always on.
		 */
		if (info->batt_detect)
			info->bat_online = (ret & MAX8925_CHG_MBDET) ? 0 : 1;
		else
			info->bat_online = 1;
		if (ret & MAX8925_CHG_AC_RANGE_MASK)
			info->ac_online = 1;
		else
			info->ac_online = 0;
	}
	/* disable charge */
	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
	/* set charging current in charge topoff mode */
	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 3 << 5,
			 info->topoff_threshold << 5);
	/* set charing current in fast charge mode */
	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 7, info->fast_charge);

	return 0;
}

static int max8925_deinit_charger(struct max8925_power_info *info)
{
	struct max8925_chip *chip = info->chip;
	int irq;

	irq = chip->irq_base + MAX8925_IRQ_VCHG_DC_OVP;
	for (; irq <= chip->irq_base + MAX8925_IRQ_VCHG_TMR_FAULT; irq++)
		free_irq(irq, info);

	return 0;
}

#ifdef CONFIG_OF
static struct max8925_power_pdata *
max8925_power_dt_init(struct platform_device *pdev)
{
	struct device_node *nproot = pdev->dev.parent->of_node;
	struct device_node *np;
	int batt_detect;
	int topoff_threshold;
	int fast_charge;
	int no_temp_support;
	int no_insert_detect;
	struct max8925_power_pdata *pdata;

	if (!nproot)
		return pdev->dev.platform_data;

	np = of_get_child_by_name(nproot, "charger");
	if (!np) {
		dev_err(&pdev->dev, "failed to find charger node\n");
		return NULL;
	}

	pdata = devm_kzalloc(&pdev->dev,
			sizeof(struct max8925_power_pdata),
			GFP_KERNEL);
	if (!pdata)
		goto ret;

	of_property_read_u32(np, "topoff-threshold", &topoff_threshold);
	of_property_read_u32(np, "batt-detect", &batt_detect);
	of_property_read_u32(np, "fast-charge", &fast_charge);
	of_property_read_u32(np, "no-insert-detect", &no_insert_detect);
	of_property_read_u32(np, "no-temp-support", &no_temp_support);

	pdata->batt_detect = batt_detect;
	pdata->fast_charge = fast_charge;
	pdata->topoff_threshold = topoff_threshold;
	pdata->no_insert_detect = no_insert_detect;
	pdata->no_temp_support = no_temp_support;

ret:
	of_node_put(np);
	return pdata;
}
#else
static struct max8925_power_pdata *
max8925_power_dt_init(struct platform_device *pdev)
{
	return pdev->dev.platform_data;
}
#endif

static int max8925_power_probe(struct platform_device *pdev)
{
	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
	struct power_supply_config psy_cfg = {}; /* Only for ac and usb */
	struct max8925_power_pdata *pdata = NULL;
	struct max8925_power_info *info;
	int ret;

	pdata = max8925_power_dt_init(pdev);
	if (!pdata) {
		dev_err(&pdev->dev, "platform data isn't assigned to "
			"power supply\n");
		return -EINVAL;
	}

	info = devm_kzalloc(&pdev->dev, sizeof(struct max8925_power_info),
				GFP_KERNEL);
	if (!info)
		return -ENOMEM;
	info->chip = chip;
	info->gpm = chip->i2c;
	info->adc = chip->adc;
	platform_set_drvdata(pdev, info);

	psy_cfg.supplied_to = pdata->supplied_to;
	psy_cfg.num_supplicants = pdata->num_supplicants;

	info->ac = power_supply_register(&pdev->dev, &ac_desc, &psy_cfg);
	if (IS_ERR(info->ac)) {
		ret = PTR_ERR(info->ac);
		goto out;
	}
	info->ac->dev.parent = &pdev->dev;

	info->usb = power_supply_register(&pdev->dev, &usb_desc, &psy_cfg);
	if (IS_ERR(info->usb)) {
		ret = PTR_ERR(info->usb);
		goto out_usb;
	}
	info->usb->dev.parent = &pdev->dev;

	info->battery = power_supply_register(&pdev->dev, &battery_desc, NULL);
	if (IS_ERR(info->battery)) {
		ret = PTR_ERR(info->battery);
		goto out_battery;
	}
	info->battery->dev.parent = &pdev->dev;

	info->batt_detect = pdata->batt_detect;
	info->topoff_threshold = pdata->topoff_threshold;
	info->fast_charge = pdata->fast_charge;
	info->set_charger = pdata->set_charger;
	info->no_temp_support = pdata->no_temp_support;
	info->no_insert_detect = pdata->no_insert_detect;

	max8925_init_charger(chip, info);
	return 0;
out_battery:
	power_supply_unregister(info->battery);
out_usb:
	power_supply_unregister(info->ac);
out:
	return ret;
}

static int max8925_power_remove(struct platform_device *pdev)
{
	struct max8925_power_info *info = platform_get_drvdata(pdev);

	if (info) {
		power_supply_unregister(info->ac);
		power_supply_unregister(info->usb);
		power_supply_unregister(info->battery);
		max8925_deinit_charger(info);
	}
	return 0;
}

static struct platform_driver max8925_power_driver = {
	.probe	= max8925_power_probe,
	.remove	= max8925_power_remove,
	.driver	= {
		.name	= "max8925-power",
	},
};

module_platform_driver(max8925_power_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Power supply driver for MAX8925");
MODULE_ALIAS("platform:max8925-power");
Commit	Line	Data
28db3888 HZ	1	/*
	2	* Battery driver for Maxim MAX8925
	3	*
	4	* Copyright (c) 2009-2010 Marvell International Ltd.
	5	* Haojian Zhuang <haojian.zhuang@marvell.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/err.h>
5a0e3ad6	14	#include <linux/slab.h>
eba3b670	15	#include <linux/of.h>
28db3888 HZ	16	#include <linux/i2c.h>
	17	#include <linux/interrupt.h>
	18	#include <linux/platform_device.h>
	19	#include <linux/power_supply.h>
	20	#include <linux/mfd/max8925.h>
	21
	22	/* registers in GPM */
	23	#define MAX8925_OUT5VEN 0x54
	24	#define MAX8925_OUT3VEN 0x58
	25	#define MAX8925_CHG_CNTL1 0x7c
	26
	27	/* bits definition */
	28	#define MAX8925_CHG_STAT_VSYSLOW (1 << 0)
	29	#define MAX8925_CHG_STAT_MODE_MASK (3 << 2)
	30	#define MAX8925_CHG_STAT_EN_MASK (1 << 4)
	31	#define MAX8925_CHG_MBDET (1 << 1)
	32	#define MAX8925_CHG_AC_RANGE_MASK (3 << 6)
	33
	34	/* registers in ADC */
	35	#define MAX8925_ADC_RES_CNFG1 0x06
	36	#define MAX8925_ADC_AVG_CNFG1 0x07
	37	#define MAX8925_ADC_ACQ_CNFG1 0x08
	38	#define MAX8925_ADC_ACQ_CNFG2 0x09
	39	/* 2 bytes registers in below. MSB is 1st, LSB is 2nd. */
	40	#define MAX8925_ADC_AUX2 0x62
	41	#define MAX8925_ADC_VCHG 0x64
	42	#define MAX8925_ADC_VBBATT 0x66
	43	#define MAX8925_ADC_VMBATT 0x68
	44	#define MAX8925_ADC_ISNS 0x6a
	45	#define MAX8925_ADC_THM 0x6c
	46	#define MAX8925_ADC_TDIE 0x6e
	47	#define MAX8925_CMD_AUX2 0xc8
	48	#define MAX8925_CMD_VCHG 0xd0
	49	#define MAX8925_CMD_VBBATT 0xd8
	50	#define MAX8925_CMD_VMBATT 0xe0
	51	#define MAX8925_CMD_ISNS 0xe8
	52	#define MAX8925_CMD_THM 0xf0
	53	#define MAX8925_CMD_TDIE 0xf8
	54
	55	enum {
	56	MEASURE_AUX2,
	57	MEASURE_VCHG,
	58	MEASURE_VBBATT,
	59	MEASURE_VMBATT,
	60	MEASURE_ISNS,
	61	MEASURE_THM,
	62	MEASURE_TDIE,
	63	MEASURE_MAX,
	64	};
	65
	66	struct max8925_power_info {
	67	struct max8925_chip *chip;
	68	struct i2c_client *gpm;
	69	struct i2c_client *adc;
	70
297d716f KK	71	struct power_supply *ac;
	72	struct power_supply *usb;
	73	struct power_supply *battery;
28db3888 HZ	74	int irq_base;
	75	unsigned ac_online:1;
	76	unsigned usb_online:1;
	77	unsigned bat_online:1;
	78	unsigned chg_mode:2;
	79	unsigned batt_detect:1; /* detecing MB by ID pin */
	80	unsigned topoff_threshold:2;
	81	unsigned fast_charge:3;
92de378b	82	unsigned no_temp_support:1;
5ba1fa0a	83	unsigned no_insert_detect:1;
28db3888 HZ	84
	85	int (*set_charger) (int);
	86	};
	87
	88	static int __set_charger(struct max8925_power_info *info, int enable)
	89	{
	90	struct max8925_chip *chip = info->chip;
	91	if (enable) {
	92	/* enable charger in platform */
	93	if (info->set_charger)
	94	info->set_charger(1);
	95	/* enable charger */
	96	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 0);
	97	} else {
	98	/* disable charge */
	99	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
	100	if (info->set_charger)
	101	info->set_charger(0);
	102	}
	103	dev_dbg(chip->dev, "%s\n", (enable) ? "Enable charger"
	104	: "Disable charger");
	105	return 0;
	106	}
	107
	108	static irqreturn_t max8925_charger_handler(int irq, void *data)
	109	{
	110	struct max8925_power_info info = (struct max8925_power_info )data;
	111	struct max8925_chip *chip = info->chip;
	112
	113	switch (irq - chip->irq_base) {
	114	case MAX8925_IRQ_VCHG_DC_R:
	115	info->ac_online = 1;
	116	__set_charger(info, 1);
	117	dev_dbg(chip->dev, "Adapter inserted\n");
	118	break;
	119	case MAX8925_IRQ_VCHG_DC_F:
	120	info->ac_online = 0;
	121	__set_charger(info, 0);
92de378b	122	dev_dbg(chip->dev, "Adapter removed\n");
28db3888	123	break;
28db3888 HZ	124	case MAX8925_IRQ_VCHG_THM_OK_F:
	125	/* Battery is not ready yet */
	126	dev_dbg(chip->dev, "Battery temperature is out of range\n");
	127	case MAX8925_IRQ_VCHG_DC_OVP:
	128	dev_dbg(chip->dev, "Error detection\n");
	129	__set_charger(info, 0);
	130	break;
	131	case MAX8925_IRQ_VCHG_THM_OK_R:
	132	/* Battery is ready now */
	133	dev_dbg(chip->dev, "Battery temperature is in range\n");
	134	break;
	135	case MAX8925_IRQ_VCHG_SYSLOW_R:
	136	/* VSYS is low */
	137	dev_info(chip->dev, "Sys power is too low\n");
	138	break;
	139	case MAX8925_IRQ_VCHG_SYSLOW_F:
	140	dev_dbg(chip->dev, "Sys power is above low threshold\n");
	141	break;
	142	case MAX8925_IRQ_VCHG_DONE:
	143	__set_charger(info, 0);
	144	dev_dbg(chip->dev, "Charging is done\n");
	145	break;
	146	case MAX8925_IRQ_VCHG_TOPOFF:
	147	dev_dbg(chip->dev, "Charging in top-off mode\n");
	148	break;
	149	case MAX8925_IRQ_VCHG_TMR_FAULT:
	150	__set_charger(info, 0);
	151	dev_dbg(chip->dev, "Safe timer is expired\n");
	152	break;
	153	case MAX8925_IRQ_VCHG_RST:
	154	__set_charger(info, 0);
	155	dev_dbg(chip->dev, "Charger is reset\n");
	156	break;
	157	}
	158	return IRQ_HANDLED;
	159	}
	160
	161	static int start_measure(struct max8925_power_info *info, int type)
	162	{
	163	unsigned char buf[2] = {0, 0};
b57f2f61	164	int meas_cmd;
28db3888 HZ	165	int meas_reg = 0, ret;
	166
	167	switch (type) {
	168	case MEASURE_VCHG:
b57f2f61	169	meas_cmd = MAX8925_CMD_VCHG;
28db3888 HZ	170	meas_reg = MAX8925_ADC_VCHG;
	171	break;
	172	case MEASURE_VBBATT:
b57f2f61	173	meas_cmd = MAX8925_CMD_VBBATT;
28db3888 HZ	174	meas_reg = MAX8925_ADC_VBBATT;
	175	break;
	176	case MEASURE_VMBATT:
b57f2f61	177	meas_cmd = MAX8925_CMD_VMBATT;
28db3888 HZ	178	meas_reg = MAX8925_ADC_VMBATT;
	179	break;
	180	case MEASURE_ISNS:
b57f2f61	181	meas_cmd = MAX8925_CMD_ISNS;
28db3888 HZ	182	meas_reg = MAX8925_ADC_ISNS;
	183	break;
	184	default:
	185	return -EINVAL;
	186	}
	187
b57f2f61	188	max8925_reg_write(info->adc, meas_cmd, 0);
28db3888	189	max8925_bulk_read(info->adc, meas_reg, 2, buf);
9c9cf9e2	190	ret = ((buf[0]<<8) \| buf[1]) >> 4;
28db3888 HZ	191
	192	return ret;
	193	}
	194
	195	static int max8925_ac_get_prop(struct power_supply *psy,
	196	enum power_supply_property psp,
	197	union power_supply_propval *val)
	198	{
297d716f	199	struct max8925_power_info *info = dev_get_drvdata(psy->dev.parent);
28db3888 HZ	200	int ret = 0;
	201
	202	switch (psp) {
	203	case POWER_SUPPLY_PROP_ONLINE:
	204	val->intval = info->ac_online;
	205	break;
	206	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	207	if (info->ac_online) {
	208	ret = start_measure(info, MEASURE_VCHG);
	209	if (ret >= 0) {
9c9cf9e2	210	val->intval = ret * 2000; /* unit is uV */
28db3888 HZ	211	goto out;
	212	}
	213	}
	214	ret = -ENODATA;
	215	break;
	216	default:
	217	ret = -ENODEV;
	218	break;
	219	}
	220	out:
	221	return ret;
	222	}
	223
	224	static enum power_supply_property max8925_ac_props[] = {
	225	POWER_SUPPLY_PROP_ONLINE,
	226	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	227	};
	228
	229	static int max8925_usb_get_prop(struct power_supply *psy,
	230	enum power_supply_property psp,
	231	union power_supply_propval *val)
	232	{
297d716f	233	struct max8925_power_info *info = dev_get_drvdata(psy->dev.parent);
28db3888 HZ	234	int ret = 0;
	235
	236	switch (psp) {
	237	case POWER_SUPPLY_PROP_ONLINE:
	238	val->intval = info->usb_online;
	239	break;
	240	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	241	if (info->usb_online) {
	242	ret = start_measure(info, MEASURE_VCHG);
	243	if (ret >= 0) {
9c9cf9e2	244	val->intval = ret * 2000; /* unit is uV */
28db3888 HZ	245	goto out;
	246	}
	247	}
	248	ret = -ENODATA;
	249	break;
	250	default:
	251	ret = -ENODEV;
	252	break;
	253	}
	254	out:
	255	return ret;
	256	}
	257
	258	static enum power_supply_property max8925_usb_props[] = {
	259	POWER_SUPPLY_PROP_ONLINE,
	260	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	261	};
	262
	263	static int max8925_bat_get_prop(struct power_supply *psy,
	264	enum power_supply_property psp,
	265	union power_supply_propval *val)
	266	{
297d716f	267	struct max8925_power_info *info = dev_get_drvdata(psy->dev.parent);
28db3888 HZ	268	int ret = 0;
	269
	270	switch (psp) {
	271	case POWER_SUPPLY_PROP_ONLINE:
	272	val->intval = info->bat_online;
	273	break;
	274	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	275	if (info->bat_online) {
	276	ret = start_measure(info, MEASURE_VMBATT);
	277	if (ret >= 0) {
9c9cf9e2	278	val->intval = ret * 2000; /* unit is uV */
28db3888 HZ	279	ret = 0;
	280	break;
	281	}
	282	}
	283	ret = -ENODATA;
	284	break;
	285	case POWER_SUPPLY_PROP_CURRENT_NOW:
	286	if (info->bat_online) {
	287	ret = start_measure(info, MEASURE_ISNS);
	288	if (ret >= 0) {
9c9cf9e2 PR	289	/* assume r_sns is 0.02 */
9c9cf9e2 PR	290	ret = ((ret * 6250) - 3125) /* uA */;
28db3888 HZ	291	val->intval = 0;
	292	if (ret > 0)
	293	val->intval = ret; /* unit is mA */
	294	ret = 0;
	295	break;
	296	}
	297	}
	298	ret = -ENODATA;
	299	break;
	300	case POWER_SUPPLY_PROP_CHARGE_TYPE:
	301	if (!info->bat_online) {
	302	ret = -ENODATA;
	303	break;
	304	}
	305	ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
	306	ret = (ret & MAX8925_CHG_STAT_MODE_MASK) >> 2;
	307	switch (ret) {
	308	case 1:
	309	val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
	310	break;
	311	case 0:
	312	case 2:
	313	val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
	314	break;
	315	case 3:
	316	val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
	317	break;
	318	}
	319	ret = 0;
	320	break;
	321	case POWER_SUPPLY_PROP_STATUS:
	322	if (!info->bat_online) {
	323	ret = -ENODATA;
	324	break;
	325	}
	326	ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
	327	if (info->usb_online \|\| info->ac_online) {
	328	val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
	329	if (ret & MAX8925_CHG_STAT_EN_MASK)
	330	val->intval = POWER_SUPPLY_STATUS_CHARGING;
	331	} else
	332	val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
	333	ret = 0;
	334	break;
	335	default:
	336	ret = -ENODEV;
	337	break;
	338	}
	339	return ret;
	340	}
	341
	342	static enum power_supply_property max8925_battery_props[] = {
	343	POWER_SUPPLY_PROP_ONLINE,
	344	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	345	POWER_SUPPLY_PROP_CURRENT_NOW,
	346	POWER_SUPPLY_PROP_CHARGE_TYPE,
	347	POWER_SUPPLY_PROP_STATUS,
	348	};
	349
297d716f KK	350	static const struct power_supply_desc ac_desc = {
	351	.name = "max8925-ac",
	352	.type = POWER_SUPPLY_TYPE_MAINS,
	353	.properties = max8925_ac_props,
	354	.num_properties = ARRAY_SIZE(max8925_ac_props),
	355	.get_property = max8925_ac_get_prop,
	356	};
	357
	358	static const struct power_supply_desc usb_desc = {
	359	.name = "max8925-usb",
	360	.type = POWER_SUPPLY_TYPE_USB,
	361	.properties = max8925_usb_props,
	362	.num_properties = ARRAY_SIZE(max8925_usb_props),
	363	.get_property = max8925_usb_get_prop,
	364	};
	365
	366	static const struct power_supply_desc battery_desc = {
	367	.name = "max8925-battery",
	368	.type = POWER_SUPPLY_TYPE_BATTERY,
	369	.properties = max8925_battery_props,
	370	.num_properties = ARRAY_SIZE(max8925_battery_props),
	371	.get_property = max8925_bat_get_prop,
	372	};
	373
28db3888 HZ	374	#define REQUEST_IRQ(_irq, _name) \
	375	do { \
	376	ret = request_threaded_irq(chip->irq_base + _irq, NULL, \
	377	max8925_charger_handler, \
	378	IRQF_ONESHOT, _name, info); \
	379	if (ret) \
	380	dev_err(chip->dev, "Failed to request IRQ #%d: %d\n", \
	381	_irq, ret); \
	382	} while (0)
	383
c8afa640	384	static int max8925_init_charger(struct max8925_chip *chip,
28db3888 HZ	385	struct max8925_power_info *info)
	386	{
	387	int ret;
	388
	389	REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_OVP, "ac-ovp");
5ba1fa0a PR	390	if (!info->no_insert_detect) {
	391	REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_F, "ac-remove");
	392	REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_R, "ac-insert");
	393	}
92de378b PR	394	if (!info->no_temp_support) {
	395	REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_R, "batt-temp-in-range");
	396	REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_F, "batt-temp-out-range");
	397	}
28db3888 HZ	398	REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_F, "vsys-high");
	399	REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_R, "vsys-low");
	400	REQUEST_IRQ(MAX8925_IRQ_VCHG_RST, "charger-reset");
	401	REQUEST_IRQ(MAX8925_IRQ_VCHG_DONE, "charger-done");
	402	REQUEST_IRQ(MAX8925_IRQ_VCHG_TOPOFF, "charger-topoff");
	403	REQUEST_IRQ(MAX8925_IRQ_VCHG_TMR_FAULT, "charger-timer-expire");
	404
28db3888 HZ	405	info->usb_online = 0;
28db3888 HZ	406	info->bat_online = 0;
00a159a5 PR	407
	408	/* check for power - can miss interrupt at boot time */
	409	if (start_measure(info, MEASURE_VCHG) * 2000 > 500000)
	410	info->ac_online = 1;
	411	else
	412	info->ac_online = 0;
	413
28db3888 HZ	414	ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
	415	if (ret >= 0) {
	416	/*
	417	* If battery detection is enabled, ID pin of battery is
	418	* connected to MBDET pin of MAX8925. It could be used to
	419	* detect battery presence.
	420	* Otherwise, we have to assume that battery is always on.
	421	*/
	422	if (info->batt_detect)
	423	info->bat_online = (ret & MAX8925_CHG_MBDET) ? 0 : 1;
	424	else
	425	info->bat_online = 1;
	426	if (ret & MAX8925_CHG_AC_RANGE_MASK)
	427	info->ac_online = 1;
	428	else
	429	info->ac_online = 0;
	430	}
	431	/* disable charge */
	432	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
	433	/* set charging current in charge topoff mode */
	434	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 3 << 5,
	435	info->topoff_threshold << 5);
	436	/* set charing current in fast charge mode */
	437	max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 7, info->fast_charge);
	438
	439	return 0;
	440	}
	441
415ec69f	442	static int max8925_deinit_charger(struct max8925_power_info *info)
28db3888 HZ	443	{
	444	struct max8925_chip *chip = info->chip;
	445	int irq;
	446
	447	irq = chip->irq_base + MAX8925_IRQ_VCHG_DC_OVP;
	448	for (; irq <= chip->irq_base + MAX8925_IRQ_VCHG_TMR_FAULT; irq++)
	449	free_irq(irq, info);
	450
	451	return 0;
	452	}
	453
eba3b670 QX	454	#ifdef CONFIG_OF
	455	static struct max8925_power_pdata *
	456	max8925_power_dt_init(struct platform_device *pdev)
	457	{
	458	struct device_node *nproot = pdev->dev.parent->of_node;
	459	struct device_node *np;
	460	int batt_detect;
	461	int topoff_threshold;
	462	int fast_charge;
	463	int no_temp_support;
	464	int no_insert_detect;
	465	struct max8925_power_pdata *pdata;
	466
	467	if (!nproot)
	468	return pdev->dev.platform_data;
	469
ddd26dff	470	np = of_get_child_by_name(nproot, "charger");
eba3b670 QX	471	if (!np) {
	472	dev_err(&pdev->dev, "failed to find charger node\n");
	473	return NULL;
	474	}
	475
	476	pdata = devm_kzalloc(&pdev->dev,
	477	sizeof(struct max8925_power_pdata),
	478	GFP_KERNEL);
920ac5be KK	479	if (!pdata)
920ac5be KK	480	goto ret;
eba3b670 QX	481
	482	of_property_read_u32(np, "topoff-threshold", &topoff_threshold);
	483	of_property_read_u32(np, "batt-detect", &batt_detect);
	484	of_property_read_u32(np, "fast-charge", &fast_charge);
	485	of_property_read_u32(np, "no-insert-detect", &no_insert_detect);
	486	of_property_read_u32(np, "no-temp-support", &no_temp_support);
	487
	488	pdata->batt_detect = batt_detect;
	489	pdata->fast_charge = fast_charge;
	490	pdata->topoff_threshold = topoff_threshold;
	491	pdata->no_insert_detect = no_insert_detect;
	492	pdata->no_temp_support = no_temp_support;
	493
920ac5be KK	494	ret:
920ac5be KK	495	of_node_put(np);
eba3b670 QX	496	return pdata;
	497	}
	498	#else
	499	static struct max8925_power_pdata *
	500	max8925_power_dt_init(struct platform_device *pdev)
	501	{
	502	return pdev->dev.platform_data;
	503	}
	504	#endif
	505
c8afa640	506	static int max8925_power_probe(struct platform_device *pdev)
28db3888 HZ	507	{
28db3888 HZ	508	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
2dc9215d	509	struct power_supply_config psy_cfg = {}; /* Only for ac and usb */
28db3888 HZ	510	struct max8925_power_pdata *pdata = NULL;
	511	struct max8925_power_info *info;
	512	int ret;
	513
eba3b670	514	pdata = max8925_power_dt_init(pdev);
28db3888 HZ	515	if (!pdata) {
	516	dev_err(&pdev->dev, "platform data isn't assigned to "
	517	"power supply\n");
	518	return -EINVAL;
	519	}
	520
feeb3a92 JH	521	info = devm_kzalloc(&pdev->dev, sizeof(struct max8925_power_info),
feeb3a92 JH	522	GFP_KERNEL);
28db3888 HZ	523	if (!info)
	524	return -ENOMEM;
	525	info->chip = chip;
	526	info->gpm = chip->i2c;
	527	info->adc = chip->adc;
2402ca5e	528	platform_set_drvdata(pdev, info);
28db3888	529
2dc9215d KK	530	psy_cfg.supplied_to = pdata->supplied_to;
	531	psy_cfg.num_supplicants = pdata->num_supplicants;
	532
297d716f KK	533	info->ac = power_supply_register(&pdev->dev, &ac_desc, &psy_cfg);
	534	if (IS_ERR(info->ac)) {
	535	ret = PTR_ERR(info->ac);
28db3888	536	goto out;
297d716f KK	537	}
297d716f KK	538	info->ac->dev.parent = &pdev->dev;
e7a5f6d5	539
297d716f KK	540	info->usb = power_supply_register(&pdev->dev, &usb_desc, &psy_cfg);
	541	if (IS_ERR(info->usb)) {
	542	ret = PTR_ERR(info->usb);
28db3888	543	goto out_usb;
297d716f KK	544	}
	545	info->usb->dev.parent = &pdev->dev;
	546
	547	info->battery = power_supply_register(&pdev->dev, &battery_desc, NULL);
	548	if (IS_ERR(info->battery)) {
	549	ret = PTR_ERR(info->battery);
28db3888	550	goto out_battery;
297d716f KK	551	}
297d716f KK	552	info->battery->dev.parent = &pdev->dev;
28db3888 HZ	553
	554	info->batt_detect = pdata->batt_detect;
	555	info->topoff_threshold = pdata->topoff_threshold;
	556	info->fast_charge = pdata->fast_charge;
	557	info->set_charger = pdata->set_charger;
92de378b	558	info->no_temp_support = pdata->no_temp_support;
5ba1fa0a	559	info->no_insert_detect = pdata->no_insert_detect;
28db3888 HZ	560
	561	max8925_init_charger(chip, info);
	562	return 0;
	563	out_battery:
297d716f	564	power_supply_unregister(info->battery);
28db3888	565	out_usb:
297d716f	566	power_supply_unregister(info->ac);
28db3888	567	out:
28db3888 HZ	568	return ret;
	569	}
	570
415ec69f	571	static int max8925_power_remove(struct platform_device *pdev)
28db3888 HZ	572	{
	573	struct max8925_power_info *info = platform_get_drvdata(pdev);
	574
	575	if (info) {
297d716f KK	576	power_supply_unregister(info->ac);
	577	power_supply_unregister(info->usb);
	578	power_supply_unregister(info->battery);
28db3888	579	max8925_deinit_charger(info);
28db3888 HZ	580	}
	581	return 0;
	582	}
	583
	584	static struct platform_driver max8925_power_driver = {
	585	.probe = max8925_power_probe,
28ea73f4	586	.remove = max8925_power_remove,
28db3888 HZ	587	.driver = {
	588	.name = "max8925-power",
	589	},
	590	};
	591
300bac7f	592	module_platform_driver(max8925_power_driver);
28db3888 HZ	593
	594	MODULE_LICENSE("GPL");
	595	MODULE_DESCRIPTION("Power supply driver for MAX8925");
	596	MODULE_ALIAS("platform:max8925-power");