power_supply: kill android-battery driver

Discontinued in favor of future userspace charging helpers.

Change-Id: I840a94ff42e2219cfd8759f919f6188355a63d92
Signed-off-by: Todd Poynor <toddpoynor@google.com>

5 files changed, 0 insertions, 751 deletions

diff --git a/android/configs/android-recommended.cfg b/android/configs/android-recommended.cfg
index ca3cc861336..546c37f552b 100644
--- a/android/configs/android-recommended.cfg
+++ b/android/configs/android-recommended.cfg
@@ -11,7 +11,6 @@ CONFIG_COMPACTION=y
 CONFIG_ANDROID_RAM_CONSOLE=y
 CONFIG_ANDROID_TIMED_GPIO=y
 CONFIG_BACKLIGHT_LCD_SUPPORT=y
-CONFIG_BATTERY_ANDROID=y
 CONFIG_BLK_DEV_LOOP=y
 CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_SIZE=8192
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index 430ef8c8b6a..7b8979c63f4 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -204,16 +204,6 @@ config BATTERY_MAX17042
 	  with MAX17042. This driver also supports max17047/50 chips which are
 	  improved version of max17042.
 
-config BATTERY_ANDROID
-	tristate "Battery driver for Android"
-	help
-	  Say Y to enable generic support for battery charging according
-	  to common Android policies.
-	  This driver adds periodic battery level and health monitoring,
-	  kernel log reporting and other debugging features, common board
-	  battery file glue logic for battery/case temperature sensors,
-	  etc.
-
 config BATTERY_Z2
 	tristate "Z2 battery driver"
 	depends on I2C && MACH_ZIPIT2
diff --git a/drivers/power/Makefile b/drivers/power/Makefile
index 27d9deef51b..653bf6ceff3 100644
--- a/drivers/power/Makefile
+++ b/drivers/power/Makefile
@@ -16,7 +16,6 @@ obj-$(CONFIG_WM8350_POWER)	+= wm8350_power.o
 obj-$(CONFIG_TEST_POWER)	+= test_power.o
 
 obj-$(CONFIG_BATTERY_88PM860X)	+= 88pm860x_battery.o
-obj-$(CONFIG_BATTERY_ANDROID)	+= android_battery.o
 obj-$(CONFIG_BATTERY_DS2760)	+= ds2760_battery.o
 obj-$(CONFIG_BATTERY_DS2780)	+= ds2780_battery.o
 obj-$(CONFIG_BATTERY_DS2781)	+= ds2781_battery.o
