[GitHub/mt8127/android_kernel_alcatel_ttab.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/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;

	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 is removal\n");
		break;
	case MAX8925_IRQ_VCHG_USB_R:
		info->usb_online = 1;
		__set_charger(info, 1);
		dev_dbg(chip->dev, "USB inserted\n");
		break;
	case MAX8925_IRQ_VCHG_USB_F:
		info->usb_online = 0;
		__set_charger(info, 0);
		dev_dbg(chip->dev, "USB is removal\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_reg = 0, ret;

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

	max8925_bulk_read(info->adc, meas_reg, 2, buf);
	ret = (buf[0] << 4) | (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 << 1;	/* unit is mV */
				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 << 1;	/* unit is mV */
				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);
	long long int tmp = 0;
	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 << 1;	/* unit is mV */
				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) {
				tmp = (long long int)ret * 6250 / 4096 - 3125;
				ret = (int)tmp;
				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,
};

#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 __devinit int max8925_init_charger(struct max8925_chip *chip,
					  struct max8925_power_info *info)
{
	int ret;

	REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_OVP, "ac-ovp");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_F, "ac-remove");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_R, "ac-insert");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_USB_OVP, "usb-ovp");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_USB_F, "usb-remove");
	REQUEST_IRQ(MAX8925_IRQ_VCHG_USB_R, "usb-insert");
	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->ac_online = 0;
	info->usb_online = 0;
	info->bat_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 __devexit 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;
}

static __devinit int max8925_power_probe(struct platform_device *pdev)
{
	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
	struct max8925_platform_data *max8925_pdata;
	struct max8925_power_pdata *pdata = NULL;
	struct max8925_power_info *info;
	int ret;

	if (pdev->dev.parent->platform_data) {
		max8925_pdata = pdev->dev.parent->platform_data;
		pdata = max8925_pdata->power;
	}

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

	info = kzalloc(sizeof(struct max8925_power_info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;
	info->chip = chip;
	info->gpm = chip->i2c;
	info->adc = chip->adc;

	info->ac.name = "max8925-ac";
	info->ac.type = POWER_SUPPLY_TYPE_MAINS;
	info->ac.properties = max8925_ac_props;
	info->ac.num_properties = ARRAY_SIZE(max8925_ac_props);
	info->ac.get_property = max8925_ac_get_prop;
	ret = power_supply_register(&pdev->dev, &info->ac);
	if (ret)
		goto out;
	info->ac.dev->parent = &pdev->dev;

	info->usb.name = "max8925-usb";
	info->usb.type = POWER_SUPPLY_TYPE_USB;
	info->usb.properties = max8925_usb_props;
	info->usb.num_properties = ARRAY_SIZE(max8925_usb_props);
	info->usb.get_property = max8925_usb_get_prop;
	ret = power_supply_register(&pdev->dev, &info->usb);
	if (ret)
		goto out_usb;
	info->usb.dev->parent = &pdev->dev;

	info->battery.name = "max8925-battery";
	info->battery.type = POWER_SUPPLY_TYPE_BATTERY;
	info->battery.properties = max8925_battery_props;
	info->battery.num_properties = ARRAY_SIZE(max8925_battery_props);
	info->battery.get_property = max8925_bat_get_prop;
	ret = power_supply_register(&pdev->dev, &info->battery);
	if (ret)
		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;
	dev_set_drvdata(&pdev->dev, info);
	platform_set_drvdata(pdev, info);

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

static __devexit 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);
		kfree(info);
	}
	return 0;
}

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

static int __init max8925_power_init(void)
{
	return platform_driver_register(&max8925_power_driver);
}
module_init(max8925_power_init);

static void __exit max8925_power_exit(void)
{
	platform_driver_unregister(&max8925_power_driver);
}
module_exit(max8925_power_exit);

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