Commit 16bb85bc 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:
  intel_mid_battery: Fix battery scaling
  intel_mid_battery: Fix the argument order to intel_scu_ipc_command
  olpc_battery: Fix build failure caused by sysfs changes
  Add s3c-adc-battery driver
  Intel MID platform battery driver

Fix up trivial conflicts (battery drivers added from different branches)
in drivers/power/{Kconfig,Makefile}
parents 4936a3b9 f59f5bcb

drivers/power/Kconfig

+13 −0
Original line number Diff line number Diff line
@@ -136,6 +136,12 @@ config BATTERY_Z2 
	help

	  Say Y to include support for the battery on the Zipit Z2.



config BATTERY_S3C_ADC

	tristate "Battery driver for Samsung ADC based monitoring"

	depends on S3C_ADC

	help

	  Say Y here to enable support for iPAQ h1930/h1940/rx1950 battery



config CHARGER_PCF50633

	tristate "NXP PCF50633 MBC"

	depends on MFD_PCF50633
@@ -153,4 +159,11 @@ config BATTERY_JZ4740 
	  This driver can be build as a module. If so, the module will be

	  called jz4740-battery.



config BATTERY_INTEL_MID

	tristate "Battery driver for Intel MID platforms"

	depends on INTEL_SCU_IPC && SPI

	help

	  Say Y here to enable the battery driver on Intel MID

	  platforms.



endif # POWER_SUPPLY

drivers/power/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -33,5 +33,7 @@ obj-$(CONFIG_BATTERY_BQ27x00) += bq27x00_battery.o 
obj-$(CONFIG_BATTERY_DA9030)	+= da9030_battery.o

obj-$(CONFIG_BATTERY_MAX17040)	+= max17040_battery.o

obj-$(CONFIG_BATTERY_Z2)	+= z2_battery.o

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

drivers/power/intel_mid_battery.c

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

 * intel_mid_battery.c - Intel MID PMIC Battery Driver

 *

 * Copyright (C) 2009 Intel 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; version 2 of the License.

 *

 * 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.,

 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

 *

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * Author: Nithish Mahalingam <nithish.mahalingam@intel.com>

 */



#include <linux/module.h>

#include <linux/init.h>

#include <linux/err.h>

#include <linux/interrupt.h>

#include <linux/workqueue.h>

#include <linux/jiffies.h>

#include <linux/param.h>

#include <linux/device.h>

#include <linux/spi/spi.h>

#include <linux/platform_device.h>

#include <linux/power_supply.h>



#include <asm/intel_scu_ipc.h>



#define DRIVER_NAME "pmic_battery"



/*********************************************************************

 *		Generic defines

 *********************************************************************/



static int debug;

module_param(debug, int, 0444);

MODULE_PARM_DESC(debug, "Flag to enable PMIC Battery debug messages.");



#define PMIC_BATT_DRV_INFO_UPDATED	1

#define PMIC_BATT_PRESENT		1

#define PMIC_BATT_NOT_PRESENT		0

#define PMIC_USB_PRESENT		PMIC_BATT_PRESENT

#define PMIC_USB_NOT_PRESENT		PMIC_BATT_NOT_PRESENT



/* pmic battery register related */

#define PMIC_BATT_CHR_SCHRGINT_ADDR	0xD2

#define PMIC_BATT_CHR_SBATOVP_MASK	(1 << 1)

#define PMIC_BATT_CHR_STEMP_MASK	(1 << 2)

#define PMIC_BATT_CHR_SCOMP_MASK	(1 << 3)

#define PMIC_BATT_CHR_SUSBDET_MASK	(1 << 4)

#define PMIC_BATT_CHR_SBATDET_MASK	(1 << 5)

#define PMIC_BATT_CHR_SDCLMT_MASK	(1 << 6)

#define PMIC_BATT_CHR_SUSBOVP_MASK	(1 << 7)

#define PMIC_BATT_CHR_EXCPT_MASK	0xC6

#define PMIC_BATT_ADC_ACCCHRG_MASK	(1 << 31)

#define PMIC_BATT_ADC_ACCCHRGVAL_MASK	0x7FFFFFFF



/* pmic ipc related */

#define PMIC_BATT_CHR_IPC_FCHRG_SUBID	0x4

