[mirror_ubuntu-jammy-kernel.git] / drivers / power / supply / tosa_battery.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Battery and Power Management code for the Sharp SL-6000x
 *
 * Copyright (c) 2005 Dirk Opfer
 * Copyright (c) 2008 Dmitry Baryshkov
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/power_supply.h>
#include <linux/wm97xx.h>
#include <linux/delay.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/gpio.h>

#include <asm/mach-types.h>
#include <mach/tosa.h>

static DEFINE_MUTEX(bat_lock); /* protects gpio pins */
static struct work_struct bat_work;

struct tosa_bat {
	int status;
	struct power_supply *psy;
	int full_chrg;

	struct mutex work_lock; /* protects data */

	bool (*is_present)(struct tosa_bat *bat);
	int gpio_full;
	int gpio_charge_off;

	int technology;

	int gpio_bat;
	int adc_bat;
	int adc_bat_divider;
	int bat_max;
	int bat_min;

	int gpio_temp;
	int adc_temp;
	int adc_temp_divider;
};

static struct tosa_bat tosa_bat_main;
static struct tosa_bat tosa_bat_jacket;

static unsigned long tosa_read_bat(struct tosa_bat *bat)
{
	unsigned long value = 0;

	if (bat->gpio_bat < 0 || bat->adc_bat < 0)
		return 0;

	mutex_lock(&bat_lock);
	gpio_set_value(bat->gpio_bat, 1);
	msleep(5);
	value = wm97xx_read_aux_adc(dev_get_drvdata(bat->psy->dev.parent),
			bat->adc_bat);
	gpio_set_value(bat->gpio_bat, 0);
	mutex_unlock(&bat_lock);

	value = value * 1000000 / bat->adc_bat_divider;

	return value;
}

static unsigned long tosa_read_temp(struct tosa_bat *bat)
{
	unsigned long value = 0;

	if (bat->gpio_temp < 0 || bat->adc_temp < 0)
		return 0;

	mutex_lock(&bat_lock);
	gpio_set_value(bat->gpio_temp, 1);
	msleep(5);
	value = wm97xx_read_aux_adc(dev_get_drvdata(bat->psy->dev.parent),
			bat->adc_temp);
	gpio_set_value(bat->gpio_temp, 0);
	mutex_unlock(&bat_lock);

	value = value * 10000 / bat->adc_temp_divider;

	return value;
}

static int tosa_bat_get_property(struct power_supply *psy,
			    enum power_supply_property psp,
			    union power_supply_propval *val)
{
	int ret = 0;
	struct tosa_bat *bat = power_supply_get_drvdata(psy);

	if (bat->is_present && !bat->is_present(bat)
			&& psp != POWER_SUPPLY_PROP_PRESENT) {
		return -ENODEV;
	}

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		val->intval = bat->status;
		break;
	case POWER_SUPPLY_PROP_TECHNOLOGY:
		val->intval = bat->technology;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		val->intval = tosa_read_bat(bat);
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
		if (bat->full_chrg == -1)
			val->intval = bat->bat_max;
		else
			val->intval = bat->full_chrg;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
		val->intval = bat->bat_max;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
		val->intval = bat->bat_min;
		break;
	case POWER_SUPPLY_PROP_TEMP:
		val->intval = tosa_read_temp(bat);
		break;
	case POWER_SUPPLY_PROP_PRESENT:
		val->intval = bat->is_present ? bat->is_present(bat) : 1;
		break;
	default:
		ret = -EINVAL;
		break;
	}
	return ret;
}

static bool tosa_jacket_bat_is_present(struct tosa_bat *bat)
{
	return gpio_get_value(TOSA_GPIO_JACKET_DETECT) == 0;
}

static void tosa_bat_external_power_changed(struct power_supply *psy)
{
	schedule_work(&bat_work);
}

static irqreturn_t tosa_bat_gpio_isr(int irq, void *data)
{
	pr_info("tosa_bat_gpio irq\n");
	schedule_work(&bat_work);
	return IRQ_HANDLED;
}

