[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / power / olpc_battery.c

/*
 * Battery driver for One Laptop Per Child board.
 *
 *	Copyright © 2006-2010  David Woodhouse <dwmw2@infradead.org>
 *
 * 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/kernel.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/err.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/jiffies.h>
#include <linux/sched.h>
#include <asm/olpc.h>


#define EC_BAT_VOLTAGE	0x10	/* uint16_t,	*9.76/32,    mV   */
#define EC_BAT_CURRENT	0x11	/* int16_t,	*15.625/120, mA   */
#define EC_BAT_ACR	0x12	/* int16_t,	*6250/15,    µAh  */
#define EC_BAT_TEMP	0x13	/* uint16_t,	*100/256,   °C  */
#define EC_AMB_TEMP	0x14	/* uint16_t,	*100/256,   °C  */
#define EC_BAT_STATUS	0x15	/* uint8_t,	bitmask */
#define EC_BAT_SOC	0x16	/* uint8_t,	percentage */
#define EC_BAT_SERIAL	0x17	/* uint8_t[6] */
#define EC_BAT_EEPROM	0x18	/* uint8_t adr as input, uint8_t output */
#define EC_BAT_ERRCODE	0x1f	/* uint8_t,	bitmask */

#define BAT_STAT_PRESENT	0x01
#define BAT_STAT_FULL		0x02
#define BAT_STAT_LOW		0x04
#define BAT_STAT_DESTROY	0x08
#define BAT_STAT_AC		0x10
#define BAT_STAT_CHARGING	0x20
#define BAT_STAT_DISCHARGING	0x40
#define BAT_STAT_TRICKLE	0x80

#define BAT_ERR_INFOFAIL	0x02
#define BAT_ERR_OVERVOLTAGE	0x04
#define BAT_ERR_OVERTEMP	0x05
#define BAT_ERR_GAUGESTOP	0x06
#define BAT_ERR_OUT_OF_CONTROL	0x07
#define BAT_ERR_ID_FAIL		0x09
#define BAT_ERR_ACR_FAIL	0x10

#define BAT_ADDR_MFR_TYPE	0x5F

/*********************************************************************
 *		Power
 *********************************************************************/

static int olpc_ac_get_prop(struct power_supply *psy,
			    enum power_supply_property psp,
			    union power_supply_propval *val)
{
	int ret = 0;
	uint8_t status;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1);
		if (ret)
			return ret;

		val->intval = !!(status & BAT_STAT_AC);
		break;
	default:
		ret = -EINVAL;
		break;
	}
	return ret;
}

static enum power_supply_property olpc_ac_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
};

static struct power_supply olpc_ac = {
	.name = "olpc-ac",
	.type = POWER_SUPPLY_TYPE_MAINS,
	.properties = olpc_ac_props,
	.num_properties = ARRAY_SIZE(olpc_ac_props),
	.get_property = olpc_ac_get_prop,
};

static char bat_serial[17]; /* Ick */

static int olpc_bat_get_status(union power_supply_propval *val, uint8_t ec_byte)
{
	if (olpc_platform_info.ecver > 0x44) {
		if (ec_byte & (BAT_STAT_CHARGING | BAT_STAT_TRICKLE))
			val->intval = POWER_SUPPLY_STATUS_CHARGING;
		else if (ec_byte & BAT_STAT_DISCHARGING)
			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
		else if (ec_byte & BAT_STAT_FULL)
			val->intval = POWER_SUPPLY_STATUS_FULL;
		else /* er,... */
			val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
	} else {
		/* Older EC didn't report charge/discharge bits */
		if (!(ec_byte & BAT_STAT_AC)) /* No AC means discharging */
			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
		else if (ec_byte & BAT_STAT_FULL)
			val->intval = POWER_SUPPLY_STATUS_FULL;
		else /* Not _necessarily_ true but EC doesn't tell all yet */
			val->intval = POWER_SUPPLY_STATUS_CHARGING;
	}

	return 0;
}

static int olpc_bat_get_health(union power_supply_propval *val)
{
	uint8_t ec_byte;
	int ret;

	ret = olpc_ec_cmd(EC_BAT_ERRCODE, NULL, 0, &ec_byte, 1);
	if (ret)
		return ret;

	switch (ec_byte) {
	case 0:
		val->intval = POWER_SUPPLY_HEALTH_GOOD;
		break;

	case BAT_ERR_OVERTEMP:
		val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
		break;

	case BAT_ERR_OVERVOLTAGE:
		val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
		break;

	case BAT_ERR_INFOFAIL:
	case BAT_ERR_OUT_OF_CONTROL:
	case BAT_ERR_ID_FAIL:
	case BAT_ERR_ACR_FAIL:
		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
		break;

	default:
		/* Eep. We don't know this failure code */
		ret = -EIO;
	}

	return ret;
}

static int olpc_bat_get_mfr(union power_supply_propval *val)
{
	uint8_t ec_byte;
	int ret;

	ec_byte = BAT_ADDR_MFR_TYPE;
	ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1);
	if (ret)
		return ret;

	switch (ec_byte >> 4) {
	case 1:
		val->strval = "Gold Peak";
		break;
	case 2:
		val->strval = "BYD";
		break;
	default:
		val->strval = "Unknown";
		break;
	}

	return ret;
}

static int olpc_bat_get_tech(union power_supply_propval *val)
{
	uint8_t ec_byte;
	int ret;

	ec_byte = BAT_ADDR_MFR_TYPE;
	ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1);
	if (ret)
		return ret;

	switch (ec_byte & 0xf) {
	case 1:
		val->intval = POWER_SUPPLY_TECHNOLOGY_NiMH;
		break;
	case 2:
		val->intval = POWER_SUPPLY_TECHNOLOGY_LiFe;
		break;
	default:
		val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
		break;
	}

	return ret;
}

