diff --git a/drivers/power/bq27000_battery.c b/drivers/power/bq27000_battery.c
index cd4968e..46c2cd2 100644
--- a/drivers/power/bq27000_battery.c
+++ b/drivers/power/bq27000_battery.c
@@ -29,6 +29,7 @@
 #include <linux/jiffies.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
+#include <linux/workqueue.h>
 #include <linux/platform_device.h>
 #include <linux/power_supply.h>
 #include <linux/bq27000_battery.h>
@@ -113,9 +114,25 @@ enum bq27000_status_flags {
 struct bq27000_device_info {
 	struct device *dev;
 	struct power_supply bat;
+	struct power_supply ac;
+	struct power_supply usb;
+	struct delayed_work work;
 	struct bq27000_platform_data *pdata;
+
+	int		ai;
+	int		flags;
+	int		lmd;
+	int		rsoc;
+	int		temp;
+	int		tte;
+	int		ttf;
+	int		volt;
 };
 
+static unsigned int cache_time = 10000;
+module_param(cache_time, uint, 0644);
+MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
+
 /*
  * reading 16 bit values over HDQ has a special hazard where the
  * hdq device firmware can update the 16-bit register during the time we
@@ -147,13 +164,9 @@ static int hdq_read16(struct bq27000_device_info *di, int address)
 	return -ETIME;
 }
 
-#define to_bq27000_device_info(x) container_of((x), \
-					       struct bq27000_device_info, \
-					       bat);
-
 static void bq27000_battery_external_power_changed(struct power_supply *psy)
 {
-	struct bq27000_device_info *di = to_bq27000_device_info(psy);
+	struct bq27000_device_info *di = container_of(psy, struct bq27000_device_info, bat);
 
 	dev_dbg(di->dev, "%s\n", __FUNCTION__);
 }
@@ -162,11 +175,8 @@ static int bq27000_battery_get_property(struct power_supply *psy,
 				       enum power_supply_property psp,
 				       union power_supply_propval *val)
 {
-	int v, n;
-	struct bq27000_device_info *di = to_bq27000_device_info(psy);
-
-	if (!(di->pdata->hdq_initialized)())
-		return -EINVAL;
+	int n;
+	struct bq27000_device_info *di = container_of(psy, struct bq27000_device_info, bat);
 
 	switch (psp) {
 	case POWER_SUPPLY_PROP_STATUS:
@@ -207,85 +217,122 @@ use_bat:
 		 * but... battery state can be out of date by 4 seconds or
 		 * so... use the platform callbacks if possible.
 		 */
-		v = hdq_read16(di, BQ27000_AI_L);
-		if (v < 0)
-			return v;
 
 		/* no real activity on the battery */
-		if (v < 2) {
-			if (!hdq_read16(di, BQ27000_TTF_L))
+		if (di->ai < 2) {
+			if (!di->ttf)
 				val->intval = POWER_SUPPLY_STATUS_FULL;
 			else
 				val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 			break;
 		}
 		/* power is actually going in or out... */
-		v = (di->pdata->hdq_read)(BQ27000_FLAGS);
-		if (v < 0)
-			return v;
-		if (v & BQ27000_STATUS_CHGS)
+		if (di->flags < 0)
+			return di->flags;
+		if (di->flags & BQ27000_STATUS_CHGS)
 			val->intval = POWER_SUPPLY_STATUS_CHARGING;
 		else
 			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 		break;
+	case POWER_SUPPLY_PROP_HEALTH:
+		val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
+		/* Do we have accurate readings... */
+		if (di->flags < 0)
+			return di->flags;
+		if (di->flags & BQ27000_STATUS_VDQ)
+			val->intval = POWER_SUPPLY_HEALTH_GOOD;
+		break;
 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
-		v = hdq_read16(di, BQ27000_VOLT_L);
-		if (v < 0)
-			return v;
+		if (di->volt < 0)
+			return di->volt;
 		/* mV -> uV */
-		val->intval = v * 1000;
+		val->intval = di->volt * 1000;
 		break;
 	case POWER_SUPPLY_PROP_CURRENT_NOW:
-		v = (di->pdata->hdq_read)(BQ27000_FLAGS);
-		if (v < 0)
-			return v;
-		if (v & BQ27000_STATUS_CHGS)
+		if (di->flags < 0)
+			return di->flags;
+		if (di->flags & BQ27000_STATUS_CHGS)
 			n = -NANOVOLTS_UNIT;
 		else
 			n = NANOVOLTS_UNIT;
-		v = hdq_read16(di, BQ27000_AI_L);
-		if (v < 0)
-			return v;
-		val->intval = (v * n) / di->pdata->rsense_mohms;
+		if (di->ai < 0)
+			return di->ai;
+		val->intval = (di->ai * n) / di->pdata->rsense_mohms;
 		break;
 	case POWER_SUPPLY_PROP_CHARGE_FULL:
-		v = hdq_read16(di, BQ27000_LMD_L);
-		if (v < 0)
-			return v;
-		val->intval = (v * 3570) / di->pdata->rsense_mohms;
+		if (di->lmd < 0)
+			return di->lmd;
+		val->intval = (di->lmd * 3570) / di->pdata->rsense_mohms;
 		break;
 	case POWER_SUPPLY_PROP_TEMP:
-		v = hdq_read16(di, BQ27000_TEMP_L);
-		if (v < 0)
-			return v;
+		if (di->temp < 0)
+			return di->temp;
 		/* K (in 0.25K units) is 273.15 up from C (in 0.1C)*/
 		/* 10926 = 27315 * 4 / 10 */
-		val->intval = (((long)v * 10l) - 10926) / 4;
+		val->intval = (((long)di->temp * 10l) - 10926) / 4;
 		break;
 	case POWER_SUPPLY_PROP_TECHNOLOGY:
 		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 		break;
 	case POWER_SUPPLY_PROP_CAPACITY:
-		val->intval = (di->pdata->hdq_read)(BQ27000_RSOC);
+		val->intval = di->rsoc;
 		if (val->intval < 0)
 			return val->intval;
 		break;
 	case POWER_SUPPLY_PROP_PRESENT:
-		v = (di->pdata->hdq_read)(BQ27000_RSOC);
-		val->intval = !(v < 0);
+		val->intval = !(di->rsoc < 0);
 		break;
 	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
-		v = hdq_read16(di, BQ27000_TTE_L);
-		if (v < 0)
-			return v;
-		val->intval = 60 * v;
+		if (di->tte < 0)
+			return di->tte;
+		val->intval = 60 * di->tte;
 		break;
 	case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
-		v = hdq_read16(di, BQ27000_TTF_L);
-		if (v < 0)
-			return v;
-		val->intval = 60 * v;
+		if (di->ttf < 0)
+			return di->ttf;
+		val->intval = 60 * di->ttf;
 		break;
+	default:
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static void bq27000_battery_work(struct work_struct *work)
+{
+	struct bq27000_device_info *di =
+		container_of(work, struct bq27000_device_info, work.work);
+
+	if ((di->pdata->hdq_initialized)()) {
+
+		di->ai    = hdq_read16(di, BQ27000_AI_L);
+		di->flags = (di->pdata->hdq_read)(BQ27000_FLAGS);
+		di->lmd   = hdq_read16(di, BQ27000_LMD_L);
+		di->rsoc  = (di->pdata->hdq_read)(BQ27000_RSOC);
+		di->temp  = hdq_read16(di, BQ27000_TEMP_L);
+		di->tte   = hdq_read16(di, BQ27000_TTE_L);
+		di->ttf   = hdq_read16(di, BQ27000_TTF_L);
+		di->volt  = hdq_read16(di, BQ27000_VOLT_L);
+
+		power_supply_changed(&di->bat);
+	}
+
+	if (!schedule_delayed_work(&di->work, cache_time))
+		dev_err(di->dev, "battery service reschedule failed\n");
+}
+
+static int ac_get_property(struct power_supply *psy,
+			enum power_supply_property psp,
+			union power_supply_propval *val)
+{
+	int ret = 0;
+	struct bq27000_device_info *di = container_of(psy, struct bq27000_device_info, ac);
+
+	if (!(di->pdata->hdq_initialized)())
+		return -EINVAL;
+
+	switch (psp) {
 	case POWER_SUPPLY_PROP_ONLINE:
 		if (di->pdata->get_charger_online_status)
 			val->intval = (di->pdata->get_charger_online_status)();
@@ -293,14 +340,39 @@ use_bat:
 			return -EINVAL;
 		break;
 	default:
-		return -EINVAL;
+		ret = -EINVAL;
+		break;
 	}
+	return ret;
+}
 
-	return 0;
+static int usb_get_property(struct power_supply *psy,
+			enum power_supply_property psp,
+			union power_supply_propval *val)
+{
+	int ret = 0;
+	struct bq27000_device_info *di = container_of(psy, struct bq27000_device_info, usb);
+
+	if (!(di->pdata->hdq_initialized)())
+		return -EINVAL;
+
+	switch (psp) {
+	case POWER_SUPPLY_PROP_ONLINE:
+		if (di->pdata->get_charger_online_status)
+			val->intval = (di->pdata->get_charger_online_status)();
+		else
+			return -EINVAL;
+		break;
+	default:
+		ret = -EINVAL;
+		break;
+	}
+	return ret;
 }
 
 static enum power_supply_property bq27000_battery_props[] = {
 	POWER_SUPPLY_PROP_STATUS,
+	POWER_SUPPLY_PROP_HEALTH,
 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
 	POWER_SUPPLY_PROP_CURRENT_NOW,
 	POWER_SUPPLY_PROP_CHARGE_FULL,
@@ -309,8 +381,11 @@ static enum power_supply_property bq27000_battery_props[] = {
 	POWER_SUPPLY_PROP_PRESENT,
 	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
 	POWER_SUPPLY_PROP_TIME_TO_FULL_NOW,
-	POWER_SUPPLY_PROP_CAPACITY,
-	POWER_SUPPLY_PROP_ONLINE
+	POWER_SUPPLY_PROP_CAPACITY
+};
+
+static enum power_supply_property power_props[] = {
+	POWER_SUPPLY_PROP_ONLINE,
 };
 
 static int bq27000_battery_probe(struct platform_device *pdev)
@@ -342,14 +417,47 @@ static int bq27000_battery_probe(struct platform_device *pdev)
 	di->bat.use_for_apm = 1;
 	di->pdata = pdata;
 
+	di->ac.name            = "ac";
+	di->ac.type            = POWER_SUPPLY_TYPE_MAINS;
+	di->ac.properties      = power_props;
+	di->ac.num_properties  = ARRAY_SIZE(power_props);
+	di->ac.get_property    = ac_get_property;
+
+	di->usb.name           = "usb";
+	di->usb.type           = POWER_SUPPLY_TYPE_USB;
+	di->usb.properties     = power_props;
+	di->usb.num_properties = ARRAY_SIZE(power_props);
+	di->usb.get_property   = usb_get_property;
+
 	retval = power_supply_register(&pdev->dev, &di->bat);
 	if (retval) {
 		dev_err(di->dev, "failed to register battery\n");
 		goto batt_failed;
 	}
 
+	retval = power_supply_register(&pdev->dev, &di->ac);
+	if (retval) {
+		dev_err(di->dev, "failed to register ac\n");
+		goto ac_failed;
+	}
+
+	retval = power_supply_register(&pdev->dev, &di->usb);
+	if (retval) {
+		dev_err(di->dev, "failed to register usb\n");
+		goto usb_failed;
+	}
+
+	INIT_DELAYED_WORK(&di->work, bq27000_battery_work);
+
+	if (!schedule_delayed_work(&di->work, 0))
+		dev_err(di->dev, "failed to schedule bq27000_battery_work\n");
+
 	return 0;
 
+usb_failed:
+	power_supply_unregister(&di->ac);
+ac_failed:
+	power_supply_unregister(&di->bat);
 batt_failed:
 	kfree(di);
 di_alloc_failed:
@@ -360,7 +468,11 @@ static int bq27000_battery_remove(struct platform_device *pdev)
 {
 	struct bq27000_device_info *di = platform_get_drvdata(pdev);
 
+	cancel_delayed_work(&di->work);
+
 	power_supply_unregister(&di->bat);
+	power_supply_unregister(&di->ac);
+	power_supply_unregister(&di->usb);
 
 	return 0;
 }
@@ -372,7 +484,8 @@ void bq27000_charging_state_change(struct platform_device *pdev)
 	if (!di)
 	    return;
 
-	power_supply_changed(&di->bat);
+	power_supply_changed(&di->ac);
+	power_supply_changed(&di->usb);
 }
 EXPORT_SYMBOL_GPL(bq27000_charging_state_change);
 
@@ -381,11 +494,17 @@ EXPORT_SYMBOL_GPL(bq27000_charging_state_change);
 static int bq27000_battery_suspend(struct platform_device *pdev,
 				  pm_message_t state)
 {
+	struct bq27000_device_info *di = platform_get_drvdata(pdev);
+
+	cancel_delayed_work(&di->work);
 	return 0;
 }
 
 static int bq27000_battery_resume(struct platform_device *pdev)
 {
+	struct bq27000_device_info *di = platform_get_drvdata(pdev);
+
+	schedule_delayed_work(&di->work, 0);
 	return 0;
 }
 
