Commit 45352bbf authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.infradead.org/battery-2.6 

* git://git.infradead.org/battery-2.6:
  power_supply: Makefile cleanup
  bq27x00_battery: Add missing kfree(di->bus) in bq27x00_battery_remove()
  power_supply: Introduce maximum current property
  power_supply: Add types for USB chargers
  ds2782_battery: Fix units
  power_supply: Add driver for TWL4030/TPS65950 BCI charger
  bq20z75: Add support for more power supply properties
  wm831x_power: Add missing kfree(wm831x_power) in wm831x_power_remove()
  jz4740-battery: Add missing kfree(jz_battery) in jz_battery_remove()
  ds2760_battery: Add missing kfree(di) in ds2760_battery_remove()
  olpc_battery: Fix endian neutral breakage for s16 values
  ds2760_battery: Fix W1 and W1_SLAVE_DS2760 dependency
  pcf50633-charger: Add missing sysfs_remove_group()
  power_supply: Add driver for TI BQ20Z75 gas gauge IC
  wm831x_power: Remove duplicate chg mask
  omap: rx51: Add support for USB chargers
  power_supply: Add isp1704 charger detection driver
parents da62aa69 57894517

arch/arm/mach-omap2/board-rx51-peripherals.c

+5 −0
Original line number Diff line number Diff line
@@ -107,6 +107,10 @@ static struct spi_board_info rx51_peripherals_spi_board_info[] __initdata = { 
	},

};



static struct platform_device rx51_charger_device = {

	.name = "isp1704_charger",

};



#if defined(CONFIG_KEYBOARD_GPIO) || defined(CONFIG_KEYBOARD_GPIO_MODULE)



#define RX51_GPIO_CAMERA_LENS_COVER	110
@@ -919,5 +923,6 @@ void __init rx51_peripherals_init(void) 
	spi_register_board_info(rx51_peripherals_spi_board_info,

				ARRAY_SIZE(rx51_peripherals_spi_board_info));

	omap2_hsmmc_init(mmc);

	platform_device_register(&rx51_charger_device);

}

drivers/power/Kconfig

+21 −2
Original line number Diff line number Diff line
@@ -64,8 +64,7 @@ config TEST_POWER 


config BATTERY_DS2760

	tristate "DS2760 battery driver (HP iPAQ & others)"

	select W1

	select W1_SLAVE_DS2760

	depends on W1 && W1_SLAVE_DS2760

	help

	  Say Y here to enable support for batteries with ds2760 chip.
@@ -109,6 +108,13 @@ config BATTERY_WM97XX 
	help

	  Say Y to enable support for battery measured by WM97xx aux port.



config BATTERY_BQ20Z75

        tristate "TI BQ20z75 gas gauge"

        depends on I2C

        help

         Say Y to include support for TI BQ20z75 SBS-compliant

         gas gauge and protection IC.



config BATTERY_BQ27x00

	tristate "BQ27x00 battery driver"

	depends on I2C
@@ -166,4 +172,17 @@ config BATTERY_INTEL_MID 
	  Say Y here to enable the battery driver on Intel MID

	  platforms.



config CHARGER_ISP1704

	tristate "ISP1704 USB Charger Detection"

	depends on USB_OTG_UTILS

	help

	  Say Y to enable support for USB Charger Detection with

	  ISP1707/ISP1704 USB transceivers.



config CHARGER_TWL4030

	tristate "OMAP TWL4030 BCI charger driver"

	depends on TWL4030_CORE

	help

	  Say Y here to enable support for TWL4030 Battery Charge Interface.



endif # POWER_SUPPLY

drivers/power/Makefile

+7 −12
Original line number Diff line number Diff line 
power_supply-objs := power_supply_core.o

ccflags-$(CONFIG_POWER_SUPPLY_DEBUG) := -DDEBUG



ifeq ($(CONFIG_SYSFS),y)

power_supply-objs += power_supply_sysfs.o

endif



ifeq ($(CONFIG_LEDS_TRIGGERS),y)

power_supply-objs += power_supply_leds.o

endif



ifeq ($(CONFIG_POWER_SUPPLY_DEBUG),y)

EXTRA_CFLAGS += -DDEBUG

endif

power_supply-y				:= power_supply_core.o

power_supply-$(CONFIG_SYSFS)		+= power_supply_sysfs.o