static int olpc_bat_get_charge_full_design(union power_supply_propval *val)
{
	uint8_t ec_byte;
	union power_supply_propval tech;
	int ret, mfr;

	ret = olpc_bat_get_tech(&tech);
	if (ret)
		return ret;

	ec_byte = BAT_ADDR_MFR_TYPE;
	ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1);
	if (ret)
		return ret;

	mfr = ec_byte >> 4;

	switch (tech.intval) {
	case POWER_SUPPLY_TECHNOLOGY_NiMH:
		switch (mfr) {
		case 1: /* Gold Peak */
			val->intval = 3000000*.8;
			break;
		default:
			return -EIO;
		}
		break;

	case POWER_SUPPLY_TECHNOLOGY_LiFe:
		switch (mfr) {
		case 1: /* Gold Peak */
			val->intval = 2800000;
			break;
		case 2: /* BYD */
			val->intval = 3100000;
			break;
		default:
			return -EIO;
		}
		break;

	default:
		return -EIO;
	}

	return ret;
}

static int olpc_bat_get_charge_now(union power_supply_propval *val)
{
	uint8_t soc;
	union power_supply_propval full;
	int ret;

	ret = olpc_ec_cmd(EC_BAT_SOC, NULL, 0, &soc, 1);
	if (ret)
		return ret;

	ret = olpc_bat_get_charge_full_design(&full);
	if (ret)
		return ret;

	val->intval = soc * (full.intval / 100);
	return 0;
}

/*********************************************************************
 *		Battery properties
 *********************************************************************/
static int olpc_bat_get_property(struct power_supply *psy,
				 enum power_supply_property psp,
				 union power_supply_propval *val)
{
	int ret = 0;
	__be16 ec_word;
	uint8_t ec_byte;
	__be64 ser_buf;

	ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &ec_byte, 1);
	if (ret)
		return ret;

	/* Theoretically there's a race here -- the battery could be
	   removed immediately after we check whether it's present, and
	   then we query for some other property of the now-absent battery.
	   It doesn't matter though -- the EC will return the last-known
	   information, and it's as if we just ran that _little_ bit faster
	   and managed to read it out before the battery went away. */
	if (!(ec_byte & (BAT_STAT_PRESENT | BAT_STAT_TRICKLE)) &&
			psp != POWER_SUPPLY_PROP_PRESENT)
		return -ENODEV;

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		ret = olpc_bat_get_status(val, ec_byte);
		if (ret)
			return ret;
		break;
	case POWER_SUPPLY_PROP_CHARGE_TYPE:
		if (ec_byte & BAT_STAT_TRICKLE)
			val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
		else if (ec_byte & BAT_STAT_CHARGING)
			val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
		else
			val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
		break;
	case POWER_SUPPLY_PROP_PRESENT:
		val->intval = !!(ec_byte & (BAT_STAT_PRESENT |
					    BAT_STAT_TRICKLE));
		break;

	case POWER_SUPPLY_PROP_HEALTH:
		if (ec_byte & BAT_STAT_DESTROY)
			val->intval = POWER_SUPPLY_HEALTH_DEAD;
		else {
			ret = olpc_bat_get_health(val);
			if (ret)
				return ret;
		}
		break;

	case POWER_SUPPLY_PROP_MANUFACTURER:
		ret = olpc_bat_get_mfr(val);
		if (ret)
			return ret;
		break;
	case POWER_SUPPLY_PROP_TECHNOLOGY:
		ret = olpc_bat_get_tech(val);
		if (ret)
			return ret;
		break;
	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
		ret = olpc_ec_cmd(EC_BAT_VOLTAGE, NULL, 0, (void *)&ec_word, 2);
		if (ret)
			return ret;

		val->intval = (s16)be16_to_cpu(ec_word) * 9760L / 32;
		break;
	case POWER_SUPPLY_PROP_CURRENT_AVG:
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		ret = olpc_ec_cmd(EC_BAT_CURRENT, NULL, 0, (void *)&ec_word, 2);
		if (ret)
			return ret;

		val->intval = (s16)be16_to_cpu(ec_word) * 15625L / 120;
		break;
	case POWER_SUPPLY_PROP_CAPACITY:
		ret = olpc_ec_cmd(EC_BAT_SOC, NULL, 0, &ec_byte, 1);
		if (ret)
			return ret;
		val->intval = ec_byte;
		break;
	case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
		if (ec_byte & BAT_STAT_FULL)
			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
		else if (ec_byte & BAT_STAT_LOW)
			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
		else
			val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
		break;
	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
		ret = olpc_bat_get_charge_full_design(val);
		if (ret)
			return ret;
		break;
	case POWER_SUPPLY_PROP_CHARGE_NOW:
		ret = olpc_bat_get_charge_now(val);
		if (ret)
			return ret;
		break;
	case POWER_SUPPLY_PROP_TEMP:
		ret = olpc_ec_cmd(EC_BAT_TEMP, NULL, 0, (void *)&ec_word, 2);
		if (ret)
			return ret;

		val->intval = (s16)be16_to_cpu(ec_word) * 100 / 256;
		break;
	case POWER_SUPPLY_PROP_TEMP_AMBIENT:
		ret = olpc_ec_cmd(EC_AMB_TEMP, NULL, 0, (void *)&ec_word, 2);
		if (ret)
			return ret;

		val->intval = (int)be16_to_cpu(ec_word) * 100 / 256;
		break;
	case POWER_SUPPLY_PROP_CHARGE_COUNTER:
		ret = olpc_ec_cmd(EC_BAT_ACR, NULL, 0, (void *)&ec_word, 2);
		if (ret)
			return ret;

		val->intval = (s16)be16_to_cpu(ec_word) * 6250 / 15;
		break;
	case POWER_SUPPLY_PROP_SERIAL_NUMBER:
		ret = olpc_ec_cmd(EC_BAT_SERIAL, NULL, 0, (void *)&ser_buf, 8);
		if (ret)
			return ret;

		sprintf(bat_serial, "%016llx", (long long)be64_to_cpu(ser_buf));
		val->strval = bat_serial;
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static enum power_supply_property olpc_xo1_bat_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_CHARGE_TYPE,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_VOLTAGE_AVG,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_AVG,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
	POWER_SUPPLY_PROP_CHARGE_NOW,
	POWER_SUPPLY_PROP_TEMP,
	POWER_SUPPLY_PROP_TEMP_AMBIENT,
	POWER_SUPPLY_PROP_MANUFACTURER,
	POWER_SUPPLY_PROP_SERIAL_NUMBER,
	POWER_SUPPLY_PROP_CHARGE_COUNTER,
};

