![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AppleOHCI_RootHub.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / usb / drvAppleOHCI|
Return to AppleOHCI_RootHub.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / usb / drvAppleOHCI |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1998 Apple Computer, Inc. All rights reserved.
24: *
25: * HISTORY
26: *
27: */
28:
29:
30: #include "AppleOHCI.h"
31: #include <libkern/OSByteOrder.h>
32:
33: #define nil (0)
34: #define DEBUGGING_LEVEL 0 // 1 = low; 2 = high; 3 = extreme
35:
36: #define super IOUSBController
37: #define self this
38:
39: /*
40: * Root hub methods
41: */
42: // FIXME Should this routine go in the device?
43: IOReturn AppleOHCI::getRootHubDeviceDescriptor(IOUSBDeviceDescriptor *desc)
44: {
45: IOUSBDeviceDescriptor newDesc =
46: {
47: sizeof(IOUSBDeviceDescriptor), // UInt8 length;
48: kUSBDeviceDesc, // UInt8 descType;
49: USB_CONSTANT16(kUSBRel10), // UInt16 usbRel;
50: kUSBHubClass, // UInt8 class;
51: kUSBRootHubSubClass, // UInt8 subClass;
52: 0, // UInt8 protocol;
53: 8, // UInt8 maxPacketSize;
54: USB_CONSTANT16(_vendorID), // UInt16 vendor;
55: USB_CONSTANT16(_deviceID), // UInt16 product;
56: USB_CONSTANT16(_revisionID), // UInt16 devRel;
57: 0, // UInt8 manuIdx;
58: 0, // UInt8 prodIdx;
59: 0, // UInt8 serialIdx;
60: 1 // UInt8 numConf;
61: };
62:
63: if (!desc)
64: return(kIOReturnNoMemory);
65:
66: bcopy(&newDesc, desc, newDesc.length);
67:
68: return(kIOReturnSuccess);
69: }
70:
71: IOReturn AppleOHCI::getRootHubDescriptor(IOUSBHubDescriptor *desc)
72: {
73: IOUSBHubDescriptor hubDesc;
74: UInt8 pps, nps, cd, ppoc, noc;
75: UInt32 descriptorA, descriptorB;
76:
77:
78: descriptorA = OSSwapInt32(pOHCIUIMData->pOHCIRegisters->hcRhDescriptorA);
79: descriptorB = OSSwapInt32(pOHCIUIMData->pOHCIRegisters->hcRhDescriptorB);
80: hubDesc.length = sizeof(IOUSBHubDescriptor);
81: hubDesc.hubType = kUSBHubDescriptorType;
82: hubDesc.numPorts = ((descriptorA & kOHCIHcRhDescriptorA_NDP)
83: >> kOHCIHcRhDescriptorA_NDPPhase);
84: // Characteristics
85: pps = descriptorA & kOHCIHcRhDescriptorA_PSM;
86: nps = descriptorA & kOHCIHcRhDescriptorA_NPS;
87: cd = descriptorA & kOHCIHcRhDescriptorA_DT;
88: ppoc = descriptorA & kOHCIHcRhDescriptorA_OCPM;
89: noc = descriptorA & kOHCIHcRhDescriptorA_NOCP;
90: hubDesc.characteristics = 0;
91: hubDesc.characteristics |= (pps ? kPerPortSwitchingBit : 0);
92: hubDesc.characteristics |= (nps ? kNoPowerSwitchingBit : 0);
93: hubDesc.characteristics |= (cd ? kCompoundDeviceBit : 0);
94: hubDesc.characteristics |= (ppoc ? kPerPortOverCurrentBit : 0);
95: hubDesc.characteristics |= (noc ? kNoOverCurrentBit : 0);
96: hubDesc.characteristics = HostToUSBWord(hubDesc.characteristics);
97:
98: hubDesc.powerOnToGood = ((descriptorA & kOHCIHcRhDescriptorA_POTPGT)
99: >> kOHCIHcRhDescriptorA_POTPGTPhase);
100: // the root hub has no power requirements
101: hubDesc.hubCurrent = 0;
102:
103: // bitmap of removable ports
104: *((UInt16*)&hubDesc.removablePortFlags[0]) =
105: ((descriptorB & kOHCIHcRhDescriptorB_DR)
106: >> kOHCIHcRhDescriptorB_DRPhase);
107: *((UInt16 *)&hubDesc.removablePortFlags[2]) = 0; // OHCI supports 15 ports
108: *((UInt32 *)&hubDesc.removablePortFlags[4]) = 0; // so zero out the rest
109:
110: // bitmap of power mode for each port
111: *((UInt16 *)&hubDesc.pwrCtlPortFlags[0]) =
112: ((descriptorB & kOHCIHcRhDescriptorB_PPCM)
113: >> kOHCIHcRhDescriptorB_PPCMPhase);
114: *((UInt16 *)&hubDesc.pwrCtlPortFlags[2]) = 0; // OHCI supports 15 ports
115: *((UInt32 *)&hubDesc.pwrCtlPortFlags[4]) = 0; // so zero out the rest
116:
117: if (!desc)
118: return(kIOReturnNoMemory);
119:
120: bcopy(&hubDesc, desc, hubDesc.length);
121:
122: /*
123: if (!buffer->appendBytes(&hubDesc, hubDesc.length))
124: return(kIOReturnNoMemory);
125: */
126:
127: return(kIOReturnSuccess);
128: }
129:
130: IOReturn AppleOHCI::getRootHubConfDescriptor(OSData *desc)
131: {
132: IOUSBConfigurationDescriptor confDesc =
133: {
134: sizeof(IOUSBConfigurationDescriptor),//UInt8 length;
135: kUSBConfDesc, //UInt8 descriptorType;
136: USB_CONSTANT16(sizeof(IOUSBConfigurationDescriptor) +
137: sizeof(IOUSBInterfaceDescriptor) +
138: sizeof(IOUSBEndpointDescriptor)), //UInt16 totalLength;
139: 1, //UInt8 numInterfaces;
140: 1, //UInt8 configValue;
141: 0, //UInt8 configStrIndex;
142: 0x60, //UInt8 attributes; self powered,
143: // supports remote wkup
144: 0, //UInt8 maxPower;
145: };
146: IOUSBInterfaceDescriptor intfDesc =
147: {
148: sizeof(IOUSBInterfaceDescriptor),//UInt8 length;
149: kUSBInterfaceDesc, //UInt8 descriptorType;
150: 0, //UInt8 interfaceNumber;
151: 0, //UInt8 alternateSetting;
152: 1, //UInt8 numEndpoints;
153: kUSBHubClass, //UInt8 interfaceClass;
154: kUSBHubSubClass, //UInt8 interfaceSubClass;
155: 1, //UInt8 interfaceProtocol;
156: 0 //UInt8 interfaceStrIndex;
157: };
158: IOUSBEndpointDescriptor endptDesc =
159: {
160: sizeof(IOUSBEndpointDescriptor),//UInt8 length;
161: kUSBEndpointDesc, //UInt8 descriptorType;
162: 0x81, //UInt8 endpointAddress; In, 1
163: kUSBInterrupt, //UInt8 attributes;
164: 8, 0, //UInt16 maxPacketSize;
165: 255, //UInt8 interval;
166: };
167:
168: if (!desc)
169: return(kIOReturnNoMemory);
170:
171: if (!desc->appendBytes(&confDesc, confDesc.length))
172: return(kIOReturnNoMemory);
173:
174: if (!desc->appendBytes(&intfDesc, intfDesc.length))
175: return(kIOReturnNoMemory);
176:
177: if (!desc->appendBytes(&endptDesc, endptDesc.length))
178: return(kIOReturnNoMemory);
179:
180: return(kIOReturnSuccess);
181: }
182:
183: IOReturn AppleOHCI::setRootHubDescriptor(OSData * /*buffer*/)
184: {
185: IOLog("%s: unimplemented set root hub descriptor\n", getName());
186: return(kIOReturnSuccess);
187: }
188:
189: IOReturn AppleOHCI::getRootHubStatus(IOUSBHubStatus *status)
190: {
191: *(UInt32*)status = pOHCIUIMData->pOHCIRegisters->hcRhStatus;
192: return(kIOReturnSuccess);
193: }
194:
195: IOReturn AppleOHCI::setRootHubFeature(UInt16 wValue)
196: {
197: switch(wValue)
198: {
199: case kUSBHubLocalPowerChangeFeature :
200: IOLog("%s: unimplemented Set Power Change Feature\n", getName());
201: // OHCIRootHubLPSChange(true); // not implemented yet
202: break;
203:
204: case kUSBHubOverCurrentChangeFeature :
205: IOLog("%s: unimplemented Set Overcurrent Change Feature\n",
206: getName());
207: // OHCIRootHubOCChange(true); // not implemented yet
208: break;
209:
210: default:
211: IOLog("%s: Unknown hub set (%d) in root hub\n", getName(), wValue);
212: break;
213: }
214:
215: return(kIOReturnSuccess);
216: }
217:
218: IOReturn AppleOHCI::clearRootHubFeature(UInt16 wValue)
219: {
220: switch(wValue)
221: {
222: case kUSBHubLocalPowerChangeFeature :
223: IOLog("%s: unimplemented Clear Power Change Feature\n", getName());
224: // OHCIRootHubLPSChange(false); // not implemented yet
225: break;
226:
227: case kUSBHubOverCurrentChangeFeature :
228: IOLog("%s: unimplemented Clear Overcurrent Change Feature\n",
229: getName());
230: // OHCIRootHubOCChange(false); // not implemented yet
231: break;
232:
233: default:
234: IOLog("%s: Unknown hub set (%d) in root hub\n", getName(), wValue);
235: break;
236: }
237:
238: return(kIOReturnSuccess);
239: }
240:
241: IOReturn AppleOHCI::getRootHubPortStatus(IOUSBHubPortStatus *status, UInt16 port)
242: {
243: if (port < 1 || port > 15)
244: return(kIOReturnBadArgument); // FIXME change error code
245: *(UInt32*)status = pOHCIUIMData->pOHCIRegisters->hcRhPortStatus[port-1];
246: return(kIOReturnSuccess);
247: }
248:
249: IOReturn AppleOHCI::setRootHubPortFeature(UInt16 wValue, UInt16 wIndex)
250: {
251: UInt16 port = wIndex-1;
252:
253: switch(wValue)
254: {
255: case kUSBHubPortSuspendFeature :
256: OHCIRootHubPortSuspend(port, true);
257: break;
258:
259: case kUSBHubPortResetFeature :
260: OHCIRootHubResetPort(port);
261: break;
262:
263: case kUSBHubPortEnableFeature :
264: OHCIRootHubPortEnable(port, true);
265: break;
266:
267: case kUSBHubPortPowerFeature :
268: OHCIRootHubPortPower(port, true);
269: OHCIRootHubPower(true);
270: break;
271:
272: default:
273: IOLog("%s: Unknown port set (%d) in root hub\n", getName(), wValue);
274: break;
275: }
276: return(kIOReturnSuccess);
277: }
278:
279: IOReturn AppleOHCI::clearRootHubPortFeature(UInt16 wValue, UInt16 wIndex)
280: {
281: UInt16 port = wIndex-1;
282:
283: switch(wValue)
284: {
285: case kUSBHubPortEnableFeature :
286: OHCIRootHubPortEnable(port, false);
287: break;
288:
289: case kUSBHubPortSuspendFeature :
290: OHCIRootHubPortSuspend(port, false);
291: break;
292:
293: case kUSBHubPortPowerFeature :
294: OHCIRootHubPortPower(port, false);
295: // Now need to check if all ports are switched off and
296: // gang off if in gang mode
297: break;
298:
299: // ****** Change features *******
300: case kUSBHubPortConnectionChangeFeature :
301: OHCIRootHubResetChangeConnection(port);
302: break;
303:
304: case kUSBHubPortEnableChangeFeature :
305: OHCIRootHubResetEnableChange(port);
306: break;
307:
308: case kUSBHubPortSuspendChangeFeature :
309: OHCIRootHubResetSuspendChange(port);
310: break;
311:
312: case kUSBHubPortOverCurrentChangeFeature :
313: OHCIRootHubResetOverCurrentChange(port);
314: break;
315:
316: case kUSBHubPortResetChangeFeature :
317: OHCIRootHubResetResetChange(port);
318: break;
319:
320: default:
321: IOLog("%s: Unknown port clear (%d) in root hub\n", getName(), wValue);
322: break;
323: }
324: return(kIOReturnSuccess);
325: }
326:
327: IOReturn AppleOHCI::getRootHubPortState(UInt8 */*state*/, UInt16 /*port*/)
328: {
329: IOLog("%s: unimplemented get hub bus state", getName());
330: return(kIOReturnSuccess);
331: }
332:
333:
334: IOReturn AppleOHCI::setHubAddress(UInt16 wValue)
335: {
336: pOHCIUIMData->rootHubFuncAddress = wValue;
337: return (kIOReturnSuccess);
338: }
339:
340: void AppleOHCI::OHCIRootHubPower(bool on)
341: {
342: UInt32 value = 0;
343: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
344:
345: pOHCIRegisters->hcRhDescriptorA = OSSwapInt32 (OSSwapInt32(pOHCIUIMData->pOHCIRegisters->hcRhDescriptorA) | kOHCIHcRhDescriptorA_NPS); //FIXME ERIC
346:
347: if(on)
348: {
349: value |= kOHCIHcRhStatus_LPSC;/* power on to all ganged ports */
350: value |= kOHCIHcRhStatus_CRWE;/* clear remove wakeup enable */
351: value |= kOHCIHcRhStatus_OCIC;/* clear over current change indicator */
352: }
353: else
354: value |= kOHCIHcRhStatus_LPS; /* turn global power off */
355:
356: pOHCIRegisters->hcRhStatus = OSSwapInt32 (value);
357:
358: return;
359: }
360:
361: void AppleOHCI::OHCIRootHubResetChangeConnection(UInt16 port)
362: {
363: UInt32 value = 0;
364: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
365:
366:
367: value |= kOHCIHcRhPortStatus_CSC; /* clear status change */
368:
369: pOHCIRegisters->hcRhPortStatus[port] = OSSwapInt32 (value);
370: IOSync();
371:
372: return;
373: }
374:
375:
376: void AppleOHCI::OHCIRootHubResetResetChange(UInt16 port)
377: {
378: UInt32 value = 0;
379: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
380:
381:
382: value |= kOHCIHcRhPortStatus_PRSC; /* clear reset status change */
383:
384: pOHCIRegisters->hcRhPortStatus[port] = OSSwapInt32 (value);
385: IOSync();
386:
387: return;
388: }
389:
390: void AppleOHCI::OHCIRootHubResetSuspendChange(UInt16 port)
391: {
392: UInt32 value = 0;
393: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
394:
395:
396: value |= kOHCIHcRhPortStatus_PSSC; /* clear suspend status change */
397:
398: pOHCIRegisters->hcRhPortStatus[port] = OSSwapInt32 (value);
399: IOSync();
400:
401: return;
402: }
403:
404: void AppleOHCI::OHCIRootHubResetEnableChange(UInt16 port)
405: {
406: UInt32 value = 0;
407: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
408:
409:
410: value |= kOHCIHcRhPortStatus_PESC; /* clear enable status change */
411:
412: pOHCIRegisters->hcRhPortStatus[port] = OSSwapInt32 (value);
413: IOSync();
414:
415: return;
416: }
417:
418:
419:
420: void AppleOHCI::OHCIRootHubResetOverCurrentChange(UInt16 port)
421: {
422: UInt32 value = 0;
423: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
424:
425:
426: value |= kOHCIHcRhPortStatus_OCIC; /* clear over current status change */
427:
428: pOHCIRegisters->hcRhPortStatus[port] = OSSwapInt32 (value);
429: IOSync();
430:
431: return;
432: }
433:
434:
435: void AppleOHCI::OHCIRootHubResetPort (UInt16 port)
436: {
437: UInt32 value = 0;
438: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
439:
440:
441: value |= kOHCIHcRhPortStatus_PRS; /* sets Bit 8 in port root hub register */
442: pOHCIRegisters->hcRhPortStatus[port] = OSSwapInt32 (value);
443: IOSync();
444: return;
445:
446: }
447:
448: void AppleOHCI::OHCIRootHubPortEnable(UInt16 port,
449: bool on)
450: {
451: UInt32 value = 0;
452: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
453:
454:
455: if(on)
456: value |= kOHCIHcRhPortStatus_PES; /* enable port */
457: else
458: value |= kOHCIHcRhPortStatus_CCS; /* disable port */
459:
460: pOHCIRegisters->hcRhPortStatus[port] = OSSwapInt32 (value);
461: IOSync();
462:
463: return;
464: }
465:
466: void AppleOHCI::OHCIRootHubPortSuspend(UInt16 port,
467: bool on)
468: {
469: UInt32 value = 0;
470: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
471:
472:
473: if(on)
474: value |= kOHCIHcRhPortStatus_PSS; /* suspend port */
475: else
476: value |= kOHCIHcRhPortStatus_POCI; /* resume port */
477:
478: pOHCIRegisters->hcRhPortStatus[port] = OSSwapInt32 (value);
479: IOSync();
480:
481: return;
482: }
483:
484: void AppleOHCI::OHCIRootHubPortPower(UInt16 port,
485: bool on)
486: {
487: UInt32 value = 0;
488: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
489:
490:
491: if(on)
492: value |= kOHCIHcRhPortStatus_PPS; /* enable port power */
493: else
494: value |= kOHCIHcRhPortStatus_LSDA; /* disable port power */
495:
496: pOHCIRegisters->hcRhPortStatus[port] = OSSwapInt32 (value);
497: IOSync();
498:
499: return;
500: }
501:
502: /*
503: * UIMRootHubStatusChange
504: *
505: * This method gets called when there is a change in the root hub status
506: * or a change in the status of one of the ports. It is assumed that the
507: * interrupt will be cleared for us, but we don't clear the change
508: * condition, we will get another interrupt. So turn off the interrupt.
509: * Entering this function means that someone turned on the RHSC interrupt
510: * and that there is a client waiting in the queue. The client expects a
511: * status change bitmap.
512: * To fix: currently there can only be one client in the queue. The RHSC
513: * interrupt should only be turned off if there is no one else in the queue,
514: * or, all clients should be responded to with the one interrupt.
515: */
516: void AppleOHCI::UIMRootHubStatusChange(void)
517: {
518: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
519: UInt32 hubStatus, portStatus, statusBit;
520: UInt16 statusChangedBitmap; /* only have 15 ports in OHCI */
521: UInt8 numPorts;
522: unsigned int index, port, move;
523: struct InterruptTransaction last;
524: UInt32 descriptorA;
525:
526:
527: /* turn off RHSC interrupt */
528: pOHCIRegisters->hcInterruptDisable = OSSwapInt32(kOHCIHcInterrupt_RHSC);
529: IOSync();
530:
531: /*
532: * Encode the status change bitmap. The format of the bitmap:
533: * bit0 = hub status changed
534: * bit1 = port 1 status changed
535: * bit2 = port 2 status changed
536: * ...
537: * See USB 1.0 spec section 11.8.3 for more info.
538: */
539:
540: statusChangedBitmap = 0;
541: statusBit = 1;
542:
543: getRootHubStatus((IOUSBHubStatus *)&hubStatus);
544: if ((hubStatus & kOHCIHcRhStatus_Change ) != 0)
545: statusChangedBitmap |= statusBit; /* Hub status change bit */
546:
547: descriptorA = OSSwapInt32(pOHCIRegisters->hcRhDescriptorA);
548: numPorts = ((descriptorA & kOHCIHcRhDescriptorA_NDP)
549: >> kOHCIHcRhDescriptorA_NDPPhase);
550:
551: for (port = 1; port <= numPorts; port++)
552: {
553: statusBit <<= 1; /* Next bit */
554:
555: getRootHubPortStatus((IOUSBHubPortStatus *)&portStatus, port);
556: if ((portStatus & kOHCIHcRhPortStatus_Change) != 0)
557: statusChangedBitmap |= statusBit; /* Hub status change bit */
558: }
559:
560: /*
561: * If a transaction is queued, handle it
562: */
563: if(_outstandingTrans[0].completion.action != nil)
564: {
565: last = _outstandingTrans[0];
566: IOTakeLock(_intLock);
567: for (index = 1; index < kMaxOutstandingTrans ; index++)
568: {
569: _outstandingTrans[index-1] = _outstandingTrans[index];
570: if (_outstandingTrans[index].completion.action == nil)
571: break;
572: }
573:
574: move = last.bufLen;
575: if (move > sizeof(statusChangedBitmap))
576: move = sizeof(statusChangedBitmap);
577: if (numPorts < 8)
578: move = 1;
579:
580: statusChangedBitmap = HostToUSBWord(statusChangedBitmap);
581: last.buf->writeBytes(0,&statusChangedBitmap, move);
582: IOUnlock(_intLock); /* Unlock the queue */
583: complete(last.completion, kIOReturnSuccess, last.bufLen - move);
584: }
585: }
586:
587: /*
588: * SimulateRootHubInt
589: * Simulate the interrupt pipe (status change pipe) of a hub for the root
590: * hub. The basic concept is to simulate the UIMCreateInterruptTransfer
591: * so we keep our own little queue -> _outstandingTrans. We are turning
592: * on the RHSC interrupt so UIMRootHubStatusChange() should handle the
593: * dequeueing.
594: */
595: void AppleOHCI::SimulateRootHubInt(
596: UInt8 endpoint,
597: IOMemoryDescriptor * buf,
598: UInt32 bufLen,
599: IOUSBCompletion completion)
600: {
601: int index;
602: OHCIRegistersPtr pOHCIRegisters = pOHCIUIMData->pOHCIRegisters;
603:
604: if (endpoint != 1)
605: {
606: complete(completion, -1, bufLen);
607: return;
608: }
609:
610: IOTakeLock(_intLock);
611:
612: for (index = 0; index < kMaxOutstandingTrans; index++)
613: {
614: if (_outstandingTrans[index].completion.action == nil)
615: {
616: /* found free trans */
617: _outstandingTrans[index].buf = buf;
618: _outstandingTrans[index].bufLen = bufLen;
619: _outstandingTrans[index].completion = completion;
620: IOUnlock(_intLock); /* Unlock the queue */
621:
622: /* turn on RHSC interrupt */
623: pOHCIRegisters->hcInterruptEnable =pOHCIRegisters->hcInterruptEnable
624: | OSSwapInt32(kOHCIHcInterrupt_RHSC);
625: IOSync();
626:
627: return;
628: }
629: }
630:
631: IOUnlock(_intLock); /* Unlock the queue */
632: complete(completion, -1, bufLen); /* too many trans */
633: }
634:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.