power_supply-$(CONFIG_LEDS_TRIGGERS)	+= power_supply_leds.o



obj-$(CONFIG_POWER_SUPPLY)	+= power_supply.o
@@ -29,6 +21,7 @@ obj-$(CONFIG_BATTERY_OLPC) += olpc_battery.o 
obj-$(CONFIG_BATTERY_TOSA)	+= tosa_battery.o

obj-$(CONFIG_BATTERY_COLLIE)	+= collie_battery.o

obj-$(CONFIG_BATTERY_WM97XX)	+= wm97xx_battery.o

obj-$(CONFIG_BATTERY_BQ20Z75)	+= bq20z75.o

obj-$(CONFIG_BATTERY_BQ27x00)	+= bq27x00_battery.o

obj-$(CONFIG_BATTERY_DA9030)	+= da9030_battery.o

obj-$(CONFIG_BATTERY_MAX17040)	+= max17040_battery.o
@@ -37,3 +30,5 @@ obj-$(CONFIG_BATTERY_S3C_ADC) += s3c_adc_battery.o 
obj-$(CONFIG_CHARGER_PCF50633)	+= pcf50633-charger.o

obj-$(CONFIG_BATTERY_JZ4740)	+= jz4740-battery.o

obj-$(CONFIG_BATTERY_INTEL_MID)	+= intel_mid_battery.o

obj-$(CONFIG_CHARGER_ISP1704)	+= isp1704_charger.o

obj-$(CONFIG_CHARGER_TWL4030)	+= twl4030_charger.o

drivers/power/bq20z75.c

0 → 100644
+493 −0
Original line number Diff line number Diff line 
/*

 * Gas Gauge driver for TI's BQ20Z75

 *

 * Copyright (c) 2010, NVIDIA Corporation.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along

 * with this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 */



#include <linux/init.h>

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/err.h>

#include <linux/power_supply.h>

#include <linux/i2c.h>

#include <linux/slab.h>



enum {

	REG_MANUFACTURER_DATA,

	REG_TEMPERATURE,

	REG_VOLTAGE,

	REG_CURRENT,

	REG_CAPACITY,

	REG_TIME_TO_EMPTY,

	REG_TIME_TO_FULL,

	REG_STATUS,

	REG_CYCLE_COUNT,

	REG_SERIAL_NUMBER,

	REG_REMAINING_CAPACITY,

	REG_FULL_CHARGE_CAPACITY,

	REG_DESIGN_CAPACITY,

	REG_DESIGN_VOLTAGE,

};



/* manufacturer access defines */

#define MANUFACTURER_ACCESS_STATUS	0x0006

#define MANUFACTURER_ACCESS_SLEEP	0x0011



/* battery status value bits */

#define BATTERY_DISCHARGING		0x40

#define BATTERY_FULL_CHARGED		0x20

#define BATTERY_FULL_DISCHARGED		0x10



#define BQ20Z75_DATA(_psp, _addr, _min_value, _max_value) { \

	.psp = _psp, \

	.addr = _addr, \

	.min_value = _min_value, \

	.max_value = _max_value, \

}



static const struct bq20z75_device_data {

	enum power_supply_property psp;

	u8 addr;

	int min_value;

	int max_value;

} bq20z75_data[] = {

	[REG_MANUFACTURER_DATA] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_PRESENT, 0x00, 0, 65535),

	[REG_TEMPERATURE] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_TEMP, 0x08, 0, 65535),

	[REG_VOLTAGE] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_VOLTAGE_NOW, 0x09, 0, 20000),

	[REG_CURRENT] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_CURRENT_NOW, 0x0A, -32768,

			32767),

	[REG_CAPACITY] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0E, 0, 100),

	[REG_REMAINING_CAPACITY] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535),

	[REG_FULL_CHARGE_CAPACITY] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535),

	[REG_TIME_TO_EMPTY] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0,

			65535),

	[REG_TIME_TO_FULL] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 0x13, 0,

			65535),

	[REG_STATUS] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_STATUS, 0x16, 0, 65535),

	[REG_CYCLE_COUNT] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_CYCLE_COUNT, 0x17, 0, 65535),

	[REG_DESIGN_CAPACITY] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0,

			65535),

	[REG_DESIGN_VOLTAGE] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0,

			65535),

	[REG_SERIAL_NUMBER] =

		BQ20Z75_DATA(POWER_SUPPLY_PROP_SERIAL_NUMBER, 0x1C, 0, 65535),

};