#define PMIC_BATT_CHR_IPC_TCHRG_SUBID	0x6



/* types of battery charging */

enum batt_charge_type {

	BATT_USBOTG_500MA_CHARGE,

	BATT_USBOTG_TRICKLE_CHARGE,

};



/* valid battery events */

enum batt_event {

	BATT_EVENT_BATOVP_EXCPT,

	BATT_EVENT_USBOVP_EXCPT,

	BATT_EVENT_TEMP_EXCPT,

	BATT_EVENT_DCLMT_EXCPT,

	BATT_EVENT_EXCPT

};





/*********************************************************************

 *		Battery properties

 *********************************************************************/



/*

 * pmic battery info

 */

struct pmic_power_module_info {

	bool is_dev_info_updated;

	struct device *dev;

	/* pmic battery data */

	unsigned long update_time;		/* jiffies when data read */

	unsigned int usb_is_present;

	unsigned int batt_is_present;

	unsigned int batt_health;

	unsigned int usb_health;

	unsigned int batt_status;

	unsigned int batt_charge_now;		/* in mAS */

	unsigned int batt_prev_charge_full;	/* in mAS */

	unsigned int batt_charge_rate;		/* in units per second */



	struct power_supply usb;

	struct power_supply batt;

	int irq;				/* GPE_ID or IRQ# */

	struct workqueue_struct *monitor_wqueue;

	struct delayed_work monitor_battery;

	struct work_struct handler;

};



static unsigned int delay_time = 2000;	/* in ms */



/*

 * pmic ac properties

 */

static enum power_supply_property pmic_usb_props[] = {

	POWER_SUPPLY_PROP_PRESENT,

	POWER_SUPPLY_PROP_HEALTH,

};



/*

 * pmic battery properties

 */

static enum power_supply_property pmic_battery_props[] = {

	POWER_SUPPLY_PROP_STATUS,

	POWER_SUPPLY_PROP_HEALTH,

	POWER_SUPPLY_PROP_PRESENT,

	POWER_SUPPLY_PROP_CHARGE_NOW,

	POWER_SUPPLY_PROP_CHARGE_FULL,

};





/*

 * Glue functions for talking to the IPC

 */



struct battery_property {

	u32 capacity;	/* Charger capacity */

	u8  crnt;	/* Quick charge current value*/

	u8  volt;	/* Fine adjustment of constant charge voltage */

	u8  prot;	/* CHRGPROT register value */

	u8  prot2;	/* CHRGPROT1 register value */

	u8  timer;	/* Charging timer */

};



#define IPCMSG_BATTERY		0xEF



/* Battery coulomb counter accumulator commands */

#define IPC_CMD_CC_WR		  0 /* Update coulomb counter value */

#define IPC_CMD_CC_RD		  1 /* Read coulomb counter value */

#define IPC_CMD_BATTERY_PROPERTY  2 /* Read Battery property */



/**

 *	pmic_scu_ipc_battery_cc_read	-	read battery cc

 *	@value: battery coulomb counter read

 *

 *	Reads the battery couloumb counter value, returns 0 on success, or

 *	an error code

 *

 *	This function may sleep. Locking for SCU accesses is handled for

 *	the caller.

 */

static int pmic_scu_ipc_battery_cc_read(u32 *value)

{

	return intel_scu_ipc_command(IPCMSG_BATTERY, IPC_CMD_CC_RD,

					NULL, 0, value, 1);

}



/**

 *	pmic_scu_ipc_battery_property_get	-	fetch properties

 *	@prop: battery properties

 *

 *	Retrieve the battery properties from the power management

 *

 *	This function may sleep. Locking for SCU accesses is handled for

 *	the caller.

 */

static int pmic_scu_ipc_battery_property_get(struct battery_property *prop)

{

	u32 data[3];

	u8 *p = (u8 *)&data[1];

	int err = intel_scu_ipc_command(IPC_CMD_BATTERY_PROPERTY,

				IPCMSG_BATTERY, NULL, 0, data, 3);



	prop->capacity = data[0];

	prop->crnt = *p++;

	prop->volt = *p++;

	prop->prot = *p++;

	prop->prot2 = *p++;

	prop->timer = *p++;



	return err;

}



