[APM] ARM: Convert to use shared APM emulation.
[linux-2.6.git] / arch / arm / common / sharpsl_pm.c
1 /*
2  * Battery and Power Management code for the Sharp SL-C7xx and SL-Cxx00
3  * series of PDAs
4  *
5  * Copyright (c) 2004-2005 Richard Purdie
6  *
7  * Based on code written by Sharp for 2.4 kernels
8  *
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.
12  *
13  */
14
15 #undef DEBUG
16
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
27 #include <asm/hardware.h>
28 #include <asm/mach-types.h>
29 #include <asm/irq.h>
30 #include <asm/apm-emulation.h>
31 #include <asm/arch/pm.h>
32 #include <asm/arch/pxa-regs.h>
33 #include <asm/arch/sharpsl.h>
34 #include <asm/hardware/sharpsl_pm.h>
35
36 /*
37  * Constants
38  */
39 #define SHARPSL_CHARGE_ON_TIME_INTERVAL        (msecs_to_jiffies(1*60*1000))  /* 1 min */
40 #define SHARPSL_CHARGE_FINISH_TIME             (msecs_to_jiffies(10*60*1000)) /* 10 min */
41 #define SHARPSL_BATCHK_TIME                    (msecs_to_jiffies(15*1000))    /* 15 sec */
42 #define SHARPSL_BATCHK_TIME_SUSPEND            (60*10)                        /* 10 min */
43
44 #define SHARPSL_WAIT_CO_TIME                   15  /* 15 sec */
45 #define SHARPSL_WAIT_DISCHARGE_ON              100 /* 100 msec */
46 #define SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP   10  /* 10 msec */
47 #define SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT   10  /* 10 msec */
48 #define SHARPSL_CHECK_BATTERY_WAIT_TIME_ACIN   10  /* 10 msec */
49 #define SHARPSL_CHARGE_WAIT_TIME               15  /* 15 msec */
50 #define SHARPSL_CHARGE_CO_CHECK_TIME           5   /* 5 msec */
51 #define SHARPSL_CHARGE_RETRY_CNT               1   /* eqv. 10 min */
52
53 /*
54  * Prototypes
55  */
56 static int sharpsl_off_charge_battery(void);
57 static int sharpsl_check_battery_temp(void);
58 static int sharpsl_check_battery_voltage(void);
59 static int sharpsl_ac_check(void);
60 static int sharpsl_fatal_check(void);
61 static int sharpsl_average_value(int ad);
62 static void sharpsl_average_clear(void);
63 static void sharpsl_charge_toggle(struct work_struct *private_);
64 static void sharpsl_battery_thread(struct work_struct *private_);
65
66
67 /*
68  * Variables
69  */
70 struct sharpsl_pm_status sharpsl_pm;
71 DECLARE_DELAYED_WORK(toggle_charger, sharpsl_charge_toggle);
72 DECLARE_DELAYED_WORK(sharpsl_bat, sharpsl_battery_thread);
73 DEFINE_LED_TRIGGER(sharpsl_charge_led_trigger);
74
75
76 static int get_percentage(int voltage)
77 {
78         int i = sharpsl_pm.machinfo->bat_levels - 1;
79         int bl_status = sharpsl_pm.machinfo->backlight_get_status ? sharpsl_pm.machinfo->backlight_get_status() : 0;
80         struct battery_thresh *thresh;
81
82         if (sharpsl_pm.charge_mode == CHRG_ON)
83                 thresh = bl_status ? sharpsl_pm.machinfo->bat_levels_acin_bl : sharpsl_pm.machinfo->bat_levels_acin;
84         else
85                 thresh = bl_status ? sharpsl_pm.machinfo->bat_levels_noac_bl : sharpsl_pm.machinfo->bat_levels_noac;
86
87         while (i > 0 && (voltage > thresh[i].voltage))
88                 i--;
89
90         return thresh[i].percentage;
91 }
92
93 static int get_apm_status(int voltage)
94 {
95         int low_thresh, high_thresh;
96
97         if (sharpsl_pm.charge_mode == CHRG_ON) {
98                 high_thresh = sharpsl_pm.machinfo->status_high_acin;
99                 low_thresh = sharpsl_pm.machinfo->status_low_acin;
100         } else {
101                 high_thresh = sharpsl_pm.machinfo->status_high_noac;
102                 low_thresh = sharpsl_pm.machinfo->status_low_noac;
103         }
104
105         if (voltage >= high_thresh)
106                 return APM_BATTERY_STATUS_HIGH;
107         if (voltage >= low_thresh)
108                 return APM_BATTERY_STATUS_LOW;
109         return APM_BATTERY_STATUS_CRITICAL;
110 }
111
112 void sharpsl_battery_kick(void)
113 {
114         schedule_delayed_work(&sharpsl_bat, msecs_to_jiffies(125));
115 }
116 EXPORT_SYMBOL(sharpsl_battery_kick);
117
118
119 static void sharpsl_battery_thread(struct work_struct *private_)
120 {
121         int voltage, percent, apm_status, i = 0;
122
123         if (!sharpsl_pm.machinfo)
124                 return;
125
126         sharpsl_pm.battstat.ac_status = (sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN) ? APM_AC_ONLINE : APM_AC_OFFLINE);
127
128         /* Corgi cannot confirm when battery fully charged so periodically kick! */
129         if (!sharpsl_pm.machinfo->batfull_irq && (sharpsl_pm.charge_mode == CHRG_ON)
130                         && time_after(jiffies, sharpsl_pm.charge_start_time +  SHARPSL_CHARGE_ON_TIME_INTERVAL))
131                 schedule_delayed_work(&toggle_charger, 0);
132
133         while(1) {
134                 voltage = sharpsl_pm.machinfo->read_devdata(SHARPSL_BATT_VOLT);
135
136                 if (voltage > 0) break;
137                 if (i++ > 5) {
138                         voltage = sharpsl_pm.machinfo->bat_levels_noac[0].voltage;
139                         dev_warn(sharpsl_pm.dev, "Warning: Cannot read main battery!\n");
140                         break;
141                 }
142         }
143
144         voltage = sharpsl_average_value(voltage);
145         apm_status = get_apm_status(voltage);
146         percent = get_percentage(voltage);
147
148         /* At low battery voltages, the voltage has a tendency to start
149            creeping back up so we try to avoid this here */
150         if ((sharpsl_pm.battstat.ac_status == APM_AC_ONLINE) || (apm_status == APM_BATTERY_STATUS_HIGH) ||  percent <= sharpsl_pm.battstat.mainbat_percent) {
151                 sharpsl_pm.battstat.mainbat_voltage = voltage;
152                 sharpsl_pm.battstat.mainbat_status = apm_status;
153                 sharpsl_pm.battstat.mainbat_percent = percent;
154         }
155
156         dev_dbg(sharpsl_pm.dev, "Battery: voltage: %d, status: %d, percentage: %d, time: %d\n", voltage,
157                         sharpsl_pm.battstat.mainbat_status, sharpsl_pm.battstat.mainbat_percent, jiffies);
158
159         /* If battery is low. limit backlight intensity to save power. */
160         if ((sharpsl_pm.battstat.ac_status != APM_AC_ONLINE)
161                         && ((sharpsl_pm.battstat.mainbat_status == APM_BATTERY_STATUS_LOW) ||
162                         (sharpsl_pm.battstat.mainbat_status == APM_BATTERY_STATUS_CRITICAL))) {
163                 if (!(sharpsl_pm.flags & SHARPSL_BL_LIMIT)) {
164                         sharpsl_pm.machinfo->backlight_limit(1);
165                         sharpsl_pm.flags |= SHARPSL_BL_LIMIT;
166                 }
167         } else if (sharpsl_pm.flags & SHARPSL_BL_LIMIT) {
168                 sharpsl_pm.machinfo->backlight_limit(0);
169                 sharpsl_pm.flags &= ~SHARPSL_BL_LIMIT;
170         }
171
172         /* Suspend if critical battery level */
173         if ((sharpsl_pm.battstat.ac_status != APM_AC_ONLINE)
174                         && (sharpsl_pm.battstat.mainbat_status == APM_BATTERY_STATUS_CRITICAL)
175                         && !(sharpsl_pm.flags & SHARPSL_APM_QUEUED)) {
176                 sharpsl_pm.flags |= SHARPSL_APM_QUEUED;
177                 dev_err(sharpsl_pm.dev, "Fatal Off\n");
178                 apm_queue_event(APM_CRITICAL_SUSPEND);
179         }
180
181         schedule_delayed_work(&sharpsl_bat, SHARPSL_BATCHK_TIME);
182 }
183
184 void sharpsl_pm_led(int val)
185 {
186         if (val == SHARPSL_LED_ERROR) {
187                 dev_err(sharpsl_pm.dev, "Charging Error!\n");
188         } else if (val == SHARPSL_LED_ON) {
189                 dev_dbg(sharpsl_pm.dev, "Charge LED On\n");
190                 led_trigger_event(sharpsl_charge_led_trigger, LED_FULL);
191         } else {
192                 dev_dbg(sharpsl_pm.dev, "Charge LED Off\n");
193                 led_trigger_event(sharpsl_charge_led_trigger, LED_OFF);
194         }
195 }
196
197 static void sharpsl_charge_on(void)
198 {
199         dev_dbg(sharpsl_pm.dev, "Turning Charger On\n");
200
201         sharpsl_pm.full_count = 0;
202         sharpsl_pm.charge_mode = CHRG_ON;
203         schedule_delayed_work(&toggle_charger, msecs_to_jiffies(250));
204         schedule_delayed_work(&sharpsl_bat, msecs_to_jiffies(500));
205 }
206
207 static void sharpsl_charge_off(void)
208 {
209         dev_dbg(sharpsl_pm.dev, "Turning Charger Off\n");
210
211         sharpsl_pm.machinfo->charge(0);
212         sharpsl_pm_led(SHARPSL_LED_OFF);
213         sharpsl_pm.charge_mode = CHRG_OFF;
214
215         schedule_delayed_work(&sharpsl_bat, 0);
216 }
217
218 static void sharpsl_charge_error(void)
219 {
220         sharpsl_pm_led(SHARPSL_LED_ERROR);
221         sharpsl_pm.machinfo->charge(0);
222         sharpsl_pm.charge_mode = CHRG_ERROR;
223 }
224
225 static void sharpsl_charge_toggle(struct work_struct *private_)
226 {
227         dev_dbg(sharpsl_pm.dev, "Toogling Charger at time: %lx\n", jiffies);
228
229         if (!sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN)) {
230                 sharpsl_charge_off();
231                 return;
232         } else if ((sharpsl_check_battery_temp() < 0) || (sharpsl_ac_check() < 0)) {
233                 sharpsl_charge_error();
234                 return;
235         }
236
237         sharpsl_pm_led(SHARPSL_LED_ON);
238         sharpsl_pm.machinfo->charge(0);
239         mdelay(SHARPSL_CHARGE_WAIT_TIME);
240         sharpsl_pm.machinfo->charge(1);
241
242         sharpsl_pm.charge_start_time = jiffies;
243 }
244
245 static void sharpsl_ac_timer(unsigned long data)
246 {
247         int acin = sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN);
248
249         dev_dbg(sharpsl_pm.dev, "AC Status: %d\n",acin);
250
251         sharpsl_average_clear();
252         if (acin && (sharpsl_pm.charge_mode != CHRG_ON))
253                 sharpsl_charge_on();
254         else if (sharpsl_pm.charge_mode == CHRG_ON)
255                 sharpsl_charge_off();
256
257         schedule_delayed_work(&sharpsl_bat, 0);
258 }
259
260
261 irqreturn_t sharpsl_ac_isr(int irq, void *dev_id)
262 {
263         /* Delay the event slightly to debounce */
264         /* Must be a smaller delay than the chrg_full_isr below */
265         mod_timer(&sharpsl_pm.ac_timer, jiffies + msecs_to_jiffies(250));
266
267         return IRQ_HANDLED;
268 }
269
270 static void sharpsl_chrg_full_timer(unsigned long data)
271 {
272         dev_dbg(sharpsl_pm.dev, "Charge Full at time: %lx\n", jiffies);
273
274         sharpsl_pm.full_count++;
275
276         if (!sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN)) {
277                 dev_dbg(sharpsl_pm.dev, "Charge Full: AC removed - stop charging!\n");
278                 if (sharpsl_pm.charge_mode == CHRG_ON)
279                         sharpsl_charge_off();
280         } else if (sharpsl_pm.full_count < 2) {
281                 dev_dbg(sharpsl_pm.dev, "Charge Full: Count too low\n");
282                 schedule_delayed_work(&toggle_charger, 0);
283         } else if (time_after(jiffies, sharpsl_pm.charge_start_time + SHARPSL_CHARGE_FINISH_TIME)) {
284                 dev_dbg(sharpsl_pm.dev, "Charge Full: Interrupt generated too slowly - retry.\n");
285                 schedule_delayed_work(&toggle_charger, 0);
286         } else {
287                 sharpsl_charge_off();
288                 sharpsl_pm.charge_mode = CHRG_DONE;
289                 dev_dbg(sharpsl_pm.dev, "Charge Full: Charging Finished\n");
290         }
291 }
292
293 /* Charging Finished Interrupt (Not present on Corgi) */
294 /* Can trigger at the same time as an AC staus change so
295    delay until after that has been processed */
296 irqreturn_t sharpsl_chrg_full_isr(int irq, void *dev_id)
297 {
298         if (sharpsl_pm.flags & SHARPSL_SUSPENDED)
299                 return IRQ_HANDLED;
300
301         /* delay until after any ac interrupt */
302         mod_timer(&sharpsl_pm.chrg_full_timer, jiffies + msecs_to_jiffies(500));
303
304         return IRQ_HANDLED;
305 }
306
307 irqreturn_t sharpsl_fatal_isr(int irq, void *dev_id)
308 {
309         int is_fatal = 0;
310
311         if (!sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_LOCK)) {
312                 dev_err(sharpsl_pm.dev, "Battery now Unlocked! Suspending.\n");
313                 is_fatal = 1;
314         }
315
316         if (!sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_FATAL)) {
317                 dev_err(sharpsl_pm.dev, "Fatal Batt Error! Suspending.\n");
318                 is_fatal = 1;
319         }
320
321         if (!(sharpsl_pm.flags & SHARPSL_APM_QUEUED) && is_fatal) {
322                 sharpsl_pm.flags |= SHARPSL_APM_QUEUED;
323                 apm_queue_event(APM_CRITICAL_SUSPEND);
324         }
325
326         return IRQ_HANDLED;
327 }
328
329 /*
330  * Maintain an average of the last 10 readings
331  */
332 #define SHARPSL_CNV_VALUE_NUM    10
333 static int sharpsl_ad_index;
334
335 static void sharpsl_average_clear(void)
336 {
337         sharpsl_ad_index = 0;
338 }
339
340 static int sharpsl_average_value(int ad)
341 {
342         int i, ad_val = 0;
343         static int sharpsl_ad[SHARPSL_CNV_VALUE_NUM+1];
344
345         if (sharpsl_pm.battstat.mainbat_status != APM_BATTERY_STATUS_HIGH) {
346                 sharpsl_ad_index = 0;
347                 return ad;
348         }
349
350         sharpsl_ad[sharpsl_ad_index] = ad;
351         sharpsl_ad_index++;
352         if (sharpsl_ad_index >= SHARPSL_CNV_VALUE_NUM) {
353                 for (i=0; i < (SHARPSL_CNV_VALUE_NUM-1); i++)
354                         sharpsl_ad[i] = sharpsl_ad[i+1];
355                 sharpsl_ad_index = SHARPSL_CNV_VALUE_NUM - 1;
356         }
357         for (i=0; i < sharpsl_ad_index; i++)
358                 ad_val += sharpsl_ad[i];
359
360         return (ad_val / sharpsl_ad_index);
361 }
362
363 /*
364  * Take an array of 5 integers, remove the maximum and minimum values
365  * and return the average.
366  */
367 static int get_select_val(int *val)
368 {
369         int i, j, k, temp, sum = 0;
370
371         /* Find MAX val */
372         temp = val[0];
373         j=0;
374         for (i=1; i<5; i++) {
375                 if (temp < val[i]) {
376                         temp = val[i];
377                         j = i;
378                 }
379         }
380
381         /* Find MIN val */
382         temp = val[4];
383         k=4;
384         for (i=3; i>=0; i--) {
385                 if (temp > val[i]) {
386                         temp = val[i];
387                         k = i;
388                 }
389         }
390
391         for (i=0; i<5; i++)
392                 if (i != j && i != k )
393                         sum += val[i];
394
395         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]);
396
397         return (sum/3);
398 }
399
400 static int sharpsl_check_battery_temp(void)
401 {
402         int val, i, buff[5];
403
404         /* Check battery temperature */
405         for (i=0; i<5; i++) {
406                 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP);
407                 sharpsl_pm.machinfo->measure_temp(1);
408                 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP);
409                 buff[i] = sharpsl_pm.machinfo->read_devdata(SHARPSL_BATT_TEMP);
410                 sharpsl_pm.machinfo->measure_temp(0);
411         }
412
413         val = get_select_val(buff);
414
415         dev_dbg(sharpsl_pm.dev, "Temperature: %d\n", val);
416         if (val > sharpsl_pm.machinfo->charge_on_temp) {
417                 printk(KERN_WARNING "Not charging: temperature out of limits.\n");
418                 return -1;
419         }
420
421         return 0;
422 }
423
424 static int sharpsl_check_battery_voltage(void)
425 {
426         int val, i, buff[5];
427
428         /* disable charge, enable discharge */
429         sharpsl_pm.machinfo->charge(0);
430         sharpsl_pm.machinfo->discharge(1);
431         mdelay(SHARPSL_WAIT_DISCHARGE_ON);
432
433         if (sharpsl_pm.machinfo->discharge1)
434                 sharpsl_pm.machinfo->discharge1(1);
435
436         /* Check battery voltage */
437         for (i=0; i<5; i++) {
438                 buff[i] = sharpsl_pm.machinfo->read_devdata(SHARPSL_BATT_VOLT);
439                 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT);
440         }
441
442         if (sharpsl_pm.machinfo->discharge1)
443                 sharpsl_pm.machinfo->discharge1(0);
444
445         sharpsl_pm.machinfo->discharge(0);
446
447         val = get_select_val(buff);
448         dev_dbg(sharpsl_pm.dev, "Battery Voltage: %d\n", val);
449
450         if (val < sharpsl_pm.machinfo->charge_on_volt)
451                 return -1;
452
453         return 0;
454 }
455
456 static int sharpsl_ac_check(void)
457 {
458         int temp, i, buff[5];
459
460         for (i=0; i<5; i++) {
461                 buff[i] = sharpsl_pm.machinfo->read_devdata(SHARPSL_ACIN_VOLT);
462                 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_ACIN);
463         }
464
465         temp = get_select_val(buff);
466         dev_dbg(sharpsl_pm.dev, "AC Voltage: %d\n",temp);
467
468         if ((temp > sharpsl_pm.machinfo->charge_acin_high) || (temp < sharpsl_pm.machinfo->charge_acin_low)) {
469                 dev_err(sharpsl_pm.dev, "Error: AC check failed.\n");
470                 return -1;
471         }
472
473         return 0;
474 }
475
476 #ifdef CONFIG_PM
477 static int sharpsl_pm_suspend(struct platform_device *pdev, pm_message_t state)
478 {
479         sharpsl_pm.flags |= SHARPSL_SUSPENDED;
480         flush_scheduled_work();
481
482         if (sharpsl_pm.charge_mode == CHRG_ON)
483                 sharpsl_pm.flags |= SHARPSL_DO_OFFLINE_CHRG;
484         else
485                 sharpsl_pm.flags &= ~SHARPSL_DO_OFFLINE_CHRG;
486
487         return 0;
488 }
489
490 static int sharpsl_pm_resume(struct platform_device *pdev)
491 {
492         /* Clear the reset source indicators as they break the bootloader upon reboot */
493         RCSR = 0x0f;
494         sharpsl_average_clear();
495         sharpsl_pm.flags &= ~SHARPSL_APM_QUEUED;
496         sharpsl_pm.flags &= ~SHARPSL_SUSPENDED;
497
498         return 0;
499 }
500
501 static void corgi_goto_sleep(unsigned long alarm_time, unsigned int alarm_enable, suspend_state_t state)
502 {
503         dev_dbg(sharpsl_pm.dev, "Time is: %08x\n",RCNR);
504
505         dev_dbg(sharpsl_pm.dev, "Offline Charge Activate = %d\n",sharpsl_pm.flags & SHARPSL_DO_OFFLINE_CHRG);
506         /* not charging and AC-IN! */
507
508         if ((sharpsl_pm.flags & SHARPSL_DO_OFFLINE_CHRG) && (sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN))) {
509                 dev_dbg(sharpsl_pm.dev, "Activating Offline Charger...\n");
510                 sharpsl_pm.charge_mode = CHRG_OFF;
511                 sharpsl_pm.flags &= ~SHARPSL_DO_OFFLINE_CHRG;
512                 sharpsl_off_charge_battery();
513         }
514
515         sharpsl_pm.machinfo->presuspend();
516
517         PEDR = 0xffffffff; /* clear it */
518
519         sharpsl_pm.flags &= ~SHARPSL_ALARM_ACTIVE;
520         if ((sharpsl_pm.charge_mode == CHRG_ON) && ((alarm_enable && ((alarm_time - RCNR) > (SHARPSL_BATCHK_TIME_SUSPEND + 30))) || !alarm_enable)) {
521                 RTSR &= RTSR_ALE;
522                 RTAR = RCNR + SHARPSL_BATCHK_TIME_SUSPEND;
523                 dev_dbg(sharpsl_pm.dev, "Charging alarm at: %08x\n",RTAR);
524                 sharpsl_pm.flags |= SHARPSL_ALARM_ACTIVE;
525         } else if (alarm_enable) {
526                 RTSR &= RTSR_ALE;
527                 RTAR = alarm_time;
528                 dev_dbg(sharpsl_pm.dev, "User alarm at: %08x\n",RTAR);
529         } else {
530                 dev_dbg(sharpsl_pm.dev, "No alarms set.\n");
531         }
532
533         pxa_pm_enter(state);
534
535         sharpsl_pm.machinfo->postsuspend();
536
537         dev_dbg(sharpsl_pm.dev, "Corgi woken up from suspend: %08x\n",PEDR);
538 }
539
540 static int corgi_enter_suspend(unsigned long alarm_time, unsigned int alarm_enable, suspend_state_t state)
541 {
542         if (!sharpsl_pm.machinfo->should_wakeup(!(sharpsl_pm.flags & SHARPSL_ALARM_ACTIVE) && alarm_enable) )
543         {
544                 if (!(sharpsl_pm.flags & SHARPSL_ALARM_ACTIVE)) {
545                         dev_dbg(sharpsl_pm.dev, "No user triggered wakeup events and not charging. Strange. Suspend.\n");
546                         corgi_goto_sleep(alarm_time, alarm_enable, state);
547                         return 1;
548                 }
549                 if(sharpsl_off_charge_battery()) {
550                         dev_dbg(sharpsl_pm.dev, "Charging. Suspend...\n");
551                         corgi_goto_sleep(alarm_time, alarm_enable, state);
552                         return 1;
553                 }
554                 dev_dbg(sharpsl_pm.dev, "User triggered wakeup in offline charger.\n");
555         }
556
557         if ((!sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_LOCK)) || (sharpsl_fatal_check() < 0) )
558         {
559                 dev_err(sharpsl_pm.dev, "Fatal condition. Suspend.\n");
560                 corgi_goto_sleep(alarm_time, alarm_enable, state);
561                 return 1;
562         }
563
564         return 0;
565 }
566
567 static int corgi_pxa_pm_enter(suspend_state_t state)
568 {
569         unsigned long alarm_time = RTAR;
570         unsigned int alarm_status = ((RTSR & RTSR_ALE) != 0);
571
572         dev_dbg(sharpsl_pm.dev, "SharpSL suspending for first time.\n");
573
574         corgi_goto_sleep(alarm_time, alarm_status, state);
575
576         while (corgi_enter_suspend(alarm_time,alarm_status,state))
577                 {}
578
579         if (sharpsl_pm.machinfo->earlyresume)
580                 sharpsl_pm.machinfo->earlyresume();
581
582         dev_dbg(sharpsl_pm.dev, "SharpSL resuming...\n");
583
584         return 0;
585 }
586 #endif
587
588
589 /*
590  * Check for fatal battery errors
591  * Fatal returns -1
592  */
593 static int sharpsl_fatal_check(void)
594 {
595         int buff[5], temp, i, acin;
596
597         dev_dbg(sharpsl_pm.dev, "sharpsl_fatal_check entered\n");
598
599         /* Check AC-Adapter */
600         acin = sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN);
601
602         if (acin && (sharpsl_pm.charge_mode == CHRG_ON)) {
603                 sharpsl_pm.machinfo->charge(0);
604                 udelay(100);
605                 sharpsl_pm.machinfo->discharge(1);      /* enable discharge */
606                 mdelay(SHARPSL_WAIT_DISCHARGE_ON);
607         }
608
609         if (sharpsl_pm.machinfo->discharge1)
610                 sharpsl_pm.machinfo->discharge1(1);
611
612         /* Check battery : check inserting battery ? */
613         for (i=0; i<5; i++) {
614                 buff[i] = sharpsl_pm.machinfo->read_devdata(SHARPSL_BATT_VOLT);
615                 mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT);
616         }
617
618         if (sharpsl_pm.machinfo->discharge1)
619                 sharpsl_pm.machinfo->discharge1(0);
620
621         if (acin && (sharpsl_pm.charge_mode == CHRG_ON)) {
622                 udelay(100);
623                 sharpsl_pm.machinfo->charge(1);
624                 sharpsl_pm.machinfo->discharge(0);
625         }
626
627         temp = get_select_val(buff);
628         dev_dbg(sharpsl_pm.dev, "sharpsl_fatal_check: acin: %d, discharge voltage: %d, no discharge: %d\n", acin, temp, sharpsl_pm.machinfo->read_devdata(SHARPSL_BATT_VOLT));
629
630         if ((acin && (temp < sharpsl_pm.machinfo->fatal_acin_volt)) ||
631                         (!acin && (temp < sharpsl_pm.machinfo->fatal_noacin_volt)))
632                 return -1;
633         return 0;
634 }
635
636 static int sharpsl_off_charge_error(void)
637 {
638         dev_err(sharpsl_pm.dev, "Offline Charger: Error occured.\n");
639         sharpsl_pm.machinfo->charge(0);
640         sharpsl_pm_led(SHARPSL_LED_ERROR);
641         sharpsl_pm.charge_mode = CHRG_ERROR;
642         return 1;
643 }
644
645 /*
646  * Charging Control while suspended
647  * Return 1 - go straight to sleep
648  * Return 0 - sleep or wakeup depending on other factors
649  */
650 static int sharpsl_off_charge_battery(void)
651 {
652         int time;
653
654         dev_dbg(sharpsl_pm.dev, "Charge Mode: %d\n", sharpsl_pm.charge_mode);
655
656         if (sharpsl_pm.charge_mode == CHRG_OFF) {
657                 dev_dbg(sharpsl_pm.dev, "Offline Charger: Step 1\n");
658
659                 /* AC Check */
660                 if ((sharpsl_ac_check() < 0) || (sharpsl_check_battery_temp() < 0))
661                         return sharpsl_off_charge_error();
662
663                 /* Start Charging */
664                 sharpsl_pm_led(SHARPSL_LED_ON);
665                 sharpsl_pm.machinfo->charge(0);
666                 mdelay(SHARPSL_CHARGE_WAIT_TIME);
667                 sharpsl_pm.machinfo->charge(1);
668
669                 sharpsl_pm.charge_mode = CHRG_ON;
670                 sharpsl_pm.full_count = 0;
671
672                 return 1;
673         } else if (sharpsl_pm.charge_mode != CHRG_ON) {
674                 return 1;
675         }
676
677         if (sharpsl_pm.full_count == 0) {
678                 int time;
679
680                 dev_dbg(sharpsl_pm.dev, "Offline Charger: Step 2\n");
681
682                 if ((sharpsl_check_battery_temp() < 0) || (sharpsl_check_battery_voltage() < 0))
683                         return sharpsl_off_charge_error();
684
685                 sharpsl_pm.machinfo->charge(0);
686                 mdelay(SHARPSL_CHARGE_WAIT_TIME);
687                 sharpsl_pm.machinfo->charge(1);
688                 sharpsl_pm.charge_mode = CHRG_ON;
689
690                 mdelay(SHARPSL_CHARGE_CO_CHECK_TIME);
691
692                 time = RCNR;
693                 while(1) {
694                         /* Check if any wakeup event had occured */
695                         if (sharpsl_pm.machinfo->charger_wakeup() != 0)
696                                 return 0;
697                         /* Check for timeout */
698                         if ((RCNR - time) > SHARPSL_WAIT_CO_TIME)
699                                 return 1;
700                         if (sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_CHRGFULL)) {
701                                 dev_dbg(sharpsl_pm.dev, "Offline Charger: Charge full occured. Retrying to check\n");
702                                 sharpsl_pm.full_count++;
703                                 sharpsl_pm.machinfo->charge(0);
704                                 mdelay(SHARPSL_CHARGE_WAIT_TIME);
705                                 sharpsl_pm.machinfo->charge(1);
706                                 return 1;
707                         }
708                 }
709         }
710
711         dev_dbg(sharpsl_pm.dev, "Offline Charger: Step 3\n");
712
713         mdelay(SHARPSL_CHARGE_CO_CHECK_TIME);
714
715         time = RCNR;
716         while(1) {
717                 /* Check if any wakeup event had occured */
718                 if (sharpsl_pm.machinfo->charger_wakeup() != 0)
719                         return 0;
720                 /* Check for timeout */
721                 if ((RCNR-time) > SHARPSL_WAIT_CO_TIME) {
722                         if (sharpsl_pm.full_count > SHARPSL_CHARGE_RETRY_CNT) {
723                                 dev_dbg(sharpsl_pm.dev, "Offline Charger: Not charged sufficiently. Retrying.\n");
724                                 sharpsl_pm.full_count = 0;
725                         }
726                         sharpsl_pm.full_count++;
727                         return 1;
728                 }
729                 if (sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_CHRGFULL)) {
730                         dev_dbg(sharpsl_pm.dev, "Offline Charger: Charging complete.\n");
731                         sharpsl_pm_led(SHARPSL_LED_OFF);
732                         sharpsl_pm.machinfo->charge(0);
733                         sharpsl_pm.charge_mode = CHRG_DONE;
734                         return 1;
735                 }
736         }
737 }
738
739
740 static ssize_t battery_percentage_show(struct device *dev, struct device_attribute *attr, char *buf)
741 {
742         return sprintf(buf, "%d\n",sharpsl_pm.battstat.mainbat_percent);
743 }
744
745 static ssize_t battery_voltage_show(struct device *dev, struct device_attribute *attr, char *buf)
746 {
747         return sprintf(buf, "%d\n",sharpsl_pm.battstat.mainbat_voltage);
748 }
749
750 static DEVICE_ATTR(battery_percentage, 0444, battery_percentage_show, NULL);
751 static DEVICE_ATTR(battery_voltage, 0444, battery_voltage_show, NULL);
752
753 extern void (*apm_get_power_status)(struct apm_power_info *);
754
755 static void sharpsl_apm_get_power_status(struct apm_power_info *info)
756 {
757         info->ac_line_status = sharpsl_pm.battstat.ac_status;
758
759         if (sharpsl_pm.charge_mode == CHRG_ON)
760                 info->battery_status = APM_BATTERY_STATUS_CHARGING;
761         else
762                 info->battery_status = sharpsl_pm.battstat.mainbat_status;
763
764         info->battery_flag = (1 << info->battery_status);
765         info->battery_life = sharpsl_pm.battstat.mainbat_percent;
766 }
767
768 static struct pm_ops sharpsl_pm_ops = {
769         .pm_disk_mode   = PM_DISK_FIRMWARE,
770         .prepare        = pxa_pm_prepare,
771         .enter          = corgi_pxa_pm_enter,
772         .finish         = pxa_pm_finish,
773 };
774
775 static int __init sharpsl_pm_probe(struct platform_device *pdev)
776 {
777         if (!pdev->dev.platform_data)
778                 return -EINVAL;
779
780         sharpsl_pm.dev = &pdev->dev;
781         sharpsl_pm.machinfo = pdev->dev.platform_data;
782         sharpsl_pm.charge_mode = CHRG_OFF;
783         sharpsl_pm.flags = 0;
784
785         init_timer(&sharpsl_pm.ac_timer);
786         sharpsl_pm.ac_timer.function = sharpsl_ac_timer;
787
788         init_timer(&sharpsl_pm.chrg_full_timer);
789         sharpsl_pm.chrg_full_timer.function = sharpsl_chrg_full_timer;
790
791         led_trigger_register_simple("sharpsl-charge", &sharpsl_charge_led_trigger);
792
793         sharpsl_pm.machinfo->init();
794
795         device_create_file(&pdev->dev, &dev_attr_battery_percentage);
796         device_create_file(&pdev->dev, &dev_attr_battery_voltage);
797
798         apm_get_power_status = sharpsl_apm_get_power_status;
799
800         pm_set_ops(&sharpsl_pm_ops);
801
802         mod_timer(&sharpsl_pm.ac_timer, jiffies + msecs_to_jiffies(250));
803
804         return 0;
805 }
806
807 static int sharpsl_pm_remove(struct platform_device *pdev)
808 {
809         pm_set_ops(NULL);
810
811         device_remove_file(&pdev->dev, &dev_attr_battery_percentage);
812         device_remove_file(&pdev->dev, &dev_attr_battery_voltage);
813
814         led_trigger_unregister_simple(sharpsl_charge_led_trigger);
815
816         sharpsl_pm.machinfo->exit();
817
818         del_timer_sync(&sharpsl_pm.chrg_full_timer);
819         del_timer_sync(&sharpsl_pm.ac_timer);
820
821         return 0;
822 }
823
824 static struct platform_driver sharpsl_pm_driver = {
825         .probe          = sharpsl_pm_probe,
826         .remove         = sharpsl_pm_remove,
827         .suspend        = sharpsl_pm_suspend,
828         .resume         = sharpsl_pm_resume,
829         .driver         = {
830                 .name           = "sharpsl-pm",
831         },
832 };
833
834 static int __devinit sharpsl_pm_init(void)
835 {
836         return platform_driver_register(&sharpsl_pm_driver);
837 }
838
839 static void sharpsl_pm_exit(void)
840 {
841         platform_driver_unregister(&sharpsl_pm_driver);
842 }
843
844 late_initcall(sharpsl_pm_init);
845 module_exit(sharpsl_pm_exit);