static enum power_supply_property bq20z75_properties[] = {

	POWER_SUPPLY_PROP_STATUS,

	POWER_SUPPLY_PROP_HEALTH,

	POWER_SUPPLY_PROP_PRESENT,

	POWER_SUPPLY_PROP_TECHNOLOGY,

	POWER_SUPPLY_PROP_CYCLE_COUNT,

	POWER_SUPPLY_PROP_VOLTAGE_NOW,

	POWER_SUPPLY_PROP_CURRENT_NOW,

	POWER_SUPPLY_PROP_CAPACITY,

	POWER_SUPPLY_PROP_TEMP,

	POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,

	POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,

	POWER_SUPPLY_PROP_SERIAL_NUMBER,

	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,

	POWER_SUPPLY_PROP_ENERGY_NOW,

	POWER_SUPPLY_PROP_ENERGY_FULL,

	POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,

};



struct bq20z75_info {

	struct i2c_client	*client;

	struct power_supply	power_supply;

};



static int bq20z75_read_word_data(struct i2c_client *client, u8 address)

{

	s32 ret;



	ret = i2c_smbus_read_word_data(client, address);

	if (ret < 0) {

		dev_err(&client->dev,

			"%s: i2c read at address 0x%x failed\n",

			__func__, address);

		return ret;

	}

	return le16_to_cpu(ret);

}



static int bq20z75_write_word_data(struct i2c_client *client, u8 address,

	u16 value)

{

	s32 ret;



	ret = i2c_smbus_write_word_data(client, address, le16_to_cpu(value));

	if (ret < 0) {

		dev_err(&client->dev,

			"%s: i2c write to address 0x%x failed\n",

			__func__, address);

		return ret;

	}

	return 0;

}



static int bq20z75_get_battery_presence_and_health(

	struct i2c_client *client, enum power_supply_property psp,

	union power_supply_propval *val)

{

	s32 ret;



	/* Write to ManufacturerAccess with

	 * ManufacturerAccess command and then

	 * read the status */

	ret = bq20z75_write_word_data(client,

		bq20z75_data[REG_MANUFACTURER_DATA].addr,

		MANUFACTURER_ACCESS_STATUS);

	if (ret < 0)

		return ret;





	ret = bq20z75_read_word_data(client,

		bq20z75_data[REG_MANUFACTURER_DATA].addr);

	if (ret < 0)

		return ret;



	if (ret < bq20z75_data[REG_MANUFACTURER_DATA].min_value ||

	    ret > bq20z75_data[REG_MANUFACTURER_DATA].max_value) {

		val->intval = 0;

		return 0;

	}



	/* Mask the upper nibble of 2nd byte and

	 * lower byte of response then

	 * shift the result by 8 to get status*/

	ret &= 0x0F00;

	ret >>= 8;

	if (psp == POWER_SUPPLY_PROP_PRESENT) {

		if (ret == 0x0F)

			/* battery removed */

			val->intval = 0;

		else

			val->intval = 1;

	} else if (psp == POWER_SUPPLY_PROP_HEALTH) {

		if (ret == 0x09)

			val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;

		else if (ret == 0x0B)

			val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;

		else if (ret == 0x0C)

			val->intval = POWER_SUPPLY_HEALTH_DEAD;

		else

			val->intval = POWER_SUPPLY_HEALTH_GOOD;

	}



	return 0;

}



static int bq20z75_get_battery_property(struct i2c_client *client,

	int reg_offset, enum power_supply_property psp,

	union power_supply_propval *val)

{

	s32 ret;



	ret = bq20z75_read_word_data(client,

		bq20z75_data[reg_offset].addr);

	if (ret < 0)

		return ret;



	/* returned values are 16 bit */

	if (bq20z75_data[reg_offset].min_value < 0)

		ret = (s16)ret;