/**

 *	pmic_scu_ipc_set_charger	-	set charger

 *	@charger: charger to select

 *

 *	Switch the charging mode for the SCU

 */



static int pmic_scu_ipc_set_charger(int charger)

{

	return intel_scu_ipc_simple_command(charger, IPCMSG_BATTERY);

}



/**

 * pmic_battery_log_event - log battery events

 * @event: battery event to be logged

 * Context: can sleep

 *

 * There are multiple battery events which may be of interest to users;

 * this battery function logs the different battery events onto the

 * kernel log messages.

 */

static void pmic_battery_log_event(enum batt_event event)

{

	printk(KERN_WARNING "pmic-battery: ");

	switch (event) {

	case BATT_EVENT_BATOVP_EXCPT:

		printk(KERN_CONT "battery overvoltage condition\n");

		break;

	case BATT_EVENT_USBOVP_EXCPT:

		printk(KERN_CONT "usb charger overvoltage condition\n");

		break;

	case BATT_EVENT_TEMP_EXCPT:

		printk(KERN_CONT "high battery temperature condition\n");

		break;

	case BATT_EVENT_DCLMT_EXCPT:

		printk(KERN_CONT "over battery charge current condition\n");

		break;

	default:

		printk(KERN_CONT "charger/battery exception %d\n", event);

		break;

	}

}



/**

 * pmic_battery_read_status - read battery status information

 * @pbi: device info structure to update the read information

 * Context: can sleep

 *

 * PMIC power source information need to be updated based on the data read

 * from the PMIC battery registers.

 *

 */

static void pmic_battery_read_status(struct pmic_power_module_info *pbi)