diff --git a/drivers/power/android_battery.c b/drivers/power/android_battery.c
deleted file mode 100644
index 8d45ff0f367..00000000000
--- a/drivers/power/android_battery.c
+++ /dev/null
@@ -1,692 +0,0 @@
-/*
- *  android_battery.c
- *  Android Battery Driver
- *
- * Copyright (C) 2012 Google, Inc.
- * Copyright (C) 2012 Samsung Electronics
- *
- * Based on work by himihee.seo@samsung.com, ms925.kim@samsung.com, and
- * joshua.chang@samsung.com.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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.
- */
-
-#include <linux/types.h>
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/err.h>
-#include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/io.h>
-#include <linux/jiffies.h>
-#include <linux/platform_device.h>
-#include <linux/power_supply.h>
-#include <linux/slab.h>
-#include <linux/wakelock.h>
-#include <linux/workqueue.h>
-#include <linux/alarmtimer.h>
-#include <linux/timer.h>
-#include <linux/mutex.h>
-#include <linux/debugfs.h>
-#include <linux/platform_data/android_battery.h>
-
-#define FAST_POLL               (1 * 60)
-#define SLOW_POLL               (10 * 60)
-
-struct android_bat_data {
-	struct android_bat_platform_data *pdata;
-	struct android_bat_callbacks callbacks;
-
-	struct device		*dev;
-
-	struct power_supply	psy_bat;
-
-	struct wake_lock	monitor_wake_lock;
-	struct wake_lock	charger_wake_lock;
-
-	int			charge_source;
-
-	int			batt_temp;
-	int			batt_current;
-	unsigned int		batt_health;
-	unsigned int		batt_vcell;
-	unsigned int		batt_soc;
-	unsigned int		charging_status;
-	bool			recharging;
-	unsigned long		charging_start_time;
-
-	struct workqueue_struct *monitor_wqueue;
-	struct work_struct	monitor_work;
-	struct work_struct	charger_work;
-
-	struct alarm		monitor_alarm;
-	ktime_t			last_poll;
-
-	struct dentry		*debugfs_entry;
-};
-
-static enum power_supply_property android_battery_props[] = {
-	POWER_SUPPLY_PROP_STATUS,
-	POWER_SUPPLY_PROP_HEALTH,
-	POWER_SUPPLY_PROP_PRESENT,
-	POWER_SUPPLY_PROP_TEMP,
-	POWER_SUPPLY_PROP_ONLINE,
-	POWER_SUPPLY_PROP_VOLTAGE_NOW,
-	POWER_SUPPLY_PROP_CAPACITY,
-	POWER_SUPPLY_PROP_TECHNOLOGY,
-	POWER_SUPPLY_PROP_CURRENT_NOW,
-};
-
-static DEFINE_MUTEX(android_bat_state_lock);
-
-static void android_bat_update_data(struct android_bat_data *battery);
-static int android_bat_enable_charging(struct android_bat_data *battery,
-					bool enable);
-
-static char *charge_source_str(int charge_source)
-{
-	switch (charge_source) {
-	case CHARGE_SOURCE_NONE:
-		return "none";
-	case CHARGE_SOURCE_AC:
-		return "ac";
-	case CHARGE_SOURCE_USB:
-		return "usb";
-	default:
-		break;
-	}
-
-	return "?";
-}
-
-static int android_bat_get_property(struct power_supply *ps,
-				enum power_supply_property psp,
-				union power_supply_propval *val)
-{
-	struct android_bat_data *battery =
-		container_of(ps, struct android_bat_data, psy_bat);
-
-	switch (psp) {
-	case POWER_SUPPLY_PROP_STATUS:
-		val->intval = battery->charging_status;
-		break;
-	case POWER_SUPPLY_PROP_HEALTH:
-		val->intval = battery->batt_health;
-		break;
-	case POWER_SUPPLY_PROP_PRESENT:
-		val->intval = 1;
-		break;
-	case POWER_SUPPLY_PROP_TEMP:
-		val->intval = battery->batt_temp;
-		break;
-	case POWER_SUPPLY_PROP_ONLINE:
-		val->intval = 1;
-		break;
-	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
-		android_bat_update_data(battery);
-		val->intval = battery->batt_vcell;
-		if (val->intval == -1)
-			return -EINVAL;
-		break;
-	case POWER_SUPPLY_PROP_CAPACITY:
-		val->intval = battery->batt_soc;
-		if (val->intval == -1)
-			return -EINVAL;
-		break;
-	case POWER_SUPPLY_PROP_TECHNOLOGY:
-		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
-		break;
-	case POWER_SUPPLY_PROP_CURRENT_NOW:
-		android_bat_update_data(battery);
-		val->intval = battery->batt_current;
-		break;
-	default:
-		return -EINVAL;
-	}
-	return 0;
-}
-
-static void android_bat_get_temp(struct android_bat_data *battery)
-{
-	int batt_temp = 42; /* 4.2C */
-	int health = battery->batt_health;
-
-	if (battery->pdata->get_temperature)
-		battery->pdata->get_temperature(&batt_temp);
-
-	if (battery->charge_source != CHARGE_SOURCE_NONE) {
-		if (batt_temp >= battery->pdata->temp_high_threshold) {
-			if (health != POWER_SUPPLY_HEALTH_OVERHEAT &&
-				health != POWER_SUPPLY_HEALTH_UNSPEC_FAILURE) {
-				pr_info("battery overheat (%d>=%d), " \
-					"charging unavailable\n",
-					batt_temp,
-					battery->pdata->temp_high_threshold);
-				battery->batt_health =
-					POWER_SUPPLY_HEALTH_OVERHEAT;
-			}
-		} else if (batt_temp <= battery->pdata->temp_high_recovery &&
-			batt_temp >= battery->pdata->temp_low_recovery) {
-			if (health == POWER_SUPPLY_HEALTH_OVERHEAT ||
-				health == POWER_SUPPLY_HEALTH_COLD) {
-				pr_info("battery recovery (%d,%d~%d),"	\
-					"charging available\n",
-					batt_temp,
-					battery->pdata->temp_low_recovery,
-					battery->pdata->temp_high_recovery);
-				battery->batt_health =
-					POWER_SUPPLY_HEALTH_GOOD;
-			}
-		} else if (batt_temp <= battery->pdata->temp_low_threshold) {
-			if (health != POWER_SUPPLY_HEALTH_COLD &&
-				health != POWER_SUPPLY_HEALTH_UNSPEC_FAILURE) {
-				pr_info("battery cold (%d <= %d),"	\
-					"charging unavailable\n",
-					batt_temp,
-					battery->pdata->temp_low_threshold);
-				battery->batt_health =
-					POWER_SUPPLY_HEALTH_COLD;
-			}
-		}
-	}
-
-	battery->batt_temp = batt_temp;
-}
-
-/*
- * android_bat_state_lock not held, may call back into
- * android_bat_charge_source_changed.  Gathering data here can be
- * non-atomic; updating our state based on the data may need to be
- * atomic.
- */
-
-static void android_bat_update_data(struct android_bat_data *battery)
-{
-	int ret;
-	int v;
-
-	if (battery->pdata->poll_charge_source)
-		battery->charge_source = battery->pdata->poll_charge_source();
-
-	if (battery->pdata->get_voltage_now) {
-		ret = battery->pdata->get_voltage_now();
-		battery->batt_vcell = ret >= 0 ? ret : 4242000;
-	}
-
-	if (battery->pdata->get_capacity) {
-		ret = battery->pdata->get_capacity();
-		battery->batt_soc = ret >= 0 ? ret : 42;
-	}
-
-	if (battery->pdata->get_current_now) {
-		ret = battery->pdata->get_current_now(&v);
-
-		if (!ret)
-			battery->batt_current = v;
-	}
-
-	android_bat_get_temp(battery);
-}
-
-static void android_bat_set_charge_time(struct android_bat_data *battery,
-					bool enable)
-{
-	if (enable && !battery->charging_start_time) {
-		struct timespec cur_time;
-
-		get_monotonic_boottime(&cur_time);
-		/* record start time for charge timeout timer */
-		battery->charging_start_time = cur_time.tv_sec;
-	} else if (!enable) {
-		/* clear charge timeout timer */
-		battery->charging_start_time = 0;
-	}
-}
-
-static int android_bat_enable_charging(struct android_bat_data *battery,
-				       bool enable)
-{
-	if (enable && (battery->batt_health != POWER_SUPPLY_HEALTH_GOOD)) {
-		battery->charging_status =
-		    POWER_SUPPLY_STATUS_NOT_CHARGING;
-		return -EPERM;
-	}
-
-	if (enable) {
-		if (battery->pdata && battery->pdata->set_charging_current)
-			battery->pdata->set_charging_current
-			(battery->charge_source);
-	}
-
-	if (battery->pdata && battery->pdata->set_charging_enable)
-		battery->pdata->set_charging_enable(enable);
-
-	android_bat_set_charge_time(battery, enable);
-	pr_info("battery: enable=%d charger: %s\n", enable,
-		charge_source_str(battery->charge_source));
-	return 0;
-}
-
-static bool android_bat_charge_timeout(struct android_bat_data *battery,
-				       unsigned long timeout)
-{
-	struct timespec cur_time;
-
-	if (!battery->charging_start_time)
-		return 0;
-
-	get_monotonic_boottime(&cur_time);
-	pr_debug("%s: Start time: %ld, End time: %ld, current time: %ld\n",
-		 __func__, battery->charging_start_time,
-		 battery->charging_start_time + timeout,
-		 cur_time.tv_sec);
-	return cur_time.tv_sec >= battery->charging_start_time + timeout;
-}
-
-static void android_bat_charging_timer(struct android_bat_data *battery)
-{
-	if (!battery->charging_start_time &&
-	    battery->charging_status == POWER_SUPPLY_STATUS_CHARGING) {
-		android_bat_enable_charging(battery, true);
-		battery->recharging = true;
-		pr_debug("%s: charge status charging but timer is expired\n",
-			__func__);
-	} else if (battery->charging_start_time == 0) {
-		pr_debug("%s: charging_start_time never initialized\n",
-				__func__);
-		return;
-	}
-
-	if (android_bat_charge_timeout(
-		    battery,
-		    battery->recharging ? battery->pdata->recharging_time :
-		    battery->pdata->full_charging_time)) {
-		android_bat_enable_charging(battery, false);
-		if (battery->batt_vcell >
-		    battery->pdata->recharging_voltage &&
-		    battery->batt_soc == 100)
-			battery->charging_status =
-				POWER_SUPPLY_STATUS_FULL;
-		battery->recharging = false;
-		battery->charging_start_time = 0;
-		pr_info("battery: charging timer expired\n");
-	}
-
-	return;
-}
-
-static void android_bat_charge_source_changed(struct android_bat_callbacks *ptr,
-					      int charge_source)
-{
-	struct android_bat_data *battery =
-		container_of(ptr, struct android_bat_data, callbacks);
-
-	wake_lock(&battery->charger_wake_lock);
-	mutex_lock(&android_bat_state_lock);
-	battery->charge_source = charge_source;
-
-	pr_info("battery: charge source type was changed: %s\n",
-		charge_source_str(battery->charge_source));
-
-	mutex_unlock(&android_bat_state_lock);
-	queue_work(battery->monitor_wqueue, &battery->charger_work);
-}
-
-static void android_bat_set_full_status(struct android_bat_callbacks *ptr)
-{
-	struct android_bat_data *battery =
-		container_of(ptr, struct android_bat_data, callbacks);
-
-	mutex_lock(&android_bat_state_lock);
-	pr_info("battery: battery full\n");
-	battery->charging_status = POWER_SUPPLY_STATUS_FULL;
-	android_bat_enable_charging(battery, false);
-	battery->recharging = false;
-	mutex_unlock(&android_bat_state_lock);
-	power_supply_changed(&battery->psy_bat);
-}
-
-static void android_bat_charger_work(struct work_struct *work)
-{
-	struct android_bat_data *battery =
-		container_of(work, struct android_bat_data, charger_work);
-
-	mutex_lock(&android_bat_state_lock);
-
-	switch (battery->charge_source) {
-	case CHARGE_SOURCE_NONE:
-		battery->charging_status = POWER_SUPPLY_STATUS_DISCHARGING;
-		android_bat_enable_charging(battery, false);
-		battery->batt_health = POWER_SUPPLY_HEALTH_GOOD;
-		battery->recharging = false;
-		battery->charging_start_time = 0;
-		break;
-	case CHARGE_SOURCE_USB:
-	case CHARGE_SOURCE_AC:
-		/*
-		 * If charging status indicates a charger was already
-		 * connected prior to this and the status is something
-		 * other than charging ("full" or "not-charging"), leave
-		 * the status alone.
-		 */
-		if (battery->charging_status ==
-		    POWER_SUPPLY_STATUS_DISCHARGING ||
-		    battery->charging_status == POWER_SUPPLY_STATUS_UNKNOWN)
-			battery->charging_status = POWER_SUPPLY_STATUS_CHARGING;
-
-		/*
-		 * Don't re-enable charging if the battery is full and we
-		 * are not actively re-charging it, or if "not-charging"
-		 * status is set.
-		 */
-		if (!((battery->charging_status == POWER_SUPPLY_STATUS_FULL
-		       && !battery->recharging) || battery->charging_status ==
-		      POWER_SUPPLY_STATUS_NOT_CHARGING))
-			android_bat_enable_charging(battery, true);
-
-		break;
-	default:
-		pr_err("%s: Invalid charger type\n", __func__);
-		break;
-	}
-
-	mutex_unlock(&android_bat_state_lock);
-	wake_lock_timeout(&battery->charger_wake_lock, HZ * 2);
-	power_supply_changed(&battery->psy_bat);
-}
-
-
-static void android_bat_monitor_set_alarm(struct android_bat_data *battery,
-					  int seconds)
-{
-	alarm_start(&battery->monitor_alarm,
-		    ktime_add(battery->last_poll, ktime_set(seconds, 0)));
-}
-
-static void android_bat_monitor_work(struct work_struct *work)
-{
-	struct android_bat_data *battery =
-		container_of(work, struct android_bat_data, monitor_work);
-	struct timespec cur_time;
-
-	wake_lock(&battery->monitor_wake_lock);
-	android_bat_update_data(battery);
-	mutex_lock(&android_bat_state_lock);
-
-	switch (battery->charging_status) {
-	case POWER_SUPPLY_STATUS_FULL:
-		if (battery->batt_vcell < battery->pdata->recharging_voltage &&
-		    !battery->recharging) {
-			battery->recharging = true;
-			android_bat_enable_charging(battery, true);
-			pr_info("battery: start recharging, v=%d\n",
-				battery->batt_vcell/1000);
-		}
-		break;
-	case POWER_SUPPLY_STATUS_DISCHARGING:
-		break;
-	case POWER_SUPPLY_STATUS_CHARGING:
-		switch (battery->batt_health) {
-		case POWER_SUPPLY_HEALTH_OVERHEAT:
-		case POWER_SUPPLY_HEALTH_COLD:
-		case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
-		case POWER_SUPPLY_HEALTH_DEAD:
-		case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
-			battery->charging_status =
-				POWER_SUPPLY_STATUS_NOT_CHARGING;
-			android_bat_enable_charging(battery, false);
-
-			pr_info("battery: Not charging, health=%d\n",
-				battery->batt_health);
-			break;
-		default:
-			break;
-		}
-		break;
-	case POWER_SUPPLY_STATUS_NOT_CHARGING:
-		if (battery->batt_health == POWER_SUPPLY_HEALTH_GOOD) {
-			pr_info("battery: battery health recovered\n");
-			if (battery->charge_source != CHARGE_SOURCE_NONE) {
-				android_bat_enable_charging(battery, true);
-				battery->charging_status
-					= POWER_SUPPLY_STATUS_CHARGING;
-			} else {
-				battery->charging_status
-					= POWER_SUPPLY_STATUS_DISCHARGING;
-			}
-		}
-		break;
-	default:
-		pr_err("%s: Undefined battery status: %d\n", __func__,
-		       battery->charging_status);
-		break;
-	}
-
-	android_bat_charging_timer(battery);
-	get_monotonic_boottime(&cur_time);
-	pr_info("battery: l=%d v=%d c=%d temp=%s%ld.%ld h=%d st=%d%s ct=%lu type=%s\n",
-		battery->batt_soc, battery->batt_vcell/1000,
-		battery->batt_current, battery->batt_temp < 0 ? "-" : "",
-		abs(battery->batt_temp / 10), abs(battery->batt_temp % 10),
-		battery->batt_health, battery->charging_status,
-		   battery->recharging ? "r" : "",
-		   battery->charging_start_time ?
-		   cur_time.tv_sec - battery->charging_start_time : 0,
-		charge_source_str(battery->charge_source));
-	mutex_unlock(&android_bat_state_lock);
-	power_supply_changed(&battery->psy_bat);
-	battery->last_poll = ktime_get_boottime();
-	android_bat_monitor_set_alarm(battery, FAST_POLL);
-	wake_unlock(&battery->monitor_wake_lock);
-	return;
-}
-
-static enum alarmtimer_restart android_bat_monitor_alarm(
-	struct alarm *alarm, ktime_t now)
-{
-	struct android_bat_data *battery =
-		container_of(alarm, struct android_bat_data, monitor_alarm);
-
-	wake_lock(&battery->monitor_wake_lock);
-	queue_work(battery->monitor_wqueue, &battery->monitor_work);
-	return ALARMTIMER_NORESTART;
-}
-
-static int android_power_debug_dump(struct seq_file *s, void *unused)
-{
-	struct android_bat_data *battery = s->private;
-	struct timespec cur_time;
-
-	android_bat_update_data(battery);
-	get_monotonic_boottime(&cur_time);
-	mutex_lock(&android_bat_state_lock);
-	seq_printf(s, "l=%d v=%d c=%d temp=%s%ld.%ld h=%d st=%d%s ct=%lu type=%s\n",
-		   battery->batt_soc, battery->batt_vcell/1000,
-		   battery->batt_current, battery->batt_temp < 0 ? "-" : "",
-		   abs(battery->batt_temp / 10), abs(battery->batt_temp % 10),
-		   battery->batt_health, battery->charging_status,
-		   battery->recharging ? "r" : "",
-		   battery->charging_start_time ?
-		   cur_time.tv_sec - battery->charging_start_time : 0,
-		   charge_source_str(battery->charge_source));
-	mutex_unlock(&android_bat_state_lock);
-	return 0;
-}
-
-static int android_power_debug_open(struct inode *inode, struct file *file)
-{
-	return single_open(file, android_power_debug_dump, inode->i_private);
-}
-
-static const struct file_operations android_power_debug_fops = {
-	.open = android_power_debug_open,
-	.read = seq_read,
-	.llseek = seq_lseek,
-	.release = single_release,
-};
-
-static int android_bat_probe(struct platform_device *pdev)
-{
-	struct android_bat_platform_data *pdata = dev_get_platdata(&pdev->dev);
-	struct android_bat_data *battery;
-	int ret = 0;
-
-	dev_info(&pdev->dev, "Android Battery Driver\n");
-	battery = kzalloc(sizeof(*battery), GFP_KERNEL);
-	if (!battery)
-		return -ENOMEM;
-
-	battery->pdata = pdata;
-	if (!battery->pdata) {
-		pr_err("%s : No platform data\n", __func__);
-		ret = -EINVAL;
-		goto err_pdata;
-	}
-
-	battery->dev = &pdev->dev;
-	platform_set_drvdata(pdev, battery);
-	battery->batt_health = POWER_SUPPLY_HEALTH_GOOD;
-
-	battery->psy_bat.name = "android-battery",
-	battery->psy_bat.type = POWER_SUPPLY_TYPE_BATTERY,
-	battery->psy_bat.properties = android_battery_props,
-	battery->psy_bat.num_properties = ARRAY_SIZE(android_battery_props),
-	battery->psy_bat.get_property = android_bat_get_property,
-
-	battery->batt_vcell = -1;
-	battery->batt_soc = -1;
-
-	wake_lock_init(&battery->monitor_wake_lock, WAKE_LOCK_SUSPEND,
-			"android-battery-monitor");
-	wake_lock_init(&battery->charger_wake_lock, WAKE_LOCK_SUSPEND,
-			"android-chargerdetect");
-
-	ret = power_supply_register(&pdev->dev, &battery->psy_bat);
-	if (ret) {
-		dev_err(battery->dev, "%s: failed to register psy_bat\n",
-			__func__);
-		goto err_psy_bat_reg;
-	}
-
-	battery->monitor_wqueue =
-		alloc_workqueue(dev_name(&pdev->dev), WQ_FREEZABLE, 1);
-	if (!battery->monitor_wqueue) {
-		dev_err(battery->dev, "%s: fail to create workqueue\n",
-				__func__);
-		goto err_wq;
-	}
-
-	INIT_WORK(&battery->monitor_work, android_bat_monitor_work);
-	INIT_WORK(&battery->charger_work, android_bat_charger_work);
-
-	battery->callbacks.charge_source_changed =
-		android_bat_charge_source_changed;
-	battery->callbacks.battery_set_full =
-		android_bat_set_full_status;
-	if (battery->pdata && battery->pdata->register_callbacks)
-		battery->pdata->register_callbacks(&battery->callbacks);
-
-	/* get initial charger status */
-	if (battery->pdata->poll_charge_source)
-		battery->charge_source = battery->pdata->poll_charge_source();
-
-	wake_lock(&battery->charger_wake_lock);
-	queue_work(battery->monitor_wqueue, &battery->charger_work);
-
-	wake_lock(&battery->monitor_wake_lock);
-	battery->last_poll = ktime_get_boottime();
-	alarm_init(&battery->monitor_alarm, ALARM_BOOTTIME,
-		   android_bat_monitor_alarm);
-	queue_work(battery->monitor_wqueue, &battery->monitor_work);
-
-	battery->debugfs_entry =
-		debugfs_create_file("android-power", S_IRUGO, NULL,
-				    battery, &android_power_debug_fops);
-	if (!battery->debugfs_entry)
-		pr_err("failed to create android-power debugfs entry\n");
-
-	return 0;
-
-err_wq:
-	power_supply_unregister(&battery->psy_bat);
-err_psy_bat_reg:
-	wake_lock_destroy(&battery->monitor_wake_lock);
-	wake_lock_destroy(&battery->charger_wake_lock);
-err_pdata:
-	kfree(battery);
-
-	return ret;
-}
-
-static int android_bat_remove(struct platform_device *pdev)
-{
-	struct android_bat_data *battery = platform_get_drvdata(pdev);
-
-	alarm_cancel(&battery->monitor_alarm);
-	flush_workqueue(battery->monitor_wqueue);
-	destroy_workqueue(battery->monitor_wqueue);
-	power_supply_unregister(&battery->psy_bat);
-	wake_lock_destroy(&battery->monitor_wake_lock);
-	wake_lock_destroy(&battery->charger_wake_lock);
-	debugfs_remove(battery->debugfs_entry);
-	kfree(battery);
-	return 0;
-}
-
-static int android_bat_suspend(struct device *dev)
-{
-	struct android_bat_data *battery = dev_get_drvdata(dev);
-
-	cancel_work_sync(&battery->monitor_work);
-	android_bat_monitor_set_alarm(
-		battery,
-		battery->charge_source == CHARGE_SOURCE_NONE ?
-		SLOW_POLL : FAST_POLL);
-	return 0;
-}
-
-static void android_bat_resume(struct device *dev)
-{
-	struct android_bat_data *battery = dev_get_drvdata(dev);
-
-	android_bat_monitor_set_alarm(battery, FAST_POLL);
-	return;
-}
-
-static const struct dev_pm_ops android_bat_pm_ops = {
-	.prepare = android_bat_suspend,
-	.complete = android_bat_resume,
-};
-
-static struct platform_driver android_bat_driver = {
-	.driver = {
-		.name = "android-battery",
-		.owner = THIS_MODULE,
-		.pm = &android_bat_pm_ops,
-	},
-	.probe = android_bat_probe,
-	.remove = android_bat_remove,
-};
-
-static int __init android_bat_init(void)
-{
-	return platform_driver_register(&android_bat_driver);
-}
-
-static void __exit android_bat_exit(void)
-{
-	platform_driver_unregister(&android_bat_driver);
-}
-
-late_initcall(android_bat_init);
-module_exit(android_bat_exit);
-
-MODULE_DESCRIPTION("Android battery driver");
-MODULE_LICENSE("GPL");
diff --git a/include/linux/platform_data/android_battery.h b/include/linux/platform_data/android_battery.h
deleted file mode 100644
index f6c8298fd88..00000000000
--- a/include/linux/platform_data/android_battery.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- *  android_battery.h
- *
- *  Copyright (C) 2012 Samsung Electronics
- *
- * 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.
- */
-
-#ifndef _LINUX_ANDROID_BATTERY_H
-#define _LINUX_ANDROID_BATTERY_H
-
-enum {
-	CHARGE_SOURCE_NONE = 0,
-	CHARGE_SOURCE_AC,
-	CHARGE_SOURCE_USB,
-};
-
-struct android_bat_callbacks {
-	void (*charge_source_changed)
-		(struct android_bat_callbacks *, int);
-	void (*battery_set_full)(struct android_bat_callbacks *);
-};
-
-struct android_bat_platform_data {
-	void (*register_callbacks)(struct android_bat_callbacks *);
-	void (*unregister_callbacks)(void);
-	void (*set_charging_current) (int);
-	void (*set_charging_enable) (int);
-	int (*poll_charge_source) (void);
-	int (*get_capacity) (void);
-	int (*get_temperature) (int *);
-	int (*get_voltage_now)(void);
-	int (*get_current_now)(int *);
-
-	int temp_high_threshold;
-	int temp_high_recovery;
-	int temp_low_recovery;
-	int temp_low_threshold;
-
-	unsigned long full_charging_time;
-	unsigned long recharging_time;
-	unsigned int recharging_voltage;
-};
-
-#endif