/* XO-1.5 does not have ambient temperature property */
static enum power_supply_property olpc_xo15_bat_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_CHARGE_TYPE,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_VOLTAGE_AVG,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_AVG,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
	POWER_SUPPLY_PROP_CHARGE_NOW,
	POWER_SUPPLY_PROP_TEMP,
	POWER_SUPPLY_PROP_MANUFACTURER,
	POWER_SUPPLY_PROP_SERIAL_NUMBER,
	POWER_SUPPLY_PROP_CHARGE_COUNTER,
};

/* EEPROM reading goes completely around the power_supply API, sadly */

#define EEPROM_START	0x20
#define EEPROM_END	0x80
#define EEPROM_SIZE	(EEPROM_END - EEPROM_START)

static ssize_t olpc_bat_eeprom_read(struct file *filp, struct kobject *kobj,
		struct bin_attribute *attr, char *buf, loff_t off, size_t count)
{
	uint8_t ec_byte;
	int ret;
	int i;

	if (off >= EEPROM_SIZE)
		return 0;
	if (off + count > EEPROM_SIZE)
		count = EEPROM_SIZE - off;

	for (i = 0; i < count; i++) {
		ec_byte = EEPROM_START + off + i;
		ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &buf[i], 1);
		if (ret) {
			pr_err("olpc-battery: "
			       "EC_BAT_EEPROM cmd @ 0x%x failed - %d!\n",
			       ec_byte, ret);
			return -EIO;
		}
	}

	return count;
}

static struct bin_attribute olpc_bat_eeprom = {
	.attr = {
		.name = "eeprom",
		.mode = S_IRUGO,
	},
	.size = 0,
	.read = olpc_bat_eeprom_read,
};

/* Allow userspace to see the specific error value pulled from the EC */

static ssize_t olpc_bat_error_read(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	uint8_t ec_byte;
	ssize_t ret;

	ret = olpc_ec_cmd(EC_BAT_ERRCODE, NULL, 0, &ec_byte, 1);
	if (ret < 0)
		return ret;

	return sprintf(buf, "%d\n", ec_byte);
}

static struct device_attribute olpc_bat_error = {
	.attr = {
		.name = "error",
		.mode = S_IRUGO,
	},
	.show = olpc_bat_error_read,
};

/*********************************************************************
 *		Initialisation
 *********************************************************************/

static struct power_supply olpc_bat = {
	.name = "olpc-battery",
	.get_property = olpc_bat_get_property,
	.use_for_apm = 1,
};

static int olpc_battery_suspend(struct platform_device *pdev,
				pm_message_t state)
{
	if (device_may_wakeup(olpc_ac.dev))
		olpc_ec_wakeup_set(EC_SCI_SRC_ACPWR);
	else
		olpc_ec_wakeup_clear(EC_SCI_SRC_ACPWR);

	if (device_may_wakeup(olpc_bat.dev))
		olpc_ec_wakeup_set(EC_SCI_SRC_BATTERY | EC_SCI_SRC_BATSOC
				   | EC_SCI_SRC_BATERR);
	else
		olpc_ec_wakeup_clear(EC_SCI_SRC_BATTERY | EC_SCI_SRC_BATSOC
				     | EC_SCI_SRC_BATERR);

	return 0;
}

static int __devinit olpc_battery_probe(struct platform_device *pdev)
{
	int ret;
	uint8_t status;

	/*
	 * We've seen a number of EC protocol changes; this driver requires
	 * the latest EC protocol, supported by 0x44 and above.
	 */
	if (olpc_platform_info.ecver < 0x44) {
		printk(KERN_NOTICE "OLPC EC version 0x%02x too old for "
			"battery driver.\n", olpc_platform_info.ecver);
		return -ENXIO;
	}

	ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1);
	if (ret)
		return ret;

	/* Ignore the status. It doesn't actually matter */

	ret = power_supply_register(&pdev->dev, &olpc_ac);
	if (ret)
		return ret;

	if (olpc_board_at_least(olpc_board_pre(0xd0))) { /* XO-1.5 */
		olpc_bat.properties = olpc_xo15_bat_props;
		olpc_bat.num_properties = ARRAY_SIZE(olpc_xo15_bat_props);
	} else { /* XO-1 */
		olpc_bat.properties = olpc_xo1_bat_props;
		olpc_bat.num_properties = ARRAY_SIZE(olpc_xo1_bat_props);
	}

	ret = power_supply_register(&pdev->dev, &olpc_bat);
	if (ret)
		goto battery_failed;

	ret = device_create_bin_file(olpc_bat.dev, &olpc_bat_eeprom);
	if (ret)
		goto eeprom_failed;

	ret = device_create_file(olpc_bat.dev, &olpc_bat_error);
	if (ret)
		goto error_failed;

	if (olpc_ec_wakeup_available()) {
		device_set_wakeup_capable(olpc_ac.dev, true);
		device_set_wakeup_capable(olpc_bat.dev, true);
	}

	return 0;