{

	unsigned int update_time_intrvl;

	unsigned int chrg_val;

	u32 ccval;

	u8 r8;

	struct battery_property batt_prop;

	int batt_present = 0;

	int usb_present = 0;

	int batt_exception = 0;



	/* make sure the last batt_status read happened delay_time before */

	if (pbi->update_time && time_before(jiffies, pbi->update_time +

						msecs_to_jiffies(delay_time)))

		return;



	update_time_intrvl = jiffies_to_msecs(jiffies -	pbi->update_time);

	pbi->update_time = jiffies;



	/* read coulomb counter registers and schrgint register */

	if (pmic_scu_ipc_battery_cc_read(&ccval)) {

		dev_warn(pbi->dev, "%s(): ipc config cmd failed\n",

								__func__);

		return;

	}



	if (intel_scu_ipc_ioread8(PMIC_BATT_CHR_SCHRGINT_ADDR, &r8)) {

		dev_warn(pbi->dev, "%s(): ipc pmic read failed\n",

								__func__);

		return;

	}



	/*

	 * set pmic_power_module_info members based on pmic register values

	 * read.

	 */



	/* set batt_is_present */

	if (r8 & PMIC_BATT_CHR_SBATDET_MASK) {

		pbi->batt_is_present = PMIC_BATT_PRESENT;

		batt_present = 1;

	} else {

		pbi->batt_is_present = PMIC_BATT_NOT_PRESENT;

		pbi->batt_health = POWER_SUPPLY_HEALTH_UNKNOWN;

		pbi->batt_status = POWER_SUPPLY_STATUS_UNKNOWN;

	}



	/* set batt_health */

	if (batt_present) {

		if (r8 & PMIC_BATT_CHR_SBATOVP_MASK) {

			pbi->batt_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;

			pbi->batt_status = POWER_SUPPLY_STATUS_NOT_CHARGING;

			pmic_battery_log_event(BATT_EVENT_BATOVP_EXCPT);

			batt_exception = 1;

		} else if (r8 & PMIC_BATT_CHR_SDCLMT_MASK) {

			pbi->batt_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;

			pbi->batt_status = POWER_SUPPLY_STATUS_NOT_CHARGING;

			pmic_battery_log_event(BATT_EVENT_DCLMT_EXCPT);

			batt_exception = 1;

		} else if (r8 & PMIC_BATT_CHR_STEMP_MASK) {

			pbi->batt_health = POWER_SUPPLY_HEALTH_OVERHEAT;

			pbi->batt_status = POWER_SUPPLY_STATUS_NOT_CHARGING;

			pmic_battery_log_event(BATT_EVENT_TEMP_EXCPT);

			batt_exception = 1;

		} else {

			pbi->batt_health = POWER_SUPPLY_HEALTH_GOOD;

		}

	}



	/* set usb_is_present */

	if (r8 & PMIC_BATT_CHR_SUSBDET_MASK) {

		pbi->usb_is_present = PMIC_USB_PRESENT;

		usb_present = 1;

	} else {

		pbi->usb_is_present = PMIC_USB_NOT_PRESENT;

		pbi->usb_health = POWER_SUPPLY_HEALTH_UNKNOWN;

	}



	if (usb_present) {

		if (r8 & PMIC_BATT_CHR_SUSBOVP_MASK) {

			pbi->usb_health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;

			pmic_battery_log_event(BATT_EVENT_USBOVP_EXCPT);

		} else {

			pbi->usb_health = POWER_SUPPLY_HEALTH_GOOD;

		}

	}



	chrg_val = ccval & PMIC_BATT_ADC_ACCCHRGVAL_MASK;



	/* set batt_prev_charge_full to battery capacity the first time */

	if (!pbi->is_dev_info_updated) {

		if (pmic_scu_ipc_battery_property_get(&batt_prop)) {

			dev_warn(pbi->dev, "%s(): ipc config cmd failed\n",

								__func__);

			return;

		}

		pbi->batt_prev_charge_full = batt_prop.capacity;

	}



	/* set batt_status */

	if (batt_present && !batt_exception) {

		if (r8 & PMIC_BATT_CHR_SCOMP_MASK) {

			pbi->batt_status = POWER_SUPPLY_STATUS_FULL;

			pbi->batt_prev_charge_full = chrg_val;

		} else if (ccval & PMIC_BATT_ADC_ACCCHRG_MASK) {

			pbi->batt_status = POWER_SUPPLY_STATUS_DISCHARGING;

		} else {

			pbi->batt_status = POWER_SUPPLY_STATUS_CHARGING;

		}

	}



	/* set batt_charge_rate */

	if (pbi->is_dev_info_updated && batt_present && !batt_exception) {

		if (pbi->batt_status == POWER_SUPPLY_STATUS_DISCHARGING) {

			if (pbi->batt_charge_now - chrg_val) {

				pbi->batt_charge_rate = ((pbi->batt_charge_now -

					chrg_val) * 1000 * 60) /

					update_time_intrvl;

			}

		} else if (pbi->batt_status == POWER_SUPPLY_STATUS_CHARGING) {

			if (chrg_val - pbi->batt_charge_now) {

				pbi->batt_charge_rate = ((chrg_val -

					pbi->batt_charge_now) * 1000 * 60) /

					update_time_intrvl;

			}

		} else

			pbi->batt_charge_rate = 0;

	} else {

		pbi->batt_charge_rate = -1;

	}



	/* batt_charge_now */

	if (batt_present && !batt_exception)

		pbi->batt_charge_now = chrg_val;

	else

		pbi->batt_charge_now = -1;



	pbi->is_dev_info_updated = PMIC_BATT_DRV_INFO_UPDATED;

}



/**

 * pmic_usb_get_property - usb power source get property

 * @psy: usb power supply context

 * @psp: usb power source property

 * @val: usb power source property value

 * Context: can sleep

 *

 * PMIC usb power source property needs to be provided to power_supply

 * subsytem for it to provide the information to users.

 */

static int pmic_usb_get_property(struct power_supply *psy,

				enum power_supply_property psp,

				union power_supply_propval *val)

{

	struct pmic_power_module_info *pbi = container_of(psy,

				struct pmic_power_module_info, usb);



	/* update pmic_power_module_info members */

	pmic_battery_read_status(pbi);



	switch (psp) {

	case POWER_SUPPLY_PROP_PRESENT:

		val->intval = pbi->usb_is_present;

		break;

	case POWER_SUPPLY_PROP_HEALTH:

		val->intval = pbi->usb_health;

		break;

	default:

		return -EINVAL;

	}



	return 0;

}



static inline unsigned long mAStouAh(unsigned long v)

{

	/* seconds to hours, mA to µA */

	return (v * 1000) / 3600;

}



/**

 * pmic_battery_get_property - battery power source get property

 * @psy: battery power supply context

 * @psp: battery power source property

 * @val: battery power source property value

 * Context: can sleep

 *

 * PMIC battery power source property needs to be provided to power_supply

 * subsytem for it to provide the information to users.

 */