	if (ret >= bq20z75_data[reg_offset].min_value &&

	    ret <= bq20z75_data[reg_offset].max_value) {

		val->intval = ret;

		if (psp == POWER_SUPPLY_PROP_STATUS) {

			if (ret & BATTERY_FULL_CHARGED)

				val->intval = POWER_SUPPLY_STATUS_FULL;

			else if (ret & BATTERY_FULL_DISCHARGED)

				val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;

			else if (ret & BATTERY_DISCHARGING)

				val->intval = POWER_SUPPLY_STATUS_DISCHARGING;

			else

				val->intval = POWER_SUPPLY_STATUS_CHARGING;

		}

	} else {

		if (psp == POWER_SUPPLY_PROP_STATUS)

			val->intval = POWER_SUPPLY_STATUS_UNKNOWN;

		else

			val->intval = 0;

	}



	return 0;

}



static void  bq20z75_unit_adjustment(struct i2c_client *client,

	enum power_supply_property psp, union power_supply_propval *val)

{

#define BASE_UNIT_CONVERSION		1000

#define BATTERY_MODE_CAP_MULT_WATT	(10 * BASE_UNIT_CONVERSION)

#define TIME_UNIT_CONVERSION		600

#define TEMP_KELVIN_TO_CELCIUS		2731

	switch (psp) {

	case POWER_SUPPLY_PROP_ENERGY_NOW:

	case POWER_SUPPLY_PROP_ENERGY_FULL:

	case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:

		val->intval *= BATTERY_MODE_CAP_MULT_WATT;

		break;



	case POWER_SUPPLY_PROP_VOLTAGE_NOW:

	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:

	case POWER_SUPPLY_PROP_CURRENT_NOW:

		val->intval *= BASE_UNIT_CONVERSION;

		break;



	case POWER_SUPPLY_PROP_TEMP:

		/* bq20z75 provides battery tempreture in 0.1°K

		 * so convert it to 0.1°C */

		val->intval -= TEMP_KELVIN_TO_CELCIUS;

		val->intval *= 10;

		break;



	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:

	case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:

		val->intval *= TIME_UNIT_CONVERSION;

		break;



	default:

		dev_dbg(&client->dev,

			"%s: no need for unit conversion %d\n", __func__, psp);

	}

}



static int bq20z75_get_battery_capacity(struct i2c_client *client,

	int reg_offset, enum power_supply_property psp,

	union power_supply_propval *val)

{

	s32 ret;



	ret = bq20z75_read_word_data(client, bq20z75_data[reg_offset].addr);

	if (ret < 0)

		return ret;



	if (psp == POWER_SUPPLY_PROP_CAPACITY) {

		/* bq20z75 spec says that this can be >100 %

		* even if max value is 100 % */

		val->intval = min(ret, 100);

	} else

		val->intval = ret;



	return 0;

}



static char bq20z75_serial[5];

static int bq20z75_get_battery_serial_number(struct i2c_client *client,

	union power_supply_propval *val)

{

	int ret;



	ret = bq20z75_read_word_data(client,

		bq20z75_data[REG_SERIAL_NUMBER].addr);

	if (ret < 0)

		return ret;



	ret = sprintf(bq20z75_serial, "%04x", ret);

	val->strval = bq20z75_serial;



	return 0;

}



static int bq20z75_get_property(struct power_supply *psy,

	enum power_supply_property psp,

	union power_supply_propval *val)

{

	int count;

	int ret;

	struct bq20z75_info *bq20z75_device = container_of(psy,

				struct bq20z75_info, power_supply);

	struct i2c_client *client = bq20z75_device->client;



	switch (psp) {

	case POWER_SUPPLY_PROP_PRESENT:

	case POWER_SUPPLY_PROP_HEALTH:

		ret = bq20z75_get_battery_presence_and_health(client, psp, val);

		if (ret)

			return ret;

		break;



	case POWER_SUPPLY_PROP_TECHNOLOGY:

		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;

		break;



	case POWER_SUPPLY_PROP_ENERGY_NOW:

	case POWER_SUPPLY_PROP_ENERGY_FULL:

	case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:

	case POWER_SUPPLY_PROP_CAPACITY:

		for (count = 0; count < ARRAY_SIZE(bq20z75_data); count++) {

			if (psp == bq20z75_data[count].psp)

				break;

		}



		ret = bq20z75_get_battery_capacity(client, count, psp, val);

		if (ret)

			return ret;



		break;



	case POWER_SUPPLY_PROP_SERIAL_NUMBER:

		ret = bq20z75_get_battery_serial_number(client, val);

		if (ret)

			return ret;

		break;



	case POWER_SUPPLY_PROP_STATUS:

	case POWER_SUPPLY_PROP_CYCLE_COUNT:

	case POWER_SUPPLY_PROP_VOLTAGE_NOW:

	case POWER_SUPPLY_PROP_CURRENT_NOW:

	case POWER_SUPPLY_PROP_TEMP:

	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:

	case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:

	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:

		for (count = 0; count < ARRAY_SIZE(bq20z75_data); count++) {

			if (psp == bq20z75_data[count].psp)

				break;

		}



		ret = bq20z75_get_battery_property(client, count, psp, val);

		if (ret)

			return ret;



		break;



	default:

		dev_err(&client->dev,

			"%s: INVALID property\n", __func__);

		return -EINVAL;

	}



