diff options
author | Todd Poynor | 2013-07-30 18:45:24 -0500 |
---|---|---|
committer | Colin Cross | 2013-09-19 13:55:39 -0500 |
commit | b396b36a15b27767215ea6a35174a6dba0302ba1 (patch) | |
tree | e4411c0057bde7460e4178c8eb8219b82700f2d0 | |
parent | 2f42fa9141974d917c5a85fc484e48f53cf7ec71 (diff) | |
download | kernel-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>
-rw-r--r-- | android/configs/android-recommended.cfg | 1 | ||||
-rw-r--r-- | drivers/power/Kconfig | 10 | ||||
-rw-r--r-- | drivers/power/Makefile | 1 | ||||
-rw-r--r-- | drivers/power/android_battery.c | 692 | ||||
-rw-r--r-- | include/linux/platform_data/android_battery.h | 47 |
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 | |||
11 | CONFIG_ANDROID_RAM_CONSOLE=y | 11 | CONFIG_ANDROID_RAM_CONSOLE=y |
12 | CONFIG_ANDROID_TIMED_GPIO=y | 12 | CONFIG_ANDROID_TIMED_GPIO=y |
13 | CONFIG_BACKLIGHT_LCD_SUPPORT=y | 13 | CONFIG_BACKLIGHT_LCD_SUPPORT=y |
14 | CONFIG_BATTERY_ANDROID=y | ||
15 | CONFIG_BLK_DEV_LOOP=y | 14 | CONFIG_BLK_DEV_LOOP=y |
16 | CONFIG_BLK_DEV_RAM=y | 15 | CONFIG_BLK_DEV_RAM=y |
17 | CONFIG_BLK_DEV_RAM_SIZE=8192 | 16 | 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 | |||
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 | ||
207 | config 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 | |||
217 | config BATTERY_Z2 | 207 | config 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 | |||
16 | obj-$(CONFIG_TEST_POWER) += test_power.o | 16 | obj-$(CONFIG_TEST_POWER) += test_power.o |
17 | 17 | ||
18 | obj-$(CONFIG_BATTERY_88PM860X) += 88pm860x_battery.o | 18 | obj-$(CONFIG_BATTERY_88PM860X) += 88pm860x_battery.o |
19 | obj-$(CONFIG_BATTERY_ANDROID) += android_battery.o | ||
20 | obj-$(CONFIG_BATTERY_DS2760) += ds2760_battery.o | 19 | obj-$(CONFIG_BATTERY_DS2760) += ds2760_battery.o |
21 | obj-$(CONFIG_BATTERY_DS2780) += ds2780_battery.o | 20 | obj-$(CONFIG_BATTERY_DS2780) += ds2780_battery.o |
22 | obj-$(CONFIG_BATTERY_DS2781) += ds2781_battery.o | 21 | 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 @@ | |||
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 | |||
43 | struct 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 | |||
75 | static 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 | |||
87 | static DEFINE_MUTEX(android_bat_state_lock); | ||
88 | |||
89 | static void android_bat_update_data(struct android_bat_data *battery); | ||
90 | static int android_bat_enable_charging(struct android_bat_data *battery, | ||
91 | bool enable); | ||
92 | |||
93 | static 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 | |||
109 | static 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 | |||
156 | static 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 | |||
210 | static 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 | |||
238 | static 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 | |||
253 | static 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 | |||
277 | static 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 | |||
293 | static 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 | |||
325 | static 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 | |||
342 | static 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 | |||
356 | static 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 | |||
406 | static 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 | |||
413 | static 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 | |||
491 | static 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 | |||
502 | static 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 | |||
523 | static 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 | |||
528 | static 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 | |||
535 | static 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 | |||
617 | err_wq: | ||
618 | power_supply_unregister(&battery->psy_bat); | ||
619 | err_psy_bat_reg: | ||
620 | wake_lock_destroy(&battery->monitor_wake_lock); | ||
621 | wake_lock_destroy(&battery->charger_wake_lock); | ||
622 | err_pdata: | ||
623 | kfree(battery); | ||
624 | |||
625 | return ret; | ||
626 | } | ||
627 | |||
628 | static 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 | |||
643 | static 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 | |||
655 | static 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 | |||
663 | static const struct dev_pm_ops android_bat_pm_ops = { | ||
664 | .prepare = android_bat_suspend, | ||
665 | .complete = android_bat_resume, | ||
666 | }; | ||
667 | |||
668 | static 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 | |||
678 | static int __init android_bat_init(void) | ||
679 | { | ||
680 | return platform_driver_register(&android_bat_driver); | ||
681 | } | ||
682 | |||
683 | static void __exit android_bat_exit(void) | ||
684 | { | ||
685 | platform_driver_unregister(&android_bat_driver); | ||
686 | } | ||
687 | |||
688 | late_initcall(android_bat_init); | ||
689 | module_exit(android_bat_exit); | ||
690 | |||
691 | MODULE_DESCRIPTION("Android battery driver"); | ||
692 | 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 @@ | |||
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 | |||
14 | enum { | ||
15 | CHARGE_SOURCE_NONE = 0, | ||
16 | CHARGE_SOURCE_AC, | ||
17 | CHARGE_SOURCE_USB, | ||
18 | }; | ||
19 | |||
20 | struct 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 | |||
26 | struct 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 | ||