static int pmic_battery_get_property(struct power_supply *psy,

				enum power_supply_property psp,

				union power_supply_propval *val)

{

	struct pmic_power_module_info *pbi = container_of(psy,

				struct pmic_power_module_info, batt);



	/* update pmic_power_module_info members */

	pmic_battery_read_status(pbi);



	switch (psp) {

	case POWER_SUPPLY_PROP_STATUS:

		val->intval = pbi->batt_status;

		break;

	case POWER_SUPPLY_PROP_HEALTH:

		val->intval = pbi->batt_health;

		break;

	case POWER_SUPPLY_PROP_PRESENT:

		val->intval = pbi->batt_is_present;

		break;

	case POWER_SUPPLY_PROP_CHARGE_NOW:

		val->intval = mAStouAh(pbi->batt_charge_now);

		break;

	case POWER_SUPPLY_PROP_CHARGE_FULL:

		val->intval = mAStouAh(pbi->batt_prev_charge_full);

		break;

	default:

		return -EINVAL;

	}



	return 0;

}



/**

 * pmic_battery_monitor - monitor battery status

 * @work: work structure

 * Context: can sleep

 *

 * PMIC battery status needs to be monitored for any change

 * and information needs to be frequently updated.

 */

static void pmic_battery_monitor(struct work_struct *work)

{

	struct pmic_power_module_info *pbi = container_of(work,

			struct pmic_power_module_info, monitor_battery.work);



	/* update pmic_power_module_info members */

	pmic_battery_read_status(pbi);

	queue_delayed_work(pbi->monitor_wqueue, &pbi->monitor_battery, HZ * 10);

}



/**

 * pmic_battery_set_charger - set battery charger

 * @pbi: device info structure

 * @chrg: charge mode to set battery charger in

 * Context: can sleep

 *

 * PMIC battery charger needs to be enabled based on the usb charge

 * capabilities connected to the platform.

 */

static int pmic_battery_set_charger(struct pmic_power_module_info *pbi,

						enum batt_charge_type chrg)

{

	int retval;



	/* set usblmt bits and chrgcntl register bits appropriately */

	switch (chrg) {

	case BATT_USBOTG_500MA_CHARGE:

		retval = pmic_scu_ipc_set_charger(PMIC_BATT_CHR_IPC_FCHRG_SUBID);

		break;

	case BATT_USBOTG_TRICKLE_CHARGE:

		retval = pmic_scu_ipc_set_charger(PMIC_BATT_CHR_IPC_TCHRG_SUBID);

		break;

	default:

		dev_warn(pbi->dev, "%s(): out of range usb charger "

						"charge detected\n", __func__);

		return -EINVAL;

	}



	if (retval) {

		dev_warn(pbi->dev, "%s(): ipc pmic read failed\n",

								__func__);

		return retval;;

	}



	return 0;

}



/**

 * pmic_battery_interrupt_handler - pmic battery interrupt handler

 * Context: interrupt context

 *

 * PMIC battery interrupt handler which will be called with either

 * battery full condition occurs or usb otg & battery connect

 * condition occurs.

 */

static irqreturn_t pmic_battery_interrupt_handler(int id, void *dev)

{

	struct pmic_power_module_info *pbi = dev;



	schedule_work(&pbi->handler);



	return IRQ_HANDLED;

}



/**

 * pmic_battery_handle_intrpt - pmic battery service interrupt

 * @work: work structure

 * Context: can sleep

 *

 * PMIC battery needs to either update the battery status as full

 * if it detects battery full condition caused the interrupt or needs

 * to enable battery charger if it detects usb and battery detect

 * caused the source of interrupt.

 */

static void pmic_battery_handle_intrpt(struct work_struct *work)

