![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AppleCuda.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / platform / drvAppleCuda|
Return to AppleCuda.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / platform / drvAppleCuda |
1.1 ! root 1: /* ! 2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991 ! 24: * All Rights Reserved ! 25: * ! 26: * Permission to use, copy, modify, and distribute this software and ! 27: * its documentation for any purpose and without fee is hereby granted, ! 28: * provided that the above copyright notice appears in all copies and ! 29: * that both the copyright notice and this permission notice appear in ! 30: * supporting documentation. ! 31: * ! 32: * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE ! 33: * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ! 34: * FOR A PARTICULAR PURPOSE. ! 35: * ! 36: * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR ! 37: * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM ! 38: * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, ! 39: * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION ! 40: * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ! 41: * ! 42: */ ! 43: /* ! 44: * Copyright 1996 1995 by Apple Computer, Inc. 1997 1996 1995 1994 1993 1992 1991 ! 45: * All Rights Reserved ! 46: * ! 47: * Permission to use, copy, modify, and distribute this software and ! 48: * its documentation for any purpose and without fee is hereby granted, ! 49: * provided that the above copyright notice appears in all copies and ! 50: * that both the copyright notice and this permission notice appear in ! 51: * supporting documentation. ! 52: * ! 53: * APPLE COMPUTER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE ! 54: * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ! 55: * FOR A PARTICULAR PURPOSE. ! 56: * ! 57: * IN NO EVENT SHALL APPLE COMPUTER BE LIABLE FOR ANY SPECIAL, INDIRECT, OR ! 58: * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM ! 59: * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, ! 60: * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION ! 61: * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ! 62: */ ! 63: /* ! 64: * MKLINUX-1.0DR2 ! 65: */ ! 66: ! 67: /* 1 April 1997 Simon Douglas: ! 68: * Stolen wholesale from MkLinux. ! 69: * Added nonblocking adb poll from interrupt level for the debugger. ! 70: * Acknowledge before response so polled mode can work from inside the adb handler. ! 71: * ! 72: * 18 June 1998 sdouglas ! 73: * Start IOKit version. Fix errors from kCudaSRQAssertMask. Use ool cmd & reply buffers, ! 74: * not fixed len in packet. Does queueing here. ! 75: * ! 76: * 20 Nov 1998 suurballe ! 77: * Port to C++ ! 78: */ ! 79: ! 80: ! 81: #include "AppleCuda.h" ! 82: #include "IOCudaADBController.h" ! 83: #include <IOKit/IOLib.h> ! 84: #include <IOKit/IOSyncer.h> ! 85: #include <IOKit/IOWorkLoop.h> ! 86: #include <IOKit/IOInterruptEventSource.h> ! 87: #include <IOKit/IODeviceMemory.h> ! 88: #include <IOKit/IOPlatformExpert.h> ! 89: ! 90: #include <IOKit/assert.h> ! 91: ! 92: #define super IOService ! 93: OSDefineMetaClassAndStructors(AppleCuda,IOService) ! 94: ! 95: static void cuda_interrupt ( AppleCuda * self ); ! 96: ! 97: static void cuda_process_response(AppleCuda * self); ! 98: static void cuda_transmit_data(AppleCuda * self); ! 99: static void cuda_expected_attention(AppleCuda * self); ! 100: static void cuda_unexpected_attention(AppleCuda * self); ! 101: static void cuda_receive_data(AppleCuda * self); ! 102: static void cuda_receive_last_byte(AppleCuda * self); ! 103: static void cuda_collision(AppleCuda * self); ! 104: static void cuda_idle(AppleCuda * self); ! 105: ! 106: static void cuda_poll(AppleCuda * self); ! 107: static void cuda_error(AppleCuda * self); ! 108: static void cuda_send_request(AppleCuda * self); ! 109: static IOReturn cuda_do_sync_request( AppleCuda * self, ! 110: cuda_request_t * request, bool polled); ! 111: static void cuda_do_state_transition_delay(AppleCuda * self); ! 112: ! 113: static int Cuda_PE_poll_input(unsigned int options, char * c); ! 114: static int Cuda_PE_read_write_time_of_day(unsigned int options, long * secs); ! 115: static int Cuda_PE_halt_restart(unsigned int type); ! 116: static int Cuda_PE_write_IIC(unsigned char addr, unsigned char reg, ! 117: unsigned char data); ! 118: ! 119: static void ! 120: autopollArrived ( OSObject *inCuda, IOInterruptEventSource *, int ); ! 121: ! 122: ! 123: // ! 124: // inline functions ! 125: // ! 126: ! 127: static __inline__ unsigned char cuda_read_data(AppleCuda * self) ! 128: { ! 129: volatile unsigned char val; ! 130: ! 131: val = *self->cuda_via_regs.shift; eieio(); ! 132: return val; ! 133: } ! 134: ! 135: static __inline__ int cuda_get_result(cuda_request_t *request) ! 136: { ! 137: int status = ADB_RET_OK; ! 138: int theStatus = request->a_reply.a_header[1]; ! 139: ! 140: if ( theStatus & kCudaTimeOutMask ) { ! 141: status = ADB_RET_TIMEOUT; ! 142: #if 0 ! 143: // these are expected before autopoll mask is set ! 144: } else if ( theStatus & kCudaSRQAssertMask ) { ! 145: status = ADB_RET_UNEXPECTED_RESULT; ! 146: #endif ! 147: } else if ( theStatus & kCudaSRQErrorMask ) { ! 148: status = ADB_RET_REQUEST_ERROR; ! 149: } else if ( theStatus & kCudaBusErrorMask ) { ! 150: status = ADB_RET_BUS_ERROR; ! 151: } ! 152: ! 153: return status; ! 154: } ! 155: ! 156: static __inline__ void cuda_lock(AppleCuda * self) ! 157: { ! 158: if( !self->cuda_polled_mode) ! 159: IOSimpleLockLock(self->cuda_request_lock); ! 160: } ! 161: ! 162: static __inline__ void cuda_unlock(AppleCuda * self) ! 163: { ! 164: if( !self->cuda_polled_mode) ! 165: IOSimpleLockUnlock(self->cuda_request_lock); ! 166: } ! 167: ! 168: // ! 169: // ! 170: // ! 171: ! 172: ! 173: static AppleCuda * gCuda; ! 174: // ********************************************************************************** ! 175: // init ! 176: // ! 177: // ********************************************************************************** ! 178: bool AppleCuda::init ( OSDictionary * properties = 0 ) ! 179: { ! 180: return super::init(properties); ! 181: } ! 182: ! 183: ! 184: // ********************************************************************************** ! 185: // start ! 186: // ! 187: // ********************************************************************************** ! 188: bool AppleCuda::start ( IOService * nub ) ! 189: { ! 190: int i; ! 191: IOMemoryMap * viaMap; ! 192: unsigned char * cuda_base; ! 193: ! 194: if( !super::start(nub)) ! 195: return false; ! 196: ! 197: gCuda = this; ! 198: ! 199: workLoop = NULL; ! 200: eventSrc = NULL; ! 201: ourADBinterface = NULL; ! 202: ! 203: workLoop = IOWorkLoop::workLoop(); ! 204: if ( !workLoop ) { ! 205: kprintf("Start is bailing\n"); ! 206: return false; ! 207: } ! 208: ! 209: eventSrc = IOInterruptEventSource::interruptEventSource(this, autopollArrived); ! 210: if (!eventSrc || ! 211: kIOReturnSuccess != workLoop->addEventSource(eventSrc) ) { ! 212: kprintf("Start is bailing\n"); ! 213: return false; ! 214: } ! 215: ! 216: if( 0 == (viaMap = nub->mapDeviceMemoryWithIndex( 0 )) ) { ! 217: IOLog("%s: no via memory\n", getName()); ! 218: kprintf("Start is bailing\n"); ! 219: return false; ! 220: } ! 221: cuda_base = (unsigned char *)viaMap->getVirtualAddress(); ! 222: ! 223: kprintf("VIA base = %08x\n", (UInt32)cuda_base); ! 224: ourADBinterface = new IOCudaADBController; ! 225: if ( !ourADBinterface ) { ! 226: kprintf("Start is bailing\n"); ! 227: return false; ! 228: } ! 229: if ( !ourADBinterface->init(0,this) ) { ! 230: kprintf("Start is bailing\n"); ! 231: return false; ! 232: } ! 233: ! 234: if ( !ourADBinterface->attach( this) ) { ! 235: kprintf("Start is bailing\n"); ! 236: return false; ! 237: } ! 238: ! 239: cuda_request_lock = IOSimpleLockAlloc(); ! 240: IOSimpleLockInit(cuda_request_lock); ! 241: ! 242: cuda_via_regs.dataB = cuda_base; ! 243: cuda_via_regs.handshakeDataA = cuda_base+0x0200; ! 244: cuda_via_regs.dataDirectionB = cuda_base+0x0400; ! 245: cuda_via_regs.dataDirectionA = cuda_base+0x0600; ! 246: cuda_via_regs.timer1CounterLow = cuda_base+0x0800; ! 247: cuda_via_regs.timer1CounterHigh = cuda_base+0x0A00; ! 248: cuda_via_regs.timer1LatchLow = cuda_base+0x0C00; ! 249: cuda_via_regs.timer1LatchHigh = cuda_base+0x0E00; ! 250: cuda_via_regs.timer2CounterLow = cuda_base+0x1000; ! 251: cuda_via_regs.timer2CounterHigh = cuda_base+0x1200; ! 252: cuda_via_regs.shift = cuda_base+0x1400; ! 253: cuda_via_regs.auxillaryControl = cuda_base+0x1600; ! 254: cuda_via_regs.peripheralControl = cuda_base+0x1800; ! 255: cuda_via_regs.interruptFlag = cuda_base+0x1A00; ! 256: cuda_via_regs.interruptEnable = cuda_base+0x1C00; ! 257: cuda_via_regs.dataA = cuda_base+0x1E00; ! 258: ! 259: // we require delays of this duration between certain state transitions ! 260: clock_interval_to_absolutetime_interval(200, 1, &cuda_state_transition_delay); ! 261: ! 262: // Set the direction of the cuda signals. ByteACk and TIP are output and ! 263: // TREQ is an input ! 264: ! 265: *cuda_via_regs.dataDirectionB |= (kCudaByteAcknowledgeMask | kCudaTransferInProgressMask); ! 266: *cuda_via_regs.dataDirectionB &= ~kCudaTransferRequestMask; ! 267: ! 268: // Set the clock control. Set to shift data in by external clock CB1. ! 269: ! 270: *cuda_via_regs.auxillaryControl = (*cuda_via_regs.auxillaryControl | kCudaTransferMode) & ! 271: kCudaSystemRecieve; ! 272: ! 273: // Clear any posible cuda interupt. ! 274: ! 275: if ( *cuda_via_regs.shift ); ! 276: ! 277: // Initialize the internal data. ! 278: ! 279: cuda_interrupt_state = CUDA_STATE_IDLE; ! 280: cuda_transaction_state = CUDA_TS_NO_REQUEST; ! 281: cuda_is_header_transfer = false; ! 282: cuda_is_packet_type = false; ! 283: cuda_transfer_count = 0; ! 284: cuda_current_response = NULL; ! 285: for( i = 0; i < NUM_AP_BUFFERS; i++ ) { ! 286: cuda_unsolicited[ i ].a_buffer = cuda_autopoll_buffers[ i ]; ! 287: } ! 288: ! 289: // Terminate transaction and set idle state ! 290: ! 291: cuda_neg_tip_and_byteack(this); ! 292: ! 293: // we want to delay 4 mS for ADB reset to complete ! 294: ! 295: IOSleep( 4 ); ! 296: ! 297: // Clear pending interrupt if any... ! 298: ! 299: (void)cuda_read_data(this); ! 300: ! 301: // Issue a Sync Transaction, ByteAck asserted while TIP is negated. ! 302: ! 303: cuda_assert_byte_ack(this); ! 304: ! 305: // Wait for the Sync acknowledgement, cuda to assert TREQ ! 306: ! 307: cuda_wait_for_transfer_request_assert(this); ! 308: ! 309: // Wait for the Sync acknowledgement interrupt. ! 310: ! 311: cuda_wait_for_interrupt(this); ! 312: ! 313: // Clear pending interrupt ! 314: ! 315: (void)cuda_read_data(this); ! 316: ! 317: // Terminate the sync cycle by Negating ByteAck ! 318: ! 319: cuda_neg_byte_ack(this); ! 320: ! 321: // Wait for the Sync termination acknowledgement, cuda negates TREQ. ! 322: ! 323: cuda_wait_for_transfer_request_neg(this); ! 324: ! 325: // Wait for the Sync termination acknowledgement interrupt. ! 326: ! 327: cuda_wait_for_interrupt(this); ! 328: ! 329: // Terminate transaction and set idle state, TIP negate and ByteAck negate. ! 330: cuda_neg_transfer_in_progress(this); ! 331: ! 332: // Clear pending interrupt, if there is one... ! 333: (void)cuda_read_data(this); ! 334: ! 335: #if 0 ! 336: cuda_polled_mode = true; ! 337: #else ! 338: #define VIA_DEV_CUDA 2 ! 339: nub->registerInterrupt(VIA_DEV_CUDA, ! 340: this, (IOInterruptAction) cuda_interrupt); ! 341: nub->enableInterrupt(VIA_DEV_CUDA); ! 342: #endif ! 343: ! 344: PE_poll_input = Cuda_PE_poll_input; ! 345: PE_read_write_time_of_day = Cuda_PE_read_write_time_of_day; ! 346: PE_halt_restart = Cuda_PE_halt_restart; ! 347: PE_write_IIC = Cuda_PE_write_IIC; ! 348: publishResource( "IOiic0", this ); ! 349: publishResource( "IORTC", this ); ! 350: ! 351: ourADBinterface->start( this ); ! 352: ! 353: return true; ! 354: } ! 355: ! 356: ! 357: // ***************************************************************************** ! 358: // getWorkLoop ! 359: // ! 360: // Return the cuda's workloop. ! 361: // ! 362: // ***************************************************************************** ! 363: IOWorkLoop *AppleCuda::getWorkLoop() const ! 364: { ! 365: return workLoop; ! 366: } ! 367: ! 368: // ***************************************************************************** ! 369: // free ! 370: // ! 371: // Release everything we may have allocated. ! 372: // ! 373: // ***************************************************************************** ! 374: void AppleCuda::free ( void ) ! 375: { ! 376: if ( workLoop ) { ! 377: workLoop->release(); ! 378: } ! 379: if ( eventSrc ) { ! 380: eventSrc->release(); ! 381: } ! 382: if ( ourADBinterface ) { ! 383: ourADBinterface->release(); ! 384: } ! 385: super::free(); ! 386: } ! 387: ! 388: ! 389: // ********************************************************************************** ! 390: // registerForADBInterrupts ! 391: // ! 392: // Some driver is calling to say it is prepared to receive "unsolicited" adb ! 393: // interrupts (e.g. autopoll keyboard and trackpad data). The parameters identify ! 394: // who to call when we get one. ! 395: // ********************************************************************************** ! 396: void AppleCuda::registerForADBInterrupts ( ADB_callback_func handler, IOService * caller ) ! 397: { ! 398: autopoll_handler = handler; ! 399: ADBid = caller; ! 400: } ! 401: ! 402: ! 403: // ********************************************************************************** ! 404: // autopollArrived ! 405: // ! 406: // ********************************************************************************** ! 407: static void autopollArrived ( OSObject * CudaDriver, IOInterruptEventSource *, int ) ! 408: { ! 409: ((AppleCuda *)CudaDriver)->serviceAutopolls(); ! 410: } ! 411: ! 412: ! 413: // ********************************************************************************** ! 414: // serviceAutopolls ! 415: // ! 416: // ********************************************************************************** ! 417: void AppleCuda::serviceAutopolls ( void ) ! 418: { ! 419: cuda_packet_t * response; ! 420: ! 421: while( inIndex != outIndex ) { ! 422: ! 423: response = &cuda_unsolicited[ outIndex ]; ! 424: ! 425: if ( ADBid != NULL ) { ! 426: (*autopoll_handler)(ADBid,response->a_header[2],response->a_bcount,response->a_buffer); ! 427: } ! 428: ! 429: outIndex = (outIndex + 1) & (NUM_AP_BUFFERS - 1); ! 430: } ! 431: } ! 432: ! 433: ! 434: // ********************************************************************************** ! 435: // doSyncRequest ! 436: // ! 437: // ********************************************************************************** ! 438: IOReturn AppleCuda::doSyncRequest ( cuda_request_t * request ) ! 439: { ! 440: return(cuda_do_sync_request(this, request, false)); ! 441: } ! 442: ! 443: ! 444: // ********************************************************************************** ! 445: // cuda_do_sync_request ! 446: // ! 447: // ********************************************************************************** ! 448: IOReturn cuda_do_sync_request ( AppleCuda * self, cuda_request_t * request, bool polled ) ! 449: { ! 450: bool wasPolled = false; ! 451: IOInterruptState ints; ! 452: ! 453: if( !polled ) { ! 454: request->sync = IOSyncer::create(); ! 455: request->needWake = true; ! 456: } ! 457: ! 458: ints = IOSimpleLockLockDisableInterrupt(self->cuda_request_lock); ! 459: ! 460: if( polled ) { ! 461: wasPolled = self->cuda_polled_mode; ! 462: self->cuda_polled_mode = polled; ! 463: } ! 464: ! 465: if( self->cuda_last_request ) ! 466: self->cuda_last_request->a_next = request; ! 467: else ! 468: self->cuda_request = request; ! 469: ! 470: self->cuda_last_request = request; ! 471: ! 472: if( self->cuda_interrupt_state == CUDA_STATE_IDLE ) ! 473: cuda_send_request(self); ! 474: ! 475: if( polled ) { ! 476: cuda_poll(self); ! 477: self->cuda_polled_mode = wasPolled; ! 478: assert( 0 == self->cuda_request ); ! 479: assert( 0 == self->cuda_last_request ); ! 480: } ! 481: ! 482: IOSimpleLockUnlockEnableInterrupt(self->cuda_request_lock, ints); ! 483: ! 484: if( !polled) ! 485: request->sync->wait(); ! 486: ! 487: return cuda_get_result(request); ! 488: } ! 489: ! 490: ! 491: // ********************************************************************************** ! 492: // Cuda_PE_read_write_time_of_day ! 493: // ! 494: // ********************************************************************************** ! 495: static int Cuda_PE_read_write_time_of_day ( unsigned int options, long * secs ) ! 496: { ! 497: cuda_request_t cmd; ! 498: ! 499: adb_init_request(&cmd); ! 500: ! 501: cmd.a_cmd.a_hcount = 2; ! 502: cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO; ! 503: ! 504: switch( options ) { ! 505: ! 506: case kPEReadTOD: ! 507: cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_GET_REAL_TIME; ! 508: cmd.a_reply.a_buffer = (UInt8 *)secs; ! 509: cmd.a_reply.a_bcount = sizeof(*secs); ! 510: break; ! 511: ! 512: case kPEWriteTOD: ! 513: cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_SET_REAL_TIME; ! 514: cmd.a_cmd.a_buffer = (UInt8 *)secs; ! 515: cmd.a_cmd.a_bcount = sizeof(*secs); ! 516: break; ! 517: ! 518: default: ! 519: return 1; ! 520: } ! 521: ! 522: return cuda_do_sync_request(gCuda, &cmd, true); ! 523: } ! 524: ! 525: ! 526: // ********************************************************************************** ! 527: // Cuda_PE_halt_restart ! 528: // ! 529: // ********************************************************************************** ! 530: static int Cuda_PE_halt_restart ( unsigned int type ) ! 531: { ! 532: cuda_request_t cmd; ! 533: ! 534: adb_init_request(&cmd); ! 535: ! 536: cmd.a_cmd.a_hcount = 2; ! 537: cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO; ! 538: ! 539: switch( type ) { ! 540: ! 541: case kPERestartCPU: ! 542: cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_RESTART_SYSTEM; ! 543: break; ! 544: ! 545: case kPEHaltCPU: ! 546: cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_POWER_DOWN; ! 547: break; ! 548: ! 549: default: ! 550: return 1; ! 551: } ! 552: ! 553: return cuda_do_sync_request(gCuda, &cmd, true); ! 554: } ! 555: ! 556: ! 557: // ********************************************************************************** ! 558: // Cuda_PE_write_IIC ! 559: // ! 560: // ********************************************************************************** ! 561: static int Cuda_PE_write_IIC ( unsigned char addr, unsigned char reg, unsigned char data ) ! 562: { ! 563: cuda_request_t cmd; ! 564: ! 565: adb_init_request(&cmd); ! 566: ! 567: cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO; ! 568: cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_GET_SET_IIC; ! 569: cmd.a_cmd.a_header[2] = addr; ! 570: cmd.a_cmd.a_header[3] = reg; ! 571: cmd.a_cmd.a_header[4] = data; ! 572: cmd.a_cmd.a_hcount = 5; ! 573: ! 574: return cuda_do_sync_request(gCuda, &cmd, true); ! 575: } ! 576: ! 577: ! 578: // ********************************************************************************** ! 579: // Cuda_PE_poll_input ! 580: // ! 581: // ********************************************************************************** ! 582: static int Cuda_PE_poll_input ( unsigned int, char * c ) ! 583: { ! 584: AppleCuda * self = gCuda; ! 585: int interruptflag; ! 586: UInt8 code; ! 587: cuda_packet_t * response; //0123456789abcdef ! 588: static char keycodes2ascii[] = "asdfhgzxcv_bqwer" //00 ! 589: "yt123465=97-80]o" //10 ! 590: "u[ip\nlj'k;_,/nm." //20 ! 591: "\t_"; //30 ! 592: ! 593: *c = 0xff; ! 594: ! 595: if( !self ) { ! 596: return 1; ! 597: } ! 598: ! 599: self->cuda_polled_mode = true; ! 600: interruptflag = *self->cuda_via_regs.interruptFlag & kCudaInterruptMask; ! 601: eieio(); ! 602: if( interruptflag ) { ! 603: cuda_interrupt(self); ! 604: } ! 605: ! 606: if( self->inIndex != self->outIndex ) { ! 607: response = &self->cuda_unsolicited[ self->outIndex ]; ! 608: if( ((response->a_header[2] >> 4) == 2) ! 609: && (response->a_bcount > 1) ) { ! 610: code = response->a_buffer[0]; ! 611: if( code < sizeof(keycodes2ascii) ) { ! 612: *c = keycodes2ascii[ code ]; ! 613: } ! 614: } ! 615: self->outIndex = self->inIndex; ! 616: } ! 617: ! 618: self->cuda_polled_mode = false; ! 619: return 0; ! 620: } ! 621: ! 622: ! 623: // ! 624: // internal ! 625: // ! 626: ! 627: ! 628: // ********************************************************************************** ! 629: // cuda_send_request ! 630: // ! 631: // ********************************************************************************** ! 632: static void cuda_send_request ( AppleCuda * self ) ! 633: { ! 634: ! 635: // The data register must written with the data byte 25uS ! 636: // after examining TREQ or we run the risk of getting out of sync ! 637: // with Cuda. So call with disabled interrupts and spinlock held. ! 638: ! 639: // Check if we can commence with the packet transmission. First, check if ! 640: // Cuda can service our request now. Second, check if Cuda wants to send ! 641: // a response packet now. ! 642: ! 643: if( !cuda_is_transfer_in_progress(self) ) { ! 644: // Set the shift register direction to output to Cuda by setting ! 645: // the direction bit. ! 646: ! 647: cuda_set_data_direction_to_output(self); ! 648: ! 649: // Write the first byte to the shift register ! 650: cuda_write_data(self, self->cuda_request->a_cmd.a_header[0]); ! 651: ! 652: // Set up the transfer state info here. ! 653: ! 654: self->cuda_is_header_transfer = true; ! 655: self->cuda_transfer_count = 1; ! 656: ! 657: // Make sure we're in idle state before transaction, and then ! 658: // assert TIP to tell Cuda we're starting command ! 659: cuda_neg_byte_ack(self); ! 660: cuda_assert_transfer_in_progress(self); ! 661: ! 662: // The next state is going to be a transmit state, if there is ! 663: // no collision. This is a requested response but call it sync. ! 664: ! 665: self->cuda_interrupt_state = CUDA_STATE_TRANSMIT_EXPECTED; ! 666: self->cuda_transaction_state = CUDA_TS_SYNC_RESPONSE; ! 667: } ! 668: ! 669: #if 0 ! 670: else { ! 671: IOLog("Req = %x, state = %x, TIP = %x\n", self->cuda_request, ! 672: self->cuda_interrupt_state, cuda_is_transfer_in_progress(self)); ! 673: } ! 674: #endif ! 675: } ! 676: ! 677: ! 678: // ********************************************************************************** ! 679: // cuda_poll ! 680: // ! 681: // ********************************************************************************** ! 682: static void cuda_poll( AppleCuda * self ) ! 683: { ! 684: do { ! 685: cuda_wait_for_interrupt(self); ! 686: cuda_interrupt(self); ! 687: } while( self->cuda_interrupt_state != CUDA_STATE_IDLE ); ! 688: } ! 689: ! 690: // ! 691: // cuda_process_response ! 692: // Execute at secondary interrupt. ! 693: // ! 694: ! 695: ! 696: // ********************************************************************************** ! 697: // cuda_process_response ! 698: // ! 699: // ********************************************************************************** ! 700: static void cuda_process_response ( AppleCuda * self ) ! 701: { ! 702: volatile cuda_request_t * request; ! 703: unsigned int newIndex; ! 704: ! 705: // Almost ready for the next state, which should be a Idle state. ! 706: // Just need to notifiy the client. ! 707: ! 708: if ( self->cuda_transaction_state == CUDA_TS_SYNC_RESPONSE ) { ! 709: ! 710: // dequeue reqeuest ! 711: cuda_lock(self); ! 712: request = self->cuda_request; ! 713: if( NULL == (self->cuda_request = request->a_next) ) { ! 714: self->cuda_last_request = NULL; ! 715: } ! 716: cuda_unlock(self); ! 717: ! 718: // wake the sync request thread ! 719: if ( ((cuda_request_t *)request)->needWake ) { ! 720: ((cuda_request_t *)request)->sync->signal(); ! 721: } ! 722: ! 723: } ! 724: else { ! 725: if ( self->cuda_transaction_state == CUDA_TS_ASYNC_RESPONSE ) { ! 726: newIndex = (self->inIndex + 1) & (NUM_AP_BUFFERS - 1); ! 727: if( newIndex != self->outIndex ) { ! 728: self->inIndex = newIndex; ! 729: } ! 730: else { ! 731: // drop this packet, and reuse the buffer ! 732: } ! 733: if ( !self->cuda_polled_mode ) { ! 734: // wake thread to service autopolls ! 735: self->eventSrc->interruptOccurred(0, 0, 0); ! 736: } ! 737: } ! 738: } ! 739: return; ! 740: } ! 741: ! 742: ! 743: // ********************************************************************************** ! 744: // cuda_interrupt ! 745: // ! 746: // ********************************************************************************** ! 747: static void cuda_interrupt ( AppleCuda * self ) ! 748: { ! 749: unsigned char interruptState; ! 750: ! 751: // Get the relevant signal in determining the cause of the interrupt: ! 752: // the shift direction, the transfer request line and the transfer ! 753: // request line. ! 754: ! 755: interruptState = cuda_get_interrupt_state(self); ! 756: ! 757: //kprintf("%02x",interruptState); ! 758: ! 759: switch ( interruptState ) { ! 760: case kCudaReceiveByte: ! 761: cuda_receive_data(self); ! 762: break; ! 763: ! 764: case kCudaReceiveLastByte: ! 765: cuda_receive_last_byte(self); ! 766: break; ! 767: ! 768: case kCudaTransmitByte: ! 769: cuda_transmit_data(self); ! 770: break; ! 771: ! 772: case kCudaUnexpectedAttention: ! 773: cuda_unexpected_attention(self); ! 774: break; ! 775: ! 776: case kCudaExpectedAttention: ! 777: cuda_expected_attention(self); ! 778: break; ! 779: ! 780: case kCudaIdleState: ! 781: cuda_idle(self); ! 782: break; ! 783: ! 784: case kCudaCollision: ! 785: cuda_collision(self); ! 786: break; ! 787: ! 788: // Unknown interrupt, clear it and leave. ! 789: default: ! 790: cuda_error(self); ! 791: break; ! 792: } ! 793: } ! 794: ! 795: // ! 796: // TransmitCudaData ! 797: // Executes at hardware interrupt level. ! 798: // ! 799: ! 800: // ********************************************************************************** ! 801: // cuda_transmit_data ! 802: // ! 803: // ********************************************************************************** ! 804: static void cuda_transmit_data ( AppleCuda * self ) ! 805: { ! 806: // Clear the pending interrupt by reading the shift register. ! 807: ! 808: if ( self->cuda_is_header_transfer ) { ! 809: // There are more header bytes, write one out. ! 810: cuda_write_data(self, self->cuda_request->a_cmd.a_header[self->cuda_transfer_count++]); ! 811: ! 812: // Toggle the handshake line. ! 813: if ( self->cuda_transfer_count >= self->cuda_request->a_cmd.a_hcount ) { ! 814: self->cuda_is_header_transfer = FALSE; ! 815: self->cuda_transfer_count = 0; ! 816: } ! 817: ! 818: cuda_toggle_byte_ack( self); ! 819: } ! 820: else { ! 821: if ( self->cuda_transfer_count < self->cuda_request->a_cmd.a_bcount ) { ! 822: // There are more command bytes, write one out and update the pointer ! 823: cuda_write_data( self, ! 824: *(self->cuda_request->a_cmd.a_buffer + self->cuda_transfer_count++)); ! 825: // Toggle the handshake line. ! 826: cuda_toggle_byte_ack(self); ! 827: } ! 828: else { ! 829: (void)cuda_read_data(self); ! 830: // There is no more command bytes, terminate the send transaction. ! 831: // Cuda should send a expected attention interrupt soon. ! 832: ! 833: cuda_neg_tip_and_byteack(self); ! 834: ! 835: // The next interrupt should be a expected attention interrupt. ! 836: ! 837: self->cuda_interrupt_state = CUDA_STATE_ATTN_EXPECTED; ! 838: } ! 839: } ! 840: } ! 841: ! 842: // ! 843: // cuda_expected_attention ! 844: // Executes at hardware interrupt level. ! 845: // ! 846: ! 847: ! 848: // ********************************************************************************** ! 849: // cuda_expected_attention ! 850: // ! 851: // ********************************************************************************** ! 852: static void cuda_expected_attention ( AppleCuda * self ) ! 853: { ! 854: // Clear the pending interrupt by reading the shift register. ! 855: ! 856: (void)cuda_read_data(self); ! 857: ! 858: // Allow the VIA to settle directions.. else the possibility of ! 859: // data corruption. ! 860: cuda_do_state_transition_delay(self); ! 861: ! 862: if ( self->cuda_transaction_state == CUDA_TS_SYNC_RESPONSE ) { ! 863: self->cuda_current_response = (cuda_packet_t*)&self->cuda_request->a_reply; ! 864: } ! 865: else { ! 866: self->cuda_current_response = &self->cuda_unsolicited[ self->inIndex ]; ! 867: self->cuda_current_response->a_hcount = 0; ! 868: self->cuda_current_response->a_bcount = MAX_AP_RESPONSE; ! 869: } ! 870: ! 871: self->cuda_is_header_transfer = true; ! 872: self->cuda_is_packet_type = true; ! 873: self->cuda_transfer_count = 0; ! 874: ! 875: // Set the shift register direction to input. ! 876: cuda_set_data_direction_to_input(self); ! 877: ! 878: // Start the response packet transaction. ! 879: cuda_assert_transfer_in_progress(self); ! 880: ! 881: // The next interrupt should be a receive data interrupt. ! 882: self->cuda_interrupt_state = CUDA_STATE_RECEIVE_EXPECTED; ! 883: } ! 884: ! 885: // ! 886: // cuda_unexpected_attention ! 887: // Executes at hardware interrupt level. ! 888: // ! 889: ! 890: ! 891: // ********************************************************************************** ! 892: // cuda_expected_attention ! 893: // ! 894: // ********************************************************************************** ! 895: static void cuda_unexpected_attention ( AppleCuda * self ) ! 896: { ! 897: // Clear the pending interrupt by reading the shift register. ! 898: (void)cuda_read_data(self); ! 899: ! 900: // Get ready for a unsolicited response. ! 901: self->cuda_current_response = &self->cuda_unsolicited[ self->inIndex ]; ! 902: self->cuda_current_response->a_hcount = 0; ! 903: self->cuda_current_response->a_bcount = MAX_AP_RESPONSE; ! 904: ! 905: self->cuda_is_header_transfer = TRUE; ! 906: self->cuda_is_packet_type = TRUE; ! 907: self->cuda_transfer_count = 0; ! 908: ! 909: // Start the response packet transaction, Transaction In Progress ! 910: cuda_assert_transfer_in_progress(self); ! 911: ! 912: // The next interrupt should be a receive data interrupt and the next ! 913: // response should be an async response. ! 914: ! 915: self->cuda_interrupt_state = CUDA_STATE_RECEIVE_EXPECTED; ! 916: ! 917: self->cuda_transaction_state = CUDA_TS_ASYNC_RESPONSE; ! 918: } ! 919: ! 920: // ! 921: // cuda_receive_data ! 922: // Executes at hardware interrupt level. ! 923: // ! 924: ! 925: ! 926: // ********************************************************************************** ! 927: // cuda_receive_data ! 928: // ! 929: // ********************************************************************************** ! 930: static void cuda_receive_data ( AppleCuda * self ) ! 931: { ! 932: if ( self->cuda_is_packet_type ) { ! 933: unsigned char packetType; ! 934: ! 935: packetType = cuda_read_data( self); ! 936: self->cuda_current_response->a_header[self->cuda_transfer_count++] = packetType; ! 937: ! 938: if ( packetType == ADB_PACKET_ERROR) { ! 939: self->cuda_current_response->a_hcount = 4; ! 940: } ! 941: else { ! 942: self->cuda_current_response->a_hcount = 3; ! 943: } ! 944: ! 945: self->cuda_is_packet_type = false; ! 946: ! 947: cuda_toggle_byte_ack(self); ! 948: ! 949: } ! 950: else { ! 951: if ( self->cuda_is_header_transfer ) { ! 952: ! 953: self->cuda_current_response->a_header[self->cuda_transfer_count++] = ! 954: cuda_read_data(self); ! 955: ! 956: if (self->cuda_transfer_count >= self->cuda_current_response->a_hcount) { ! 957: self->cuda_is_header_transfer = FALSE; ! 958: self->cuda_transfer_count = 0; ! 959: } ! 960: ! 961: cuda_toggle_byte_ack(self); ! 962: } ! 963: else { ! 964: if ( self->cuda_transfer_count < self->cuda_current_response->a_bcount ) { ! 965: // Still room for more bytes. Get the byte and tell Cuda to continue. ! 966: // Toggle the handshake line, ByteAck, to acknowledge receive. ! 967: ! 968: *(self->cuda_current_response->a_buffer + self->cuda_transfer_count++) = ! 969: cuda_read_data(self); ! 970: ! 971: cuda_toggle_byte_ack(self); ! 972: ! 973: } ! 974: else { ! 975: // Cuda is still sending data but the buffer is full. ! 976: // Normally should not get here. The only exceptions are open ended ! 977: // request such as PRAM read... In any event time to exit. ! 978: ! 979: self->cuda_current_response->a_bcount = self->cuda_transfer_count; ! 980: ! 981: cuda_read_data(self); ! 982: ! 983: cuda_process_response(self); ! 984: cuda_neg_tip_and_byteack(self); ! 985: } ! 986: } ! 987: } ! 988: } ! 989: ! 990: ! 991: // ! 992: // cuda_receive_last_byte ! 993: // Executes at hardware interrupt level. ! 994: // ! 995: ! 996: ! 997: // ********************************************************************************** ! 998: // cuda_receive_last_byte ! 999: // ! 1000: // ********************************************************************************** ! 1001: static void cuda_receive_last_byte ( AppleCuda * self ) ! 1002: { ! 1003: if ( self->cuda_is_header_transfer ) { ! 1004: self->cuda_current_response->a_header[self->cuda_transfer_count++] = ! 1005: cuda_read_data(self); ! 1006: ! 1007: self->cuda_transfer_count = 0; ! 1008: } ! 1009: else { ! 1010: if ( self->cuda_transfer_count < self->cuda_current_response->a_bcount ) { ! 1011: *(self->cuda_current_response->a_buffer + self->cuda_transfer_count++) = ! 1012: cuda_read_data(self); ! 1013: } ! 1014: else { ! 1015: /* Overrun -- ignore data */ ! 1016: (void) cuda_read_data(self); ! 1017: } ! 1018: } ! 1019: self->cuda_current_response->a_bcount = self->cuda_transfer_count; ! 1020: ! 1021: // acknowledge before response so polled mode can work ! 1022: // from inside the handler ! 1023: cuda_neg_tip_and_byteack(self); ! 1024: cuda_process_response(self); ! 1025: } ! 1026: ! 1027: ! 1028: // ! 1029: // cuda_collision ! 1030: // Executes at hardware interrupt level. ! 1031: // ! 1032: ! 1033: ! 1034: // ********************************************************************************** ! 1035: // cuda_collision ! 1036: // ! 1037: // ********************************************************************************** ! 1038: static void cuda_collision ( AppleCuda * self ) ! 1039: { ! 1040: // Clear the pending interrupt by reading the shift register. ! 1041: (void)cuda_read_data(self); ! 1042: ! 1043: // Negate TIP to abort the send. Cuda should send a second attention ! 1044: // interrupt to acknowledge the abort cycle. ! 1045: cuda_neg_transfer_in_progress(self); ! 1046: ! 1047: // The next interrupt should be an expected attention and the next ! 1048: // response packet should be an async response. ! 1049: ! 1050: self->cuda_interrupt_state = CUDA_STATE_ATTN_EXPECTED; ! 1051: self->cuda_transaction_state = CUDA_TS_ASYNC_RESPONSE; ! 1052: ! 1053: /* queue the request */ ! 1054: self->cuda_is_header_transfer = false; ! 1055: self->cuda_transfer_count = 0; ! 1056: } ! 1057: ! 1058: ! 1059: // ! 1060: // ! 1061: // Executes at hardware interrupt level. ! 1062: // ! 1063: ! 1064: ! 1065: // ********************************************************************************** ! 1066: // cuda_idle ! 1067: // ! 1068: // ********************************************************************************** ! 1069: static void cuda_idle ( AppleCuda * self ) ! 1070: { ! 1071: ! 1072: // Clear the pending interrupt by reading the shift register. ! 1073: (void)cuda_read_data(self); ! 1074: ! 1075: cuda_lock(self); ! 1076: // Set to the idle state. ! 1077: self->cuda_interrupt_state = CUDA_STATE_IDLE; ! 1078: // See if there are any pending requests. ! 1079: if( self->cuda_request ) { ! 1080: cuda_send_request(self); ! 1081: } ! 1082: cuda_unlock(self); ! 1083: } ! 1084: ! 1085: ! 1086: // ********************************************************************************** ! 1087: // cuda_error ! 1088: // ! 1089: // ********************************************************************************** ! 1090: static void cuda_error ( AppleCuda * self ) ! 1091: { ! 1092: //printf("{Error %d}", self->cuda_transaction_state); ! 1093: ! 1094: // Was looking at cuda_transaction_state - doesn't seem right ! 1095: ! 1096: switch ( self->cuda_interrupt_state ) { ! 1097: case CUDA_STATE_IDLE: ! 1098: cuda_neg_tip_and_byteack(self); ! 1099: break; ! 1100: ! 1101: case CUDA_STATE_TRANSMIT_EXPECTED: ! 1102: if ( self->cuda_is_header_transfer && self->cuda_transfer_count <= 1 ) { ! 1103: cuda_do_state_transition_delay(self); ! 1104: cuda_neg_transfer_in_progress(self); ! 1105: cuda_set_data_direction_to_input(self); ! 1106: panic ("CUDA - TODO FORCE COMMAND BACK UP!\n"); ! 1107: } ! 1108: else { ! 1109: self->cuda_interrupt_state = CUDA_STATE_ATTN_EXPECTED; ! 1110: cuda_neg_tip_and_byteack(self); ! 1111: } ! 1112: break; ! 1113: ! 1114: case CUDA_STATE_ATTN_EXPECTED: ! 1115: cuda_assert_transfer_in_progress(self); ! 1116: ! 1117: cuda_do_state_transition_delay(self); ! 1118: cuda_set_data_direction_to_input(self); ! 1119: cuda_neg_transfer_in_progress(self); ! 1120: panic("CUDA - TODO CHECK FOR TRANSACTION TYPE AND ERROR"); ! 1121: break; ! 1122: ! 1123: case CUDA_STATE_RECEIVE_EXPECTED: ! 1124: cuda_neg_tip_and_byteack(self); ! 1125: panic("Cuda - todo check for transaction type and error"); ! 1126: break; ! 1127: ! 1128: default: ! 1129: cuda_set_data_direction_to_input(self); ! 1130: cuda_neg_tip_and_byteack(self); ! 1131: break; ! 1132: } ! 1133: } ! 1134: ! 1135: static void cuda_do_state_transition_delay( AppleCuda * self ) ! 1136: { ! 1137: AbsoluteTime deadline; ! 1138: ! 1139: clock_absolutetime_interval_to_deadline( ! 1140: self->cuda_state_transition_delay, &deadline); ! 1141: clock_delay_until(deadline); ! 1142: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.