![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to KeyboardModule.c 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 / drvUSBCMD / kbd|
Return to KeyboardModule.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvUSBCMD / kbd |
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: /*
26: File: KeyboardModule.c
27:
28: Contains: HID Module for USB Keyboard
29:
30: Version: xxx put version here xxx
31:
32: Copyright: � 1997-1998 by Apple Computer, Inc., all rights reserved.
33:
34: File Ownership:
35:
36: DRI: Craig Keithley
37:
38: Other Contact: xxx put other contact here xxx
39:
40: Technology: xxx put technology here xxx
41:
42: Writers:
43:
44: (BT) Barry Twycross
45: (DF) David Ferguson
46: (CJK) Craig Keithley
47:
48: Change History (most recent first):
49:
50: <USB35> 10/28/98 CJK [2281764] use the supplied interface descriptor (for the ,
51: rather than searching the configuration descriptor and using the
52: one found.
53: <USB34> 8/25/98 BT Isoc name changes
54: <USB33> 6/22/98 CJK rename FindNextEndpointDescriptor to
55: FindNextEndpointDescriptorImmediate (no functional change, just
56: a name change)
57: <USB32> 6/17/98 CJK leave retries in place for non-pipe stall situations. That's the
58: most compatible with the earlier versions of the driver... It
59: feels pretty risky disabling that functionality this close to
60: intro.
61: <USB31> 6/17/98 CJK change to check pipe status, if stalled, then try to clear it.
62: <USB30> 6/17/98 CJK change error handling to not retry on some types of errors
63: <USB29> 6/16/98 CJK change FindHIDInterfaceByProtocol to FindHIDInterfaceByNumber
64: <USB28> 6/15/98 CJK Change "USL Reported an error" message so that it shows the
65: refcon (and not the deviceRef)
66: <USB27> 6/11/98 CJK Remove driverentry routine (not needed or used).
67: <USB26> 6/8/98 CJK eliminate PBVERSION1 define
68: <USB25> 6/5/98 CJK remove ExpertStatus calls; cluttering up expert log
69: <USB24> 5/20/98 BT Add V2 param block stuff
70: <USB23> 5/20/98 CJK change driver name from USBKeyboardModule to
71: USBHIDKeyboardModule
72: <USB22> 5/20/98 CJK add prototype for SetParamBlock
73: <USB21> 4/30/98 CJK add a "send raw report" mode. initialize rawdatamode and
74: initialized flags appropriately.
75: <USB20> 4/29/98 CJK Back out, just for the Columbus demo, the changes since the
76: 1.0a9 release.
77: <USB19> 4/29/98 CJK add break where needed
78: <USB18> 4/27/98 CJK don't fatalerror if setidle never succeeds. just give up after
79: 5 tries and move on to opening the pipe.
80: <USB17> 4/26/98 CJK Add clear param block routine. Dramatically reorganized to
81: match the "new" style used in the mouse module. The keyboard
82: module now searchs for an interface, and when it finds a
83: keyboard interface, it locates the interrupt pipe. No more hard
84: coded assumptions! Okay, so we're still assuming that keyboard
85: reports (in boot protocol mode) are 8 bytes.
86: <USB16> 4/9/98 CJK change driver services to be a externally supplied header file
87: (using < & >) rather than quotes.
88: <USB15> 4/9/98 DF Massaged to work with MasterInterfaces
89: <14> 4/8/98 CJK add initialization of saved interrupt routine ptr.
90: <13> 3/26/98 CJK remove init of delay field inside of my keyboard structure.
91: Clean up USBExpertFatalError messages (to show USB error code,
92: etc.)
93: <12> 3/25/98 CJK Remove unneeded poll & delay code
94: <11> 3/24/98 CJK turn on interrupt pipe usage. This required some changes in the
95: USL, as well as doing a "set_idle" in order to get the reports
96: when keys were released.
97: <10> 3/17/98 CJK Begin adding support for interrupt transactions. Change the
98: occasion "};" to just "}", as MetroWerks has a problem with some
99: "};".
100: <9> 3/12/98 CJK add initialization of the shim keyboard param block.
101: <8> 3/2/98 CJK remove include of KBDHIDEmulation.h
102: <7> 2/26/98 CJK change poll rate to 10ms. Add support for LEDs
103: <6> 2/17/98 CJK remove "" from each notify expert call.
104: <5> 2/16/98 CJK change poll time to 8ms
105: <4> 2/11/98 CJK change debugstrs to USBExpertFatalError calls.
106: <3> 2/11/98 CJK remove unneeded states
107: <2> 2/10/98 CJK Correct change history (to reflect the keyboard module changes)
108: <1> 2/10/98 CJK First time checkin. Cloned from Mouse HID Module.
109: */
110: /*
111: #include <Types.h>
112: #include <Devices.h>
113: #include <processes.h>
114: */
115: #include "../driverservices.h"
116: #include "../USB.h"
117:
118: #include "KeyboardModule.h"
119:
120: usbKeyboardPBStruct myKeyboardPB;
121: usbKeyboardPBStruct shimKeyboardPB;
122:
123:
124: static void KeyboardModuleDelay1CompletionProc(USBPB *pb);
125: void SetParamBlock(USBDeviceRef theDeviceRef, USBPB * paramblock);
126:
127: void SetParamBlock(USBDeviceRef theDeviceRef, USBPB * paramblock)
128: {
129: paramblock->usbReference = theDeviceRef;
130: paramblock->pbVersion = kUSBCurrentPBVersion;
131: paramblock->usb.cntl.WIndex = 0;
132: paramblock->usbBuffer = nil;
133: paramblock->usbStatus = noErr;
134: paramblock->usbReqCount = 0;
135: paramblock->usb.cntl.WValue = 0;
136: paramblock->usbFlags = 0;
137: }
138: static Boolean immediateError(OSStatus err)
139: {
140: return((err != kUSBPending) && (err != noErr) );
141: }
142: void KeyboardModuleInitiateTransaction(USBPB *pb)
143: {
144: register usbKeyboardPBStruct *pKeyboardPB;
145: OSStatus myErr;
146:
147: //A.W. 12/9/98 It seems this code is never called
148: pKeyboardPB = (usbKeyboardPBStruct *)(pb);
149: pKeyboardPB->transDepth++;
150: if (pKeyboardPB->transDepth < 0)
151: {
152: printf("transdepth<0\n");
153: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: transDepth < 0 (initiation)", pKeyboardPB->pb.usbRefcon );
154: }
155:
156: //A.W. 12/9/98 It seems this code is never called
157: if (pKeyboardPB->transDepth > 1)
158: {
159: printf("transdepth>1\n");
160: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: transDepth > 1 (initiation)", pKeyboardPB->pb.usbRefcon );
161: }
162:
163: switch(pKeyboardPB->pb.usbRefcon & ~kRetryTransaction)
164: {
165: case kSetKeyboardLEDs:
166: SetParamBlock(pKeyboardPB->deviceRef, &pKeyboardPB->pb);
167:
168: pKeyboardPB->pb.usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBInterface);
169:
170: pKeyboardPB->pb.usb.cntl.BRequest = kHIDRqSetReport;
171: pKeyboardPB->pb.usb.cntl.WValue = (kHIDRtOutputReport << 8);
172: pKeyboardPB->pb.usb.cntl.WIndex = pKeyboardPB->interfaceDescriptor.interfaceNumber;
173:
174: pKeyboardPB->pb.usbBuffer = (Ptr)&pKeyboardPB->hidReport[0];
175: pKeyboardPB->pb.usbReqCount = 1;
176:
177: pKeyboardPB->pb.usbCompletion = (USBCompletion)KeyboardCompletionProc;
178: pKeyboardPB->pb.usbRefcon |= kCompletionPending;
179:
180: myErr = USBDeviceRequest(&pKeyboardPB->pb);
181: if(immediateError(myErr))
182: {
183: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: kSetKeyboardLEDs - immediate error", myErr);
184: }
185: //A.W. 12/9/98 This code seems to be going through OK
186:
187: break;
188:
189: case kGetFullConfiguration:
190: SetParamBlock(pKeyboardPB->deviceRef, &pKeyboardPB->pb);
191:
192: pKeyboardPB->pb.usbRefcon |= kCompletionPending;
193: pKeyboardPB->pb.usbCompletion = (USBCompletion)KeyboardCompletionProc;
194: myErr = USBGetFullConfigurationDescriptor(pb);
195: if(immediateError(myErr))
196: {
197: USBExpertFatalError(pKeyboardPB->pb.usbReference, kUSBInternalErr, "USBHIDKeyboardModule: kGetFullConfiguration (ImmediateError)", myErr);
198: }
199: break;
200:
201: case kFindInterfaceAndSetProtocol:
202: myErr = kbd_FindHIDInterfaceByNumber(pKeyboardPB->pFullConfigDescriptor, pKeyboardPB->interfaceDescriptor.interfaceNumber, &pKeyboardPB->pInterfaceDescriptor ); // find the HID interface
203: if ((pKeyboardPB->pInterfaceDescriptor == NULL) ||
204: (myErr != noErr))
205: {
206: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: Interface not found", myErr);
207: pKeyboardPB->pb.usbRefcon = kReturnFromDriver;
208: }
209:
210: SetParamBlock(pKeyboardPB->deviceRef, &pKeyboardPB->pb);
211:
212: pKeyboardPB->pb.usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBInterface);
213: pKeyboardPB->pb.usb.cntl.BRequest = kHIDRqSetProtocol;
214: pKeyboardPB->pb.usb.cntl.WValue = kHIDBootProtocolValue;
215: pKeyboardPB->pb.usb.cntl.WIndex = pKeyboardPB->interfaceDescriptor.interfaceNumber;
216: pKeyboardPB->pb.usbCompletion = (USBCompletion)KeyboardCompletionProc;
217:
218: pKeyboardPB->pb.usbRefcon |= kCompletionPending;
219: myErr = USBDeviceRequest(&pKeyboardPB->pb);
220: if (immediateError(myErr))
221: {
222: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: kSetProtocol (ImmediateError)", myErr);
223: }
224: break;
225:
226: case kSetIdleRequest:
227: SetParamBlock(pKeyboardPB->deviceRef, &pKeyboardPB->pb);
228:
229: pKeyboardPB->pb.usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBInterface);
230:
231: pKeyboardPB->pb.usb.cntl.BRequest = kHIDRqSetIdle;
232: pKeyboardPB->pb.usb.cntl.WValue = ((24/4)<<8); // force a read completion if idle for more than 24ms
233: pKeyboardPB->pb.usb.cntl.WIndex = pKeyboardPB->interfaceDescriptor.interfaceNumber;
234: pKeyboardPB->pb.usbCompletion = (USBCompletion)KeyboardCompletionProc;
235:
236: pKeyboardPB->pb.usbRefcon |= kCompletionPending;
237:
238: myErr = USBDeviceRequest(&pKeyboardPB->pb);
239: if(immediateError(myErr))
240: {
241: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: kSetIdleRequest - immediate error", myErr);
242: }
243: break;
244:
245: case kFindAndOpenInterruptPipe:
246: pKeyboardPB->pb.usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBInterface);
247: pKeyboardPB->pb.usbFlags = kUSBIn;
248: pKeyboardPB->pb.usbClassType = kUSBInterrupt;
249: pKeyboardPB->pb.usbOther = 0;
250: pKeyboardPB->pb.usbBuffer = pKeyboardPB->pInterfaceDescriptor;
251: pKeyboardPB->pb.usbReqCount = (UInt8*)pKeyboardPB->pInterfaceDescriptor - (UInt8*)pKeyboardPB->pFullConfigDescriptor;
252: myErr = USBFindNextEndpointDescriptorImmediate( &pKeyboardPB->pb );
253: if((immediateError(myErr)) || (pKeyboardPB->pb.usbBuffer == nil))
254: {
255: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: Endpoint not found", myErr);
256: pKeyboardPB->pb.usbRefcon = kReturnFromDriver;
257: }
258: else
259: {
260: pKeyboardPB->pEndpointDescriptor = (USBEndPointDescriptorPtr) pKeyboardPB->pb.usbBuffer;
261:
262: SetParamBlock(pKeyboardPB->deviceRef, &pKeyboardPB->pb);
263:
264: pKeyboardPB->pb.usbFlags = kUSBIn;
265: pKeyboardPB->pb.usb.cntl.WValue = 0x08;
266: pKeyboardPB->pb.usbClassType = kUSBInterrupt;
267: pKeyboardPB->pb.usbOther = (pKeyboardPB->pEndpointDescriptor->endpointAddress & 0x0f);
268: pKeyboardPB->pb.usbRefcon |= kCompletionPending;
269: pKeyboardPB->pb.usbCompletion = (USBCompletion)KeyboardCompletionProc;
270:
271: myErr = USBOpenPipe( &pKeyboardPB->pb );
272: if(immediateError(myErr))
273: {
274: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: USBOpenPipe Failed (ImmediateError)", myErr);
275: }
276: }
277: break;
278:
279: case kReadInterruptPipe:
280: SetParamBlock(pKeyboardPB->pipeRef, &pKeyboardPB->pb);
281:
282: pKeyboardPB->pb.usbBuffer = (Ptr)pKeyboardPB->hidReport;
283: pKeyboardPB->pb.usbReqCount = 0x08;
284: pKeyboardPB->pb.usb.cntl.WIndex = pKeyboardPB->interfaceDescriptor.interfaceNumber;
285: pKeyboardPB->pb.usbCompletion = (USBCompletion)KeyboardCompletionProc;
286:
287: pKeyboardPB->pb.usbRefcon |= kCompletionPending;
288: kprintf("***Issuing keyboard USBIntRead\n");
289: myErr = USBIntRead(&pKeyboardPB->pb);
290: if(immediateError(myErr))
291: {
292: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: Read Interrupt Pipe (ImmediateError)", myErr);
293: }
294: break;
295:
296: default:
297: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule - Transaction completed with bad refcon value", pKeyboardPB->pb.usbRefcon );
298: pKeyboardPB->pb.usbRefcon = kUndefined + kReturnFromDriver;
299: break;
300: }
301:
302: // At this point the control is returned to the system. If a USB transaction
303: // has been initiated, then it will call the Complete procs
304: // (below) to handle the results of the transaction.
305: }
306:
307: void KeyboardCompletionProc(USBPB *pb)
308: {
309: unsigned char * errstring;
310: register usbKeyboardPBStruct *pKeyboardPB;
311: USBPipeState pipeState;
312:
313: pKeyboardPB = (usbKeyboardPBStruct *)(pb);
314: pKeyboardPB->transDepth--;
315: if (pKeyboardPB->transDepth < 0)
316: {
317: printf("transDepth<0\n");
318: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: transDepth < 0 (completion)", pKeyboardPB->pb.usbRefcon );
319: }
320:
321: if (pKeyboardPB->transDepth > 1)
322: {
323: printf("transDepth>1\n");
324: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule: transDepth > 1 (completion)", pKeyboardPB->pb.usbRefcon );
325: }
326:
327: if(pKeyboardPB->pb.usbStatus != noErr) // was there an error?
328: {
329: switch(pKeyboardPB->pb.usbRefcon & 0x0fff) // yes, so show where the error occurred
330: {
331: case kSetKeyboardLEDs: errstring = "USBHIDKeyboardModule: Error during SetKeyboardLEDs"; break;
332: case kGetFullConfiguration: errstring = "USBHIDKeyboardModule: Error during GetFullConfiguration"; break;
333: case kFindInterfaceAndSetProtocol: errstring = "USBHIDKeyboardModule: Error during FindInterfaceAndSetProtocol"; break;
334: case kFindAndOpenInterruptPipe: errstring = "USBHIDKeyboardModule: Error during FindAndOpenInterruptPipe"; break;
335: case kReadInterruptPipe: errstring = "USBHIDKeyboardModule: Error during ReadInterruptPipe"; break;
336: default: errstring = "USBHIDKeyboardModule: Error occurred, but state is unknown"; break;
337: };
338: USBExpertFatalError(pKeyboardPB->deviceRef, pKeyboardPB->pb.usbStatus, errstring, (pKeyboardPB->pb.usbRefcon & 0x0fff));
339:
340: pKeyboardPB->pb.usbRefcon &= ~(kCompletionPending + kReturnFromDriver); // set up to retry the transaction
341: pKeyboardPB->pb.usbRefcon |= kRetryTransaction;
342: pKeyboardPB->retryCount--;
343:
344: if ((!pKeyboardPB->retryCount) || (pKeyboardPB->pb.usbStatus == kUSBAbortedError)) // have we exhausted the retries?
345: { // or received an abort?
346: USBExpertStatus(pKeyboardPB->deviceRef, "USBHIDKeyboardModule: Pipe abort or unable to recover from error", pKeyboardPB->deviceRef);
347: pKeyboardPB->pb.usbRefcon = kReturnFromDriver; // if so, just exit.
348: }
349: else // if it didn't abort and there's retries left, then...
350: {
351: if (pKeyboardPB->pipeRef) // check if the pipe is open.
352: {
353: USBGetPipeStatusByReference(pKeyboardPB->pipeRef, &pipeState); // yes, so what it's state?
354: if (pipeState != kUSBActive) // if it's not active, try to clear it. It might be stalled...
355: {
356: USBExpertStatus(pKeyboardPB->deviceRef, "USBHIDKeyboardModule: Pipe is open and stalled, clearing stall...", pKeyboardPB->deviceRef);
357: USBClearPipeStallByReference(pKeyboardPB->pipeRef);
358: }
359: }
360: }
361: }
362: else
363: {
364: pKeyboardPB->pb.usbRefcon &= ~kRetryTransaction;
365: pKeyboardPB->retryCount = kKeyboardRetryCount;
366: }
367:
368: if (pKeyboardPB->pb.usbRefcon & kCompletionPending)
369: {
370: pKeyboardPB->pb.usbRefcon &= ~(kCompletionPending + kReturnFromDriver);
371: switch(pKeyboardPB->pb.usbRefcon)
372: {
373: case kSetKeyboardLEDs:
374: pKeyboardPB->pb.usbRefcon = kReturnFromDriver;
375: break;
376:
377: case kGetFullConfiguration:
378: pKeyboardPB->pFullConfigDescriptor = pKeyboardPB->pb.usbBuffer;
379: if (pKeyboardPB->pFullConfigDescriptor == nil)
380: {
381: USBExpertFatalError(pKeyboardPB->pb.usbReference, kUSBInternalErr, "USBHIDKeyboardModule: USBGetFullConfiguration - pointer is nil", pKeyboardPB->pb.usbRefcon);
382: pKeyboardPB->pb.usbRefcon = kReturnFromDriver;
383: }
384: else
385: {
386: pKeyboardPB->pb.usbRefcon = kFindInterfaceAndSetProtocol;
387: }
388: break;
389:
390: case kFindInterfaceAndSetProtocol:
391: pKeyboardPB->pb.usbRefcon = kSetIdleRequest;
392: break;
393:
394: case kSetIdleRequest:
395: pKeyboardPB->pb.usbRefcon = kFindAndOpenInterruptPipe;
396: break;
397:
398: case kFindAndOpenInterruptPipe:
399: pKeyboardPB->pipeRef = pKeyboardPB->pb.usbReference;
400: pKeyboardPB->pb.usbRefcon = kReadInterruptPipe;
401: break;
402:
403: case kReadInterruptPipe:
404: kbd_NotifyRegisteredHIDUser(pKeyboardPB->hidDeviceType, pKeyboardPB->hidReport);
405: pKeyboardPB->pb.usbRefcon = kReadInterruptPipe;
406: break;
407:
408: default:
409: USBExpertFatalError(pKeyboardPB->deviceRef, kUSBInternalErr, "USBHIDKeyboardModule - Transaction completed with bad refcon value", pKeyboardPB->pb.usbRefcon );
410: pKeyboardPB->pb.usbRefcon = kUndefined + kReturnFromDriver;
411: break;
412: }
413: }
414: if (!(pKeyboardPB->pb.usbRefcon & kReturnFromDriver))
415: KeyboardModuleInitiateTransaction(pb);
416: }
417:
418:
419: void kbd_InterfaceEntry(UInt32 interfacenum, USBInterfaceDescriptorPtr pInterfaceDescriptor, USBDeviceDescriptorPtr pDeviceDescriptor, USBDeviceRef device)
420: {
421: #pragma unused (interfacenum)
422:
423: static Boolean beenThereDoneThat = false;
424:
425: if(beenThereDoneThat)
426: {
427: USBExpertFatalError(device, kUSBInternalErr, "USBHIDKeyboardModule is not reentrant", 12);
428: return;
429: }
430: //Hot Plug n Play
431: //naga beenThereDoneThat = true;
432:
433: // DebugStr("In Keyboard Module Interface entry routine");
434: shimKeyboardPB.deviceDescriptor = *pDeviceDescriptor;
435: shimKeyboardPB.interfaceDescriptor = *pInterfaceDescriptor;
436: shimKeyboardPB.transDepth = 0;
437: shimKeyboardPB.retryCount = kKeyboardRetryCount;
438: shimKeyboardPB.pSHIMInterruptRoutine = nil;
439: shimKeyboardPB.pSavedInterruptRoutine = nil;
440: shimKeyboardPB.deviceRef = device;
441: shimKeyboardPB.interfaceRef = 0;
442: shimKeyboardPB.pipeRef = 0;
443:
444: shimKeyboardPB.deviceRef = device;
445: shimKeyboardPB.interfaceRef = nil;
446: shimKeyboardPB.pipeRef = nil;
447:
448: SetParamBlock(device, &shimKeyboardPB.pb);
449: shimKeyboardPB.pb.pbLength = sizeof(usbKeyboardPBStruct);
450: shimKeyboardPB.pb.usbRefcon = 0;
451:
452: myKeyboardPB.deviceDescriptor = *pDeviceDescriptor;
453: myKeyboardPB.interfaceDescriptor = *pInterfaceDescriptor;
454: myKeyboardPB.transDepth = 0;
455: myKeyboardPB.retryCount = kKeyboardRetryCount;
456: myKeyboardPB.pSHIMInterruptRoutine = nil;
457: myKeyboardPB.pSavedInterruptRoutine = nil;
458: myKeyboardPB.deviceRef = device;
459: myKeyboardPB.interfaceRef = 0;
460: myKeyboardPB.pipeRef = 0;
461:
462: myKeyboardPB.deviceRef = device;
463: myKeyboardPB.interfaceRef = nil;
464: myKeyboardPB.pipeRef = nil;
465:
466: myKeyboardPB.sendRawReportFlag = false;
467: myKeyboardPB.hidEmulationInit = false;
468:
469: SetParamBlock(device, &myKeyboardPB.pb);
470: myKeyboardPB.pb.pbLength = sizeof(usbKeyboardPBStruct);
471: myKeyboardPB.pb.usbRefcon = kGetFullConfiguration; /* Start with setting the interface protocol */
472:
473:
474: kbd_USBHIDControlDevice(kHIDEnableDemoMode,0);
475: KeyboardModuleInitiateTransaction(&myKeyboardPB.pb);
476: }
477:
478:
479:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.