{

	struct pmic_power_module_info *pbi = container_of(work,

				struct pmic_power_module_info, handler);

	enum batt_charge_type chrg;

	u8 r8;



	if (intel_scu_ipc_ioread8(PMIC_BATT_CHR_SCHRGINT_ADDR, &r8)) {

		dev_warn(pbi->dev, "%s(): ipc pmic read failed\n",

								__func__);

		return;

	}

	/* find the cause of the interrupt */

	if (r8 & PMIC_BATT_CHR_SBATDET_MASK) {

		pbi->batt_is_present = PMIC_BATT_PRESENT;

	} else {

		pbi->batt_is_present = PMIC_BATT_NOT_PRESENT;

		pbi->batt_health = POWER_SUPPLY_HEALTH_UNKNOWN;

		pbi->batt_status = POWER_SUPPLY_STATUS_UNKNOWN;

		return;

	}



	if (r8 & PMIC_BATT_CHR_EXCPT_MASK) {

		pbi->batt_health = POWER_SUPPLY_HEALTH_UNKNOWN;

		pbi->batt_status = POWER_SUPPLY_STATUS_NOT_CHARGING;

		pbi->usb_health = POWER_SUPPLY_HEALTH_UNKNOWN;

		pmic_battery_log_event(BATT_EVENT_EXCPT);

		return;

	} else {

		pbi->batt_health = POWER_SUPPLY_HEALTH_GOOD;

		pbi->usb_health = POWER_SUPPLY_HEALTH_GOOD;

	}



	if (r8 & PMIC_BATT_CHR_SCOMP_MASK) {

		u32 ccval;

		pbi->batt_status = POWER_SUPPLY_STATUS_FULL;



		if (pmic_scu_ipc_battery_cc_read(&ccval)) {

			dev_warn(pbi->dev, "%s(): ipc config cmd "

							"failed\n", __func__);

			return;

		}

		pbi->batt_prev_charge_full = ccval &

						PMIC_BATT_ADC_ACCCHRGVAL_MASK;

		return;

	}



	if (r8 & PMIC_BATT_CHR_SUSBDET_MASK) {

		pbi->usb_is_present = PMIC_USB_PRESENT;

	} else {

		pbi->usb_is_present = PMIC_USB_NOT_PRESENT;

		pbi->usb_health = POWER_SUPPLY_HEALTH_UNKNOWN;

		return;

	}



	/* setup battery charging */



#if 0

	/* check usb otg power capability and set charger accordingly */

	retval = langwell_udc_maxpower(&power);

	if (retval) {

		dev_warn(pbi->dev,

		    "%s(): usb otg power query failed with error code %d\n",

			__func__, retval);

		return;

	}



	if (power >= 500)

		chrg = BATT_USBOTG_500MA_CHARGE;

	else

#endif

		chrg = BATT_USBOTG_TRICKLE_CHARGE;



	/* enable battery charging */

	if (pmic_battery_set_charger(pbi, chrg)) {

		dev_warn(pbi->dev,

			"%s(): failed to set up battery charging\n", __func__);

		return;

	}



	dev_dbg(pbi->dev,

		"pmic-battery: %s() - setting up battery charger successful\n",

			__func__);

}



/**

 * pmic_battery_probe - pmic battery initialize

 * @irq: pmic battery device irq

 * @dev: pmic battery device structure

 * Context: can sleep

 *

 * PMIC battery initializes its internal data structue and other

 * infrastructure components for it to work as expected.

 */

static __devinit int probe(int irq, struct device *dev)

