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 <asm/hardware.h>
30 #include <asm/mach-types.h>
32 #include <asm/arch/pm.h>
33 #include <asm/arch/pxa-regs.h>
34 #include <asm/arch/pxa2xx-regs.h>
35 #include <asm/arch/sharpsl.h>
36 #include <asm/hardware/sharpsl_pm.h>
41 #define SHARPSL_CHARGE_ON_TIME_INTERVAL (msecs_to_jiffies(1*60*1000)) /* 1 min */
42 #define SHARPSL_CHARGE_FINISH_TIME (msecs_to_jiffies(10*60*1000)) /* 10 min */
43 #define SHARPSL_BATCHK_TIME (msecs_to_jiffies(15*1000)) /* 15 sec */
44 #define SHARPSL_BATCHK_TIME_SUSPEND (60*10) /* 10 min */
46 #define SHARPSL_WAIT_CO_TIME 15 /* 15 sec */
47 #define SHARPSL_WAIT_DISCHARGE_ON 100 /* 100 msec */
48 #define SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP 10 /* 10 msec */
49 #define SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT 10 /* 10 msec */
50 #define SHARPSL_CHECK_BATTERY_WAIT_TIME_ACIN 10 /* 10 msec */
51 #define SHARPSL_CHARGE_WAIT_TIME 15 /* 15 msec */
52 #define SHARPSL_CHARGE_CO_CHECK_TIME 5 /* 5 msec */
53 #define SHARPSL_CHARGE_RETRY_CNT 1 /* eqv. 10 min */
58 static int sharpsl_off_charge_battery(void);
59 static int sharpsl_check_battery_temp(void);
60 static int sharpsl_check_battery_voltage(void);
61 static int sharpsl_ac_check(void);
62 static int sharpsl_fatal_check(void);
63 static int sharpsl_average_value(int ad
);
64 static void sharpsl_average_clear(void);
65 static void sharpsl_charge_toggle(struct work_struct
*private_
);
66 static void sharpsl_battery_thread(struct work_struct
*private_
);
72 struct sharpsl_pm_status sharpsl_pm
;
73 DECLARE_DELAYED_WORK(toggle_charger
, sharpsl_charge_toggle
);
74 DECLARE_DELAYED_WORK(sharpsl_bat
, sharpsl_battery_thread
);
75 DEFINE_LED_TRIGGER(sharpsl_charge_led_trigger
);
78 static int get_percentage(int voltage
)
80 int i
= sharpsl_pm
.machinfo
->bat_levels
- 1;
81 int bl_status
= sharpsl_pm
.machinfo
->backlight_get_status
? sharpsl_pm
.machinfo
->backlight_get_status() : 0;
82 struct battery_thresh
*thresh
;
84 if (sharpsl_pm
.charge_mode
== CHRG_ON
)
85 thresh
= bl_status
? sharpsl_pm
.machinfo
->bat_levels_acin_bl
: sharpsl_pm
.machinfo
->bat_levels_acin
;
87 thresh
= bl_status
? sharpsl_pm
.machinfo
->bat_levels_noac_bl
: sharpsl_pm
.machinfo
->bat_levels_noac
;
89 while (i
> 0 && (voltage
> thresh
[i
].voltage
))
92 return thresh
[i
].percentage
;
95 static int get_apm_status(int voltage
)
97 int low_thresh
, high_thresh
;
99 if (sharpsl_pm
.charge_mode
== CHRG_ON
) {
100 high_thresh
= sharpsl_pm
.machinfo
->status_high_acin
;
101 low_thresh
= sharpsl_pm
.machinfo
->status_low_acin
;
103 high_thresh
= sharpsl_pm
.machinfo
->status_high_noac
;
104 low_thresh
= sharpsl_pm
.machinfo
->status_low_noac
;
107 if (voltage
>= high_thresh
)
108 return APM_BATTERY_STATUS_HIGH
;
109 if (voltage
>= low_thresh
)
110 return APM_BATTERY_STATUS_LOW
;
111 return APM_BATTERY_STATUS_CRITICAL
;
114 void sharpsl_battery_kick(void)
116 schedule_delayed_work(&sharpsl_bat
, msecs_to_jiffies(125));
118 EXPORT_SYMBOL(sharpsl_battery_kick
);
121 static void sharpsl_battery_thread(struct work_struct
*private_
)
123 int voltage
, percent
, apm_status
, i
= 0;
125 if (!sharpsl_pm
.machinfo
)
128 sharpsl_pm
.battstat
.ac_status
= (sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
) ? APM_AC_ONLINE
: APM_AC_OFFLINE
);
130 /* Corgi cannot confirm when battery fully charged so periodically kick! */
131 if (!sharpsl_pm
.machinfo
->batfull_irq
&& (sharpsl_pm
.charge_mode
== CHRG_ON
)
132 && time_after(jiffies
, sharpsl_pm
.charge_start_time
+ SHARPSL_CHARGE_ON_TIME_INTERVAL
))
133 schedule_delayed_work(&toggle_charger
, 0);
136 voltage
= sharpsl_pm
.machinfo
->read_devdata(SHARPSL_BATT_VOLT
);
138 if (voltage
> 0) break;
140 voltage
= sharpsl_pm
.machinfo
->bat_levels_noac
[0].voltage
;
141 dev_warn(sharpsl_pm
.dev
, "Warning: Cannot read main battery!\n");
146 voltage
= sharpsl_average_value(voltage
);
147 apm_status
= get_apm_status(voltage
);
148 percent
= get_percentage(voltage
);
150 /* At low battery voltages, the voltage has a tendency to start
151 creeping back up so we try to avoid this here */
152 if ((sharpsl_pm
.battstat
.ac_status
== APM_AC_ONLINE
) || (apm_status
== APM_BATTERY_STATUS_HIGH
) || percent
<= sharpsl_pm
.battstat
.mainbat_percent
) {
153 sharpsl_pm
.battstat
.mainbat_voltage
= voltage
;
154 sharpsl_pm
.battstat
.mainbat_status
= apm_status
;
155 sharpsl_pm
.battstat
.mainbat_percent
= percent
;
158 dev_dbg(sharpsl_pm
.dev
, "Battery: voltage: %d, status: %d, percentage: %d, time: %ld\n", voltage
,
159 sharpsl_pm
.battstat
.mainbat_status
, sharpsl_pm
.battstat
.mainbat_percent
, jiffies
);
161 #ifdef CONFIG_BACKLIGHT_CORGI
162 /* If battery is low. limit backlight intensity to save power. */
163 if ((sharpsl_pm
.battstat
.ac_status
!= APM_AC_ONLINE
)
164 && ((sharpsl_pm
.battstat
.mainbat_status
== APM_BATTERY_STATUS_LOW
) ||
165 (sharpsl_pm
.battstat
.mainbat_status
== APM_BATTERY_STATUS_CRITICAL
))) {
166 if (!(sharpsl_pm
.flags
& SHARPSL_BL_LIMIT
)) {
167 sharpsl_pm
.machinfo
->backlight_limit(1);
168 sharpsl_pm
.flags
|= SHARPSL_BL_LIMIT
;
170 } else if (sharpsl_pm
.flags
& SHARPSL_BL_LIMIT
) {
171 sharpsl_pm
.machinfo
->backlight_limit(0);
172 sharpsl_pm
.flags
&= ~SHARPSL_BL_LIMIT
;
176 /* Suspend if critical battery level */
177 if ((sharpsl_pm
.battstat
.ac_status
!= APM_AC_ONLINE
)
178 && (sharpsl_pm
.battstat
.mainbat_status
== APM_BATTERY_STATUS_CRITICAL
)
179 && !(sharpsl_pm
.flags
& SHARPSL_APM_QUEUED
)) {
180 sharpsl_pm
.flags
|= SHARPSL_APM_QUEUED
;
181 dev_err(sharpsl_pm
.dev
, "Fatal Off\n");
182 apm_queue_event(APM_CRITICAL_SUSPEND
);
185 schedule_delayed_work(&sharpsl_bat
, SHARPSL_BATCHK_TIME
);
188 void sharpsl_pm_led(int val
)
190 if (val
== SHARPSL_LED_ERROR
) {
191 dev_err(sharpsl_pm
.dev
, "Charging Error!\n");
192 } else if (val
== SHARPSL_LED_ON
) {
193 dev_dbg(sharpsl_pm
.dev
, "Charge LED On\n");
194 led_trigger_event(sharpsl_charge_led_trigger
, LED_FULL
);
196 dev_dbg(sharpsl_pm
.dev
, "Charge LED Off\n");
197 led_trigger_event(sharpsl_charge_led_trigger
, LED_OFF
);
201 static void sharpsl_charge_on(void)
203 dev_dbg(sharpsl_pm
.dev
, "Turning Charger On\n");
205 sharpsl_pm
.full_count
= 0;
206 sharpsl_pm
.charge_mode
= CHRG_ON
;
207 schedule_delayed_work(&toggle_charger
, msecs_to_jiffies(250));
208 schedule_delayed_work(&sharpsl_bat
, msecs_to_jiffies(500));
211 static void sharpsl_charge_off(void)
213 dev_dbg(sharpsl_pm
.dev
, "Turning Charger Off\n");
215 sharpsl_pm
.machinfo
->charge(0);
216 sharpsl_pm_led(SHARPSL_LED_OFF
);
217 sharpsl_pm
.charge_mode
= CHRG_OFF
;
219 schedule_delayed_work(&sharpsl_bat
, 0);
222 static void sharpsl_charge_error(void)
224 sharpsl_pm_led(SHARPSL_LED_ERROR
);
225 sharpsl_pm
.machinfo
->charge(0);
226 sharpsl_pm
.charge_mode
= CHRG_ERROR
;
229 static void sharpsl_charge_toggle(struct work_struct
*private_
)
231 dev_dbg(sharpsl_pm
.dev
, "Toogling Charger at time: %lx\n", jiffies
);
233 if (!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
)) {
234 sharpsl_charge_off();
236 } else if ((sharpsl_check_battery_temp() < 0) || (sharpsl_ac_check() < 0)) {
237 sharpsl_charge_error();
241 sharpsl_pm_led(SHARPSL_LED_ON
);
242 sharpsl_pm
.machinfo
->charge(0);
243 mdelay(SHARPSL_CHARGE_WAIT_TIME
);
244 sharpsl_pm
.machinfo
->charge(1);
246 sharpsl_pm
.charge_start_time
= jiffies
;
249 static void sharpsl_ac_timer(unsigned long data
)
251 int acin
= sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
);
253 dev_dbg(sharpsl_pm
.dev
, "AC Status: %d\n",acin
);
255 sharpsl_average_clear();
256 if (acin
&& (sharpsl_pm
.charge_mode
!= CHRG_ON
))
258 else if (sharpsl_pm
.charge_mode
== CHRG_ON
)
259 sharpsl_charge_off();
261 schedule_delayed_work(&sharpsl_bat
, 0);
265 irqreturn_t
sharpsl_ac_isr(int irq
, void *dev_id
)
267 /* Delay the event slightly to debounce */
268 /* Must be a smaller delay than the chrg_full_isr below */
269 mod_timer(&sharpsl_pm
.ac_timer
, jiffies
+ msecs_to_jiffies(250));
274 static void sharpsl_chrg_full_timer(unsigned long data
)
276 dev_dbg(sharpsl_pm
.dev
, "Charge Full at time: %lx\n", jiffies
);
278 sharpsl_pm
.full_count
++;
280 if (!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
)) {
281 dev_dbg(sharpsl_pm
.dev
, "Charge Full: AC removed - stop charging!\n");
282 if (sharpsl_pm
.charge_mode
== CHRG_ON
)
283 sharpsl_charge_off();
284 } else if (sharpsl_pm
.full_count
< 2) {
285 dev_dbg(sharpsl_pm
.dev
, "Charge Full: Count too low\n");
286 schedule_delayed_work(&toggle_charger
, 0);
287 } else if (time_after(jiffies
, sharpsl_pm
.charge_start_time
+ SHARPSL_CHARGE_FINISH_TIME
)) {
288 dev_dbg(sharpsl_pm
.dev
, "Charge Full: Interrupt generated too slowly - retry.\n");
289 schedule_delayed_work(&toggle_charger
, 0);
291 sharpsl_charge_off();
292 sharpsl_pm
.charge_mode
= CHRG_DONE
;
293 dev_dbg(sharpsl_pm
.dev
, "Charge Full: Charging Finished\n");
297 /* Charging Finished Interrupt (Not present on Corgi) */
298 /* Can trigger at the same time as an AC status change so
299 delay until after that has been processed */
300 irqreturn_t
sharpsl_chrg_full_isr(int irq
, void *dev_id
)
302 if (sharpsl_pm
.flags
& SHARPSL_SUSPENDED
)
305 /* delay until after any ac interrupt */
306 mod_timer(&sharpsl_pm
.chrg_full_timer
, jiffies
+ msecs_to_jiffies(500));
311 irqreturn_t
sharpsl_fatal_isr(int irq
, void *dev_id
)
315 if (!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_LOCK
)) {
316 dev_err(sharpsl_pm
.dev
, "Battery now Unlocked! Suspending.\n");
320 if (!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_FATAL
)) {
321 dev_err(sharpsl_pm
.dev
, "Fatal Batt Error! Suspending.\n");
325 if (!(sharpsl_pm
.flags
& SHARPSL_APM_QUEUED
) && is_fatal
) {
326 sharpsl_pm
.flags
|= SHARPSL_APM_QUEUED
;
327 apm_queue_event(APM_CRITICAL_SUSPEND
);
334 * Maintain an average of the last 10 readings
336 #define SHARPSL_CNV_VALUE_NUM 10
337 static int sharpsl_ad_index
;
339 static void sharpsl_average_clear(void)
341 sharpsl_ad_index
= 0;
344 static int sharpsl_average_value(int ad
)
347 static int sharpsl_ad
[SHARPSL_CNV_VALUE_NUM
+1];
349 if (sharpsl_pm
.battstat
.mainbat_status
!= APM_BATTERY_STATUS_HIGH
) {
350 sharpsl_ad_index
= 0;
354 sharpsl_ad
[sharpsl_ad_index
] = ad
;
356 if (sharpsl_ad_index
>= SHARPSL_CNV_VALUE_NUM
) {
357 for (i
=0; i
< (SHARPSL_CNV_VALUE_NUM
-1); i
++)
358 sharpsl_ad
[i
] = sharpsl_ad
[i
+1];
359 sharpsl_ad_index
= SHARPSL_CNV_VALUE_NUM
- 1;
361 for (i
=0; i
< sharpsl_ad_index
; i
++)
362 ad_val
+= sharpsl_ad
[i
];
364 return (ad_val
/ sharpsl_ad_index
);
368 * Take an array of 5 integers, remove the maximum and minimum values
369 * and return the average.
371 static int get_select_val(int *val
)
373 int i
, j
, k
, temp
, sum
= 0;
378 for (i
=1; i
<5; i
++) {
388 for (i
=3; i
>=0; i
--) {
396 if (i
!= j
&& i
!= k
)
399 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]);
404 static int sharpsl_check_battery_temp(void)
408 /* Check battery temperature */
409 for (i
=0; i
<5; i
++) {
410 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP
);
411 sharpsl_pm
.machinfo
->measure_temp(1);
412 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP
);
413 buff
[i
] = sharpsl_pm
.machinfo
->read_devdata(SHARPSL_BATT_TEMP
);
414 sharpsl_pm
.machinfo
->measure_temp(0);
417 val
= get_select_val(buff
);
419 dev_dbg(sharpsl_pm
.dev
, "Temperature: %d\n", val
);
420 if (val
> sharpsl_pm
.machinfo
->charge_on_temp
) {
421 printk(KERN_WARNING
"Not charging: temperature out of limits.\n");
428 static int sharpsl_check_battery_voltage(void)
432 /* disable charge, enable discharge */
433 sharpsl_pm
.machinfo
->charge(0);
434 sharpsl_pm
.machinfo
->discharge(1);
435 mdelay(SHARPSL_WAIT_DISCHARGE_ON
);
437 if (sharpsl_pm
.machinfo
->discharge1
)
438 sharpsl_pm
.machinfo
->discharge1(1);
440 /* Check battery voltage */
441 for (i
=0; i
<5; i
++) {
442 buff
[i
] = sharpsl_pm
.machinfo
->read_devdata(SHARPSL_BATT_VOLT
);
443 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT
);
446 if (sharpsl_pm
.machinfo
->discharge1
)
447 sharpsl_pm
.machinfo
->discharge1(0);
449 sharpsl_pm
.machinfo
->discharge(0);
451 val
= get_select_val(buff
);
452 dev_dbg(sharpsl_pm
.dev
, "Battery Voltage: %d\n", val
);
454 if (val
< sharpsl_pm
.machinfo
->charge_on_volt
)
460 static int sharpsl_ac_check(void)
462 int temp
, i
, buff
[5];
464 for (i
=0; i
<5; i
++) {
465 buff
[i
] = sharpsl_pm
.machinfo
->read_devdata(SHARPSL_ACIN_VOLT
);
466 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_ACIN
);
469 temp
= get_select_val(buff
);
470 dev_dbg(sharpsl_pm
.dev
, "AC Voltage: %d\n",temp
);
472 if ((temp
> sharpsl_pm
.machinfo
->charge_acin_high
) || (temp
< sharpsl_pm
.machinfo
->charge_acin_low
)) {
473 dev_err(sharpsl_pm
.dev
, "Error: AC check failed.\n");
481 static int sharpsl_pm_suspend(struct platform_device
*pdev
, pm_message_t state
)
483 sharpsl_pm
.flags
|= SHARPSL_SUSPENDED
;
484 flush_scheduled_work();
486 if (sharpsl_pm
.charge_mode
== CHRG_ON
)
487 sharpsl_pm
.flags
|= SHARPSL_DO_OFFLINE_CHRG
;
489 sharpsl_pm
.flags
&= ~SHARPSL_DO_OFFLINE_CHRG
;
494 static int sharpsl_pm_resume(struct platform_device
*pdev
)
496 /* Clear the reset source indicators as they break the bootloader upon reboot */
498 sharpsl_average_clear();
499 sharpsl_pm
.flags
&= ~SHARPSL_APM_QUEUED
;
500 sharpsl_pm
.flags
&= ~SHARPSL_SUSPENDED
;
505 static void corgi_goto_sleep(unsigned long alarm_time
, unsigned int alarm_enable
, suspend_state_t state
)
507 dev_dbg(sharpsl_pm
.dev
, "Time is: %08x\n",RCNR
);
509 dev_dbg(sharpsl_pm
.dev
, "Offline Charge Activate = %d\n",sharpsl_pm
.flags
& SHARPSL_DO_OFFLINE_CHRG
);
510 /* not charging and AC-IN! */
512 if ((sharpsl_pm
.flags
& SHARPSL_DO_OFFLINE_CHRG
) && (sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
))) {
513 dev_dbg(sharpsl_pm
.dev
, "Activating Offline Charger...\n");
514 sharpsl_pm
.charge_mode
= CHRG_OFF
;
515 sharpsl_pm
.flags
&= ~SHARPSL_DO_OFFLINE_CHRG
;
516 sharpsl_off_charge_battery();
519 sharpsl_pm
.machinfo
->presuspend();
521 PEDR
= 0xffffffff; /* clear it */
523 sharpsl_pm
.flags
&= ~SHARPSL_ALARM_ACTIVE
;
524 if ((sharpsl_pm
.charge_mode
== CHRG_ON
) && ((alarm_enable
&& ((alarm_time
- RCNR
) > (SHARPSL_BATCHK_TIME_SUSPEND
+ 30))) || !alarm_enable
)) {
526 RTAR
= RCNR
+ SHARPSL_BATCHK_TIME_SUSPEND
;
527 dev_dbg(sharpsl_pm
.dev
, "Charging alarm at: %08x\n",RTAR
);
528 sharpsl_pm
.flags
|= SHARPSL_ALARM_ACTIVE
;
529 } else if (alarm_enable
) {
532 dev_dbg(sharpsl_pm
.dev
, "User alarm at: %08x\n",RTAR
);
534 dev_dbg(sharpsl_pm
.dev
, "No alarms set.\n");
539 sharpsl_pm
.machinfo
->postsuspend();
541 dev_dbg(sharpsl_pm
.dev
, "Corgi woken up from suspend: %08x\n",PEDR
);
544 static int corgi_enter_suspend(unsigned long alarm_time
, unsigned int alarm_enable
, suspend_state_t state
)
546 if (!sharpsl_pm
.machinfo
->should_wakeup(!(sharpsl_pm
.flags
& SHARPSL_ALARM_ACTIVE
) && alarm_enable
) )
548 if (!(sharpsl_pm
.flags
& SHARPSL_ALARM_ACTIVE
)) {
549 dev_dbg(sharpsl_pm
.dev
, "No user triggered wakeup events and not charging. Strange. Suspend.\n");
550 corgi_goto_sleep(alarm_time
, alarm_enable
, state
);
553 if(sharpsl_off_charge_battery()) {
554 dev_dbg(sharpsl_pm
.dev
, "Charging. Suspend...\n");
555 corgi_goto_sleep(alarm_time
, alarm_enable
, state
);
558 dev_dbg(sharpsl_pm
.dev
, "User triggered wakeup in offline charger.\n");
561 if ((!sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_LOCK
)) || (sharpsl_fatal_check() < 0) )
563 dev_err(sharpsl_pm
.dev
, "Fatal condition. Suspend.\n");
564 corgi_goto_sleep(alarm_time
, alarm_enable
, state
);
571 static int corgi_pxa_pm_enter(suspend_state_t state
)
573 unsigned long alarm_time
= RTAR
;
574 unsigned int alarm_status
= ((RTSR
& RTSR_ALE
) != 0);
576 dev_dbg(sharpsl_pm
.dev
, "SharpSL suspending for first time.\n");
578 corgi_goto_sleep(alarm_time
, alarm_status
, state
);
580 while (corgi_enter_suspend(alarm_time
,alarm_status
,state
))
583 if (sharpsl_pm
.machinfo
->earlyresume
)
584 sharpsl_pm
.machinfo
->earlyresume();
586 dev_dbg(sharpsl_pm
.dev
, "SharpSL resuming...\n");
594 * Check for fatal battery errors
597 static int sharpsl_fatal_check(void)
599 int buff
[5], temp
, i
, acin
;
601 dev_dbg(sharpsl_pm
.dev
, "sharpsl_fatal_check entered\n");
603 /* Check AC-Adapter */
604 acin
= sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_ACIN
);
606 if (acin
&& (sharpsl_pm
.charge_mode
== CHRG_ON
)) {
607 sharpsl_pm
.machinfo
->charge(0);
609 sharpsl_pm
.machinfo
->discharge(1); /* enable discharge */
610 mdelay(SHARPSL_WAIT_DISCHARGE_ON
);
613 if (sharpsl_pm
.machinfo
->discharge1
)
614 sharpsl_pm
.machinfo
->discharge1(1);
616 /* Check battery : check inserting battery ? */
617 for (i
=0; i
<5; i
++) {
618 buff
[i
] = sharpsl_pm
.machinfo
->read_devdata(SHARPSL_BATT_VOLT
);
619 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT
);
622 if (sharpsl_pm
.machinfo
->discharge1
)
623 sharpsl_pm
.machinfo
->discharge1(0);
625 if (acin
&& (sharpsl_pm
.charge_mode
== CHRG_ON
)) {
627 sharpsl_pm
.machinfo
->charge(1);
628 sharpsl_pm
.machinfo
->discharge(0);
631 temp
= get_select_val(buff
);
632 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
));
634 if ((acin
&& (temp
< sharpsl_pm
.machinfo
->fatal_acin_volt
)) ||
635 (!acin
&& (temp
< sharpsl_pm
.machinfo
->fatal_noacin_volt
)))
640 static int sharpsl_off_charge_error(void)
642 dev_err(sharpsl_pm
.dev
, "Offline Charger: Error occurred.\n");
643 sharpsl_pm
.machinfo
->charge(0);
644 sharpsl_pm_led(SHARPSL_LED_ERROR
);
645 sharpsl_pm
.charge_mode
= CHRG_ERROR
;
650 * Charging Control while suspended
651 * Return 1 - go straight to sleep
652 * Return 0 - sleep or wakeup depending on other factors
654 static int sharpsl_off_charge_battery(void)
658 dev_dbg(sharpsl_pm
.dev
, "Charge Mode: %d\n", sharpsl_pm
.charge_mode
);
660 if (sharpsl_pm
.charge_mode
== CHRG_OFF
) {
661 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Step 1\n");
664 if ((sharpsl_ac_check() < 0) || (sharpsl_check_battery_temp() < 0))
665 return sharpsl_off_charge_error();
668 sharpsl_pm_led(SHARPSL_LED_ON
);
669 sharpsl_pm
.machinfo
->charge(0);
670 mdelay(SHARPSL_CHARGE_WAIT_TIME
);
671 sharpsl_pm
.machinfo
->charge(1);
673 sharpsl_pm
.charge_mode
= CHRG_ON
;
674 sharpsl_pm
.full_count
= 0;
677 } else if (sharpsl_pm
.charge_mode
!= CHRG_ON
) {
681 if (sharpsl_pm
.full_count
== 0) {
684 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Step 2\n");
686 if ((sharpsl_check_battery_temp() < 0) || (sharpsl_check_battery_voltage() < 0))
687 return sharpsl_off_charge_error();
689 sharpsl_pm
.machinfo
->charge(0);
690 mdelay(SHARPSL_CHARGE_WAIT_TIME
);
691 sharpsl_pm
.machinfo
->charge(1);
692 sharpsl_pm
.charge_mode
= CHRG_ON
;
694 mdelay(SHARPSL_CHARGE_CO_CHECK_TIME
);
698 /* Check if any wakeup event had occurred */
699 if (sharpsl_pm
.machinfo
->charger_wakeup() != 0)
701 /* Check for timeout */
702 if ((RCNR
- time
) > SHARPSL_WAIT_CO_TIME
)
704 if (sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_CHRGFULL
)) {
705 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Charge full occurred. Retrying to check\n");
706 sharpsl_pm
.full_count
++;
707 sharpsl_pm
.machinfo
->charge(0);
708 mdelay(SHARPSL_CHARGE_WAIT_TIME
);
709 sharpsl_pm
.machinfo
->charge(1);
715 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Step 3\n");
717 mdelay(SHARPSL_CHARGE_CO_CHECK_TIME
);
721 /* Check if any wakeup event had occurred */
722 if (sharpsl_pm
.machinfo
->charger_wakeup() != 0)
724 /* Check for timeout */
725 if ((RCNR
-time
) > SHARPSL_WAIT_CO_TIME
) {
726 if (sharpsl_pm
.full_count
> SHARPSL_CHARGE_RETRY_CNT
) {
727 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Not charged sufficiently. Retrying.\n");
728 sharpsl_pm
.full_count
= 0;
730 sharpsl_pm
.full_count
++;
733 if (sharpsl_pm
.machinfo
->read_devdata(SHARPSL_STATUS_CHRGFULL
)) {
734 dev_dbg(sharpsl_pm
.dev
, "Offline Charger: Charging complete.\n");
735 sharpsl_pm_led(SHARPSL_LED_OFF
);
736 sharpsl_pm
.machinfo
->charge(0);
737 sharpsl_pm
.charge_mode
= CHRG_DONE
;
744 static ssize_t
battery_percentage_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
746 return sprintf(buf
, "%d\n",sharpsl_pm
.battstat
.mainbat_percent
);
749 static ssize_t
battery_voltage_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
751 return sprintf(buf
, "%d\n",sharpsl_pm
.battstat
.mainbat_voltage
);
754 static DEVICE_ATTR(battery_percentage
, 0444, battery_percentage_show
, NULL
);
755 static DEVICE_ATTR(battery_voltage
, 0444, battery_voltage_show
, NULL
);
757 extern void (*apm_get_power_status
)(struct apm_power_info
*);
759 static void sharpsl_apm_get_power_status(struct apm_power_info
*info
)
761 info
->ac_line_status
= sharpsl_pm
.battstat
.ac_status
;
763 if (sharpsl_pm
.charge_mode
== CHRG_ON
)
764 info
->battery_status
= APM_BATTERY_STATUS_CHARGING
;
766 info
->battery_status
= sharpsl_pm
.battstat
.mainbat_status
;
768 info
->battery_flag
= (1 << info
->battery_status
);
769 info
->battery_life
= sharpsl_pm
.battstat
.mainbat_percent
;
772 static struct platform_suspend_ops sharpsl_pm_ops
= {
773 .enter
= corgi_pxa_pm_enter
,
774 .valid
= suspend_valid_only_mem
,
777 static int __init
sharpsl_pm_probe(struct platform_device
*pdev
)
781 if (!pdev
->dev
.platform_data
)
784 sharpsl_pm
.dev
= &pdev
->dev
;
785 sharpsl_pm
.machinfo
= pdev
->dev
.platform_data
;
786 sharpsl_pm
.charge_mode
= CHRG_OFF
;
787 sharpsl_pm
.flags
= 0;
789 init_timer(&sharpsl_pm
.ac_timer
);
790 sharpsl_pm
.ac_timer
.function
= sharpsl_ac_timer
;
792 init_timer(&sharpsl_pm
.chrg_full_timer
);
793 sharpsl_pm
.chrg_full_timer
.function
= sharpsl_chrg_full_timer
;
795 led_trigger_register_simple("sharpsl-charge", &sharpsl_charge_led_trigger
);
797 sharpsl_pm
.machinfo
->init();
799 ret
= device_create_file(&pdev
->dev
, &dev_attr_battery_percentage
);
800 ret
|= device_create_file(&pdev
->dev
, &dev_attr_battery_voltage
);
802 dev_warn(&pdev
->dev
, "Failed to register attributes (%d)\n", ret
);
804 apm_get_power_status
= sharpsl_apm_get_power_status
;
806 suspend_set_ops(&sharpsl_pm_ops
);
808 mod_timer(&sharpsl_pm
.ac_timer
, jiffies
+ msecs_to_jiffies(250));
813 static int sharpsl_pm_remove(struct platform_device
*pdev
)
815 suspend_set_ops(NULL
);
817 device_remove_file(&pdev
->dev
, &dev_attr_battery_percentage
);
818 device_remove_file(&pdev
->dev
, &dev_attr_battery_voltage
);
820 led_trigger_unregister_simple(sharpsl_charge_led_trigger
);
822 sharpsl_pm
.machinfo
->exit();
824 del_timer_sync(&sharpsl_pm
.chrg_full_timer
);
825 del_timer_sync(&sharpsl_pm
.ac_timer
);
830 static struct platform_driver sharpsl_pm_driver
= {
831 .probe
= sharpsl_pm_probe
,
832 .remove
= sharpsl_pm_remove
,
833 .suspend
= sharpsl_pm_suspend
,
834 .resume
= sharpsl_pm_resume
,
836 .name
= "sharpsl-pm",
840 static int __devinit
sharpsl_pm_init(void)
842 return platform_driver_register(&sharpsl_pm_driver
);
845 static void sharpsl_pm_exit(void)
847 platform_driver_unregister(&sharpsl_pm_driver
);
850 late_initcall(sharpsl_pm_init
);
851 module_exit(sharpsl_pm_exit
);