![[BACK]](/icons/back.gif){kind=icon}
Return to zaurus_apm.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / zaurus / dev|
Return to zaurus_apm.c CVS log | Up to [local] / sys / arch / zaurus / dev |
1.1 nbrk 1: /* $OpenBSD: zaurus_apm.c,v 1.13 2006/12/12 23:14:28 dim Exp $ */
2:
3: /*
4: * Copyright (c) 2005 Uwe Stuehler <uwe@bsdx.de>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <sys/param.h>
20: #include <sys/systm.h>
21: #include <sys/kernel.h>
22: #include <sys/timeout.h>
23: #include <sys/conf.h>
24: #include <sys/sysctl.h>
25:
26: #include <arm/xscale/pxa2x0reg.h>
27: #include <arm/xscale/pxa2x0var.h>
28: #include <arm/xscale/pxa2x0_apm.h>
29: #include <arm/xscale/pxa2x0_gpio.h>
30:
31: #include <zaurus/dev/zaurus_scoopvar.h>
32: #include <zaurus/dev/zaurus_sspvar.h>
33: void zssp_init(void); /* XXX */
34:
35: #include <zaurus/dev/zaurus_apm.h>
36:
37: #if defined(APMDEBUG)
38: #define DPRINTF(x) printf x
39: #else
40: #define DPRINTF(x) /**/
41: #endif
42:
43: struct zapm_softc {
44: struct pxa2x0_apm_softc sc;
45: struct timeout sc_poll;
46: struct timeval sc_lastbattchk;
47: int sc_suspended;
48: int sc_ac_on;
49: int sc_charging;
50: int sc_discharging;
51: int sc_batt_full;
52: int sc_batt_volt;
53: u_int sc_event;
54: };
55:
56: int apm_match(struct device *, void *, void *);
57: void apm_attach(struct device *, struct device *, void *);
58:
59: struct cfattach apm_pxaip_ca = {
60: sizeof (struct zapm_softc), apm_match, apm_attach
61: };
62: extern struct cfdriver apm_cd;
63:
64: /* MAX1111 command word */
65: #define MAXCTRL_PD0 (1<<0)
66: #define MAXCTRL_PD1 (1<<1)
67: #define MAXCTRL_SGL (1<<2)
68: #define MAXCTRL_UNI (1<<3)
69: #define MAXCTRL_SEL_SHIFT 4
70: #define MAXCTRL_STR (1<<7)
71:
72: /* MAX1111 ADC channels */
73: #define BATT_THM 2
74: #define BATT_AD 4
75: #define JK_VAD 6
76:
77: /* battery-related GPIO pins */
78: #define GPIO_AC_IN_C3000 115 /* 0=AC connected */
79: #define GPIO_CHRG_CO_C3000 101 /* 1=battery full */
80: #define GPIO_BATT_COVER_C3000 90 /* 0=unlocked */
81:
82: /*
83: * Battery-specific information
84: */
85:
86: struct battery_threshold {
87: int bt_volt;
88: int bt_life;
89: int bt_state;
90: };
91:
92: struct battery_info {
93: int bi_minutes; /* 100% life time */
94: const struct battery_threshold *bi_thres;
95: };
96:
97: const struct battery_threshold zaurus_battery_life_c3000[] = {
98: #if 0
99: {224, 125, APM_BATT_HIGH}, /* XXX unverified */
100: #endif
101: {194, 100, APM_BATT_HIGH},
102: {188, 75, APM_BATT_HIGH},
103: {184, 50, APM_BATT_HIGH},
104: {180, 25, APM_BATT_LOW},
105: {178, 5, APM_BATT_LOW},
106: {0, 0, APM_BATT_CRITICAL},
107: };
108:
109: const struct battery_info zaurus_battery_c3000 = {
110: 180 /* minutes; pessimistic estimate */,
111: zaurus_battery_life_c3000
112: };
113:
114: const struct battery_info *zaurus_main_battery = &zaurus_battery_c3000;
115:
116: /* Restart charging this many times before accepting BATT_FULL. */
117: #define MIN_BATT_FULL 2
118:
119: /* Discharge 100 ms before reading the voltage if AC is connected. */
120: #define DISCHARGE_TIMEOUT (hz / 10)
121:
122: /* Check battery voltage and "kick charging" every minute. */
123: const struct timeval zapm_battchkrate = { 60, 0 };
124:
125: /* Prototypes */
126:
127: #if 0
128: void zapm_shutdown(void *);
129: #endif
130: int zapm_acintr(void *);
131: int zapm_bcintr(void *);
132: int zapm_ac_on(void);
133: int max1111_adc_value(int);
134: int max1111_adc_value_avg(int, int);
135: #if 0
136: int zapm_jkvad_voltage(void);
137: int zapm_batt_temp(void);
138: #endif
139: int zapm_batt_volt(void);
140: int zapm_batt_state(int);
141: int zapm_batt_life(int);
142: int zapm_batt_minutes(int);
143: void zapm_enable_charging(struct zapm_softc *, int);
144: int zapm_charge_complete(struct zapm_softc *);
145: void zapm_poll(void *);
146: int zapm_get_event(struct pxa2x0_apm_softc *, u_int *);
147: void zapm_power_info(struct pxa2x0_apm_softc *, struct apm_power_info *);
148: void zapm_suspend(struct pxa2x0_apm_softc *);
149: int zapm_resume(struct pxa2x0_apm_softc *);
150: void pxa2x0_setperf(int);
151: int pxa2x0_cpuspeed(int *);
152:
153:
154: int
155: apm_match(struct device *parent, void *match, void *aux)
156: {
157: return (1);
158: }
159:
160: void
161: apm_attach(struct device *parent, struct device *self, void *aux)
162: {
163: struct zapm_softc *sc = (struct zapm_softc *)self;
164:
165: pxa2x0_gpio_set_function(GPIO_AC_IN_C3000, GPIO_IN);
166: pxa2x0_gpio_set_function(GPIO_CHRG_CO_C3000, GPIO_IN);
167: pxa2x0_gpio_set_function(GPIO_BATT_COVER_C3000, GPIO_IN);
168:
169: (void)pxa2x0_gpio_intr_establish(GPIO_AC_IN_C3000,
170: IST_EDGE_BOTH, IPL_BIO, zapm_acintr, sc, "apm_ac");
171: (void)pxa2x0_gpio_intr_establish(GPIO_BATT_COVER_C3000,
172: IST_EDGE_BOTH, IPL_BIO, zapm_bcintr, sc, "apm_bc");
173:
174: sc->sc_event = APM_NOEVENT;
175: sc->sc.sc_get_event = zapm_get_event;
176: sc->sc.sc_power_info = zapm_power_info;
177: sc->sc.sc_suspend = zapm_suspend;
178: sc->sc.sc_resume = zapm_resume;
179:
180: timeout_set(&sc->sc_poll, &zapm_poll, sc);
181:
182: /* Get initial battery voltage. */
183: zapm_enable_charging(sc, 0);
184: if (zapm_ac_on()) {
185: /* C3000: discharge 100 ms when AC is on. */
186: scoop_discharge_battery(1);
187: delay(100000);
188: }
189: sc->sc_batt_volt = zapm_batt_volt();
190: scoop_discharge_battery(0);
191:
192: pxa2x0_apm_attach_sub(&sc->sc);
193:
194: #if 0
195: (void)shutdownhook_establish(zapm_shutdown, NULL);
196: #endif
197:
198: cpu_setperf = pxa2x0_setperf;
199: cpu_cpuspeed = pxa2x0_cpuspeed;
200: }
201:
202: #if 0
203: void
204: zapm_shutdown(void *v)
205: {
206: struct zapm_softc *sc = v;
207:
208: zapm_enable_charging(sc, 0);
209: }
210: #endif
211:
212: int
213: zapm_acintr(void *v)
214: {
215: zapm_poll(v);
216: return (1);
217: }
218:
219: int
220: zapm_bcintr(void *v)
221: {
222: zapm_poll(v);
223: return (1);
224: }
225:
226: int
227: zapm_ac_on(void)
228: {
229: return (!pxa2x0_gpio_get_bit(GPIO_AC_IN_C3000));
230: }
231:
232: int
233: max1111_adc_value(int chan)
234: {
235:
236: return ((int)zssp_ic_send(ZSSP_IC_MAX1111, MAXCTRL_PD0 |
237: MAXCTRL_PD1 | MAXCTRL_SGL | MAXCTRL_UNI |
238: (chan << MAXCTRL_SEL_SHIFT) | MAXCTRL_STR));
239: }
240:
241: /* XXX simplify */
242: int
243: max1111_adc_value_avg(int chan, int pause)
244: {
245: int val[5];
246: int i, j, k, x;
247: int sum = 0;
248:
249: for (i = 0; i < 5; i++) {
250: val[i] = max1111_adc_value(chan);
251: if (i != 4)
252: delay(pause * 1000);
253: }
254:
255: x = val[0];
256: j = 0;
257: for (i = 1; i < 5; i++) {
258: if (x < val[i]) {
259: x = val[i];
260: j = i;
261: }
262: }
263:
264: x = val[4];
265: k = 4;
266: for (i = 3; i >= 0; i--) {
267: if (x > val[i]) {
268: x = val[i];
269: k = i;
270: }
271: }
272:
273: for (i = 0; i < 5; i++) {
274: if (i == j || i == k)
275: continue;
276: sum += val[i];
277: }
278:
279: return (sum / 3);
280: }
281:
282: #if 0
283: /*
284: * Return the voltage available for charging. This will be zero,
285: * unless A/C power is connected.
286: */
287: int
288: zapm_jkvad_voltage(void)
289: {
290:
291: return (max1111_adc_value_avg(JK_VAD, 10));
292: }
293:
294: int
295: zapm_batt_temp(void)
296: {
297: int temp;
298:
299: scoop_battery_temp_adc(1);
300: delay(10000);
301: temp = max1111_adc_value_avg(BATT_THM, 1);
302: scoop_battery_temp_adc(0);
303:
304: return (temp);
305: }
306: #endif
307:
308: int
309: zapm_batt_volt(void)
310: {
311:
312: return (max1111_adc_value_avg(BATT_AD, 10));
313: }
314:
315: int
316: zapm_batt_state(int volt)
317: {
318: const struct battery_threshold *bthr;
319: int i;
320:
321: bthr = zaurus_main_battery->bi_thres;
322:
323: for (i = 0; bthr[i].bt_volt > 0; i++)
324: if (bthr[i].bt_volt <= volt)
325: break;
326:
327: return (bthr[i].bt_state);
328: }
329:
330: int
331: zapm_batt_life(int volt)
332: {
333: const struct battery_threshold *bthr;
334: int i;
335:
336: bthr = zaurus_main_battery->bi_thres;
337:
338: for (i = 0; bthr[i].bt_volt > 0; i++)
339: if (bthr[i].bt_volt <= volt)
340: break;
341:
342: if (i == 0)
343: return (bthr[i].bt_life);
344:
345: return (bthr[i].bt_life +
346: ((volt - bthr[i].bt_volt) * 100) /
347: (bthr[i-1].bt_volt - bthr[i].bt_volt) *
348: (bthr[i-1].bt_life - bthr[i].bt_life) / 100);
349: }
350:
351: int
352: zapm_batt_minutes(int life)
353: {
354:
355: return (zaurus_main_battery->bi_minutes * life / 100);
356: }
357:
358: void
359: zapm_enable_charging(struct zapm_softc *sc, int enable)
360: {
361:
362: scoop_discharge_battery(0);
363: scoop_charge_battery(enable, 0);
364: scoop_led_set(SCOOP_LED_ORANGE, enable);
365: }
366:
367: /*
368: * Return non-zero if the charge complete signal indicates that the
369: * battery is fully charged. Restart charging to clear this signal.
370: */
371: int
372: zapm_charge_complete(struct zapm_softc *sc)
373: {
374:
375: if (sc->sc_charging && sc->sc_batt_full < MIN_BATT_FULL) {
376: if (pxa2x0_gpio_get_bit(GPIO_CHRG_CO_C3000) != 0) {
377: if (++sc->sc_batt_full < MIN_BATT_FULL) {
378: DPRINTF(("battery almost full\n"));
379: zapm_enable_charging(sc, 0);
380: delay(15000);
381: zapm_enable_charging(sc, 1);
382: }
383: } else if (sc->sc_batt_full > 0) {
384: /* false alarm */
385: sc->sc_batt_full = 0;
386: zapm_enable_charging(sc, 0);
387: delay(15000);
388: zapm_enable_charging(sc, 1);
389: }
390: }
391:
392: return (sc->sc_batt_full >= MIN_BATT_FULL);
393: }
394:
395: /*
396: * Poll power-management related GPIO inputs, update battery life
397: * in softc, and/or control battery charging.
398: */
399: void
400: zapm_poll(void *v)
401: {
402: struct zapm_softc *sc = v;
403: int ac_on;
404: int bc_lock;
405: int charging;
406: int volt;
407: int s;
408:
409: s = splhigh();
410:
411: /* Check positition of battery compartment lock switch. */
412: bc_lock = pxa2x0_gpio_get_bit(GPIO_BATT_COVER_C3000) ? 1 : 0;
413:
414: /* Stop discharging. */
415: if (sc->sc_discharging) {
416: sc->sc_discharging = 0;
417: volt = zapm_batt_volt();
418: ac_on = zapm_ac_on();
419: charging = 0;
420: DPRINTF(("zapm_poll: discharge off volt %d\n", volt));
421: } else {
422: ac_on = zapm_ac_on();
423: charging = sc->sc_charging;
424: volt = sc->sc_batt_volt;
425: }
426:
427: /* Start or stop charging as necessary. */
428: if (ac_on && bc_lock) {
429: if (charging) {
430: if (zapm_charge_complete(sc)) {
431: DPRINTF(("zapm_poll: batt full\n"));
432: charging = 0;
433: zapm_enable_charging(sc, 0);
434: }
435: } else if (!zapm_charge_complete(sc)) {
436: charging = 1;
437: volt = zapm_batt_volt();
438: zapm_enable_charging(sc, 1);
439: DPRINTF(("zapm_poll: start charging volt %d\n", volt));
440: }
441: } else {
442: if (charging) {
443: charging = 0;
444: zapm_enable_charging(sc, 0);
445: timerclear(&sc->sc_lastbattchk);
446: DPRINTF(("zapm_poll: stop charging\n"));
447: }
448: sc->sc_batt_full = 0;
449: }
450:
451: /*
452: * Restart charging once in a while. Discharge a few milliseconds
453: * before updating the voltage in our softc if A/C is connected.
454: */
455: if (bc_lock && ratecheck(&sc->sc_lastbattchk, &zapm_battchkrate)) {
456: if (sc->sc_suspended) {
457: DPRINTF(("zapm_poll: suspended %lu %lu\n",
458: sc->sc_lastbattchk.tv_sec,
459: pxa2x0_rtc_getsecs()));
460: if (charging) {
461: zapm_enable_charging(sc, 0);
462: delay(15000);
463: zapm_enable_charging(sc, 1);
464: pxa2x0_rtc_setalarm(pxa2x0_rtc_getsecs() +
465: zapm_battchkrate.tv_sec + 1);
466: }
467: } else if (ac_on && sc->sc_batt_full == 0) {
468: DPRINTF(("zapm_poll: discharge on\n"));
469: if (charging)
470: zapm_enable_charging(sc, 0);
471: sc->sc_discharging = 1;
472: scoop_discharge_battery(1);
473: timeout_add(&sc->sc_poll, DISCHARGE_TIMEOUT);
474: } else if (!ac_on) {
475: volt = zapm_batt_volt();
476: DPRINTF(("zapm_poll: volt %d\n", volt));
477: }
478: }
479:
480: /* Update the cached power state in our softc. */
481: if (ac_on != sc->sc_ac_on || charging != sc->sc_charging ||
482: volt != sc->sc_batt_volt) {
483: sc->sc_ac_on = ac_on;
484: sc->sc_charging = charging;
485: sc->sc_batt_volt = volt;
486: if (sc->sc_event == APM_NOEVENT)
487: sc->sc_event = APM_POWER_CHANGE;
488: }
489:
490: /* Detect battery low conditions. */
491: if (!ac_on) {
492: if (zapm_batt_life(volt) < 5)
493: sc->sc_event = APM_BATTERY_LOW;
494: if (zapm_batt_state(volt) == APM_BATT_CRITICAL)
495: sc->sc_event = APM_CRIT_SUSPEND_REQ;
496: }
497:
498: #ifdef APMDEBUG
499: if (sc->sc_event != APM_NOEVENT)
500: DPRINTF(("zapm_poll: power event %d\n", sc->sc_event));
501: #endif
502: splx(s);
503: }
504:
505: /*
506: * apm_thread() calls this routine approximately once per second.
507: */
508: int
509: zapm_get_event(struct pxa2x0_apm_softc *pxa_sc, u_int *typep)
510: {
511: struct zapm_softc *sc = (struct zapm_softc *)pxa_sc;
512: int s;
513:
514: s = splsoftclock();
515:
516: /* Don't interfere with discharging. */
517: if (sc->sc_discharging)
518: *typep = sc->sc_event;
519: else if (sc->sc_event == APM_NOEVENT) {
520: zapm_poll(sc);
521: *typep = sc->sc_event;
522: }
523: sc->sc_event = APM_NOEVENT;
524:
525: splx(s);
526: return (*typep == APM_NOEVENT);
527: }
528:
529: /*
530: * Return power status to the generic APM driver.
531: */
532: void
533: zapm_power_info(struct pxa2x0_apm_softc *pxa_sc, struct apm_power_info *power)
534: {
535: struct zapm_softc *sc = (struct zapm_softc *)pxa_sc;
536: int s;
537: int ac_on;
538: int volt;
539: int charging;
540:
541: s = splsoftclock();
542: ac_on = sc->sc_ac_on;
543: volt = sc->sc_batt_volt;
544: charging = sc->sc_charging;
545: splx(s);
546:
547: power->ac_state = ac_on ? APM_AC_ON : APM_AC_OFF;
548: if (charging)
549: power->battery_state = APM_BATT_CHARGING;
550: else
551: power->battery_state = zapm_batt_state(volt);
552:
553: power->battery_life = zapm_batt_life(volt);
554: power->minutes_left = zapm_batt_minutes(power->battery_life);
555: }
556:
557: /*
558: * Called before suspending when all powerhooks are done.
559: */
560: void
561: zapm_suspend(struct pxa2x0_apm_softc *pxa_sc)
562: {
563: struct zapm_softc *sc = (struct zapm_softc *)pxa_sc;
564:
565: /* Poll in suspended mode and forget the discharge timeout. */
566: sc->sc_suspended = 1;
567: timeout_del(&sc->sc_poll);
568:
569: /* Make sure charging is enabled and RTC alarm is set. */
570: timerclear(&sc->sc_lastbattchk);
571:
572: zapm_poll(sc);
573:
574: #if 0
575: pxa2x0_rtc_setalarm(pxa2x0_rtc_getsecs() + 5);
576: #endif
577: pxa2x0_wakeup_config(PXA2X0_WAKEUP_ALL, 1);
578: }
579:
580: /*
581: * Called after wake-up from suspend with interrupts still disabled,
582: * before any powerhooks are done.
583: */
584: int
585: zapm_resume(struct pxa2x0_apm_softc *pxa_sc)
586: {
587: struct zapm_softc *sc = (struct zapm_softc *)pxa_sc;
588: int a, b;
589: u_int wsrc;
590: int wakeup = 0;
591:
592: /* C3000 */
593: a = pxa2x0_gpio_get_bit(97) ? 1 : 0;
594: b = pxa2x0_gpio_get_bit(96) ? 2 : 0;
595:
596: wsrc = pxa2x0_wakeup_status();
597:
598: /* Resume only if the lid is not closed. */
599: if ((a | b) != 3 && (wsrc & PXA2X0_WAKEUP_POWERON) != 0) {
600: int timeout = 100; /* 10 ms */
601: /* C3000 */
602: while (timeout-- > 0 && pxa2x0_gpio_get_bit(95) != 0) {
603: if (timeout == 0) {
604: wakeup = 1;
605: break;
606: }
607: delay(100);
608: }
609: }
610:
611: /* Initialize the SSP unit before using the MAX1111 again. */
612: zssp_init();
613:
614: zapm_poll(sc);
615:
616: if (wakeup) {
617: /* Resume normal polling. */
618: sc->sc_suspended = 0;
619:
620: pxa2x0_rtc_setalarm(0);
621: } else {
622: #if 0
623: DPRINTF(("zapm_resume: suspended %lu %lu\n",
624: sc->sc_lastbattchk.tv_sec, pxa2x0_rtc_getsecs()));
625: pxa2x0_rtc_setalarm(pxa2x0_rtc_getsecs() + 5);
626: #endif
627: }
628:
629: return (wakeup);
630: }
631:
632: void
633: zapm_poweroff(void)
634: {
635: struct pxa2x0_apm_softc *sc;
636:
637: KASSERT(apm_cd.cd_ndevs > 0 && apm_cd.cd_devs[0] != NULL);
638: sc = apm_cd.cd_devs[0];
639:
640: dopowerhooks(PWR_SUSPEND);
641:
642: /* XXX enable charging during suspend */
643:
644: /* XXX keep power LED state during suspend */
645:
646: /* XXX do the same thing for GPIO 43 (BTTXD) */
647:
648: /* XXX scoop power down */
649:
650: /* XXX set PGSRn and GPDRn */
651:
652: pxa2x0_wakeup_config(PXA2X0_WAKEUP_ALL, 1);
653:
654: do {
655: pxa2x0_apm_sleep(sc);
656: }
657: while (!zapm_resume(sc));
658:
659: zapm_restart();
660:
661: /* NOTREACHED */
662: dopowerhooks(PWR_RESUME);
663: }
664:
665: /*
666: * Do a GPIO reset, immediately causing the processor to begin the normal
667: * boot sequence. See 2.7 Reset in the PXA27x Developer's Manual for the
668: * summary of effects of this kind of reset.
669: */
670: void
671: zapm_restart(void)
672: {
673: if (apm_cd.cd_ndevs > 0 && apm_cd.cd_devs[0] != NULL) {
674: struct pxa2x0_apm_softc *sc = apm_cd.cd_devs[0];
675: int rv;
676:
677: /*
678: * Reduce the ROM Delay Next Access and ROM Delay First
679: * Access times for synchronous flash connected to nCS1.
680: */
681: rv = bus_space_read_4(sc->sc_iot, sc->sc_memctl_ioh,
682: MEMCTL_MSC0);
683: if ((rv & 0xffff0000) == 0x7ff00000)
684: bus_space_write_4(sc->sc_iot, sc->sc_memctl_ioh,
685: MEMCTL_MSC0, (rv & 0xffff) | 0x7ee00000);
686: }
687:
688: /* External reset circuit presumably asserts nRESET_GPIO. */
689: pxa2x0_gpio_set_function(89, GPIO_OUT | GPIO_SET);
690: delay(1000000);
691: }