static void tosa_bat_update(struct tosa_bat *bat)
{
	int old;
	struct power_supply *psy = bat->psy;

	mutex_lock(&bat->work_lock);

	old = bat->status;

	if (bat->is_present && !bat->is_present(bat)) {
		printk(KERN_NOTICE "%s not present\n", psy->desc->name);
		bat->status = POWER_SUPPLY_STATUS_UNKNOWN;
		bat->full_chrg = -1;
	} else if (power_supply_am_i_supplied(psy)) {
		if (bat->status == POWER_SUPPLY_STATUS_DISCHARGING) {
			gpio_set_value(bat->gpio_charge_off, 0);
			mdelay(15);
		}

		if (gpio_get_value(bat->gpio_full)) {
			if (old == POWER_SUPPLY_STATUS_CHARGING ||
					bat->full_chrg == -1)
				bat->full_chrg = tosa_read_bat(bat);

			gpio_set_value(bat->gpio_charge_off, 1);
			bat->status = POWER_SUPPLY_STATUS_FULL;
		} else {
			gpio_set_value(bat->gpio_charge_off, 0);
			bat->status = POWER_SUPPLY_STATUS_CHARGING;
		}
	} else {
		gpio_set_value(bat->gpio_charge_off, 1);
		bat->status = POWER_SUPPLY_STATUS_DISCHARGING;
	}

	if (old != bat->status)
		power_supply_changed(psy);

	mutex_unlock(&bat->work_lock);
}

static void tosa_bat_work(struct work_struct *work)
{
	tosa_bat_update(&tosa_bat_main);
	tosa_bat_update(&tosa_bat_jacket);
}


static enum power_supply_property tosa_bat_main_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_VOLTAGE_MAX,
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_TEMP,
	POWER_SUPPLY_PROP_PRESENT,
};

static enum power_supply_property tosa_bat_bu_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
	POWER_SUPPLY_PROP_PRESENT,
};

static const struct power_supply_desc tosa_bat_main_desc = {
	.name		= "main-battery",
	.type		= POWER_SUPPLY_TYPE_BATTERY,
	.properties	= tosa_bat_main_props,
	.num_properties	= ARRAY_SIZE(tosa_bat_main_props),
	.get_property	= tosa_bat_get_property,
	.external_power_changed = tosa_bat_external_power_changed,
	.use_for_apm	= 1,
};

static const struct power_supply_desc tosa_bat_jacket_desc = {
	.name		= "jacket-battery",
	.type		= POWER_SUPPLY_TYPE_BATTERY,
	.properties	= tosa_bat_main_props,
	.num_properties	= ARRAY_SIZE(tosa_bat_main_props),
	.get_property	= tosa_bat_get_property,
	.external_power_changed = tosa_bat_external_power_changed,
};

static const struct power_supply_desc tosa_bat_bu_desc = {
	.name		= "backup-battery",
	.type		= POWER_SUPPLY_TYPE_BATTERY,
	.properties	= tosa_bat_bu_props,
	.num_properties	= ARRAY_SIZE(tosa_bat_bu_props),
	.get_property	= tosa_bat_get_property,
	.external_power_changed = tosa_bat_external_power_changed,
};

static struct tosa_bat tosa_bat_main = {
	.status = POWER_SUPPLY_STATUS_DISCHARGING,
	.full_chrg = -1,
	.psy = NULL,

	.gpio_full = TOSA_GPIO_BAT0_CRG,
	.gpio_charge_off = TOSA_GPIO_CHARGE_OFF,

	.technology = POWER_SUPPLY_TECHNOLOGY_LIPO,

	.gpio_bat = TOSA_GPIO_BAT0_V_ON,
	.adc_bat = WM97XX_AUX_ID3,
	.adc_bat_divider = 414,
	.bat_max = 4310000,
	.bat_min = 1551 * 1000000 / 414,

	.gpio_temp = TOSA_GPIO_BAT1_TH_ON,
	.adc_temp = WM97XX_AUX_ID2,
	.adc_temp_divider = 10000,
};

static struct tosa_bat tosa_bat_jacket = {
	.status = POWER_SUPPLY_STATUS_DISCHARGING,
	.full_chrg = -1,
	.psy = NULL,

	.is_present = tosa_jacket_bat_is_present,
	.gpio_full = TOSA_GPIO_BAT1_CRG,
	.gpio_charge_off = TOSA_GPIO_CHARGE_OFF_JC,

	.technology = POWER_SUPPLY_TECHNOLOGY_LIPO,

	.gpio_bat = TOSA_GPIO_BAT1_V_ON,
	.adc_bat = WM97XX_AUX_ID3,
	.adc_bat_divider = 414,
	.bat_max = 4310000,
	.bat_min = 1551 * 1000000 / 414,

	.gpio_temp = TOSA_GPIO_BAT0_TH_ON,
	.adc_temp = WM97XX_AUX_ID2,
	.adc_temp_divider = 10000,
};

static struct tosa_bat tosa_bat_bu = {
	.status = POWER_SUPPLY_STATUS_UNKNOWN,
	.full_chrg = -1,
	.psy = NULL,

	.gpio_full = -1,
	.gpio_charge_off = -1,

	.technology = POWER_SUPPLY_TECHNOLOGY_LiMn,