error_failed:
	device_remove_bin_file(olpc_bat.dev, &olpc_bat_eeprom);
eeprom_failed:
	power_supply_unregister(&olpc_bat);
battery_failed:
	power_supply_unregister(&olpc_ac);
	return ret;
}

static int __devexit olpc_battery_remove(struct platform_device *pdev)
{
	device_remove_file(olpc_bat.dev, &olpc_bat_error);
	device_remove_bin_file(olpc_bat.dev, &olpc_bat_eeprom);
	power_supply_unregister(&olpc_bat);
	power_supply_unregister(&olpc_ac);
	return 0;
}

static const struct of_device_id olpc_battery_ids[] __devinitconst = {
	{ .compatible = "olpc,xo1-battery" },
	{}
};
MODULE_DEVICE_TABLE(of, olpc_battery_ids);

static struct platform_driver olpc_battery_driver = {
	.driver = {
		.name = "olpc-battery",
		.owner = THIS_MODULE,
		.of_match_table = olpc_battery_ids,
	},
	.probe = olpc_battery_probe,
	.remove = __devexit_p(olpc_battery_remove),
	.suspend = olpc_battery_suspend,
};

module_platform_driver(olpc_battery_driver);

MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Battery driver for One Laptop Per Child 'XO' machine");
Commit	Line	Data
fb972873 DW	1	/*
	2	* Battery driver for One Laptop Per Child board.
	3	*
690e85a3	4	* Copyright © 2006-2010 David Woodhouse <dwmw2@infradead.org>
fb972873 DW	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10
04a820ea	11	#include <linux/kernel.h>
fb972873	12	#include <linux/module.h>
144bbeae	13	#include <linux/types.h>
fb972873	14	#include <linux/err.h>
144bbeae	15	#include <linux/device.h>
fb972873 DW	16	#include <linux/platform_device.h>
	17	#include <linux/power_supply.h>
	18	#include <linux/jiffies.h>
	19	#include <linux/sched.h>
	20	#include <asm/olpc.h>
	21
	22
	23	#define EC_BAT_VOLTAGE 0x10 /* uint16_t, 9.76/32, mV /
	24	#define EC_BAT_CURRENT 0x11 /* int16_t, 15.625/120, mA /
75d88079	25	#define EC_BAT_ACR 0x12 /* int16_t, 6250/15, µAh /
fb972873 DW	26	#define EC_BAT_TEMP 0x13 /* uint16_t, 100/256, °C /
	27	#define EC_AMB_TEMP 0x14 /* uint16_t, 100/256, °C /
	28	#define EC_BAT_STATUS 0x15 /* uint8_t, bitmask */
	29	#define EC_BAT_SOC 0x16 /* uint8_t, percentage */
	30	#define EC_BAT_SERIAL 0x17 /* uint8_t[6] */
	31	#define EC_BAT_EEPROM 0x18 /* uint8_t adr as input, uint8_t output */
	32	#define EC_BAT_ERRCODE 0x1f /* uint8_t, bitmask */
	33
	34	#define BAT_STAT_PRESENT 0x01
	35	#define BAT_STAT_FULL 0x02
	36	#define BAT_STAT_LOW 0x04
	37	#define BAT_STAT_DESTROY 0x08
	38	#define BAT_STAT_AC 0x10
	39	#define BAT_STAT_CHARGING 0x20
	40	#define BAT_STAT_DISCHARGING 0x40
8f7e5798	41	#define BAT_STAT_TRICKLE 0x80
fb972873 DW	42
	43	#define BAT_ERR_INFOFAIL 0x02
	44	#define BAT_ERR_OVERVOLTAGE 0x04
	45	#define BAT_ERR_OVERTEMP 0x05
	46	#define BAT_ERR_GAUGESTOP 0x06
	47	#define BAT_ERR_OUT_OF_CONTROL 0x07
	48	#define BAT_ERR_ID_FAIL 0x09
	49	#define BAT_ERR_ACR_FAIL 0x10
	50
	51	#define BAT_ADDR_MFR_TYPE 0x5F
	52
	53	/*********************************************************************
	54	* Power
	55	*********************************************************************/
	56
	57	static int olpc_ac_get_prop(struct power_supply *psy,
	58	enum power_supply_property psp,
	59	union power_supply_propval *val)
	60	{
	61	int ret = 0;
	62	uint8_t status;
	63
	64	switch (psp) {
	65	case POWER_SUPPLY_PROP_ONLINE:
	66	ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1);
	67	if (ret)
	68	return ret;
	69
	70	val->intval = !!(status & BAT_STAT_AC);
	71	break;
	72	default:
	73	ret = -EINVAL;
	74	break;
	75	}
	76	return ret;
	77	}
	78
	79	static enum power_supply_property olpc_ac_props[] = {
	80	POWER_SUPPLY_PROP_ONLINE,
	81	};
	82
	83	static struct power_supply olpc_ac = {
	84	.name = "olpc-ac",
	85	.type = POWER_SUPPLY_TYPE_MAINS,
	86	.properties = olpc_ac_props,
	87	.num_properties = ARRAY_SIZE(olpc_ac_props),
	88	.get_property = olpc_ac_get_prop,
	89	};
	90