{

	int retval = 0;

	struct pmic_power_module_info *pbi;



	dev_dbg(dev, "pmic-battery: found pmic battery device\n");



	pbi = kzalloc(sizeof(*pbi), GFP_KERNEL);

	if (!pbi) {

		dev_err(dev, "%s(): memory allocation failed\n",

								__func__);

		return -ENOMEM;

	}



	pbi->dev = dev;

	pbi->irq = irq;

	dev_set_drvdata(dev, pbi);



	/* initialize all required framework before enabling interrupts */

	INIT_WORK(&pbi->handler, pmic_battery_handle_intrpt);

	INIT_DELAYED_WORK(&pbi->monitor_battery, pmic_battery_monitor);

	pbi->monitor_wqueue =

			create_singlethread_workqueue(dev_name(dev));

	if (!pbi->monitor_wqueue) {

		dev_err(dev, "%s(): wqueue init failed\n", __func__);

		retval = -ESRCH;

		goto wqueue_failed;

	}



	/* register interrupt */

	retval = request_irq(pbi->irq, pmic_battery_interrupt_handler,

							0, DRIVER_NAME, pbi);

	if (retval) {

		dev_err(dev, "%s(): cannot get IRQ\n", __func__);

		goto requestirq_failed;

	}



	/* register pmic-batt with power supply subsystem */

	pbi->batt.name = "pmic-batt";

	pbi->batt.type = POWER_SUPPLY_TYPE_BATTERY;

	pbi->batt.properties = pmic_battery_props;

	pbi->batt.num_properties = ARRAY_SIZE(pmic_battery_props);

	pbi->batt.get_property = pmic_battery_get_property;

	retval = power_supply_register(dev, &pbi->batt);

	if (retval) {

		dev_err(dev,

			"%s(): failed to register pmic battery device with power supply subsystem\n",

				__func__);

		goto power_reg_failed;

	}



	dev_dbg(dev, "pmic-battery: %s() - pmic battery device "

		"registration with power supply subsystem successful\n",

		__func__);



	queue_delayed_work(pbi->monitor_wqueue, &pbi->monitor_battery, HZ * 1);



	/* register pmic-usb with power supply subsystem */

	pbi->usb.name = "pmic-usb";

	pbi->usb.type = POWER_SUPPLY_TYPE_USB;

	pbi->usb.properties = pmic_usb_props;

	pbi->usb.num_properties = ARRAY_SIZE(pmic_usb_props);

	pbi->usb.get_property = pmic_usb_get_property;

	retval = power_supply_register(dev, &pbi->usb);

	if (retval) {

		dev_err(dev,

			"%s(): failed to register pmic usb device with power supply subsystem\n",

				__func__);

		goto power_reg_failed_1;

	}



	if (debug)

		printk(KERN_INFO "pmic-battery: %s() - pmic usb device "

			"registration with power supply subsystem successful\n",

			__func__);



	return retval;



power_reg_failed_1:

	power_supply_unregister(&pbi->batt);

power_reg_failed:

	cancel_rearming_delayed_workqueue(pbi->monitor_wqueue,

						&pbi->monitor_battery);

requestirq_failed:

	destroy_workqueue(pbi->monitor_wqueue);

wqueue_failed:

	kfree(pbi);



	return retval;

}



static int __devinit platform_pmic_battery_probe(struct platform_device *pdev)

{

	return probe(pdev->id, &pdev->dev);

}



/**

 * pmic_battery_remove - pmic battery finalize

 * @dev: pmic battery device structure

 * Context: can sleep

 *

 * PMIC battery finalizes its internal data structue and other

 * infrastructure components that it initialized in

 * pmic_battery_probe.

 */



static int __devexit platform_pmic_battery_remove(struct platform_device *pdev)

{

	struct pmic_power_module_info *pbi = dev_get_drvdata(&pdev->dev);



	free_irq(pbi->irq, pbi);

	cancel_rearming_delayed_workqueue(pbi->monitor_wqueue,

					&pbi->monitor_battery);

	destroy_workqueue(pbi->monitor_wqueue);



	power_supply_unregister(&pbi->usb);

	power_supply_unregister(&pbi->batt);



	flush_scheduled_work();

	kfree(pbi);

	return 0;

}



static struct platform_driver platform_pmic_battery_driver = {

	.driver = {

		.name = DRIVER_NAME,

		.owner = THIS_MODULE,

	},

	.probe = platform_pmic_battery_probe,

	.remove = __devexit_p(platform_pmic_battery_remove),

};



static int __init platform_pmic_battery_module_init(void)

{

	return platform_driver_register(&platform_pmic_battery_driver);

}



static void __exit platform_pmic_battery_module_exit(void)

{

	platform_driver_unregister(&platform_pmic_battery_driver);

}



module_init(platform_pmic_battery_module_init);

module_exit(platform_pmic_battery_module_exit);



MODULE_AUTHOR("Nithish Mahalingam <nithish.mahalingam@intel.com>");

MODULE_DESCRIPTION("Intel Moorestown PMIC Battery Driver");

MODULE_LICENSE("GPL");

drivers/power/olpc_battery.c

+1 −1
Original line number Diff line number Diff line 
/*

 * Battery driver for One Laptop Per Child board.

 *

 *	Copyright © 2006  David Woodhouse <dwmw2@infradead.org>

 *	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

CRA Git | Maintained and supported by SUSTech CRA and CCSE