	.gpio_bat = TOSA_GPIO_BU_CHRG_ON,
	.adc_bat = WM97XX_AUX_ID4,
	.adc_bat_divider = 1266,

	.gpio_temp = -1,
	.adc_temp = -1,
	.adc_temp_divider = -1,
};

static struct gpio tosa_bat_gpios[] = {
	{ TOSA_GPIO_CHARGE_OFF,	   GPIOF_OUT_INIT_HIGH, "main charge off" },
	{ TOSA_GPIO_CHARGE_OFF_JC, GPIOF_OUT_INIT_HIGH, "jacket charge off" },
	{ TOSA_GPIO_BAT_SW_ON,	   GPIOF_OUT_INIT_LOW,	"battery switch" },
	{ TOSA_GPIO_BAT0_V_ON,	   GPIOF_OUT_INIT_LOW,	"main battery" },
	{ TOSA_GPIO_BAT1_V_ON,	   GPIOF_OUT_INIT_LOW,	"jacket battery" },
	{ TOSA_GPIO_BAT1_TH_ON,	   GPIOF_OUT_INIT_LOW,	"main battery temp" },
	{ TOSA_GPIO_BAT0_TH_ON,	   GPIOF_OUT_INIT_LOW,	"jacket battery temp" },
	{ TOSA_GPIO_BU_CHRG_ON,	   GPIOF_OUT_INIT_LOW,	"backup battery" },
	{ TOSA_GPIO_BAT0_CRG,	   GPIOF_IN,		"main battery full" },
	{ TOSA_GPIO_BAT1_CRG,	   GPIOF_IN,		"jacket battery full" },
	{ TOSA_GPIO_BAT0_LOW,	   GPIOF_IN,		"main battery low" },
	{ TOSA_GPIO_BAT1_LOW,	   GPIOF_IN,		"jacket battery low" },
	{ TOSA_GPIO_JACKET_DETECT, GPIOF_IN,		"jacket detect" },
};

#ifdef CONFIG_PM
static int tosa_bat_suspend(struct platform_device *dev, pm_message_t state)
{
	/* flush all pending status updates */
	flush_work(&bat_work);
	return 0;
}

static int tosa_bat_resume(struct platform_device *dev)
{
	/* things may have changed while we were away */
	schedule_work(&bat_work);
	return 0;
}
#else
#define tosa_bat_suspend NULL
#define tosa_bat_resume NULL
#endif

static int tosa_bat_probe(struct platform_device *dev)
{
	int ret;
	struct power_supply_config main_psy_cfg = {},
				   jacket_psy_cfg = {},
				   bu_psy_cfg = {};

	if (!machine_is_tosa())
		return -ENODEV;

	ret = gpio_request_array(tosa_bat_gpios, ARRAY_SIZE(tosa_bat_gpios));
	if (ret)
		return ret;

	mutex_init(&tosa_bat_main.work_lock);
	mutex_init(&tosa_bat_jacket.work_lock);

	INIT_WORK(&bat_work, tosa_bat_work);

	main_psy_cfg.drv_data = &tosa_bat_main;
	tosa_bat_main.psy = power_supply_register(&dev->dev,
						  &tosa_bat_main_desc,
						  &main_psy_cfg);
	if (IS_ERR(tosa_bat_main.psy)) {
		ret = PTR_ERR(tosa_bat_main.psy);
		goto err_psy_reg_main;
	}

	jacket_psy_cfg.drv_data = &tosa_bat_jacket;
	tosa_bat_jacket.psy = power_supply_register(&dev->dev,
						    &tosa_bat_jacket_desc,
						    &jacket_psy_cfg);
	if (IS_ERR(tosa_bat_jacket.psy)) {
		ret = PTR_ERR(tosa_bat_jacket.psy);
		goto err_psy_reg_jacket;
	}

	bu_psy_cfg.drv_data = &tosa_bat_bu;
	tosa_bat_bu.psy = power_supply_register(&dev->dev, &tosa_bat_bu_desc,
						&bu_psy_cfg);
	if (IS_ERR(tosa_bat_bu.psy)) {
		ret = PTR_ERR(tosa_bat_bu.psy);
		goto err_psy_reg_bu;
	}

	ret = request_irq(gpio_to_irq(TOSA_GPIO_BAT0_CRG),
				tosa_bat_gpio_isr,
				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
				"main full", &tosa_bat_main);
	if (ret)
		goto err_req_main;

	ret = request_irq(gpio_to_irq(TOSA_GPIO_BAT1_CRG),
				tosa_bat_gpio_isr,
				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
				"jacket full", &tosa_bat_jacket);
	if (ret)
		goto err_req_jacket;

	ret = request_irq(gpio_to_irq(TOSA_GPIO_JACKET_DETECT),
				tosa_bat_gpio_isr,
				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
				"jacket detect", &tosa_bat_jacket);
	if (!ret) {
		schedule_work(&bat_work);
		return 0;
	}

	free_irq(gpio_to_irq(TOSA_GPIO_BAT1_CRG), &tosa_bat_jacket);
err_req_jacket:
	free_irq(gpio_to_irq(TOSA_GPIO_BAT0_CRG), &tosa_bat_main);
err_req_main:
	power_supply_unregister(tosa_bat_bu.psy);
err_psy_reg_bu:
	power_supply_unregister(tosa_bat_jacket.psy);
err_psy_reg_jacket:
	power_supply_unregister(tosa_bat_main.psy);
err_psy_reg_main:

	/* see comment in tosa_bat_remove */
	cancel_work_sync(&bat_work);

	gpio_free_array(tosa_bat_gpios, ARRAY_SIZE(tosa_bat_gpios));
	return ret;
}