1ca5b9d2 DW	91	static char bat_serial[17]; /* Ick */
1ca5b9d2 DW	92
b2bd8a3b AS	93	static int olpc_bat_get_status(union power_supply_propval *val, uint8_t ec_byte)
	94	{
	95	if (olpc_platform_info.ecver > 0x44) {
8f7e5798	96	if (ec_byte & (BAT_STAT_CHARGING \| BAT_STAT_TRICKLE))
b2bd8a3b AS	97	val->intval = POWER_SUPPLY_STATUS_CHARGING;
	98	else if (ec_byte & BAT_STAT_DISCHARGING)
	99	val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
	100	else if (ec_byte & BAT_STAT_FULL)
	101	val->intval = POWER_SUPPLY_STATUS_FULL;
	102	else /* er,... */
	103	val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
	104	} else {
	105	/* Older EC didn't report charge/discharge bits */
	106	if (!(ec_byte & BAT_STAT_AC)) /* No AC means discharging */
	107	val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
	108	else if (ec_byte & BAT_STAT_FULL)
	109	val->intval = POWER_SUPPLY_STATUS_FULL;
	110	else /* Not _necessarily_ true but EC doesn't tell all yet */
	111	val->intval = POWER_SUPPLY_STATUS_CHARGING;
	112	}
	113
	114	return 0;
	115	}
	116
	117	static int olpc_bat_get_health(union power_supply_propval *val)
	118	{
	119	uint8_t ec_byte;
	120	int ret;
	121
	122	ret = olpc_ec_cmd(EC_BAT_ERRCODE, NULL, 0, &ec_byte, 1);
	123	if (ret)
	124	return ret;
	125
	126	switch (ec_byte) {
	127	case 0:
	128	val->intval = POWER_SUPPLY_HEALTH_GOOD;
	129	break;
	130
	131	case BAT_ERR_OVERTEMP:
	132	val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
	133	break;
	134
	135	case BAT_ERR_OVERVOLTAGE:
	136	val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
	137	break;
	138
	139	case BAT_ERR_INFOFAIL:
	140	case BAT_ERR_OUT_OF_CONTROL:
	141	case BAT_ERR_ID_FAIL:
	142	case BAT_ERR_ACR_FAIL:
	143	val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
	144	break;
	145
	146	default:
	147	/* Eep. We don't know this failure code */
	148	ret = -EIO;
	149	}
	150
	151	return ret;
	152	}
	153
	154	static int olpc_bat_get_mfr(union power_supply_propval *val)
	155	{
	156	uint8_t ec_byte;
	157	int ret;
	158
	159	ec_byte = BAT_ADDR_MFR_TYPE;
	160	ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1);
161	if (ret)
162	return ret;
163
164	switch (ec_byte >> 4) {
165	case 1:
166	val->strval = "Gold Peak";
167	break;
168	case 2:
169	val->strval = "BYD";
170	break;
171	default:
172	val->strval = "Unknown";
173	break;
174	}
175
176	return ret;
177	}
178
179	static int olpc_bat_get_tech(union power_supply_propval *val)
180	{
181	uint8_t ec_byte;
182	int ret;
183
184	ec_byte = BAT_ADDR_MFR_TYPE;
185	ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1);
186	if (ret)
187	return ret;
188
189	switch (ec_byte & 0xf) {
190	case 1:
191	val->intval = POWER_SUPPLY_TECHNOLOGY_NiMH;
192	break;
193	case 2:
194	val->intval = POWER_SUPPLY_TECHNOLOGY_LiFe;
195	break;
196	default:
197	val->intval = POWER_SUPPLY_TECHNOLOGY_UNKNOWN;
198	break;
199	}
200
201	return ret;
202	}
203
b202a5e6 SS	204	static int olpc_bat_get_charge_full_design(union power_supply_propval *val)
	205	{
	206	uint8_t ec_byte;
	207	union power_supply_propval tech;
	208	int ret, mfr;
	209
	210	ret = olpc_bat_get_tech(&tech);
	211	if (ret)
	212	return ret;
	213
	214	ec_byte = BAT_ADDR_MFR_TYPE;
	215	ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &ec_byte, 1);
	216	if (ret)
	217	return ret;
	218
	219	mfr = ec_byte >> 4;
	220
	221	switch (tech.intval) {
	222	case POWER_SUPPLY_TECHNOLOGY_NiMH:
	223	switch (mfr) {
	224	case 1: /* Gold Peak */
	225	val->intval = 3000000*.8;
	226	break;
	227	default:
	228	return -EIO;
	229	}
	230	break;
	231
	232	case POWER_SUPPLY_TECHNOLOGY_LiFe:
	233	switch (mfr) {
	234	case 1: /* Gold Peak */
	235	val->intval = 2800000;
	236	break;
	237	case 2: /* BYD */
	238	val->intval = 3100000;
	239	break;
	240	default:
	241	return -EIO;
	242	}
	243	break;
	244
	245	default:
	246	return -EIO;
	247	}
	248
	249	return ret;
	250	}
	251
20fd9830 SS	252	static int olpc_bat_get_charge_now(union power_supply_propval *val)
	253	{
	254	uint8_t soc;
	255	union power_supply_propval full;
	256	int ret;
	257
	258	ret = olpc_ec_cmd(EC_BAT_SOC, NULL, 0, &soc, 1);
	259	if (ret)
	260	return ret;
	261
	262	ret = olpc_bat_get_charge_full_design(&full);
	263	if (ret)
	264	return ret;
	265
	266	val->intval = soc * (full.intval / 100);
	267	return 0;
	268	}
	269
