![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cuda.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvCuda|
Return to cuda.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvCuda |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25:
26: /*********
27:
28: cuda.m
29:
30: This file is a combination of the old cuda.c and the new pmu.m for PGE.
31: Cuda is based on a Motorola MC68HC05E1.
32:
33: NOTES:
34:
35: "WARNING" look for this string during integration.
36: cuda interrupts are cleared by reading the shift register.
37: cuda has a TIP (transaction in progress) signal which the PGE seems to lack.
38: PGE seems to require a "length" byte in command packets while cuda does not.
39: Signals:
40: TIP is asserted when 0. System asserts this when transaction is in progress.
41: BYTEACK is asserted when 0. When data is passed from the system to Cuda,
42: a toggle indicates to Cuda that the VIA data register is full. When
43: data is passed from Cuda to the system, a toggle indicates that the
44: system has read the data from the VIA and the VIA data register
45: is now empty. When no transaction in progress (note TIP), this
46: line is deasserted.
47: TREQ is asserted when 0. When asserted by Cuda, this indicates to the system
48: that Cuda is making a Transaction REQUEST. During a transaction which
49: is initiated by Cuda (as opposed to one initiated by system), this line
50: is negated prior to generating a VIA interrupt for the last byte
51: of data transacted. When no transaction is in progress (note TIP),
52: this line is negated.
53:
54:
55: *********/
56:
57:
58: #include <sys/param.h> //for sysctl
59: #include <sys/proc.h> //for sysctl also (but not documented)
60:
61: #import <kern/clock.h>
62: #import <kernserv/prototypes.h>
63: #import <kernserv/clock_timer.h>
64: #import <kernserv/ns_timer.h>
65: #import <sys/time.h>
66: #import <sys/callout.h>
67: #import <machdep/ppc/proc_reg.h>
68: #import <driverkit/generalFuncs.h>
69: #import <driverkit/kernelDriver.h>
70: #import <driverkit/interruptMsg.h>
71:
72: #import <bsd/dev/ppc/drvPMU/pmu.h>
73: #import <bsd/dev/ppc/drvPMU/pmupriv.h>
74: #import <bsd/dev/ppc/drvPMU/pmumisc.h>
75: #include <sys/sysctl.h> //for debug2, debug3, debug4 in sysctl
76: #import "via6522.h"
77: #import "cuda_hdw.h"
78: #import "cuda.h" //must come after pmu definitions
79:
80: //typedefs from cuda.c:
81: //
82: // CudaInterruptState - internal
83: //
84: //#define kNS_TIMEOUT_AUTOPOLL 9000000000ULL
85: #define kNS_TIMEOUT_AUTOPOLL 4000000000ULL
86:
87: enum CudaInterruptState
88: {
89: CUDA_STATE_INTERRUPT_LIMBO = -1, //
90: CUDA_STATE_IDLE = 0, //
91: CUDA_STATE_ATTN_EXPECTED = 1, //
92: CUDA_STATE_TRANSMIT_EXPECTED = 2, //
93: CUDA_STATE_RECEIVE_EXPECTED = 3 //
94: };
95:
96: typedef enum CudaInterruptState CudaInterruptState;
97:
98:
99: //
100: // CudaTransactionFlag - internal to cuda2.m, used to be in cuda.c
101: //
102:
103: enum CudaTransactionFlag
104: {
105: CUDA_TS_NO_REQUEST = 0x0000,
106: CUDA_TS_SYNC_RESPONSE = 0x0001,
107: CUDA_TS_ASYNC_RESPONSE = 0x0002
108: };
109:
110: typedef enum CudaTransactionFlag CudaTransactionFlag;
111:
112:
113: void gotInterruptCause(id, UInt32, UInt32, UInt8 *);
114: void cuda_timer_autopoll(port_t mach_port);
115: void timer_expired(port_t mach_port); //WARNING... not needed by Cuda? Was not in cuda.c
116:
117: extern id ApplePMUId; //in adb.m (remove this when adb becomes an indirect driver)(q8q)
118:
119: extern void kprintf(const char *, ...);
120: extern void bcopy(void *, void *, int);
121: // extern to let us fix up the boot time.
122: extern void set_boot_time(void);
123: extern msg_send_from_kernel(msg_header_t *, int, int);
124:
125: // Variables copied from cuda.c:
126: static long cuda_state_transition_delay_ticks;
127: volatile CudaInterruptState cuda_interrupt_state;
128: volatile CudaTransactionFlag cuda_transaction_state;
129: static port_t glob_port;
130:
131: //WARNING Hack to make pmutables.h work
132: extern SInt8 *cmdLengthTable;
133: extern SInt8 *rspLengthTable;
134:
135:
136: CudaRequest *cuda_request = NULL, *cuda_collided = NULL;
137: adb_packet_t cuda_unsolicited;
138: adb_packet_t *cuda_current_response = NULL;
139:
140: int cuda_transfer_count = 0;
141: boolean_t cuda_is_header_transfer = FALSE;
142: boolean_t cuda_is_packet_type = FALSE;
143: boolean_t cuda_initted = FALSE;
144: boolean_t debugging = FALSE;
145: boolean_t adb_reading = FALSE;
146:
147: static UInt8 *return_buff_pointer = NULL;
148: static boolean_t bImmediate_buff_needed = FALSE;
149:
150: // for Debug
151: pmADBinput_func cuda_debug_client; // Input handler in ADB client
152: static VIAAddress stat_aux_control;
153: static boolean_t p = FALSE;
154: int que_cuda_count;
155: int cuda_glob_dbug_freeze; //Can only be asserted through debugging tool
156: int cuda_glob_data1;
157: int cuda_glob_data2;
158: int cuda_freeze_counter; //This will become "static" after debugging phase
159: int cuda_freeze_prevcount;
160:
161: //sysctl debugging tool
162: struct ctldebug debug2 = { "cuda_glob_dbug_freeze", &cuda_glob_dbug_freeze };
163: //struct ctldebug debug3 = { "cuda_glob_data1", &cuda_glob_data1 };
164: //struct ctldebug debug4 = { "cuda_glob_data2", &cuda_glob_data2 };
165:
166:
167: @implementation AppleCuda
168:
169: // **********************************************************************************
170: // probe
171: //
172: //
173: //
174: // **********************************************************************************
175: + (Boolean) probe : deviceDescription
176: {
177: id dev;
178:
179: if (cuda_initted)
180: return 1;
181:
182: cuda_initted = TRUE;
183: que_cuda_count = 0;
184: cuda_glob_dbug_freeze = 0; // 0. Only external debugger can change it now.
185: cuda_freeze_counter = 1; //2 vars needed to recover from BYTEACK hang
186: cuda_freeze_prevcount = 0;
187:
188: if ( (dev = [ self alloc ]) == nil ) {
189: return NO;
190: }
191:
192: if ([dev initFromDeviceDescription:deviceDescription] == nil) {
193: return NO;
194: }
195:
196: // tell ADB about us. This is a global variable accessible in adb.m
197: ApplePMUId = dev;
198:
199: set_boot_time();
200:
201: return YES;
202: }
203:
204:
205: // **********************************************************************************
206: // initFromDeviceDescription
207: //
208: //
209: //
210: // **********************************************************************************
211: - initFromDeviceDescription:(IODeviceDescription *)deviceDescription
212: {
213: volatile unsigned char valcuda;
214: VIAAddress physicalAddress;
215: IORange * ioRange;
216: unsigned char *cuda_temp_reg;
217:
218: struct timeval x = {0,1000000}; // one second timeout on adb reads
219:
220: auto_power_on = 1; //default is to enable auto power on feature (after electrical power failure)
221:
222: if ( [super initFromDeviceDescription:deviceDescription] == nil ) {
223: [self free];
224: return nil;
225: }
226:
227: [self setDeviceKind:"Cuda Subsystem"];
228: [self setLocation:NULL];
229: [self setName:"Cuda"];
230:
231:
232: ioRange = [deviceDescription memoryRangeList];
233:
234: physicalAddress = (VIAAddress)ioRange->start;
235: stat_aux_control = physicalAddress;
236:
237: //above works perfectly physicalAddress = (unsigned char*)POWERMAC_IO(PCI_VIA_BASE_PHYS);
238:
239:
240: //CUDA_REPLACE
241:
242:
243: VIA1_shift = physicalAddress + 0x1400; // initialize VIA addresses
244: VIA1_auxillaryControl = physicalAddress + 0x1600;
245:
246: VIA1_interruptFlag = physicalAddress + 0x1A00;
247: VIA1_interruptEnable = physicalAddress + 0x1C00;
248: VIA2_dataB = physicalAddress + 0x0000; // Hooper uses VIA 1 instead
249:
250:
251: PMack = kCudaAssertByteAcknowledge; //in cuda_hdw.h is 0x10
252:
253:
254:
255: cuda_state_transition_delay_ticks = nsec_to_processor_clock_ticks(200);
256: //This is just 2 ticks
257: // Set the direction of the cuda signals. ByteACk and TIP are output and
258: // TREQ is an input
259:
260: cuda_temp_reg = physicalAddress + 0x0400; //dataDirectionB
261: *cuda_temp_reg |= (kCudaByteAcknowledgeMask | kCudaTransferInProgressMask);
262: *cuda_temp_reg &= ~kCudaTransferRequestMask;
263:
264: *VIA1_auxillaryControl = ( *VIA1_auxillaryControl | kCudaTransferMode) &
265: kCudaSystemRecieve;
266:
267: // Clear any posible cuda interupt.
268: if ( *VIA1_shift );
269:
270: // Initialize the internal data.
271:
272: cuda_interrupt_state = CUDA_STATE_IDLE;
273: cuda_transaction_state = CUDA_TS_NO_REQUEST;
274: cuda_is_header_transfer = FALSE;
275: cuda_is_packet_type = FALSE;
276: cuda_transfer_count = 0;
277: cuda_current_response = NULL;
278:
279: // Terminate transaction and set idle state
280: // cuda_neg_tip_and_byteack();
281: *VIA2_dataB |= kCudaNegateByteAcknowledge | kCudaNegateTransferInProgress;
282: eieio();
283:
284: // we want to delay 4 mS for ADB reset to complete
285:
286: delay(4000);
287:
288: // Clear pending interrupt if any...
289: //(void)cuda_read_data();
290: valcuda = *VIA1_shift; eieio();
291:
292: // Issue a Sync Transaction, ByteAck asserted while TIP is negated.
293: // cuda_assert_byte_ack();
294: *VIA2_dataB &= kCudaAssertByteAcknowledge; eieio();
295:
296:
297: // Wait for the Sync acknowledgement, cuda to assert TREQ
298: // cuda_wait_for_transfer_request_assert();
299: while ( (*VIA2_dataB & kCudaTransferRequestMask) != 0 )
300: {
301: eieio();
302: }
303: eieio();
304:
305: // Wait for the Sync acknowledgement interrupt.
306: // cuda_wait_for_interrupt();
307: while ( (*VIA1_interruptFlag & kCudaInterruptMask) == 0 )
308: {
309: eieio();
310: }
311: eieio();
312:
313:
314: // Clear pending interrupt
315: //(void)cuda_read_data();
316: valcuda = *VIA1_shift; eieio();
317:
318: // Terminate the sync cycle by Negating ByteAck
319: // cuda_neg_byte_ack();
320: *VIA2_dataB |= kCudaNegateByteAcknowledge; eieio();
321:
322: // Wait for the Sync termination acknowledgement, cuda negates TREQ.
323: // cuda_wait_for_transfer_request_neg();
324: while ( (*VIA2_dataB & kCudaTransferRequestMask) == 0 )
325: {
326: eieio();
327: }
328: eieio();
329:
330:
331: // Wait for the Sync termination acknowledgement interrupt.
332: // cuda_wait_for_interrupt();
333: while ( (*VIA1_interruptFlag & kCudaInterruptMask) == 0 )
334: {
335: eieio();
336: }
337: eieio();
338:
339:
340: // Terminate transaction and set idle state, TIP negate and ByteAck negate.
341: // cuda_neg_transfer_in_progress();
342: *VIA2_dataB |= kCudaNegateTransferInProgress; eieio();
343:
344: // Clear pending interrupt, if there is one...
345: //(void)cuda_read_data();
346: valcuda = *VIA1_shift; eieio();
347:
348:
349:
350:
351:
352: ADBclient = NULL;
353: RTCclient = NULL;
354: debugging = FALSE;
355: queueHead = NULL;
356: queueTail = NULL;
357: adb_reading = FALSE;
358: adb_read_timeout = timeval_to_ns_time(&x);
359:
360: //CUDA_REPLACE
361: // A.W. This call seems to have no counterpart in Cuda
362: // Pending interrupts are cleared with cuda_read_data()
363: *VIA1_interruptEnable = kCudaInterruptDisable;eieio(); // turn off any pending interrupt
364: valcuda = *VIA1_shift; eieio();
365:
366: [self EnableCudaInterrupt]; // enable PGE interrupts. CUDA_REPLACE already
367:
368: [self enableAllInterrupts];
369:
370: //WARNING... this was moved here in new pmu.m
371: if ([self startIOThread] != IO_R_SUCCESS) {
372: [self free];
373: return nil;
374: }
375: port = IOConvertPort([self interruptPort],IO_KernelIOTask,IO_Kernel);
376: glob_port = port; //needed for non-ObjC functions
377: [self registerDevice];
378:
379:
380: //A.W. I don't think Cuda needs to exclude any interrupts
381: //I need to set up a 5-second timer which will make sure that the Auto Poll
382: // feature of Cuda is never accidentally disabled by anybody
383: ns_timeout((func)cuda_timer_autopoll,(void *)port, kNS_TIMEOUT_AUTOPOLL ,CALLOUT_PRI_SOFTINT0); // start timer
384:
385:
386: return self;
387: }
388:
389:
390: // **********************************************************************************
391: // free
392: //
393: //
394: //
395: // **********************************************************************************
396: - free
397: {
398: return [ super free ];
399: }
400:
401:
402: // **********************************************************************************
403: // receiveMsg
404: //
405: //
406: //
407: // **********************************************************************************
408:
409:
410: - (void)receiveMsg
411: {
412: CudaMachMessage * toQueue;
413: IOReturn result;
414: spl_t intstate;
415: //unsigned char interruptState;
416:
417: //interruptState = (*VIA2_dataB & kCudaInterruptStateMask) | (*VIA1_auxillaryControl & kCudaDirectionMask) ;
418: //if ( (interruptState == kCudaIdleState) && !adb_reading )
419:
420: if (cuda_interrupt_state == CUDA_STATE_IDLE)
421: {
422:
423: if (p) kprintf("cuda2.m::receiveMsg will Xmit now... \n");
424: //localMachMessage is class variable in cuda.h
425: localMachMessage.msgHeader.msg_size = sizeof(CudaMachMessage);
426: localMachMessage.msgHeader.msg_local_port = [self interruptPort];
427: result = msg_receive(&localMachMessage.msgHeader, (msg_option_t)RCV_TIMEOUT, 0);
428:
429: #ifdef OMIT
430: if ( localMachMessage.msgBody.pmCallback == NULL )
431: {
432: kprintf("ADAM: receiveMsg no callback\n");
433: }
434: #endif
435:
436: if ( result == RCV_SUCCESS ) {
437: //Try Simon's suggestion
438: intstate = spltty();
439: [self StartCudaTransmission:&localMachMessage.msgBody];
440: splx(intstate);
441: }
442: }
443: else
444: {
445: if (p) kprintf("cuda2.m::receiveMsg will enqueue instead \n");
446:
447: #ifdef DEBUG
448: if (cuda_glob_dbug_freeze == 1)
449: {
450: kprintf("cuda: Queued\n");
451: }
452: #endif
453:
454: toQueue = (CudaMachMessage*)kalloc(sizeof(CudaMachMessage));
455: toQueue->msgHeader.msg_size = sizeof(CudaMachMessage);
456: toQueue->msgHeader.msg_local_port = [self interruptPort];
457: result = msg_receive(&toQueue->msgHeader, (msg_option_t)RCV_TIMEOUT, 0);
458: if ( result == RCV_SUCCESS ) {
459: toQueue->msgBody.prev = queueTail;
460: toQueue->msgBody.next = NULL;
461: if ( queueTail != NULL ) {
462: queueTail->msgBody.next = toQueue;
463: }
464: else
465: {
466: queueHead = toQueue;
467: }
468: queueTail = toQueue;
469: }
470: }
471: }
472:
473:
474:
475:
476:
477:
478:
479: // **********************************************************************************
480: // timeoutOccurred
481: //
482: // Our adb-read timer has expired after sending an adb-read command to the PMU.
483: // This means there is no such addressed device on the ADB bus.
484: // We call back to the ADB driver with a zero-characters-received response and
485: // dequeue our command queue and carry on.
486: // **********************************************************************************
487: - (void)timeoutOccurred
488: {
489: adb_reading = FALSE;
490: if ( clientRequest->pmCallback != NULL ) { // Make the client callback
491: clientRequest->pmCallback(clientRequest->pmId, clientRequest->pmRefNum, 0, NULL);
492: } // with zero received-length
493: [self CheckRequestQueue];
494: }
495:
496:
497: // ****************************************************************************
498: // CheckRequestQueue
499: // Called at interrupt time when current request is complete. We may start
500: // another request here if one is in queue, or we may re-enable PMU interrupts
501: // (they were turned off in PMUStartIO) and return.
502: // ****************************************************************************
503:
504: - (void)CheckRequestQueue
505: {
506: CudaMachMessage * nextRequest;
507:
508: if ( queueHead == NULL ) { // is queue empty?
509: if (p) kprintf("cuda2.m::CheckRequestQueue empty \n");
510: [self EnableCudaInterrupt]; // yes, enable interrupt and return
511: }
512: else
513: {
514: que_cuda_count--;
515: if (p) kprintf("cuda2.m::CheckRequestQueue will dequeue \n");
516: nextRequest = queueHead; // no, dequeue first command
517: queueHead = nextRequest->msgBody.next;
518: if ( queueHead == NULL ) {
519: queueTail = NULL;
520: }
521: bcopy (&nextRequest->msgBody, &localMachMessage.msgBody, sizeof(CudaRequest)); // copy it
522: kfree(nextRequest, sizeof(CudaMachMessage)); // free its memory
523: [self StartCudaTransmission:&localMachMessage.msgBody]; // and send it to the Cuda
524: }
525: }
526:
527:
528:
529:
530: // **********************************************************************************
531: // registerForADBAutopoll
532: //
533: // The ADB driver is calling to tell us that it is prepared to receive
534: // "unsolicited" ADB autopoll data. The parameter tells who to call
535: // when we get some.
536: //
537: // **********************************************************************************
538: - (void)registerForADBAutopoll :(pmCallback_func)InputHandler
539: :(id)caller
540: {
541: if (p) kprintf("registerForADBAutopoll: %08x caller: %08x\n", InputHandler, caller);
542: ADBclient = InputHandler;
543: cuda_debug_client = ADBclient; // Debug use only
544: ADBid = caller;
545: }
546:
547:
548: // **********************************************************************************
549: // ADBWrite
550: //
551: // **********************************************************************************
552: - (PMUStatus)ADBWrite :(UInt32)DevAddr
553: :(UInt32)DevReg
554: :(UInt32)ByteCount
555: :(UInt8*)Buffer
556: :(UInt32)RefNum
557: :(id)Id
558: :(pmCallback_func)Callback
559: {
560: CudaMachMessage request;
561: msg_return_t return_code;
562:
563: if (p) kprintf("ADBWrite\n");
564:
565: if (ByteCount > 7)
566: {
567: kprintf("bsd-dev-ppc-drvCuda-cuda.m: ADBWrite may fail\n");
568: }
569:
570: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_ADB;
571: request.msgBody.a_cmd.a_header[1] = ADB_ADBCMD_WRITE_ADB | DevAddr << 4 | DevReg;
572: request.msgBody.a_cmd.a_header[2] = Buffer[0];
573: request.msgBody.a_cmd.a_header[3] = Buffer[1];
574: request.msgBody.a_cmd.a_header[4] = Buffer[2]; //necessary?
575: request.msgBody.a_cmd.a_header[5] = Buffer[3];
576: request.msgBody.a_cmd.a_header[6] = Buffer[4];
577: request.msgBody.a_cmd.a_header[7] = Buffer[5];
578: request.msgBody.a_cmd.a_header[8] = Buffer[6];
579:
580: //request.msgBody.a_cmd.a_hcount = 4;
581: request.msgBody.a_cmd.a_hcount = ByteCount + 2;
582: //Dave added unlimited-length adb_writereg()
583:
584: request.msgBody.a_cmd.a_bcount = 0;
585: request.msgBody.pmCallback = Callback;
586:
587: #ifdef OMIT
588: if (Callback == NULL)
589: {
590: kprintf("Cuda: ADBWrite callback is NULL\n");
591: }
592: #endif
593:
594: request.msgBody.pmId = Id;
595: request.msgBody.pmRefNum = RefNum;
596:
597: request.msgHeader.msg_simple = TRUE;
598: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
599: request.msgHeader.msg_remote_port = port;
600: request.msgHeader.msg_local_port = PORT_NULL;
601: request.msgHeader.msg_size = sizeof(CudaMachMessage);
602: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
603:
604: if ( return_code == SEND_SUCCESS ) {
605: return kPMUNoError;
606: }
607: else {
608: return kPMUIOError;
609: }
610: }
611:
612:
613: // **********************************************************************************
614: // ADBRead
615: //
616: // **********************************************************************************
617: - (PMUStatus)ADBRead :(UInt32)DevAddr
618: :(UInt32)DevReg
619: :(UInt32)RefNum
620: :(id)Id
621: :(pmCallback_func)Callback
622: {
623: CudaMachMessage request;
624: msg_return_t return_code;
625:
626: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_ADB;
627: request.msgBody.a_cmd.a_header[1] = ADB_ADBCMD_READ_ADB | DevAddr << 4 | DevReg;
628: request.msgBody.a_cmd.a_hcount = 2;
629: //request.msgBody.a_cmd.a_bsize = sizeof(request.msgBody.a_cmd.a_buffer);
630: request.msgBody.a_reply.a_bsize = 8; //It's 8 in adb.h
631: //WARNING... try out line above 3/4/98 TitanL kernel
632:
633: request.msgBody.a_cmd.a_bcount = 0;
634: request.msgBody.pmCallback = Callback;
635:
636: #ifdef OMIT
637: if (Callback == NULL)
638: {
639: kprintf("Cuda: ADBRead callback is NULL\n");
640: }
641: #endif
642:
643: request.msgBody.pmId = Id;
644: request.msgBody.pmRefNum = RefNum;
645:
646: request.msgHeader.msg_simple = TRUE;
647: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
648: request.msgHeader.msg_remote_port = port;
649: request.msgHeader.msg_local_port = PORT_NULL;
650: request.msgHeader.msg_size = sizeof(CudaMachMessage);
651: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
652:
653: if ( return_code == SEND_SUCCESS ) {
654: return kPMUNoError;
655: }
656: else {
657: return kPMUIOError;
658: }
659: }
660:
661:
662: // **********************************************************************************
663: // ADBReset
664: //
665: // **********************************************************************************
666: - (PMUStatus)ADBReset :(UInt32)RefNum
667: :(id)Id
668: :(pmCallback_func)Callback
669: {
670: CudaMachMessage request;
671: msg_return_t return_code;
672:
673: kprintf("CUDA: ADBReset\n");
674: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_ADB;
675: request.msgBody.a_cmd.a_header[1] = ADB_ADBCMD_RESET_BUS;
676: request.msgBody.a_cmd.a_hcount = 2;
677: request.msgBody.a_cmd.a_bcount = 0;
678: request.msgBody.pmCallback = Callback;
679: request.msgBody.pmId = Id;
680: request.msgBody.pmRefNum = RefNum;
681:
682: request.msgHeader.msg_simple = TRUE;
683: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
684: request.msgHeader.msg_remote_port = port;
685: request.msgHeader.msg_local_port = PORT_NULL;
686: request.msgHeader.msg_size = sizeof(CudaMachMessage);
687: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
688:
689: if ( return_code == SEND_SUCCESS ) {
690: return kPMUNoError;
691: }
692: else {
693: return kPMUIOError;
694: }
695: }
696:
697:
698: // **********************************************************************************
699: // ADBFlush
700: //
701: // **********************************************************************************
702: - (PMUStatus)ADBFlush :(UInt32)DevAddr
703: :(UInt32)RefNum
704: :(id)Id
705: :(pmCallback_func)Callback
706: {
707: CudaMachMessage request;
708: msg_return_t return_code;
709:
710: if (p) kprintf("ADBFlush\n");
711: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_ADB;
712: request.msgBody.a_cmd.a_header[1] = ADB_ADBCMD_FLUSH_ADB | (DevAddr << 4);
713: request.msgBody.a_cmd.a_hcount = 2;
714: request.msgBody.a_cmd.a_bcount = 0;
715: request.msgBody.pmId = Id;
716: request.msgBody.pmRefNum = RefNum;
717: request.msgBody.pmCallback = Callback;
718:
719: request.msgHeader.msg_simple = TRUE;
720: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
721: request.msgHeader.msg_remote_port = port;
722: request.msgHeader.msg_local_port = PORT_NULL;
723: request.msgHeader.msg_size = sizeof(CudaMachMessage);
724: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
725:
726: if ( return_code == SEND_SUCCESS ) {
727: return kPMUNoError;
728: }
729: else {
730: return kPMUIOError;
731: }
732: }
733:
734:
735: // **********************************************************************************
736: // ADBSetPollList
737: //
738: //
739: // **********************************************************************************
740: - (PMUStatus)ADBSetPollList :(UInt32)PollBitField
741: :(UInt32)RefNum
742: :(id)Id
743: :(pmCallback_func)Callback
744: {
745: CudaMachMessage request;
746: msg_return_t return_code;
747:
748: if (p) kprintf("ADBSetPollList\n");
749: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
750: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_SET_DEVICE_LIST;
751: request.msgBody.a_cmd.a_header[2] = (PollBitField >> 8) & 0xFF;
752: request.msgBody.a_cmd.a_header[3] = PollBitField & 0xFF;
753: request.msgBody.a_cmd.a_hcount = 4;
754: request.msgBody.a_cmd.a_bcount = 0;
755: request.msgBody.pmRefNum = RefNum;
756: request.msgBody.pmId = Id;
757: request.msgBody.pmCallback = Callback;
758:
759: #ifdef OMIT
760: if (Callback == NULL)
761: {
762: kprintf("Cuda: ADBSetPollList callback is NULL\n");
763: }
764: #endif
765:
766:
767: request.msgHeader.msg_simple = TRUE;
768: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
769: request.msgHeader.msg_remote_port = port;
770: request.msgHeader.msg_local_port = PORT_NULL;
771: request.msgHeader.msg_size = sizeof(CudaMachMessage);
772: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
773:
774: if ( return_code == SEND_SUCCESS ) {
775: return kPMUNoError;
776: }
777: else {
778: return kPMUIOError;
779: }
780: }
781:
782:
783:
784:
785: // **********************************************************************************
786: // ADBSetFileServerMode()
787: //
788: // **********************************************************************************
789: - (PMUStatus)ADBSetFileServerMode :(UInt32)RefNum
790: :(id)Id
791: :(pmCallback_func)Callback
792:
793: {
794: CudaMachMessage request;
795: msg_return_t return_code;
796:
797: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
798: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_FILE_SERVER_FLAG;
799: request.msgBody.a_cmd.a_header[2] = TRUE;
800: request.msgBody.a_cmd.a_hcount = 3;
801: request.msgBody.a_cmd.a_bcount = 0;
802: request.msgBody.pmRefNum = RefNum;
803: request.msgBody.pmId = Id;
804: request.msgBody.pmCallback = Callback;
805:
806: request.msgHeader.msg_simple = TRUE;
807: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
808: request.msgHeader.msg_remote_port = port;
809: request.msgHeader.msg_local_port = PORT_NULL;
810: request.msgHeader.msg_size = sizeof(CudaMachMessage);
811: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
812:
813: if ( return_code == SEND_SUCCESS ) {
814: return kPMUNoError;
815: }
816: else {
817: return kPMUIOError;
818: }
819: }
820:
821:
822: // **********************************************************************************
823: // ADBPollEnable
824: //
825: // **********************************************************************************
826: - (PMUStatus)ADBPollEnable :(UInt32)RefNum
827: :(id)Id
828: :(pmCallback_func)Callback
829:
830: {
831: CudaMachMessage request;
832: msg_return_t return_code;
833:
834: if (p) kprintf("ADBPollEnable\n");
835: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
836: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_START_STOP_AUTO_POLL;
837: request.msgBody.a_cmd.a_header[2] = TRUE;
838: request.msgBody.a_cmd.a_hcount = 3;
839: request.msgBody.a_cmd.a_bcount = 0;
840: request.msgBody.pmRefNum = RefNum;
841: request.msgBody.pmId = Id;
842: request.msgBody.pmCallback = Callback;
843:
844: request.msgHeader.msg_simple = TRUE;
845: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
846: request.msgHeader.msg_remote_port = port;
847: request.msgHeader.msg_local_port = PORT_NULL;
848: request.msgHeader.msg_size = sizeof(CudaMachMessage);
849: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
850:
851: if ( return_code == SEND_SUCCESS ) {
852: return kPMUNoError;
853: }
854: else {
855: return kPMUIOError;
856: }
857: }
858:
859:
860: // **********************************************************************************
861: // ADBPollDisable
862: //
863: // **********************************************************************************
864: - (PMUStatus)ADBPollDisable :(UInt32)RefNum
865: :(id)Id
866: :(pmCallback_func)Callback
867: {
868: CudaMachMessage request;
869: msg_return_t return_code;
870:
871: if (p) kprintf("ADBPollDisable\n");
872: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
873: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_START_STOP_AUTO_POLL;
874: request.msgBody.a_cmd.a_header[2] = FALSE;
875: request.msgBody.a_cmd.a_hcount = 3;
876: request.msgBody.a_cmd.a_bcount = 0;
877: request.msgBody.pmRefNum = RefNum;
878: request.msgBody.pmId = Id;
879: request.msgBody.pmCallback = Callback;
880:
881: request.msgHeader.msg_simple = TRUE;
882: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
883: request.msgHeader.msg_remote_port = port;
884: request.msgHeader.msg_local_port = PORT_NULL;
885: request.msgHeader.msg_size = sizeof(CudaMachMessage);
886: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
887:
888: if ( return_code == SEND_SUCCESS ) {
889: return kPMUNoError;
890: }
891: else {
892: return kPMUIOError;
893: }
894: }
895:
896:
897: // **********************************************************************************
898: // ADBSetPollRate
899: //
900: // **********************************************************************************
901: - (PMUStatus)ADBSetPollRate :(UInt32)NewRate
902: :(UInt32)RefNum
903: :(id)Id
904: :(pmCallback_func)Callback
905: {
906: CudaMachMessage request;
907: msg_return_t return_code;
908:
909: if (p) kprintf("ADBSetPollRate\n");
910: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
911: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_SET_AUTO_RATE;
912: request.msgBody.a_cmd.a_header[2] = NewRate;
913: request.msgBody.a_cmd.a_hcount = 3;
914: request.msgBody.a_cmd.a_bcount = 0;
915: request.msgBody.pmRefNum = RefNum;
916: request.msgBody.pmId = Id;
917: request.msgBody.pmCallback = Callback;
918:
919: request.msgHeader.msg_simple = TRUE;
920: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
921: request.msgHeader.msg_remote_port = port;
922: request.msgHeader.msg_local_port = PORT_NULL;
923: request.msgHeader.msg_size = sizeof(CudaMachMessage);
924: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
925:
926: if ( return_code == SEND_SUCCESS ) {
927: return kPMUNoError;
928: }
929: else {
930: return kPMUIOError;
931: }
932: }
933:
934:
935: // **********************************************************************************
936: // ADBGetPollRate
937: //
938: // **********************************************************************************
939: - (PMUStatus)ADBGetPollRate :(UInt32 *)CurrentRate
940: :(UInt32)RefNum
941: :(id)Id
942: :(pmCallback_func)Callback
943: {
944: return kPMUNotSupported;
945: }
946:
947:
948: // **********************************************************************************
949: // ADBSetAlternateKeyboard
950: //
951: // **********************************************************************************
952: - (PMUStatus)ADBSetAlternateKeyboard :(UInt32)DevAddr
953: :(UInt32)RefNum
954: :(id)Id
955: :(pmCallback_func)Callback
956: {
957: return kPMUNotSupported;
958: }
959:
960:
961: // **********************************************************************************
962: // ADBinput
963: //
964: // The PGE has interrupted with ADB data. We package this up and send
965: // it to our ADB client, if there is one, either as the result to its previous
966: // read command, or as autopoll data.
967: //
968: // Removed since cuda_process_response() does the same thing
969: // **********************************************************************************
970:
971:
972: // **********************************************************************************
973: // registerForClockTicks
974: //
975: // The RTC driver is calling to tell us that it is prepared to receive clock
976: // ticks every second. The parameter block tells who to call when we get one.
977: //
978: // **********************************************************************************
979: - (void)registerForClockTicks :(pmCallback_func)TickHandler
980: :(id)caller
981: {
982: RTCclient = TickHandler;
983: RTCid = caller;
984: }
985:
986:
987: // **********************************************************************************
988: // setRealTimeClock
989: //
990: // The RTC driver is calling to set the real time clock. We translate this into
991: // a PMU command and enqueue it to our command queue.
992: //
993: // **********************************************************************************
994: - (PMUStatus)setRealTimeClock :(UInt8 *)newTime
995: :(UInt32)RefNum
996: :(id)Id
997: :(pmCallback_func)Callback
998: {
999: CudaMachMessage request;
1000: msg_return_t return_code;
1001:
1002: if (p) kprintf("ADBSetRealTimeClock\n");
1003: if ( newTime == NULL ) {
1004: return kPMUParameterError;
1005: }
1006:
1007: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
1008: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_SET_REAL_TIME;
1009: request.msgBody.a_cmd.a_hcount = 2;
1010: request.msgBody.a_cmd.a_buffer[0] = newTime[0];
1011: request.msgBody.a_cmd.a_buffer[1] = newTime[1];
1012: request.msgBody.a_cmd.a_buffer[2] = newTime[2];
1013: request.msgBody.a_cmd.a_buffer[3] = newTime[3];
1014: request.msgBody.a_cmd.a_bcount = 4;
1015: request.msgBody.pmRefNum = RefNum;
1016: request.msgBody.pmId = Id;
1017: request.msgBody.pmCallback = Callback;
1018:
1019: request.msgHeader.msg_simple = TRUE;
1020: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
1021: request.msgHeader.msg_remote_port = port;
1022: request.msgHeader.msg_local_port = PORT_NULL;
1023: request.msgHeader.msg_size = sizeof(CudaMachMessage);
1024: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
1025:
1026: if ( return_code == SEND_SUCCESS ) {
1027: return kPMUNoError;
1028: }
1029: else {
1030: return kPMUIOError;
1031: }
1032: }
1033:
1034:
1035: // **********************************************************************************
1036: // getRealTimeClock
1037: //
1038: // The RTC driver is calling to read the real time clock. We translate this into
1039: // a PMU command and enqueue it to our command queue.
1040: // Called from PowerSurgeMB.m
1041: //
1042: // **********************************************************************************
1043: - (PMUStatus)getRealTimeClock :(UInt8 *)currentTime
1044: :(UInt32)RefNum
1045: :(id)Id
1046: :(pmCallback_func)Callback
1047: {
1048: CudaMachMessage request;
1049: msg_return_t return_code;
1050:
1051: if (p) kprintf("ADBGetRealTimeClock\n");
1052:
1053: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
1054: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_GET_REAL_TIME;
1055: request.msgBody.a_cmd.a_hcount = 2;
1056: request.msgBody.a_cmd.a_bcount = 0; //A.W. added 2/27. Is it enough? Response Specs:
1057: // Attention Byte
1058: // Response Type = PSEUDO
1059: // Response Flag
1060: // Command (was)
1061: // Data (Real Time Clock MSB)
1062: // Data
1063: // Data
1064: // Data (RTC LSB)
1065: // Idle Byte
1066:
1067: //The a_cmd.a_buffer is filled in by cuda_transmit_data()... but I need receive_data
1068: //Called from PowerSurgeMB.m
1069: /*** following commented out because it doesn't look right
1070: request.msgBody.a_cmd.a_buffer[0] = currentTime[0];
1071: request.msgBody.a_cmd.a_buffer[1] = currentTime[1];
1072: request.msgBody.a_cmd.a_buffer[2] = currentTime[2];
1073: request.msgBody.a_cmd.a_buffer[3] = currentTime[3];
1074: ******/
1075: bImmediate_buff_needed = TRUE;
1076: return_buff_pointer = currentTime;
1077: request.msgBody.a_reply.a_bsize = 8; //It's 8 in adb.h
1078:
1079: request.msgBody.pmRefNum = RefNum;
1080: request.msgBody.pmId = Id;
1081: request.msgBody.pmCallback = Callback;
1082:
1083: request.msgHeader.msg_simple = TRUE;
1084: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
1085: request.msgHeader.msg_remote_port = port;
1086: request.msgHeader.msg_local_port = PORT_NULL;
1087: request.msgHeader.msg_size = sizeof(CudaMachMessage);
1088: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
1089:
1090: if ( return_code == SEND_SUCCESS ) {
1091: return kPMUNoError;
1092: }
1093: else {
1094: return kPMUIOError;
1095: }
1096: }
1097:
1098:
1099:
1100: // **********************************************************************************
1101: // setPowerupTime
1102: // This sets the future time (in seconds) when Cuda will power-up the system again
1103: // If the power is already on then nothing happens. TRICKLE SENSE must be asserted.
1104: //
1105: // **********************************************************************************
1106: - (PMUStatus)setPowerupTime :(UInt8 *)newTime
1107: :(UInt32)RefNum
1108: :(id)Id
1109: :(pmCallback_func)Callback
1110: {
1111: CudaMachMessage request;
1112: msg_return_t return_code;
1113:
1114: if ( newTime == NULL ) {
1115: return kPMUParameterError;
1116: }
1117:
1118: if ( auto_power_on == 0) {
1119: return kPMUNoError;
1120: }
1121:
1122: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
1123: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_SET_POWER_UPTIME;
1124: request.msgBody.a_cmd.a_hcount = 2;
1125: request.msgBody.a_cmd.a_buffer[0] = newTime[0];
1126: request.msgBody.a_cmd.a_buffer[1] = newTime[1];
1127: request.msgBody.a_cmd.a_buffer[2] = newTime[2];
1128: request.msgBody.a_cmd.a_buffer[3] = newTime[3];
1129: request.msgBody.a_cmd.a_bcount = 4;
1130: request.msgBody.pmRefNum = RefNum;
1131: request.msgBody.pmId = Id;
1132: request.msgBody.pmCallback = Callback;
1133:
1134: request.msgHeader.msg_simple = TRUE;
1135: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
1136: request.msgHeader.msg_remote_port = port;
1137: request.msgHeader.msg_local_port = PORT_NULL;
1138: request.msgHeader.msg_size = sizeof(CudaMachMessage);
1139: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
1140:
1141: if ( return_code == SEND_SUCCESS ) {
1142: return kPMUNoError;
1143: }
1144: else {
1145: return kPMUIOError;
1146: }
1147: }
1148:
1149:
1150: // **********************************************************************************
1151: // CudaMisc
1152: //
1153: //
1154: // **********************************************************************************
1155: - (PMUStatus)CudaMisc :(UInt8 *)output
1156: :(UInt32)length
1157: :(UInt32)RefNum
1158: :(id)Id
1159: :(pmCallback_func)Callback
1160: {
1161: CudaMachMessage request;
1162: msg_return_t return_code;
1163: int i;
1164:
1165: for ( i = 0; i < length; i++ ) {
1166: //I should check for length < 8 but I trust callers in adb.m and PowerSurgeMB.m
1167: request.msgBody.a_cmd.a_header[i] = output[i];
1168: }
1169:
1170: request.msgBody.a_cmd.a_hcount = length;
1171: request.msgBody.a_cmd.a_bcount = 0;
1172: //Don't need to worry about how big the caller's buffer is because
1173: // cuda's adb_packet_t buffer is 8 bytes, and it's the caller who
1174: // must copy the bytes in its callback function
1175: request.msgBody.a_reply.a_bsize = 8; //It's 8 in adb.h for adb_packet_type
1176: request.msgBody.pmRefNum = RefNum;
1177: request.msgBody.pmId = Id;
1178: request.msgBody.pmCallback = Callback;
1179:
1180: request.msgHeader.msg_simple = TRUE;
1181: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
1182: request.msgHeader.msg_remote_port = port;
1183: request.msgHeader.msg_local_port = PORT_NULL;
1184: request.msgHeader.msg_size = sizeof(CudaMachMessage);
1185: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
1186:
1187: if ( return_code == SEND_SUCCESS ) {
1188: return kPMUNoError;
1189: }
1190: else {
1191: return kPMUIOError;
1192: }
1193:
1194: }
1195:
1196:
1197:
1198: //This function calls back the ADB client (such as Mouse driver).
1199: -(void) cuda_process_response
1200: {
1201:
1202: if ( cuda_transaction_state == CUDA_TS_SYNC_RESPONSE )
1203: {
1204: if ( cuda_request->pmCallback != NULL ) { // make the client callback
1205:
1206: if (p) kprintf("cuda_process_response: pmId = %08x, a_bcount = %08x, a_buffer = %08x\n",
1207: cuda_request->pmId, cuda_request->a_reply.a_bcount, cuda_request->a_reply.a_buffer);
1208:
1209:
1210: cuda_request->pmCallback ( cuda_request->pmId,
1211: cuda_request->pmRefNum,
1212: cuda_request->a_reply.a_bcount,
1213: cuda_request->a_reply.a_buffer );
1214: }
1215: else
1216: {
1217: //It's OK to not have a callback since some callers don't care
1218: // about synchronous completion
1219: //kprintf("WARNING: Cuda process_response() has no callback\n");
1220: }
1221: return_buff_pointer = NULL; //for getRealTimeClock only. a_buffer[]
1222: //above is ignored by PowerSurgeMB.m
1223: bImmediate_buff_needed = FALSE;
1224: //kprintf("cuda.m: cuda_process_response end \n");
1225: }
1226:
1227: else
1228: {
1229: if ( cuda_transaction_state == CUDA_TS_ASYNC_RESPONSE )
1230: {
1231: if ( ADBclient != NULL )
1232: { // call the client input handler
1233: cuda_freeze_counter++;
1234:
1235: if (p) {
1236: kprintf("cuda2.m::cuda_process_response ASYNC \n");
1237: kprintf("cuda2.m::ASYNC count is %d\n", cuda_current_response->a_bcount);
1238: kprintf("cuda2.m::ASYNC buffer 0 is %x\n", cuda_current_response->a_buffer[0]);
1239: kprintf("cuda2.m::ASYNC buffer 1 is %x\n", cuda_current_response->a_buffer[1]);
1240: kprintf("cuda2.m::ASYNC buffer 2 is %x\n", cuda_current_response->a_buffer[2]);
1241: kprintf("cuda2.m::ASYNC buffer 3 is %x\n", cuda_current_response->a_buffer[3]);
1242: kprintf("cuda2.m::ASYNC buffer 4 is %x\n", cuda_current_response->a_buffer[4]);
1243: kprintf("cuda2.m::ASYNC buffer 5 is %x\n", cuda_current_response->a_buffer[5]);
1244: kprintf("cuda2.m::ASYNC header 0 is %x\n", cuda_current_response->a_header[0]);
1245: kprintf("cuda2.m::ASYNC header 1 is %x\n", cuda_current_response->a_header[1]);
1246: kprintf("cuda2.m::ASYNC header 2 is %x\n", cuda_current_response->a_header[2]);
1247: }
1248:
1249: if (p) kprintf("cuda_process_response: ADBclient = %08x, ADBid = %08x\n", ADBclient, ADBid);
1250:
1251: #ifdef DEBUG
1252: cuda_glob_data1 = cuda_current_response->a_buffer[0];
1253: cuda_glob_data2 = cuda_current_response->a_buffer[1];
1254: if (cuda_glob_dbug_freeze == 1)
1255: {
1256: //kprintf("%x %x \n", cuda_glob_data1, cuda_glob_data2);
1257: }
1258: #endif
1259: //ADBClient is the global variable that clients registered with
1260: ADBclient(ADBid,
1261: 0,
1262: (cuda_current_response->a_header[2] >> 4) & 0xf,
1263: cuda_current_response->a_bcount,
1264: &cuda_current_response->a_buffer[0]);
1265: }
1266: }
1267: }
1268: }
1269:
1270:
1271: // **********************************************************************************
1272: // readNVRAM
1273: //
1274: // The NVRAM driver is calling to read part of the NVRAM. We translate this into
1275: // a PMU command and enqueue it to our command queue.
1276: //
1277: // **********************************************************************************
1278: - (PMUStatus) readNVRAM :(UInt32)Offset
1279: :(UInt32)Length
1280: :(UInt8 *)Buffer
1281: :(UInt32)RefNum
1282: :(id)Id
1283: :(pmCallback_func)Callback
1284: {
1285: return kPMUNotSupported;
1286: }
1287:
1288:
1289: // **********************************************************************************
1290: // writeNVRAM
1291: //
1292: // The NVRAM driver is calling to write part of the NVRAM. We translate this into
1293: // a PMU command and enqueue it to our command queue.
1294: //
1295: // **********************************************************************************
1296: - (PMUStatus) writeNVRAM:(UInt32)Offset
1297: :(UInt32)Length
1298: :(UInt8 *)Buffer
1299: :(UInt32)RefNum
1300: :(id)Id
1301: :(pmCallback_func)Callback
1302: {
1303: return kPMUNotSupported;
1304: }
1305:
1306:
1307: // **********************************************************************************
1308: // registerForPowerInterrupts
1309: //
1310: // Some driver is calling to say it is prepared to receive "unsolicited" power-system
1311: // interrups (e.g. battery low). The parameter block says who to call when we get one.
1312: //
1313: // **********************************************************************************
1314: - (void)registerForPowerInterrupts :(pmCallback_func)buttonHandler
1315: :(id)caller
1316: {
1317: PWRclient = buttonHandler;
1318: PWRid = caller;
1319: }
1320:
1321:
1322: // **********************************************************************************
1323: // sendMiscCommand
1324: //
1325: // Some driver is calling to send some miscellaneous command. We copy this into a
1326: // PMU command and enqueue it to our command queue.
1327: // A.W. Not completed yet for Cuda commands!!
1328: // **********************************************************************************
1329: - (PMUStatus)sendMiscCommand :(UInt32)Command
1330: :(UInt32)SLength
1331: :(UInt8 *)SBuffer
1332: :(UInt8 *)RBuffer
1333: :(UInt32)RefNum
1334: :(id)Id
1335: :(pmCallback_func)Callback
1336: {
1337: CudaMachMessage request;
1338: msg_return_t return_code;
1339: spl_t interruptState;
1340:
1341:
1342: if (Command == kPMUPmgrPWRoff)
1343: {
1344: //kprintf("\nCuda received power-down message\n");
1345: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_POWER_DOWN;
1346: auto_power_on = 0; //console operator really wants to shut off power
1347: }
1348: else if (Command == kPMUresetCPU)
1349: {
1350: request.msgBody.a_cmd.a_header[1] = ADB_PSEUDOCMD_RESTART_SYSTEM;
1351: //kprintf("\nCuda received reset message\n");
1352: }
1353: else
1354: {
1355: return kPMUParameterError;
1356: }
1357:
1358: //A.W. 3/17/98 I found out that reboots cannot happen from within
1359: // the mini-monitor because interrupts are turned off, which means
1360: // Cuda cannot get the subsequent command packet bytes to reboot
1361: // However, Simon says that next 2 lines are not necessary
1362: // WARNING The current file is checked out from trunk, don't check in
1363: interruptState = spltty();
1364: splx(interruptState);
1365: //request.msgBody.a_reply.a_bsize = 0; //we don't expect any replies for two commands above
1366: request.msgBody.a_reply.a_bsize = 8; //reset fails WARNING
1367: request.msgBody.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
1368: request.msgBody.a_cmd.a_hcount = 2;
1369: request.msgBody.a_cmd.a_bcount = 0;
1370: request.msgBody.pmRefNum = RefNum;
1371: request.msgBody.pmId = Id;
1372: request.msgBody.pmCallback = Callback;
1373:
1374: request.msgHeader.msg_simple = TRUE;
1375: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
1376: request.msgHeader.msg_remote_port = port;
1377: request.msgHeader.msg_local_port = PORT_NULL;
1378: request.msgHeader.msg_size = sizeof(CudaMachMessage);
1379: return_code = msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
1380:
1381: if ( return_code == SEND_SUCCESS ) {
1382: return kPMUNoError;
1383: }
1384: else {
1385: return kPMUIOError;
1386: }
1387: }
1388:
1389:
1390: // **********************************************************************************
1391: // StartCudaTransmission
1392: //
1393: // Called with PMU interrupts disabled. q8q
1394: // Transmission of the command byte is started. The transaction will be
1395: // completed by the Shift Register Interrupt Service Routine.
1396: // **********************************************************************************
1397: - (void)StartCudaTransmission:(CudaRequest *)plugInMessage;
1398: {
1399:
1400:
1401: if (( *VIA2_dataB & kCudaTransferRequestMask) == 0)
1402: {
1403: //Simon says there's a collision here
1404: cuda_interrupt_state = CUDA_STATE_ATTN_EXPECTED;
1405: cuda_transaction_state = CUDA_TS_ASYNC_RESPONSE;
1406: [self cuda_queue: plugInMessage];
1407: return;
1408: }
1409:
1410: //MAJOR CHANGE 8/6/98... 2 lines were at beginning, IDLE didn't make sense there
1411: if ( cuda_interrupt_state == CUDA_STATE_IDLE)
1412: {
1413: clientRequest = plugInMessage;
1414: firstChar = plugInMessage->a_cmd.a_header[0]; //Should be ADB_PACKET or PSEUDO
1415: charCountS1 = plugInMessage->a_cmd.a_hcount;
1416:
1417: dataPointer1 = &plugInMessage->a_cmd.a_header[0];
1418:
1419: cuda_request = plugInMessage;
1420: cuda_request->a_reply.a_bcount = 0;
1421:
1422:
1423: // cuda_set_data_direction_to_output(); //On cuda value is 0x10;
1424: *VIA1_auxillaryControl |= kCudaSystemSend; eieio();
1425:
1426: // ADBPollDisable is handled how?
1427: *VIA1_shift = firstChar; // give it the byte (this clears any pending SR interrupt)
1428:
1429: // Set up the transfer state info here.
1430:
1431: cuda_is_header_transfer = TRUE;
1432: cuda_transfer_count = 1;
1433:
1434:
1435:
1436: // *VIA2_dataB &= ~kCudaNegateTransferRequest; // yes, assert /REQ
1437: //I think I actually need to assert TIP here, not REQ.
1438: //eieio();
1439:
1440:
1441: // cuda_neg_byte_ack();
1442: *VIA2_dataB |= kCudaNegateByteAcknowledge; eieio();
1443:
1444: // cuda_assert_transfer_in_progress();
1445: *VIA2_dataB &= kCudaAssertTransferInProgress; eieio();
1446:
1447: // The next state is going to be a transmit state, if there is
1448: // no collision. This is a requested response but call it sync.
1449:
1450: cuda_interrupt_state = CUDA_STATE_TRANSMIT_EXPECTED;
1451:
1452: //INVESTIGATE: we get here even if there was a collision and the
1453: // collision packet was put onto the queue. In that case it means
1454: // the transaction was ASYNC?
1455: // This entire function is protected by splt so no interrupts should
1456: // be happening at all.
1457: cuda_transaction_state = CUDA_TS_SYNC_RESPONSE;
1458:
1459: return;
1460:
1461: }
1462: }
1463:
1464:
1465:
1466: //This ISR is copied from cuda.c. The nice thing about Cuda is that at any
1467: // time we can determine state of hardware by examining 3 bits.
1468: - (void)interruptOccurred
1469: {
1470:
1471: unsigned char interruptState;
1472:
1473: *VIA2_dataB |= kCudaNegateTransferRequest; // deassert /REQ
1474:
1475: // Get the relevant signal in determining the cause of the interrupt:
1476: // the shift direction, the transfer request line and the transfer
1477: // request line.
1478:
1479: //interruptState = cuda_get_interrupt_state();
1480: interruptState = (*VIA2_dataB & kCudaInterruptStateMask) | (*VIA1_auxillaryControl & kCudaDirectionMask) ;
1481:
1482: #ifdef DEBUG
1483: if ( cuda_glob_dbug_freeze == 1)
1484: {
1485: printf(" %d: ", interruptState);
1486: }
1487: #endif
1488:
1489: //no use DELAY(12); //12 microsecond delay in Ray Montagne's Cuda Manager for MacOS
1490:
1491: switch ( interruptState ) {
1492:
1493: case kCudaReceiveByte:
1494: if (p) kprintf("CUDA ** INTERRUPT ** RECEIVE *** \n");
1495: [self cuda_receive_data];
1496: break;
1497:
1498: case kCudaReceiveLastByte:
1499: if (p) kprintf("CUDA ** INTERRUPT ** RECEIVE LAST BYTE *** \n");
1500: [self cuda_receive_last_byte];
1501: break;
1502:
1503: case kCudaTransmitByte:
1504: if (p) kprintf("CUDA ** INTERRUPT ** TRANSMIT *** \n");
1505: [self cuda_transmit_data];
1506: break;
1507:
1508: case kCudaUnexpectedAttention:
1509: if (p) kprintf("CUDA ** INTERRUPT ** Unexpected Attention *** \n");
1510: [self cuda_unexpected_attention];
1511: break;
1512:
1513: case kCudaExpectedAttention:
1514: if (p) kprintf("CUDA ** INTERRUPT ** EXPECTED ATTENTION *** \n");
1515: [self cuda_expected_attention];
1516: break;
1517:
1518: case kCudaIdleState:
1519: if (p) kprintf("CUDA ** INTERRUPT ** IDLE *** \n");
1520: [self cuda_idle];
1521: break;
1522:
1523: case kCudaCollision:
1524: if (p) kprintf("Cuda *** INTERRUPT *** ADB collision\n");
1525: [self cuda_collision];
1526: break;
1527:
1528: // Unknown interrupt, clear it and leave
1529: default:
1530: if (p) kprintf("Cuda *** INTERRUPT *** ERROR\n");
1531: [self cuda_error];
1532: break;
1533: }
1534: }
1535:
1536:
1537: // ****************************************************************************
1538: // interruptOccurredAt
1539: // PGE has interrupted. Send the ReadInt command to find out why.
1540: // When the command byte is sent, the Shift Register will interrupt.
1541: // If we are mid-transaction when we find out about the interrupt,
1542: // set a flag and find out why later.
1543: //
1544: // A.W. Removed 2/11/98 because cuda only has 1 interrupt
1545: //
1546: // ****************************************************************************
1547:
1548:
1549:
1550: // ****************************************************************************
1551: // gotInterruptCause
1552: //
1553: // Called by the debug-mode PMU interrupt handler as the Callback function
1554: // after sending the kPMUreadInt command and receiving its response
1555: // A.W. only called by interruptOccurredAt above, so remove as well
1556: // ****************************************************************************
1557:
1558:
1559: // ****************************************************************************
1560: // EnableCudaInterrupt used to be EnablePMUInterrupt
1561: // ****************************************************************************
1562: - (void)EnableCudaInterrupt
1563: {
1564:
1565: // cuda_enable_interrupt(); // from cuda_hdw.h
1566: *VIA1_interruptEnable = kCudaInterruptEnable;
1567: eieio();
1568:
1569: }
1570:
1571:
1572: #ifdef OMIT
1573: // ****************************************************************************
1574: // timer_expired
1575: //
1576: // Our adb-read timer has expired, so we have to notify our i/o thread by
1577: // enqueuing a Timeout message to its interrupt port.
1578: // This was only called by ADBinput() in pmu.m, but cuda doesn't have ADBinput()
1579: // so this method is useless for now.
1580: // ****************************************************************************
1581: void timer_expired(port_t mach_port)
1582: {
1583: PMUmachMessage request;
1584:
1585: request.msgHeader.msg_simple = TRUE;
1586: request.msgHeader.msg_type = MSG_TYPE_NORMAL;
1587: request.msgHeader.msg_id = IO_TIMEOUT_MSG;
1588: request.msgHeader.msg_remote_port = mach_port;
1589: request.msgHeader.msg_local_port = PORT_NULL;
1590: request.msgHeader.msg_size = sizeof(msg_header_t);
1591: msg_send_from_kernel(&request.msgHeader, MSG_OPTION_NONE, 0);
1592:
1593: }
1594:
1595: #endif
1596:
1597:
1598:
1599: // ****************************************************************************
1600: // cuda_timer_autopoll
1601: //
1602: // Automatic scheduling of command to make sure auto-polling is always available
1603: // In worst case, I may want to reset Cuda here.
1604: // ****************************************************************************
1605: void cuda_timer_autopoll(port_t mach_port)
1606: {
1607: CudaMachMessage request;
1608: extern int kdp_flag;
1609: static int old_kdp_flag;
1610: static int cuda_TREQ_history;
1611: VIAAddress temp_register, dataB;
1612: unsigned char interruptState;
1613: //unsigned int newTime;
1614:
1615: #ifdef DEBUG
1616: //[ApplePMUId ADBPollEnable :0:0: NULL]; //stress this one
1617: //newTime = 0;
1618: //[ApplePMUId getRealTimeClock :(UInt8 *)&newTime : 0: 0: NULL];
1619:
1620: //*stat_aux_control &= kCudaSystemRecieve; eieio();
1621: ns_timeout((func)cuda_timer_autopoll,(void *)glob_port, kNS_TIMEOUT_AUTOPOLL,CALLOUT_PRI_SOFTINT0); // start timer again for another 4 seconds
1622: //Can only be set through debugging tool
1623: switch (cuda_glob_dbug_freeze )
1624: {
1625: case 0:
1626: old_kdp_flag = kdp_flag;
1627: break;
1628: case 1:
1629: kdp_flag |= 0x02;
1630: temp_register = stat_aux_control + 0x1600; //auxillary
1631: dataB = stat_aux_control ;
1632: interruptState = (*dataB & kCudaInterruptStateMask) | (*temp_register & kCudaDirectionMask) ;
1633: printf("CUDA: 4-second periodic, interruptState is %x\n", interruptState);
1634: kprintf("CUDA: 4-second periodic, interruptState is %x\n", interruptState);
1635:
1636: #ifdef OMIT_CUDA_DBUG
1637: //kprintf("istate = %x ", interruptState);
1638: //temp_register = stat_aux_control + 0x1A00;
1639: //kprintf("ir flag = %x ", *temp_register);
1640: //eieio();
1641: temp_register = stat_aux_control + 0x1600; //auxillary
1642: kprintf("aux= %x ", *temp_register);
1643: eieio();
1644: temp_register = stat_aux_control;//dataB
1645: kprintf("dataB= %x ", *temp_register);
1646: eieio();
1647: temp_register = stat_aux_control + 0x1400; // SHIFT
1648: kprintf("shift= %x ", *temp_register);
1649: eieio();
1650: temp_register = stat_aux_control + 0x1c00; // Interrupt Enable
1651: kprintf("IE= %x \n", *temp_register);
1652: eieio();
1653: #endif
1654:
1655: //put printf here so it doesn't interfere with other debugging sessions
1656: break;
1657: case 2:
1658: //May disabling Cuda debugging kprintf, but preserve "4" for debugging
1659: kdp_flag = old_kdp_flag;
1660: break;
1661: case 3:
1662: cuda_glob_dbug_freeze = 1;
1663: cuda_interrupt_state = CUDA_STATE_IDLE; //Force state change
1664: [ApplePMUId EnableCudaInterrupt];
1665: [ApplePMUId enableAllInterrupts];
1666: [ApplePMUId ADBReset :0:0: NULL];
1667: //mouse will be in low-res mode
1668: break;
1669: case 4:
1670: cuda_glob_dbug_freeze = 1;
1671: [ApplePMUId ADBPollEnable :0:0: NULL];
1672: //No side effects seen for now, but gets queued when cuda freezes
1673: break;
1674: case 5:
1675: cuda_glob_dbug_freeze = 1;
1676: [ApplePMUId ADBFlush :2:0:0: NULL]; //keyboard is 2
1677: //No side effects seen for now, but gets queued when cuda freezes
1678: break;
1679: case 6:
1680: cuda_glob_dbug_freeze = 1;
1681: //change data direction to input
1682: temp_register = stat_aux_control + 0x1600;
1683: *temp_register &= kCudaSystemRecieve; eieio();
1684: break;
1685: case 7:
1686: cuda_glob_dbug_freeze = 1;
1687: temp_register = stat_aux_control + 0x1400; // SHIFT
1688: interruptState = *temp_register; eieio(); //dummy read
1689: //Simon suggests toggling the byteack too
1690: temp_register = stat_aux_control;//dataB
1691: *temp_register ^= kCudaByteAcknowledgeMask; eieio();
1692: break;
1693: case 8:
1694: cuda_interrupt_state = CUDA_STATE_IDLE; //Force state change
1695: temp_register = stat_aux_control;//dataB
1696: *temp_register &= kCudaAssertTransferInProgress;
1697: *temp_register |= kCudaNegateByteAcknowledge ;
1698: eieio();
1699: cuda_glob_dbug_freeze = 1;
1700: break;
1701: case 9:
1702: cuda_glob_dbug_freeze = 1;
1703: cuda_current_response->a_buffer[0] = 0;
1704: cuda_current_response->a_buffer[1] = 0xff;
1705: cuda_debug_client(0, 0, 2, 2, &cuda_current_response->a_buffer[0]);
1706: break;
1707: case 10:
1708: cuda_glob_dbug_freeze = 1;
1709: call_kdp();
1710: break;
1711: case 11:
1712: cuda_glob_dbug_freeze = 1;
1713: cuda_interrupt_state = CUDA_STATE_IDLE; //Force state change
1714: [ApplePMUId EnableCudaInterrupt];
1715: [ApplePMUId enableAllInterrupts];
1716: [ApplePMUId ADBPollEnable :0 :0: NULL];
1717: break;
1718: case 12:
1719: cuda_glob_dbug_freeze = 1;
1720: temp_register = stat_aux_control + 0x1400; // SHIFT
1721: interruptState = *temp_register; eieio(); //dummy read
1722: break;
1723: case 20: //Negate ByteAcknowledge
1724: temp_register = stat_aux_control;//dataB
1725: *temp_register |= kCudaNegateByteAcknowledge; eieio();
1726: eieio();
1727: cuda_glob_dbug_freeze = 1;
1728: break;
1729: case 21:
1730: //Set ByteAcknowledge
1731: temp_register = stat_aux_control;//dataB
1732: *temp_register &= kCudaAssertByteAcknowledge; eieio();
1733: eieio();
1734: cuda_glob_dbug_freeze = 1;
1735: break;
1736: case 22:
1737: //Set TIP
1738: temp_register = stat_aux_control; //dataB
1739: *temp_register &= kCudaTransferInProgressMask;
1740: eieio();
1741: cuda_glob_dbug_freeze = 1;
1742: break;
1743: case 23:
1744: //Negate TIP
1745: temp_register = stat_aux_control; //dataB
1746: *temp_register |= kCudaNegateTransferInProgress;
1747: eieio();
1748: cuda_glob_dbug_freeze = 1;
1749: break;
1750: case 24:
1751: //data direction to input
1752: temp_register = stat_aux_control + 0x1600; //auxillary
1753: *temp_register &= kCudaSystemRecieve;
1754: eieio();
1755: cuda_glob_dbug_freeze = 1;
1756: break;
1757: case 25:
1758: //data direction to output
1759: temp_register = stat_aux_control + 0x1600; //auxillary
1760: *temp_register |= kCudaSystemSend;
1761: eieio();
1762: cuda_glob_dbug_freeze = 1;
1763: break;
1764: case 30: //general reset
1765: {
1766: temp_register = stat_aux_control + 0x0400; //dataDirectionB
1767: *temp_register |= (kCudaByteAcknowledgeMask | kCudaTransferInProgressMask);
1768: *temp_register &= ~kCudaTransferRequestMask;
1769:
1770: temp_register = stat_aux_control + 0x1600; //auxillary
1771: *temp_register = ( *temp_register | kCudaTransferMode) & kCudaSystemRecieve;
1772:
1773: // Clear any posible cuda interupt.
1774: temp_register = stat_aux_control + 0x1400; //shift
1775: if ( *temp_register );
1776: eieio();
1777:
1778: // Initialize the internal data.
1779:
1780: cuda_interrupt_state = CUDA_STATE_IDLE;
1781: cuda_transaction_state = CUDA_TS_NO_REQUEST;
1782: cuda_is_header_transfer = FALSE;
1783: cuda_is_packet_type = FALSE;
1784: cuda_transfer_count = 0;
1785: cuda_current_response = NULL;
1786:
1787: // Terminate transaction and set idle state
1788: // cuda_neg_tip_and_byteack();
1789: temp_register = stat_aux_control; //dataB
1790: *temp_register |= kCudaNegateByteAcknowledge | kCudaNegateTransferInProgress;
1791: eieio();
1792:
1793: // we want to delay 4 mS for ADB reset to complete
1794:
1795: delay(4000);
1796:
1797: // Clear pending interrupt if any...
1798: //(void)cuda_read_data();
1799: temp_register = stat_aux_control + 0x1400; //Shift
1800: if ( *temp_register ); eieio();
1801:
1802: // Issue a Sync Transaction, ByteAck asserted while TIP is negated.
1803: // cuda_assert_byte_ack();
1804: temp_register = stat_aux_control; //dataB
1805: *temp_register &= kCudaAssertByteAcknowledge; eieio();
1806:
1807:
1808: // Wait for the Sync acknowledgement, cuda to assert TREQ
1809: // cuda_wait_for_transfer_request_assert();
1810: while ( (*temp_register & kCudaTransferRequestMask) != 0 )
1811: {
1812: eieio();
1813: }
1814: eieio();
1815:
1816: // Wait for the Sync acknowledgement interrupt.
1817: // cuda_wait_for_interrupt();
1818: temp_register = stat_aux_control + 0x1A00; //VIA interrupt flag
1819: while ( (*temp_register & kCudaInterruptMask) == 0 )
1820: {
1821: eieio();
1822: }
1823: eieio();
1824:
1825:
1826: // Clear pending interrupt
1827: //(void)cuda_read_data();
1828: temp_register = stat_aux_control + 0x1400; //shift
1829: if ( *temp_register );
1830: eieio();
1831:
1832: // Terminate the sync cycle by Negating ByteAck
1833: // cuda_neg_byte_ack();
1834: temp_register = stat_aux_control; //dataB
1835: *temp_register |= kCudaNegateByteAcknowledge; eieio();
1836:
1837: // Wait for the Sync termination acknowledgement, cuda negates TREQ.
1838: // cuda_wait_for_transfer_request_neg();
1839: while ( (*temp_register & kCudaTransferRequestMask) == 0 )
1840: {
1841: eieio();
1842: }
1843: eieio();
1844:
1845:
1846: // Wait for the Sync termination acknowledgement interrupt.
1847: // cuda_wait_for_interrupt();
1848: temp_register = stat_aux_control + 0x1A00; //VIA interrupt flag
1849: while ( (*temp_register & kCudaInterruptMask) == 0 )
1850: {
1851: eieio();
1852: }
1853: eieio();
1854:
1855:
1856: // Terminate transaction and set idle state, TIP negate and ByteAck negate.
1857: // cuda_neg_transfer_in_progress();
1858: temp_register = stat_aux_control; //dataB
1859: *temp_register |= kCudaNegateTransferInProgress; eieio();
1860:
1861: // Clear pending interrupt, if there is one...
1862: //(void)cuda_read_data();
1863: temp_register = stat_aux_control + 0x1400; //shift
1864: if ( *temp_register );
1865: eieio();
1866:
1867:
1868:
1869:
1870: debugging = FALSE;
1871: adb_reading = FALSE;
1872:
1873: //CUDA_REPLACE
1874: // A.W. This call seems to have no counterpart in Cuda
1875: // Pending interrupts are cleared with cuda_read_data()
1876: temp_register = stat_aux_control + 0x1A00; //VIA interrupt flag
1877: *temp_register = kCudaInterruptDisable;eieio(); // turn off any pending interrupt
1878:
1879: temp_register = stat_aux_control + 0x1400; //shift
1880: if ( *temp_register );
1881: eieio();
1882:
1883: [ApplePMUId EnableCudaInterrupt];
1884:
1885: [ApplePMUId enableAllInterrupts];
1886:
1887: }
1888: break;
1889:
1890: case 40:
1891: //try AIX stuff
1892: temp_register = stat_aux_control; //dataB
1893: *temp_register |= kCudaNegateTransferInProgress | kCudaNegateByteAcknowledge;
1894: eieio();
1895: [ApplePMUId EnableCudaInterrupt];
1896: //[ApplePMUId enableAllInterrupts];
1897: [ApplePMUId ADBPollEnable :0 :0: NULL];
1898: cuda_glob_dbug_freeze = 1;
1899: break;
1900:
1901: default:
1902: }
1903:
1904: // Sept 11, 1998 Add new code to fix ADB hang problem
1905: if ( cuda_freeze_counter == cuda_freeze_prevcount)
1906: //Even if user never touches keyboard, this test is FALSE first time
1907: {
1908: //if here then that means either user has not moved ADB device for
1909: // a long time or the system is hung
1910: //kprintf("HH: No ADB movement so far\n");
1911: //Now check TREQ (if in middle of transaction)
1912: temp_register = stat_aux_control; //dataB
1913: if ((*temp_register & kCudaTransferRequestMask) == 0 )
1914: {
1915: //kprintf("HH: TREQ is 0 (asserted), incrementing flag now\n");
1916: cuda_TREQ_history++;
1917: }
1918: else
1919: {
1920: cuda_TREQ_history = 0;
1921: }
1922: if ( cuda_TREQ_history == 2) // 2 cycles already
1923: {
1924: //Executing this code at any time has proven to be safe and does
1925: // not affect the operation of the high-resolution pointing devices
1926: //kprintf("HH: In recovery code now \n");
1927: printf("\nCuda: recover from transaction hang\n");
1928: temp_register = stat_aux_control; //dataB
1929: *temp_register |= kCudaNegateTransferInProgress | kCudaNegateByteAcknowledge;
1930: eieio();
1931: [ApplePMUId EnableCudaInterrupt];
1932: [ApplePMUId ADBPollEnable :0 :0: NULL];
1933: cuda_TREQ_history = 0;
1934: }
1935: }
1936: else
1937: {
1938: cuda_TREQ_history = 0;
1939: }
1940:
1941: cuda_freeze_prevcount = cuda_freeze_counter ; //Get ready for next 4-sec timer
1942: #endif //DEBUG
1943:
1944:
1945: }
1946:
1947:
1948: // Cuda functions needed to help -interruptOccured:
1949:
1950:
1951:
1952:
1953: //
1954: // TransmitCudaData
1955: // Executes at hardware interrupt level.
1956: //
1957:
1958: -(void) cuda_transmit_data
1959: {
1960: volatile unsigned char valcuda; //dummy, unused
1961: // Clear the pending interrupt by reading the shift register.
1962:
1963:
1964: if ( cuda_is_header_transfer ) {
1965: // There are more header bytes, write one out.
1966: // Initially cuda_transfer_count is 1, so for most Cuda commands
1967: // that means the ADB command itself, which contains Talk, Listen, etc.
1968: // cuda_write_data(cuda_request->a_cmd.a_header[cuda_transfer_count++]);
1969: *VIA1_shift = cuda_request->a_cmd.a_header[cuda_transfer_count++];
1970:
1971: // Toggle the handshake line.
1972: // a_hcount is number of bytes in command packet
1973: if ( cuda_transfer_count >= cuda_request->a_cmd.a_hcount ) {
1974: cuda_is_header_transfer = FALSE;
1975: cuda_transfer_count = 0;
1976: }
1977:
1978: // cuda_toggle_byte_ack();
1979: *VIA2_dataB ^= kCudaByteAcknowledgeMask; eieio();
1980:
1981:
1982: } else if ( cuda_transfer_count < cuda_request->a_cmd.a_bcount ) {
1983: //WARNING... find out why a_bcount above is examined during Cuda Transmit?
1984:
1985:
1986: // There are more command bytes, write one out and update the pointer
1987: // cuda_write_data(cuda_request->a_cmd.a_buffer[cuda_transfer_count++]);
1988: *VIA1_shift = cuda_request->a_cmd.a_buffer[cuda_transfer_count++];
1989:
1990: // Toggle the handshake line.
1991: // cuda_toggle_byte_ack();
1992: *VIA2_dataB ^= kCudaByteAcknowledgeMask; eieio();
1993: } else {
1994: //(void)cuda_read_data();
1995: valcuda = *VIA1_shift; eieio();
1996: // There is no more command bytes, terminate the send transaction.
1997: // Cuda should send a expected attention interrupt soon.
1998:
1999: // cuda_neg_tip_and_byteack();
2000: *VIA2_dataB |= kCudaNegateByteAcknowledge | kCudaNegateTransferInProgress;
2001: eieio();
2002:
2003: // The next interrupt should be a expected attention interrupt.
2004:
2005: cuda_interrupt_state = CUDA_STATE_ATTN_EXPECTED;
2006:
2007: /**** moved to cuda_idle() portion
2008: // call back the ADB layer if entire transmission packet is complete.
2009: if ( clientRequest->pmCallback != NULL ) {
2010: clientRequest->pmCallback(clientRequest->pmId, clientRequest->pmRefNum, 0, NULL);
2011:
2012: }
2013: *****/
2014:
2015: }
2016: }
2017:
2018: //
2019: // cuda_expected_attention
2020: // Executes at hardware interrupt level.
2021: //
2022:
2023: - (void)cuda_expected_attention
2024: {
2025: volatile unsigned char valcuda; //dummy, unused
2026:
2027:
2028: // Clear the pending interrupt by reading the shift register.
2029: // This first byte is the "attention" byte and contains no
2030: // useful data, so ignore it. Next byte should be response
2031: // packet TYPE.
2032: //(void)cuda_read_data();
2033: valcuda = *VIA1_shift; eieio();
2034:
2035: // Allow the VIA to settle directions.. else the possibility of
2036: // data corruption.
2037: tick_delay(cuda_state_transition_delay_ticks);
2038:
2039: if ( cuda_transaction_state == CUDA_TS_SYNC_RESPONSE) {
2040: cuda_current_response = (adb_packet_t*)&cuda_request->a_reply;
2041: } else {
2042: cuda_unsolicited.a_hcount = 0;
2043: cuda_unsolicited.a_bcount = 0;
2044: cuda_unsolicited.a_bsize = sizeof(cuda_unsolicited.a_buffer);
2045: cuda_current_response = &cuda_unsolicited;
2046: }
2047:
2048: cuda_is_header_transfer = TRUE;
2049: cuda_is_packet_type = TRUE;
2050: cuda_transfer_count = 0;
2051:
2052: // Set the shift register direction to input.
2053: // cuda_set_data_direction_to_input();
2054: *VIA1_auxillaryControl &= kCudaSystemRecieve; eieio();
2055:
2056: // Start the response packet transaction.
2057: // cuda_assert_transfer_in_progress();
2058: *VIA2_dataB &= kCudaAssertTransferInProgress; eieio();
2059:
2060: // The next interrupt should be a receive data interrupt.
2061: cuda_interrupt_state = CUDA_STATE_RECEIVE_EXPECTED;
2062: }
2063:
2064: //
2065: // cuda_unexpected_attention
2066: // Executes at hardware interrupt level.
2067: //
2068:
2069: -(void) cuda_unexpected_attention
2070: {
2071: volatile unsigned char valcuda; //dummy, unused
2072:
2073: // Clear the pending interrupt by reading the shift register.
2074: // This first byte is the "attention" byte and contains no
2075: // useful data, so ignore it. Next byte should be response
2076: // packet TYPE.
2077: //(void)cuda_read_data();
2078: valcuda = *VIA1_shift; eieio();
2079:
2080: // Get ready for a unsolicited response.
2081:
2082: cuda_unsolicited.a_hcount = 0;
2083: cuda_unsolicited.a_bcount = 0;
2084: cuda_unsolicited.a_bsize = sizeof(cuda_unsolicited.a_buffer);
2085: //Try to fix jumping bug
2086: bzero( cuda_unsolicited.a_buffer, cuda_unsolicited.a_bsize);
2087:
2088:
2089: cuda_current_response = &cuda_unsolicited;
2090:
2091: cuda_is_header_transfer = TRUE;
2092: cuda_is_packet_type = TRUE;
2093: cuda_transfer_count = 0;
2094:
2095:
2096: // Start the response packet transaction, Transaction In Progress
2097: // cuda_assert_transfer_in_progress();
2098: *VIA2_dataB &= kCudaAssertTransferInProgress; eieio();
2099:
2100: // The next interrupt should be a receive data interrupt and the next
2101: // response should be an async response.
2102:
2103: cuda_interrupt_state = CUDA_STATE_RECEIVE_EXPECTED;
2104:
2105: cuda_transaction_state = CUDA_TS_ASYNC_RESPONSE;
2106: }
2107:
2108: //
2109: // cuda_receive_data
2110: // Executes at hardware interrupt level.
2111: //
2112:
2113: -(void) cuda_receive_data
2114: {
2115:
2116: // cuda_is_packet_type is set to TRUE when cuda_(+un)expected_attention() is called
2117: // The first part will be called just to read the packet type
2118: if ( cuda_is_packet_type ) {
2119: unsigned char packetType;
2120:
2121: //packetType = cuda_read_data();
2122: packetType = *VIA1_shift; eieio();
2123: cuda_current_response->a_header[cuda_transfer_count++] = packetType;
2124:
2125: if ( packetType == ADB_PACKET_ERROR) {
2126: cuda_current_response->a_hcount = 4;
2127: } else {
2128: cuda_current_response->a_hcount = 3;
2129: }
2130:
2131: cuda_is_packet_type = FALSE;
2132:
2133: // cuda_toggle_byte_ack();
2134: *VIA2_dataB ^= kCudaByteAcknowledgeMask; eieio();
2135:
2136: } else if ( cuda_is_header_transfer ) { //set TRUE by cuda_(+un)expected_attention
2137:
2138: //This should be the Response Packet ADB Status byte (2nd byte)
2139: cuda_current_response->a_header[cuda_transfer_count++] =
2140: *VIA1_shift; eieio();
2141: // cuda_read_data();
2142:
2143: if (cuda_transfer_count >= cuda_current_response->a_hcount) {
2144: cuda_is_header_transfer = FALSE;
2145: cuda_transfer_count = 0;
2146: }
2147:
2148: // cuda_toggle_byte_ack();
2149: *VIA2_dataB ^= kCudaByteAcknowledgeMask; eieio();
2150:
2151: } else if ( cuda_transfer_count < cuda_current_response->a_bsize ) {
2152: // Still room for more bytes. Get the byte and tell Cuda to continue.
2153: // Toggle the handshake line, ByteAck, to acknowledge receive.
2154:
2155: // a_buffer[] is the actual buffer going back to ADB.M Callback
2156: cuda_current_response->a_buffer[cuda_transfer_count] =
2157: *VIA1_shift; eieio();
2158: // cuda_read_data();
2159:
2160: if (bImmediate_buff_needed) //just for getRealTimeClock
2161: {
2162: if ( return_buff_pointer)
2163: {
2164: *(return_buff_pointer + cuda_transfer_count) =
2165: cuda_current_response->a_buffer[cuda_transfer_count];
2166:
2167: //kprintf("%x ", cuda_current_response->a_buffer[cuda_transfer_count]);
2168: }
2169: }
2170:
2171: cuda_transfer_count++;
2172:
2173: // cuda_toggle_byte_ack();
2174: *VIA2_dataB ^= kCudaByteAcknowledgeMask; eieio();
2175: } else {
2176: // Cuda is still sending data but the buffer is full.
2177: // Normally should not get here. The only exceptions are open ended
2178: // request such as PRAM read... In any event time to exit.
2179:
2180: // a_bcount is the actual count going back to ADB.M Callback
2181: cuda_current_response->a_bcount = cuda_transfer_count;
2182:
2183: // cuda_read_data();
2184: if (*VIA1_shift); eieio();
2185:
2186: //So far no hits here on kernel bootup 3/20/98
2187:
2188: [self cuda_process_response]; //Rewritten by D.S.
2189: // cuda_neg_tip_and_byteack();
2190: *VIA2_dataB |= kCudaNegateByteAcknowledge | kCudaNegateTransferInProgress;
2191: eieio();
2192: }
2193: }
2194:
2195: //
2196: // cuda_receive_last_byte
2197: // Executes at hardware interrupt level.
2198: //
2199:
2200: -(void) cuda_receive_last_byte
2201: {
2202: volatile unsigned char valcuda; //dummy, unused
2203:
2204:
2205: if ( cuda_is_header_transfer ) {
2206: cuda_current_response->a_header[cuda_transfer_count++] =
2207: *VIA1_shift; eieio();
2208: // cuda_read_data();
2209:
2210: cuda_transfer_count = 0;
2211: } else if ( cuda_transfer_count < cuda_current_response->a_bsize ) {
2212:
2213: cuda_current_response->a_buffer[cuda_transfer_count] =
2214: *VIA1_shift; eieio();
2215:
2216: //Added 1/13/98 A.W.
2217: if (bImmediate_buff_needed) //just for getRealTimeClock
2218: {
2219: if ( return_buff_pointer)
2220: {
2221: *(return_buff_pointer + cuda_transfer_count) =
2222: cuda_current_response->a_buffer[cuda_transfer_count];
2223: }
2224: }
2225: cuda_transfer_count++;
2226:
2227: // cuda_read_data();
2228: } else {
2229: /* Overrun -- ignore data */
2230: //(void) cuda_read_data();
2231: valcuda = *VIA1_shift; eieio();
2232: }
2233:
2234: cuda_current_response->a_bcount = cuda_transfer_count;
2235:
2236: //SD: acknowledge before response so polled mode can work from inside the adb handler
2237:
2238: // cuda_neg_tip_and_byteack();
2239: *VIA2_dataB |= kCudaNegateByteAcknowledge | kCudaNegateTransferInProgress;
2240: eieio();
2241: if (p) kprintf("cuda.m: process response in LAST BYTE, count is %d\n", cuda_transfer_count);
2242: [self cuda_process_response]; //Rewritten by D.S.
2243: }
2244:
2245: /* 3/19/98 A.W. added to fix collision problems */
2246: - (void) cuda_queue:(CudaRequest *)cuda_req
2247: {
2248: CudaMachMessage * toQueue;
2249: IOReturn result;
2250:
2251: que_cuda_count++; //for debugging only
2252: //For collisions, queue up the incoming request from Rhapsody system
2253: // and handle Cuda's urgent request first.
2254: toQueue = (CudaMachMessage*)kalloc(sizeof(CudaMachMessage));
2255: toQueue->msgHeader.msg_size = sizeof(CudaMachMessage);
2256: toQueue->msgHeader.msg_local_port = [self interruptPort];
2257: bcopy (cuda_req, &toQueue->msgBody, sizeof(CudaRequest)); // copy it
2258: toQueue->msgBody.prev = queueTail;
2259: toQueue->msgBody.next = NULL;
2260: if ( queueTail != NULL ) {
2261: queueTail->msgBody.next = toQueue;
2262: }
2263: else
2264: {
2265: queueHead = toQueue;
2266: }
2267: queueTail = toQueue;
2268: }
2269:
2270: //
2271: // cuda_collision
2272: // Executes at hardware interrupt level.
2273: //
2274:
2275: -(void) cuda_collision
2276: {
2277: volatile unsigned char valcuda; //dummy, unused
2278:
2279:
2280: // Clear the pending interrupt by reading the shift register.
2281: //(void)cuda_read_data();
2282: valcuda = *VIA1_shift; eieio();
2283:
2284: // Negate TIP to abort the send. Cuda should send a second attention
2285: // interrupt to acknowledge the abort cycle.
2286: // cuda_neg_transfer_in_progress();
2287: *VIA2_dataB |= kCudaNegateTransferInProgress; eieio();
2288:
2289: // The next interrupt should be an expected attention and the next
2290: // response packet should be an async response.
2291:
2292: cuda_interrupt_state = CUDA_STATE_ATTN_EXPECTED;
2293: cuda_transaction_state = CUDA_TS_ASYNC_RESPONSE;
2294:
2295: /* queue the request */
2296: cuda_collided = cuda_request; //WARNING... unused now, don't use this variable
2297: #ifdef OMIT
2298: cuda_request = NULL;
2299: #endif
2300: cuda_is_header_transfer = FALSE;
2301: cuda_transfer_count = 0;
2302:
2303: [self cuda_queue: cuda_request];
2304: }
2305:
2306: //
2307: // cuda_idle
2308: // Executes at hardware interrupt level.
2309: // A.W. WARNING... what if this state is reached without a client callback available?
2310: // what happens with unsolicited cuda events? Should they go to the ADBRegisterAutopoll
2311: // function?
2312: //
2313:
2314: -(void) cuda_idle
2315: {
2316: volatile unsigned char valcuda; //dummy, unused
2317:
2318: // Clear the pending interrupt by reading the shift register.
2319: //(void)cuda_read_data();
2320: valcuda = *VIA1_shift; eieio();
2321:
2322: // Set to the idle state.
2323: cuda_interrupt_state = CUDA_STATE_IDLE;
2324:
2325: // See if there are any pending requests. There may be a pending request
2326: // if a collision has occured. If so do the resend.
2327:
2328: //if (adb_polling)
2329: //return; /* Prevent recursion */
2330:
2331: //if collision then that has already been queued above, so all we do
2332: // now is check for it.
2333:
2334: [self CheckRequestQueue];
2335:
2336: }
2337:
2338:
2339:
2340: -(void) cuda_error
2341: {
2342: unsigned char valcuda;
2343:
2344: kprintf("\nCUDA:{Error %d}\n", cuda_transaction_state);
2345:
2346: switch (cuda_transaction_state) {
2347: case CUDA_STATE_IDLE:
2348: // cuda_neg_tip_and_byteack();
2349: *VIA2_dataB |= kCudaNegateByteAcknowledge | kCudaNegateTransferInProgress;
2350: eieio();
2351: break;
2352:
2353: case CUDA_STATE_TRANSMIT_EXPECTED:
2354: if (cuda_is_header_transfer && cuda_transfer_count <= 1) {
2355: tick_delay(cuda_state_transition_delay_ticks);
2356: // cuda_neg_transfer_in_progress();
2357: *VIA2_dataB |= kCudaNegateTransferInProgress; eieio();
2358: // cuda_set_data_direction_to_input();
2359: *VIA1_auxillaryControl &= kCudaSystemRecieve; eieio();
2360: //panic ("CUDA - TODO FORCE COMMAND BACK UP!\n");
2361: } else {
2362: cuda_transaction_state = CUDA_STATE_ATTN_EXPECTED;
2363: // cuda_neg_tip_and_byteack();
2364: *VIA2_dataB |= kCudaNegateByteAcknowledge | kCudaNegateTransferInProgress;
2365: eieio();
2366: }
2367: break;
2368:
2369: case CUDA_STATE_ATTN_EXPECTED:
2370: // cuda_assert_transfer_in_progress();
2371: *VIA2_dataB &= kCudaAssertTransferInProgress; eieio();
2372:
2373: tick_delay(cuda_state_transition_delay_ticks);
2374: // cuda_set_data_direction_to_input();
2375: *VIA1_auxillaryControl &= kCudaSystemRecieve; eieio();
2376: // cuda_neg_transfer_in_progress();
2377: *VIA2_dataB |= kCudaNegateTransferInProgress; eieio();
2378: //panic("CUDA - TODO CHECK FOR TRANSACTION TYPE AND ERROR");
2379: break;
2380:
2381: case CUDA_STATE_RECEIVE_EXPECTED:
2382: // cuda_neg_tip_and_byteack();
2383: *VIA2_dataB |= kCudaNegateByteAcknowledge | kCudaNegateTransferInProgress;
2384: eieio();
2385: //panic("Cuda - todo check for transaction type and error");
2386: break;
2387:
2388: default:
2389: // cuda_set_data_direction_to_input();
2390: *VIA1_auxillaryControl &= kCudaSystemRecieve; eieio();
2391: valcuda = *VIA1_shift; eieio(); //Ray Montagne .a indicates this may be useful
2392: // cuda_neg_tip_and_byteack();
2393: *VIA2_dataB |= kCudaNegateByteAcknowledge | kCudaNegateTransferInProgress;
2394: eieio();
2395: break;
2396: }
2397: }
2398:
2399: -(void) poll_device
2400: {
2401: CudaRequest *next;
2402: int interruptflag = *VIA1_interruptFlag & kCudaInterruptMask;
2403: eieio();
2404:
2405: if(interruptflag) {
2406: [self interruptOccurred];
2407: if( cuda_interrupt_state == CUDA_STATE_IDLE) {
2408: [self CheckRequestQueue];
2409: }
2410: }
2411: }
2412:
2413:
2414: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.