aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorTodd Poynor2013-07-30 18:45:24 -0500
committerColin Cross2013-09-19 13:55:39 -0500
commitb396b36a15b27767215ea6a35174a6dba0302ba1 (patch)
treee4411c0057bde7460e4178c8eb8219b82700f2d0
parent2f42fa9141974d917c5a85fc484e48f53cf7ec71 (diff)
downloadkernel-common-b396b36a15b27767215ea6a35174a6dba0302ba1.tar.gz
kernel-common-b396b36a15b27767215ea6a35174a6dba0302ba1.tar.xz
kernel-common-b396b36a15b27767215ea6a35174a6dba0302ba1.zip
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>
Diffstat
-rw-r--r--android/configs/android-recommended.cfg1
-rw-r--r--drivers/power/Kconfig10
-rw-r--r--drivers/power/Makefile1
-rw-r--r--drivers/power/android_battery.c692
-rw-r--r--include/linux/platform_data/android_battery.h47
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
11CONFIG_ANDROID_RAM_CONSOLE=y 11CONFIG_ANDROID_RAM_CONSOLE=y
12CONFIG_ANDROID_TIMED_GPIO=y 12CONFIG_ANDROID_TIMED_GPIO=y
13CONFIG_BACKLIGHT_LCD_SUPPORT=y 13CONFIG_BACKLIGHT_LCD_SUPPORT=y
14CONFIG_BATTERY_ANDROID=y
15CONFIG_BLK_DEV_LOOP=y 14CONFIG_BLK_DEV_LOOP=y
16CONFIG_BLK_DEV_RAM=y 15CONFIG_BLK_DEV_RAM=y
17CONFIG_BLK_DEV_RAM_SIZE=8192 16CONFIG_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
204 with MAX17042. This driver also supports max17047/50 chips which are 204 with MAX17042. This driver also supports max17047/50 chips which are
205 improved version of max17042. 205 improved version of max17042.
206 206
207config BATTERY_ANDROID
208 tristate "Battery driver for Android"
209 help
210 Say Y to enable generic support for battery charging according
211 to common Android policies.
212 This driver adds periodic battery level and health monitoring,
213 kernel log reporting and other debugging features, common board
214 battery file glue logic for battery/case temperature sensors,
215 etc.
216
217config BATTERY_Z2 207config BATTERY_Z2
218 tristate "Z2 battery driver" 208 tristate "Z2 battery driver"
219 depends on I2C && MACH_ZIPIT2 209 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
16obj-$(CONFIG_TEST_POWER) += test_power.o 16obj-$(CONFIG_TEST_POWER) += test_power.o
17 17
18obj-$(CONFIG_BATTERY_88PM860X) += 88pm860x_battery.o 18obj-$(CONFIG_BATTERY_88PM860X) += 88pm860x_battery.o
19obj-$(CONFIG_BATTERY_ANDROID) += android_battery.o
20obj-$(CONFIG_BATTERY_DS2760) += ds2760_battery.o 19obj-$(CONFIG_BATTERY_DS2760) += ds2760_battery.o
21obj-$(CONFIG_BATTERY_DS2780) += ds2780_battery.o 20obj-$(CONFIG_BATTERY_DS2780) += ds2780_battery.o
22obj-$(CONFIG_BATTERY_DS2781) += ds2781_battery.o 21obj-$(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 @@
1/*
2 * android_battery.c
3 * Android Battery Driver
4 *
5 * Copyright (C) 2012 Google, Inc.
6 * Copyright (C) 2012 Samsung Electronics
7 *
8 * Based on work by himihee.seo@samsung.com, ms925.kim@samsung.com, and
9 * joshua.chang@samsung.com.
10 *
11 * This software is licensed under the terms of the GNU General Public
12 * License version 2, as published by the Free Software Foundation, and
13 * may be copied, distributed, and modified under those terms.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 */
20
21#include <linux/types.h>
22#include <linux/module.h>
23#include <linux/delay.h>
24#include <linux/err.h>
25#include <linux/init.h>
26#include <linux/interrupt.h>
27#include <linux/io.h>
28#include <linux/jiffies.h>
29#include <linux/platform_device.h>
30#include <linux/power_supply.h>
31#include <linux/slab.h>
32#include <linux/wakelock.h>
33#include <linux/workqueue.h>
34#include <linux/alarmtimer.h>
35#include <linux/timer.h>
36#include <linux/mutex.h>
37#include <linux/debugfs.h>
38#include <linux/platform_data/android_battery.h>
39
40#define FAST_POLL (1 * 60)
41#define SLOW_POLL (10 * 60)
42
43struct android_bat_data {
44 struct android_bat_platform_data *pdata;
45 struct android_bat_callbacks callbacks;
46
47 struct device *dev;
48
49 struct power_supply psy_bat;
50
51 struct wake_lock monitor_wake_lock;
52 struct wake_lock charger_wake_lock;
53
54 int charge_source;
55
56 int batt_temp;
57 int batt_current;
58 unsigned int batt_health;
59 unsigned int batt_vcell;
60 unsigned int batt_soc;
61 unsigned int charging_status;
62 bool recharging;
63 unsigned long charging_start_time;
64
65 struct workqueue_struct *monitor_wqueue;
66 struct work_struct monitor_work;
67 struct work_struct charger_work;
68
69 struct alarm monitor_alarm;
70 ktime_t last_poll;
71
72 struct dentry *debugfs_entry;
73};
74
75static enum power_supply_property android_battery_props[] = {
76 POWER_SUPPLY_PROP_STATUS,
77 POWER_SUPPLY_PROP_HEALTH,
78 POWER_SUPPLY_PROP_PRESENT,
79 POWER_SUPPLY_PROP_TEMP,
80 POWER_SUPPLY_PROP_ONLINE,
81 POWER_SUPPLY_PROP_VOLTAGE_NOW,
82 POWER_SUPPLY_PROP_CAPACITY,
83 POWER_SUPPLY_PROP_TECHNOLOGY,
84 POWER_SUPPLY_PROP_CURRENT_NOW,
85};
86
87static DEFINE_MUTEX(android_bat_state_lock);
88
89static void android_bat_update_data(struct android_bat_data *battery);
90static int android_bat_enable_charging(struct android_bat_data *battery,
91 bool enable);
92
93static char *charge_source_str(int charge_source)
94{
95 switch (charge_source) {
96 case CHARGE_SOURCE_NONE:
97 return "none";
98 case CHARGE_SOURCE_AC:
99 return "ac";
100 case CHARGE_SOURCE_USB:
101 return "usb";
102 default:
103 break;
104 }
105
106 return "?";
107}
108
109static int android_bat_get_property(struct power_supply *ps,
110 enum power_supply_property psp,
111 union power_supply_propval *val)
112{
113 struct android_bat_data *battery =
114 container_of(ps, struct android_bat_data, psy_bat);
115
116 switch (psp) {
117 case POWER_SUPPLY_PROP_STATUS:
118 val->intval = battery->charging_status;
119 break;
120 case POWER_SUPPLY_PROP_HEALTH:
121 val->intval = battery->batt_health;
122 break;
123 case POWER_SUPPLY_PROP_PRESENT:
124 val->intval = 1;
125 break;
126 case POWER_SUPPLY_PROP_TEMP:
127 val->intval = battery->batt_temp;
128 break;
129 case POWER_SUPPLY_PROP_ONLINE:
130 val->intval = 1;
131 break;
132 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
133 android_bat_update_data(battery);
134 val->intval = battery->batt_vcell;
135 if (val->intval == -1)
136 return -EINVAL;
137 break;
138 case POWER_SUPPLY_PROP_CAPACITY:
139 val->intval = battery->batt_soc;
140 if (val->intval == -1)
141 return -EINVAL;
142 break;
143 case POWER_SUPPLY_PROP_TECHNOLOGY:
144 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
145 break;
146 case POWER_SUPPLY_PROP_CURRENT_NOW:
147 android_bat_update_data(battery);
148 val->intval = battery->batt_current;
149 break;
150 default:
151 return -EINVAL;
152 }
153 return 0;
154}
155
156static void android_bat_get_temp(struct android_bat_data *battery)
157{
158 int batt_temp = 42; /* 4.2C */
159 int health = battery->batt_health;
160
161 if (battery->pdata->get_temperature)
162 battery->pdata->get_temperature(&batt_temp);
163
164 if (battery->charge_source != CHARGE_SOURCE_NONE) {
165 if (batt_temp >= battery->pdata->temp_high_threshold) {
166 if (health != POWER_SUPPLY_HEALTH_OVERHEAT &&
167 health != POWER_SUPPLY_HEALTH_UNSPEC_FAILURE) {
168 pr_info("battery overheat (%d>=%d), " \
169 "charging unavailable\n",
170 batt_temp,
171 battery->pdata->temp_high_threshold);
172 battery->batt_health =
173 POWER_SUPPLY_HEALTH_OVERHEAT;
174 }
175 } else if (batt_temp <= battery->pdata->temp_high_recovery &&
176 batt_temp >= battery->pdata->temp_low_recovery) {
177 if (health == POWER_SUPPLY_HEALTH_OVERHEAT ||
178 health == POWER_SUPPLY_HEALTH_COLD) {
179 pr_info("battery recovery (%d,%d~%d)," \
180 "charging available\n",
181 batt_temp,
182 battery->pdata->temp_low_recovery,
183 battery->pdata->temp_high_recovery);
184 battery->batt_health =
185 POWER_SUPPLY_HEALTH_GOOD;
186 }
187 } else if (batt_temp <= battery->pdata->temp_low_threshold) {
188 if (health != POWER_SUPPLY_HEALTH_COLD &&
189 health != POWER_SUPPLY_HEALTH_UNSPEC_FAILURE) {
190 pr_info("battery cold (%d <= %d)," \
191 "charging unavailable\n",
192 batt_temp,
193 battery->pdata->temp_low_threshold);
194 battery->batt_health =
195 POWER_SUPPLY_HEALTH_COLD;
196 }
197 }
198 }
199
200 battery->batt_temp = batt_temp;
201}
202
203/*
204 * android_bat_state_lock not held, may call back into
205 * android_bat_charge_source_changed. Gathering data here can be
206 * non-atomic; updating our state based on the data may need to be
207 * atomic.
208 */
209
210static void android_bat_update_data(struct android_bat_data *battery)
211{
212 int ret;
213 int v;
214
215 if (battery->pdata->poll_charge_source)
216 battery->charge_source = battery->pdata->poll_charge_source();
217
218 if (battery->pdata->get_voltage_now) {
219 ret = battery->pdata->get_voltage_now();
220 battery->batt_vcell = ret >= 0 ? ret : 4242000;
221 }
222
223 if (battery->pdata->get_capacity) {
224 ret = battery->pdata->get_capacity();
225 battery->batt_soc = ret >= 0 ? ret : 42;
226 }
227
228 if (battery->pdata->get_current_now) {
229 ret = battery->pdata->get_current_now(&v);
230
231 if (!ret)
232 battery->batt_current = v;
233 }
234
235 android_bat_get_temp(battery);
236}
237
238static void android_bat_set_charge_time(struct android_bat_data *battery,
239 bool enable)
240{
241 if (enable && !battery->charging_start_time) {
242 struct timespec cur_time;
243
244 get_monotonic_boottime(&cur_time);
245 /* record start time for charge timeout timer */
246 battery->charging_start_time = cur_time.tv_sec;
247 } else if (!enable) {
248 /* clear charge timeout timer */
249 battery->charging_start_time = 0;
250 }
251}
252
253static int android_bat_enable_charging(struct android_bat_data *battery,
254 bool enable)
255{
256 if (enable && (battery->batt_health != POWER_SUPPLY_HEALTH_GOOD)) {
257 battery->charging_status =
258 POWER_SUPPLY_STATUS_NOT_CHARGING;
259 return -EPERM;
260 }
261
262 if (enable) {
263 if (battery->pdata && battery->pdata->set_charging_current)
264 battery->pdata->set_charging_current
265 (battery->charge_source);
266 }
267
268 if (battery->pdata && battery->pdata->set_charging_enable)
269 battery->pdata->set_charging_enable(enable);
270
271 android_bat_set_charge_time(battery, enable);
272 pr_info("battery: enable=%d charger: %s\n", enable,
273 charge_source_str(battery->charge_source));
274 return 0;
275}
276
277static bool android_bat_charge_timeout(struct android_bat_data *battery,
278 unsigned long timeout)
279{
280 struct timespec cur_time;
281
282 if (!battery->charging_start_time)
283 return 0;
284
285 get_monotonic_boottime(&cur_time);
286 pr_debug("%s: Start time: %ld, End time: %ld, current time: %ld\n",
287 __func__, battery->charging_start_time,
288 battery->charging_start_time + timeout,
289 cur_time.tv_sec);
290 return cur_time.tv_sec >= battery->charging_start_time + timeout;
291}
292
293static void android_bat_charging_timer(struct android_bat_data *battery)
294{
295 if (!battery->charging_start_time &&
296 battery->charging_status == POWER_SUPPLY_STATUS_CHARGING) {
297 android_bat_enable_charging(battery, true);
298 battery->recharging = true;
299 pr_debug("%s: charge status charging but timer is expired\n",
300 __func__);
301 } else if (battery->charging_start_time == 0) {
302 pr_debug("%s: charging_start_time never initialized\n",
303 __func__);
304 return;
305 }
306
307 if (android_bat_charge_timeout(
308 battery,
309 battery->recharging ? battery->pdata->recharging_time :
310 battery->pdata->full_charging_time)) {
311 android_bat_enable_charging(battery, false);
312 if (battery->batt_vcell >
313 battery->pdata->recharging_voltage &&
314 battery->batt_soc == 100)
315 battery->charging_status =
316 POWER_SUPPLY_STATUS_FULL;
317 battery->recharging = false;
318 battery->charging_start_time = 0;
319 pr_info("battery: charging timer expired\n");
320 }
321
322 return;
323}
324
325static void android_bat_charge_source_changed(struct android_bat_callbacks *ptr,
326 int charge_source)
327{
328 struct android_bat_data *battery =
329 container_of(ptr, struct android_bat_data, callbacks);
330
331 wake_lock(&battery->charger_wake_lock);
332 mutex_lock(&android_bat_state_lock);
333 battery->charge_source = charge_source;
334
335 pr_info("battery: charge source type was changed: %s\n",
336 charge_source_str(battery->charge_source));
337
338 mutex_unlock(&android_bat_state_lock);
339 queue_work(battery->monitor_wqueue, &battery->charger_work);
340}
341
342static void android_bat_set_full_status(struct android_bat_callbacks *ptr)
343{
344 struct android_bat_data *battery =
345 container_of(ptr, struct android_bat_data, callbacks);
346
347 mutex_lock(&android_bat_state_lock);
348 pr_info("battery: battery full\n");
349 battery->charging_status = POWER_SUPPLY_STATUS_FULL;
350 android_bat_enable_charging(battery, false);
351 battery->recharging = false;
352 mutex_unlock(&android_bat_state_lock);
353 power_supply_changed(&battery->psy_bat);
354}
355
356static void android_bat_charger_work(struct work_struct *work)
357{
358 struct android_bat_data *battery =
359 container_of(work, struct android_bat_data, charger_work);
360
361 mutex_lock(&android_bat_state_lock);
362
363 switch (battery->charge_source) {
364 case CHARGE_SOURCE_NONE:
365 battery->charging_status = POWER_SUPPLY_STATUS_DISCHARGING;
366 android_bat_enable_charging(battery, false);
367 battery->batt_health = POWER_SUPPLY_HEALTH_GOOD;
368 battery->recharging = false;
369 battery->charging_start_time = 0;
370 break;
371 case CHARGE_SOURCE_USB:
372 case CHARGE_SOURCE_AC:
373 /*
374 * If charging status indicates a charger was already
375 * connected prior to this and the status is something
376 * other than charging ("full" or "not-charging"), leave
377 * the status alone.
378 */
379 if (battery->charging_status ==
380 POWER_SUPPLY_STATUS_DISCHARGING ||
381 battery->charging_status == POWER_SUPPLY_STATUS_UNKNOWN)
382 battery->charging_status = POWER_SUPPLY_STATUS_CHARGING;
383
384 /*
385 * Don't re-enable charging if the battery is full and we
386 * are not actively re-charging it, or if "not-charging"
387 * status is set.
388 */
389 if (!((battery->charging_status == POWER_SUPPLY_STATUS_FULL
390 && !battery->recharging) || battery->charging_status ==
391 POWER_SUPPLY_STATUS_NOT_CHARGING))
392 android_bat_enable_charging(battery, true);
393
394 break;
395 default:
396 pr_err("%s: Invalid charger type\n", __func__);
397 break;
398 }
399
400 mutex_unlock(&android_bat_state_lock);
401 wake_lock_timeout(&battery->charger_wake_lock, HZ * 2);
402 power_supply_changed(&battery->psy_bat);
403}
404
405
406static void android_bat_monitor_set_alarm(struct android_bat_data *battery,
407 int seconds)
408{
409 alarm_start(&battery->monitor_alarm,
410 ktime_add(battery->last_poll, ktime_set(seconds, 0)));
411}
412
413static void android_bat_monitor_work(struct work_struct *work)
414{
415 struct android_bat_data *battery =
416 container_of(work, struct android_bat_data, monitor_work);
417 struct timespec cur_time;
418
419 wake_lock(&battery->monitor_wake_lock);
420 android_bat_update_data(battery);
421 mutex_lock(&android_bat_state_lock);
422
423 switch (battery->charging_status) {
424 case POWER_SUPPLY_STATUS_FULL:
425 if (battery->batt_vcell < battery->pdata->recharging_voltage &&
426 !battery->recharging) {
427 battery->recharging = true;
428 android_bat_enable_charging(battery, true);
429 pr_info("battery: start recharging, v=%d\n",
430 battery->batt_vcell/1000);
431 }
432 break;
433 case POWER_SUPPLY_STATUS_DISCHARGING:
434 break;
435 case POWER_SUPPLY_STATUS_CHARGING:
436 switch (battery->batt_health) {
437 case POWER_SUPPLY_HEALTH_OVERHEAT:
438 case POWER_SUPPLY_HEALTH_COLD:
439 case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
440 case POWER_SUPPLY_HEALTH_DEAD:
441 case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
442 battery->charging_status =
443 POWER_SUPPLY_STATUS_NOT_CHARGING;
444 android_bat_enable_charging(battery, false);
445
446 pr_info("battery: Not charging, health=%d\n",
447 battery->batt_health);
448 break;
449 default:
450 break;
451 }
452 break;
453 case POWER_SUPPLY_STATUS_NOT_CHARGING:
454 if (battery->batt_health == POWER_SUPPLY_HEALTH_GOOD) {
455 pr_info("battery: battery health recovered\n");
456 if (battery->charge_source != CHARGE_SOURCE_NONE) {
457 android_bat_enable_charging(battery, true);
458 battery->charging_status
459 = POWER_SUPPLY_STATUS_CHARGING;
460 } else {
461 battery->charging_status
462 = POWER_SUPPLY_STATUS_DISCHARGING;
463 }
464 }
465 break;
466 default:
467 pr_err("%s: Undefined battery status: %d\n", __func__,
468 battery->charging_status);
469 break;
470 }
471
472 android_bat_charging_timer(battery);
473 get_monotonic_boottime(&cur_time);
474 pr_info("battery: l=%d v=%d c=%d temp=%s%ld.%ld h=%d st=%d%s ct=%lu type=%s\n",
475 battery->batt_soc, battery->batt_vcell/1000,
476 battery->batt_current, battery->batt_temp < 0 ? "-" : "",
477 abs(battery->batt_temp / 10), abs(battery->batt_temp % 10),
478 battery->batt_health, battery->charging_status,
479 battery->recharging ? "r" : "",
480 battery->charging_start_time ?
481 cur_time.tv_sec - battery->charging_start_time : 0,
482 charge_source_str(battery->charge_source));
483 mutex_unlock(&android_bat_state_lock);
484 power_supply_changed(&battery->psy_bat);
485 battery->last_poll = ktime_get_boottime();
486 android_bat_monitor_set_alarm(battery, FAST_POLL);
487 wake_unlock(&battery->monitor_wake_lock);
488 return;
489}
490
491static enum alarmtimer_restart android_bat_monitor_alarm(
492 struct alarm *alarm, ktime_t now)
493{
494 struct android_bat_data *battery =
495 container_of(alarm, struct android_bat_data, monitor_alarm);
496
497 wake_lock(&battery->monitor_wake_lock);
498 queue_work(battery->monitor_wqueue, &battery->monitor_work);
499 return ALARMTIMER_NORESTART;
500}
501
502static int android_power_debug_dump(struct seq_file *s, void *unused)
503{
504 struct android_bat_data *battery = s->private;
505 struct timespec cur_time;
506
507 android_bat_update_data(battery);
508 get_monotonic_boottime(&cur_time);
509 mutex_lock(&android_bat_state_lock);
510 seq_printf(s, "l=%d v=%d c=%d temp=%s%ld.%ld h=%d st=%d%s ct=%lu type=%s\n",
511 battery->batt_soc, battery->batt_vcell/1000,
512 battery->batt_current, battery->batt_temp < 0 ? "-" : "",
513 abs(battery->batt_temp / 10), abs(battery->batt_temp % 10),
514 battery->batt_health, battery->charging_status,
515 battery->recharging ? "r" : "",
516 battery->charging_start_time ?
517 cur_time.tv_sec - battery->charging_start_time : 0,
518 charge_source_str(battery->charge_source));
519 mutex_unlock(&android_bat_state_lock);
520 return 0;
521}
522
523static int android_power_debug_open(struct inode *inode, struct file *file)
524{
525 return single_open(file, android_power_debug_dump, inode->i_private);
526}
527
528static const struct file_operations android_power_debug_fops = {
529 .open = android_power_debug_open,
530 .read = seq_read,
531 .llseek = seq_lseek,
532 .release = single_release,
533};
534
535static int android_bat_probe(struct platform_device *pdev)
536{
537 struct android_bat_platform_data *pdata = dev_get_platdata(&pdev->dev);
538 struct android_bat_data *battery;
539 int ret = 0;
540
541 dev_info(&pdev->dev, "Android Battery Driver\n");
542 battery = kzalloc(sizeof(*battery), GFP_KERNEL);
543 if (!battery)
544 return -ENOMEM;
545
546 battery->pdata = pdata;
547 if (!battery->pdata) {
548 pr_err("%s : No platform data\n", __func__);
549 ret = -EINVAL;
550 goto err_pdata;
551 }
552
553 battery->dev = &pdev->dev;
554 platform_set_drvdata(pdev, battery);
555 battery->batt_health = POWER_SUPPLY_HEALTH_GOOD;
556
557 battery->psy_bat.name = "android-battery",
558 battery->psy_bat.type = POWER_SUPPLY_TYPE_BATTERY,
559 battery->psy_bat.properties = android_battery_props,
560 battery->psy_bat.num_properties = ARRAY_SIZE(android_battery_props),
561 battery->psy_bat.get_property = android_bat_get_property,
562
563 battery->batt_vcell = -1;
564 battery->batt_soc = -1;
565
566 wake_lock_init(&battery->monitor_wake_lock, WAKE_LOCK_SUSPEND,
567 "android-battery-monitor");
568 wake_lock_init(&battery->charger_wake_lock, WAKE_LOCK_SUSPEND,
569 "android-chargerdetect");
570
571 ret = power_supply_register(&pdev->dev, &battery->psy_bat);
572 if (ret) {
573 dev_err(battery->dev, "%s: failed to register psy_bat\n",
574 __func__);
575 goto err_psy_bat_reg;
576 }
577
578 battery->monitor_wqueue =
579 alloc_workqueue(dev_name(&pdev->dev), WQ_FREEZABLE, 1);
580 if (!battery->monitor_wqueue) {
581 dev_err(battery->dev, "%s: fail to create workqueue\n",
582 __func__);
583 goto err_wq;
584 }
585
586 INIT_WORK(&battery->monitor_work, android_bat_monitor_work);
587 INIT_WORK(&battery->charger_work, android_bat_charger_work);
588
589 battery->callbacks.charge_source_changed =
590 android_bat_charge_source_changed;
591 battery->callbacks.battery_set_full =
592 android_bat_set_full_status;
593 if (battery->pdata && battery->pdata->register_callbacks)
594 battery->pdata->register_callbacks(&battery->callbacks);
595
596 /* get initial charger status */
597 if (battery->pdata->poll_charge_source)
598 battery->charge_source = battery->pdata->poll_charge_source();
599
600 wake_lock(&battery->charger_wake_lock);
601 queue_work(battery->monitor_wqueue, &battery->charger_work);
602
603 wake_lock(&battery->monitor_wake_lock);
604 battery->last_poll = ktime_get_boottime();
605 alarm_init(&battery->monitor_alarm, ALARM_BOOTTIME,
606 android_bat_monitor_alarm);
607 queue_work(battery->monitor_wqueue, &battery->monitor_work);
608
609 battery->debugfs_entry =
610 debugfs_create_file("android-power", S_IRUGO, NULL,
611 battery, &android_power_debug_fops);
612 if (!battery->debugfs_entry)
613 pr_err("failed to create android-power debugfs entry\n");
614
615 return 0;
616
617err_wq:
618 power_supply_unregister(&battery->psy_bat);
619err_psy_bat_reg:
620 wake_lock_destroy(&battery->monitor_wake_lock);
621 wake_lock_destroy(&battery->charger_wake_lock);
622err_pdata:
623 kfree(battery);
624
625 return ret;
626}
627
628static int android_bat_remove(struct platform_device *pdev)
629{
630 struct android_bat_data *battery = platform_get_drvdata(pdev);
631
632 alarm_cancel(&battery->monitor_alarm);
633 flush_workqueue(battery->monitor_wqueue);
634 destroy_workqueue(battery->monitor_wqueue);
635 power_supply_unregister(&battery->psy_bat);
636 wake_lock_destroy(&battery->monitor_wake_lock);
637 wake_lock_destroy(&battery->charger_wake_lock);
638 debugfs_remove(battery->debugfs_entry);
639 kfree(battery);
640 return 0;
641}
642
643static int android_bat_suspend(struct device *dev)
644{
645 struct android_bat_data *battery = dev_get_drvdata(dev);
646
647 cancel_work_sync(&battery->monitor_work);
648 android_bat_monitor_set_alarm(
649 battery,
650 battery->charge_source == CHARGE_SOURCE_NONE ?
651 SLOW_POLL : FAST_POLL);
652 return 0;
653}
654
655static void android_bat_resume(struct device *dev)
656{
657 struct android_bat_data *battery = dev_get_drvdata(dev);
658
659 android_bat_monitor_set_alarm(battery, FAST_POLL);
660 return;
661}
662
663static const struct dev_pm_ops android_bat_pm_ops = {
664 .prepare = android_bat_suspend,
665 .complete = android_bat_resume,
666};
667
668static struct platform_driver android_bat_driver = {
669 .driver = {
670 .name = "android-battery",
671 .owner = THIS_MODULE,
672 .pm = &android_bat_pm_ops,
673 },
674 .probe = android_bat_probe,
675 .remove = android_bat_remove,
676};
677
678static int __init android_bat_init(void)
679{
680 return platform_driver_register(&android_bat_driver);
681}
682
683static void __exit android_bat_exit(void)
684{
685 platform_driver_unregister(&android_bat_driver);
686}
687
688late_initcall(android_bat_init);
689module_exit(android_bat_exit);
690
691MODULE_DESCRIPTION("Android battery driver");
692MODULE_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 @@
1/*
2 * android_battery.h
3 *
4 * Copyright (C) 2012 Samsung Electronics
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
11#ifndef _LINUX_ANDROID_BATTERY_H
12#define _LINUX_ANDROID_BATTERY_H
13
14enum {
15 CHARGE_SOURCE_NONE = 0,
16 CHARGE_SOURCE_AC,
17 CHARGE_SOURCE_USB,
18};
19
20struct android_bat_callbacks {
21 void (*charge_source_changed)
22 (struct android_bat_callbacks *, int);
23 void (*battery_set_full)(struct android_bat_callbacks *);
24};
25
26struct android_bat_platform_data {
27 void (*register_callbacks)(struct android_bat_callbacks *);
28 void (*unregister_callbacks)(void);
29 void (*set_charging_current) (int);
30 void (*set_charging_enable) (int);
31 int (*poll_charge_source) (void);
32 int (*get_capacity) (void);
33 int (*get_temperature) (int *);
34 int (*get_voltage_now)(void);
35 int (*get_current_now)(int *);
36
37 int temp_high_threshold;
38 int temp_high_recovery;
39 int temp_low_recovery;
40 int temp_low_threshold;
41
42 unsigned long full_charging_time;
43 unsigned long recharging_time;
44 unsigned int recharging_voltage;
45};
46
47#endif
generated by cgit v1.2.3 (git 2.39.2)