fb972873 DW	270	/*********************************************************************
	271	* Battery properties
	272	*********************************************************************/
	273	static int olpc_bat_get_property(struct power_supply *psy,
	274	enum power_supply_property psp,
	275	union power_supply_propval *val)
	276	{
	277	int ret = 0;
8e9c7716	278	__be16 ec_word;
fb972873	279	uint8_t ec_byte;
8e9c7716	280	__be64 ser_buf;
fb972873 DW	281
	282	ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &ec_byte, 1);
	283	if (ret)
	284	return ret;
	285
	286	/* Theoretically there's a race here -- the battery could be
	287	removed immediately after we check whether it's present, and
	288	then we query for some other property of the now-absent battery.
	289	It doesn't matter though -- the EC will return the last-known
	290	information, and it's as if we just ran that _little_ bit faster
	291	and managed to read it out before the battery went away. */
8f7e5798 AS	292	if (!(ec_byte & (BAT_STAT_PRESENT \| BAT_STAT_TRICKLE)) &&
8f7e5798 AS	293	psp != POWER_SUPPLY_PROP_PRESENT)
fb972873 DW	294	return -ENODEV;
	295
	296	switch (psp) {
	297	case POWER_SUPPLY_PROP_STATUS:
b2bd8a3b AS	298	ret = olpc_bat_get_status(val, ec_byte);
	299	if (ret)
	300	return ret;
	301	break;
ee8076ed AS	302	case POWER_SUPPLY_PROP_CHARGE_TYPE:
	303	if (ec_byte & BAT_STAT_TRICKLE)
	304	val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
	305	else if (ec_byte & BAT_STAT_CHARGING)
	306	val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
	307	else
	308	val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
	309	break;
fb972873	310	case POWER_SUPPLY_PROP_PRESENT:
8f7e5798 AS	311	val->intval = !!(ec_byte & (BAT_STAT_PRESENT \|
8f7e5798 AS	312	BAT_STAT_TRICKLE));
fb972873 DW	313	break;
	314
	315	case POWER_SUPPLY_PROP_HEALTH:
	316	if (ec_byte & BAT_STAT_DESTROY)
	317	val->intval = POWER_SUPPLY_HEALTH_DEAD;
	318	else {
b2bd8a3b	319	ret = olpc_bat_get_health(val);
fb972873 DW	320	if (ret)
fb972873 DW	321	return ret;
fb972873 DW	322	}
	323	break;
	324
	325	case POWER_SUPPLY_PROP_MANUFACTURER:
b2bd8a3b	326	ret = olpc_bat_get_mfr(val);
fb972873 DW	327	if (ret)
fb972873 DW	328	return ret;
fb972873 DW	329	break;
fb972873 DW	330	case POWER_SUPPLY_PROP_TECHNOLOGY:
b2bd8a3b	331	ret = olpc_bat_get_tech(val);
fb972873 DW	332	if (ret)
fb972873 DW	333	return ret;
fb972873 DW	334	break;
fb972873 DW	335	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
22fadd76	336	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
fb972873 DW	337	ret = olpc_ec_cmd(EC_BAT_VOLTAGE, NULL, 0, (void *)&ec_word, 2);
	338	if (ret)
	339	return ret;
	340
7cfbb294	341	val->intval = (s16)be16_to_cpu(ec_word) * 9760L / 32;
fb972873 DW	342	break;
fb972873 DW	343	case POWER_SUPPLY_PROP_CURRENT_AVG:
22fadd76	344	case POWER_SUPPLY_PROP_CURRENT_NOW:
fb972873 DW	345	ret = olpc_ec_cmd(EC_BAT_CURRENT, NULL, 0, (void *)&ec_word, 2);
	346	if (ret)
	347	return ret;
	348
7cfbb294	349	val->intval = (s16)be16_to_cpu(ec_word) * 15625L / 120;
fb972873 DW	350	break;
	351	case POWER_SUPPLY_PROP_CAPACITY:
	352	ret = olpc_ec_cmd(EC_BAT_SOC, NULL, 0, &ec_byte, 1);
	353	if (ret)
	354	return ret;
	355	val->intval = ec_byte;
	356	break;
b294a290 AS	357	case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
	358	if (ec_byte & BAT_STAT_FULL)
	359	val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
	360	else if (ec_byte & BAT_STAT_LOW)
	361	val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
	362	else
	363	val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
	364	break;
b202a5e6 SS	365	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
	366	ret = olpc_bat_get_charge_full_design(val);
	367	if (ret)
	368	return ret;
	369	break;
20fd9830 SS	370	case POWER_SUPPLY_PROP_CHARGE_NOW:
	371	ret = olpc_bat_get_charge_now(val);
	372	if (ret)
	373	return ret;
	374	break;
fb972873 DW	375	case POWER_SUPPLY_PROP_TEMP:
	376	ret = olpc_ec_cmd(EC_BAT_TEMP, NULL, 0, (void *)&ec_word, 2);
	377	if (ret)
	378	return ret;
8e9c7716	379
7cfbb294	380	val->intval = (s16)be16_to_cpu(ec_word) * 100 / 256;
fb972873 DW	381	break;
	382	case POWER_SUPPLY_PROP_TEMP_AMBIENT:
	383	ret = olpc_ec_cmd(EC_AMB_TEMP, NULL, 0, (void *)&ec_word, 2);
	384	if (ret)
	385	return ret;
	386
8e9c7716	387	val->intval = (int)be16_to_cpu(ec_word) * 100 / 256;
fb972873	388	break;
8e552c36 AS	389	case POWER_SUPPLY_PROP_CHARGE_COUNTER:
	390	ret = olpc_ec_cmd(EC_BAT_ACR, NULL, 0, (void *)&ec_word, 2);
	391	if (ret)
	392	return ret;
	393
7cfbb294	394	val->intval = (s16)be16_to_cpu(ec_word) * 6250 / 15;
8e552c36	395	break;
1ca5b9d2 DW	396	case POWER_SUPPLY_PROP_SERIAL_NUMBER:
	397	ret = olpc_ec_cmd(EC_BAT_SERIAL, NULL, 0, (void *)&ser_buf, 8);
	398	if (ret)
	399	return ret;
	400
	401	sprintf(bat_serial, "%016llx", (long long)be64_to_cpu(ser_buf));
	402	val->strval = bat_serial;
	403	break;
fb972873 DW	404	default:
	405	ret = -EINVAL;
	406	break;
	407	}
	408
	409	return ret;
	410	}
	411
