sharpsl_pm.c 23 KB

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