![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AppleKeyboard.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / usb / drvAppleKeyboard|
Return to AppleKeyboard.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / usb / drvAppleKeyboard |
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 (c) 1998, 1999 Apple Computer, Inc. All rights reserved. ! 24: * ! 25: * HISTORY ! 26: * ! 27: */ ! 28: #include <libkern/OSByteOrder.h> ! 29: ! 30: #include "AppleKeyboard.h" ! 31: #include <IOKit/hidsystem/IOHIPointing.h> ! 32: #include <IOKit/IOBufferMemoryDescriptor.h> ! 33: #include <IOKit/usb/IOUSBInterface.h> ! 34: #include <IOKit/usb/IOUSBPipe.h> ! 35: #include <IOKit/usb/IOUSBController.h> ! 36: ! 37: extern "C" { ! 38: #include <pexpert/pexpert.h> ! 39: } ! 40: ! 41: ! 42: #define super IOHIKeyboard ! 43: #define self this ! 44: #define DEBUGGING_LEVEL 0 ! 45: ! 46: OSDefineMetaClassAndStructors(AppleKeyboard, IOHIKeyboard) ! 47: ! 48: extern unsigned char usb_2_adb_keymap[]; //In Cosmo_USB2ADB.cpp ! 49: ! 50: static IOUSBController *sPollControl; ! 51: static IOUSBPipe *sPollPipe; ! 52: static UInt8 sBuffer[8]; ! 53: static IOMemoryDescriptor *sBufDesc; ! 54: static bool sComplete = true; ! 55: ! 56: ! 57: static void bodgeComplete(void *target, void * parameter, IOReturn status, UInt32 bufferSizeRemaining) ! 58: { ! 59: sComplete = true; ! 60: } ! 61: ! 62: static int PE_usb_poll_input(unsigned int options, char * c) ! 63: { ! 64: static char adbkeycodes2ascii[] = "asdfhgzxcv_bqwer"//00 ! 65: "yt123465=97-80]o" //10 ! 66: "u[ip\nlj'k;_,/nm." //20 ! 67: "\t_"; //30 ! 68: *c = 0xff; ! 69: ! 70: if(!sPollPipe) ! 71: return 0; ! 72: if(sComplete) { ! 73: IOUSBCompletion completion; ! 74: sComplete = false; ! 75: ! 76: *c = adbkeycodes2ascii[usb_2_adb_keymap[sBuffer[2]]]; ! 77: completion.target = 0; ! 78: completion.action = bodgeComplete; ! 79: completion.parameter = 0; ! 80: ! 81: sPollControl->PolledRead( ! 82: sPollPipe->address() /*functionAddress*/, ! 83: sPollPipe->endpoint()->number /*endpointNumber*/, ! 84: completion /*completion*/, ! 85: sBufDesc /*buffer*/, ! 86: true /*bufferRounding*/, ! 87: sizeof(sBuffer) /*bufferSize*/); ! 88: } ! 89: else ! 90: sPollControl->pollInterrupts(bodgeComplete); // Only complete our transactions ! 91: ! 92: return 0; ! 93: } ! 94: ! 95: void usb_asyncLED ( AppleKeyboard * me ); ! 96: AppleKeyboard *glob_usbkeyboard_obj; ! 97: ! 98: bool AppleKeyboard::start(IOService * provider) ! 99: { ! 100: IOReturn err = 0; ! 101: ! 102: if( !super::start(provider)) ! 103: return (false); ! 104: ! 105: // remember my device ! 106: _interface = OSDynamicCast(IOUSBInterface, provider); ! 107: _deviceDescriptor = _interface->deviceDescriptor(); ! 108: _prevent_LED_set = FALSE; ! 109: ! 110: //Following 3 lines moved here from Simulate_ADB_Event to make multiple ! 111: // keyboards work correctly. The instance variables cannot be shared ! 112: // between each instance of this driver for each USB keyboard. ! 113: prev_bytes_read=8; ! 114: oldmodifier = 0xff; ! 115: bzero( old_array, kUSB_LOWSPEED_MAXPACKET); ! 116: ! 117: ! 118: if (_interface->open(self) == false) return false; ! 119: ! 120: //Fix hardware bug in iMac USB keyboard mapping for ISO keyboards ! 121: //kprintf("\nUSB product = %x, vendor = %x\n", _deviceDescriptor->product, _deviceDescriptor->vendor); ! 122: if ( _deviceDescriptor) //just to be safe ! 123: { ! 124: if (_deviceDescriptor->vendor == 0xac05) //Apple Corp. vendor ID, not byte swapped ! 125: { ! 126: switch (_deviceDescriptor->product) ! 127: { ! 128: case 0x0201: //North American iMac keyboard ! 129: break; // return 18 ! 130: case 0x0203: //38=Japanese. 34 is adjustable JIS ! 131: break; // return 34; ! 132: case 0x0202: //Arabic, other ISO such as German ! 133: //Swap two ISO keys around ! 134: usb_2_adb_keymap[0x35] = 0x0a; //Cosmo key18 swaps with key74, 0a is ADB keycode ! 135: usb_2_adb_keymap[0x64] = 0x32; ! 136: break; ! 137: // return 21; //21 is Apple ISO Extended Keyboard ! 138: default: ! 139: //return 18; ! 140: break; ! 141: } ! 142: } ! 143: ! 144: ! 145: ! 146: if (_deviceDescriptor->vendor == 0x5e04) //Microsoft ID ! 147: { ! 148: //Figure out what to do with Microsoft keyboard later ! 149: ! 150: //if (usb_kbd_product_id == 0x000b) //Natural USB+PS/2 keyboard ! 151: //return 18; ! 152: } ! 153: } ! 154: ! 155: do { ! 156: IOLog("%s: USB Generic Keyboard @ %d\n", getName(), _interface->address()); ! 157: ! 158: #if 0 ! 159: ! 160: kprintf("Adam: Class is %d\n", req.theClass); //3 HID ! 161: kprintf("Adam: SubClass is %d\n", req.subClass); //1 ! 162: kprintf("Adam: Protocol is %d\n", req.protocol); //1 keyboard ! 163: ! 164: kprintf("Adam: Type is %d\n", (_interface->endpoints[0])->transferType); //I get 1 ! 165: kprintf("Adam: Number is %d\n", (_interface->endpoints[0])->number); // I get 1 ! 166: ! 167: #endif ! 168: ! 169: //setAlphaLockFeedback(false); //Disable caps lock LED at first ! 170: ! 171: IOUSBFindEndpointRequest request; ! 172: request.type = kUSBInterrupt; ! 173: request.direction = kUSBIn; ! 174: _interruptPipe = _interface->findNextPipe(NULL, &request); ! 175: ! 176: if(!_interruptPipe) ! 177: return false; ! 178: ! 179: _maxPacketSize = request.maxPacketSize; ! 180: _buffer = IOBufferMemoryDescriptor::withCapacity(8, kIODirectionIn); ! 181: ! 182: _completion.target = (void *)self; ! 183: _completion.action = (IOUSBCompletionAction) &AppleKeyboard::readHandler; ! 184: _completion.parameter = (void *)0; // not used ! 185: ! 186: _buffer->setLength(_maxPacketSize); // shouldn't this be _maxPacketSize? ! 187: ! 188: if ((err = _interruptPipe->read(_buffer, &_completion))) ! 189: break; ! 190: ! 191: #if (DEBUGGING_LEVEL > 0) ! 192: //printInterfaceDescriptor(_interface->descriptor); ! 193: #endif ! 194: ! 195: // Save stuff for polled mode ! 196: sPollControl = _interface->bus(); ! 197: sPollPipe = _interruptPipe; ! 198: sBufDesc = IOMemoryDescriptor::withAddress(sBuffer, 8, kIODirectionIn); ! 199: PE_poll_input = PE_usb_poll_input; ! 200: ! 201: return(true); ! 202: ! 203: } while (false); ! 204: ! 205: IOLog("%s: aborting startup. err = %d\n", getName(), err); ! 206: ! 207: provider->close(this); ! 208: stop(provider); ! 209: ! 210: return(false); ! 211: } ! 212: ! 213: void AppleKeyboard::stop(IOService * provider) ! 214: { ! 215: if (_buffer) { ! 216: _buffer->release(); ! 217: _buffer = 0; ! 218: } ! 219: if(sPollPipe == _interruptPipe) { ! 220: sPollControl = NULL; ! 221: sPollPipe = NULL; ! 222: sBufDesc->release(); ! 223: sBufDesc = NULL; ! 224: } ! 225: super::stop(provider); ! 226: } ! 227: ! 228: void AppleKeyboard::test_myusb_f1(void) ! 229: { ! 230: /* ! 231: char dummy[8]; ! 232: IOReturn err = kIOReturnSuccess; ! 233: OSData *writebuf; ! 234: IOUSBPipe * tinterruptPipe; ! 235: ! 236: writebuf = OSData::withCapacity(8); ! 237: err = _device->openPipe(&tinterruptPipe, _interface->endpoints[0]); ! 238: kprintf("Adam1: err is %x\n", err); ! 239: dummy[0] = 0xff; ! 240: dummy[1] = 0xff; ! 241: dummy[2] = 0xff; ! 242: dummy[3] = 0xff; ! 243: dummy[4] = 0xff; ! 244: dummy[5] = 0xff; ! 245: dummy[6] = 0xff; ! 246: dummy[7] = 0xff; ! 247: ! 248: writebuf->appendBytes(dummy, 8); ! 249: // err = _device->write(writebuf, tinterruptPipe); ! 250: kprintf("Adam2: err is %x\n", err); ! 251: //deallocate writebuf ! 252: */ ! 253: } ! 254: ! 255: ! 256: //bits = 2 is Caps Lock, I haven't tried anything else. 0 clears all ! 257: void AppleKeyboard::Set_LED_States(UInt8 bits) ! 258: { ! 259: IOReturn err = kIOReturnSuccess; ! 260: IOUSBCompletion completion; ! 261: ! 262: ! 263: if (_prevent_LED_set) ! 264: return; ! 265: ! 266: //_request and _hid_report must be static because the deviceRequest() call ! 267: // is asynchronous. ! 268: ! 269: _request.rqDirection = kUSBOut; ! 270: _request.rqType = kUSBClass; ! 271: _request.rqRecipient = kUSBInterface; ! 272: _request.bRequest = kHIDRqSetReport; //Set Report in HID specs ! 273: OSWriteLittleInt16(&_request.wValue, 0, (UInt16) kHIDRtOutputReport << 8 ); ! 274: OSWriteLittleInt16(&_request.wIndex, 0, ! 275: _interface->interfaceDescriptor()->interfaceNumber); // 0 for iMac keyboards ! 276: OSWriteLittleInt16(&_request.wLength, 0, 1); // MacOS 8.5 hard-codes it to 1 byte length ! 277: _hid_report[0] = bits; // 2 to set LED, 0 to clear all LEDs ! 278: _hid_report[1] = 0; ! 279: _request.pData = (void *)_hid_report; ! 280: ! 281: completion.target = (void *)self; ! 282: completion.action = &AppleKeyboard::setLEDHandler; ! 283: completion.parameter = (void *)0; ! 284: err = _interface->deviceRequest(&_request, &completion); ! 285: return; ! 286: ! 287: } ! 288: ! 289: ! 290: extern "C" { ! 291: void Debugger( const char * ); ! 292: void boot(int paniced, int howto, char * command); ! 293: #define RB_BOOT 1 /* Causes reboot, not halt. Is in xnu/bsd/sys/reboot.h */ ! 294: ! 295: } ! 296: ! 297: ! 298: //This helper function is only called by StartHandler below. key_ptr points ! 299: // to 8 (kUSB_LOWSPEED_MAXPACKET) valid bytes of data ! 300: void AppleKeyboard::Simulate_ADB_Event(UInt8 *key_ptr, UInt32 bytes_read) ! 301: { ! 302: UInt8 alpha, modifier=0; ! 303: bool found; ! 304: AbsoluteTime now; ! 305: UInt8 seq_key, i;//counter for alpha keys pressed. ! 306: ! 307: /** ! 308: UInt8 *kbdData; ! 309: kbdData = key_ptr; ! 310: kprintf("Num = %d x%x x%x x%x x%x x%x x%x x%x x%x\n", ! 311: bytes_read, *kbdData, *(kbdData +1), ! 312: *(kbdData+2), *(kbdData +3), ! 313: *(kbdData+4), *(kbdData +5), ! 314: *(kbdData+6), *(kbdData +7) ! 315: ); ! 316: **/ ! 317: ! 318: // Test for the keyboard bug where all the keys are 0x01. JDC. ! 319: found = true; ! 320: for (seq_key = 2; seq_key < prev_bytes_read; seq_key++) { ! 321: if (*(key_ptr + seq_key) != 1) found = false; ! 322: } ! 323: if (found) return; ! 324: ! 325: ! 326: if (bytes_read > kUSB_LOWSPEED_MAXPACKET) // 8 bytes ! 327: { ! 328: bytes_read = kUSB_LOWSPEED_MAXPACKET; //Limit myself to low-speed keyboards ! 329: } ! 330: modifier = *key_ptr; ! 331: //alpha = *(key_ptr +2); // byte +1 seems to be unused ! 332: //adb_code = usb_2_adb_keymap[alpha]; ! 333: ! 334: //Handle new key information. The first byte is a set of bits describing ! 335: // which modifier keys are down. The 2nd byte never seems to be used. ! 336: // The third byte is the first USB key down, and the fourth byte is the ! 337: // second key down, and so on. ! 338: //When a key is released, there's no code... just a zero upon USB polling ! 339: //8/2/99 A.W. fixed Blue Box's multiple modifier keys being pressed ! 340: // simultaneously. The trick is if a modifier key DOWN event is reported, ! 341: // and another DOWN is reported, then Blue Box loses track of it. I must ! 342: // report a UP key event first, or else avoid resending the DOWN event. ! 343: ! 344: ! 345: //SECTION 1. Handle modifier keys here first ! 346: if (modifier == oldmodifier) ! 347: { ! 348: //Do nothing. Same keys are still pressed, or if 0 then none pressed ! 349: // so don't overload the HID system with useless events. ! 350: } ! 351: else //Modifiers may or may not be pressed right now ! 352: { ! 353: //kprintf("mod is %x\n", modifier); ! 354: clock_get_uptime(&now); ! 355: ! 356: //left-hand CONTROL modifier key ! 357: if ((modifier & kUSB_LEFT_CONTROL_BIT) && !(oldmodifier & kUSB_LEFT_CONTROL_BIT)) ! 358: { ! 359: dispatchKeyboardEvent(0x36, true, now); //ADB left-hand CONTROL ! 360: _control_key = true; //determine if we reboot CPU. Is instance variable. ! 361: } ! 362: else if ((oldmodifier & kUSB_LEFT_CONTROL_BIT) && !(modifier & kUSB_LEFT_CONTROL_BIT)) ! 363: { ! 364: //Now check for released modifier keys ! 365: dispatchKeyboardEvent(0x36, false, now); ! 366: _control_key = false; ! 367: } ! 368: ! 369: //right-hand CONTROL modifier ! 370: if ((modifier & kUSB_RIGHT_CONTROL_BIT) && !(oldmodifier & kUSB_RIGHT_CONTROL_BIT)) ! 371: { ! 372: dispatchKeyboardEvent(0x7d, true, now); //right-hand CONTROL ! 373: _control_key = true; //determine if we reboot CPU. Is instance variable. ! 374: } ! 375: else if ((oldmodifier & kUSB_RIGHT_CONTROL_BIT) && !(modifier & kUSB_RIGHT_CONTROL_BIT)) ! 376: { ! 377: dispatchKeyboardEvent(0x7d, false, now); ! 378: _control_key = false; ! 379: } ! 380: ! 381: //left-hand SHIFT ! 382: if ((modifier & kUSB_LEFT_SHIFT_BIT) && !(oldmodifier & kUSB_LEFT_SHIFT_BIT)) ! 383: { ! 384: // Debugger("LEFT SHIFT"); ! 385: ! 386: dispatchKeyboardEvent(0x38, true, now); ! 387: } ! 388: else if ((oldmodifier & kUSB_LEFT_SHIFT_BIT) && !(modifier & kUSB_LEFT_SHIFT_BIT)) ! 389: { ! 390: dispatchKeyboardEvent(0x38, false, now); ! 391: } ! 392: ! 393: //right-hand SHIFT ! 394: if ((modifier & kUSB_RIGHT_SHIFT_BIT) && !(oldmodifier & kUSB_RIGHT_SHIFT_BIT)) ! 395: { ! 396: dispatchKeyboardEvent(0x7b, true, now); ! 397: } ! 398: else if ((oldmodifier & kUSB_RIGHT_SHIFT_BIT) && !(modifier & kUSB_RIGHT_SHIFT_BIT)) ! 399: { ! 400: dispatchKeyboardEvent(0x7b, false, now); ! 401: } ! 402: ! 403: if ((modifier & kUSB_LEFT_ALT_BIT) && !(oldmodifier & kUSB_LEFT_ALT_BIT)) ! 404: { ! 405: dispatchKeyboardEvent(0x3a, true, now); ! 406: } ! 407: else if ((oldmodifier & kUSB_LEFT_ALT_BIT) && !(modifier & kUSB_LEFT_ALT_BIT)) ! 408: { ! 409: dispatchKeyboardEvent(0x3a, false, now); ! 410: } ! 411: ! 412: if ((modifier & kUSB_RIGHT_ALT_BIT) && !(oldmodifier & kUSB_RIGHT_ALT_BIT)) ! 413: { ! 414: dispatchKeyboardEvent(0x7c, true, now); ! 415: } ! 416: else if ((oldmodifier & kUSB_RIGHT_ALT_BIT) && !(modifier & kUSB_RIGHT_ALT_BIT)) ! 417: { ! 418: dispatchKeyboardEvent(0x7c, false, now); ! 419: } ! 420: ! 421: if ((modifier & kUSB_LEFT_FLOWER_BIT) && !(oldmodifier & kUSB_LEFT_FLOWER_BIT)) ! 422: { ! 423: dispatchKeyboardEvent(0x37, true, now); ! 424: _flower_key = true; //determine if we go into kernel debugger, or reboot CPU ! 425: } ! 426: else if ((oldmodifier & kUSB_LEFT_FLOWER_BIT) && !(modifier & kUSB_LEFT_FLOWER_BIT)) ! 427: { ! 428: dispatchKeyboardEvent(0x37, false, now); ! 429: _flower_key = false; ! 430: } ! 431: ! 432: if ((modifier & kUSB_RIGHT_FLOWER_BIT) && !(oldmodifier & kUSB_RIGHT_FLOWER_BIT)) ! 433: { ! 434: //dispatchKeyboardEvent(0x7e, true, now); ! 435: //WARNING... NeXT only recognizes left-hand flower key, so ! 436: // emulate that for now ! 437: dispatchKeyboardEvent(0x37, true, now); ! 438: _flower_key = true; ! 439: } ! 440: else if ((oldmodifier & kUSB_RIGHT_FLOWER_BIT) && !(modifier & kUSB_RIGHT_FLOWER_BIT)) ! 441: { ! 442: dispatchKeyboardEvent(0x37, false, now); ! 443: _flower_key = false; ! 444: } ! 445: ! 446: } ! 447: ! 448: //SECTION 2. Handle regular alphanumeric keys now. Look first at previous keystrokes. ! 449: // Alphanumeric portion of HID report starts at byte +2. ! 450: ! 451: for (seq_key = 2; seq_key < prev_bytes_read; seq_key++) ! 452: { ! 453: alpha = old_array[seq_key]; ! 454: if (alpha == 0) //No keys pressed ! 455: { ! 456: break; ! 457: } ! 458: found = false; ! 459: for (i = 2; i < bytes_read; i++) //Look through current keypresses ! 460: { ! 461: if (alpha == *(key_ptr + i)) ! 462: { ! 463: found = true; //This key has been held down for a while, so do nothing. ! 464: break; // Autorepeat is taken care of by IOKit. ! 465: } ! 466: } ! 467: if (!found) ! 468: { ! 469: clock_get_uptime(&now); ! 470: if (alpha == 0x39) //This is USB Caps Lock scan code ! 471: { ! 472: if (!_capsLockState) ! 473: { ! 474: dispatchKeyboardEvent(usb_2_adb_keymap[0x39], false, now); ! 475: //Only dispatch if we're in the correct state for Caps Lock ! 476: Set_LED_States(0); ! 477: } ! 478: } ! 479: else //For any other keys except LED-setting keys, dispatch immediately ! 480: { ! 481: dispatchKeyboardEvent(usb_2_adb_keymap[alpha], false, now); //KEY UP ! 482: } ! 483: } ! 484: } ! 485: ! 486: //Now take care of KEY DOWN. ! 487: for (seq_key = 2; seq_key < bytes_read; seq_key++) ! 488: { ! 489: alpha = *(key_ptr + seq_key); ! 490: if (alpha == 0) //No keys pressed ! 491: { ! 492: break; ! 493: } ! 494: else if (alpha == 0x66) //POWER ON key ! 495: { ! 496: if ((_control_key) && (_flower_key)) //User wants to reboot ! 497: { ! 498: boot( RB_BOOT, 0, 0 ); //call to xnu/bsd/kern/kern_shutdown.c ! 499: } ! 500: if (_flower_key) // Apple CMD modifier must be simultaneously held down ! 501: { ! 502: PE_enter_debugger("USB Programmer Key"); ! 503: //In xnu/pexpert/ppc/pe_interrupt.c and defined in pexpert.h above ! 504: } ! 505: //The reason this kernel debugger call is made here instead of KEY UP ! 506: // is that the HID system will see the POWER key and bring up a ! 507: // dialog box to shut down the computer, which is not what we want. ! 508: } ! 509: ! 510: //Don't dispatch the same key again which was held down previously ! 511: found = false; ! 512: for (i = 2; i < prev_bytes_read; i++) ! 513: { ! 514: if (alpha == old_array[i]) ! 515: { ! 516: found = true; ! 517: break; ! 518: } ! 519: } ! 520: if (!found) ! 521: { ! 522: clock_get_uptime(&now); ! 523: //If Debugger() is triggered then I shouldn't show the restart dialog ! 524: // box, but I think developers doing kernel debugging can live with ! 525: // this minor incovenience. Otherwise I need to do more checking here. ! 526: ! 527: if (alpha == 0x39) //This is USB Caps Lock scan code ! 528: { ! 529: if (_capsLockState) ! 530: { ! 531: _capsLockState = 0; ! 532: //Don't do anything else, wait for KEY_UP loop above to handle it ! 533: } ! 534: else ! 535: { ! 536: _capsLockState = 1; ! 537: Set_LED_States(kUSB_CAPSLOCKLED_SET); // kUSB_CAPSLOCKLED_SET = 2 ! 538: } ! 539: } ! 540: ! 541: dispatchKeyboardEvent(usb_2_adb_keymap[alpha], true, now); ! 542: } ! 543: } ! 544: ! 545: //Save the history for next time ! 546: oldmodifier = modifier; ! 547: prev_bytes_read = bytes_read; ! 548: for (i=0; i< bytes_read; i++) //guaranteed not to exceed 8 ! 549: { ! 550: old_array[i] = *(key_ptr + i); ! 551: } ! 552: ! 553: } ! 554: ! 555: ! 556: ! 557: void AppleKeyboard::setLEDHandler(void * parameter, ! 558: IOReturn status, ! 559: UInt32 bufferSizeRemaining) ! 560: { ! 561: if (status) ! 562: { ! 563: //Setting the LED causes problems on CMD USB controller on MacOSX, ! 564: // so if error then prevent further attempts. Log the failure ! 565: IOLog("USB Keyboard Caps Lock LED failed\n"); ! 566: kprintf("USB Keyboard Caps Lock LED failed\n"); ! 567: _prevent_LED_set = TRUE; ! 568: } ! 569: } ! 570: ! 571: void AppleKeyboard::readHandler(void * parameter, ! 572: IOReturn status, ! 573: UInt32 bufferSizeRemaining) ! 574: { ! 575: IOReturn err = kIOReturnSuccess; ! 576: ! 577: // Handle the error if any ! 578: switch (status) ! 579: { ! 580: case kIOReturnSuccess: ! 581: break; ! 582: ! 583: case kIOReturnOverrun: ! 584: // Not sure what to do with this error. It means more data ! 585: // came back than the size of a descriptor. Hmmm. For now ! 586: // just ignore it and assume the data that did come back is ! 587: // useful. ! 588: IOLog("%s: overrun error. ignoring.\n", getName()); ! 589: break; ! 590: ! 591: case kIOReturnNotResponding: ! 592: // This probably means the device was unplugged. Now ! 593: // we need to close the driver. ! 594: IOLog("%s: Device unplugged. Goodbye\n", getName()); ! 595: goto close; ! 596: ! 597: default: ! 598: // We should handle other errors more intelligently, but ! 599: // for now just return and assume the error is recoverable. ! 600: IOLog("%s: error %d reading interrupt pipe\n", getName(), status); ! 601: goto queueAnother; ! 602: } ! 603: ! 604: // Handle the data ! 605: Simulate_ADB_Event((UInt8 *)_buffer->getBytesNoCopy(), ! 606: (UInt32) _maxPacketSize - bufferSizeRemaining); ! 607: ! 608: queueAnother: ! 609: // Reset the buffer ! 610: _buffer->setLength(_maxPacketSize); ! 611: ! 612: // Queue up another one before we leave. ! 613: if ((err = _interruptPipe->read(_buffer, &_completion))) ! 614: { ! 615: // This is bad. We probably shouldn't continue on from here. ! 616: IOLog("%s: immediate error %d queueing read\n", getName(), err); ! 617: goto close; ! 618: } ! 619: ! 620: return; ! 621: ! 622: close: ! 623: _interface->close(this); ! 624: return; ! 625: } ! 626: ! 627: ! 628: ! 629: // *************************************************************************** ! 630: // usb_asyncLED ! 631: // ! 632: // Called asynchronously to turn on/off the keyboard LED ! 633: // ! 634: // ************************************************************************** ! 635: void usb_asyncLED( thread_call_param_t param, thread_call_param_t ) ! 636: { ! 637: AppleKeyboard * me = (AppleKeyboard *) param; ! 638: me->Set_LED_States( me->_ledState ); ! 639: } ! 640: ! 641: ! 642: //****************************************************************************** ! 643: // COPIED from ADB keyboard driver 3/25/99 ! 644: // This is usually called on a call-out thread after the caps-lock key is pressed. ! 645: // ADB operations to PMU are synchronous, and this is must not be done ! 646: // on the call-out thread since that is the PMU driver workloop thread, and ! 647: // it will block itself. ! 648: // ! 649: // Therefore, we schedule the ADB write to disconnect the call-out thread ! 650: // and the one that initiates the ADB write. ! 651: // ! 652: // ******************************************************************************* ! 653: void AppleKeyboard::setLEDFeedback( UInt8 LED_state) ! 654: { ! 655: _ledState = LED_state; ! 656: ! 657: thread_call_func(usb_asyncLED, (thread_call_param_t)this, true); ! 658: } ! 659: ! 660: ! 661: // ***************************************************************************** ! 662: // maxKeyCodes ! 663: // A.W. copied 3/25/99 from ADB keyboard driver, I don't know what this does ! 664: // *************************************************************************** ! 665: UInt32 AppleKeyboard::maxKeyCodes (void ) ! 666: { ! 667: return 0x80; ! 668: } ! 669: ! 670: ! 671: // ************************************************************************* ! 672: // deviceType ! 673: // ! 674: // ************************************************************************** ! 675: UInt32 AppleKeyboard::deviceType ( void ) ! 676: { ! 677: return 2; ! 678: } ! 679: ! 680: // ************************************************************************ ! 681: // interfaceID. Fake ADB for now since USB defaultKeymapOfLength is too complex ! 682: // ! 683: // ************************************************************************** ! 684: UInt32 AppleKeyboard::interfaceID ( void ) ! 685: { ! 686: //Return value must match "interface" line in .keyboard file ! 687: return NX_EVS_DEVICE_INTERFACE_ADB; // 2 This matches contents of AppleExt.keyboard ! 688: } ! 689: ! 690: ! 691: /***********************************************/ ! 692: //Get handler ID ! 693: // ! 694: // I assume that this method is only called if a valid USB keyboard ! 695: // is found. This method should return a 0 or something if there's ! 696: // no keyboard, but then the USB keyboard driver should never have ! 697: // been probed if there's no keyboard, so for now it won't return 0. ! 698: UInt32 AppleKeyboard::handlerID ( void ) ! 699: { ! 700: UInt32 ret_id = 0x201; //513 decimal is ANSI USB iMac keyboard ! 701: ! 702: //Return value must match "handler_id" line in .keyboard file ! 703: // For some reason the ADB and PS/2 keyboard drivers are missing this method ! 704: // Also, Beaker Keyboard Prefs doesn't run properly ! 705: //Fix hardware bug in iMac USB keyboard mapping for ISO keyboards ! 706: //kprintf("\nUSB product = %x, vendor = %x\n", _deviceDescriptor->product, _deviceDescriptor->vendor); ! 707: if ( _deviceDescriptor) //just to be safe ! 708: { ! 709: if (_deviceDescriptor->vendor == 0xac05) //Apple USB keyboards ! 710: { ! 711: ret_id = _deviceDescriptor->product; //0x201=ANSI, 0x202=ISO, or 0x203=JIS ! 712: if (ret_id == 0x202) ! 713: { ! 714: usb_2_adb_keymap[0x35] = 0x0a; //Cosmo key18 swaps with key74, 0a is ADB keycode ! 715: usb_2_adb_keymap[0x64] = 0x32; ! 716: IOLog("USB ISO keys swapped\n"); ! 717: } ! 718: } ! 719: ! 720: if (_deviceDescriptor->vendor == 0x045e) //Microsoft ID ! 721: { ! 722: if (_deviceDescriptor->product == 0x000b) //Natural USB+PS/2 keyboard ! 723: ret_id = 18; //18 is Apple Extended ADB keyboard ! 724: } ! 725: } ! 726: ! 727: return ret_id; ! 728: } ! 729: ! 730: ! 731: // ***************************************************************************** ! 732: // defaultKeymapOfLength ! 733: // A.W. copied from ADB keyboard, I don't have time to make custom USB version ! 734: // ***************************************************************************** ! 735: const unsigned char * AppleKeyboard::defaultKeymapOfLength (UInt32 * length ) ! 736: { ! 737: static const unsigned char appleUSAKeyMap[] = { ! 738: 0x00,0x00,0x07, ! 739: 0x00,0x01,0x39, ! 740: 0x01,0x02,0x38,0x7b, ! 741: 0x02,0x02,0x36,0x7d,0x03,0x02,0x3a,0x7c,0x04, ! 742: 0x01,0x37,0x05,0x15,0x52,0x41,0x4c,0x53,0x54,0x55,0x45,0x58,0x57,0x56,0x5b,0x5c, ! 743: 0x43,0x4b,0x51,0x3b,0x3d,0x3e,0x3c,0x4e,0x59,0x06,0x01,0x72,0x7b,0x0d,0x00,0x61, ! 744: 0x00,0x41,0x00,0x01,0x00,0x01,0x00,0xca,0x00,0xc7,0x00,0x01,0x00,0x01,0x0d,0x00, ! 745: 0x73,0x00,0x53,0x00,0x13,0x00,0x13,0x00,0xfb,0x00,0xa7,0x00,0x13,0x00,0x13,0x0d, ! 746: 0x00,0x64,0x00,0x44,0x00,0x04,0x00,0x04,0x01,0x44,0x01,0xb6,0x00,0x04,0x00,0x04, ! 747: 0x0d,0x00,0x66,0x00,0x46,0x00,0x06,0x00,0x06,0x00,0xa6,0x01,0xac,0x00,0x06,0x00, ! 748: 0x06,0x0d,0x00,0x68,0x00,0x48,0x00,0x08,0x00,0x08,0x00,0xe3,0x00,0xeb,0x00,0x00, ! 749: 0x18,0x00,0x0d,0x00,0x67,0x00,0x47,0x00,0x07,0x00,0x07,0x00,0xf1,0x00,0xe1,0x00, ! 750: 0x07,0x00,0x07,0x0d,0x00,0x7a,0x00,0x5a,0x00,0x1a,0x00,0x1a,0x00,0xcf,0x01,0x57, ! 751: 0x00,0x1a,0x00,0x1a,0x0d,0x00,0x78,0x00,0x58,0x00,0x18,0x00,0x18,0x01,0xb4,0x01, ! 752: 0xce,0x00,0x18,0x00,0x18,0x0d,0x00,0x63,0x00,0x43,0x00,0x03,0x00,0x03,0x01,0xe3, ! 753: 0x01,0xd3,0x00,0x03,0x00,0x03,0x0d,0x00,0x76,0x00,0x56,0x00,0x16,0x00,0x16,0x01, ! 754: 0xd6,0x01,0xe0,0x00,0x16,0x00,0x16,0x02,0x00,0x3c,0x00,0x3e,0x0d,0x00,0x62,0x00, ! 755: 0x42,0x00,0x02,0x00,0x02,0x01,0xe5,0x01,0xf2,0x00,0x02,0x00,0x02,0x0d,0x00,0x71, ! 756: 0x00,0x51,0x00,0x11,0x00,0x11,0x00,0xfa,0x00,0xea,0x00,0x11,0x00,0x11,0x0d,0x00, ! 757: 0x77,0x00,0x57,0x00,0x17,0x00,0x17,0x01,0xc8,0x01,0xc7,0x00,0x17,0x00,0x17,0x0d, ! 758: 0x00,0x65,0x00,0x45,0x00,0x05,0x00,0x05,0x00,0xc2,0x00,0xc5,0x00,0x05,0x00,0x05, ! 759: 0x0d,0x00,0x72,0x00,0x52,0x00,0x12,0x00,0x12,0x01,0xe2,0x01,0xd2,0x00,0x12,0x00, ! 760: 0x12,0x0d,0x00,0x79,0x00,0x59,0x00,0x19,0x00,0x19,0x00,0xa5,0x01,0xdb,0x00,0x19, ! 761: 0x00,0x19,0x0d,0x00,0x74,0x00,0x54,0x00,0x14,0x00,0x14,0x01,0xe4,0x01,0xd4,0x00, ! 762: 0x14,0x00,0x14,0x0a,0x00,0x31,0x00,0x21,0x01,0xad,0x00,0xa1,0x0e,0x00,0x32,0x00, ! 763: 0x40,0x00,0x32,0x00,0x00,0x00,0xb2,0x00,0xb3,0x00,0x00,0x00,0x00,0x0a,0x00,0x33, ! 764: 0x00,0x23,0x00,0xa3,0x01,0xba,0x0a,0x00,0x34,0x00,0x24,0x00,0xa2,0x00,0xa8,0x0e, ! 765: 0x00,0x36,0x00,0x5e,0x00,0x36,0x00,0x1e,0x00,0xb6,0x00,0xc3,0x00,0x1e,0x00,0x1e, ! 766: 0x0a,0x00,0x35,0x00,0x25,0x01,0xa5,0x00,0xbd,0x0a,0x00,0x3d,0x00,0x2b,0x01,0xb9, ! 767: 0x01,0xb1,0x0a,0x00,0x39,0x00,0x28,0x00,0xac,0x00,0xab,0x0a,0x00,0x37,0x00,0x26, ! 768: 0x01,0xb0,0x01,0xab,0x0e,0x00,0x2d,0x00,0x5f,0x00,0x1f,0x00,0x1f,0x00,0xb1,0x00, ! 769: 0xd0,0x00,0x1f,0x00,0x1f,0x0a,0x00,0x38,0x00,0x2a,0x00,0xb7,0x00,0xb4,0x0a,0x00, ! 770: 0x30,0x00,0x29,0x00,0xad,0x00,0xbb,0x0e,0x00,0x5d,0x00,0x7d,0x00,0x1d,0x00,0x1d, ! 771: 0x00,0x27,0x00,0xba,0x00,0x1d,0x00,0x1d,0x0d,0x00,0x6f,0x00,0x4f,0x00,0x0f,0x00, ! 772: 0x0f,0x00,0xf9,0x00,0xe9,0x00,0x0f,0x00,0x0f,0x0d,0x00,0x75,0x00,0x55,0x00,0x15, ! 773: 0x00,0x15,0x00,0xc8,0x00,0xcd,0x00,0x15,0x00,0x15,0x0e,0x00,0x5b,0x00,0x7b,0x00, ! 774: 0x1b,0x00,0x1b,0x00,0x60,0x00,0xaa,0x00,0x1b,0x00,0x1b,0x0d,0x00,0x69,0x00,0x49, ! 775: 0x00,0x09,0x00,0x09,0x00,0xc1,0x00,0xf5,0x00,0x09,0x00,0x09,0x0d,0x00,0x70,0x00, ! 776: 0x50,0x00,0x10,0x00,0x10,0x01,0x70,0x01,0x50,0x00,0x10,0x00,0x10,0x10,0x00,0x0d, ! 777: 0x00,0x03,0x0d,0x00,0x6c,0x00,0x4c,0x00,0x0c,0x00,0x0c,0x00,0xf8,0x00,0xe8,0x00, ! 778: 0x0c,0x00,0x0c,0x0d,0x00,0x6a,0x00,0x4a,0x00,0x0a,0x00,0x0a,0x00,0xc6,0x00,0xae, ! 779: 0x00,0x0a,0x00,0x0a,0x0a,0x00,0x27,0x00,0x22,0x00,0xa9,0x01,0xae,0x0d,0x00,0x6b, ! 780: 0x00,0x4b,0x00,0x0b,0x00,0x0b,0x00,0xce,0x00,0xaf,0x00,0x0b,0x00,0x0b,0x0a,0x00, ! 781: 0x3b,0x00,0x3a,0x01,0xb2,0x01,0xa2,0x0e,0x00,0x5c,0x00,0x7c,0x00,0x1c,0x00,0x1c, ! 782: 0x00,0xe3,0x00,0xeb,0x00,0x1c,0x00,0x1c,0x0a,0x00,0x2c,0x00,0x3c,0x00,0xcb,0x01, ! 783: 0xa3,0x0a,0x00,0x2f,0x00,0x3f,0x01,0xb8,0x00,0xbf,0x0d,0x00,0x6e,0x00,0x4e,0x00, ! 784: 0x0e,0x00,0x0e,0x00,0xc4,0x01,0xaf,0x00,0x0e,0x00,0x0e,0x0d,0x00,0x6d,0x00,0x4d, ! 785: 0x00,0x0d,0x00,0x0d,0x01,0x6d,0x01,0xd8,0x00,0x0d,0x00,0x0d,0x0a,0x00,0x2e,0x00, ! 786: 0x3e,0x00,0xbc,0x01,0xb3,0x02,0x00,0x09,0x00,0x19,0x0c,0x00,0x20,0x00,0x00,0x00, ! 787: 0x80,0x00,0x00,0x0a,0x00,0x60,0x00,0x7e,0x00,0x60,0x01,0xbb,0x02,0x00,0x7f,0x00, ! 788: 0x08,0xff,0x02,0x00,0x1b,0x00,0x7e,0xff,0xff,0xff,0xff,0xff,0x00,0x01,0xac,0x00, ! 789: 0x01,0xae,0x00,0x01,0xaf,0x00,0x01,0xad,0xff,0xff,0x00,0x00,0x2e,0xff,0x00,0x00, ! 790: 0x2a,0xff,0x00,0x00,0x2b,0xff,0x00,0x00,0x1b,0xff,0xff,0xff,0x0e,0x00,0x2f,0x00, ! 791: 0x5c,0x00,0x2f,0x00,0x1c,0x00,0x2f,0x00,0x5c,0x00,0x00,0x0a,0x00,0x00,0x00,0x0d, //XX03 ! 792: 0xff,0x00,0x00,0x2d,0xff,0xff,0x0e,0x00,0x3d,0x00,0x7c,0x00,0x3d,0x00,0x1c,0x00, ! 793: 0x3d,0x00,0x7c,0x00,0x00,0x18,0x46,0x00,0x00,0x30,0x00,0x00,0x31,0x00,0x00,0x32, ! 794: 0x00,0x00,0x33,0x00,0x00,0x34,0x00,0x00,0x35,0x00,0x00,0x36,0x00,0x00,0x37,0xff, ! 795: 0x00,0x00,0x38,0x00,0x00,0x39,0xff,0xff,0xff,0x00,0xfe,0x24,0x00,0xfe,0x25,0x00, ! 796: 0xfe,0x26,0x00,0xfe,0x22,0x00,0xfe,0x27,0x00,0xfe,0x28,0xff,0x00,0xfe,0x2a,0xff, ! 797: 0x00,0xfe,0x32,0xff,0x00,0xfe,0x33,0xff,0x00,0xfe,0x29,0xff,0x00,0xfe,0x2b,0xff, ! 798: 0x00,0xfe,0x34,0xff,0x00,0xfe,0x2e,0x00,0xfe,0x30,0x00,0xfe,0x2d,0x00,0xfe,0x23, ! 799: 0x00,0xfe,0x2f,0x00,0xfe,0x21,0x00,0xfe,0x31,0x00,0xfe,0x20,0x0f,0x02,0xff,0x04, ! 800: 0x00,0x31,0x02,0xff,0x04,0x00,0x32,0x02,0xff,0x04,0x00,0x33,0x02,0xff,0x04,0x00, ! 801: 0x34,0x02,0xff,0x04,0x00,0x35,0x02,0xff,0x04,0x00,0x36,0x02,0xff,0x04,0x00,0x37, ! 802: 0x02,0xff,0x04,0x00,0x38,0x02,0xff,0x04,0x00,0x39,0x02,0xff,0x04,0x00,0x30,0x02, ! 803: 0xff,0x04,0x00,0x2d,0x02,0xff,0x04,0x00,0x3d,0x02,0xff,0x04,0x00,0x70,0x02,0xff, ! 804: 0x04,0x00,0x5d,0x02,0xff,0x04,0x00,0x5b,0x04,0x05,0x72,0x06,0x7f,0x07, ! 805: 0x3e,0x08,0x3d ! 806: }; ! 807: ! 808: *length = sizeof(appleUSAKeyMap); ! 809: return appleUSAKeyMap; ! 810: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.