![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ApplePS2Controller.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 / drvApplePS2Controller|
Return to ApplePS2Controller.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / platform / drvApplePS2Controller |
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: #include <IOKit/assert.h>
24: #include <IOKit/IOService.h>
25: #include <IOKit/IOSyncer.h>
26: #include <IOKit/IOCommandQueue.h>
27: #include <IOKit/ps2/ApplePS2KeyboardDevice.h>
28: #include <IOKit/ps2/ApplePS2MouseDevice.h>
29: #include "ApplePS2Controller.h"
30:
31: extern "C"
32: {
33: #include <architecture/i386/pio.h>
34: #include <machine/machine_routines.h>
35: }
36:
37: static ApplePS2Controller * gApplePS2Controller = 0; // global variable to self
38:
39: // =============================================================================
40: // Interrupt-Time Support Functions
41: //
42:
43: static void interruptHandlerMouse(OSObject *, void *, IOService *, int)
44: {
45: //
46: // Wake our workloop to service the interrupt. This is an edge-triggered
47: // interrupt, so returning from this routine without clearing the interrupt
48: // condition is perfectly normal.
49: //
50:
51: gApplePS2Controller->_interruptSourceMouse->interruptOccurred(0, 0, 0);
52: }
53:
54: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
55:
56: static void interruptHandlerKeyboard(OSObject *, void *, IOService *, int)
57: {
58: #if DEBUGGER_SUPPORT
59: //
60: // The keyboard interrupt handler reads in the pending scan code and stores
61: // it on our internal queue; should it completes a debugger escape sequence,
62: // we jump to the debugger function immediately.
63: //
64:
65: UInt8 key;
66: UInt8 status;
67:
68: // Lock out the keyboard interrupt handler [redundant here] and claim
69: // exclusive access to the internal keyboard queue.
70:
71: gApplePS2Controller->lockController();
72:
73: // Verify that data is available on the controller's input port.
74:
75: if ( ((status = inb(kCommandPort)) & kOutputReady) )
76: {
77: // Verify that the data is keyboard data, otherwise call mouse handler.
78: // This case should never really happen, but if it does, we handle it.
79:
80: if ( (status & kMouseData) )
81: {
82: interruptHandlerMouse(0, 0, 0, 0);
83: }
84: else
85: {
86: // Retrieve the keyboard data on the controller's input port.
87:
88: key = inb(kDataPort);
89:
90: // Call the debugger-key-sequence checking code (if a debugger sequence
91: // completes, the debugger function will be invoked immediately within
92: // doEscape). The doEscape call may insist that we drop the scan code
93: // we just received in some cases (a true return) -- we don't question
94: // it's judgement and comply.
95:
96: if (gApplePS2Controller->doEscape(key) == false)
97: gApplePS2Controller->enqueueKeyboardData(key);
98:
99: // In all cases, we wake up our workloop to service the interrupt data.
100: gApplePS2Controller->_interruptSourceKeyboard->interruptOccurred(0, 0, 0);
101: }
102: }
103:
104: // Remove the lockout on the keyboard interrupt handler [ineffective here]
105: // and release our exclusive access to the internal keyboard queue.
106:
107: gApplePS2Controller->unlockController();
108: #else
109: //
110: // Wake our workloop to service the interrupt. This is an edge-triggered
111: // interrupt, so returning from this routine without clearing the interrupt
112: // condition is perfectly normal.
113: //
114:
115: gApplePS2Controller->_interruptSourceKeyboard->interruptOccurred(0, 0, 0);
116:
117: #endif DEBUGGER_SUPPORT
118: }
119:
120: // =============================================================================
121: // ApplePS2Controller Class Implementation
122: //
123:
124: #define super IOService
125: OSDefineMetaClassAndStructors(ApplePS2Controller, IOService);
126:
127: bool ApplePS2Controller::init(OSDictionary * properties)
128: {
129: if (!super::init(properties)) return false;
130:
131: //
132: // Initialize minimal state.
133: //
134:
135: _commandQueue = 0;
136: _workLoop = 0;
137:
138: _interruptSourceKeyboard = 0;
139: _interruptSourceMouse = 0;
140:
141: _interruptTargetKeyboard = 0;
142: _interruptTargetMouse = 0;
143:
144: _interruptActionKeyboard = NULL;
145: _interruptActionMouse = NULL;
146:
147: _interruptInstalledKeyboard = false;
148: _interruptInstalledMouse = false;
149:
150: _mouseDevice = 0;
151: _keyboardDevice = 0;
152:
153: #if DEBUGGER_SUPPORT
154: _extendedState = false;
155: _modifierState = 0x00;
156:
157: _keyboardQueueAlloc = NULL;
158: queue_init(&_keyboardQueue);
159: queue_init(&_keyboardQueueUnused);
160:
161: _controllerLockOldSpl = 0;
162: usimple_lock_init(&_controllerLock, ETAP_NO_TRACE);
163: #endif DEBUGGER_SUPPORT
164:
165: return true;
166: }
167:
168: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
169:
170: bool ApplePS2Controller::start(IOService * provider)
171: {
172: //
173: // The driver has been instructed to start. Allocate all our resources.
174: //
175:
176: if (!super::start(provider)) return false;
177:
178: #if DEBUGGER_SUPPORT
179: _keyboardQueueAlloc = (KeyboardQueueElement *)
180: IOMalloc(kKeyboardQueueSize*sizeof(KeyboardQueueElement));
181: if (!_keyboardQueueAlloc) return false;
182:
183: // Add the allocated keyboard queue entries to "unused" queue.
184: for (int index = 0; index < kKeyboardQueueSize; index++)
185: queue_enter(&_keyboardQueueUnused, &_keyboardQueueAlloc[index],
186: KeyboardQueueElement *, chain);
187: #endif DEBUGGER_SUPPORT
188:
189: //
190: // Initialize the mouse and keyboard hardware to a known state -- the IRQs
191: // are disabled (don't want interrupts), the clock line is enabled (want to
192: // be able to send commands), and the device itself is disabled (don't want
193: // asynchronous data arrival for key/mouse events). We call the read/write
194: // port routines directly, since no other thread will conflict with us.
195: //
196:
197: UInt8 commandByte;
198: writeCommandPort(kCP_GetCommandByte);
199: commandByte = readDataPort(kDT_Keyboard);
200: commandByte &= ~(kCB_EnableMouseIRQ | kCB_DisableMouseClock);
201: writeCommandPort(kCP_SetCommandByte);
202: writeDataPort(commandByte);
203:
204: writeDataPort(kDP_SetDefaultsAndDisable);
205: readDataPort(kDT_Keyboard); // (discard acknowledge; success irrelevant)
206:
207: writeCommandPort(kCP_TransmitToMouse);
208: writeDataPort(kDP_SetDefaultsAndDisable);
209: readDataPort(kDT_Mouse); // (discard acknowledge; success irrelevant)
210:
211: //
212: // Clear out garbage in the controller's input streams, before starting up
213: // the work loop.
214: //
215:
216: while ( inb(kCommandPort) & kOutputReady )
217: {
218: inb(kDataPort);
219: IODelay(kDataDelay);
220: }
221:
222: //
223: // Initialize our work loop, our command queue, and our interrupt event
224: // sources. The work loop can accept requests after this step.
225: //
226:
227: _workLoop = IOWorkLoop::workLoop();
228: _commandQueue = IOCommandQueue::commandQueue(
229: this, (IOCommandQueueAction) &ApplePS2Controller::processRequest);
230: _interruptSourceMouse = IOInterruptEventSource::interruptEventSource(
231: this, (IOInterruptEventAction) &ApplePS2Controller::interruptOccurred);
232: _interruptSourceKeyboard = IOInterruptEventSource::interruptEventSource(
233: this, (IOInterruptEventAction) &ApplePS2Controller::interruptOccurred);
234:
235: if ( !_workLoop ||
236: !_commandQueue ||
237: !_interruptSourceMouse ||
238: !_interruptSourceKeyboard ) return false;
239:
240: if ( _workLoop->addEventSource(_commandQueue) != kIOReturnSuccess )
241: return false;
242:
243: //
244: // Create the keyboard nub and the mouse nub. The keyboard and mouse drivers
245: // will query these nubs to determine the existence of the keyboard or mouse,
246: // and should they exist, will attach themselves to the nub as clients.
247: //
248:
249: _keyboardDevice = new ApplePS2KeyboardDevice;
250:
251: if ( !_keyboardDevice ||
252: !_keyboardDevice->init() ||
253: !_keyboardDevice->attach(this) ) return false;
254:
255: _mouseDevice = new ApplePS2MouseDevice;
256:
257: if ( !_mouseDevice ||
258: !_mouseDevice->init() ||
259: !_mouseDevice->attach(this) ) return false;
260:
261: gApplePS2Controller = this;
262:
263: _keyboardDevice->registerService();
264: _mouseDevice->registerService();
265:
266: return true; // success
267: }
268:
269: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
270:
271: void ApplePS2Controller::stop(IOService * provider)
272: {
273: //
274: // The driver has been instructed to stop. Note that we must break all
275: // connections to other service objects now (ie. no registered actions,
276: // no pointers and retains to objects, etc), if any.
277: //
278:
279: // Ensure that the interrupt handlers have been uninstalled (ie. no clients).
280: assert(_interruptInstalledKeyboard == false);
281: assert(_interruptInstalledMouse == false);
282:
283: // Free the nubs we created.
284: if (_keyboardDevice) _keyboardDevice->release();
285: if (_mouseDevice) _mouseDevice->release();
286:
287: // Free the work loop.
288: if (_workLoop) _workLoop->release();
289:
290: // Free the interrupt source and command queue.
291: if (_commandQueue) _commandQueue->release();
292: if (_interruptSourceKeyboard) _interruptSourceKeyboard->release();
293: if (_interruptSourceMouse) _interruptSourceMouse->release();
294:
295: #if DEBUGGER_SUPPORT
296: // Free the keyboard queue allocation space (after disabling interrupt).
297: if (_keyboardQueueAlloc)
298: IOFree(_keyboardQueueAlloc,kKeyboardQueueSize*sizeof(KeyboardQueueElement));
299: #endif DEBUGGER_SUPPORT
300:
301: gApplePS2Controller = 0;
302:
303: super::stop(provider);
304: }
305:
306: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
307:
308: IOWorkLoop * ApplePS2Controller::getWorkLoop() const
309: {
310: return _workLoop;
311: }
312:
313: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
314:
315: void ApplePS2Controller::installInterruptAction(PS2DeviceType deviceType,
316: OSObject * target,
317: PS2InterruptAction action)
318: {
319: //
320: // Install the keyboard or mouse interrupt handler.
321: //
322: // This method assumes only one possible mouse and only one possible
323: // keyboard client (ie. callers), and assumes two distinct interrupt
324: // handlers for each, hence needs no protection against races.
325: //
326:
327: // Is it the keyboard or the mouse interrupt handler that was requested?
328: // We only install it if it is currently uninstalled.
329:
330: if (deviceType == kDT_Keyboard && _interruptInstalledKeyboard == false)
331: {
332: target->retain();
333: _interruptTargetKeyboard = target;
334: _interruptActionKeyboard = action;
335: _workLoop->addEventSource(_interruptSourceKeyboard);
336: getProvider()->registerInterrupt(kIRQ_Keyboard,0, interruptHandlerKeyboard);
337: getProvider()->enableInterrupt(kIRQ_Keyboard);
338: _interruptInstalledKeyboard = true;
339: }
340:
341: else if (deviceType == kDT_Mouse && _interruptInstalledMouse == false)
342: {
343: target->retain();
344: _interruptTargetMouse = target;
345: _interruptActionMouse = action;
346: _workLoop->addEventSource(_interruptSourceMouse);
347: getProvider()->registerInterrupt(kIRQ_Mouse, 0, interruptHandlerMouse);
348: getProvider()->enableInterrupt(kIRQ_Mouse);
349: _interruptInstalledMouse = true;
350: }
351: }
352:
353: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
354:
355: void ApplePS2Controller::uninstallInterruptAction(PS2DeviceType deviceType)
356: {
357: //
358: // Uninstall the keyboard or mouse interrupt handler.
359: //
360: // This method assumes only one possible mouse and only one possible
361: // keyboard client (ie. callers), and assumes two distinct interrupt
362: // handlers for each, hence needs no protection against races.
363: //
364:
365: // Is it the keyboard or the mouse interrupt handler that was requested?
366: // We only install it if it is currently uninstalled.
367:
368: if (deviceType == kDT_Keyboard && _interruptInstalledKeyboard == true)
369: {
370: getProvider()->disableInterrupt(kIRQ_Keyboard);
371: getProvider()->unregisterInterrupt(kIRQ_Keyboard);
372: _workLoop->removeEventSource(_interruptSourceMouse);
373: _interruptInstalledKeyboard = false;
374: _interruptActionKeyboard = NULL;
375: _interruptTargetKeyboard->release();
376: _interruptTargetKeyboard = 0;
377: }
378:
379: else if (deviceType == kDT_Mouse && _interruptInstalledMouse == true)
380: {
381: getProvider()->disableInterrupt(kIRQ_Mouse);
382: getProvider()->unregisterInterrupt(kIRQ_Mouse);
383: _workLoop->removeEventSource(_interruptSourceMouse);
384: _interruptInstalledMouse = false;
385: _interruptActionMouse = NULL;
386: _interruptTargetMouse->release();
387: _interruptTargetMouse = 0;
388: }
389: }
390:
391: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
392:
393: PS2Request * ApplePS2Controller::allocateRequest()
394: {
395: //
396: // Allocate a request structure. Blocks until successful. Request structure
397: // is guaranteed to be zeroed.
398: //
399:
400: PS2Request * request = (PS2Request *) IOMalloc(sizeof(PS2Request));
401: bzero(request, sizeof(PS2Request));
402: return request;
403: }
404:
405: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
406:
407: void ApplePS2Controller::freeRequest(PS2Request * request)
408: {
409: //
410: // Deallocate a request structure.
411: //
412:
413: IOFree(request, sizeof(PS2Request));
414: }
415:
416: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
417:
418: bool ApplePS2Controller::submitRequest(PS2Request * request)
419: {
420: //
421: // Submit the request to the controller for processing, asynchronously.
422: //
423:
424: return (_commandQueue->enqueueCommand(false, request) == KERN_SUCCESS);
425: }
426:
427: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
428:
429: void ApplePS2Controller::submitRequestAndBlock(PS2Request * request)
430: {
431: //
432: // Submit the request to the controller for processing, synchronously.
433: //
434:
435: IOSyncer * completionSyncer = IOSyncer::create();
436:
437: assert(completionSyncer);
438: request->completionTarget = this;
439: request->completionAction = submitRequestAndBlockCompletion;
440: request->completionParam = completionSyncer;
441:
442: _commandQueue->enqueueCommand(true, request);
443:
444: completionSyncer->wait(); // wait 'till done
445: }
446:
447: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
448:
449: void ApplePS2Controller::submitRequestAndBlockCompletion(void *, void * param)
450: { // PS2CompletionAction
451: IOSyncer * completionSyncer = (IOSyncer *) param;
452: completionSyncer->signal();
453: }
454:
455: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
456:
457: void ApplePS2Controller::interruptOccurred(IOInterruptEventSource *, int)
458: { // IOInterruptEventAction
459: //
460: // Our work loop has informed us of an interrupt, that is, asynchronous
461: // data has arrived on our input stream. Read the data and dispatch it
462: // to the appropriate driver.
463: //
464: // This method should only be called from our single-threaded work loop.
465: //
466:
467: UInt8 status;
468:
469: #if DEBUGGER_SUPPORT
470: lockController(); // (lock out interrupt + access to queue)
471: while (1)
472: {
473: // See if data is available on the keyboard input stream (off queue);
474: // we do not read keyboard data from the real data port if it should
475: // be available.
476:
477: if (dequeueKeyboardData(&status))
478: {
479: unlockController();
480: dispatchDriverInterrupt(kDT_Keyboard, status);
481: lockController();
482: }
483:
484: // See if data is available on the mouse input stream (off real port).
485:
486: else if ( (inb(kCommandPort) & (kOutputReady | kMouseData)) ==
487: (kOutputReady | kMouseData))
488: {
489: unlockController();
490: dispatchDriverInterrupt(kDT_Mouse, inb(kDataPort));
491: lockController();
492: }
493: else break; // out of loop
494: }
495: unlockController(); // (release interrupt lockout + access to queue)
496: #else
497: // Loop only while there is data currently on the input stream.
498:
499: while ( ((status = inb(kCommandPort)) & kOutputReady) )
500: {
501: // Read in and dispatch the data, but only if it isn't what is required
502: // by the active command.
503:
504: dispatchDriverInterrupt((status&kMouseData)?kDT_Mouse:kDT_Keyboard,
505: inb(kDataPort));
506: }
507: #endif DEBUGGER_SUPPORT
508: }
509:
510: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
511:
512: void ApplePS2Controller::dispatchDriverInterrupt(PS2DeviceType deviceType,
513: UInt8 data)
514: {
515: //
516: // The supplied data is passed onto the interrupt handler in the appropriate
517: // driver, if one is registered, otherwise the data byte is thrown away.
518: //
519: // This method should only be called from our single-threaded work loop.
520: //
521:
522: if ( deviceType == kDT_Mouse )
523: {
524: // Dispatch the data to the mouse driver.
525: if (_interruptInstalledMouse)
526: (*_interruptActionMouse)(_interruptTargetMouse, data);
527: }
528: else if ( deviceType == kDT_Keyboard )
529: {
530: // Dispatch the data to the keyboard driver.
531: if (_interruptInstalledKeyboard)
532: (*_interruptActionKeyboard)(_interruptTargetKeyboard, data);
533: }
534: }
535:
536: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
537:
538: void ApplePS2Controller::processRequest(PS2Request * request,
539: void * /* field1 */,
540: void * /* field2 */,
541: void * /* field3 */)
542: // IOCommandQueueAction
543: {
544: //
545: // Our work loop has informed us of a request submission. Process
546: // the request. Note that this code "figures out" when the mouse
547: // input stream should be read over the keyboard input stream.
548: //
549: // This method should only be called from our single-threaded work loop.
550: //
551:
552: UInt8 byte;
553: PS2DeviceType deviceMode = kDT_Keyboard;
554: bool failed = false;
555: bool transmitToMouse = false;
556: unsigned index;
557:
558: // Process each of the commands in the list.
559:
560: for (index = 0; index < request->commandsCount; index++)
561: {
562: switch (request->commands[index].command)
563: {
564: case kPS2C_ReadDataPort:
565: request->commands[index].inOrOut = readDataPort(deviceMode);
566: break;
567:
568: case kPS2C_ReadDataPortAndCompare:
569: #if OUT_OF_ORDER_DATA_CORRECTION_FEATURE
570: byte = readDataPort(deviceMode, request->commands[index].inOrOut);
571: #else
572: byte = readDataPort(deviceMode);
573: #endif
574: failed = (byte != request->commands[index].inOrOut);
575: break;
576:
577: case kPS2C_WriteDataPort:
578: writeDataPort(request->commands[index].inOrOut);
579: if (transmitToMouse) // next reads from mouse input stream
580: {
581: deviceMode = kDT_Mouse;
582: transmitToMouse = false;
583: }
584: else
585: {
586: deviceMode = kDT_Keyboard;
587: }
588: break;
589:
590: case kPS2C_WriteCommandPort:
591: writeCommandPort(request->commands[index].inOrOut);
592: if (request->commands[index].inOrOut == kCP_TransmitToMouse)
593: transmitToMouse = true; // preparing to transmit data to mouse
594: break;
595: }
596:
597: if (failed) break;
598: }
599:
600: // If a command failed and stopped the request processing, store its
601: // index into the commandsCount field.
602:
603: if (failed) request->commandsCount = index;
604:
605: // Invoke the completion routine, if one was supplied.
606:
607: if (request->completionTarget && request->completionAction)
608: {
609: (*request->completionAction)(request->completionTarget,
610: request->completionParam);
611: }
612: }
613:
614: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
615:
616: UInt8 ApplePS2Controller::readDataPort(PS2DeviceType deviceType)
617: {
618: //
619: // Blocks until keyboard or mouse data is available from the controller
620: // and returns that data. Note, if mouse data is requested but keyboard
621: // data is what is available, the data is delivered to the appropriate
622: // driver interrupt routine immediately (effectively, the request is
623: // "preempted" temporarily).
624: //
625: // There is a built-in timeout for this command of (timeoutCounter X
626: // kDataDelay) microseconds, approximately.
627: //
628: // This method should only be called from our single-threaded work loop.
629: //
630:
631: UInt8 readByte;
632: UInt8 status;
633: UInt32 timeoutCounter = 10000; // (timeoutCounter * kDataDelay = 70 ms)
634:
635: while (1)
636: {
637: #if DEBUGGER_SUPPORT
638: lockController(); // (lock out interrupt + access to queue)
639: if (deviceType == kDT_Keyboard && dequeueKeyboardData(&readByte))
640: {
641: unlockController();
642: return readByte;
643: }
644: #endif DEBUGGER_SUPPORT
645:
646: //
647: // Wait for the controller's output buffer to become ready.
648: //
649:
650: while (timeoutCounter && !((status = inb(kCommandPort)) & kOutputReady))
651: {
652: timeoutCounter--;
653: IODelay(kDataDelay);
654: }
655:
656: //
657: // If we timed out, something went awfully wrong; return a fake value.
658: //
659:
660: if (timeoutCounter == 0)
661: {
662: #if DEBUGGER_SUPPORT
663: unlockController(); // (release interrupt lockout + access to queue)
664: #endif DEBUGGER_SUPPORT
665:
666: IOLog("%s: Timed out on %s input stream.\n", getName(),
667: (deviceType == kDT_Keyboard) ? "keyboard" : "mouse");
668: return 0;
669: }
670:
671: //
672: // Read in the data. We return the data, however, only if it arrived on
673: // the requested input stream.
674: //
675:
676: readByte = inb(kDataPort);
677:
678: #if DEBUGGER_SUPPORT
679: unlockController(); // (release interrupt lockout + access to queue)
680: #endif DEBUGGER_SUPPORT
681:
682: if ( (status & kMouseData) )
683: {
684: if (deviceType == kDT_Mouse) return readByte;
685: }
686: else
687: {
688: if (deviceType == kDT_Keyboard) return readByte;
689: }
690:
691: //
692: // The data we just received is for the other input stream, not the one
693: // that was requested, so dispatch other device's interrupt handler.
694: //
695:
696: dispatchDriverInterrupt((deviceType==kDT_Keyboard)?kDT_Mouse:kDT_Keyboard,
697: readByte);
698: } // while (forever)
699: }
700:
701: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
702:
703: #if OUT_OF_ORDER_DATA_CORRECTION_FEATURE
704:
705: UInt8 ApplePS2Controller::readDataPort(PS2DeviceType deviceType,
706: UInt8 expectedByte)
707: {
708: //
709: // Blocks until keyboard or mouse data is available from the controller
710: // and returns that data. Note, if mouse data is requested but keyboard
711: // data is what is available, the data is delivered to the appropriate
712: // driver interrupt routine immediately (effectively, the request is
713: // "preempted" temporarily).
714: //
715: // There is a built-in timeout for this command of (timeoutCounter X
716: // kDataDelay) microseconds, approximately.
717: //
718: // This method should only be called from our single-threaded work loop.
719: //
720: // This version of readDataPort does exactly the same as the original,
721: // except that if the value that should be read from the (appropriate)
722: // input stream is not what is expected, we make these assumptions:
723: //
724: // (a) the data byte we did get was "asynchronous" data being sent by
725: // the device, which has not figured out that it has to respond to
726: // the command we just sent to it.
727: // (b) that the real "expected" response will be the next byte in the
728: // stream; so what we do is put aside the first byte we read and
729: // wait for the next byte; if it's the expected value, we dispatch
730: // the first byte we read to the driver's interrupt handler, then
731: // return the expected byte. The caller will have never known that
732: // asynchronous data arrived at a very bad time.
733: // (c) that the real "expected" response will arrive within (kDataDelay
734: // X timeoutCounter) microseconds from the time the call is made.
735: //
736:
737: UInt8 firstByte = 0;
738: bool firstByteHeld = false;
739: UInt8 readByte;
740: bool requestedStream;
741: UInt8 status;
742: UInt32 timeoutCounter = 10000; // (timeoutCounter * kDataDelay = 70 ms)
743:
744: while (1)
745: {
746: #if DEBUGGER_SUPPORT
747: lockController(); // (lock out interrupt + access to queue)
748: if (deviceType == kDT_Keyboard && dequeueKeyboardData(&readByte))
749: {
750: requestedStream = true;
751: goto skipForwardToY;
752: }
753: #endif DEBUGGER_SUPPORT
754:
755: //
756: // Wait for the controller's output buffer to become ready.
757: //
758:
759: while (timeoutCounter && !((status = inb(kCommandPort)) & kOutputReady))
760: {
761: timeoutCounter--;
762: IODelay(kDataDelay);
763: }
764:
765: //
766: // If we timed out, we return the first byte we read, unless THIS IS the
767: // first byte we are trying to read, then something went awfully wrong
768: // and we return a fake value rather than lock up the controller longer.
769: //
770:
771: if (timeoutCounter == 0)
772: {
773: #if DEBUGGER_SUPPORT
774: unlockController(); // release interrupt lockout + access to queue
775: #endif DEBUGGER_SUPPORT
776:
777: if (firstByteHeld) return firstByte;
778:
779: IOLog("%s: Timed out on %s input stream.\n", getName(),
780: (deviceType == kDT_Keyboard) ? "keyboard" : "mouse");
781: return 0;
782: }
783:
784: //
785: // Read in the data. We process the data, however, only if it arrived on
786: // the requested input stream.
787: //
788:
789: readByte = inb(kDataPort);
790: requestedStream = false;
791:
792: if ( (status & kMouseData) )
793: {
794: if (deviceType == kDT_Mouse) requestedStream = true;
795: }
796: else
797: {
798: if (deviceType == kDT_Keyboard) requestedStream = true;
799: }
800:
801: #if DEBUGGER_SUPPORT
802: skipForwardToY:
803: unlockController(); // (release interrupt lockout + access to queue)
804: #endif DEBUGGER_SUPPORT
805:
806: if (requestedStream)
807: {
808: if (readByte == expectedByte)
809: {
810: if (firstByteHeld == false)
811: {
812: //
813: // Normal case. Return first byte received.
814: //
815:
816: return readByte;
817: }
818: else
819: {
820: //
821: // Our assumption was correct. The second byte matched. Dispatch
822: // the first byte to the interrupt handler, and return the second.
823: //
824:
825: dispatchDriverInterrupt(deviceType, firstByte);
826: return readByte;
827: }
828: }
829: else // (readByte does not match expectedByte)
830: {
831: if (firstByteHeld == false)
832: {
833: //
834: // The first byte was received, and does not match the byte we are
835: // expecting. Put it aside for the moment.
836: //
837:
838: firstByteHeld = true;
839: firstByte = readByte;
840: }
841: else if (readByte != expectedByte)
842: {
843: //
844: // The second byte mismatched as well. I have yet to see this case
845: // occur [Dan], however I do think it's plausible. No error logged.
846: //
847:
848: dispatchDriverInterrupt(deviceType, readByte);
849: return firstByte;
850: }
851: }
852: }
853: else
854: {
855: //
856: // The data we just received is for the other input stream, not ours,
857: // so dispatch appropriate interrupt handler.
858: //
859:
860: dispatchDriverInterrupt((deviceType==kDT_Keyboard)?kDT_Mouse:kDT_Keyboard,
861: readByte);
862: }
863: } // while (forever)
864: }
865:
866: #endif
867:
868: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
869:
870: void ApplePS2Controller::writeDataPort(UInt8 byte)
871: {
872: //
873: // Block until room in the controller's input buffer is available, then
874: // write the given byte to the Data Port.
875: //
876: // This method should only be dispatched from our single-threaded work loop.
877: //
878:
879: while (inb(kCommandPort) & kInputBusy) IODelay(kDataDelay);
880: outb(kDataPort, byte);
881: }
882:
883: // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
884:
885: void ApplePS2Controller::writeCommandPort(UInt8 byte)
886: {
887: //
888: // Block until room in the controller's input buffer is available, then
889: // write the given byte to the Command Port.
890: //
891: // This method should only be dispatched from our single-threaded work loop.
892: //
893:
894: while (inb(kCommandPort) & kInputBusy) IODelay(kDataDelay);
895: outb(kCommandPort, byte);
896: }
897:
898: // =============================================================================
899: // Escape-Key Processing Stuff Localized Here (eg. Mini-Monitor)
900: //
901:
902: #if DEBUGGER_SUPPORT
903:
904: #define kModifierShiftLeft 0x01
905: #define kModifierShiftRight 0x02
906: #define kModifierCtrlLeft 0x04
907: #define kModifierCtrlRight 0x08
908: #define kModifierAltLeft 0x10
909: #define kModifierAltRight 0x20
910: #define kModifierWindowsLeft 0x40
911: #define kModifierWindowsRight 0x80
912:
913: #define kModifierShiftMask (kModifierShiftLeft | kModifierShiftRight )
914: #define kModifierCtrlMask (kModifierCtrlLeft | kModifierCtrlRight )
915: #define kModifierAltMask (kModifierAltLeft | kModifierAltRight )
916: #define kModifierWindowsMask (kModifierWindowsLeft | kModifierWindowsRight)
917:
918: bool ApplePS2Controller::doEscape(UInt8 scancode)
919: {
920: static struct
921: {
922: UInt8 scancode;
923: UInt8 extended;
924: UInt16 modifier;
925: } modifierTable[] = { { kSC_Alt, false, kModifierAltLeft },
926: { kSC_Alt, true, kModifierAltRight },
927: { kSC_Ctrl, false, kModifierCtrlLeft },
928: { kSC_Ctrl, true, kModifierCtrlRight },
929: { kSC_ShiftLeft, false, kModifierShiftLeft },
930: { kSC_ShiftRight, false, kModifierShiftRight },
931: { kSC_WindowsLeft, true, kModifierWindowsLeft },
932: { kSC_WindowsRight, true, kModifierWindowsRight },
933: { 0, 0, 0 } };
934:
935: UInt32 index;
936: bool releaseModifiers = false;
937: bool upBit = (scancode & kSC_UpBit) ? true : false;
938:
939: //
940: // See if this is an extened scancode sequence.
941: //
942:
943: if (scancode == kSC_Extend)
944: {
945: _extendedState = true;
946: return false;
947: }
948:
949: //
950: // Update the modifier state, if applicable.
951: //
952:
953: scancode &= ~kSC_UpBit;
954:
955: for (index = 0; modifierTable[index].scancode; index++)
956: {
957: if ( modifierTable[index].scancode == scancode &&
958: modifierTable[index].extended == _extendedState )
959: {
960: if (upBit) _modifierState &= ~modifierTable[index].modifier;
961: else _modifierState |= modifierTable[index].modifier;
962:
963: _extendedState = false;
964: return false;
965: }
966: }
967:
968: //
969: // Call the debugger function, if applicable.
970: //
971:
972: if (scancode == kSC_Delete) // (both extended and non-extended scancodes)
973: {
974: if ( _modifierState == kModifierAltLeft ||
975: _modifierState == kModifierAltRight )
976: {
977: // Disable the mouse by forcing the clock line low.
978:
979: while (inb(kCommandPort) & kInputBusy) IODelay(kDataDelay);
980: outb(kCommandPort, kCP_DisableMouseClock);
981:
982: // Call the debugger function.
983:
984: Debugger("Programmer Key");
985:
986: // Re-enable the mouse by making the clock line active.
987:
988: while (inb(kCommandPort) & kInputBusy) IODelay(kDataDelay);
989: outb(kCommandPort, kCP_EnableMouseClock);
990:
991: releaseModifiers = true;
992: }
993: }
994:
995: //
996: // Release all the modifier keys that were down before the debugger
997: // function was called (assumption is that they are no longer held
998: // down after the debugger function returns).
999: //
1000:
1001: if (releaseModifiers)
1002: {
1003: for (index = 0; modifierTable[index].scancode; index++)
1004: {
1005: if ( _modifierState & modifierTable[index].modifier )
1006: {
1007: if (modifierTable[index].extended) enqueueKeyboardData(kSC_Extend);
1008: enqueueKeyboardData(modifierTable[index].scancode | kSC_UpBit);
1009: }
1010: }
1011: _modifierState = 0x00;
1012: }
1013:
1014: //
1015: // Update all other state and return status.
1016: //
1017:
1018: _extendedState = false;
1019: return (releaseModifiers);
1020: }
1021:
1022: void ApplePS2Controller::enqueueKeyboardData(UInt8 key)
1023: {
1024: //
1025: // Enqueue the supplied keyboard data onto our internal queues. The
1026: // controller must already be locked.
1027: //
1028:
1029: KeyboardQueueElement * element;
1030:
1031: // Obtain an unused keyboard data element.
1032: if (!queue_empty(&_keyboardQueueUnused))
1033: {
1034: queue_remove_first(&_keyboardQueueUnused,
1035: element, KeyboardQueueElement *, chain);
1036:
1037: // Store the new keyboard data element on the queue.
1038: element->data = key;
1039: queue_enter(&_keyboardQueue, element, KeyboardQueueElement *, chain);
1040: }
1041: }
1042:
1043: bool ApplePS2Controller::dequeueKeyboardData(UInt8 * key)
1044: {
1045: //
1046: // Dequeue keyboard data from our internal queues, if the queue is not
1047: // empty. Should the queue be empty, false is returned. The controller
1048: // must already be locked.
1049: //
1050:
1051: KeyboardQueueElement * element;
1052:
1053: // Obtain an unused keyboard data element.
1054: if (!queue_empty(&_keyboardQueue))
1055: {
1056: queue_remove_first(&_keyboardQueue, element, KeyboardQueueElement *, chain);
1057: *key = element->data;
1058:
1059: // Place the unused keyboard data element onto the unused queue.
1060: queue_enter(&_keyboardQueueUnused, element, KeyboardQueueElement *, chain);
1061:
1062: return true;
1063: }
1064: return false;
1065: }
1066:
1067: void ApplePS2Controller::unlockController(void)
1068: {
1069: usimple_unlock(&_controllerLock);
1070: ml_set_interrupts_enabled(_controllerLockOldSpl);
1071: }
1072:
1073: void ApplePS2Controller::lockController(void)
1074: {
1075: int oldSpl = ml_set_interrupts_enabled(FALSE);
1076: usimple_lock(&_controllerLock);
1077: _controllerLockOldSpl = oldSpl;
1078: }
1079:
1080: #endif DEBUGGER_SUPPORT
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.