	/* Convert units to match requirements for power supply class */

	bq20z75_unit_adjustment(client, psp, val);



	dev_dbg(&client->dev,

		"%s: property = %d, value = %d\n", __func__, psp, val->intval);



	return 0;

}



static int bq20z75_probe(struct i2c_client *client,

	const struct i2c_device_id *id)

{

	struct bq20z75_info *bq20z75_device;

	int rc;



	bq20z75_device = kzalloc(sizeof(struct bq20z75_info), GFP_KERNEL);

	if (!bq20z75_device)

		return -ENOMEM;



	bq20z75_device->client = client;

	bq20z75_device->power_supply.name = "battery";

	bq20z75_device->power_supply.type = POWER_SUPPLY_TYPE_BATTERY;

	bq20z75_device->power_supply.properties = bq20z75_properties;

	bq20z75_device->power_supply.num_properties =

		ARRAY_SIZE(bq20z75_properties);

	bq20z75_device->power_supply.get_property = bq20z75_get_property;



	i2c_set_clientdata(client, bq20z75_device);



	rc = power_supply_register(&client->dev, &bq20z75_device->power_supply);

	if (rc) {

		dev_err(&client->dev,

			"%s: Failed to register power supply\n", __func__);

		kfree(bq20z75_device);

		return rc;

	}



	dev_info(&client->dev,

		"%s: battery gas gauge device registered\n", client->name);



	return 0;

}



static int bq20z75_remove(struct i2c_client *client)

{

	struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);



	power_supply_unregister(&bq20z75_device->power_supply);

	kfree(bq20z75_device);

	bq20z75_device = NULL;



	return 0;

}



#if defined CONFIG_PM

static int bq20z75_suspend(struct i2c_client *client,

	pm_message_t state)

{

	s32 ret;



	/* write to manufacturer access with sleep command */

	ret = bq20z75_write_word_data(client,

		bq20z75_data[REG_MANUFACTURER_DATA].addr,

		MANUFACTURER_ACCESS_SLEEP);

	if (ret < 0)

		return ret;



	return 0;

}

#else

#define bq20z75_suspend		NULL

#endif

/* any smbus transaction will wake up bq20z75 */

#define bq20z75_resume		NULL



static const struct i2c_device_id bq20z75_id[] = {

	{ "bq20z75", 0 },

	{}

};



static struct i2c_driver bq20z75_battery_driver = {

	.probe		= bq20z75_probe,

	.remove		= bq20z75_remove,

	.suspend	= bq20z75_suspend,

	.resume		= bq20z75_resume,

	.id_table	= bq20z75_id,

	.driver = {

		.name	= "bq20z75-battery",

	},

};



static int __init bq20z75_battery_init(void)

{

	return i2c_add_driver(&bq20z75_battery_driver);

}

module_init(bq20z75_battery_init);



static void __exit bq20z75_battery_exit(void)

{

	i2c_del_driver(&bq20z75_battery_driver);

}

module_exit(bq20z75_battery_exit);



MODULE_DESCRIPTION("BQ20z75 battery monitor driver");

MODULE_LICENSE("GPL");

drivers/power/bq27x00_battery.c

+1 −0
Original line number Diff line number Diff line
@@ -418,6 +418,7 @@ static int bq27x00_battery_remove(struct i2c_client *client) 


	power_supply_unregister(&di->bat);



	kfree(di->bus);

	kfree(di->bat.name);



	mutex_lock(&battery_mutex);

CRA Git | Maintained and supported by SUSTech CRA and CCSE