static int tosa_bat_remove(struct platform_device *dev)
{
	free_irq(gpio_to_irq(TOSA_GPIO_JACKET_DETECT), &tosa_bat_jacket);
	free_irq(gpio_to_irq(TOSA_GPIO_BAT1_CRG), &tosa_bat_jacket);
	free_irq(gpio_to_irq(TOSA_GPIO_BAT0_CRG), &tosa_bat_main);

	power_supply_unregister(tosa_bat_bu.psy);
	power_supply_unregister(tosa_bat_jacket.psy);
	power_supply_unregister(tosa_bat_main.psy);

	/*
	 * Now cancel the bat_work.  We won't get any more schedules,
	 * since all sources (isr and external_power_changed) are
	 * unregistered now.
	 */
	cancel_work_sync(&bat_work);
	gpio_free_array(tosa_bat_gpios, ARRAY_SIZE(tosa_bat_gpios));
	return 0;
}

static struct platform_driver tosa_bat_driver = {
	.driver.name	= "wm97xx-battery",
	.driver.owner	= THIS_MODULE,
	.probe		= tosa_bat_probe,
	.remove		= tosa_bat_remove,
	.suspend	= tosa_bat_suspend,
	.resume		= tosa_bat_resume,
};

module_platform_driver(tosa_bat_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Dmitry Baryshkov");
MODULE_DESCRIPTION("Tosa battery driver");
MODULE_ALIAS("platform:wm97xx-battery");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
fece4184 DB	2	/*
	3	* Battery and Power Management code for the Sharp SL-6000x
	4	*
	5	* Copyright (c) 2005 Dirk Opfer
	6	* Copyright (c) 2008 Dmitry Baryshkov
fece4184 DB	7	*/
	8	#include <linux/kernel.h>
	9	#include <linux/module.h>
	10	#include <linux/power_supply.h>
	11	#include <linux/wm97xx.h>
	12	#include <linux/delay.h>
	13	#include <linux/spinlock.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/gpio.h>
	16
	17	#include <asm/mach-types.h>
a09e64fb	18	#include <mach/tosa.h>
fece4184 DB	19
	20	static DEFINE_MUTEX(bat_lock); /* protects gpio pins */
	21	static struct work_struct bat_work;
	22
	23	struct tosa_bat {
	24	int status;
297d716f	25	struct power_supply *psy;
fece4184 DB	26	int full_chrg;
	27
	28	struct mutex work_lock; /* protects data */
	29
	30	bool (is_present)(struct tosa_bat bat);
	31	int gpio_full;
	32	int gpio_charge_off;
	33
	34	int technology;
	35
	36	int gpio_bat;
	37	int adc_bat;
	38	int adc_bat_divider;
	39	int bat_max;
	40	int bat_min;
	41
	42	int gpio_temp;
	43	int adc_temp;
	44	int adc_temp_divider;
	45	};
	46
	47	static struct tosa_bat tosa_bat_main;
	48	static struct tosa_bat tosa_bat_jacket;
	49
	50	static unsigned long tosa_read_bat(struct tosa_bat *bat)
	51	{
	52	unsigned long value = 0;
	53
	54	if (bat->gpio_bat < 0 \|\| bat->adc_bat < 0)
	55	return 0;
	56
	57	mutex_lock(&bat_lock);
	58	gpio_set_value(bat->gpio_bat, 1);
	59	msleep(5);
297d716f	60	value = wm97xx_read_aux_adc(dev_get_drvdata(bat->psy->dev.parent),
fece4184 DB	61	bat->adc_bat);
	62	gpio_set_value(bat->gpio_bat, 0);
	63	mutex_unlock(&bat_lock);
	64
	65	value = value * 1000000 / bat->adc_bat_divider;
	66
	67	return value;
	68	}
	69
	70	static unsigned long tosa_read_temp(struct tosa_bat *bat)
	71	{
	72	unsigned long value = 0;
	73
	74	if (bat->gpio_temp < 0 \|\| bat->adc_temp < 0)
	75	return 0;
	76
	77	mutex_lock(&bat_lock);
	78	gpio_set_value(bat->gpio_temp, 1);
	79	msleep(5);
297d716f	80	value = wm97xx_read_aux_adc(dev_get_drvdata(bat->psy->dev.parent),
fece4184 DB	81	bat->adc_temp);
	82	gpio_set_value(bat->gpio_temp, 0);
	83	mutex_unlock(&bat_lock);
	84
	85	value = value * 10000 / bat->adc_temp_divider;
	86
	87	return value;
	88	}
	89
	90	static int tosa_bat_get_property(struct power_supply *psy,
	91	enum power_supply_property psp,
	92	union power_supply_propval *val)
	93	{
	94	int ret = 0;
297d716f	95	struct tosa_bat *bat = power_supply_get_drvdata(psy);
fece4184 DB	96
	97	if (bat->is_present && !bat->is_present(bat)
	98	&& psp != POWER_SUPPLY_PROP_PRESENT) {
	99	return -ENODEV;
	100	}
	101
	102	switch (psp) {
	103	case POWER_SUPPLY_PROP_STATUS:
	104	val->intval = bat->status;
	105	break;
	106	case POWER_SUPPLY_PROP_TECHNOLOGY:
	107	val->intval = bat->technology;
	108	break;
	109	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	110	val->intval = tosa_read_bat(bat);
	111	break;
	112	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
	113	if (bat->full_chrg == -1)
	114	val->intval = bat->bat_max;
	115	else
	116	val->intval = bat->full_chrg;
	117	break;
	118	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
	119	val->intval = bat->bat_max;
	120	break;
	121	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
	122	val->intval = bat->bat_min;
	123	break;
	124	case POWER_SUPPLY_PROP_TEMP:
	125	val->intval = tosa_read_temp(bat);
	126	break;
	127	case POWER_SUPPLY_PROP_PRESENT:
	128	val->intval = bat->is_present ? bat->is_present(bat) : 1;
	129	break;
	130	default:
	131	ret = -EINVAL;
	132	break;
	133	}
	134	return ret;
	135	}
	136
	137	static bool tosa_jacket_bat_is_present(struct tosa_bat *bat)
	138	{
	139	return gpio_get_value(TOSA_GPIO_JACKET_DETECT) == 0;
	140	}
	141
	142	static void tosa_bat_external_power_changed(struct power_supply *psy)
	143	{
	144	schedule_work(&bat_work);
	145	}
	146
	147	static irqreturn_t tosa_bat_gpio_isr(int irq, void *data)
	148	{
0e81ef58	149	pr_info("tosa_bat_gpio irq\n");
fece4184 DB	150	schedule_work(&bat_work);
	151	return IRQ_HANDLED;
	152	}
	153
	154	static void tosa_bat_update(struct tosa_bat *bat)
	155	{
	156	int old;
297d716f	157	struct power_supply *psy = bat->psy;
fece4184 DB	158
	159	mutex_lock(&bat->work_lock);
	160
	161	old = bat->status;
	162
	163	if (bat->is_present && !bat->is_present(bat)) {
297d716f	164	printk(KERN_NOTICE "%s not present\n", psy->desc->name);
fece4184 DB	165	bat->status = POWER_SUPPLY_STATUS_UNKNOWN;
	166	bat->full_chrg = -1;
	167	} else if (power_supply_am_i_supplied(psy)) {
	168	if (bat->status == POWER_SUPPLY_STATUS_DISCHARGING) {
	169	gpio_set_value(bat->gpio_charge_off, 0);
	170	mdelay(15);
	171	}
	172
	173	if (gpio_get_value(bat->gpio_full)) {
	174	if (old == POWER_SUPPLY_STATUS_CHARGING \|\|
	175	bat->full_chrg == -1)
	176	bat->full_chrg = tosa_read_bat(bat);
	177
	178	gpio_set_value(bat->gpio_charge_off, 1);
	179	bat->status = POWER_SUPPLY_STATUS_FULL;
	180	} else {
	181	gpio_set_value(bat->gpio_charge_off, 0);
	182	bat->status = POWER_SUPPLY_STATUS_CHARGING;
	183	}
	184	} else {
	185	gpio_set_value(bat->gpio_charge_off, 1);
	186	bat->status = POWER_SUPPLY_STATUS_DISCHARGING;
	187	}
	188
	189	if (old != bat->status)
	190	power_supply_changed(psy);
	191
	192	mutex_unlock(&bat->work_lock);
	193	}
	194
	195	static void tosa_bat_work(struct work_struct *work)
	196	{
	197	tosa_bat_update(&tosa_bat_main);
	198	tosa_bat_update(&tosa_bat_jacket);
	199	}
	200
	201
	202	static enum power_supply_property tosa_bat_main_props[] = {
	203	POWER_SUPPLY_PROP_STATUS,
	204	POWER_SUPPLY_PROP_TECHNOLOGY,
	205	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	206	POWER_SUPPLY_PROP_VOLTAGE_MAX,
	207	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	208	POWER_SUPPLY_PROP_TEMP,
	209	POWER_SUPPLY_PROP_PRESENT,
	210	};
	211
	212	static enum power_supply_property tosa_bat_bu_props[] = {
	213	POWER_SUPPLY_PROP_STATUS,
	214	POWER_SUPPLY_PROP_TECHNOLOGY,
	215	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	216	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	217	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
	218	POWER_SUPPLY_PROP_PRESENT,
	219	};
	220
297d716f KK	221	static const struct power_supply_desc tosa_bat_main_desc = {
	222	.name = "main-battery",
	223	.type = POWER_SUPPLY_TYPE_BATTERY,
	224	.properties = tosa_bat_main_props,
	225	.num_properties = ARRAY_SIZE(tosa_bat_main_props),
	226	.get_property = tosa_bat_get_property,
	227	.external_power_changed = tosa_bat_external_power_changed,
	228	.use_for_apm = 1,
	229	};
	230
	231	static const struct power_supply_desc tosa_bat_jacket_desc = {
	232	.name = "jacket-battery",
	233	.type = POWER_SUPPLY_TYPE_BATTERY,
	234	.properties = tosa_bat_main_props,
	235	.num_properties = ARRAY_SIZE(tosa_bat_main_props),
	236	.get_property = tosa_bat_get_property,
	237	.external_power_changed = tosa_bat_external_power_changed,
	238	};
	239
	240	static const struct power_supply_desc tosa_bat_bu_desc = {
	241	.name = "backup-battery",
	242	.type = POWER_SUPPLY_TYPE_BATTERY,
	243	.properties = tosa_bat_bu_props,
	244	.num_properties = ARRAY_SIZE(tosa_bat_bu_props),
	245	.get_property = tosa_bat_get_property,
	246	.external_power_changed = tosa_bat_external_power_changed,
	247	};
	248
fece4184 DB	249	static struct tosa_bat tosa_bat_main = {
	250	.status = POWER_SUPPLY_STATUS_DISCHARGING,
	251	.full_chrg = -1,
297d716f	252	.psy = NULL,
fece4184 DB	253
	254	.gpio_full = TOSA_GPIO_BAT0_CRG,
	255	.gpio_charge_off = TOSA_GPIO_CHARGE_OFF,
	256
	257	.technology = POWER_SUPPLY_TECHNOLOGY_LIPO,
	258
	259	.gpio_bat = TOSA_GPIO_BAT0_V_ON,
	260	.adc_bat = WM97XX_AUX_ID3,
	261	.adc_bat_divider = 414,
	262	.bat_max = 4310000,
	263	.bat_min = 1551 * 1000000 / 414,
	264
	265	.gpio_temp = TOSA_GPIO_BAT1_TH_ON,
	266	.adc_temp = WM97XX_AUX_ID2,
	267	.adc_temp_divider = 10000,
	268	};
	269
	270	static struct tosa_bat tosa_bat_jacket = {
	271	.status = POWER_SUPPLY_STATUS_DISCHARGING,
	272	.full_chrg = -1,
297d716f	273	.psy = NULL,
fece4184 DB	274
	275	.is_present = tosa_jacket_bat_is_present,
	276	.gpio_full = TOSA_GPIO_BAT1_CRG,
	277	.gpio_charge_off = TOSA_GPIO_CHARGE_OFF_JC,
	278
	279	.technology = POWER_SUPPLY_TECHNOLOGY_LIPO,
	280
	281	.gpio_bat = TOSA_GPIO_BAT1_V_ON,
	282	.adc_bat = WM97XX_AUX_ID3,
	283	.adc_bat_divider = 414,
	284	.bat_max = 4310000,
	285	.bat_min = 1551 * 1000000 / 414,
	286
	287	.gpio_temp = TOSA_GPIO_BAT0_TH_ON,
	288	.adc_temp = WM97XX_AUX_ID2,
	289	.adc_temp_divider = 10000,
	290	};
	291
	292	static struct tosa_bat tosa_bat_bu = {
	293	.status = POWER_SUPPLY_STATUS_UNKNOWN,
	294	.full_chrg = -1,
297d716f	295	.psy = NULL,
fece4184 DB	296
	297	.gpio_full = -1,
	298	.gpio_charge_off = -1,
	299
	300	.technology = POWER_SUPPLY_TECHNOLOGY_LiMn,
	301
	302	.gpio_bat = TOSA_GPIO_BU_CHRG_ON,
	303	.adc_bat = WM97XX_AUX_ID4,
	304	.adc_bat_divider = 1266,
	305
	306	.gpio_temp = -1,
	307	.adc_temp = -1,
	308	.adc_temp_divider = -1,
	309	};
	310
019370d3 AL	311	static struct gpio tosa_bat_gpios[] = {
	312	{ TOSA_GPIO_CHARGE_OFF, GPIOF_OUT_INIT_HIGH, "main charge off" },
	313	{ TOSA_GPIO_CHARGE_OFF_JC, GPIOF_OUT_INIT_HIGH, "jacket charge off" },
	314	{ TOSA_GPIO_BAT_SW_ON, GPIOF_OUT_INIT_LOW, "battery switch" },
	315	{ TOSA_GPIO_BAT0_V_ON, GPIOF_OUT_INIT_LOW, "main battery" },
	316	{ TOSA_GPIO_BAT1_V_ON, GPIOF_OUT_INIT_LOW, "jacket battery" },
	317	{ TOSA_GPIO_BAT1_TH_ON, GPIOF_OUT_INIT_LOW, "main battery temp" },
	318	{ TOSA_GPIO_BAT0_TH_ON, GPIOF_OUT_INIT_LOW, "jacket battery temp" },
	319	{ TOSA_GPIO_BU_CHRG_ON, GPIOF_OUT_INIT_LOW, "backup battery" },
	320	{ TOSA_GPIO_BAT0_CRG, GPIOF_IN, "main battery full" },
	321	{ TOSA_GPIO_BAT1_CRG, GPIOF_IN, "jacket battery full" },
	322	{ TOSA_GPIO_BAT0_LOW, GPIOF_IN, "main battery low" },
	323	{ TOSA_GPIO_BAT1_LOW, GPIOF_IN, "jacket battery low" },
	324	{ TOSA_GPIO_JACKET_DETECT, GPIOF_IN, "jacket detect" },
fece4184 DB	325	};
	326
	327	#ifdef CONFIG_PM
	328	static int tosa_bat_suspend(struct platform_device *dev, pm_message_t state)
	329	{
	330	/* flush all pending status updates */
43829731	331	flush_work(&bat_work);
fece4184 DB	332	return 0;
	333	}
	334
	335	static int tosa_bat_resume(struct platform_device *dev)
	336	{
	337	/* things may have changed while we were away */
	338	schedule_work(&bat_work);
	339	return 0;
	340	}
	341	#else
	342	#define tosa_bat_suspend NULL
	343	#define tosa_bat_resume NULL
	344	#endif
	345
c8afa640	346	static int tosa_bat_probe(struct platform_device *dev)
fece4184 DB	347	{
fece4184 DB	348	int ret;
297d716f KK	349	struct power_supply_config main_psy_cfg = {},
	350	jacket_psy_cfg = {},
	351	bu_psy_cfg = {};
fece4184 DB	352
	353	if (!machine_is_tosa())
	354	return -ENODEV;
	355
019370d3 AL	356	ret = gpio_request_array(tosa_bat_gpios, ARRAY_SIZE(tosa_bat_gpios));
	357	if (ret)
	358	return ret;
fece4184 DB	359
	360	mutex_init(&tosa_bat_main.work_lock);
	361	mutex_init(&tosa_bat_jacket.work_lock);
	362
	363	INIT_WORK(&bat_work, tosa_bat_work);
	364
297d716f KK	365	main_psy_cfg.drv_data = &tosa_bat_main;
	366	tosa_bat_main.psy = power_supply_register(&dev->dev,
	367	&tosa_bat_main_desc,
	368	&main_psy_cfg);
	369	if (IS_ERR(tosa_bat_main.psy)) {
	370	ret = PTR_ERR(tosa_bat_main.psy);
fece4184	371	goto err_psy_reg_main;
297d716f KK	372	}
	373
	374	jacket_psy_cfg.drv_data = &tosa_bat_jacket;
	375	tosa_bat_jacket.psy = power_supply_register(&dev->dev,
	376	&tosa_bat_jacket_desc,
	377	&jacket_psy_cfg);
	378	if (IS_ERR(tosa_bat_jacket.psy)) {
	379	ret = PTR_ERR(tosa_bat_jacket.psy);
fece4184	380	goto err_psy_reg_jacket;
297d716f KK	381	}
	382
	383	bu_psy_cfg.drv_data = &tosa_bat_bu;
	384	tosa_bat_bu.psy = power_supply_register(&dev->dev, &tosa_bat_bu_desc,
	385	&bu_psy_cfg);
	386	if (IS_ERR(tosa_bat_bu.psy)) {
	387	ret = PTR_ERR(tosa_bat_bu.psy);
fece4184	388	goto err_psy_reg_bu;
297d716f	389	}
fece4184 DB	390
	391	ret = request_irq(gpio_to_irq(TOSA_GPIO_BAT0_CRG),
	392	tosa_bat_gpio_isr,
	393	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING,
	394	"main full", &tosa_bat_main);
	395	if (ret)
	396	goto err_req_main;
	397
	398	ret = request_irq(gpio_to_irq(TOSA_GPIO_BAT1_CRG),
	399	tosa_bat_gpio_isr,
	400	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING,
	401	"jacket full", &tosa_bat_jacket);
	402	if (ret)
	403	goto err_req_jacket;
	404
	405	ret = request_irq(gpio_to_irq(TOSA_GPIO_JACKET_DETECT),
	406	tosa_bat_gpio_isr,
	407	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING,
	408	"jacket detect", &tosa_bat_jacket);
	409	if (!ret) {
	410	schedule_work(&bat_work);
	411	return 0;
	412	}
	413
	414	free_irq(gpio_to_irq(TOSA_GPIO_BAT1_CRG), &tosa_bat_jacket);
	415	err_req_jacket:
	416	free_irq(gpio_to_irq(TOSA_GPIO_BAT0_CRG), &tosa_bat_main);
	417	err_req_main:
297d716f	418	power_supply_unregister(tosa_bat_bu.psy);
fece4184	419	err_psy_reg_bu:
297d716f	420	power_supply_unregister(tosa_bat_jacket.psy);
fece4184	421	err_psy_reg_jacket:
297d716f	422	power_supply_unregister(tosa_bat_main.psy);
fece4184 DB	423	err_psy_reg_main:
	424
	425	/* see comment in tosa_bat_remove */
bc51e7ff	426	cancel_work_sync(&bat_work);
fece4184	427
019370d3	428	gpio_free_array(tosa_bat_gpios, ARRAY_SIZE(tosa_bat_gpios));
fece4184 DB	429	return ret;
	430	}
	431
415ec69f	432	static int tosa_bat_remove(struct platform_device *dev)
fece4184	433	{
fece4184 DB	434	free_irq(gpio_to_irq(TOSA_GPIO_JACKET_DETECT), &tosa_bat_jacket);
	435	free_irq(gpio_to_irq(TOSA_GPIO_BAT1_CRG), &tosa_bat_jacket);
	436	free_irq(gpio_to_irq(TOSA_GPIO_BAT0_CRG), &tosa_bat_main);
	437
297d716f KK	438	power_supply_unregister(tosa_bat_bu.psy);
	439	power_supply_unregister(tosa_bat_jacket.psy);
	440	power_supply_unregister(tosa_bat_main.psy);
fece4184 DB	441
fece4184 DB	442	/*
bc51e7ff TH	443	* Now cancel the bat_work. We won't get any more schedules,
	444	* since all sources (isr and external_power_changed) are
	445	* unregistered now.
fece4184	446	*/
bc51e7ff	447	cancel_work_sync(&bat_work);
019370d3	448	gpio_free_array(tosa_bat_gpios, ARRAY_SIZE(tosa_bat_gpios));
fece4184 DB	449	return 0;
	450	}
	451
	452	static struct platform_driver tosa_bat_driver = {
	453	.driver.name = "wm97xx-battery",
	454	.driver.owner = THIS_MODULE,
	455	.probe = tosa_bat_probe,
28ea73f4	456	.remove = tosa_bat_remove,
fece4184 DB	457	.suspend = tosa_bat_suspend,
	458	.resume = tosa_bat_resume,
	459	};
	460
300bac7f	461	module_platform_driver(tosa_bat_driver);
fece4184 DB	462
	463	MODULE_LICENSE("GPL");
	464	MODULE_AUTHOR("Dmitry Baryshkov");
	465	MODULE_DESCRIPTION("Tosa battery driver");
	466	MODULE_ALIAS("platform:wm97xx-battery");