2 * Battery and Power Management code for the Sharp SL-C7xx and SL-Cxx00
5 * Copyright (c) 2004-2005 Richard Purdie
7 * Based on code written by Sharp for 2.4 kernels
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
17 #include <linux/module.h>
18 #include <linux/timer.h>
19 #include <linux/init.h>
20 #include <linux/kernel.h>
21 #include <linux/apm_bios.h>
22 #include <linux/delay.h>
23 #include <linux/interrupt.h>
24 #include <linux/platform_device.h>
25 #include <linux/leds.h>
26 #include <linux/apm-emulation.h>
27 #include <linux/suspend.h>
29 #include <mach/hardware.h>
32 #include <mach/pxa-regs.h>
33 #include <mach/pxa2xx-regs.h>
34 #include <mach/sharpsl.h>
35 #include <asm/hardware/sharpsl_pm.h>
40 #define SHARPSL_CHARGE_ON_TIME_INTERVAL (msecs_to_jiffies(1*60*1000)) /* 1 min */
41 #define SHARPSL_CHARGE_FINISH_TIME (msecs_to_jiffies(10*60*1000)) /* 10 min */
42 #define SHARPSL_BATCHK_TIME (msecs_to_jiffies(15*1000)) /* 15 sec */
43 #define SHARPSL_BATCHK_TIME_SUSPEND (60*10) /* 10 min */
45 #define SHARPSL_WAIT_CO_TIME 15 /* 15 sec */
46 #define SHARPSL_WAIT_DISCHARGE_ON 100 /* 100 msec */
47 #define SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP 10 /* 10 msec */
48 #define SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT 10 /* 10 msec */
49 #define SHARPSL_CHECK_BATTERY_WAIT_TIME_ACIN 10 /* 10 msec */
50 #define SHARPSL_CHARGE_WAIT_TIME 15 /* 15 msec */
51 #define SHARPSL_CHARGE_CO_CHECK_TIME 5 /* 5 msec */
52 #define SHARPSL_CHARGE_RETRY_CNT 1 /* eqv. 10 min */
57 static int sharpsl_off_charge_battery(void);
58 static int sharpsl_check_battery_temp(void);
59 static int sharpsl_check_battery_voltage(void);
60 static int sharpsl_ac_check(void);
61 static int sharpsl_fatal_check(void);
62 static int sharpsl_average_value(int ad
);
63 static void sharpsl_average_clear(void);
64 static void sharpsl_charge_toggle(struct work_struct
*private_
);
65 static void sharpsl_battery_thread(struct work_struct
*private_
);
71 struct sharpsl_pm_status sharpsl_pm
;
72 DECLARE_DELAYED_WORK(toggle_charger
, sharpsl_charge_toggle
);
73 DECLARE_DELAYED_WORK(sharpsl_bat
, sharpsl_battery_thread
);
74 DEFINE_LED_TRIGGER(sharpsl_charge_led_trigger
);
77 static int get_percentage(int voltage
)
79 int i
= sharpsl_pm
.machinfo
->bat_levels
- 1;
80 int bl_status
= sharpsl_pm
.machinfo
->backlight_get_status
? sharpsl_pm
.machinfo
->backlight_get_status() : 0;
81 struct battery_thresh
*thresh
;
83 if (sharpsl_pm
.charge_mode
== CHRG_ON
)
84 thresh
= bl_status
? sharpsl_pm
.machinfo
->bat_levels_acin_bl
: sharpsl_pm
.machinfo
->bat_levels_acin
;
86 thresh
= bl_status
? sharpsl_pm
.machinfo
->bat_levels_noac_bl
: sharpsl_pm
.machinfo
->bat_levels_noac
;
88 while (i
> 0 && (voltage
> thresh
[i
].voltage
))
91 return thresh
[i
].percentage
;
94 static int get_apm_status(int voltage
)
96 int low_thresh
, high_thresh
;
98 if (sharpsl_pm
.charge_mode
== CHRG_ON
) {
99 high_thresh
= sharpsl_pm
.machinfo
->status_high_acin
;
100 low_thresh
= sharpsl_pm
.machinfo
->status_low_acin
;
102 high_thresh
= sharpsl_pm
.machinfo
->status_high_noac
;
103 low_thresh
= sharpsl_pm
.machinfo
->status_low_noac
;
106 if (voltage
>= high_thresh
)
107 return APM_BATTERY_STATUS_HIGH
;
108 if (voltage
>= low_thresh
)
109 return APM_BATTERY_STATUS_LOW
;
110 return APM_BATTERY_STATUS_CRITICAL
;
113 void sharpsl_battery_kick(void)
115 schedule_delayed_work(&sharpsl_bat
, msecs_to_jiffies(125));
117 EXPORT_SYMBOL(sharpsl_battery_kick
);
120 static void sharpsl_battery_thread(struct work_struct
*private_
)
122 int voltage
, percent
, apm_status
, i
= 0;
124 if (!sharpsl_pm
.machinfo
)
127 sharpsl_pm
.battstat
.ac_status
= (sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
) ? APM_AC_ONLINE
: APM_AC_OFFLINE
);
129 /* Corgi cannot confirm when battery fully charged so periodically kick! */
130 if (!sharpsl_pm
.machinfo
->batfull_irq
&& (sharpsl_pm
.charge_mode
== CHRG_ON
)
131 && time_after(jiffies
, sharpsl_pm
.charge_start_time
+ SHARPSL_CHARGE_ON_TIME_INTERVAL
))
132 schedule_delayed_work(&toggle_charger
, 0);
135 voltage
= sharpsl_pm
.machinfo
->read_devdata(SHARPSL_BATT_VOLT
);
137 if (voltage
> 0) break;
139 voltage
= sharpsl_pm
.machinfo
->bat_levels_noac
[0].voltage
;
140 dev_warn(sharpsl_pm
.dev
, "Warning: Cannot read main battery!\n");
145 voltage
= sharpsl_average_value(voltage
);
146 apm_status
= get_apm_status(voltage
);
147 percent
= get_percentage(voltage
);
149 /* At low battery voltages, the voltage has a tendency to start
150 creeping back up so we try to avoid this here */
151 if ((sharpsl_pm
.battstat
.ac_status
== APM_AC_ONLINE
) || (apm_status
== APM_BATTERY_STATUS_HIGH
) || percent
<= sharpsl_pm
.battstat
.mainbat_percent
) {
152 sharpsl_pm
.battstat
.mainbat_voltage
= voltage
;
153 sharpsl_pm
.battstat
.mainbat_status
= apm_status
;
154 sharpsl_pm
.battstat
.mainbat_percent
= percent
;
157 dev_dbg(sharpsl_pm
.dev
, "Battery: voltage: %d, status: %d, percentage: %d, time: %ld\n", voltage
,
158 sharpsl_pm
.battstat
.mainbat_status
, sharpsl_pm
.battstat
.mainbat_percent
, jiffies
);
160 #ifdef CONFIG_BACKLIGHT_CORGI
161 /* If battery is low. limit backlight intensity to save power. */
162 if ((sharpsl_pm
.battstat
.ac_status
!= APM_AC_ONLINE
)
163 && ((sharpsl_pm
.battstat
.mainbat_status
== APM_BATTERY_STATUS_LOW
) ||
164 (sharpsl_pm
.battstat
.mainbat_status
== APM_BATTERY_STATUS_CRITICAL
))) {
165 if (!(sharpsl_pm
.flags
& SHARPSL_BL_LIMIT
)) {
166 sharpsl_pm
.machinfo
->backlight_limit(1);
167 sharpsl_pm
.flags
|= SHARPSL_BL_LIMIT
;
169 } else if (sharpsl_pm
.flags
& SHARPSL_BL_LIMIT
) {
170 sharpsl_pm
.machinfo
->backlight_limit(0);
171 sharpsl_pm
.flags
&= ~SHARPSL_BL_LIMIT
;
175 /* Suspend if critical battery level */
176 if ((sharpsl_pm
.battstat
.ac_status
!= APM_AC_ONLINE
)
177 && (sharpsl_pm
.battstat
.mainbat_status
== APM_BATTERY_STATUS_CRITICAL
)
178 && !(sharpsl_pm
.flags
& SHARPSL_APM_QUEUED
)) {
179 sharpsl_pm
.flags
|= SHARPSL_APM_QUEUED
;
180 dev_err(sharpsl_pm
.dev
, "Fatal Off\n");
181 apm_queue_event(APM_CRITICAL_SUSPEND
);
184 schedule_delayed_work(&sharpsl_bat
, SHARPSL_BATCHK_TIME
);
187 void sharpsl_pm_led(int val
)
189 if (val
== SHARPSL_LED_ERROR
) {
190 dev_err(sharpsl_pm
.dev
, "Charging Error!\n");
191 } else if (val
== SHARPSL_LED_ON
) {
192 dev_dbg(sharpsl_pm
.dev
, "Charge LED On\n");
193 led_trigger_event(sharpsl_charge_led_trigger
, LED_FULL
);
195 dev_dbg(sharpsl_pm
.dev
, "Charge LED Off\n");
196 led_trigger_event(sharpsl_charge_led_trigger
, LED_OFF
);
200 static void sharpsl_charge_on(void)
202 dev_dbg(sharpsl_pm
.dev
, "Turning Charger On\n");
204 sharpsl_pm
.full_count
= 0;
205 sharpsl_pm
.charge_mode
= CHRG_ON
;
206 schedule_delayed_work(&toggle_charger
, msecs_to_jiffies(250));
207 schedule_delayed_work(&sharpsl_bat
, msecs_to_jiffies(500));
210 static void sharpsl_charge_off(void)
212 dev_dbg(sharpsl_pm
.dev
, "Turning Charger Off\n");
214 sharpsl_pm
.machinfo
->charge(0);
215 sharpsl_pm_led(SHARPSL_LED_OFF
);
216 sharpsl_pm
.charge_mode
= CHRG_OFF
;
218 schedule_delayed_work(&sharpsl_bat
, 0);
221 static void sharpsl_charge_error(void)
223 sharpsl_pm_led(SHARPSL_LED_ERROR
);
224 sharpsl_pm
.machinfo
->charge(0);
225 sharpsl_pm
.charge_mode
= CHRG_ERROR
;
228 static void sharpsl_charge_toggle(struct work_struct
*private_
)
230 dev_dbg(sharpsl_pm
.dev
, "Toogling Charger at time: %lx\n", jiffies
);
232 if (!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
)) {
233 sharpsl_charge_off();
235 } else if ((sharpsl_check_battery_temp() < 0) || (sharpsl_ac_check() < 0)) {
236 sharpsl_charge_error();
240 sharpsl_pm_led(SHARPSL_LED_ON
);
241 sharpsl_pm
.machinfo
->charge(0);
242 mdelay(SHARPSL_CHARGE_WAIT_TIME
);
243 sharpsl_pm
.machinfo
->charge(1);
245 sharpsl_pm
.charge_start_time
= jiffies
;
248 static void sharpsl_ac_timer(unsigned long data
)
250 int acin
= sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
);
252 dev_dbg(sharpsl_pm
.dev
, "AC Status: %d\n",acin
);
254 sharpsl_average_clear();
255 if (acin
&& (sharpsl_pm
.charge_mode
!= CHRG_ON
))
257 else if (sharpsl_pm
.charge_mode
== CHRG_ON
)
258 sharpsl_charge_off();
260 schedule_delayed_work(&sharpsl_bat
, 0);
264 irqreturn_t
sharpsl_ac_isr(int irq
, void *dev_id
)
266 /* Delay the event slightly to debounce */
267 /* Must be a smaller delay than the chrg_full_isr below */
268 mod_timer(&sharpsl_pm
.ac_timer
, jiffies
+ msecs_to_jiffies(250));
273 static void sharpsl_chrg_full_timer(unsigned long data
)
275 dev_dbg(sharpsl_pm
.dev
, "Charge Full at time: %lx\n", jiffies
);
277 sharpsl_pm
.full_count
++;
279 if (!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
)) {
280 dev_dbg(sharpsl_pm
.dev
, "Charge Full: AC removed - stop charging!\n");
281 if (sharpsl_pm
.charge_mode
== CHRG_ON
)
282 sharpsl_charge_off();
283 } else if (sharpsl_pm
.full_count
< 2) {
284 dev_dbg(sharpsl_pm
.dev
, "Charge Full: Count too low\n");
285 schedule_delayed_work(&toggle_charger
, 0);
286 } else if (time_after(jiffies
, sharpsl_pm
.charge_start_time
+ SHARPSL_CHARGE_FINISH_TIME
)) {
287 dev_dbg(sharpsl_pm
.dev
, "Charge Full: Interrupt generated too slowly - retry.\n");
288 schedule_delayed_work(&toggle_charger
, 0);
290 sharpsl_charge_off();
291 sharpsl_pm
.charge_mode
= CHRG_DONE
;
292 dev_dbg(sharpsl_pm
.dev
, "Charge Full: Charging Finished\n");
296 /* Charging Finished Interrupt (Not present on Corgi) */
297 /* Can trigger at the same time as an AC status change so
298 delay until after that has been processed */
299 irqreturn_t
sharpsl_chrg_full_isr(int irq
, void *dev_id
)
301 if (sharpsl_pm
.flags
& SHARPSL_SUSPENDED
)
304 /* delay until after any ac interrupt */
305 mod_timer(&sharpsl_pm
.chrg_full_timer
, jiffies
+ msecs_to_jiffies(500));
310 irqreturn_t
sharpsl_fatal_isr(int irq
, void *dev_id
)
314 if (!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_LOCK
)) {
315 dev_err(sharpsl_pm
.dev
, "Battery now Unlocked! Suspending.\n");
319 if (!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_FATAL
)) {
320 dev_err(sharpsl_pm
.dev
, "Fatal Batt Error! Suspending.\n");
324 if (!(sharpsl_pm
.flags
& SHARPSL_APM_QUEUED
) && is_fatal
) {
325 sharpsl_pm
.flags
|= SHARPSL_APM_QUEUED
;
326 apm_queue_event(APM_CRITICAL_SUSPEND
);
333 * Maintain an average of the last 10 readings
335 #define SHARPSL_CNV_VALUE_NUM 10
336 static int sharpsl_ad_index
;
338 static void sharpsl_average_clear(void)
340 sharpsl_ad_index
= 0;
343 static int sharpsl_average_value(int ad
)
346 static int sharpsl_ad
[SHARPSL_CNV_VALUE_NUM
+1];
348 if (sharpsl_pm
.battstat
.mainbat_status
!= APM_BATTERY_STATUS_HIGH
) {
349 sharpsl_ad_index
= 0;
353 sharpsl_ad
[sharpsl_ad_index
] = ad
;
355 if (sharpsl_ad_index
>= SHARPSL_CNV_VALUE_NUM
) {
356 for (i
=0; i
< (SHARPSL_CNV_VALUE_NUM
-1); i
++)
357 sharpsl_ad
[i
] = sharpsl_ad
[i
+1];
358 sharpsl_ad_index
= SHARPSL_CNV_VALUE_NUM
- 1;
360 for (i
=0; i
< sharpsl_ad_index
; i
++)
361 ad_val
+= sharpsl_ad
[i
];
363 return (ad_val
/ sharpsl_ad_index
);
367 * Take an array of 5 integers, remove the maximum and minimum values
368 * and return the average.
370 static int get_select_val(int *val
)
372 int i
, j
, k
, temp
, sum
= 0;
377 for (i
=1; i
<5; i
++) {
387 for (i
=3; i
>=0; i
--) {
395 if (i
!= j
&& i
!= k
)
398 dev_dbg(sharpsl_pm
.dev
, "Average: %d from values: %d, %d, %d, %d, %d\n", sum
/3, val
[0], val
[1], val
[2], val
[3], val
[4]);
403 static int sharpsl_check_battery_temp(void)
407 /* Check battery temperature */
408 for (i
=0; i
<5; i
++) {
409 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP
);
410 sharpsl_pm
.machinfo
->measure_temp(1);
411 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP
);
412 buff
[i
] = sharpsl_pm
.machinfo
->read_devdata(SHARPSL_BATT_TEMP
);
413 sharpsl_pm
.machinfo
->measure_temp(0);
416 val
= get_select_val(buff
);
418 dev_dbg(sharpsl_pm
.dev
, "Temperature: %d\n", val
);
419 if (val
> sharpsl_pm
.machinfo
->charge_on_temp
) {
420 printk(KERN_WARNING
"Not charging: temperature out of limits.\n");
427 static int sharpsl_check_battery_voltage(void)
431 /* disable charge, enable discharge */
432 sharpsl_pm
.machinfo
->charge(0);
433 sharpsl_pm
.machinfo
->discharge(1);
434 mdelay(SHARPSL_WAIT_DISCHARGE_ON
);
436 if (sharpsl_pm
.machinfo
->discharge1
)
437 sharpsl_pm
.machinfo
->discharge1(1);
439 /* Check battery voltage */
440 for (i
=0; i
<5; i
++) {
441 buff
[i
] = sharpsl_pm
.machinfo
->read_devdata(SHARPSL_BATT_VOLT
);
442 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT
);
445 if (sharpsl_pm
.machinfo
->discharge1
)
446 sharpsl_pm
.machinfo
->discharge1(0);
448 sharpsl_pm
.machinfo
->discharge(0);
450 val
= get_select_val(buff
);
451 dev_dbg(sharpsl_pm
.dev
, "Battery Voltage: %d\n", val
);
453 if (val
< sharpsl_pm
.machinfo
->charge_on_volt
)
459 static int sharpsl_ac_check(void)
461 int temp
, i
, buff
[5];
463 for (i
=0; i
<5; i
++) {
464 buff
[i
] = sharpsl_pm
.machinfo
->read_devdata(SHARPSL_ACIN_VOLT
);
465 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_ACIN
);
468 temp
= get_select_val(buff
);
469 dev_dbg(sharpsl_pm
.dev
, "AC Voltage: %d\n",temp
);
471 if ((temp
> sharpsl_pm
.machinfo
->charge_acin_high
) || (temp
< sharpsl_pm
.machinfo
->charge_acin_low
)) {
472 dev_err(sharpsl_pm
.dev
, "Error: AC check failed.\n");
480 static int sharpsl_pm_suspend(struct platform_device
*pdev
, pm_message_t state
)
482 sharpsl_pm
.flags
|= SHARPSL_SUSPENDED
;
483 flush_scheduled_work();
485 if (sharpsl_pm
.charge_mode
== CHRG_ON
)
486 sharpsl_pm
.flags
|= SHARPSL_DO_OFFLINE_CHRG
;
488 sharpsl_pm
.flags
&= ~SHARPSL_DO_OFFLINE_CHRG
;
493 static int sharpsl_pm_resume(struct platform_device
*pdev
)
495 /* Clear the reset source indicators as they break the bootloader upon reboot */
497 sharpsl_average_clear();
498 sharpsl_pm
.flags
&= ~SHARPSL_APM_QUEUED
;
499 sharpsl_pm
.flags
&= ~SHARPSL_SUSPENDED
;
504 static void corgi_goto_sleep(unsigned long alarm_time
, unsigned int alarm_enable
, suspend_state_t state
)
506 dev_dbg(sharpsl_pm
.dev
, "Time is: %08x\n",RCNR
);
508 dev_dbg(sharpsl_pm
.dev
, "Offline Charge Activate = %d\n",sharpsl_pm
.flags
& SHARPSL_DO_OFFLINE_CHRG
);
509 /* not charging and AC-IN! */
511 if ((sharpsl_pm
.flags
& SHARPSL_DO_OFFLINE_CHRG
) && (sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
))) {
512 dev_dbg(sharpsl_pm
.dev
, "Activating Offline Charger...\n");
513 sharpsl_pm
.charge_mode
= CHRG_OFF
;
514 sharpsl_pm
.flags
&= ~SHARPSL_DO_OFFLINE_CHRG
;
515 sharpsl_off_charge_battery();
518 sharpsl_pm
.machinfo
->presuspend();
520 PEDR
= 0xffffffff; /* clear it */
522 sharpsl_pm
.flags
&= ~SHARPSL_ALARM_ACTIVE
;
523 if ((sharpsl_pm
.charge_mode
== CHRG_ON
) && ((alarm_enable
&& ((alarm_time
- RCNR
) > (SHARPSL_BATCHK_TIME_SUSPEND
+ 30))) || !alarm_enable
)) {
525 RTAR
= RCNR
+ SHARPSL_BATCHK_TIME_SUSPEND
;
526 dev_dbg(sharpsl_pm
.dev
, "Charging alarm at: %08x\n",RTAR
);
527 sharpsl_pm
.flags
|= SHARPSL_ALARM_ACTIVE
;
528 } else if (alarm_enable
) {
531 dev_dbg(sharpsl_pm
.dev
, "User alarm at: %08x\n",RTAR
);
533 dev_dbg(sharpsl_pm
.dev
, "No alarms set.\n");
538 sharpsl_pm
.machinfo
->postsuspend();
540 dev_dbg(sharpsl_pm
.dev
, "Corgi woken up from suspend: %08x\n",PEDR
);
543 static int corgi_enter_suspend(unsigned long alarm_time
, unsigned int alarm_enable
, suspend_state_t state
)
545 if (!sharpsl_pm
.machinfo
->should_wakeup(!(sharpsl_pm
.flags
& SHARPSL_ALARM_ACTIVE
) && alarm_enable
) )
547 if (!(sharpsl_pm
.flags
& SHARPSL_ALARM_ACTIVE
)) {
548 dev_dbg(sharpsl_pm
.dev
, "No user triggered wakeup events and not charging. Strange. Suspend.\n");
549 corgi_goto_sleep(alarm_time
, alarm_enable
, state
);
552 if(sharpsl_off_charge_battery()) {
553 dev_dbg(sharpsl_pm
.dev
, "Charging. Suspend...\n");
554 corgi_goto_sleep(alarm_time
, alarm_enable
, state
);
557 dev_dbg(sharpsl_pm
.dev
, "User triggered wakeup in offline charger.\n");
560 if ((!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_LOCK
)) || (sharpsl_fatal_check() < 0) )
562 dev_err(sharpsl_pm
.dev
, "Fatal condition. Suspend.\n");
563 corgi_goto_sleep(alarm_time
, alarm_enable
, state
);
570 static int corgi_pxa_pm_enter(suspend_state_t state
)
572 unsigned long alarm_time
= RTAR
;
573 unsigned int alarm_status
= ((RTSR
& RTSR_ALE
) != 0);
575 dev_dbg(sharpsl_pm
.dev
, "SharpSL suspending for first time.\n");
577 corgi_goto_sleep(alarm_time
, alarm_status
, state
);
579 while (corgi_enter_suspend(alarm_time
,alarm_status
,state
))
582 if (sharpsl_pm
.machinfo
->earlyresume
)
583 sharpsl_pm
.machinfo
->earlyresume();
585 dev_dbg(sharpsl_pm
.dev
, "SharpSL resuming...\n");
593 * Check for fatal battery errors
596 static int sharpsl_fatal_check(void)
598 int buff
[5], temp
, i
, acin
;
600 dev_dbg(sharpsl_pm
.dev
, "sharpsl_fatal_check entered\n");
602 /* Check AC-Adapter */
603 acin
= sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
);
605 if (acin
&& (sharpsl_pm
.charge_mode
== CHRG_ON
)) {
606 sharpsl_pm
.machinfo
->charge(0);
608 sharpsl_pm
.machinfo
->discharge(1); /* enable discharge */
609 mdelay(SHARPSL_WAIT_DISCHARGE_ON
);
612 if (sharpsl_pm
.machinfo
->discharge1
)
613 sharpsl_pm
.machinfo
->discharge1(1);
615 /* Check battery : check inserting battery ? */
616 for (i
=0; i
<5; i
++) {
617 buff
[i
] = sharpsl_pm
.machinfo
->read_devdata(SHARPSL_BATT_VOLT
);
618 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT
);
621 if (sharpsl_pm
.machinfo
->discharge1
)
622 sharpsl_pm
.machinfo
->discharge1(0);
624 if (acin
&& (sharpsl_pm
.charge_mode
== CHRG_ON
)) {
626 sharpsl_pm
.machinfo
->charge(1);
627 sharpsl_pm
.machinfo
->discharge(0);
630 temp
= get_select_val(buff
);
631 dev_dbg(sharpsl_pm
.dev
, "sharpsl_fatal_check: acin: %d, discharge voltage: %d, no discharge: %ld\n", acin
, temp
, sharpsl_pm
.machinfo
->read_devdata(SHARPSL_BATT_VOLT
));
633 if ((acin
&& (temp
< sharpsl_pm
.machinfo
->fatal_acin_volt
)) ||
634 (!acin
&& (temp
< sharpsl_pm
.machinfo
->fatal_noacin_volt
)))
639 static int sharpsl_off_charge_error(void)
641 dev_err(sharpsl_pm
.dev
, "Offline Charger: Error occurred.\n");
642 sharpsl_pm
.machinfo
->charge(0);
643 sharpsl_pm_led(SHARPSL_LED_ERROR
);
644 sharpsl_pm
.charge_mode
= CHRG_ERROR
;
649 * Charging Control while suspended
650 * Return 1 - go straight to sleep
651 * Return 0 - sleep or wakeup depending on other factors
653 static int sharpsl_off_charge_battery(void)
657 dev_dbg(sharpsl_pm
.dev
, "Charge Mode: %d\n", sharpsl_pm
.charge_mode
);
659 if (sharpsl_pm
.charge_mode
== CHRG_OFF
) {
660 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Step 1\n");
663 if ((sharpsl_ac_check() < 0) || (sharpsl_check_battery_temp() < 0))
664 return sharpsl_off_charge_error();
667 sharpsl_pm_led(SHARPSL_LED_ON
);
668 sharpsl_pm
.machinfo
->charge(0);
669 mdelay(SHARPSL_CHARGE_WAIT_TIME
);
670 sharpsl_pm
.machinfo
->charge(1);
672 sharpsl_pm
.charge_mode
= CHRG_ON
;
673 sharpsl_pm
.full_count
= 0;
676 } else if (sharpsl_pm
.charge_mode
!= CHRG_ON
) {
680 if (sharpsl_pm
.full_count
== 0) {
683 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Step 2\n");
685 if ((sharpsl_check_battery_temp() < 0) || (sharpsl_check_battery_voltage() < 0))
686 return sharpsl_off_charge_error();
688 sharpsl_pm
.machinfo
->charge(0);
689 mdelay(SHARPSL_CHARGE_WAIT_TIME
);
690 sharpsl_pm
.machinfo
->charge(1);
691 sharpsl_pm
.charge_mode
= CHRG_ON
;
693 mdelay(SHARPSL_CHARGE_CO_CHECK_TIME
);
697 /* Check if any wakeup event had occurred */
698 if (sharpsl_pm
.machinfo
->charger_wakeup() != 0)
700 /* Check for timeout */
701 if ((RCNR
- time
) > SHARPSL_WAIT_CO_TIME
)
703 if (sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_CHRGFULL
)) {
704 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Charge full occurred. Retrying to check\n");
705 sharpsl_pm
.full_count
++;
706 sharpsl_pm
.machinfo
->charge(0);
707 mdelay(SHARPSL_CHARGE_WAIT_TIME
);
708 sharpsl_pm
.machinfo
->charge(1);
714 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Step 3\n");
716 mdelay(SHARPSL_CHARGE_CO_CHECK_TIME
);
720 /* Check if any wakeup event had occurred */
721 if (sharpsl_pm
.machinfo
->charger_wakeup() != 0)
723 /* Check for timeout */
724 if ((RCNR
-time
) > SHARPSL_WAIT_CO_TIME
) {
725 if (sharpsl_pm
.full_count
> SHARPSL_CHARGE_RETRY_CNT
) {
726 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Not charged sufficiently. Retrying.\n");
727 sharpsl_pm
.full_count
= 0;
729 sharpsl_pm
.full_count
++;
732 if (sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_CHRGFULL
)) {
733 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Charging complete.\n");
734 sharpsl_pm_led(SHARPSL_LED_OFF
);
735 sharpsl_pm
.machinfo
->charge(0);
736 sharpsl_pm
.charge_mode
= CHRG_DONE
;
743 static ssize_t
battery_percentage_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
745 return sprintf(buf
, "%d\n",sharpsl_pm
.battstat
.mainbat_percent
);
748 static ssize_t
battery_voltage_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
750 return sprintf(buf
, "%d\n",sharpsl_pm
.battstat
.mainbat_voltage
);
753 static DEVICE_ATTR(battery_percentage
, 0444, battery_percentage_show
, NULL
);
754 static DEVICE_ATTR(battery_voltage
, 0444, battery_voltage_show
, NULL
);
756 extern void (*apm_get_power_status
)(struct apm_power_info
*);
758 static void sharpsl_apm_get_power_status(struct apm_power_info
*info
)
760 info
->ac_line_status
= sharpsl_pm
.battstat
.ac_status
;
762 if (sharpsl_pm
.charge_mode
== CHRG_ON
)
763 info
->battery_status
= APM_BATTERY_STATUS_CHARGING
;
765 info
->battery_status
= sharpsl_pm
.battstat
.mainbat_status
;
767 info
->battery_flag
= (1 << info
->battery_status
);
768 info
->battery_life
= sharpsl_pm
.battstat
.mainbat_percent
;
771 static struct platform_suspend_ops sharpsl_pm_ops
= {
772 .enter
= corgi_pxa_pm_enter
,
773 .valid
= suspend_valid_only_mem
,
776 static int __init
sharpsl_pm_probe(struct platform_device
*pdev
)
780 if (!pdev
->dev
.platform_data
)
783 sharpsl_pm
.dev
= &pdev
->dev
;
784 sharpsl_pm
.machinfo
= pdev
->dev
.platform_data
;
785 sharpsl_pm
.charge_mode
= CHRG_OFF
;
786 sharpsl_pm
.flags
= 0;
788 init_timer(&sharpsl_pm
.ac_timer
);
789 sharpsl_pm
.ac_timer
.function
= sharpsl_ac_timer
;
791 init_timer(&sharpsl_pm
.chrg_full_timer
);
792 sharpsl_pm
.chrg_full_timer
.function
= sharpsl_chrg_full_timer
;
794 led_trigger_register_simple("sharpsl-charge", &sharpsl_charge_led_trigger
);
796 sharpsl_pm
.machinfo
->init();
798 ret
= device_create_file(&pdev
->dev
, &dev_attr_battery_percentage
);
799 ret
|= device_create_file(&pdev
->dev
, &dev_attr_battery_voltage
);
801 dev_warn(&pdev
->dev
, "Failed to register attributes (%d)\n", ret
);
803 apm_get_power_status
= sharpsl_apm_get_power_status
;
805 suspend_set_ops(&sharpsl_pm_ops
);
807 mod_timer(&sharpsl_pm
.ac_timer
, jiffies
+ msecs_to_jiffies(250));
812 static int sharpsl_pm_remove(struct platform_device
*pdev
)
814 suspend_set_ops(NULL
);
816 device_remove_file(&pdev
->dev
, &dev_attr_battery_percentage
);
817 device_remove_file(&pdev
->dev
, &dev_attr_battery_voltage
);
819 led_trigger_unregister_simple(sharpsl_charge_led_trigger
);
821 sharpsl_pm
.machinfo
->exit();
823 del_timer_sync(&sharpsl_pm
.chrg_full_timer
);
824 del_timer_sync(&sharpsl_pm
.ac_timer
);
829 static struct platform_driver sharpsl_pm_driver
= {
830 .probe
= sharpsl_pm_probe
,
831 .remove
= sharpsl_pm_remove
,
832 .suspend
= sharpsl_pm_suspend
,
833 .resume
= sharpsl_pm_resume
,
835 .name
= "sharpsl-pm",
839 static int __devinit
sharpsl_pm_init(void)
841 return platform_driver_register(&sharpsl_pm_driver
);
844 static void sharpsl_pm_exit(void)
846 platform_driver_unregister(&sharpsl_pm_driver
);
849 late_initcall(sharpsl_pm_init
);
850 module_exit(sharpsl_pm_exit
);