c566d299	412	static enum power_supply_property olpc_xo1_bat_props[] = {
fb972873	413	POWER_SUPPLY_PROP_STATUS,
ee8076ed	414	POWER_SUPPLY_PROP_CHARGE_TYPE,
fb972873 DW	415	POWER_SUPPLY_PROP_PRESENT,
	416	POWER_SUPPLY_PROP_HEALTH,
	417	POWER_SUPPLY_PROP_TECHNOLOGY,
	418	POWER_SUPPLY_PROP_VOLTAGE_AVG,
22fadd76	419	POWER_SUPPLY_PROP_VOLTAGE_NOW,
fb972873	420	POWER_SUPPLY_PROP_CURRENT_AVG,
22fadd76	421	POWER_SUPPLY_PROP_CURRENT_NOW,
fb972873	422	POWER_SUPPLY_PROP_CAPACITY,
b294a290	423	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
b202a5e6	424	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
20fd9830	425	POWER_SUPPLY_PROP_CHARGE_NOW,
fb972873 DW	426	POWER_SUPPLY_PROP_TEMP,
	427	POWER_SUPPLY_PROP_TEMP_AMBIENT,
	428	POWER_SUPPLY_PROP_MANUFACTURER,
1ca5b9d2	429	POWER_SUPPLY_PROP_SERIAL_NUMBER,
8e552c36	430	POWER_SUPPLY_PROP_CHARGE_COUNTER,
fb972873 DW	431	};
fb972873 DW	432
c566d299 DD	433	/* XO-1.5 does not have ambient temperature property */
	434	static enum power_supply_property olpc_xo15_bat_props[] = {
	435	POWER_SUPPLY_PROP_STATUS,
	436	POWER_SUPPLY_PROP_CHARGE_TYPE,
	437	POWER_SUPPLY_PROP_PRESENT,
	438	POWER_SUPPLY_PROP_HEALTH,
	439	POWER_SUPPLY_PROP_TECHNOLOGY,
	440	POWER_SUPPLY_PROP_VOLTAGE_AVG,
bf542a4e	441	POWER_SUPPLY_PROP_VOLTAGE_NOW,
c566d299	442	POWER_SUPPLY_PROP_CURRENT_AVG,
bf542a4e	443	POWER_SUPPLY_PROP_CURRENT_NOW,
c566d299 DD	444	POWER_SUPPLY_PROP_CAPACITY,
c566d299 DD	445	POWER_SUPPLY_PROP_CAPACITY_LEVEL,
bf542a4e SS	446	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
bf542a4e SS	447	POWER_SUPPLY_PROP_CHARGE_NOW,
c566d299 DD	448	POWER_SUPPLY_PROP_TEMP,
	449	POWER_SUPPLY_PROP_MANUFACTURER,
	450	POWER_SUPPLY_PROP_SERIAL_NUMBER,
	451	POWER_SUPPLY_PROP_CHARGE_COUNTER,
	452	};
	453
d7eb9e36 AS	454	/* EEPROM reading goes completely around the power_supply API, sadly */
	455
	456	#define EEPROM_START 0x20
	457	#define EEPROM_END 0x80
	458	#define EEPROM_SIZE (EEPROM_END - EEPROM_START)
	459
2c3c8bea	460	static ssize_t olpc_bat_eeprom_read(struct file filp, struct kobject kobj,
d7eb9e36 AS	461	struct bin_attribute attr, char buf, loff_t off, size_t count)
	462	{
	463	uint8_t ec_byte;
04a820ea AS	464	int ret;
04a820ea AS	465	int i;
d7eb9e36 AS	466
	467	if (off >= EEPROM_SIZE)
	468	return 0;
	469	if (off + count > EEPROM_SIZE)
	470	count = EEPROM_SIZE - off;
	471
04a820ea AS	472	for (i = 0; i < count; i++) {
	473	ec_byte = EEPROM_START + off + i;
	474	ret = olpc_ec_cmd(EC_BAT_EEPROM, &ec_byte, 1, &buf[i], 1);
d7eb9e36	475	if (ret) {
04a820ea AS	476	pr_err("olpc-battery: "
	477	"EC_BAT_EEPROM cmd @ 0x%x failed - %d!\n",
	478	ec_byte, ret);
d7eb9e36 AS	479	return -EIO;
	480	}
	481	}
	482
	483	return count;
	484	}
	485
	486	static struct bin_attribute olpc_bat_eeprom = {
	487	.attr = {
	488	.name = "eeprom",
	489	.mode = S_IRUGO,
d7eb9e36 AS	490	},
	491	.size = 0,
	492	.read = olpc_bat_eeprom_read,
	493	};
	494
144bbeae AS	495	/* Allow userspace to see the specific error value pulled from the EC */
	496
	497	static ssize_t olpc_bat_error_read(struct device *dev,
	498	struct device_attribute attr, char buf)
	499	{
	500	uint8_t ec_byte;
	501	ssize_t ret;
	502
	503	ret = olpc_ec_cmd(EC_BAT_ERRCODE, NULL, 0, &ec_byte, 1);
	504	if (ret < 0)
	505	return ret;
	506
	507	return sprintf(buf, "%d\n", ec_byte);
	508	}
	509
	510	static struct device_attribute olpc_bat_error = {
	511	.attr = {
	512	.name = "error",
	513	.mode = S_IRUGO,
	514	},
	515	.show = olpc_bat_error_read,
	516	};
	517
