![[BACK]](/icons/back.gif){kind=icon}
Return to pm_direct.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / macppc / dev|
Return to pm_direct.c CVS log | Up to [local] / sys / arch / macppc / dev |
1.1 nbrk 1: /* $OpenBSD: pm_direct.c,v 1.22 2007/02/18 19:33:48 gwk Exp $ */
2: /* $NetBSD: pm_direct.c,v 1.9 2000/06/08 22:10:46 tsubai Exp $ */
3:
4: /*
5: * Copyright (C) 1997 Takashi Hamada
6: * All rights reserved.
7: *
8: * Redistribution and use in source and binary forms, with or without
9: * modification, are permitted provided that the following conditions
10: * are met:
11: * 1. Redistributions of source code must retain the above copyright
12: * notice, this list of conditions and the following disclaimer.
13: * 2. Redistributions in binary form must reproduce the above copyright
14: * notice, this list of conditions and the following disclaimer in the
15: * documentation and/or other materials provided with the distribution.
16: * 3. All advertising materials mentioning features or use of this software
17: * must display the following acknowledgement:
18: * This product includes software developed by Takashi Hamada
19: * 4. The name of the author may not be used to endorse or promote products
20: * derived from this software without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32: */
33:
34: #ifdef DEBUG
35: #ifndef ADB_DEBUG
36: #define ADB_DEBUG
37: #endif
38: #endif
39:
40: /* #define PM_GRAB_SI 1 */
41:
42: #include <sys/param.h>
43: #include <sys/cdefs.h>
44: #include <sys/device.h>
45: #include <sys/systm.h>
46:
47: #include <machine/cpu.h>
48:
49: #include <dev/adb/adb.h>
50: #include <macppc/dev/adbvar.h>
51: #include <macppc/dev/pm_direct.h>
52: #include <macppc/dev/viareg.h>
53:
54: /* hardware dependent values */
55: #define ADBDelay 100 /* XXX */
56:
57: /* define the types of the Power Manager */
58: #define PM_HW_UNKNOWN 0x00 /* don't know */
59: #define PM_HW_PB5XX 0x02 /* PowerBook Duo and 5XX series */
60:
61: /* useful macros */
62: #define PM_SR() read_via_reg(VIA1, vSR)
63: #define PM_VIA_INTR_ENABLE() write_via_reg(VIA1, vIER, 0x90)
64: #define PM_VIA_INTR_DISABLE() write_via_reg(VIA1, vIER, 0x10)
65: #define PM_VIA_CLR_INTR() write_via_reg(VIA1, vIFR, 0x90)
66: #if 0
67: #define PM_SET_STATE_ACKON() via_reg_or(VIA2, vBufB, 0x04)
68: #define PM_SET_STATE_ACKOFF() via_reg_and(VIA2, vBufB, ~0x04)
69: #define PM_IS_ON (0x02 == (read_via_reg(VIA2, vBufB) & 0x02))
70: #define PM_IS_OFF (0x00 == (read_via_reg(VIA2, vBufB) & 0x02))
71: #else
72: #define PM_SET_STATE_ACKON() via_reg_or(VIA2, vBufB, 0x10)
73: #define PM_SET_STATE_ACKOFF() via_reg_and(VIA2, vBufB, ~0x10)
74: #define PM_IS_ON (0x08 == (read_via_reg(VIA2, vBufB) & 0x08))
75: #define PM_IS_OFF (0x00 == (read_via_reg(VIA2, vBufB) & 0x08))
76: #endif
77:
78: /*
79: * Variables for internal use
80: */
81: int pmHardware = PM_HW_UNKNOWN;
82:
83: /* these values shows that number of data returned after 'send' cmd is sent */
84: signed char pm_send_cmd_type[] = {
85: -1, -1, -1, -1, -1, -1, -1, -1,
86: -1, -1, -1, -1, -1, -1, -1, -1,
87: 0x01, 0x01, -1, -1, -1, -1, -1, -1,
88: 0x00, 0x00, -1, -1, -1, -1, -1, 0x00,
89: -1, 0x00, 0x02, 0x01, 0x01, -1, -1, -1,
90: 0x00, -1, -1, -1, -1, -1, -1, -1,
91: 0x04, 0x14, -1, 0x03, -1, -1, -1, -1,
92: 0x00, 0x00, 0x02, 0x02, -1, -1, -1, -1,
93: 0x01, 0x01, -1, -1, -1, -1, -1, -1,
94: 0x00, 0x00, -1, -1, 0x01, -1, -1, -1,
95: 0x01, 0x00, 0x02, 0x02, -1, 0x01, 0x03, 0x01,
96: 0x00, 0x01, 0x00, 0x00, 0x00, -1, -1, -1,
97: 0x02, -1, -1, -1, -1, -1, -1, -1,
98: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, -1, -1,
99: 0x01, 0x01, 0x01, -1, -1, -1, -1, -1,
100: 0x00, 0x00, -1, -1, -1, -1, 0x04, 0x04,
101: 0x04, -1, 0x00, -1, -1, -1, -1, -1,
102: 0x00, -1, -1, -1, -1, -1, -1, -1,
103: 0x01, 0x02, -1, -1, -1, -1, -1, -1,
104: 0x00, 0x00, -1, -1, -1, -1, -1, -1,
105: 0x02, 0x02, 0x02, 0x04, -1, 0x00, -1, -1,
106: 0x01, 0x01, 0x03, 0x02, -1, -1, -1, -1,
107: -1, -1, -1, -1, -1, -1, -1, -1,
108: -1, -1, -1, -1, -1, -1, -1, -1,
109: -1, -1, -1, -1, -1, -1, -1, -1,
110: -1, -1, -1, -1, -1, -1, -1, -1,
111: 0x00, -1, -1, -1, -1, -1, -1, -1,
112: 0x01, 0x01, -1, -1, 0x00, 0x00, -1, -1,
113: -1, 0x04, 0x00, -1, -1, -1, -1, -1,
114: 0x03, -1, 0x00, -1, 0x00, -1, -1, 0x00,
115: -1, -1, -1, -1, -1, -1, -1, -1,
116: -1, -1, -1, -1, -1, -1, -1, -1
117: };
118:
119: /* these values shows that number of data returned after 'receive' cmd is sent */
120: signed char pm_receive_cmd_type[] = {
121: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
122: -1, -1, -1, -1, -1, -1, -1, -1,
123: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
124: 0x02, 0x02, -1, -1, -1, -1, -1, 0x00,
125: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
126: -1, -1, -1, -1, -1, -1, -1, -1,
127: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
128: 0x05, 0x15, -1, 0x02, -1, -1, -1, -1,
129: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
130: 0x02, 0x02, -1, -1, -1, -1, -1, -1,
131: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
132: 0x02, 0x00, 0x03, 0x03, -1, -1, -1, -1,
133: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
134: 0x04, 0x04, 0x03, 0x09, -1, -1, -1, -1,
135: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
136: -1, -1, -1, -1, -1, -1, 0x01, 0x01,
137: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
138: 0x06, -1, -1, -1, -1, -1, -1, -1,
139: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
140: 0x02, 0x02, -1, -1, -1, -1, -1, -1,
141: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
142: 0x02, 0x00, 0x00, 0x00, -1, -1, -1, -1,
143: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
144: -1, -1, -1, -1, -1, -1, -1, -1,
145: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
146: -1, -1, -1, -1, -1, -1, -1, -1,
147: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
148: 0x02, 0x02, -1, -1, 0x02, -1, -1, -1,
149: 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
150: -1, -1, 0x02, -1, -1, -1, -1, 0x00,
151: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
152: -1, -1, -1, -1, -1, -1, -1, -1,
153: };
154:
155:
156: /*
157: * Define the private functions
158: */
159:
160: /* for debugging */
161: #ifdef ADB_DEBUG
162: void pm_printerr(char *, int, int, char *);
163: #endif
164:
165: int pm_wait_busy(int);
166: int pm_wait_free(int);
167:
168: /* these functions are for the PB Duo series and the PB 5XX series */
169: int pm_receive_pm2(u_char *);
170: int pm_send_pm2(u_char);
171: int pm_pmgrop_pm2(PMData *);
172: void pm_intr_pm2(void);
173:
174: /* these functions also use the variables of adb_direct.c */
175: void pm_adb_get_TALK_result(PMData *);
176: void pm_adb_get_ADB_data(PMData *);
177:
178:
179: /*
180: * These variables are in adb_direct.c.
181: */
182: extern u_char *adbBuffer; /* pointer to user data area */
183: extern void *adbCompRout; /* pointer to the completion routine */
184: extern void *adbCompData; /* pointer to the completion routine data */
185: extern int adbWaiting; /* waiting for return data from the device */
186: extern int adbWaitingCmd; /* ADB command we are waiting for */
187: extern int adbStarting; /* doing ADB reinit, so do "polling" differently */
188:
189: #define ADB_MAX_MSG_LENGTH 16
190: #define ADB_MAX_HDR_LENGTH 8
191: struct adbCommand {
192: u_char header[ADB_MAX_HDR_LENGTH]; /* not used yet */
193: u_char data[ADB_MAX_MSG_LENGTH]; /* packet data only */
194: u_char *saveBuf; /* where to save result */
195: u_char *compRout; /* completion routine pointer */
196: u_char *compData; /* completion routine data pointer */
197: u_int cmd; /* the original command for this data */
198: u_int unsol; /* 1 if packet was unsolicited */
199: u_int ack_only; /* 1 for no special processing */
200: };
201: extern void adb_pass_up(struct adbCommand *);
202:
203:
204: #ifdef ADB_DEBUG
205: /*
206: * This function dumps contents of the PMData
207: */
208: void
209: pm_printerr(ttl, rval, num, data)
210: char *ttl;
211: int rval;
212: int num;
213: char *data;
214: {
215: int i;
216:
217: printf("pm: %s:%04x %02x ", ttl, rval, num);
218: for (i = 0; i < num; i++)
219: printf("%02x ", data[i]);
220: printf("\n");
221: }
222: #endif
223:
224:
225:
226: /*
227: * Check the hardware type of the Power Manager
228: */
229: void
230: pm_setup_adb()
231: {
232: pmHardware = PM_HW_PB5XX; /* XXX */
233: }
234:
235:
236: /*
237: * Wait until PM IC is busy
238: */
239: int
240: pm_wait_busy(int delay)
241: {
242: while (PM_IS_ON) {
243: #ifdef PM_GRAB_SI
244: (void)intr_dispatch(0x70);
245: #endif
246: if ((--delay) < 0)
247: return 1; /* timeout */
248: }
249: return 0;
250: }
251:
252:
253: /*
254: * Wait until PM IC is free
255: */
256: int
257: pm_wait_free(int delay)
258: {
259: while (PM_IS_OFF) {
260: #ifdef PM_GRAB_SI
261: (void)intr_dispatch(0x70);
262: #endif
263: if ((--delay) < 0)
264: return 0; /* timeout */
265: }
266: return 1;
267: }
268:
269: /*
270: * Functions for the PB Duo series and the PB 5XX series
271: */
272:
273: /*
274: * Receive data from PM for the PB Duo series and the PB 5XX series
275: */
276: int
277: pm_receive_pm2(u_char *data)
278: {
279: int i;
280: int rval;
281:
282: rval = 0xffffcd34;
283:
284: switch (1) {
285: default:
286: /* set VIA SR to input mode */
287: via_reg_or(VIA1, vACR, 0x0c);
288: via_reg_and(VIA1, vACR, ~0x10);
289: i = PM_SR();
290:
291: PM_SET_STATE_ACKOFF();
292: if (pm_wait_busy((int)ADBDelay*32) != 0)
293: break; /* timeout */
294:
295: PM_SET_STATE_ACKON();
296: rval = 0xffffcd33;
297: if (pm_wait_free((int)ADBDelay*32) == 0)
298: break; /* timeout */
299:
300: *data = PM_SR();
301: rval = 0;
302:
303: break;
304: }
305:
306: PM_SET_STATE_ACKON();
307: via_reg_or(VIA1, vACR, 0x1c);
308:
309: return rval;
310: }
311:
312: /*
313: * Send data to PM for the PB Duo series and the PB 5XX series
314: */
315: int
316: pm_send_pm2(data)
317: u_char data;
318: {
319: int rval;
320:
321: via_reg_or(VIA1, vACR, 0x1c);
322: write_via_reg(VIA1, vSR, data); /* PM_SR() = data; */
323:
324: PM_SET_STATE_ACKOFF();
325: rval = 0xffffcd36;
326: if (pm_wait_busy((int)ADBDelay*32) != 0) {
327: PM_SET_STATE_ACKON();
328: via_reg_or(VIA1, vACR, 0x1c);
329: return rval;
330: }
331:
332: PM_SET_STATE_ACKON();
333: rval = 0xffffcd35;
334: if (pm_wait_free((int)ADBDelay*32) != 0)
335: rval = 0;
336:
337: PM_SET_STATE_ACKON();
338: via_reg_or(VIA1, vACR, 0x1c);
339:
340: return rval;
341: }
342:
343:
344:
345: /*
346: * My PMgrOp routine for the PB Duo series and the PB 5XX series
347: */
348: int
349: pm_pmgrop_pm2(PMData *pmdata)
350: {
351: int i;
352: int s;
353: u_char via1_vIER;
354: int rval = 0;
355: int num_pm_data = 0;
356: u_char pm_cmd;
357: short pm_num_rx_data;
358: u_char pm_data;
359: u_char *pm_buf;
360:
361: s = splhigh();
362:
363: /* disable all interrupts but PM */
364: via1_vIER = 0x10;
365: via1_vIER &= read_via_reg(VIA1, vIER);
366: write_via_reg(VIA1, vIER, via1_vIER);
367: if (via1_vIER != 0x0)
368: via1_vIER |= 0x80;
369:
370: switch (pmdata->command) {
371: default:
372: /* wait until PM is free */
373: pm_cmd = (u_char)(pmdata->command & 0xff);
374: rval = 0xcd38;
375: if (pm_wait_free(ADBDelay * 4) == 0)
376: break; /* timeout */
377:
378: /* send PM command */
379: if ((rval = pm_send_pm2((u_char)(pm_cmd & 0xff))))
380: break; /* timeout */
381:
382: /* send number of PM data */
383: num_pm_data = pmdata->num_data;
384: if (pm_send_cmd_type[pm_cmd] < 0) {
385: if ((rval = pm_send_pm2((u_char)(num_pm_data & 0xff))) != 0)
386: break; /* timeout */
387: pmdata->command = 0;
388: }
389: /* send PM data */
390: pm_buf = (u_char *)pmdata->s_buf;
391: for (i = 0 ; i < num_pm_data; i++)
392: if ((rval = pm_send_pm2(pm_buf[i])) != 0)
393: break; /* timeout */
394: if (i != num_pm_data)
395: break; /* timeout */
396:
397:
398: /* check if PM will send me data */
399: pm_num_rx_data = pm_receive_cmd_type[pm_cmd];
400: pmdata->num_data = pm_num_rx_data;
401: if (pm_num_rx_data == 0) {
402: rval = 0;
403: break; /* no return data */
404: }
405:
406: /* receive PM command */
407: pm_data = pmdata->command;
408: pm_num_rx_data--;
409: if (pm_num_rx_data == 0)
410: if ((rval = pm_receive_pm2(&pm_data)) != 0) {
411: rval = 0xffffcd37;
412: break;
413: }
414: pmdata->command = pm_data;
415:
416: /* receive number of PM data */
417: if (pm_num_rx_data < 0) {
418: if ((rval = pm_receive_pm2(&pm_data)) != 0)
419: break; /* timeout */
420: num_pm_data = pm_data;
421: } else
422: num_pm_data = pm_num_rx_data;
423: pmdata->num_data = num_pm_data;
424:
425: /* receive PM data */
426: pm_buf = (u_char *)pmdata->r_buf;
427: for (i = 0; i < num_pm_data; i++) {
428: if ((rval = pm_receive_pm2(&pm_data)) != 0)
429: break; /* timeout */
430: pm_buf[i] = pm_data;
431: }
432:
433: rval = 0;
434: }
435:
436: /* restore former value */
437: write_via_reg(VIA1, vIER, via1_vIER);
438: splx(s);
439:
440: return rval;
441: }
442:
443:
444: /*
445: * My PM interrupt routine for the PB Duo series and the PB 5XX series
446: */
447: void
448: pm_intr_pm2()
449: {
450: int s;
451: int rval;
452: PMData pmdata;
453:
454: s = splhigh();
455:
456: PM_VIA_CLR_INTR(); /* clear VIA1 interrupt */
457: /* ask PM what happend */
458: pmdata.command = 0x78;
459: pmdata.num_data = 0;
460: pmdata.s_buf = &pmdata.data[2];
461: pmdata.r_buf = &pmdata.data[2];
462: rval = pm_pmgrop_pm2(&pmdata);
463: if (rval != 0) {
464: #ifdef ADB_DEBUG
465: if (adb_debug)
466: printf("pm: PM is not ready. error code: %08x\n", rval);
467: #endif
468: splx(s);
469: return;
470: }
471:
472: switch ((u_int)(pmdata.data[2] & 0xff)) {
473: case 0x00: /* 1 sec interrupt? */
474: break;
475: case PMU_INT_TICK: /* 1 sec interrupt? */
476: break;
477: case PMU_INT_SNDBRT: /* Brightness/Contrast button on LCD panel */
478: break;
479: case PMU_INT_ADB: /* ADB data requested by TALK command */
480: case PMU_INT_ADB|PMU_INT_ADB_AUTO:
481: pm_adb_get_TALK_result(&pmdata);
482: break;
483: case 0x16: /* ADB device event */
484: case 0x18:
485: case 0x1e:
486: case PMU_INT_WAKEUP:
487: pm_adb_get_ADB_data(&pmdata);
488: break;
489: default:
490: #ifdef ADB_DEBUG
491: if (adb_debug)
492: pm_printerr("driver does not support this event.",
493: pmdata.data[2], pmdata.num_data,
494: pmdata.data);
495: #endif
496: break;
497: }
498:
499: splx(s);
500: }
501:
502:
503: /*
504: * My PMgrOp routine
505: */
506: int
507: pmgrop(PMData *pmdata)
508: {
509: switch (pmHardware) {
510: case PM_HW_PB5XX:
511: return (pm_pmgrop_pm2(pmdata));
512: default:
513: /* return (pmgrop_mrg(pmdata)); */
514: return 1;
515: }
516: }
517:
518:
519: /*
520: * My PM interrupt routine
521: */
522: void
523: pm_intr()
524: {
525: switch (pmHardware) {
526: case PM_HW_PB5XX:
527: pm_intr_pm2();
528: break;
529: default:
530: break;
531: }
532: }
533:
534:
535:
536: /*
537: * Synchronous ADBOp routine for the Power Manager
538: */
539: int
540: pm_adb_op(u_char *buffer, void *compRout, void *data, int command)
541: {
542: int i;
543: int s;
544: int rval;
545: int ndelay;
546: int waitfor; /* interrupts to poll for */
547: int ifr;
548: #ifdef ADB_DEBUG
549: int oldifr;
550: #endif
551: PMData pmdata;
552: struct adbCommand packet;
553: extern int adbempty;
554:
555: if (adbWaiting == 1)
556: return 1;
557:
558: s = splhigh();
559: write_via_reg(VIA1, vIER, 0x10);
560:
561: adbBuffer = buffer;
562: adbCompRout = compRout;
563: adbCompData = data;
564:
565: pmdata.command = 0x20;
566: pmdata.s_buf = pmdata.data;
567: pmdata.r_buf = pmdata.data;
568:
569: /*
570: * if the command is LISTEN,
571: * add number of ADB data to number of PM data
572: */
573: if ((command & 0xc) == 0x8) {
574: if (buffer != (u_char *)0)
575: pmdata.num_data = buffer[0] + 3;
576: } else
577: pmdata.num_data = 3;
578:
579: /*
580: * Resetting adb on several models, such as
581: * - PowerBook3,*
582: * - PowerBook5,*
583: * - PowerMac10,1
584: * causes several pmu interrupts with ifr set to PMU_INT_SNDBRT.
585: * Not processing them prevents us from seeing the adb devices
586: * afterwards, so we have to expect it unless we know the adb
587: * bus is empty.
588: */
589: if (command == PMU_RESET_ADB) {
590: waitfor = PMU_INT_ADB_AUTO | PMU_INT_ADB;
591: if (adbempty == 0)
592: waitfor |= PMU_INT_SNDBRT;
593: } else
594: waitfor = PMU_INT_ALL;
595:
596: pmdata.data[0] = (u_char)(command & 0xff);
597: pmdata.data[1] = 0;
598: /* if the command is LISTEN, copy ADB data to PM buffer */
599: if ((command & 0xc) == 0x8) {
600: if ((buffer != (u_char *)0) && (buffer[0] <= 24)) {
601: pmdata.data[2] = buffer[0]; /* number of data */
602: for (i = 0; i < buffer[0]; i++)
603: pmdata.data[3 + i] = buffer[1 + i];
604: } else
605: pmdata.data[2] = 0;
606: } else
607: pmdata.data[2] = 0;
608:
609: if ((command & 0xc) != 0xc) { /* if the command is not TALK */
610: /* set up stuff for adb_pass_up */
611: packet.data[0] = 1 + pmdata.data[2];
612: packet.data[1] = command;
613: for (i = 0; i < pmdata.data[2]; i++)
614: packet.data[i+2] = pmdata.data[i+3];
615: packet.saveBuf = adbBuffer;
616: packet.compRout = adbCompRout;
617: packet.compData = adbCompData;
618: packet.cmd = command;
619: packet.unsol = 0;
620: packet.ack_only = 1;
621: adb_polling = 1;
622: adb_pass_up(&packet);
623: adb_polling = 0;
624: }
625:
626: rval = pmgrop(&pmdata);
627: if (rval != 0) {
628: splx(s);
629: return 1;
630: }
631:
632: delay (1000);
633:
634: adbWaiting = 1;
635: adbWaitingCmd = command;
636:
637: PM_VIA_INTR_ENABLE();
638:
639: /* wait until the PM interrupt is occurred */
640: ndelay = 0x8000;
641: #ifdef ADB_DEBUG
642: oldifr = 0;
643: #endif
644: while (adbWaiting == 1) {
645: ifr = read_via_reg(VIA1, vIFR);
646: if (ifr & waitfor) {
647: pm_intr();
648: #ifdef PM_GRAB_SI
649: (void)intr_dispatch(0x70);
650: #endif
651: #ifdef ADB_DEBUG
652: } else if (ifr != oldifr) {
653: if (adb_debug)
654: printf("pm_adb_op: ignoring ifr %02x"
655: ", expecting %02x\n",
656: (u_int)ifr, (u_int)waitfor);
657: oldifr = ifr;
658: #endif
659: }
660: if ((--ndelay) < 0) {
661: splx(s);
662: return 1;
663: }
664: delay(10);
665: }
666:
667: /* this command enables the interrupt by operating ADB devices */
668: pmdata.command = 0x20;
669: pmdata.num_data = 4;
670: pmdata.s_buf = pmdata.data;
671: pmdata.r_buf = pmdata.data;
672: pmdata.data[0] = 0x00;
673: pmdata.data[1] = 0x86; /* magic spell for awaking the PM */
674: pmdata.data[2] = 0x00;
675: pmdata.data[3] = 0x0c; /* each bit may express the existent ADB device */
676: rval = pmgrop(&pmdata);
677:
678: splx(s);
679: return rval;
680: }
681:
682:
683: void
684: pm_adb_get_TALK_result(PMData *pmdata)
685: {
686: int i;
687: struct adbCommand packet;
688:
689: /* set up data for adb_pass_up */
690: packet.data[0] = pmdata->num_data-1;
691: packet.data[1] = pmdata->data[3];
692: for (i = 0; i <packet.data[0]-1; i++)
693: packet.data[i+2] = pmdata->data[i+4];
694:
695: packet.saveBuf = adbBuffer;
696: packet.compRout = adbCompRout;
697: packet.compData = adbCompData;
698: packet.unsol = 0;
699: packet.ack_only = 0;
700: adb_polling = 1;
701: adb_pass_up(&packet);
702: adb_polling = 0;
703:
704: adbWaiting = 0;
705: adbBuffer = (long)0;
706: adbCompRout = (long)0;
707: adbCompData = (long)0;
708: }
709:
710:
711: void
712: pm_adb_get_ADB_data(PMData *pmdata)
713: {
714: int i;
715: struct adbCommand packet;
716:
717: /* set up data for adb_pass_up */
718: packet.data[0] = pmdata->num_data-1; /* number of raw data */
719: packet.data[1] = pmdata->data[3]; /* ADB command */
720: for (i = 0; i <packet.data[0]-1; i++)
721: packet.data[i+2] = pmdata->data[i+4];
722: packet.unsol = 1;
723: packet.ack_only = 0;
724: adb_pass_up(&packet);
725: }
726:
727: void
728: pm_adb_restart()
729: {
730: PMData p;
731:
732: p.command = PMU_RESET_CPU;
733: p.num_data = 0;
734: p.s_buf = p.data;
735: p.r_buf = p.data;
736: pmgrop(&p);
737: }
738:
739: void
740: pm_adb_poweroff()
741: {
742: PMData p;
743:
744: bzero(&p, sizeof p);
745: p.command = PMU_POWER_OFF;
746: p.num_data = 4;
747: p.s_buf = p.data;
748: p.r_buf = p.data;
749: strlcpy(p.data, "MATT", sizeof p.data);
750: pmgrop(&p);
751: }
752:
753: void
754: pm_read_date_time(time_t *time)
755: {
756: PMData p;
757:
758: p.command = PMU_READ_RTC;
759: p.num_data = 0;
760: p.s_buf = p.data;
761: p.r_buf = p.data;
762: pmgrop(&p);
763:
764: bcopy(p.data, time, 4);
765: }
766:
767: void
768: pm_set_date_time(time_t time)
769: {
770: PMData p;
771:
772: p.command = PMU_SET_RTC;
773: p.num_data = 4;
774: p.s_buf = p.r_buf = p.data;
775: bcopy(&time, p.data, 4);
776: pmgrop(&p);
777: }
778:
779: #if 0
780: void
781: pm_eject_pcmcia(int slot)
782: {
783: PMData p;
784:
785: if (slot != 0 && slot != 1)
786: return;
787:
788: p.command = PMU_EJECT_PCMCIA;
789: p.num_data = 1;
790: p.s_buf = p.r_buf = p.data;
791: p.data[0] = 5 + slot; /* XXX */
792: pmgrop(&p);
793: }
794: #endif
795:
796:
797: /*
798: * Thanks to Paul Mackerras and Fabio Riccardi's Linux implementation
799: * for a clear description of the PMU results.
800: */
801:
802: int
803: pm_battery_info(int battery, struct pmu_battery_info *info)
804: {
805: PMData p;
806:
807: p.command = PMU_SMART_BATTERY_STATE;
808: p.num_data = 1;
809: p.s_buf = p.r_buf = p.data;
810: p.data[0] = battery + 1;
811: pmgrop(&p);
812:
813: info->flags = p.data[1];
814:
815: switch (p.data[0]) {
816: case 3:
817: case 4:
818: info->cur_charge = p.data[2];
819: info->max_charge = p.data[3];
820: info->draw = *((signed char *)&p.data[4]);
821: info->voltage = p.data[5];
822: break;
823: case 5:
824: info->cur_charge = ((p.data[2] << 8) | (p.data[3]));
825: info->max_charge = ((p.data[4] << 8) | (p.data[5]));
826: info->draw = *((signed short *)&p.data[6]);
827: info->voltage = ((p.data[8] << 8) | (p.data[7]));
828: break;
829: default:
830: /* XXX - Error condition */
831: info->cur_charge = 0;
832: info->max_charge = 0;
833: info->draw = 0;
834: info->voltage = 0;
835: break;
836: }
837:
838: return 1;
839: }
840:
841: void
842: pmu_fileserver_mode(int on)
843: {
844: PMData p;
845:
846: p.command = PMU_POWER_EVENTS;
847: p.num_data = 1;
848: p.s_buf = p.r_buf = p.data;
849: p.data[0] = PMU_PWR_GET_POWERUP_EVENTS;
850: pmgrop(&p);
851:
852: p.command = PMU_POWER_EVENTS;
853: p.num_data = 3;
854: p.s_buf = p.r_buf = p.data;
855: p.data[1] = p.data[0]; /* result from the get */
856: if (on) {
857: p.data[0] = PMU_PWR_SET_POWERUP_EVENTS;
858: p.data[2] = PMU_WAKE_AC_LOSS;
859: } else {
860: p.data[0] = PMU_PWR_CLR_POWERUP_EVENTS;
861: p.data[2] = PMU_WAKE_AC_LOSS;
862: }
863: pmgrop(&p);
864: }