![[BACK]](/icons/back.gif){kind=icon}
Return to adb.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / mac68k / dev|
Return to adb.c CVS log | Up to [local] / sys / arch / mac68k / dev |
1.1 nbrk 1: /* $OpenBSD: adb.c,v 1.26 2007/04/10 17:47:54 miod Exp $ */
2: /* $NetBSD: adb.c,v 1.47 2005/06/16 22:43:36 jmc Exp $ */
3: /* $NetBSD: adb_direct.c,v 1.51 2005/06/16 22:43:36 jmc Exp $ */
4:
5: /*
6: * Copyright (C) 1996, 1997 John P. Wittkoski
7: * All rights reserved.
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice, this list of conditions and the following disclaimer.
14: * 2. Redistributions in binary form must reproduce the above copyright
15: * notice, this list of conditions and the following disclaimer in the
16: * documentation and/or other materials provided with the distribution.
17: * 3. All advertising materials mentioning features or use of this software
18: * must display the following acknowledgement:
19: * This product includes software developed by John P. Wittkoski.
20: * 4. The name of the author may not be used to endorse or promote products
21: * derived from this software without specific prior written permission.
22: *
23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33: */
34:
35: /*
36: * Copyright (C) 1994 Bradley A. Grantham
37: * All rights reserved.
38: *
39: * Redistribution and use in source and binary forms, with or without
40: * modification, are permitted provided that the following conditions
41: * are met:
42: * 1. Redistributions of source code must retain the above copyright
43: * notice, this list of conditions and the following disclaimer.
44: * 2. Redistributions in binary form must reproduce the above copyright
45: * notice, this list of conditions and the following disclaimer in the
46: * documentation and/or other materials provided with the distribution.
47: * 3. All advertising materials mentioning features or use of this software
48: * must display the following acknowledgement:
49: * This product includes software developed by Bradley A. Grantham.
50: * 4. The name of the author may not be used to endorse or promote products
51: * derived from this software without specific prior written permission.
52: *
53: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
54: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
55: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
56: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
57: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
58: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
59: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
60: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
61: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
62: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
63: */
64:
65: /*
66: * This code is rather messy, but I don't have time right now
67: * to clean it up as much as I would like.
68: * But it works, so I'm happy. :-) jpw
69: */
70:
71: /*
72: * TO DO:
73: * - We could reduce the time spent in the adb_intr_* routines
74: * by having them save the incoming and outgoing data directly
75: * in the adbInbound and adbOutbound queues, as it would reduce
76: * the number of times we need to copy the data around. It
77: * would also make the code more readable and easier to follow.
78: * - (Related to above) Use the header part of adbCommand to
79: * reduce the number of copies we have to do of the data.
80: * - (Related to above) Actually implement the adbOutbound queue.
81: * This is fairly easy once you switch all the intr routines
82: * over to using adbCommand structs directly.
83: * - There is a bug in the state machine of adb_intr_cuda
84: * code that causes hangs, especially on 030 machines, probably
85: * because of some timing issues. Because I have been unable to
86: * determine the exact cause of this bug, I used the timeout function
87: * to check for and recover from this condition. If anyone finds
88: * the actual cause of this bug, the calls to timeout and the
89: * adb_cuda_tickle routine can be removed.
90: */
91:
92: #include <sys/param.h>
93: #include <sys/device.h>
94: #include <sys/fcntl.h>
95: #include <sys/poll.h>
96: #include <sys/selinfo.h>
97: #include <sys/proc.h>
98: #include <sys/signalvar.h>
99: #include <sys/timeout.h>
100: #include <sys/systm.h>
101:
102: #include <machine/autoconf.h>
103: #include <machine/cpu.h>
104: #include <machine/viareg.h>
105:
106: #include <dev/adb/adb.h>
107: #include <mac68k/dev/adbvar.h>
108:
109: #define printf_intr printf
110:
111: int adb_polling; /* Are we polling? (Debugger mode) */
112: #ifdef ADB_DEBUG
113: int adb_debug; /* Output debugging messages */
114: #endif /* ADB_DEBUG */
115:
116: /* some misc. leftovers */
117: #define vPB 0x0000
118: #define vPB3 0x08
119: #define vPB4 0x10
120: #define vPB5 0x20
121: #define vSR_INT 0x04
122: #define vSR_OUT 0x10
123:
124: /* the type of ADB action that we are currently preforming */
125: #define ADB_ACTION_NOTREADY 0x1 /* has not been initialized yet */
126: #define ADB_ACTION_IDLE 0x2 /* the bus is currently idle */
127: #define ADB_ACTION_OUT 0x3 /* sending out a command */
128: #define ADB_ACTION_IN 0x4 /* receiving data */
129: #define ADB_ACTION_POLLING 0x5 /* polling - II only */
130:
131: /*
132: * These describe the state of the ADB bus itself, although they
133: * don't necessarily correspond directly to ADB states.
134: * Note: these are not really used in the IIsi code.
135: */
136: #define ADB_BUS_UNKNOWN 0x1 /* we don't know yet - all models */
137: #define ADB_BUS_IDLE 0x2 /* bus is idle - all models */
138: #define ADB_BUS_CMD 0x3 /* starting a command - II models */
139: #define ADB_BUS_ODD 0x4 /* the "odd" state - II models */
140: #define ADB_BUS_EVEN 0x5 /* the "even" state - II models */
141: #define ADB_BUS_ACTIVE 0x6 /* active state - IIsi models */
142: #define ADB_BUS_ACK 0x7 /* currently ACKing - IIsi models */
143:
144: /*
145: * Shortcuts for setting or testing the VIA bit states.
146: * Not all shortcuts are used for every type of ADB hardware.
147: */
148: #define ADB_SET_STATE_IDLE_II() via_reg(VIA1, vBufB) |= (vPB4 | vPB5)
149: #define ADB_SET_STATE_IDLE_IISI() via_reg(VIA1, vBufB) &= ~(vPB4 | vPB5)
150: #define ADB_SET_STATE_IDLE_CUDA() via_reg(VIA1, vBufB) |= (vPB4 | vPB5)
151: #define ADB_SET_STATE_CMD() via_reg(VIA1, vBufB) &= ~(vPB4 | vPB5)
152: #define ADB_SET_STATE_EVEN() via_reg(VIA1, vBufB) = ((via_reg(VIA1, \
153: vBufB) | vPB4) & ~vPB5)
154: #define ADB_SET_STATE_ODD() via_reg(VIA1, vBufB) = ((via_reg(VIA1, \
155: vBufB) | vPB5) & ~vPB4)
156: #define ADB_SET_STATE_ACTIVE() via_reg(VIA1, vBufB) |= vPB5
157: #define ADB_SET_STATE_INACTIVE() via_reg(VIA1, vBufB) &= ~vPB5
158: #define ADB_SET_STATE_TIP() via_reg(VIA1, vBufB) &= ~vPB5
159: #define ADB_CLR_STATE_TIP() via_reg(VIA1, vBufB) |= vPB5
160: #define ADB_SET_STATE_ACKON() via_reg(VIA1, vBufB) |= vPB4
161: #define ADB_SET_STATE_ACKOFF() via_reg(VIA1, vBufB) &= ~vPB4
162: #define ADB_TOGGLE_STATE_ACK_CUDA() via_reg(VIA1, vBufB) ^= vPB4
163: #define ADB_SET_STATE_ACKON_CUDA() via_reg(VIA1, vBufB) &= ~vPB4
164: #define ADB_SET_STATE_ACKOFF_CUDA() via_reg(VIA1, vBufB) |= vPB4
165: #define ADB_SET_SR_INPUT() via_reg(VIA1, vACR) &= ~vSR_OUT
166: #define ADB_SET_SR_OUTPUT() via_reg(VIA1, vACR) |= vSR_OUT
167: #define ADB_SR() via_reg(VIA1, vSR)
168: #define ADB_VIA_INTR_ENABLE() via_reg(VIA1, vIER) = 0x84
169: #define ADB_VIA_INTR_DISABLE() via_reg(VIA1, vIER) = 0x04
170: #define ADB_VIA_CLR_INTR() via_reg(VIA1, vIFR) = 0x04
171: #define ADB_INTR_IS_OFF (vPB3 == (via_reg(VIA1, vBufB) & vPB3))
172: #define ADB_INTR_IS_ON (0 == (via_reg(VIA1, vBufB) & vPB3))
173: #define ADB_SR_INTR_IS_OFF (0 == (via_reg(VIA1, vIFR) & vSR_INT))
174: #define ADB_SR_INTR_IS_ON (vSR_INT == (via_reg(VIA1, \
175: vIFR) & vSR_INT))
176:
177: /*
178: * This is the delay that is required (in uS) between certain
179: * ADB transactions. The actual timing delay for for each uS is
180: * calculated at boot time to account for differences in machine speed.
181: */
182: #define ADB_DELAY 150
183:
184: /*
185: * Maximum ADB message length; includes space for data, result, and
186: * device code - plus a little for safety.
187: */
188: #define ADB_MAX_MSG_LENGTH 16
189: #define ADB_MAX_HDR_LENGTH 8
190:
191: #define ADB_QUEUE 32
192: #define ADB_TICKLE_TICKS 4
193:
194: /*
195: * A structure for storing information about each ADB device.
196: */
197: struct ADBDevEntry {
198: void (*ServiceRtPtr)(void);
199: void *DataAreaAddr;
200: int devType;
201: int origAddr;
202: int currentAddr;
203: };
204:
205: /*
206: * Used to hold ADB commands that are waiting to be sent out.
207: */
208: struct adbCmdHoldEntry {
209: u_char outBuf[ADB_MAX_MSG_LENGTH]; /* our message */
210: u_char *saveBuf; /* buffer to know where to save result */
211: u_char *compRout; /* completion routine pointer */
212: u_char *data; /* completion routine data pointer */
213: };
214:
215: /*
216: * Eventually used for two separate queues, the queue between
217: * the upper and lower halves, and the outgoing packet queue.
218: * TO DO: adbCommand can replace all of adbCmdHoldEntry eventually
219: */
220: struct adbCommand {
221: u_char header[ADB_MAX_HDR_LENGTH]; /* not used yet */
222: u_char data[ADB_MAX_MSG_LENGTH]; /* packet data only */
223: u_char *saveBuf; /* where to save result */
224: u_char *compRout; /* completion routine pointer */
225: u_char *compData; /* completion routine data pointer */
226: u_int cmd; /* the original command for this data */
227: u_int unsol; /* 1 if packet was unsolicited */
228: u_int ack_only; /* 1 for no special processing */
229: };
230:
231: /*
232: * Text representations of each hardware class
233: */
234: const char *adbHardwareDescr[] = {
235: "unknown",
236: "II series",
237: "IIsi series",
238: "PowerBook",
239: "Cuda",
240: "IOP"
241: };
242:
243: /*
244: * A few variables that we need and their initial values.
245: */
246: int adbHardware = ADB_HW_UNKNOWN;
247: int adbActionState = ADB_ACTION_NOTREADY;
248: int adbBusState = ADB_BUS_UNKNOWN;
249: int adbWaiting; /* waiting for return data from the device */
250: int adbWriteDelay; /* working on (or waiting to do) a write */
251: int adbOutQueueHasData; /* something in the queue waiting to go out */
252: int adbSoftPower; /* machine supports soft power */
253:
254: int adbWaitingCmd; /* ADB command we are waiting for */
255: u_char *adbBuffer; /* pointer to user data area */
256: void *adbCompRout; /* pointer to the completion routine */
257: void *adbCompData; /* pointer to the completion routine data */
258: int adbStarting = 1; /* doing adb_reinit so do polling differently */
259:
260: u_char adbInputBuffer[ADB_MAX_MSG_LENGTH]; /* data input buffer */
261: u_char adbOutputBuffer[ADB_MAX_MSG_LENGTH]; /* data output buffer */
262: struct adbCmdHoldEntry adbOutQueue; /* our 1 entry output queue */
263:
264: int adbSentChars; /* how many characters we have sent */
265: int adbLastDevice; /* last ADB dev we heard from (II ONLY) */
266:
267: struct ADBDevEntry ADBDevTable[16]; /* our ADB device table */
268: int ADBNumDevices; /* num. of ADB devices found with adb_reinit */
269:
270: struct adbCommand adbInbound[ADB_QUEUE]; /* incoming queue */
271: volatile int adbInCount; /* how many packets in in queue */
272: int adbInHead; /* head of in queue */
273: int adbInTail; /* tail of in queue */
274: struct adbCommand adbOutbound[ADB_QUEUE]; /* outgoing queue - not used yet */
275: int adbOutCount; /* how many packets in out queue */
276: int adbOutHead; /* head of out queue */
277: int adbOutTail; /* tail of out queue */
278:
279: int tickle_count; /* how many tickles seen for this packet? */
280: int tickle_serial; /* the last packet tickled */
281: int adb_cuda_serial; /* the current packet */
282:
283: struct timeout adb_cuda_timeout;
284:
285: void pm_setup_adb(void);
286: void pm_hw_setup(struct device *);
287: void pm_check_adb_devices(int);
288: int pm_adb_op(u_char *, void *, void *, int);
289: void pm_init_adb_device(void);
290:
291: /*
292: * The following are private routines.
293: */
294: #ifdef ADB_DEBUG
295: void print_single(u_char *);
296: #endif
297: int adb_intr(void *);
298: int adb_intr_II(void *);
299: int adb_intr_IIsi(void *);
300: int adb_intr_cuda(void *);
301: void adb_soft_intr(void);
302: int send_adb_II(u_char *, u_char *, void *, void *, int);
303: int send_adb_IIsi(u_char *, u_char *, void *, void *, int);
304: int send_adb_cuda(u_char *, u_char *, void *, void *, int);
305: void adb_intr_cuda_test(void);
306: void adb_cuda_tickle(void);
307: void adb_pass_up(struct adbCommand *);
308: void adb_op_comprout(caddr_t, caddr_t, int);
309: void adb_reinit(struct device *);
310: int count_adbs(void);
311: int get_ind_adb_info(ADBDataBlock *, int);
312: int get_adb_info(ADBDataBlock *, int);
313: void adb_setup_hw_type(void);
314: int adb_op(Ptr, Ptr, Ptr, short);
315: void adb_read_II(u_char *);
316: void adb_hw_setup(struct device *);
317: void adb_hw_setup_IIsi(u_char *);
318: int adb_cmd_result(u_char *);
319: int adb_guess_next_device(void);
320: int adb_prog_switch_enable(void);
321: int adb_prog_switch_disable(void);
322: /* we should create this and it will be the public version */
323: int send_adb(u_char *, void *, void *);
324:
325: #ifdef ADB_DEBUG
326: /*
327: * print_single
328: * Diagnostic display routine. Displays the hex values of the
329: * specified elements of the u_char. The length of the "string"
330: * is in [0].
331: */
332: void
333: print_single(u_char *str)
334: {
335: int x;
336:
337: if (str == NULL) {
338: printf_intr("no data - null pointer\n");
339: return;
340: }
341: if (*str == '\0') {
342: printf_intr("nothing returned\n");
343: return;
344: }
345: if (*str > 20) {
346: printf_intr("ADB: ACK > 20 no way!\n");
347: *str = (u_char)20;
348: }
349: printf_intr("(length=0x%x):", (u_int)*str);
350: for (x = 1; x <= *str; x++)
351: printf_intr(" 0x%02x", (u_int)*(str + x));
352: printf_intr("\n");
353: }
354: #endif
355:
356: void
357: adb_cuda_tickle(void)
358: {
359: volatile int s;
360:
361: if (adbActionState == ADB_ACTION_IN) {
362: if (tickle_serial == adb_cuda_serial) {
363: if (++tickle_count > 0) {
364: s = splhigh();
365: adbActionState = ADB_ACTION_IDLE;
366: adbInputBuffer[0] = 0;
367: ADB_SET_STATE_IDLE_CUDA();
368: splx(s);
369: }
370: } else {
371: tickle_serial = adb_cuda_serial;
372: tickle_count = 0;
373: }
374: } else {
375: tickle_serial = adb_cuda_serial;
376: tickle_count = 0;
377: }
378:
379: timeout_add(&adb_cuda_timeout, ADB_TICKLE_TICKS);
380: }
381:
382: /*
383: * called when when an adb interrupt happens
384: *
385: * Cuda version of adb_intr
386: * TO DO: do we want to add some calls to intr_dispatch() here to
387: * grab serial interrupts?
388: */
389: int
390: adb_intr_cuda(void *arg)
391: {
392: volatile int i, ending;
393: volatile unsigned int s;
394: struct adbCommand packet;
395:
396: s = splhigh(); /* can't be too careful - might be called */
397: /* from a routine, NOT an interrupt */
398:
399: ADB_VIA_CLR_INTR(); /* clear interrupt */
400: ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */
401:
402: switch_start:
403: switch (adbActionState) {
404: case ADB_ACTION_IDLE:
405: /*
406: * This is an unexpected packet, so grab the first (dummy)
407: * byte, set up the proper vars, and tell the chip we are
408: * starting to receive the packet by setting the TIP bit.
409: */
410: adbInputBuffer[1] = ADB_SR();
411: adb_cuda_serial++;
412: if (ADB_INTR_IS_OFF) /* must have been a fake start */
413: break;
414:
415: ADB_SET_SR_INPUT();
416: ADB_SET_STATE_TIP();
417:
418: adbInputBuffer[0] = 1;
419: adbActionState = ADB_ACTION_IN;
420: #ifdef ADB_DEBUG
421: if (adb_debug)
422: printf_intr("idle 0x%02x ", adbInputBuffer[1]);
423: #endif
424: break;
425:
426: case ADB_ACTION_IN:
427: adbInputBuffer[++adbInputBuffer[0]] = ADB_SR();
428: /* intr off means this is the last byte (end of frame) */
429: if (ADB_INTR_IS_OFF)
430: ending = 1;
431: else
432: ending = 0;
433:
434: if (1 == ending) { /* end of message? */
435: #ifdef ADB_DEBUG
436: if (adb_debug) {
437: printf_intr("in end 0x%02x ",
438: adbInputBuffer[adbInputBuffer[0]]);
439: print_single(adbInputBuffer);
440: }
441: #endif
442:
443: /*
444: * Are we waiting AND does this packet match what we
445: * are waiting for AND is it coming from either the
446: * ADB or RTC/PRAM sub-device? This section _should_
447: * recognize all ADB and RTC/PRAM type commands, but
448: * there may be more... NOTE: commands are always at
449: * [4], even for RTC/PRAM commands.
450: */
451: /* set up data for adb_pass_up */
452: memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
453:
454: if ((adbWaiting == 1) &&
455: (adbInputBuffer[4] == adbWaitingCmd) &&
456: ((adbInputBuffer[2] == 0x00) ||
457: (adbInputBuffer[2] == 0x01))) {
458: packet.saveBuf = adbBuffer;
459: packet.compRout = adbCompRout;
460: packet.compData = adbCompData;
461: packet.unsol = 0;
462: packet.ack_only = 0;
463: adb_pass_up(&packet);
464:
465: adbWaitingCmd = 0; /* reset "waiting" vars */
466: adbWaiting = 0;
467: adbBuffer = NULL;
468: adbCompRout = NULL;
469: adbCompData = NULL;
470: } else {
471: packet.unsol = 1;
472: packet.ack_only = 0;
473: adb_pass_up(&packet);
474: }
475:
476:
477: /* reset vars and signal the end of this frame */
478: adbActionState = ADB_ACTION_IDLE;
479: adbInputBuffer[0] = 0;
480: ADB_SET_STATE_IDLE_CUDA();
481: /*ADB_SET_SR_INPUT();*/
482:
483: /*
484: * If there is something waiting to be sent out,
485: * the set everything up and send the first byte.
486: */
487: if (adbWriteDelay == 1) {
488: delay(ADB_DELAY); /* required */
489: adbSentChars = 0;
490: adbActionState = ADB_ACTION_OUT;
491: /*
492: * If the interrupt is on, we were too slow
493: * and the chip has already started to send
494: * something to us, so back out of the write
495: * and start a read cycle.
496: */
497: if (ADB_INTR_IS_ON) {
498: ADB_SET_SR_INPUT();
499: ADB_SET_STATE_IDLE_CUDA();
500: adbSentChars = 0;
501: adbActionState = ADB_ACTION_IDLE;
502: adbInputBuffer[0] = 0;
503: break;
504: }
505: /*
506: * If we got here, it's ok to start sending
507: * so load the first byte and tell the chip
508: * we want to send.
509: */
510: ADB_SET_STATE_TIP();
511: ADB_SET_SR_OUTPUT();
512: ADB_SR() = adbOutputBuffer[adbSentChars + 1];
513: }
514: } else {
515: ADB_TOGGLE_STATE_ACK_CUDA();
516: #ifdef ADB_DEBUG
517: if (adb_debug)
518: printf_intr("in 0x%02x ",
519: adbInputBuffer[adbInputBuffer[0]]);
520: #endif
521: }
522: break;
523:
524: case ADB_ACTION_OUT:
525: i = ADB_SR(); /* reset SR-intr in IFR */
526: #ifdef ADB_DEBUG
527: if (adb_debug)
528: printf_intr("intr out 0x%02x ", i);
529: #endif
530:
531: adbSentChars++;
532: if (ADB_INTR_IS_ON) { /* ADB intr low during write */
533: #ifdef ADB_DEBUG
534: if (adb_debug)
535: printf_intr("intr was on ");
536: #endif
537: ADB_SET_SR_INPUT(); /* make sure SR is set to IN */
538: ADB_SET_STATE_IDLE_CUDA();
539: adbSentChars = 0; /* must start all over */
540: adbActionState = ADB_ACTION_IDLE; /* new state */
541: adbInputBuffer[0] = 0;
542: adbWriteDelay = 1; /* must retry when done with
543: * read */
544: delay(ADB_DELAY);
545: goto switch_start; /* process next state right
546: * now */
547: break;
548: }
549: if (adbOutputBuffer[0] == adbSentChars) { /* check for done */
550: if (0 == adb_cmd_result(adbOutputBuffer)) { /* do we expect data
551: * back? */
552: adbWaiting = 1; /* signal waiting for return */
553: adbWaitingCmd = adbOutputBuffer[2]; /* save waiting command */
554: } else { /* no talk, so done */
555: /* set up stuff for adb_pass_up */
556: memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
557: packet.saveBuf = adbBuffer;
558: packet.compRout = adbCompRout;
559: packet.compData = adbCompData;
560: packet.cmd = adbWaitingCmd;
561: packet.unsol = 0;
562: packet.ack_only = 1;
563: adb_pass_up(&packet);
564:
565: /* reset "waiting" vars, just in case */
566: adbWaitingCmd = 0;
567: adbBuffer = NULL;
568: adbCompRout = NULL;
569: adbCompData = NULL;
570: }
571:
572: adbWriteDelay = 0; /* done writing */
573: adbActionState = ADB_ACTION_IDLE; /* signal bus is idle */
574: ADB_SET_SR_INPUT();
575: ADB_SET_STATE_IDLE_CUDA();
576: #ifdef ADB_DEBUG
577: if (adb_debug)
578: printf_intr("write done ");
579: #endif
580: } else {
581: ADB_SR() = adbOutputBuffer[adbSentChars + 1]; /* send next byte */
582: ADB_TOGGLE_STATE_ACK_CUDA(); /* signal byte ready to
583: * shift */
584: #ifdef ADB_DEBUG
585: if (adb_debug)
586: printf_intr("toggle ");
587: #endif
588: }
589: break;
590:
591: case ADB_ACTION_NOTREADY:
592: #ifdef ADB_DEBUG
593: if (adb_debug)
594: printf_intr("adb: not yet initialized\n");
595: #endif
596: break;
597:
598: default:
599: #ifdef ADB_DEBUG
600: if (adb_debug)
601: printf_intr("intr: unknown ADB state\n");
602: #endif
603: break;
604: }
605:
606: ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */
607:
608: splx(s); /* restore */
609:
610: return (1);
611: } /* end adb_intr_cuda */
612:
613:
614: int
615: send_adb_cuda(u_char *in, u_char *buffer, void *compRout, void *data, int
616: command)
617: {
618: int s, len;
619:
620: #ifdef ADB_DEBUG
621: if (adb_debug)
622: printf_intr("SEND\n");
623: #endif
624:
625: if (adbActionState == ADB_ACTION_NOTREADY)
626: return 1;
627:
628: /* Don't interrupt while we are messing with the ADB */
629: s = splhigh();
630:
631: if ((adbActionState == ADB_ACTION_IDLE) && /* ADB available? */
632: (ADB_INTR_IS_OFF)) { /* and no incoming interrupt? */
633: } else
634: if (adbWriteDelay == 0) /* it's busy, but is anything waiting? */
635: adbWriteDelay = 1; /* if no, then we'll "queue"
636: * it up */
637: else {
638: splx(s);
639: return 1; /* really busy! */
640: }
641:
642: #ifdef ADB_DEBUG
643: if (adb_debug)
644: printf_intr("QUEUE\n");
645: #endif
646: if ((long)in == (long)0) { /* need to convert? */
647: /*
648: * Don't need to use adb_cmd_extra here because this section
649: * will be called ONLY when it is an ADB command (no RTC or
650: * PRAM)
651: */
652: if ((command & 0x0c) == 0x08) /* copy addl data ONLY if
653: * doing a listen! */
654: len = buffer[0]; /* length of additional data */
655: else
656: len = 0;/* no additional data */
657:
658: adbOutputBuffer[0] = 2 + len; /* dev. type + command + addl.
659: * data */
660: adbOutputBuffer[1] = 0x00; /* mark as an ADB command */
661: adbOutputBuffer[2] = (u_char)command; /* load command */
662:
663: /* copy additional output data, if any */
664: memcpy(adbOutputBuffer + 3, buffer + 1, len);
665: } else
666: /* if data ready, just copy over */
667: memcpy(adbOutputBuffer, in, in[0] + 2);
668:
669: adbSentChars = 0; /* nothing sent yet */
670: adbBuffer = buffer; /* save buffer to know where to save result */
671: adbCompRout = compRout; /* save completion routine pointer */
672: adbCompData = data; /* save completion routine data pointer */
673: adbWaitingCmd = adbOutputBuffer[2]; /* save wait command */
674:
675: if (adbWriteDelay != 1) { /* start command now? */
676: #ifdef ADB_DEBUG
677: if (adb_debug)
678: printf_intr("out start NOW");
679: #endif
680: delay(ADB_DELAY);
681: adbActionState = ADB_ACTION_OUT; /* set next state */
682: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
683: ADB_SR() = adbOutputBuffer[adbSentChars + 1]; /* load byte for output */
684: ADB_SET_STATE_ACKOFF_CUDA();
685: ADB_SET_STATE_TIP(); /* tell ADB that we want to send */
686: }
687: adbWriteDelay = 1; /* something in the write "queue" */
688:
689: splx(s);
690:
691: /* were VIA1 interrupts blocked? */
692: if (PSLTOIPL(s) >= mac68k_machine.via1_ipl) {
693: /* poll until byte done */
694: while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)
695: || (adbWaiting == 1))
696: if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */
697: adb_intr_cuda(NULL); /* go process it */
698: if (adb_polling)
699: adb_soft_intr();
700: }
701: }
702:
703: return 0;
704: } /* send_adb_cuda */
705:
706:
707: int
708: adb_intr_II(void *arg)
709: {
710: struct adbCommand packet;
711: int i, intr_on = 0;
712: int send = 0;
713: unsigned int s;
714:
715: s = splhigh(); /* can't be too careful - might be called */
716: /* from a routine, NOT an interrupt */
717:
718: ADB_VIA_CLR_INTR(); /* clear interrupt */
719:
720: ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */
721:
722: delay(ADB_DELAY); /* yuck (don't remove) */
723:
724: (void)intr_dispatch(0x70); /* grab any serial interrupts */
725:
726: if (ADB_INTR_IS_ON)
727: intr_on = 1; /* save for later */
728:
729: switch_start:
730: switch (adbActionState) {
731: case ADB_ACTION_POLLING:
732: if (!intr_on) {
733: if (adbOutQueueHasData) {
734: #ifdef ADB_DEBUG
735: if (adb_debug & 0x80)
736: printf_intr("POLL-doing-out-queue. ");
737: #endif
738: ADB_SET_STATE_IDLE_II();
739: delay(ADB_DELAY);
740:
741: /* copy over data */
742: memcpy(adbOutputBuffer, adbOutQueue.outBuf,
743: adbOutQueue.outBuf[0] + 2);
744:
745: adbBuffer = adbOutQueue.saveBuf; /* user data area */
746: adbCompRout = adbOutQueue.compRout; /* completion routine */
747: adbCompData = adbOutQueue.data; /* comp. rout. data */
748: adbOutQueueHasData = 0; /* currently processing
749: * "queue" entry */
750: adbSentChars = 0; /* nothing sent yet */
751: adbActionState = ADB_ACTION_OUT; /* set next state */
752: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
753: ADB_SR() = adbOutputBuffer[1]; /* load byte for output */
754: adbBusState = ADB_BUS_CMD; /* set bus to cmd state */
755: ADB_SET_STATE_CMD(); /* tell ADB that we want to send */
756: break;
757: } else {
758: #ifdef ADB_DEBUG
759: if (adb_debug)
760: printf_intr("pIDLE ");
761: #endif
762: adbActionState = ADB_ACTION_IDLE;
763: }
764: } else {
765: #ifdef ADB_DEBUG
766: if (adb_debug & 0x80)
767: printf_intr("pIN ");
768: #endif
769: adbActionState = ADB_ACTION_IN;
770: }
771: delay(ADB_DELAY);
772: (void)intr_dispatch(0x70); /* grab any serial interrupts */
773: goto switch_start;
774: break;
775: case ADB_ACTION_IDLE:
776: if (!intr_on) {
777: i = ADB_SR();
778: adbBusState = ADB_BUS_IDLE;
779: adbActionState = ADB_ACTION_IDLE;
780: ADB_SET_STATE_IDLE_II();
781: break;
782: }
783: adbInputBuffer[0] = 1;
784: adbInputBuffer[1] = ADB_SR(); /* get first byte */
785: #ifdef ADB_DEBUG
786: if (adb_debug & 0x80)
787: printf_intr("idle 0x%02x ", adbInputBuffer[1]);
788: #endif
789: ADB_SET_SR_INPUT(); /* make sure SR is set to IN */
790: adbActionState = ADB_ACTION_IN; /* set next state */
791: ADB_SET_STATE_EVEN(); /* set bus state to even */
792: adbBusState = ADB_BUS_EVEN;
793: break;
794:
795: case ADB_ACTION_IN:
796: adbInputBuffer[++adbInputBuffer[0]] = ADB_SR(); /* get byte */
797: #ifdef ADB_DEBUG
798: if (adb_debug & 0x80)
799: printf_intr("in 0x%02x ",
800: adbInputBuffer[adbInputBuffer[0]]);
801: #endif
802: ADB_SET_SR_INPUT(); /* make sure SR is set to IN */
803:
804: if (intr_on) { /* process last byte of packet */
805: adbInputBuffer[0]--; /* minus one */
806: /*
807: * If intr_on was true, and it's the second byte, then
808: * the byte we just discarded is really valid, so
809: * adjust the count
810: */
811: if (adbInputBuffer[0] == 2) {
812: adbInputBuffer[0]++;
813: }
814:
815: #ifdef ADB_DEBUG
816: if (adb_debug & 0x80) {
817: printf_intr("done: ");
818: print_single(adbInputBuffer);
819: }
820: #endif
821:
822: adbLastDevice = ADB_CMDADDR(adbInputBuffer[1]);
823:
824: if (adbInputBuffer[0] == 1 && !adbWaiting) { /* SRQ!!!*/
825: #ifdef ADB_DEBUG
826: if (adb_debug & 0x80)
827: printf_intr(" xSRQ! ");
828: #endif
829: adb_guess_next_device();
830: #ifdef ADB_DEBUG
831: if (adb_debug & 0x80)
832: printf_intr("try 0x%0x ",
833: adbLastDevice);
834: #endif
835: adbOutputBuffer[0] = 1;
836: adbOutputBuffer[1] = ADBTALK(adbLastDevice, 0);
837:
838: adbSentChars = 0; /* nothing sent yet */
839: adbActionState = ADB_ACTION_POLLING; /* set next state */
840: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
841: ADB_SR() = adbOutputBuffer[1]; /* load byte for output */
842: adbBusState = ADB_BUS_CMD; /* set bus to cmd state */
843: ADB_SET_STATE_CMD(); /* tell ADB that we want to */
844: break;
845: }
846:
847: /* set up data for adb_pass_up */
848: memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
849:
850: if (!adbWaiting && (adbInputBuffer[0] != 0)) {
851: packet.unsol = 1;
852: packet.ack_only = 0;
853: adb_pass_up(&packet);
854: } else {
855: packet.saveBuf = adbBuffer;
856: packet.compRout = adbCompRout;
857: packet.compData = adbCompData;
858: packet.unsol = 0;
859: packet.ack_only = 0;
860: adb_pass_up(&packet);
861: }
862:
863: adbWaiting = 0;
864: adbInputBuffer[0] = 0;
865: adbBuffer = NULL;
866: adbCompRout = NULL;
867: adbCompData = NULL;
868: /*
869: * Since we are done, check whether there is any data
870: * waiting to do out. If so, start the sending the data.
871: */
872: if (adbOutQueueHasData == 1) {
873: #ifdef ADB_DEBUG
874: if (adb_debug & 0x80)
875: printf_intr("XXX: DOING OUT QUEUE\n");
876: #endif
877: /* copy over data */
878: memcpy(adbOutputBuffer, adbOutQueue.outBuf,
879: adbOutQueue.outBuf[0] + 2);
880: adbBuffer = adbOutQueue.saveBuf; /* user data area */
881: adbCompRout = adbOutQueue.compRout; /* completion routine */
882: adbCompData = adbOutQueue.data; /* comp. rout. data */
883: adbOutQueueHasData = 0; /* currently processing
884: * "queue" entry */
885: send = 1;
886: } else {
887: #ifdef ADB_DEBUG
888: if (adb_debug & 0x80)
889: printf_intr("XXending ");
890: #endif
891: adb_guess_next_device();
892: adbOutputBuffer[0] = 1;
893: adbOutputBuffer[1] = ((adbLastDevice & 0x0f) << 4) | 0x0c;
894: adbSentChars = 0; /* nothing sent yet */
895: adbActionState = ADB_ACTION_POLLING; /* set next state */
896: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
897: ADB_SR() = adbOutputBuffer[1]; /* load byte for output */
898: adbBusState = ADB_BUS_CMD; /* set bus to cmd state */
899: ADB_SET_STATE_CMD(); /* tell ADB that we want to */
900: break;
901: }
902: }
903:
904: /*
905: * If send is true then something above determined that
906: * the message has ended and we need to start sending out
907: * a new message immediately. This could be because there
908: * is data waiting to go out or because an SRQ was seen.
909: */
910: if (send) {
911: adbSentChars = 0; /* nothing sent yet */
912: adbActionState = ADB_ACTION_OUT; /* set next state */
913: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
914: ADB_SR() = adbOutputBuffer[1]; /* load byte for output */
915: adbBusState = ADB_BUS_CMD; /* set bus to cmd state */
916: ADB_SET_STATE_CMD(); /* tell ADB that we want to
917: * send */
918: break;
919: }
920: /* We only get this far if the message hasn't ended yet. */
921: switch (adbBusState) { /* set to next state */
922: case ADB_BUS_EVEN:
923: ADB_SET_STATE_ODD(); /* set state to odd */
924: adbBusState = ADB_BUS_ODD;
925: break;
926:
927: case ADB_BUS_ODD:
928: ADB_SET_STATE_EVEN(); /* set state to even */
929: adbBusState = ADB_BUS_EVEN;
930: break;
931: default:
932: printf_intr("strange state!!!\n"); /* huh? */
933: break;
934: }
935: break;
936:
937: case ADB_ACTION_OUT:
938: i = ADB_SR(); /* clear interrupt */
939: adbSentChars++;
940: /*
941: * If the outgoing data was a TALK, we must
942: * switch to input mode to get the result.
943: */
944: if ((adbOutputBuffer[1] & 0x0c) == 0x0c) {
945: adbInputBuffer[0] = 1;
946: adbInputBuffer[1] = i;
947: adbActionState = ADB_ACTION_IN;
948: ADB_SET_SR_INPUT();
949: adbBusState = ADB_BUS_EVEN;
950: ADB_SET_STATE_EVEN();
951: #ifdef ADB_DEBUG
952: if (adb_debug & 0x80)
953: printf_intr("talk out 0x%02x ", i);
954: #endif
955: /* we want something back */
956: adbWaiting = 1;
957: break;
958: }
959: /*
960: * If it's not a TALK, check whether all data has been sent.
961: * If so, call the completion routine and clean up. If not,
962: * advance to the next state.
963: */
964: #ifdef ADB_DEBUG
965: if (adb_debug & 0x80)
966: printf_intr("non-talk out 0x%0x ", i);
967: #endif
968: ADB_SET_SR_OUTPUT();
969: if (adbOutputBuffer[0] == adbSentChars) { /* check for done */
970: #ifdef ADB_DEBUG
971: if (adb_debug & 0x80)
972: printf_intr("done \n");
973: #endif
974: /* set up stuff for adb_pass_up */
975: memcpy(packet.data, adbOutputBuffer, adbOutputBuffer[0] + 1);
976: packet.saveBuf = adbBuffer;
977: packet.compRout = adbCompRout;
978: packet.compData = adbCompData;
979: packet.cmd = adbWaitingCmd;
980: packet.unsol = 0;
981: packet.ack_only = 1;
982: adb_pass_up(&packet);
983:
984: /* reset "waiting" vars, just in case */
985: adbBuffer = NULL;
986: adbCompRout = NULL;
987: adbCompData = NULL;
988: if (adbOutQueueHasData == 1) {
989: /* copy over data */
990: memcpy(adbOutputBuffer, adbOutQueue.outBuf,
991: adbOutQueue.outBuf[0] + 2);
992: adbBuffer = adbOutQueue.saveBuf; /* user data area */
993: adbCompRout = adbOutQueue.compRout; /* completion routine */
994: adbCompData = adbOutQueue.data; /* comp. rout. data */
995: adbOutQueueHasData = 0; /* currently processing
996: * "queue" entry */
997: adbSentChars = 0; /* nothing sent yet */
998: adbActionState = ADB_ACTION_OUT; /* set next state */
999: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
1000: ADB_SR() = adbOutputBuffer[1]; /* load byte for output */
1001: adbBusState = ADB_BUS_CMD; /* set bus to cmd state */
1002: ADB_SET_STATE_CMD(); /* tell ADB that we want to
1003: * send */
1004: break;
1005: } else {
1006: /* send talk to last device instead */
1007: adbOutputBuffer[0] = 1;
1008: adbOutputBuffer[1] =
1009: ADBTALK(ADB_CMDADDR(adbOutputBuffer[1]), 0);
1010:
1011: adbSentChars = 0; /* nothing sent yet */
1012: adbActionState = ADB_ACTION_IDLE; /* set next state */
1013: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
1014: ADB_SR() = adbOutputBuffer[1]; /* load byte for output */
1015: adbBusState = ADB_BUS_CMD; /* set bus to cmd state */
1016: ADB_SET_STATE_CMD(); /* tell ADB that we want to */
1017: break;
1018: }
1019: }
1020: ADB_SR() = adbOutputBuffer[adbSentChars + 1];
1021: switch (adbBusState) { /* advance to next state */
1022: case ADB_BUS_EVEN:
1023: ADB_SET_STATE_ODD(); /* set state to odd */
1024: adbBusState = ADB_BUS_ODD;
1025: break;
1026:
1027: case ADB_BUS_CMD:
1028: case ADB_BUS_ODD:
1029: ADB_SET_STATE_EVEN(); /* set state to even */
1030: adbBusState = ADB_BUS_EVEN;
1031: break;
1032:
1033: default:
1034: #ifdef ADB_DEBUG
1035: if (adb_debug) {
1036: printf_intr("strange state!!! (0x%x)\n",
1037: adbBusState);
1038: }
1039: #endif
1040: break;
1041: }
1042: break;
1043:
1044: default:
1045: #ifdef ADB_DEBUG
1046: if (adb_debug)
1047: printf_intr("adb: unknown ADB state (during intr)\n");
1048: #endif
1049: break;
1050: }
1051:
1052: ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */
1053:
1054: splx(s); /* restore */
1055:
1056: return (1);
1057:
1058: }
1059:
1060:
1061: /*
1062: * send_adb version for II series machines
1063: */
1064: int
1065: send_adb_II(u_char *in, u_char *buffer, void *compRout, void *data, int command)
1066: {
1067: int s, len;
1068:
1069: if (adbActionState == ADB_ACTION_NOTREADY) /* return if ADB not
1070: * available */
1071: return 1;
1072:
1073: /* Don't interrupt while we are messing with the ADB */
1074: s = splhigh();
1075:
1076: if (0 != adbOutQueueHasData) { /* right now, "has data" means "full" */
1077: splx(s); /* sorry, try again later */
1078: return 1;
1079: }
1080: if ((long)in == (long)0) { /* need to convert? */
1081: /*
1082: * Don't need to use adb_cmd_extra here because this section
1083: * will be called ONLY when it is an ADB command (no RTC or
1084: * PRAM), especially on II series!
1085: */
1086: if ((command & 0x0c) == 0x08) /* copy addl data ONLY if
1087: * doing a listen! */
1088: len = buffer[0]; /* length of additional data */
1089: else
1090: len = 0;/* no additional data */
1091:
1092: adbOutQueue.outBuf[0] = 1 + len; /* command + addl. data */
1093: adbOutQueue.outBuf[1] = (u_char)command; /* load command */
1094:
1095: /* copy additional output data, if any */
1096: memcpy(adbOutQueue.outBuf + 2, buffer + 1, len);
1097: } else
1098: /* if data ready, just copy over */
1099: memcpy(adbOutQueue.outBuf, in, in[0] + 2);
1100:
1101: adbOutQueue.saveBuf = buffer; /* save buffer to know where to save
1102: * result */
1103: adbOutQueue.compRout = compRout; /* save completion routine
1104: * pointer */
1105: adbOutQueue.data = data;/* save completion routine data pointer */
1106:
1107: if ((adbActionState == ADB_ACTION_IDLE) && /* is ADB available? */
1108: (ADB_INTR_IS_OFF)) { /* and no incoming interrupts? */
1109: /* then start command now */
1110: memcpy(adbOutputBuffer, adbOutQueue.outBuf,
1111: adbOutQueue.outBuf[0] + 2); /* copy over data */
1112:
1113: adbBuffer = adbOutQueue.saveBuf; /* pointer to user data
1114: * area */
1115: adbCompRout = adbOutQueue.compRout; /* pointer to the
1116: * completion routine */
1117: adbCompData = adbOutQueue.data; /* pointer to the completion
1118: * routine data */
1119:
1120: adbSentChars = 0; /* nothing sent yet */
1121: adbActionState = ADB_ACTION_OUT; /* set next state */
1122: adbBusState = ADB_BUS_CMD; /* set bus to cmd state */
1123:
1124: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
1125:
1126: ADB_SR() = adbOutputBuffer[adbSentChars + 1]; /* load byte for output */
1127: ADB_SET_STATE_CMD(); /* tell ADB that we want to send */
1128: adbOutQueueHasData = 0; /* currently processing "queue" entry */
1129: } else
1130: adbOutQueueHasData = 1; /* something in the write "queue" */
1131:
1132: splx(s);
1133:
1134: /* were VIA1 interrupts blocked? */
1135: if (PSLTOIPL(s) >= mac68k_machine.via1_ipl) {
1136: /* poll until message done */
1137: while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)
1138: || (adbWaiting == 1))
1139: if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */
1140: adb_intr_II(NULL); /* go process it */
1141: if (adb_polling)
1142: adb_soft_intr();
1143: }
1144: }
1145:
1146: return 0;
1147: }
1148:
1149:
1150: /*
1151: * This routine is called from the II series interrupt routine
1152: * to determine what the "next" device is that should be polled.
1153: */
1154: int
1155: adb_guess_next_device(void)
1156: {
1157: int last, i, dummy;
1158:
1159: if (adbStarting) {
1160: /*
1161: * Start polling EVERY device, since we can't be sure there is
1162: * anything in the device table yet
1163: */
1164: if (adbLastDevice < 1 || adbLastDevice > 15)
1165: adbLastDevice = 1;
1166: if (++adbLastDevice > 15) /* point to next one */
1167: adbLastDevice = 1;
1168: } else {
1169: /* find the next device using the device table */
1170: if (adbLastDevice < 1 || adbLastDevice > 15) /* let's be parinoid */
1171: adbLastDevice = 2;
1172: last = 1; /* default index location */
1173:
1174: for (i = 1; i < 16; i++) /* find index entry */
1175: if (ADBDevTable[i].currentAddr == adbLastDevice) { /* look for device */
1176: last = i; /* found it */
1177: break;
1178: }
1179: dummy = last; /* index to start at */
1180: for (;;) { /* find next device in index */
1181: if (++dummy > 15) /* wrap around if needed */
1182: dummy = 1;
1183: if (dummy == last) { /* didn't find any other
1184: * device! This can happen if
1185: * there are no devices on the
1186: * bus */
1187: dummy = 1;
1188: break;
1189: }
1190: /* found the next device */
1191: if (ADBDevTable[dummy].devType != 0)
1192: break;
1193: }
1194: adbLastDevice = ADBDevTable[dummy].currentAddr;
1195: }
1196: return adbLastDevice;
1197: }
1198:
1199: #include "akbd.h"
1200: #if NAKBD > 0
1201: /*
1202: * Called when when an adb interrupt happens.
1203: * This routine simply transfers control over to the appropriate
1204: * code for the machine we are running on.
1205: */
1206: int
1207: adb_intr(void *arg)
1208: {
1209: switch (adbHardware) {
1210: case ADB_HW_II:
1211: return adb_intr_II(arg);
1212: case ADB_HW_IISI:
1213: return adb_intr_IIsi(arg);
1214: case ADB_HW_CUDA:
1215: return adb_intr_cuda(arg);
1216: default:
1217: return (-1);
1218: }
1219: }
1220: #endif
1221:
1222: /*
1223: * called when when an adb interrupt happens
1224: *
1225: * IIsi version of adb_intr
1226: *
1227: */
1228: int
1229: adb_intr_IIsi(void *arg)
1230: {
1231: struct adbCommand packet;
1232: int i, ending;
1233: unsigned int s;
1234:
1235: s = splhigh(); /* can't be too careful - might be called */
1236: /* from a routine, NOT an interrupt */
1237:
1238: ADB_VIA_CLR_INTR(); /* clear interrupt */
1239:
1240: ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */
1241:
1242: switch_start:
1243: switch (adbActionState) {
1244: case ADB_ACTION_IDLE:
1245: delay(ADB_DELAY); /* short delay is required before the
1246: * first byte */
1247:
1248: ADB_SET_SR_INPUT(); /* make sure SR is set to IN */
1249: ADB_SET_STATE_ACTIVE(); /* signal start of data frame */
1250: adbInputBuffer[1] = ADB_SR(); /* get byte */
1251: adbInputBuffer[0] = 1;
1252: adbActionState = ADB_ACTION_IN; /* set next state */
1253:
1254: ADB_SET_STATE_ACKON(); /* start ACK to ADB chip */
1255: delay(ADB_DELAY); /* delay */
1256: ADB_SET_STATE_ACKOFF(); /* end ACK to ADB chip */
1257: (void)intr_dispatch(0x70); /* grab any serial interrupts */
1258: break;
1259:
1260: case ADB_ACTION_IN:
1261: ADB_SET_SR_INPUT(); /* make sure SR is set to IN */
1262: adbInputBuffer[++adbInputBuffer[0]] = ADB_SR(); /* get byte */
1263: if (ADB_INTR_IS_OFF) /* check for end of frame */
1264: ending = 1;
1265: else
1266: ending = 0;
1267:
1268: ADB_SET_STATE_ACKON(); /* start ACK to ADB chip */
1269: delay(ADB_DELAY); /* delay */
1270: ADB_SET_STATE_ACKOFF(); /* end ACK to ADB chip */
1271: (void)intr_dispatch(0x70); /* grab any serial interrupts */
1272:
1273: if (1 == ending) { /* end of message? */
1274: ADB_SET_STATE_INACTIVE(); /* signal end of frame */
1275: /*
1276: * This section _should_ handle all ADB and RTC/PRAM
1277: * type commands, but there may be more... Note:
1278: * commands are always at [4], even for rtc/pram
1279: * commands
1280: */
1281: /* set up data for adb_pass_up */
1282: memcpy(packet.data, adbInputBuffer, adbInputBuffer[0] + 1);
1283:
1284: if ((adbWaiting == 1) && /* are we waiting AND */
1285: (adbInputBuffer[4] == adbWaitingCmd) && /* the cmd we sent AND */
1286: ((adbInputBuffer[2] == 0x00) || /* it's from the ADB
1287: * device OR */
1288: (adbInputBuffer[2] == 0x01))) { /* it's from the
1289: * PRAM/RTC device */
1290:
1291: packet.saveBuf = adbBuffer;
1292: packet.compRout = adbCompRout;
1293: packet.compData = adbCompData;
1294: packet.unsol = 0;
1295: packet.ack_only = 0;
1296: adb_pass_up(&packet);
1297:
1298: adbWaitingCmd = 0; /* reset "waiting" vars */
1299: adbWaiting = 0;
1300: adbBuffer = NULL;
1301: adbCompRout = NULL;
1302: adbCompData = NULL;
1303: } else {
1304: packet.unsol = 1;
1305: packet.ack_only = 0;
1306: adb_pass_up(&packet);
1307: }
1308:
1309: adbActionState = ADB_ACTION_IDLE;
1310: adbInputBuffer[0] = 0; /* reset length */
1311:
1312: if (adbWriteDelay == 1) { /* were we waiting to
1313: * write? */
1314: adbSentChars = 0; /* nothing sent yet */
1315: adbActionState = ADB_ACTION_OUT; /* set next state */
1316:
1317: delay(ADB_DELAY); /* delay */
1318: (void)intr_dispatch(0x70); /* grab any serial interrupts */
1319:
1320: if (ADB_INTR_IS_ON) { /* ADB intr low during
1321: * write */
1322: ADB_SET_STATE_IDLE_IISI(); /* reset */
1323: ADB_SET_SR_INPUT(); /* make sure SR is set
1324: * to IN */
1325: adbSentChars = 0; /* must start all over */
1326: adbActionState = ADB_ACTION_IDLE; /* new state */
1327: adbInputBuffer[0] = 0;
1328: /* may be able to take this out later */
1329: delay(ADB_DELAY); /* delay */
1330: break;
1331: }
1332: ADB_SET_STATE_ACTIVE(); /* tell ADB that we want
1333: * to send */
1334: ADB_SET_STATE_ACKOFF(); /* make sure */
1335: ADB_SET_SR_OUTPUT(); /* set shift register
1336: * for OUT */
1337: ADB_SR() = adbOutputBuffer[adbSentChars + 1];
1338: ADB_SET_STATE_ACKON(); /* tell ADB byte ready
1339: * to shift */
1340: }
1341: }
1342: break;
1343:
1344: case ADB_ACTION_OUT:
1345: i = ADB_SR(); /* reset SR-intr in IFR */
1346: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
1347:
1348: ADB_SET_STATE_ACKOFF(); /* finish ACK */
1349: adbSentChars++;
1350: if (ADB_INTR_IS_ON) { /* ADB intr low during write */
1351: ADB_SET_STATE_IDLE_IISI(); /* reset */
1352: ADB_SET_SR_INPUT(); /* make sure SR is set to IN */
1353: adbSentChars = 0; /* must start all over */
1354: adbActionState = ADB_ACTION_IDLE; /* new state */
1355: adbInputBuffer[0] = 0;
1356: adbWriteDelay = 1; /* must retry when done with
1357: * read */
1358: delay(ADB_DELAY); /* delay */
1359: (void)intr_dispatch(0x70); /* grab any serial interrupts */
1360: goto switch_start; /* process next state right
1361: * now */
1362: break;
1363: }
1364: delay(ADB_DELAY); /* required delay */
1365: (void)intr_dispatch(0x70); /* grab any serial interrupts */
1366:
1367: if (adbOutputBuffer[0] == adbSentChars) { /* check for done */
1368: if (0 == adb_cmd_result(adbOutputBuffer)) { /* do we expect data
1369: * back? */
1370: adbWaiting = 1; /* signal waiting for return */
1371: adbWaitingCmd = adbOutputBuffer[2]; /* save waiting command */
1372: } else {/* no talk, so done */
1373: /* set up stuff for adb_pass_up */
1374: memcpy(packet.data, adbInputBuffer,
1375: adbInputBuffer[0] + 1);
1376: packet.saveBuf = adbBuffer;
1377: packet.compRout = adbCompRout;
1378: packet.compData = adbCompData;
1379: packet.cmd = adbWaitingCmd;
1380: packet.unsol = 0;
1381: packet.ack_only = 1;
1382: adb_pass_up(&packet);
1383:
1384: /* reset "waiting" vars, just in case */
1385: adbWaitingCmd = 0;
1386: adbBuffer = NULL;
1387: adbCompRout = NULL;
1388: adbCompData = NULL;
1389: }
1390:
1391: adbWriteDelay = 0; /* done writing */
1392: adbActionState = ADB_ACTION_IDLE; /* signal bus is idle */
1393: ADB_SET_SR_INPUT(); /* make sure SR is set to IN */
1394: ADB_SET_STATE_INACTIVE(); /* end of frame */
1395: } else {
1396: ADB_SR() = adbOutputBuffer[adbSentChars + 1]; /* send next byte */
1397: ADB_SET_STATE_ACKON(); /* signal byte ready to shift */
1398: }
1399: break;
1400:
1401: case ADB_ACTION_NOTREADY:
1402: #ifdef ADB_DEBUG
1403: if (adb_debug)
1404: printf_intr("adb: not yet initialized\n");
1405: #endif
1406: break;
1407:
1408: default:
1409: #ifdef ADB_DEBUG
1410: if (adb_debug)
1411: printf_intr("intr: unknown ADB state\n");
1412: #endif
1413: break;
1414: }
1415:
1416: ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */
1417:
1418: splx(s); /* restore */
1419:
1420: return (1);
1421: } /* end adb_intr_IIsi */
1422:
1423:
1424: /*****************************************************************************
1425: * if the device is currently busy, and there is no data waiting to go out, then
1426: * the data is "queued" in the outgoing buffer. If we are already waiting, then
1427: * we return.
1428: * in: if (in == 0) then the command string is built from command and buffer
1429: * if (in != 0) then in is used as the command string
1430: * buffer: additional data to be sent (used only if in == 0)
1431: * this is also where return data is stored
1432: * compRout: the completion routine that is called when then return value
1433: * is received (if a return value is expected)
1434: * data: a data pointer that can be used by the completion routine
1435: * command: an ADB command to be sent (used only if in == 0)
1436: *
1437: */
1438: int
1439: send_adb_IIsi(u_char *in, u_char *buffer, void *compRout, void *data, int
1440: command)
1441: {
1442: int s, len;
1443:
1444: if (adbActionState == ADB_ACTION_NOTREADY)
1445: return 1;
1446:
1447: /* Don't interrupt while we are messing with the ADB */
1448: s = splhigh();
1449:
1450: if ((adbActionState == ADB_ACTION_IDLE) && /* ADB available? */
1451: (ADB_INTR_IS_OFF)) {/* and no incoming interrupt? */
1452:
1453: } else
1454: if (adbWriteDelay == 0) /* it's busy, but is anything waiting? */
1455: adbWriteDelay = 1; /* if no, then we'll "queue"
1456: * it up */
1457: else {
1458: splx(s);
1459: return 1; /* really busy! */
1460: }
1461:
1462: if ((long)in == (long)0) { /* need to convert? */
1463: /*
1464: * Don't need to use adb_cmd_extra here because this section
1465: * will be called ONLY when it is an ADB command (no RTC or
1466: * PRAM)
1467: */
1468: if ((command & 0x0c) == 0x08) /* copy addl data ONLY if
1469: * doing a listen! */
1470: len = buffer[0]; /* length of additional data */
1471: else
1472: len = 0;/* no additional data */
1473:
1474: adbOutputBuffer[0] = 2 + len; /* dev. type + command + addl.
1475: * data */
1476: adbOutputBuffer[1] = 0x00; /* mark as an ADB command */
1477: adbOutputBuffer[2] = (u_char)command; /* load command */
1478:
1479: /* copy additional output data, if any */
1480: memcpy(adbOutputBuffer + 3, buffer + 1, len);
1481: } else
1482: /* if data ready, just copy over */
1483: memcpy(adbOutputBuffer, in, in[0] + 2);
1484:
1485: adbSentChars = 0; /* nothing sent yet */
1486: adbBuffer = buffer; /* save buffer to know where to save result */
1487: adbCompRout = compRout; /* save completion routine pointer */
1488: adbCompData = data; /* save completion routine data pointer */
1489: adbWaitingCmd = adbOutputBuffer[2]; /* save wait command */
1490:
1491: if (adbWriteDelay != 1) { /* start command now? */
1492: adbActionState = ADB_ACTION_OUT; /* set next state */
1493:
1494: ADB_SET_STATE_ACTIVE(); /* tell ADB that we want to send */
1495: ADB_SET_STATE_ACKOFF(); /* make sure */
1496:
1497: ADB_SET_SR_OUTPUT(); /* set shift register for OUT */
1498:
1499: ADB_SR() = adbOutputBuffer[adbSentChars + 1]; /* load byte for output */
1500:
1501: ADB_SET_STATE_ACKON(); /* tell ADB byte ready to shift */
1502: }
1503: adbWriteDelay = 1; /* something in the write "queue" */
1504:
1505: splx(s);
1506:
1507: /* were VIA1 interrupts blocked? */
1508: if (PSLTOIPL(s) >= mac68k_machine.via1_ipl) {
1509: /* poll until byte done */
1510: while ((adbActionState != ADB_ACTION_IDLE) || (ADB_INTR_IS_ON)
1511: || (adbWaiting == 1))
1512: if (ADB_SR_INTR_IS_ON) { /* wait for "interrupt" */
1513: adb_intr_IIsi(NULL); /* go process it */
1514: if (adb_polling)
1515: adb_soft_intr();
1516: }
1517: }
1518:
1519: return 0;
1520: } /* send_adb_IIsi */
1521:
1522: /*
1523: * adb_pass_up is called by the interrupt-time routines.
1524: * It takes the raw packet data that was received from the
1525: * device and puts it into the queue that the upper half
1526: * processes. It then signals for a soft ADB interrupt which
1527: * will eventually call the upper half routine (adb_soft_intr).
1528: *
1529: * If in->unsol is 0, then this is either the notification
1530: * that the packet was sent (on a LISTEN, for example), or the
1531: * response from the device (on a TALK). The completion routine
1532: * is called only if the user specified one.
1533: *
1534: * If in->unsol is 1, then this packet was unsolicited and
1535: * so we look up the device in the ADB device table to determine
1536: * what its default service routine is.
1537: *
1538: * If in->ack_only is 1, then we really only need to call
1539: * the completion routine, so don't do any other stuff.
1540: *
1541: * Note that in->data contains the packet header AND data,
1542: * while adbInbound[]->data contains ONLY data.
1543: *
1544: * Note: Called only at interrupt time. Assumes this.
1545: */
1546: void
1547: adb_pass_up(struct adbCommand *in)
1548: {
1549: int start = 0, len = 0, cmd = 0;
1550: ADBDataBlock block;
1551:
1552: if (adbInCount >= ADB_QUEUE) {
1553: #ifdef ADB_DEBUG
1554: if (adb_debug)
1555: printf_intr("adb: ring buffer overflow\n");
1556: #endif
1557: return;
1558: }
1559:
1560: if (in->ack_only) {
1561: len = in->data[0];
1562: cmd = in->cmd;
1563: start = 0;
1564: } else {
1565: switch (adbHardware) {
1566: case ADB_HW_IOP:
1567: case ADB_HW_II:
1568: cmd = in->data[1];
1569: if (in->data[0] < 2)
1570: len = 0;
1571: else
1572: len = in->data[0]-1;
1573: start = 1;
1574: break;
1575:
1576: case ADB_HW_IISI:
1577: case ADB_HW_CUDA:
1578: /* If it's unsolicited, accept only ADB data for now */
1579: if (in->unsol)
1580: if (0 != in->data[2])
1581: return;
1582: cmd = in->data[4];
1583: if (in->data[0] < 5)
1584: len = 0;
1585: else
1586: len = in->data[0]-4;
1587: start = 4;
1588: break;
1589:
1590: case ADB_HW_PB:
1591: cmd = in->data[1];
1592: if (in->data[0] < 2)
1593: len = 0;
1594: else
1595: len = in->data[0]-1;
1596: start = 1;
1597: break;
1598:
1599: case ADB_HW_UNKNOWN:
1600: return;
1601: }
1602:
1603: /* Make sure there is a valid device entry for this device */
1604: if (in->unsol) {
1605: /* ignore unsolicited data during adbreinit */
1606: if (adbStarting)
1607: return;
1608: /* get device's comp. routine and data area */
1609: if (-1 == get_adb_info(&block, ADB_CMDADDR(cmd)))
1610: return;
1611: }
1612: }
1613:
1614: /*
1615: * If this is an unsolicited packet, we need to fill in
1616: * some info so adb_soft_intr can process this packet
1617: * properly. If it's not unsolicited, then use what
1618: * the caller sent us.
1619: */
1620: if (in->unsol) {
1621: adbInbound[adbInTail].compRout = (void *)block.dbServiceRtPtr;
1622: adbInbound[adbInTail].compData = (void *)block.dbDataAreaAddr;
1623: adbInbound[adbInTail].saveBuf = (void *)adbInbound[adbInTail].data;
1624: } else {
1625: adbInbound[adbInTail].compRout = (void *)in->compRout;
1626: adbInbound[adbInTail].compData = (void *)in->compData;
1627: adbInbound[adbInTail].saveBuf = (void *)in->saveBuf;
1628: }
1629:
1630: #ifdef ADB_DEBUG
1631: if (adb_debug && in->data[1] == 2)
1632: printf_intr("adb: caught error\n");
1633: #endif
1634:
1635: /* copy the packet data over */
1636: /*
1637: * TO DO: If the *_intr routines fed their incoming data
1638: * directly into an adbCommand struct, which is passed to
1639: * this routine, then we could eliminate this copy.
1640: */
1641: memcpy(adbInbound[adbInTail].data + 1, in->data + start + 1, len);
1642: adbInbound[adbInTail].data[0] = len;
1643: adbInbound[adbInTail].cmd = cmd;
1644:
1645: adbInCount++;
1646: if (++adbInTail >= ADB_QUEUE)
1647: adbInTail = 0;
1648:
1649: /*
1650: * If the debugger is running, call upper half manually.
1651: * Otherwise, trigger a soft interrupt to handle the rest later.
1652: */
1653: if (adb_polling)
1654: adb_soft_intr();
1655: else
1656: setsoftadb();
1657: }
1658:
1659:
1660: /*
1661: * Called to process the packets after they have been
1662: * placed in the incoming queue.
1663: *
1664: */
1665: void
1666: adb_soft_intr(void)
1667: {
1668: int s;
1669: int cmd = 0;
1670: u_char *buffer;
1671: void *comprout;
1672: u_char *compdata;
1673:
1674: /*delay(2*ADB_DELAY);*/
1675:
1676: while (adbInCount) {
1677: #ifdef ADB_DEBUG
1678: if (adb_debug & 0x80)
1679: printf_intr("%x %x %x ",
1680: adbInCount, adbInHead, adbInTail);
1681: #endif
1682: /* get the data we need from the queue */
1683: buffer = adbInbound[adbInHead].saveBuf;
1684: comprout = adbInbound[adbInHead].compRout;
1685: compdata = adbInbound[adbInHead].compData;
1686: cmd = adbInbound[adbInHead].cmd;
1687:
1688: /* copy over data to data area if it's valid */
1689: /*
1690: * Note that for unsol packets we don't want to copy the
1691: * data anywhere, so buffer was already set to 0.
1692: * For ack_only buffer was set to 0, so don't copy.
1693: */
1694: if (buffer)
1695: memcpy(buffer, adbInbound[adbInHead].data,
1696: adbInbound[adbInHead].data[0] + 1);
1697:
1698: #ifdef ADB_DEBUG
1699: if (adb_debug & 0x80) {
1700: printf_intr("%p %p %p %x ",
1701: buffer, comprout, compdata, (short)cmd);
1702: printf_intr("buf: ");
1703: print_single(adbInbound[adbInHead].data);
1704: }
1705: #endif
1706:
1707: /*
1708: * Remove the packet from the queue before calling
1709: * the completion routine, so that the completion
1710: * routine can reentrantly process the queue. For
1711: * example, this happens when polling is turned on
1712: * by entering the debugger by keystroke.
1713: */
1714: s = splhigh();
1715: adbInCount--;
1716: if (++adbInHead >= ADB_QUEUE)
1717: adbInHead = 0;
1718: splx(s);
1719:
1720: /* call default completion routine if it's valid */
1721: if (comprout) {
1722: (void)((int (*)(u_char *, u_char *, int))comprout)
1723: (buffer, compdata, cmd);
1724: }
1725: }
1726: }
1727:
1728:
1729: /*
1730: * This is my version of the ADBOp routine. It mainly just calls the
1731: * hardware-specific routine.
1732: *
1733: * data : pointer to data area to be used by compRout
1734: * compRout : completion routine
1735: * buffer : for LISTEN: points to data to send - MAX 8 data bytes,
1736: * byte 0 = # of bytes
1737: * : for TALK: points to place to save return data
1738: * command : the adb command to send
1739: * result : 0 = success
1740: * : -1 = could not complete
1741: */
1742: int
1743: adb_op(Ptr buffer, Ptr compRout, Ptr data, short command)
1744: {
1745: int result;
1746:
1747: switch (adbHardware) {
1748: case ADB_HW_II:
1749: result = send_adb_II((u_char *)0, (u_char *)buffer,
1750: (void *)compRout, (void *)data, (int)command);
1751: if (result == 0)
1752: return 0;
1753: else
1754: return -1;
1755: break;
1756:
1757: case ADB_HW_IISI:
1758: result = send_adb_IIsi((u_char *)0, (u_char *)buffer,
1759: (void *)compRout, (void *)data, (int)command);
1760: /*
1761: * I wish I knew why this delay is needed. It usually needs to
1762: * be here when several commands are sent in close succession,
1763: * especially early in device probes when doing collision
1764: * detection. It must be some race condition. Sigh. - jpw
1765: */
1766: delay(100);
1767: if (result == 0)
1768: return 0;
1769: else
1770: return -1;
1771: break;
1772:
1773: case ADB_HW_PB:
1774: result = pm_adb_op((u_char *)buffer, (void *)compRout,
1775: (void *)data, (int)command);
1776:
1777: if (result == 0)
1778: return 0;
1779: else
1780: return -1;
1781: break;
1782:
1783: case ADB_HW_CUDA:
1784: result = send_adb_cuda((u_char *)0, (u_char *)buffer,
1785: (void *)compRout, (void *)data, (int)command);
1786: if (result == 0)
1787: return 0;
1788: else
1789: return -1;
1790: break;
1791:
1792: case ADB_HW_IOP:
1793: case ADB_HW_UNKNOWN:
1794: default:
1795: return -1;
1796: }
1797: }
1798:
1799:
1800: /*
1801: * adb_hw_setup
1802: * This routine sets up the possible machine specific hardware
1803: * config (mainly VIA settings) for the various models.
1804: */
1805: void
1806: adb_hw_setup(struct device *self)
1807: {
1808: volatile int i;
1809: u_char send_string[ADB_MAX_MSG_LENGTH];
1810:
1811: switch (adbHardware) {
1812: case ADB_HW_II:
1813: via1_register_irq(2, adb_intr_II, self, self->dv_xname);
1814:
1815: via_reg(VIA1, vDirB) |= 0x30; /* register B bits 4 and 5:
1816: * outputs */
1817: via_reg(VIA1, vDirB) &= 0xf7; /* register B bit 3: input */
1818: via_reg(VIA1, vACR) &= ~vSR_OUT; /* make sure SR is set
1819: * to IN (II, IIsi) */
1820: adbActionState = ADB_ACTION_IDLE; /* used by all types of
1821: * hardware (II, IIsi) */
1822: adbBusState = ADB_BUS_IDLE; /* this var. used in II-series
1823: * code only */
1824: via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts
1825: * are on (II, IIsi) */
1826: ADB_SET_STATE_IDLE_II(); /* set ADB bus state to idle */
1827:
1828: ADB_VIA_CLR_INTR(); /* clear interrupt */
1829: break;
1830:
1831: case ADB_HW_IISI:
1832: via1_register_irq(2, adb_intr_IIsi, self, self->dv_xname);
1833: via_reg(VIA1, vDirB) |= 0x30; /* register B bits 4 and 5:
1834: * outputs */
1835: via_reg(VIA1, vDirB) &= 0xf7; /* register B bit 3: input */
1836: via_reg(VIA1, vACR) &= ~vSR_OUT; /* make sure SR is set
1837: * to IN (II, IIsi) */
1838: adbActionState = ADB_ACTION_IDLE; /* used by all types of
1839: * hardware (II, IIsi) */
1840: adbBusState = ADB_BUS_IDLE; /* this var. used in II-series
1841: * code only */
1842: via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts
1843: * are on (II, IIsi) */
1844: ADB_SET_STATE_IDLE_IISI(); /* set ADB bus state to idle */
1845:
1846: /* get those pesky clock ticks we missed while booting */
1847: for (i = 0; i < 30; i++) {
1848: delay(ADB_DELAY);
1849: adb_hw_setup_IIsi(send_string);
1850: #ifdef ADB_DEBUG
1851: if (adb_debug) {
1852: printf_intr("adb: cleanup: ");
1853: print_single(send_string);
1854: }
1855: #endif
1856: delay(ADB_DELAY);
1857: if (ADB_INTR_IS_OFF)
1858: break;
1859: }
1860: break;
1861:
1862: case ADB_HW_PB:
1863: /*
1864: * XXX - really PM_VIA_CLR_INTR - should we put it in
1865: * pm_direct.h?
1866: */
1867: pm_hw_setup(self);
1868: break;
1869:
1870: case ADB_HW_CUDA:
1871: via1_register_irq(2, adb_intr_cuda, self, self->dv_xname);
1872: via_reg(VIA1, vDirB) |= 0x30; /* register B bits 4 and 5:
1873: * outputs */
1874: via_reg(VIA1, vDirB) &= 0xf7; /* register B bit 3: input */
1875: via_reg(VIA1, vACR) &= ~vSR_OUT; /* make sure SR is set
1876: * to IN */
1877: via_reg(VIA1, vACR) = (via_reg(VIA1, vACR) | 0x0c) & ~0x10;
1878: adbActionState = ADB_ACTION_IDLE; /* used by all types of
1879: * hardware */
1880: adbBusState = ADB_BUS_IDLE; /* this var. used in II-series
1881: * code only */
1882: via_reg(VIA1, vIER) = 0x84; /* make sure VIA interrupts
1883: * are on */
1884: ADB_SET_STATE_IDLE_CUDA(); /* set ADB bus state to idle */
1885:
1886: /* sort of a device reset */
1887: i = ADB_SR(); /* clear interrupt */
1888: ADB_VIA_INTR_DISABLE(); /* no interrupts while clearing */
1889: ADB_SET_STATE_IDLE_CUDA(); /* reset state to idle */
1890: delay(ADB_DELAY);
1891: ADB_SET_STATE_TIP(); /* signal start of frame */
1892: delay(ADB_DELAY);
1893: ADB_TOGGLE_STATE_ACK_CUDA();
1894: delay(ADB_DELAY);
1895: ADB_CLR_STATE_TIP();
1896: delay(ADB_DELAY);
1897: ADB_SET_STATE_IDLE_CUDA(); /* back to idle state */
1898: i = ADB_SR(); /* clear interrupt */
1899: ADB_VIA_INTR_ENABLE(); /* ints ok now */
1900: break;
1901:
1902: case ADB_HW_IOP:
1903: case ADB_HW_UNKNOWN:
1904: default:
1905: via_reg(VIA1, vIER) = 0x04; /* turn interrupts off - TO
1906: * DO: turn PB ints off? */
1907: break;
1908: }
1909: }
1910:
1911:
1912: /*
1913: * adb_hw_setup_IIsi
1914: * This is sort of a "read" routine that forces the adb hardware through a read cycle
1915: * if there is something waiting. This helps "clean up" any commands that may have gotten
1916: * stuck or stopped during the boot process.
1917: *
1918: */
1919: void
1920: adb_hw_setup_IIsi(u_char *buffer)
1921: {
1922: int i;
1923: int dummy;
1924: int s;
1925: long my_time;
1926: int endofframe;
1927:
1928: delay(ADB_DELAY);
1929:
1930: i = 1; /* skip over [0] */
1931: s = splhigh(); /* block ALL interrupts while we are working */
1932: ADB_SET_SR_INPUT(); /* make sure SR is set to IN */
1933: ADB_VIA_INTR_DISABLE(); /* disable ADB interrupt on IIs. */
1934: /* this is required, especially on faster machines */
1935: delay(ADB_DELAY);
1936:
1937: if (ADB_INTR_IS_ON) {
1938: ADB_SET_STATE_ACTIVE(); /* signal start of data frame */
1939:
1940: endofframe = 0;
1941: while (0 == endofframe) {
1942: /*
1943: * Poll for ADB interrupt and watch for timeout.
1944: * If time out, keep going in hopes of not hanging
1945: * the ADB chip - I think
1946: */
1947: my_time = ADB_DELAY * 5;
1948: while ((ADB_SR_INTR_IS_OFF) && (my_time-- > 0))
1949: dummy = via_reg(VIA1, vBufB);
1950:
1951: buffer[i++] = ADB_SR(); /* reset interrupt flag by
1952: * reading vSR */
1953: /*
1954: * Perhaps put in a check here that ignores all data
1955: * after the first ADB_MAX_MSG_LENGTH bytes ???
1956: */
1957: if (ADB_INTR_IS_OFF) /* check for end of frame */
1958: endofframe = 1;
1959:
1960: ADB_SET_STATE_ACKON(); /* send ACK to ADB chip */
1961: delay(ADB_DELAY); /* delay */
1962: ADB_SET_STATE_ACKOFF(); /* send ACK to ADB chip */
1963: }
1964: ADB_SET_STATE_INACTIVE(); /* signal end of frame and
1965: * delay */
1966:
1967: /* probably don't need to delay this long */
1968: delay(ADB_DELAY);
1969: }
1970: buffer[0] = --i; /* [0] is length of message */
1971: ADB_VIA_INTR_ENABLE(); /* enable ADB interrupt on IIs. */
1972: splx(s); /* restore interrupts */
1973: }
1974:
1975:
1976:
1977: /*
1978: * adb_reinit sets up the adb stuff
1979: *
1980: */
1981: void
1982: adb_reinit(struct device *self)
1983: {
1984: u_char send_string[ADB_MAX_MSG_LENGTH];
1985: ADBDataBlock data; /* temp. holder for getting device info */
1986: volatile int i, x;
1987: int s;
1988: int command;
1989: int result;
1990: int saveptr; /* point to next free relocation address */
1991: int device;
1992: int nonewtimes; /* times thru loop w/o any new devices */
1993:
1994: /* Make sure we are not interrupted while building the table. */
1995: /* ints must be on for PB & IOP (at least, for now) */
1996: if (adbHardware != ADB_HW_PB && adbHardware != ADB_HW_IOP)
1997: s = splhigh();
1998: else
1999: s = 0; /* XXX shut the compiler up*/
2000:
2001: ADBNumDevices = 0; /* no devices yet */
2002:
2003: /* Let intr routines know we are running reinit */
2004: adbStarting = 1;
2005:
2006: /*
2007: * Initialize the ADB table. For now, we'll always use the same table
2008: * that is defined at the beginning of this file - no mallocs.
2009: */
2010: for (i = 0; i < 16; i++) {
2011: ADBDevTable[i].devType = 0;
2012: ADBDevTable[i].origAddr = ADBDevTable[i].currentAddr = 0;
2013: }
2014:
2015: adb_hw_setup(self); /* init the VIA bits and hard reset ADB */
2016:
2017: delay(1000);
2018:
2019: /* send an ADB reset first */
2020: (void)adb_op_sync((Ptr)0, (short)0x00);
2021: delay(3000);
2022:
2023: /*
2024: * Probe for ADB devices. Probe devices 1-15 quickly to determine
2025: * which device addresses are in use and which are free. For each
2026: * address that is in use, move the device at that address to a higher
2027: * free address. Continue doing this at that address until no device
2028: * responds at that address. Then move the last device that was moved
2029: * back to the original address. Do this for the remaining addresses
2030: * that we determined were in use.
2031: *
2032: * When finished, do this entire process over again with the updated
2033: * list of in use addresses. Do this until no new devices have been
2034: * found in 20 passes though the in use address list. (This probably
2035: * seems long and complicated, but it's the best way to detect multiple
2036: * devices at the same address - sometimes it takes a couple of tries
2037: * before the collision is detected.)
2038: */
2039:
2040: /* initial scan through the devices */
2041: for (i = 1; i < 16; i++) {
2042: command = ADBTALK(i, 3);
2043: result = adb_op_sync((Ptr)send_string, (short)command);
2044:
2045: if (result == 0 && send_string[0] != 0) {
2046: /* found a device */
2047: ++ADBNumDevices;
2048: KASSERT(ADBNumDevices < 16);
2049: ADBDevTable[ADBNumDevices].devType =
2050: (int)(send_string[2]);
2051: ADBDevTable[ADBNumDevices].origAddr = i;
2052: ADBDevTable[ADBNumDevices].currentAddr = i;
2053: ADBDevTable[ADBNumDevices].DataAreaAddr = NULL;
2054: ADBDevTable[ADBNumDevices].ServiceRtPtr = NULL;
2055: pm_check_adb_devices(i); /* tell pm driver device
2056: * is here */
2057: }
2058: }
2059:
2060: /* find highest unused address */
2061: for (saveptr = 15; saveptr > 0; saveptr--)
2062: if (-1 == get_adb_info(&data, saveptr))
2063: break;
2064:
2065: #ifdef ADB_DEBUG
2066: if (adb_debug & 0x80) {
2067: printf_intr("first free is: 0x%02x\n", saveptr);
2068: printf_intr("devices: %i\n", ADBNumDevices);
2069: }
2070: #endif
2071:
2072: nonewtimes = 0; /* no loops w/o new devices */
2073: while (saveptr > 0 && nonewtimes++ < 11) {
2074: for (i = 1;saveptr > 0 && i <= ADBNumDevices; i++) {
2075: device = ADBDevTable[i].currentAddr;
2076: #ifdef ADB_DEBUG
2077: if (adb_debug & 0x80)
2078: printf_intr("moving device 0x%02x to 0x%02x "
2079: "(index 0x%02x) ", device, saveptr, i);
2080: #endif
2081:
2082: /* send TALK R3 to address */
2083: command = ADBTALK(device, 3);
2084: (void)adb_op_sync((Ptr)send_string, (short)command);
2085:
2086: /* move device to higher address */
2087: command = ADBLISTEN(device, 3);
2088: send_string[0] = 2;
2089: send_string[1] = (u_char)(saveptr | 0x60);
2090: send_string[2] = 0xfe;
2091: (void)adb_op_sync((Ptr)send_string, (short)command);
2092: delay(1000);
2093:
2094: /* send TALK R3 - anthing at new address? */
2095: command = ADBTALK(saveptr, 3);
2096: send_string[0] = 0;
2097: result = adb_op_sync((Ptr)send_string, (short)command);
2098: delay(1000);
2099:
2100: if (result != 0 || send_string[0] == 0) {
2101: /*
2102: * maybe there's a communication breakdown;
2103: * just in case, move it back from whence it
2104: * came, and we'll try again later
2105: */
2106: command = ADBLISTEN(saveptr, 3);
2107: send_string[0] = 2;
2108: send_string[1] = (u_char)(device | 0x60);
2109: send_string[2] = 0x00;
2110: (void)adb_op_sync((Ptr)send_string,
2111: (short)command);
2112: #ifdef ADB_DEBUG
2113: if (adb_debug & 0x80)
2114: printf_intr("failed, continuing\n");
2115: #endif
2116: delay(1000);
2117: continue;
2118: }
2119:
2120: /* send TALK R3 - anything at old address? */
2121: command = ADBTALK(device, 3);
2122: send_string[0] = 0;
2123: result = adb_op_sync((Ptr)send_string, (short)command);
2124: if (result == 0 && send_string[0] != 0) {
2125: /* new device found */
2126: /* update data for previously moved device */
2127: ADBDevTable[i].currentAddr = saveptr;
2128: #ifdef ADB_DEBUG
2129: if (adb_debug & 0x80)
2130: printf_intr("old device at index %i\n",i);
2131: #endif
2132: /* add new device in table */
2133: #ifdef ADB_DEBUG
2134: if (adb_debug & 0x80)
2135: printf_intr("new device found\n");
2136: #endif
2137: if (saveptr > ADBNumDevices) {
2138: ++ADBNumDevices;
2139: KASSERT(ADBNumDevices < 16);
2140: }
2141: ADBDevTable[ADBNumDevices].devType =
2142: (int)(send_string[2]);
2143: ADBDevTable[ADBNumDevices].origAddr = device;
2144: ADBDevTable[ADBNumDevices].currentAddr = device;
2145: /* These will be set correctly in adbsys.c */
2146: /* Until then, unsol. data will be ignored. */
2147: ADBDevTable[ADBNumDevices].DataAreaAddr =
2148: (long)0;
2149: ADBDevTable[ADBNumDevices].ServiceRtPtr =
2150: (void *)0;
2151: /* find next unused address */
2152: for (x = saveptr; x > 0; x--) {
2153: if (-1 == get_adb_info(&data, x)) {
2154: saveptr = x;
2155: break;
2156: }
2157: }
2158: if (x == 0)
2159: saveptr = 0;
2160: #ifdef ADB_DEBUG
2161: if (adb_debug & 0x80)
2162: printf_intr("new free is 0x%02x\n",
2163: saveptr);
2164: #endif
2165: nonewtimes = 0;
2166: /* tell pm driver device is here */
2167: pm_check_adb_devices(device);
2168: } else {
2169: #ifdef ADB_DEBUG
2170: if (adb_debug & 0x80)
2171: printf_intr("moving back...\n");
2172: #endif
2173: /* move old device back */
2174: command = ADBLISTEN(saveptr, 3);
2175: send_string[0] = 2;
2176: send_string[1] = (u_char)(device | 0x60);
2177: send_string[2] = 0xfe;
2178: (void)adb_op_sync((Ptr)send_string,
2179: (short)command);
2180: delay(1000);
2181: }
2182: }
2183: }
2184:
2185: #ifdef ADB_DEBUG
2186: if (adb_debug) {
2187: for (i = 1; i <= ADBNumDevices; i++) {
2188: x = get_ind_adb_info(&data, i);
2189: if (x != -1)
2190: printf_intr("index 0x%x, addr 0x%x, type 0x%hx\n",
2191: i, x, data.devType);
2192: }
2193: }
2194: #endif
2195:
2196: /* enable the programmer's switch, if we have one */
2197: adb_prog_switch_enable();
2198:
2199: #ifdef ADB_DEBUG
2200: if (adb_debug) {
2201: if (0 == ADBNumDevices) /* tell user if no devices found */
2202: printf_intr("adb: no devices found\n");
2203: }
2204: #endif
2205:
2206: adbStarting = 0; /* not starting anymore */
2207: #ifdef ADB_DEBUG
2208: if (adb_debug)
2209: printf_intr("adb: adb_reinit complete\n");
2210: #endif
2211:
2212: if (adbHardware == ADB_HW_CUDA) {
2213: timeout_set(&adb_cuda_timeout, (void *)adb_cuda_tickle, NULL);
2214: timeout_add(&adb_cuda_timeout, ADB_TICKLE_TICKS);
2215: }
2216:
2217: /* ints must be on for PB & IOP (at least, for now) */
2218: if (adbHardware != ADB_HW_PB && adbHardware != ADB_HW_IOP)
2219: splx(s);
2220: }
2221:
2222:
2223: /*
2224: * adb_cmd_result
2225: *
2226: * This routine lets the caller know whether the specified adb command string
2227: * should expect a returned result, such as a TALK command.
2228: *
2229: * returns: 0 if a result should be expected
2230: * 1 if a result should NOT be expected
2231: */
2232: int
2233: adb_cmd_result(u_char *in)
2234: {
2235: switch (adbHardware) {
2236: case ADB_HW_IOP:
2237: case ADB_HW_II:
2238: /* was it an ADB talk command? */
2239: if ((in[1] & 0x0c) == 0x0c)
2240: return 0;
2241: return 1;
2242:
2243: case ADB_HW_IISI:
2244: case ADB_HW_CUDA:
2245: /* was it an ADB talk command? */
2246: if ((in[1] == 0x00) && ((in[2] & 0x0c) == 0x0c))
2247: return 0;
2248: /* was it an RTC/PRAM read date/time? */
2249: if ((in[1] == 0x01) && (in[2] == 0x03))
2250: return 0;
2251: return 1;
2252:
2253: case ADB_HW_PB:
2254: return 1;
2255:
2256: case ADB_HW_UNKNOWN:
2257: default:
2258: return 1;
2259: }
2260: }
2261:
2262: void
2263: adb_setup_hw_type(void)
2264: {
2265: /*
2266: * Determine what type of ADB hardware we are running on.
2267: */
2268: switch (mac68k_machine.machineid) {
2269: case MACH_MACC610: /* Centris 610 */
2270: case MACH_MACC650: /* Centris 650 */
2271: case MACH_MACII: /* II */
2272: case MACH_MACIICI: /* IIci */
2273: case MACH_MACIICX: /* IIcx */
2274: case MACH_MACIIX: /* IIx */
2275: case MACH_MACQ610: /* Quadra 610 */
2276: case MACH_MACQ650: /* Quadra 650 */
2277: case MACH_MACQ700: /* Quadra 700 */
2278: case MACH_MACQ800: /* Quadra 800 */
2279: case MACH_MACSE30: /* SE/30 */
2280: adbHardware = ADB_HW_II;
2281: break;
2282:
2283: case MACH_MACCLASSICII: /* Classic II */
2284: case MACH_MACLCII: /* LC II, Performa 400/405/430 */
2285: case MACH_MACLCIII: /* LC III, Performa 450 */
2286: case MACH_MACIISI: /* IIsi */
2287: case MACH_MACIIVI: /* IIvi */
2288: case MACH_MACIIVX: /* IIvx */
2289: case MACH_MACP460: /* Performa 460/465/467 */
2290: case MACH_MACP600: /* Performa 600 */
2291: adbHardware = ADB_HW_IISI;
2292: break;
2293:
2294: case MACH_MACPB140: /* PowerBook 140 */
2295: case MACH_MACPB145: /* PowerBook 145 */
2296: case MACH_MACPB150: /* PowerBook 150 */
2297: case MACH_MACPB160: /* PowerBook 160 */
2298: case MACH_MACPB165: /* PowerBook 165 */
2299: case MACH_MACPB165C: /* PowerBook 165c */
2300: case MACH_MACPB170: /* PowerBook 170 */
2301: case MACH_MACPB180: /* PowerBook 180 */
2302: case MACH_MACPB180C: /* PowerBook 180c */
2303: case MACH_MACPB190: /* PowerBook 190 */
2304: case MACH_MACPB190CS: /* PowerBook 190cs */
2305: case MACH_MACPB210: /* PowerBook Duo 210 */
2306: case MACH_MACPB230: /* PowerBook Duo 230 */
2307: case MACH_MACPB250: /* PowerBook Duo 250 */
2308: case MACH_MACPB270: /* PowerBook Duo 270 */
2309: case MACH_MACPB280: /* PowerBook Duo 280 */
2310: case MACH_MACPB280C: /* PowerBook Duo 280c */
2311: case MACH_MACPB500: /* PowerBook 500 series */
2312: adbHardware = ADB_HW_PB;
2313: pm_setup_adb();
2314: break;
2315:
2316: case MACH_MACC660AV: /* Centris 660AV */
2317: case MACH_MACCCLASSIC: /* Color Classic */
2318: case MACH_MACCCLASSICII: /* Color Classic II */
2319: case MACH_MACLC475: /* LC 475, Performa 475/476 */
2320: case MACH_MACLC475_33: /* Clock-chipped 47x */
2321: case MACH_MACLC520: /* LC 520 */
2322: case MACH_MACLC575: /* LC 575, Performa 575/577/578 */
2323: case MACH_MACP550: /* LC 550, Performa 550 */
2324: case MACH_MACTV: /* Macintosh TV */
2325: case MACH_MACP580: /* Performa 580/588 */
2326: case MACH_MACQ605: /* Quadra 605 */
2327: case MACH_MACQ605_33: /* Clock-chipped Quadra 605 */
2328: case MACH_MACQ630: /* LC 630, Performa 630, Quadra 630 */
2329: case MACH_MACQ840AV: /* Quadra 840AV */
2330: adbHardware = ADB_HW_CUDA;
2331: break;
2332:
2333: case MACH_MACQ900: /* Quadra 900 */
2334: case MACH_MACQ950: /* Quadra 950 */
2335: case MACH_MACIIFX: /* Mac IIfx */
2336: adbHardware = ADB_HW_IOP;
2337: break;
2338:
2339: default:
2340: adbHardware = ADB_HW_UNKNOWN;
2341: break;
2342: }
2343:
2344: /*
2345: * Determine whether this machine has ADB based soft power.
2346: */
2347: switch (mac68k_machine.machineid) {
2348: case MACH_MACCCLASSIC: /* Color Classic */
2349: case MACH_MACCCLASSICII: /* Color Classic II */
2350: case MACH_MACIISI: /* IIsi */
2351: case MACH_MACIIVI: /* IIvi */
2352: case MACH_MACIIVX: /* IIvx */
2353: case MACH_MACLC520: /* LC 520 */
2354: case MACH_MACLC575: /* LC 575, Performa 575/577/578 */
2355: case MACH_MACP550: /* LC 550, Performa 550 */
2356: case MACH_MACTV: /* Macintosh TV */
2357: case MACH_MACP580: /* Performa 580/588 */
2358: case MACH_MACP600: /* Performa 600 */
2359: case MACH_MACQ630: /* LC 630, Performa 630, Quadra 630 */
2360: case MACH_MACQ840AV: /* Quadra 840AV */
2361: adbSoftPower = 1;
2362: break;
2363: }
2364: }
2365:
2366: /*
2367: * adb_op_sync
2368: *
2369: * This routine does exactly what the adb_op routine does, except that after
2370: * the adb_op is called, it waits until the return value is present before
2371: * returning.
2372: */
2373: int
2374: adb_op_sync(Ptr buffer, short command)
2375: {
2376: int tmout;
2377: int result;
2378: volatile int flag = 0;
2379:
2380: result = adb_op(buffer, (void *)adb_op_comprout, (Ptr)&flag,
2381: command); /* send command */
2382: if (result == 0) { /* send ok? */
2383: /*
2384: * Total time to wait is calculated as follows:
2385: * - Tlt (stop to start time): 260 usec
2386: * - start bit: 100 usec
2387: * - up to 8 data bytes: 64 * 100 usec = 6400 usec
2388: * - stop bit (with SRQ): 140 usec
2389: * Total: 6900 usec
2390: *
2391: * This is the total time allowed by the specification. Any
2392: * device that doesn't conform to this will fail to operate
2393: * properly on some Apple systems. In spite of this we
2394: * double the time to wait; some Cuda-based apparently
2395: * queues some commands and allows the main CPU to continue
2396: * processing (radical concept, eh?). To be safe, allow
2397: * time for two complete ADB transactions to occur.
2398: */
2399: for (tmout = 13800; !flag && tmout >= 10; tmout -= 10)
2400: delay(10);
2401: if (!flag && tmout > 0)
2402: delay(tmout);
2403:
2404: if (!flag)
2405: result = -2;
2406: }
2407:
2408: return result;
2409: }
2410:
2411: /*
2412: * adb_op_comprout
2413: *
2414: * This function is used by the adb_op_sync routine so it knows when the
2415: * function is done.
2416: */
2417: void
2418: adb_op_comprout(caddr_t buffer, caddr_t data_area, int adb_command)
2419: {
2420: *(int *)data_area = 0x01; /* update flag value */
2421: }
2422:
2423: int
2424: count_adbs(void)
2425: {
2426: int i;
2427: int found;
2428:
2429: found = 0;
2430:
2431: for (i = 1; i < 16; i++)
2432: if (0 != ADBDevTable[i].currentAddr)
2433: found++;
2434:
2435: return found;
2436: }
2437:
2438: int
2439: get_ind_adb_info(ADBDataBlock *info, int index)
2440: {
2441: if ((index < 1) || (index > 15)) /* check range 1-15 */
2442: return (-1);
2443:
2444: #ifdef ADB_DEBUG
2445: if (adb_debug & 0x80)
2446: printf_intr("index 0x%x devType is: 0x%x\n", index,
2447: ADBDevTable[index].devType);
2448: #endif
2449: if (0 == ADBDevTable[index].devType) /* make sure it's a valid entry */
2450: return (-1);
2451:
2452: info->devType = (unsigned char)(ADBDevTable[index].devType);
2453: info->origADBAddr = (unsigned char)(ADBDevTable[index].origAddr);
2454: info->dbServiceRtPtr = (Ptr)ADBDevTable[index].ServiceRtPtr;
2455: info->dbDataAreaAddr = (Ptr)ADBDevTable[index].DataAreaAddr;
2456:
2457: return (ADBDevTable[index].currentAddr);
2458: }
2459:
2460: int
2461: get_adb_info(ADBDataBlock *info, int adbAddr)
2462: {
2463: int i;
2464:
2465: if ((adbAddr < 1) || (adbAddr > 15)) /* check range 1-15 */
2466: return (-1);
2467:
2468: for (i = 1; i < 15; i++)
2469: if (ADBDevTable[i].currentAddr == adbAddr) {
2470: info->devType = (unsigned char)(ADBDevTable[i].devType);
2471: info->origADBAddr = (unsigned char)(ADBDevTable[i].origAddr);
2472: info->dbServiceRtPtr = (Ptr)ADBDevTable[i].ServiceRtPtr;
2473: info->dbDataAreaAddr = ADBDevTable[i].DataAreaAddr;
2474: return 0; /* found */
2475: }
2476:
2477: return (-1); /* not found */
2478: }
2479:
2480: int
2481: set_adb_info(ADBSetInfoBlock *info, int adbAddr)
2482: {
2483: int i;
2484:
2485: if ((adbAddr < 1) || (adbAddr > 15)) /* check range 1-15 */
2486: return (-1);
2487:
2488: for (i = 1; i < 15; i++)
2489: if (ADBDevTable[i].currentAddr == adbAddr) {
2490: ADBDevTable[i].ServiceRtPtr =
2491: (void *)(info->siServiceRtPtr);
2492: ADBDevTable[i].DataAreaAddr = info->siDataAreaAddr;
2493: return 0; /* found */
2494: }
2495:
2496: return (-1); /* not found */
2497:
2498: }
2499:
2500: /* caller should really use machine-independant version: getPramTime */
2501: /* this version does pseudo-adb access only */
2502: int
2503: adb_read_date_time(unsigned long *time)
2504: {
2505: u_char output[ADB_MAX_MSG_LENGTH];
2506: int result;
2507: volatile int flag = 0;
2508:
2509: switch (adbHardware) {
2510: case ADB_HW_IOP:
2511: case ADB_HW_II:
2512: return -1;
2513:
2514: case ADB_HW_IISI:
2515: output[0] = 0x02; /* 2 byte message */
2516: output[1] = 0x01; /* to pram/rtc device */
2517: output[2] = 0x03; /* read date/time */
2518: result = send_adb_IIsi((u_char *)output, (u_char *)output,
2519: (void *)adb_op_comprout, (void *)&flag, (int)0);
2520: if (result != 0) /* exit if not sent */
2521: return -1;
2522:
2523: while (0 == flag) /* wait for result */
2524: ;
2525:
2526: *time = (long)(*(long *)(output + 1));
2527: return 0;
2528:
2529: case ADB_HW_PB:
2530: return -1;
2531:
2532: case ADB_HW_CUDA:
2533: output[0] = 0x02; /* 2 byte message */
2534: output[1] = 0x01; /* to pram/rtc device */
2535: output[2] = 0x03; /* read date/time */
2536: result = send_adb_cuda((u_char *)output, (u_char *)output,
2537: (void *)adb_op_comprout, (void *)&flag, (int)0);
2538: if (result != 0) /* exit if not sent */
2539: return -1;
2540:
2541: while (0 == flag) /* wait for result */
2542: ;
2543:
2544: *time = (long)(*(long *)(output + 1));
2545: return 0;
2546:
2547: case ADB_HW_UNKNOWN:
2548: default:
2549: return -1;
2550: }
2551: }
2552:
2553: /* caller should really use machine-independant version: setPramTime */
2554: /* this version does pseudo-adb access only */
2555: int
2556: adb_set_date_time(unsigned long time)
2557: {
2558: u_char output[ADB_MAX_MSG_LENGTH];
2559: int result;
2560: volatile int flag = 0;
2561:
2562: switch (adbHardware) {
2563: case ADB_HW_IOP:
2564: case ADB_HW_II:
2565: return -1;
2566:
2567: case ADB_HW_IISI:
2568: output[0] = 0x06; /* 6 byte message */
2569: output[1] = 0x01; /* to pram/rtc device */
2570: output[2] = 0x09; /* set date/time */
2571: output[3] = (u_char)(time >> 24);
2572: output[4] = (u_char)(time >> 16);
2573: output[5] = (u_char)(time >> 8);
2574: output[6] = (u_char)(time);
2575: result = send_adb_IIsi((u_char *)output, (u_char *)0,
2576: (void *)adb_op_comprout, (void *)&flag, (int)0);
2577: if (result != 0) /* exit if not sent */
2578: return -1;
2579:
2580: while (0 == flag) /* wait for send to finish */
2581: ;
2582:
2583: return 0;
2584:
2585: case ADB_HW_PB:
2586: return -1;
2587:
2588: case ADB_HW_CUDA:
2589: output[0] = 0x06; /* 6 byte message */
2590: output[1] = 0x01; /* to pram/rtc device */
2591: output[2] = 0x09; /* set date/time */
2592: output[3] = (u_char)(time >> 24);
2593: output[4] = (u_char)(time >> 16);
2594: output[5] = (u_char)(time >> 8);
2595: output[6] = (u_char)(time);
2596: result = send_adb_cuda((u_char *)output, (u_char *)0,
2597: (void *)adb_op_comprout, (void *)&flag, (int)0);
2598: if (result != 0) /* exit if not sent */
2599: return -1;
2600:
2601: while (0 == flag) /* wait for send to finish */
2602: ;
2603:
2604: return 0;
2605:
2606: case ADB_HW_UNKNOWN:
2607: default:
2608: return -1;
2609: }
2610: }
2611:
2612:
2613: int
2614: adb_poweroff(void)
2615: {
2616: u_char output[ADB_MAX_MSG_LENGTH];
2617: int result;
2618:
2619: if (!adbSoftPower)
2620: return -1;
2621:
2622: adb_polling = 1;
2623:
2624: switch (adbHardware) {
2625: case ADB_HW_IISI:
2626: output[0] = 0x02; /* 2 byte message */
2627: output[1] = 0x01; /* to pram/rtc/soft-power device */
2628: output[2] = 0x0a; /* set date/time */
2629: result = send_adb_IIsi((u_char *)output, (u_char *)0,
2630: (void *)0, (void *)0, (int)0);
2631: if (result != 0) /* exit if not sent */
2632: return -1;
2633:
2634: for (;;); /* wait for power off */
2635:
2636: return 0;
2637:
2638: case ADB_HW_PB:
2639: return -1;
2640:
2641: case ADB_HW_CUDA:
2642: output[0] = 0x02; /* 2 byte message */
2643: output[1] = 0x01; /* to pram/rtc/soft-power device */
2644: output[2] = 0x0a; /* set date/time */
2645: result = send_adb_cuda((u_char *)output, (u_char *)0,
2646: (void *)0, (void *)0, (int)0);
2647: if (result != 0) /* exit if not sent */
2648: return -1;
2649:
2650: for (;;); /* wait for power off */
2651:
2652: return 0;
2653:
2654: case ADB_HW_IOP: /* IOP models don't do ADB soft power */
2655: case ADB_HW_II: /* II models don't do ADB soft power */
2656: case ADB_HW_UNKNOWN:
2657: default:
2658: return -1;
2659: }
2660: }
2661:
2662: int
2663: adb_prog_switch_enable(void)
2664: {
2665: u_char output[ADB_MAX_MSG_LENGTH];
2666: int result;
2667: volatile int flag = 0;
2668:
2669: switch (adbHardware) {
2670: case ADB_HW_IISI:
2671: output[0] = 0x03; /* 3 byte message */
2672: output[1] = 0x01; /* to pram/rtc/soft-power device */
2673: output[2] = 0x1c; /* prog. switch control */
2674: output[3] = 0x01; /* enable */
2675: result = send_adb_IIsi((u_char *)output, (u_char *)0,
2676: (void *)adb_op_comprout, (void *)&flag, (int)0);
2677: if (result != 0) /* exit if not sent */
2678: return -1;
2679:
2680: while (0 == flag) /* wait for send to finish */
2681: ;
2682:
2683: return 0;
2684:
2685: case ADB_HW_PB:
2686: return -1;
2687:
2688: case ADB_HW_II: /* II models don't do prog. switch */
2689: case ADB_HW_IOP: /* IOP models don't do prog. switch */
2690: case ADB_HW_CUDA: /* cuda doesn't do prog. switch TO DO: verify this */
2691: case ADB_HW_UNKNOWN:
2692: default:
2693: return -1;
2694: }
2695: }
2696:
2697: #if 0
2698: int
2699: adb_prog_switch_disable(void)
2700: {
2701: u_char output[ADB_MAX_MSG_LENGTH];
2702: int result;
2703: volatile int flag = 0;
2704:
2705: switch (adbHardware) {
2706: case ADB_HW_IISI:
2707: output[0] = 0x03; /* 3 byte message */
2708: output[1] = 0x01; /* to pram/rtc/soft-power device */
2709: output[2] = 0x1c; /* prog. switch control */
2710: output[3] = 0x01; /* disable */
2711: result = send_adb_IIsi((u_char *)output, (u_char *)0,
2712: (void *)adb_op_comprout, (void *)&flag, (int)0);
2713: if (result != 0) /* exit if not sent */
2714: return -1;
2715:
2716: while (0 == flag) /* wait for send to finish */
2717: ;
2718:
2719: return 0;
2720:
2721: case ADB_HW_PB:
2722: return -1;
2723:
2724: case ADB_HW_II: /* II models don't do prog. switch */
2725: case ADB_HW_IOP: /* IOP models don't do prog. switch */
2726: case ADB_HW_CUDA: /* cuda doesn't do prog. switch */
2727: case ADB_HW_UNKNOWN:
2728: default:
2729: return -1;
2730: }
2731: }
2732: #endif
2733:
2734: /*
2735: * Function declarations.
2736: */
2737: int adbmatch(struct device *, void *, void *);
2738: void adbattach(struct device *, struct device *, void *);
2739: void adb_attach_deferred(void *);
2740:
2741: /*
2742: * Driver definition.
2743: */
2744: struct cfattach adb_ca = {
2745: sizeof(struct device), adbmatch, adbattach
2746: };
2747:
2748: int
2749: adbmatch(struct device *parent, void *vcf, void *aux)
2750: {
2751: static int adb_matched = 0;
2752:
2753: /* Allow only one instance. */
2754: if (adb_matched)
2755: return (0);
2756:
2757: adb_matched = 1;
2758: return (1);
2759: }
2760:
2761: void
2762: adbattach(struct device *parent, struct device *self, void *aux)
2763: {
2764: adb_setup_hw_type(); /* setup hardware type */
2765: printf(": %s\n", adbHardwareDescr[adbHardware]);
2766: startuphook_establish(adb_attach_deferred, self);
2767: }
2768:
2769: void
2770: adb_attach_deferred(void *v)
2771: {
2772: struct device *self = v;
2773: ADBDataBlock adbdata;
2774: struct adb_attach_args aa_args;
2775: int totaladbs;
2776: int adbindex, adbaddr;
2777:
2778: printf("%s: ", self->dv_xname);
2779: adb_polling = 1;
2780: adb_reinit(self);
2781:
2782: #ifdef ADB_DEBUG
2783: if (adb_debug)
2784: printf("adb: done with adb_reinit\n");
2785: #endif
2786:
2787: totaladbs = count_adbs();
2788:
2789: printf("%d target%s\n", totaladbs, (totaladbs == 1) ? "" : "s");
2790:
2791: /* for each ADB device */
2792: for (adbindex = 1; adbindex <= totaladbs; adbindex++) {
2793: /* Get the ADB information */
2794: adbaddr = get_ind_adb_info(&adbdata, adbindex);
2795:
2796: aa_args.origaddr = (int)(adbdata.origADBAddr);
2797: aa_args.adbaddr = adbaddr;
2798: aa_args.handler_id = (int)(adbdata.devType);
2799:
2800: (void)config_found(self, &aa_args, adbprint);
2801: }
2802: adb_polling = 0;
2803: }