fb972873 DW	518	/*********************************************************************
	519	* Initialisation
	520	*********************************************************************/
	521
fb972873	522	static struct power_supply olpc_bat = {
c3503fd0	523	.name = "olpc-battery",
fb972873 DW	524	.get_property = olpc_bat_get_property,
	525	.use_for_apm = 1,
	526	};
	527
cae659af DD	528	static int olpc_battery_suspend(struct platform_device *pdev,
	529	pm_message_t state)
	530	{
	531	if (device_may_wakeup(olpc_ac.dev))
	532	olpc_ec_wakeup_set(EC_SCI_SRC_ACPWR);
	533	else
	534	olpc_ec_wakeup_clear(EC_SCI_SRC_ACPWR);
	535
	536	if (device_may_wakeup(olpc_bat.dev))
	537	olpc_ec_wakeup_set(EC_SCI_SRC_BATTERY \| EC_SCI_SRC_BATSOC
	538	\| EC_SCI_SRC_BATERR);
	539	else
	540	olpc_ec_wakeup_clear(EC_SCI_SRC_BATTERY \| EC_SCI_SRC_BATSOC
	541	\| EC_SCI_SRC_BATERR);
	542
	543	return 0;
	544	}
	545
c3503fd0	546	static int __devinit olpc_battery_probe(struct platform_device *pdev)
fb972873	547	{
c3503fd0	548	int ret;
fb972873 DW	549	uint8_t status;
fb972873 DW	550
484d6d50 AS	551	/*
	552	* We've seen a number of EC protocol changes; this driver requires
	553	* the latest EC protocol, supported by 0x44 and above.
	554	*/
	555	if (olpc_platform_info.ecver < 0x44) {
	556	printk(KERN_NOTICE "OLPC EC version 0x%02x too old for "
	557	"battery driver.\n", olpc_platform_info.ecver);
fb972873 DW	558	return -ENXIO;
	559	}
	560
	561	ret = olpc_ec_cmd(EC_BAT_STATUS, NULL, 0, &status, 1);
	562	if (ret)
	563	return ret;
	564
	565	/* Ignore the status. It doesn't actually matter */
	566
c3503fd0	567	ret = power_supply_register(&pdev->dev, &olpc_ac);
fb972873	568	if (ret)
c3503fd0	569	return ret;
fb972873	570
c566d299 DD	571	if (olpc_board_at_least(olpc_board_pre(0xd0))) { /* XO-1.5 */
	572	olpc_bat.properties = olpc_xo15_bat_props;
	573	olpc_bat.num_properties = ARRAY_SIZE(olpc_xo15_bat_props);
	574	} else { /* XO-1 */
	575	olpc_bat.properties = olpc_xo1_bat_props;
	576	olpc_bat.num_properties = ARRAY_SIZE(olpc_xo1_bat_props);
	577	}
fb972873	578
c3503fd0	579	ret = power_supply_register(&pdev->dev, &olpc_bat);
fb972873 DW	580	if (ret)
	581	goto battery_failed;
	582
d7eb9e36 AS	583	ret = device_create_bin_file(olpc_bat.dev, &olpc_bat_eeprom);
	584	if (ret)
	585	goto eeprom_failed;
	586
144bbeae AS	587	ret = device_create_file(olpc_bat.dev, &olpc_bat_error);
	588	if (ret)
	589	goto error_failed;
	590
cae659af DD	591	if (olpc_ec_wakeup_available()) {
	592	device_set_wakeup_capable(olpc_ac.dev, true);
	593	device_set_wakeup_capable(olpc_bat.dev, true);
	594	}
	595
c3503fd0	596	return 0;
fb972873	597
144bbeae AS	598	error_failed:
144bbeae AS	599	device_remove_bin_file(olpc_bat.dev, &olpc_bat_eeprom);
d7eb9e36 AS	600	eeprom_failed:
d7eb9e36 AS	601	power_supply_unregister(&olpc_bat);
fb972873 DW	602	battery_failed:
fb972873 DW	603	power_supply_unregister(&olpc_ac);
fb972873 DW	604	return ret;
	605	}
	606
c3503fd0	607	static int __devexit olpc_battery_remove(struct platform_device *pdev)
fb972873	608	{
144bbeae	609	device_remove_file(olpc_bat.dev, &olpc_bat_error);
d7eb9e36	610	device_remove_bin_file(olpc_bat.dev, &olpc_bat_eeprom);
fb972873 DW	611	power_supply_unregister(&olpc_bat);
fb972873 DW	612	power_supply_unregister(&olpc_ac);
c3503fd0	613	return 0;
fb972873 DW	614	}
fb972873 DW	615
c3503fd0 DD	616	static const struct of_device_id olpc_battery_ids[] __devinitconst = {
	617	{ .compatible = "olpc,xo1-battery" },
	618	{}
	619	};
	620	MODULE_DEVICE_TABLE(of, olpc_battery_ids);
	621
5519d00e	622	static struct platform_driver olpc_battery_driver = {
c3503fd0 DD	623	.driver = {
	624	.name = "olpc-battery",
	625	.owner = THIS_MODULE,
	626	.of_match_table = olpc_battery_ids,
	627	},
	628	.probe = olpc_battery_probe,
	629	.remove = __devexit_p(olpc_battery_remove),
cae659af	630	.suspend = olpc_battery_suspend,
c3503fd0 DD	631	};
c3503fd0 DD	632
300bac7f	633	module_platform_driver(olpc_battery_driver);
fb972873 DW	634
	635	MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
	636	MODULE_LICENSE("GPL");
	637	MODULE_DESCRIPTION("Battery driver for One Laptop Per Child 'XO' machine");