[linux-2.6-block.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 <linux/olpc-ec.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 const struct power_supply_desc olpc_ac_desc = {
	.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 struct power_supply *olpc_ac;

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, fall through */
		case 2: /* BYD */
			val->intval = 2800000;
			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;
}

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

	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 = 6000000;
			break;
		default:
			return -EIO;
		}
		break;

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

	default:
		return -EIO;
	}

	return ret;
}

/*********************************************************************
 *		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;
	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
		ret = olpc_bat_get_voltage_max_design(val);
		if (ret)
			return ret;
		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,
	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
};

/* 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,
	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
};

/* 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;

	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 = EEPROM_SIZE,
	.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_desc olpc_bat_desc = {
	.name = "olpc-battery",
	.get_property = olpc_bat_get_property,
	.use_for_apm = 1,
};

static struct power_supply *olpc_bat;

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 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 */

	olpc_ac = power_supply_register(&pdev->dev, &olpc_ac_desc, NULL);
	if (IS_ERR(olpc_ac))
		return PTR_ERR(olpc_ac);

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

	olpc_bat = power_supply_register(&pdev->dev, &olpc_bat_desc, NULL);
	if (IS_ERR(olpc_bat)) {
		ret = PTR_ERR(olpc_bat);
		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 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[] = {
	{ .compatible = "olpc,xo1-battery" },
	{}
};
MODULE_DEVICE_TABLE(of, olpc_battery_ids);

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