![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOHIKeyboard.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOHIDSystem|
Return to IOHIKeyboard.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOHIDSystem |
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: *
24: * From EventSrcPCKeyoard.m - PC Keyboard EventSrc subclass implementation
25: * Copyright (c) 1992 NeXT Computer, Inc. All rights reserved.
26: */
27:
28: #include <IOKit/IOLib.h>
29: #include <IOKit/hidsystem/IOHIKeyboard.h>
30: #include <IOKit/hidsystem/IOHIKeyboardMapper.h>
31: #include <IOKit/hidsystem/IOLLEvent.h>
32: #include <IOKit/hidsystem/IOHIDParameter.h>
33:
34: #define super IOHIDevice
35: OSDefineMetaClassAndStructors(IOHIKeyboard, IOHIDevice);
36:
37: bool IOHIKeyboard::init(OSDictionary * properties)
38: {
39: if (!super::init(properties)) return false;
40:
41: /*
42: * Initialize minimal state.
43: */
44:
45: _deviceLock = IOLockAlloc();
46: _keyMap = 0;
47: _keyStateSize = 4*((maxKeyCodes()+(EVK_BITS_PER_UNIT-1))/EVK_BITS_PER_UNIT);
48: _keyState = (UInt32 *) IOMalloc(_keyStateSize);
49:
50: if (!_deviceLock || !_keyState) return false;
51:
52: IOLockInit(_deviceLock);
53: bzero(_keyState, _keyStateSize);
54:
55: return true;
56: }
57:
58: bool IOHIKeyboard::start(IOService * provider)
59: {
60: if (!super::start(provider)) return false;
61:
62: /*
63: * IOHIKeyboard serves both as a service and a nub (we lead a double
64: * life). Register ourselves as a nub to kick off matching.
65: */
66:
67: registerService();
68:
69: return true;
70: }
71:
72: void IOHIKeyboard::free()
73: // Description: Go Away. Be careful when freeing the lock.
74: {
75: IOLock * lock = NULL;
76:
77: if ( _deviceLock )
78: {
79: lock = _deviceLock;
80: IOTakeLock( lock);
81: _deviceLock = NULL;
82: }
83: if ( _keyMap )
84: _keyMap->release();
85: if( _keyState )
86: IOFree( _keyState, _keyStateSize);
87: if ( lock )
88: {
89: IOUnlock( lock);
90: IOLockFree( lock);
91: }
92: super::free();
93: }
94:
95: IOHIDKind IOHIKeyboard::hidKind()
96: {
97: return kHIKeyboardDevice;
98: }
99:
100: bool IOHIKeyboard::updateProperties( void )
101: {
102: UInt64 keyRepeatNano;
103: UInt64 initialKeyRepeatNano;
104: bool ok;
105:
106: absolutetime_to_nanoseconds( _keyRepeat, &keyRepeatNano);
107: absolutetime_to_nanoseconds( _initialKeyRepeat, &initialKeyRepeatNano);
108:
109: ok = setProperty( kIOHIDKeyMappingKey, _keyMap )
110: & setProperty( kIOHIDKeyRepeatKey, &keyRepeatNano,
111: sizeof(keyRepeatNano))
112: & setProperty( kIOHIDInitialKeyRepeatKey, &initialKeyRepeatNano,
113: sizeof(initialKeyRepeatNano));
114:
115: return( ok & super::updateProperties() );
116: }
117:
118: IOReturn IOHIKeyboard::setParamProperties( OSDictionary * dict )
119: {
120: OSData * data;
121: IOReturn err = kIOReturnSuccess;
122: unsigned char * map;
123: IOHIKeyboardMapper * oldMap;
124: bool updated = false;
125: UInt64 nano;
126: IOTakeLock( _deviceLock);
127:
128: if( (data = OSDynamicCast( OSData,
129: dict->getObject(kIOHIDKeyRepeatKey)))) {
130:
131: nano = *((UInt64 *)(data->getBytesNoCopy()));
132: if( nano < EV_MINKEYREPEAT)
133: nano = EV_MINKEYREPEAT;
134: nanoseconds_to_absolutetime(nano, &_keyRepeat);
135: updated = true;
136: }
137:
138: if( (data = OSDynamicCast( OSData,
139: dict->getObject(kIOHIDInitialKeyRepeatKey)))) {
140:
141: nano = *((UInt64 *)(data->getBytesNoCopy()));
142: if( nano < EV_MINKEYREPEAT)
143: nano = EV_MINKEYREPEAT;
144: nanoseconds_to_absolutetime(nano, &_initialKeyRepeat);
145: updated = true;
146: }
147:
148: if( (data = OSDynamicCast( OSData, dict->getObject(kIOHIDKeyMappingKey)))) {
149:
150: map = (unsigned char *)IOMalloc( data->getLength() );
151: bcopy( data->getBytesNoCopy(), map, data->getLength() );
152: oldMap = _keyMap;
153: _keyMap = IOHIKeyboardMapper::keyboardMapper(this, map, data->getLength(), true);
154: if (_keyMap) {
155: if (oldMap)
156: oldMap->release();
157: updated = true;
158: } else {
159: _keyMap = oldMap;
160: err = kIOReturnBadArgument;
161: }
162: }
163: IOUnlock( _deviceLock);
164:
165: if( dict->getObject(kIOHIDResetKeyboardKey))
166: resetKeyboard();
167:
168: if( updated )
169: updateProperties();
170:
171: return( err );
172: }
173:
174: bool IOHIKeyboard::resetKeyboard()
175: // Description: Reset the keymapping to the default value and reconfigure
176: // the keyboards.
177: {
178: const unsigned char *defaultKeymap;
179: UInt32 defaultKeymapLength;
180:
181: IOTakeLock( _deviceLock);
182:
183: if ( _keyMap )
184: _keyMap->release();
185:
186: // Set up default keymapping.
187: defaultKeymap = defaultKeymapOfLength(&defaultKeymapLength);
188:
189: _keyMap = IOHIKeyboardMapper::keyboardMapper( this,
190: defaultKeymap,
191: defaultKeymapLength,
192: false );
193: if (_keyMap)
194: {
195: clock_interval_to_absolutetime_interval( EV_DEFAULTKEYREPEAT,
196: kNanosecondScale, &_keyRepeat);
197: clock_interval_to_absolutetime_interval( EV_DEFAULTINITIALREPEAT,
198: kNanosecondScale, &_initialKeyRepeat);
199: }
200:
201: updateProperties();
202:
203: IOUnlock( _deviceLock);
204: return (_keyMap) ? true : false;
205: }
206:
207: void IOHIKeyboard::scheduleAutoRepeat()
208: // Description: Schedule a procedure to be called when a timeout has expired
209: // so that we can generate a repeated key.
210: // Preconditions:
211: // * _deviceLock should be held on entry
212: {
213: if ( _calloutPending == true )
214: {
215: thread_call_func_cancel(_autoRepeat, this, true);
216: _calloutPending = false;
217: }
218: if ( AbsoluteTime_to_scalar(&_downRepeatTime) )
219: {
220: AbsoluteTime deadline;
221: clock_absolutetime_interval_to_deadline(_downRepeatTime, &deadline);
222: thread_call_func_delayed(_autoRepeat, this, deadline);
223: _calloutPending = true;
224: }
225: }
226:
227: void IOHIKeyboard::_autoRepeat(thread_call_param_t arg,
228: thread_call_param_t) /* thread_call_func_t */
229: {
230: IOHIKeyboard *self = (IOHIKeyboard *) arg;
231: self->autoRepeat();
232: }
233:
234: void IOHIKeyboard::autoRepeat()
235: // Description: Repeat the currently pressed key and schedule ourselves
236: // to be called again after another interval elapses.
237: // Preconditions:
238: // * Should only be executed on callout thread
239: // * _deviceLock should be unlocked on entry.
240: {
241: IOTakeLock( _deviceLock);
242: if ( _calloutPending == false )
243: {
244: IOUnlock( _deviceLock);
245: return;
246: }
247: _calloutPending = false;
248: _isRepeat = true;
249:
250: if ( AbsoluteTime_to_scalar(&_downRepeatTime) )
251: {
252: // Device is due to generate a repeat
253: if (_keyMap) _keyMap->translateKeyCode(_codeToRepeat,
254: /* direction */ true,
255: /* keyBits */ _keyState);
256: _downRepeatTime = _keyRepeat;
257: }
258:
259: _isRepeat = false;
260: scheduleAutoRepeat();
261: IOUnlock( _deviceLock);
262: }
263:
264: void IOHIKeyboard::setRepeat(unsigned eventType, unsigned keyCode)
265: // Description: Set up or tear down key repeat operations. The method
266: // that locks _deviceLock is a bit higher on the call stack.
267: // This method is invoked as a side effect of our own
268: // invocation of _keyMap->translateKeyCode().
269: // Preconditions:
270: // * _deviceLock should be held upon entry.
271: {
272: if ( _isRepeat == false ) // make sure we're not already repeating
273: {
274: if (eventType == NX_KEYDOWN) // Start repeat
275: {
276: // Set this key to repeat (push out last key if present)
277: _downRepeatTime = _initialKeyRepeat; // + _lastEventTime;
278: _codeToRepeat = keyCode;
279: // reschedule key repeat event here
280: scheduleAutoRepeat();
281: }
282: else if (eventType == NX_KEYUP) // End repeat
283: {
284: /* Remove from downKey */
285: if (_codeToRepeat == keyCode)
286: {
287: AbsoluteTime_to_scalar(&_downRepeatTime) = 0;
288: _codeToRepeat = (unsigned)-1;
289: scheduleAutoRepeat();
290: }
291: }
292: }
293: }
294:
295: //
296: // BEGIN: Implementation of the methods required by IOHIKeyboardMapper.
297: //
298:
299: void IOHIKeyboard::keyboardEvent(unsigned eventType,
300: /* flags */ unsigned flags,
301: /* keyCode */ unsigned keyCode,
302: /* charCode */ unsigned charCode,
303: /* charSet */ unsigned charSet,
304: /* originalCharCode */ unsigned origCharCode,
305: /* originalCharSet */ unsigned origCharSet)
306: // Description: We use this notification to set up our _keyRepeat timer
307: // and to pass along the event to our owner. This method
308: // will be called while the KeyMap object is processing
309: // the key code we've sent it using deliverKey.
310: {
311:
312: if (_keyboardEventAction) /* upstream call */
313: {
314: (*_keyboardEventAction)(_keyboardEventTarget,
315: eventType,
316: /* flags */ flags,
317: /* keyCode */ keyCode,
318: /* charCode */ charCode,
319: /* charSet */ charSet,
320: /* originalCharCode */ origCharCode,
321: /* originalCharSet */ origCharSet,
322: /* repeat */ _isRepeat,
323: /* atTime */ _lastEventTime);
324: }
325:
326: // Set up key repeat operations here.
327: setRepeat(eventType, keyCode);
328: }
329:
330: void IOHIKeyboard::keyboardSpecialEvent(unsigned eventType,
331: /* flags */ unsigned flags,
332: /* keyCode */ unsigned keyCode,
333: /* specialty */ unsigned flavor)
334: // Description: See the description for keyboardEvent.
335: {
336:
337: if (_keyboardSpecialEventAction) /* upstream call */
338: {
339: (*_keyboardSpecialEventAction)(_keyboardSpecialEventTarget,
340: eventType,
341: /* flags */ flags,
342: /* keyCode */ keyCode,
343: /* specialty */ flavor,
344: /* atTime */ _lastEventTime);
345: }
346:
347: // Set up key repeat operations here.
348: if (flavor != NX_KEYTYPE_CAPS_LOCK)
349: setRepeat(eventType, keyCode);
350: }
351:
352: void IOHIKeyboard::updateEventFlags(unsigned flags)
353: // Description: Process non-event-generating flag changes. Simply pass this
354: // along to our owner.
355: {
356: if (_updateEventFlagsAction) /* upstream call */
357: {
358: (*_updateEventFlagsAction)(_updateEventFlagsTarget, flags);
359: }
360: }
361:
362: unsigned IOHIKeyboard::eventFlags()
363: // Description: Return global event flags In this world, there is only
364: // one keyboard device so device flags == global flags.
365: {
366: return _eventFlags;
367: }
368:
369: unsigned IOHIKeyboard::deviceFlags()
370: // Description: Return per-device event flags. In this world, there is only
371: // one keyboard device so device flags == global flags.
372: {
373: return _eventFlags;
374: }
375:
376: void IOHIKeyboard::setDeviceFlags(unsigned flags)
377: // Description: Set device event flags. In this world, there is only
378: // one keyboard device so device flags == global flags.
379: {
380: _eventFlags = flags;
381: }
382:
383: bool IOHIKeyboard::alphaLock()
384: // Description: Return current alpha-lock state. This is a state tracking
385: // callback used by the KeyMap object.
386: {
387: return _alphaLock;
388: }
389:
390: void IOHIKeyboard::setAlphaLock(bool val)
391: // Description: Set current alpha-lock state This is a state tracking
392: // callback used by the KeyMap object.
393: {
394: _alphaLock = val;
395: setAlphaLockFeedback(val);
396: }
397:
398: bool IOHIKeyboard::charKeyActive()
399: // Description: Return true If a character generating key down This is a state
400: // tracking callback used by the KeyMap object.
401: {
402: return _charKeyActive;
403: }
404:
405: void IOHIKeyboard::setCharKeyActive(bool val)
406: // Description: Note whether a char generating key is down. This is a state
407: // tracking callback used by the KeyMap object.
408: {
409: _charKeyActive = val;
410: }
411: //
412: // END: Implementation of the methods required by IOHIKeyboardMapper.
413: //
414:
415: void IOHIKeyboard::dispatchKeyboardEvent(unsigned int keyCode,
416: /* direction */ bool goingDown,
417: /* timeStamp */ AbsoluteTime time)
418: // Description: This method is the heart of event dispatching. The overlying
419: // subclass invokes this method with each event. We then
420: // get the event xlated and dispatched using a _keyMap instance.
421: // The event structure passed in by reference should not be freed.
422: {
423: _lastEventTime = time;
424:
425: IOTakeLock( _deviceLock);
426:
427: if (_keyMap) _keyMap->translateKeyCode(keyCode,
428: /* direction */ goingDown,
429: /* keyBits */ _keyState);
430: IOUnlock( _deviceLock);
431: }
432:
433: const unsigned char * IOHIKeyboard::defaultKeymapOfLength(UInt32 * length)
434: {
435: *length = 0;
436: return NULL;
437: }
438:
439: void IOHIKeyboard::setAlphaLockFeedback(bool /* val */)
440: {
441: return;
442: }
443:
444: UInt32 IOHIKeyboard::maxKeyCodes()
445: {
446: return( 0x80);
447: }
448:
449: bool IOHIKeyboard::open(IOService * client,
450: IOOptionBits options,
451: KeyboardEventAction keAction,
452: KeyboardSpecialEventAction kseAction,
453: UpdateEventFlagsAction uefAction)
454: {
455: if ( (!_keyMap) && (!resetKeyboard())) return false;
456:
457: if (super::open(client, options))
458: {
459: // Note: client object is already retained by superclass' open()
460: _keyboardEventTarget = client;
461: _keyboardEventAction = keAction;
462: _keyboardSpecialEventTarget = client;
463: _keyboardSpecialEventAction = kseAction;
464: _updateEventFlagsTarget = client;
465: _updateEventFlagsAction = uefAction;
466:
467: return true;
468: }
469:
470: return false;
471: }
472:
473: void IOHIKeyboard::close(IOService * client, IOOptionBits)
474: {
475: // kill autorepeat task
476: AbsoluteTime_to_scalar(&_downRepeatTime) = 0;
477: _codeToRepeat = (unsigned)-1;
478: scheduleAutoRepeat();
479: // clear modifiers to avoid stuck keys
480: setAlphaLock(false);
481: if (_updateEventFlagsAction)
482: (*_updateEventFlagsAction)(_updateEventFlagsTarget, 0); _eventFlags = 0;
483: bzero(_keyState, _keyStateSize);
484:
485: _keyboardEventAction = NULL;
486: _keyboardEventTarget = 0;
487: _keyboardSpecialEventAction = NULL;
488: _keyboardSpecialEventTarget = 0;
489: _updateEventFlagsAction = NULL;
490: _updateEventFlagsTarget = 0;
491:
492: super::close(client);
493: }
494:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.