![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to EventSrcPCKeyboard.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|
Return to EventSrcPCKeyboard.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc |
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: /* Copyright (c) 1992 NeXT Computer, Inc. All rights reserved. ! 26: * ! 27: * EventSrcPCKeyoard.m - PC Keyboard EventSrc subclass implementation ! 28: * ! 29: * HISTORY ! 30: * 10 Sep 1992 Joe Pasqua ! 31: * Created. ! 32: * 5 Nov, 1993 ! 33: * Modified for Hppa ! 34: * 15 Dec 1993 ! 35: * Modified for 712 ! 36: * 23 Mar 1997 ! 37: * Modified for PPC ! 38: */ ! 39: ! 40: // TO DO: ! 41: // ! 42: // NOTES: ! 43: // * We override methods in the EventSrcExported protocol so that we can ! 44: // intercept messages used to control who owns us. This gives us ! 45: // an opportunity to acquire/release the PCKeyboard device we want to own. ! 46: // * In the current system the EventDriver instance is always the owner ! 47: // of this EventSrc. In the future the km driver and the EventDriver might ! 48: // both be potential owners. ! 49: // * The device dependent portion of the event flags are set by this module ! 50: // before the flags are passed up to our owner. There are a couple of notes ! 51: // on this. First, the PC keyboard has no key labelled "Command", therefore ! 52: // the NX_NEXT[RL]CMDKEYMASK flag bits will never be set. Conversely, the ! 53: // PC keyboard has both a left and a right Control key. When either key is ! 54: // pressed we set the NX_NEXTCTLKEYMASK mask. The code processing events ! 55: // must determine which one it was by looking at the code that is generated. ! 56: // * To find things that need to be fixed, search for FIX, to find questions ! 57: // to be resolved, search for ASK, to find stuff that still needs to be ! 58: // done, search for TO DO. ! 59: // ! 60: ! 61: #import <driverkit/generalFuncs.h> ! 62: #import <machkit/NXLock.h> ! 63: #import <driverkit/KeyMap.h> ! 64: #import <bsd/dev/evsio.h> ! 65: #import <bsd/dev/ppc/event.h> ! 66: #import <bsd/dev/ppc/PPCKeymap.c> // The default keymapping string ! 67: #import <bsd/dev/ppc/EventSrcPCKeyboard.h> ! 68: #import <bsd/dev/ppc/PCKeyboardDefs.h> ! 69: #import <bsd/dev/ppc/PPCKeyboardPriv.h> ! 70: ! 71: // Private variables that are global to the module: ! 72: static EventSrcPCKeyboard *instance = (EventSrcPCKeyboard *)0; ! 73: ! 74: // Forward declarations ! 75: static void autoRepeatCallout( void *data ); ! 76: unsigned int wserver_on=0; ! 77: ! 78: //Make sure USB exists ! 79: id usb_UIM_object = 0; ! 80: ! 81: // FIXME: Nasty hack to reinit mouse on server startup ! 82: #include "PPCMouse.h" ! 83: extern PPCMouse *_my_Mouse; ! 84: ! 85: @implementation EventSrcPCKeyboard ! 86: ! 87: // ! 88: // BEGIN: Utility Procedures ! 89: // ! 90: static void nsecs_to_packed_ns(ns_time_t *nsecs, unsigned int *pnsecs) ! 91: { ! 92: _NX_packed_time_t data; ! 93: int i; ! 94: ! 95: data.tval = *nsecs; // nsecs to ns_time_t ! 96: for ( i = 0; i < EVS_PACKED_TIME_SIZE; ++i ) ! 97: pnsecs[i] = data.itval[i]; ! 98: } ! 99: ! 100: static void packed_nsecs_to_nsecs(unsigned int *pnsecs, ns_time_t *nsecs) ! 101: { ! 102: _NX_packed_time_t data; ! 103: int i; ! 104: ! 105: for ( i = 0; i < EVS_PACKED_TIME_SIZE; ++i ) ! 106: data.itval[i] = pnsecs[i]; ! 107: *nsecs = data.tval; ! 108: } ! 109: // ! 110: // END: Utility Procedures ! 111: // ! 112: ! 113: ! 114: // ! 115: // BEGIN: Implementation of Private EventSrcPCKeyoard methods ! 116: // ! 117: - resetKeyboard ! 118: // Description: Reset the keymapping to the default value and reconfigure ! 119: // the keyboards. ! 120: { ! 121: [deviceLock lock]; ! 122: if ( keyMap != nil ) ! 123: [keyMap free]; ! 124: // Set up default keymapping. ! 125: ! 126: keyMap = [[KeyMap alloc] initFromKeyMapping:PPCDefaultKeymap ! 127: length:sizeof PPCDefaultKeymap ! 128: canFree:NO]; ! 129: ! 130: [keyMap setDelegate:self]; ! 131: keyRepeat = EV_DEFAULTKEYREPEAT; ! 132: initialKeyRepeat = EV_DEFAULTINITIALREPEAT; ! 133: [deviceLock unlock]; ! 134: return self; ! 135: } ! 136: ! 137: - scheduleAutoRepeat ! 138: // Description: Schedule a procedure to be called when a timeout has expired ! 139: // so that we can generate a repeated key. ! 140: // Preconditions: ! 141: // * deviceLock should be held on entry ! 142: { ! 143: if ( calloutPending == YES ) ! 144: { ! 145: ns_untimeout( (func)autoRepeatCallout, (void *)self ); ! 146: calloutPending = NO; ! 147: } ! 148: if ( downRepeatTime > 0ULL ) ! 149: { ! 150: ns_abstimeout( ! 151: (func)autoRepeatCallout, ! 152: (void *)self, ! 153: downRepeatTime, ! 154: CALLOUT_PRI_THREAD ); ! 155: calloutPending = YES; ! 156: } ! 157: return self; ! 158: } ! 159: ! 160: - autoRepeat ! 161: // Description: Repeat the currently pressed key and schedule ourselves ! 162: // to be called again after another interval elapses. ! 163: // Preconditions: ! 164: // * Should only be executed on callout thread ! 165: // * deviceLock should be unlocked on entry. ! 166: { ! 167: ns_time_t ns; ! 168: ! 169: IOGetTimestamp(&ns); ! 170: [deviceLock lock]; ! 171: if ( calloutPending == NO ) ! 172: { ! 173: [deviceLock unlock]; ! 174: return self; ! 175: } ! 176: calloutPending = NO; ! 177: isRepeat = YES; ! 178: ! 179: if ( downRepeatTime > 0ULL && downRepeatTime <= ns ) ! 180: { ! 181: // Device is due to generate a repeat ! 182: lastEventTime = ns; ! 183: [keyMap doKeyboardEvent:codeToRepeat ! 184: direction:YES ! 185: keyBits:keyState]; ! 186: downRepeatTime += keyRepeat; ! 187: } ! 188: ! 189: isRepeat = NO; ! 190: [self scheduleAutoRepeat]; ! 191: [deviceLock unlock]; ! 192: return self; ! 193: } ! 194: ! 195: static void autoRepeatCallout( void *data ) ! 196: // Description: Callout used to enter Obj-C autoRepeat code from NS timer ! 197: // callout. This proc was set as a callback in scheduleAutoRepeat. ! 198: { ! 199: EventSrcPCKeyboard *kbd = (EventSrcPCKeyboard *)data; ! 200: [kbd autoRepeat]; ! 201: } ! 202: ! 203: ! 204: - setRepeat:(unsigned)eventType forCode:(unsigned)keyCode ! 205: // Description: Set up or tear dow key repeat operations. The method ! 206: // that locks deviceLock is a bit higher on the call stack. ! 207: // This method is invoked as a side effect of our own ! 208: // invocation of [keyMap doKeyboardEvent]. ! 209: // Preconditions: ! 210: // * deviceLock should be held upon entry. ! 211: { ! 212: if ( isRepeat == NO ) // make sure we're not already repeating ! 213: { ! 214: if (eventType == NX_KEYDOWN) // Start repeat ! 215: { ! 216: // Set this key to repeat (push out last key if present) ! 217: downRepeatTime = initialKeyRepeat + lastEventTime; ! 218: codeToRepeat = keyCode; ! 219: // reschedule key repeat event here ! 220: [self scheduleAutoRepeat]; ! 221: } ! 222: else if (eventType == NX_KEYUP) // End repeat ! 223: { ! 224: /* Remove from downKey */ ! 225: if (codeToRepeat == keyCode) ! 226: { ! 227: downRepeatTime = 0ULL; ! 228: codeToRepeat = -1; ! 229: [self scheduleAutoRepeat]; ! 230: } ! 231: } ! 232: } ! 233: return self; ! 234: } ! 235: ! 236: - initKeyboard ! 237: // Description: Perform setup work needed to find and configure our ! 238: // PCKeyboard device. We have to tell it to send events to us. ! 239: { ! 240: IOReturn drtn; ! 241: ! 242: ! 243: drtn = IOGetObjectForDeviceName("PPCKeyboard0", &kbdDevice); ! 244: if(drtn) { ! 245: IOLog("initKeyboard: Can't find PPCKeyboard0 (%s)\n", ! 246: [self stringFromReturn:drtn]); ! 247: return nil; ! 248: } ! 249: return self; ! 250: } ! 251: // ! 252: // END: Implementation of Private EventSrcPCKeyoard methods ! 253: // ! 254: ! 255: ! 256: // ! 257: // BEGIN: Implementation of the KeyMapDelegate protocol ! 258: // ! 259: - keyboardEvent:(int)eventType ! 260: flags:(unsigned)flags ! 261: keyCode:(unsigned)keyCode ! 262: charCode:(unsigned)charCode ! 263: charSet:(unsigned)charSet ! 264: originalCharCode:(unsigned)origCharCode ! 265: originalCharSet:(unsigned)origCharSet ! 266: // Description: We use this notification to set up our keyRepeat timer ! 267: // and to pass along the event to our owner. In the current ! 268: // implementation this is always the EventDriver. In the future, ! 269: // the km driver may be another potential owner. This method ! 270: // will be called while the KeyMap object is processing ! 271: // the key code we've sent it using doKeyboardEvent. ! 272: { ! 273: [[self owner] keyboardEvent :eventType ! 274: flags:(flags | deviceDependentFlags) ! 275: keyCode:keyCode ! 276: charCode:charCode ! 277: charSet:charSet ! 278: originalCharCode:origCharCode ! 279: originalCharSet:origCharSet ! 280: repeat:isRepeat ! 281: atTime:lastEventTime]; ! 282: ! 283: // Set up key repeat operations here. ! 284: return [self setRepeat:eventType forCode:keyCode]; ! 285: } ! 286: ! 287: - keyboardSpecialEvent:(unsigned)eventType ! 288: flags:(unsigned)flags ! 289: keyCode:(unsigned)keyCode ! 290: specialty:(unsigned)flavor ! 291: // Description: See the description for keyboardEvent. ! 292: { ! 293: [[self owner] keyboardSpecialEvent:eventType ! 294: flags:(flags | deviceDependentFlags) ! 295: keyCode :keyCode ! 296: specialty:flavor ! 297: atTime:lastEventTime]; ! 298: ! 299: // Set up key repeat operations here. ! 300: if (flavor != NX_KEYTYPE_CAPS_LOCK) ! 301: return [self setRepeat:eventType forCode:keyCode]; ! 302: } ! 303: ! 304: - updateEventFlags:(unsigned)flags ! 305: // Description: Process non-event-generating flag changes. Simply pass this ! 306: // along to our owner. ! 307: { ! 308: return [[self owner] updateEventFlags:flags]; ! 309: } ! 310: ! 311: - (unsigned)eventFlags ! 312: // Description: Return global event flags In this world, there is only ! 313: // one keyboard device so device flags == global flags. ! 314: { ! 315: return eventFlags; ! 316: } ! 317: ! 318: - (unsigned)deviceFlags ! 319: // Description: Return per-device event flags. In this world, there is only ! 320: // one keyboard device so device flags == global flags. ! 321: { ! 322: return eventFlags; ! 323: } ! 324: ! 325: - setDeviceFlags:(unsigned)flags ! 326: // Description: Set device event flags. In this world, there is only ! 327: // one keyboard device so device flags == global flags. ! 328: { ! 329: eventFlags = flags; ! 330: return self; ! 331: } ! 332: ! 333: - (BOOL)alphaLock ! 334: // Description: Return current alpha-lock state. This is a state tracking ! 335: // callback used by the KeyMap object. ! 336: { ! 337: return alphaLock; ! 338: } ! 339: ! 340: - setAlphaLock:(BOOL)val ! 341: // Description: Set current alpha-lock state This is a state tracking ! 342: // callback used by the KeyMap object. ! 343: { ! 344: alphaLock = val; ! 345: [kbdDevice setAlphaLockFeedback:val]; ! 346: return self; ! 347: } ! 348: ! 349: - (BOOL)charKeyActive ! 350: // Description: Return YES If a character generating key down This is a state ! 351: // tracking callback used by the KeyMap object. ! 352: { ! 353: return charKeyActive; ! 354: } ! 355: ! 356: - setCharKeyActive:(BOOL)val ! 357: // Description: Note whether a char generating key is down. This is a state ! 358: // tracking callback used by the KeyMap object. ! 359: { ! 360: charKeyActive = val; ! 361: return self; ! 362: } ! 363: // ! 364: // END: Implementation of the KeyMapDelegate protocol ! 365: // ! 366: ! 367: ! 368: // ! 369: // BEGIN: Implementation of PCKeyboardImported protocol ! 370: // ! 371: - (void)dispatchKeyboardEvent:(PCKeyboardEvent *)event ! 372: // Description: This method is the heart of event dispatching. The underlying ! 373: // PCKeyboard object invokes this method with each event. We then ! 374: // get the event xlated and dispatched using a keyMap instance. ! 375: // The event structure passed in by reference should not be freed. ! 376: { ! 377: unsigned keyMask; ! 378: ! 379: lastEventTime = event->timeStamp; ! 380: ! 381: switch (event->keyCode) { ! 382: case ADBK_SHIFT: keyMask = NX_NEXTLSHIFTKEYMASK; break; ! 383: case ADBK_SHIFT_R: keyMask = NX_NEXTRSHIFTKEYMASK; break; ! 384: case ADBK_OPTION: keyMask = NX_NEXTLALTKEYMASK; break; ! 385: case ADBK_OPTION_R: keyMask = NX_NEXTRALTKEYMASK; break; ! 386: case ADBK_CONTROL: keyMask = NX_NEXTCTLKEYMASK; break; ! 387: case ADBK_CONTROL_R: keyMask = NX_NEXTCTLKEYMASK; break; ! 388: default: keyMask = 0; break; ! 389: } ! 390: ! 391: if (event->goingDown) ! 392: deviceDependentFlags |= keyMask; ! 393: else ! 394: deviceDependentFlags &= ~keyMask; ! 395: ! 396: [deviceLock lock]; ! 397: ! 398: if( (event->keyCode == ADBK_CAPSLOCK)) { // Send a capslock toggle ! 399: if( event->goingDown != alphaLock ) { ! 400: [keyMap doKeyboardEvent:ADBK_CAPSLOCK ! 401: direction:YES ! 402: keyBits:keyState]; ! 403: [keyMap doKeyboardEvent:ADBK_CAPSLOCK ! 404: direction:NO ! 405: keyBits:keyState]; ! 406: } ! 407: } else { ! 408: [keyMap doKeyboardEvent:event->keyCode ! 409: direction:event->goingDown ! 410: keyBits:keyState]; ! 411: } ! 412: [deviceLock unlock]; ! 413: } ! 414: ! 415: - (IOReturn)relinquishOwnershipRequest : device ! 416: { ! 417: IOReturn r; ! 418: ! 419: [[self ownerLock] lock]; ! 420: if ( [self owner] == nil ) ! 421: { ! 422: ownDevice = NO; ! 423: r = IO_R_SUCCESS; ! 424: } ! 425: else ! 426: r = IO_R_BUSY; ! 427: ! 428: [[self ownerLock] unlock]; ! 429: return r; ! 430: } ! 431: ! 432: - (IOReturn)canBecomeOwner : device ! 433: { ! 434: IOReturn drtn; ! 435: drtn = [device becomeOwner: self]; ! 436: if(drtn) ! 437: { ! 438: IOLog("%s: becomeOwner of %s failed (%s)\n", ! 439: [self name], ! 440: [device name], ! 441: [self stringFromReturn:drtn]); ! 442: } ! 443: else ! 444: { ! 445: ownDevice = YES; ! 446: } ! 447: return( drtn); ! 448: } ! 449: // ! 450: // END: Implementation of PCKeyboardImported protocol ! 451: // ! 452: ! 453: ! 454: // ! 455: // BEGIN: Implementation of Exported EventSrcPCKeyoard methods ! 456: // ! 457: - init ! 458: // Description: Initialize an EventSrcPCKeyboard ! 459: { ! 460: [deviceLock lock]; ! 461: [super init]; ! 462: if ( keyMap != nil ) ! 463: [keyMap free]; ! 464: // Set up default keymapping ! 465: ! 466: keyMap = [[KeyMap alloc] initFromKeyMapping:PPCDefaultKeymap ! 467: length:sizeof PPCDefaultKeymap ! 468: canFree:NO]; ! 469: ! 470: [keyMap setDelegate:self]; ! 471: [self initKeyboard]; ! 472: keyRepeat = EV_DEFAULTKEYREPEAT; ! 473: initialKeyRepeat = EV_DEFAULTINITIALREPEAT; ! 474: [deviceLock unlock]; ! 475: return self; ! 476: } ! 477: ! 478: + probe ! 479: // Description: This is our factory method. It is the IODevice probe ! 480: // routine for psuedo drivers. ! 481: { ! 482: if ( instance != nil ) ! 483: return instance; ! 484: ! 485: instance = [self alloc]; ! 486: ! 487: instance->deviceLock = [NXLock new]; ! 488: [instance setName:"EventSrcPCKeyboard0"]; ! 489: [instance setDeviceKind:"EventSrcPCKeyboard"]; ! 490: ! 491: if ( [instance init] == nil ) ! 492: [instance free]; // No devices. Go away ! 493: return instance; ! 494: } ! 495: ! 496: - free ! 497: // Description: Go Away. Be careful when freeing the lock. ! 498: { ! 499: id lock; ! 500: ! 501: lock = deviceLock; ! 502: [lock lock]; ! 503: instance = nil; ! 504: deviceLock = nil; ! 505: if ( keyMap != nil ) ! 506: [keyMap free]; ! 507: // Release keyboard device, so we won't get any more events ! 508: if ( kbdDevice != nil ) ! 509: [kbdDevice relinquishOwnership:self]; ! 510: [lock unlock]; ! 511: [lock free]; ! 512: return [super free]; ! 513: } ! 514: ! 515: - (IOReturn)getIntValues:(unsigned *)parameterArray ! 516: forParameter:(IOParameterName)parameterName ! 517: count:(unsigned int *)count ! 518: { ! 519: IOReturn r = IO_R_INVALID_ARG; ! 520: NXEventSystemDevice *dp; ! 521: unsigned maxCount = *count; ! 522: unsigned *returnedCount = count; ! 523: ! 524: if ( strcmp( parameterName, EVSIOCKR ) == 0 ) // Current Key Repeat ! 525: { ! 526: if ( maxCount >= EVSIOCKR_SIZE ) ! 527: { ! 528: *returnedCount = EVSIOCKR_SIZE; ! 529: [deviceLock lock]; ! 530: nsecs_to_packed_ns( ! 531: &initialKeyRepeat, ¶meterArray[EVSIOCKR_INITIAL]); ! 532: nsecs_to_packed_ns( ! 533: &keyRepeat, ¶meterArray[EVSIOCKR_BETWEEN]); ! 534: [deviceLock unlock]; ! 535: r = IO_R_SUCCESS; ! 536: } ! 537: } ! 538: else if ( strcmp( parameterName, EVSIOCKML ) == 0 ) // Current Keymap len. ! 539: { ! 540: if ( maxCount >= EVSIOCKML_SIZE ) ! 541: { ! 542: *returnedCount = EVSIOCKML_SIZE; ! 543: [deviceLock lock]; ! 544: if ( keyMap == nil ) ! 545: parameterArray[0] = 0; ! 546: else ! 547: parameterArray[0] = [keyMap keyMappingLength]; ! 548: [deviceLock unlock]; ! 549: r = IO_R_SUCCESS; ! 550: } ! 551: } ! 552: else if ( strcmp( parameterName, EVSIOINFO ) == 0 ) // Device info ! 553: { ! 554: dp = (NXEventSystemDevice *)¶meterArray[0]; ! 555: *returnedCount = 0; ! 556: // No need to lock device since we're not even reading the structure. ! 557: dp->interface = [kbdDevice interfaceId]; ! 558: dp->dev_type = NX_EVS_DEVICE_TYPE_KEYBOARD; ! 559: dp->interface_addr = 0; ! 560: dp->id = [kbdDevice handlerId]; //Right now ID is for ADB keyboard ! 561: //This line shows up very late in bootup, around time LOGIN is happening on screen ! 562: // I think this may be the code that maps international key maps. A.W. 12/21/98 ! 563: // Now I will call USB method to retrieve USB keyboard attached, if any. The ! 564: // USB method will return the same 16 + ADB ID that is in the various .keyboard ! 565: // files in /System/Library/Keyboards/* ! 566: ! 567: if (usb_UIM_object != 0) ! 568: { ! 569: int adb_id; ! 570: ! 571: adb_id = [usb_UIM_object getADBKeyboardID]; ! 572: if (adb_id != 0) ! 573: { ! 574: dp->id = adb_id; //converted from USB land ! 575: //kprintf("ADB: keyboard converted from USB is %d decimal\n", adb_id); ! 576: } ! 577: } ! 578: ! 579: ! 580: *returnedCount = sizeof(NXEventSystemDevice) / sizeof(int); ! 581: r = IO_R_SUCCESS; ! 582: } ! 583: else if ( strcmp( parameterName, EVSIOGKEYS ) == 0 ) // Key state ! 584: { ! 585: if( maxCount == EVK_NUNITS) { ! 586: [deviceLock lock]; ! 587: bcopy( &keyState, parameterArray, EVK_NUNITS * sizeof( int)); ! 588: [deviceLock unlock]; ! 589: r = IO_R_SUCCESS; ! 590: } ! 591: } ! 592: else ! 593: { ! 594: r = [super getIntValues:parameterArray ! 595: forParameter:parameterName ! 596: count:count]; ! 597: if (r == IO_R_UNSUPPORTED) ! 598: r = IO_R_INVALID_ARG; ! 599: } ! 600: return r; ! 601: } ! 602: ! 603: - (IOReturn)getCharValues:(unsigned char *)parameterArray ! 604: forParameter:(IOParameterName)parameterName ! 605: count:(unsigned int *)count ! 606: { ! 607: IOReturn r = IO_R_INVALID_ARG; ! 608: int cnt; ! 609: unsigned maxCount = *count; ! 610: unsigned *returnedCount = count; ! 611: ! 612: if ( strcmp( parameterName, EVSIOCKM ) == 0 ) // Current KeyMap ! 613: { ! 614: [deviceLock lock]; ! 615: if ( keyMap != nil ) ! 616: { ! 617: cnt = [keyMap keyMappingLength]; ! 618: cnt = (cnt < maxCount) ? cnt : maxCount; ! 619: *returnedCount = cnt; ! 620: bcopy( [keyMap keyMapping:(int *)0], parameterArray, cnt ); ! 621: r = IO_R_SUCCESS; ! 622: } ! 623: else ! 624: r = IO_R_NOT_ATTACHED; ! 625: [deviceLock unlock]; ! 626: } ! 627: else ! 628: { ! 629: r = [super getCharValues:parameterArray ! 630: forParameter:parameterName ! 631: count:count]; ! 632: if (r == IO_R_UNSUPPORTED) ! 633: r = IO_R_INVALID_ARG; ! 634: } ! 635: return r; ! 636: } ! 637: ! 638: - (IOReturn)setIntValues:(unsigned *)parameterArray ! 639: forParameter:(IOParameterName)parameterName ! 640: count:(unsigned int)count ! 641: { ! 642: IOReturn r = IO_R_INVALID_ARG; ! 643: ! 644: if ( strcmp( parameterName, EVSIOSKR ) == 0 ) // Set Key Repeat ! 645: { ! 646: if ( count == EVSIOSKR_SIZE ) ! 647: { ! 648: [deviceLock lock]; ! 649: packed_nsecs_to_nsecs(parameterArray, &keyRepeat); ! 650: if ( keyRepeat < EV_MINKEYREPEAT ) ! 651: keyRepeat = EV_MINKEYREPEAT; ! 652: [deviceLock unlock]; ! 653: r = IO_R_SUCCESS; ! 654: } ! 655: } ! 656: else if ( strcmp( parameterName, EVSIOSIKR ) == 0 ) // Set Init Key Repeat ! 657: { ! 658: if ( count == EVSIOSIKR_SIZE ) ! 659: { ! 660: [deviceLock lock]; ! 661: packed_nsecs_to_nsecs(parameterArray, &initialKeyRepeat); ! 662: if ( initialKeyRepeat < EV_MINKEYREPEAT ) ! 663: initialKeyRepeat = EV_MINKEYREPEAT; ! 664: [deviceLock unlock]; ! 665: r = IO_R_SUCCESS; ! 666: } ! 667: } ! 668: else if ( strcmp( parameterName, EVSIORKBD ) == 0 ) // Reset keyboard ! 669: { ! 670: [self resetKeyboard]; ! 671: r = IO_R_SUCCESS; ! 672: } ! 673: else ! 674: { ! 675: r = [super setIntValues:parameterArray ! 676: forParameter:parameterName ! 677: count : count]; ! 678: if (r == IO_R_UNSUPPORTED) ! 679: r = IO_R_INVALID_ARG; ! 680: } ! 681: return r; ! 682: } ! 683: ! 684: - (IOReturn)setCharValues:(unsigned char *)parameterArray ! 685: forParameter:(IOParameterName)parameterName ! 686: count:(unsigned int)count ! 687: { ! 688: IOReturn r = IO_R_INVALID_ARG; ! 689: unsigned char *map; ! 690: id oldMap; ! 691: ! 692: if ( strcmp( parameterName, EVSIOSKM ) == 0 ) // Set KeyMap ! 693: { ! 694: map = (unsigned char *)IOMalloc( count ); ! 695: bcopy( parameterArray, map, count ); ! 696: [deviceLock lock]; ! 697: oldMap = keyMap; ! 698: keyMap = [[KeyMap alloc] initFromKeyMapping:map ! 699: length:count ! 700: canFree:YES]; ! 701: if ( keyMap != nil ) ! 702: { ! 703: if ( oldMap != nil ) ! 704: [oldMap free]; ! 705: [keyMap setDelegate:self]; ! 706: r = IO_R_SUCCESS; ! 707: } ! 708: else ! 709: { ! 710: keyMap = oldMap; ! 711: r = IO_R_INVALID_ARG; ! 712: } ! 713: [deviceLock unlock]; ! 714: } ! 715: else ! 716: { ! 717: r = [super setCharValues:parameterArray ! 718: forParameter:parameterName ! 719: count : count]; ! 720: if (r == IO_R_UNSUPPORTED) ! 721: r = IO_R_INVALID_ARG; ! 722: } ! 723: return r; ! 724: } ! 725: // ! 726: // END: Implementation of Exported EventSrcPCKeyoard methods ! 727: // ! 728: ! 729: ! 730: ! 731: // ! 732: // BEGIN: Implementation of EventSrcExported protocol ! 733: // ! 734: // ! 735: - (IOReturn)relinquishOwnership:(id)client ! 736: { ! 737: IOReturn r; ! 738: ! 739: // kill autorepeat task ! 740: downRepeatTime = 0ULL; ! 741: codeToRepeat = -1; ! 742: [self scheduleAutoRepeat]; ! 743: // clear modifiers to avoid stuck keys ! 744: [self setAlphaLock:NO]; ! 745: [[self owner] updateEventFlags:0]; ! 746: deviceDependentFlags = 0; ! 747: eventFlags = 0; ! 748: bzero( keyState, sizeof( kbdBitVector)); ! 749: ! 750: r = [super relinquishOwnership:client]; ! 751: [[self ownerLock] lock]; ! 752: // If nobody took over this EventSrc, release attached keyboards ! 753: wserver_on = 0; ! 754: if ( r == IO_R_SUCCESS && [self owner] == nil ) ! 755: { ! 756: if ( [kbdDevice relinquishOwnership:self] == IO_R_SUCCESS ) ! 757: ownDevice = NO; ! 758: } ! 759: [[self ownerLock] unlock]; ! 760: return r; ! 761: } ! 762: ! 763: - (IOReturn) becomeOwner:(id)client ! 764: { ! 765: IOReturn r; ! 766: ! 767: r = [super becomeOwner:client]; ! 768: [[self ownerLock] lock]; ! 769: if ( r == IO_R_SUCCESS && ownDevice == NO ) ! 770: { ! 771: if ( [kbdDevice becomeOwner:self] == IO_R_SUCCESS ) ! 772: { ! 773: ownDevice = YES; ! 774: wserver_on = 1; ! 775: // FIXME: Nasty hack to reinit mouse on server startup ! 776: [_my_Mouse mouseInit]; ! 777: } ! 778: else if ( [kbdDevice desireOwnership:self] != IO_R_SUCCESS ) ! 779: { ! 780: [super relinquishOwnership:client]; ! 781: r = IO_R_BUSY; ! 782: } ! 783: } ! 784: [[self ownerLock] unlock]; ! 785: return r; ! 786: } ! 787: // ! 788: // END: Implementation of EventSrcExported protocol ! 789: // ! 790: ! 791: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.