![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOUSBHub.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOUSBBus|
Return to IOUSBHub.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOUSBBus |
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: #include <libkern/OSByteOrder.h>
30:
31: #include "IOUSBHub.h"
32: #include <IOKit/usb/IOUSBInterface.h>
33: #include <IOKit/usb/IOUSBPipe.h>
34:
35: #define super IOService
36: #define self this
37: #define DEBUGGING_LEVEL 0
38: #define DEBUGLOG kprintf
39:
40: UInt32 GetErrataBits(IOUSBDeviceDescriptor *desc);
41:
42: /* private API */
43: static void callStartHandler(void *hub)
44: {
45: ((IOUSBHub *) hub)->StartHandler();
46: }
47:
48: OSDefineMetaClassAndStructors(IOUSBHub, IOService)
49:
50: bool IOUSBHub::init( OSDictionary * propTable )
51: {
52: if( !super::init(propTable))
53: return (false);
54:
55: _numCaptive = 0;
56:
57: return(true);
58: }
59:
60: bool IOUSBHub::start(IOService * provider)
61: {
62: IOReturn err = 0;
63: IOUSBDevice::FindInterfaceRequest req;
64: IOThread ioThread;
65:
66: if( !super::start(provider))
67: return (false);
68:
69: // remember my device
70: _device = (IOUSBDevice *) provider;
71: _address = _device->address();
72: _bus = _device->bus();
73:
74: if (!_device->open(this)) return false;
75:
76: do {
77: IOLog("%s: USB Generic Hub @ %d\n", getName(), _address);
78:
79: // Find the first config/interface
80: if (_device->deviceDescriptor()->numConf < 1)
81: {
82: IOLog("%s: no hub configurations\n", getName());
83: break;
84: }
85:
86: req.theClass = kUSBHubClass;
87: req.subClass = req.protocol = 0;
88: req.maxPower = 0;
89: if ((_hubInterface = _device->findNextInterface(NULL, &req)) == 0)
90: {
91: IOLog("%s: no interface found\n", getName());
92: break;
93: }
94: _busPowered = req.busPowered == 2; //FIXME
95: _selfPowered = req.selfPowered == 2; //FIXME
96:
97: if( !(_busPowered || _selfPowered) )
98: {
99: IOLog("%s: illegal device config - no power\n", getName());
100: break;
101: }
102:
103: // set my configuration
104:
105: if ((err = _device->SetConfiguration(_hubInterface->getConfigValue())))
106: break;
107:
108: // Get the hub descriptor
109: if ((err = GetHubDescriptor(&_hubDescriptor)))
110: break;
111:
112: // Setup for reading status pipe
113: _buffer = IOBufferMemoryDescriptor::withCapacity(8, kIODirectionIn);
114:
115: if (!_hubInterface->open(this))
116: break;
117:
118: IOUSBFindEndpointRequest request;
119: request.type = kUSBInterrupt;
120: request.direction = kUSBIn;
121: _interruptPipe = _hubInterface->findNextPipe(NULL, &request);
122:
123: if(!_interruptPipe)
124: return false;
125:
126: // prepare the ports
127: UnpackPortFlags();
128: CountCaptivePorts();
129: #if (DEBUGGING_LEVEL > 0)
130: PrintHubDescriptor(&_hubDescriptor);
131: #endif
132: if (!CheckPortPowerRequirements()) continue;
133: if (!AllocatePortMemory()) continue;
134: if (!StartPorts()) continue;
135: ioThread = IOCreateThread(callStartHandler, this);
136: if (ioThread == NULL) continue;
137:
138: return(true);
139:
140: } while (false);
141:
142: IOLog("%s: aborting startup. err = %d\n", getName(), err);
143:
144: _device->close(this);
145: stop(provider);
146:
147: return(false);
148: }
149:
150: void IOUSBHub::stop(IOService * provider)
151: {
152: // stop/close all ports
153: // deallocate ports
154: StopPorts();
155:
156: if (_buffer) {
157: _buffer->release();
158: _buffer = 0;
159: }
160: if(_hubInterface) {
161: _hubInterface->close(this);
162: _hubInterface->release();
163: _hubInterface = 0;
164: }
165: super::stop(provider);
166: }
167:
168: /**********************************************************************
169: **
170: ** HUB FUNCTIONS
171: **
172: **********************************************************************/
173: void IOUSBHub::UnpackPortFlags(void)
174: {
175: // ERIC FIXME?- I don't think the first +1 should be there.
176: int numFlags = ((_hubDescriptor.numPorts + 1) / 8) + 1;
177: int i;
178:
179: for(i = 0; i < numFlags; i++)
180: {
181: _hubDescriptor.pwrCtlPortFlags[i] =
182: _hubDescriptor.removablePortFlags[numFlags+i];
183: _hubDescriptor.removablePortFlags[numFlags+i] = 0;
184: }
185: }
186:
187: void IOUSBHub::CountCaptivePorts(void)
188: {
189: int portMask = 2;
190: int portByte = 0;
191: int currentPort;
192:
193:
194: for (currentPort = 1; currentPort <= _hubDescriptor.numPorts; currentPort++)
195: {
196: /* determine if the port is a captive port */
197: if ((_hubDescriptor.removablePortFlags[portByte] & portMask) != 0)
198: _numCaptive++; // save this for power calculations
199:
200: portMask <<= 1;
201: if(portMask > 0x80)
202: {
203: portMask = 1;
204: portByte++;
205: }
206: }
207: }
208:
209:
210: /*
211: ExtPower Good off
212:
213: Bus Self
214:
215: 0 0 Illegal config
216: 1 0 Always 100mA per port
217: 0 1 500mA 0 (dead)
218: 1 1 500 100
219: */
220: bool IOUSBHub::CheckPortPowerRequirements(void)
221: {
222: IOReturn err = kIOReturnSuccess;
223: /* Note hub current in units of 1mA, everything else in units of 2mA */
224: UInt32 hubPower = _hubDescriptor.hubCurrent/2;
225: UInt32 busPower = _device->busPowerAvailable();
226: UInt32 powerAvailForPorts, powerNeededForPorts;
227: bool startExternal;
228:
229: do
230: {
231: if (hubPower > busPower)
232: {
233: IOLog("%s: hub needs more power than available", getName());
234: err = kIOReturnNoPower;
235: }
236:
237: powerAvailForPorts = busPower - hubPower;
238: /* we minimally need make available 100mA per non-captive port */
239: powerNeededForPorts =
240: (_hubDescriptor.numPorts - _numCaptive) * kUSB100mA;
241: _busPowerGood = powerAvailForPorts >= powerNeededForPorts;
242: if(_numCaptive > 0)
243: {
244: if(_busPowerGood)
245: _powerForCaptive =
246: (powerAvailForPorts - powerNeededForPorts) / _numCaptive;
247: else
248: _powerForCaptive = powerAvailForPorts / _numCaptive;
249: }
250:
251: if( (_errataBits & kErrataCaptiveOK) != 0)
252: _powerForCaptive = kUSB100mAAvailable;
253:
254: #if (DEBUGGING_LEVEL > 0)
255: DEBUGLOG("%s: power:\n", getName());
256: DEBUGLOG("\tbus power available = %ldmA\n", busPower * 2);
257: DEBUGLOG("\thub power needed = %ldmA\n", hubPower * 2);
258: DEBUGLOG("\tport power available = %ldmA\n", powerAvailForPorts * 2);
259: DEBUGLOG("\tport power needed = %ldmA\n", powerNeededForPorts * 2);
260: DEBUGLOG("\tpower for captives = %ldmA\n", _powerForCaptive * 2);
261: DEBUGLOG("\tbus power is %s\n", _busPowerGood?"good" : "insufficient");
262: #endif
263:
264: _selfPowerGood = false;
265:
266: if(_selfPowered)
267: {
268: USBStatus status = 0;
269:
270: if ((err = _device->GetDeviceStatus(&status))) break;
271: status = USBToHostWord(status);
272: _selfPowerGood = ((status & 1) != 0); // FIXME 1?
273: }
274:
275: if(_selfPowered && _busPowered)
276: {
277: /* Dual power hub */
278: DEBUGLOG("%s: Hub attached - Self/Bus powered, ", getName());
279: if(_selfPowerGood)
280: DEBUGLOG("power supply good\n");
281: else
282: DEBUGLOG("no external power\n");
283: }
284: else
285: {
286: /* Single power hub */
287: if(_selfPowered)
288: {
289: DEBUGLOG("%s: Hub attached - Self powered, ", getName());
290: if(_selfPowerGood)
291: DEBUGLOG("power supply good\n");
292: else
293: DEBUGLOG("no external power\n");
294: }
295: else
296: {
297: DEBUGLOG("%s: Hub attached - Bus powered\n", getName());
298: }
299:
300: }
301: startExternal = (_busPowerGood || _selfPowerGood);
302: if( !startExternal )
303: { /* not plugged in or bus powered on a bus powered hub */
304: err = kIOReturnNoPower;
305: DEBUGLOG("%s: insufficient power to turn on ports\n", getName());
306: if(!_busPowered)
307: {
308: /* may be able to turn on compound devices */
309: break; /* Now what ?? */
310: }
311: }
312: } while (false);
313:
314: return(err == kIOReturnSuccess);
315: }
316:
317:
318: bool IOUSBHub::AllocatePortMemory(void)
319: {
320: IOUSBHubPort *port;
321: UInt32 power;
322: int portMask = 2;
323: int portByte = 0;
324: int currentPort;
325:
326:
327: _ports = (IOUSBHubPort **)
328: IOMalloc(sizeof(IOUSBHubPort *) * _hubDescriptor.numPorts);
329: if (!_ports)
330: return(false);
331:
332: for (currentPort = 1; currentPort <= _hubDescriptor.numPorts; currentPort++)
333: {
334: /* determine if the port is a captive port */
335: if ((_hubDescriptor.removablePortFlags[portByte] & portMask) != 0)
336: {
337: power = _powerForCaptive;
338: }
339: else
340: {
341: power = _selfPowerGood ? kUSB500mAAvailable : kUSB100mAAvailable;
342: }
343:
344: port = new IOUSBHubPort;
345: port->init(self, currentPort, power);
346: _ports[currentPort-1] = port;
347:
348: portMask <<= 1;
349: if(portMask > 0x80)
350: {
351: portMask = 1;
352: portByte++;
353: }
354: }
355:
356: return(true);
357: }
358:
359:
360: bool IOUSBHub::StartPorts(void)
361: {
362: IOReturn err = kIOReturnSuccess;
363: IOUSBHubPort *port;
364: int currentPort;
365: //IOThread ioThread;
366:
367:
368: #if (DEBUGGING_LEVEL > 0)
369: DEBUGLOG("%s: starting ports (%d)\n", getName(), _hubDescriptor.numPorts);
370: #endif
371:
372: for (currentPort = 1; currentPort <= _hubDescriptor.numPorts; currentPort++)
373: {
374: port = _ports[currentPort-1];
375: if (port)
376: err = port->start();
377:
378: // Temporarily fork off a thread for each port. Each port could
379: // potentially call addDevice which will generate hub events.
380: //ioThread = IOCreateThread(callStart, port);
381: //if (ioThread == NULL)
382: //{
383: // err = kIOReturnNoMemory;
384: // break;
385: //}
386: }
387:
388: // Ignore any error for now. Maybe the hub would want to know
389: // if all ports failed, but if at least one succeeds, then we
390: // should continue.
391: return(true);
392: }
393:
394: bool IOUSBHub::StopPorts(void)
395: {
396: IOUSBHubPort *port;
397: int currentPort;
398:
399:
400: #if (DEBUGGING_LEVEL > 0)
401: DEBUGLOG("%s: stopping ports (%d)\n", getName(), _hubDescriptor.numPorts);
402: #endif
403:
404: if( _ports) for (currentPort = 1; currentPort <= _hubDescriptor.numPorts; currentPort++)
405: {
406: port = _ports[currentPort-1];
407: if (port) {
408: port->stop();
409: delete port;
410: _ports[currentPort-1] = 0;
411: }
412: }
413:
414: IOFree(_ports, sizeof(IOUSBHubPort *) * _hubDescriptor.numPorts);
415: _ports = 0;
416: return(true);
417: }
418:
419: const UInt8 * IOUSBHub::getStatusChanged(void)
420: {
421: IOReturn err = kIOReturnSuccess;
422: const UInt8 * status = NULL;
423:
424: _buffer->setLength(8);
425:
426: do
427: {
428: if ((err = _interruptPipe->read(_buffer)))
429: {
430: DEBUGLOG("%s: error 0x%x reading interrupt pipe.\n", getName(), err);
431: break;
432: }
433:
434: if (err == kIOReturnNotResponding)
435: {
436: // This probably means the device was unplugged.
437: break;
438: }
439: else if (err != kIOReturnSuccess)
440: {
441: // We should handle other errors more intelligently, but
442: // for now just return and assume the error is recoverable.
443: //kprintf("%s: error %d reading interrupt pipe\n", getName(), err);
444: break;
445: }
446: status = (const UInt8 *)_buffer->getBytesNoCopy();
447: } while (false);
448: return status;
449: }
450:
451: bool IOUSBHub::StartHandler(void)
452: {
453: IOReturn err = kIOReturnSuccess;
454: const UInt8 *statusChangedBitmap;
455: int portMask;
456: int portByte;
457: int portIndex;
458: IOUSBHubPort *port;
459:
460: do
461: {
462: portMask = 2;
463: portByte = 0;
464: statusChangedBitmap = getStatusChanged();
465: if (statusChangedBitmap == 0)
466: {
467: DEBUGLOG("%s: no data returned from int pipe\n", getName());
468: break;
469: }
470:
471: #if (DEBUGGING_LEVEL > 0)
472: DEBUGLOG("read returned 0x%x (%d)\n", statusChangedBitmap[portByte],
473: _buffer->getLength());
474: #endif
475:
476: for (portIndex = 1; portIndex <=_hubDescriptor.numPorts; portIndex++)
477: {
478: if ((statusChangedBitmap[portByte] & portMask) != 0)
479: {
480: port = _ports[portIndex-1];
481: port->statusChanged();
482: }
483:
484: portMask <<= 1;
485: if (portMask > 0x80)
486: {
487: portMask = 1;
488: portByte++;
489: }
490: }
491:
492: /* hub status changed */
493: if ((statusChangedBitmap[0] & 1) != 0)
494: {
495: statusChanged();
496: }
497:
498: } while (true);
499:
500: DEBUGLOG("%s: error %d. Exiting Hub Handler\n", getName(), err);
501:
502: _device->close(this);
503:
504: return(false);
505: }
506:
507:
508: bool IOUSBHub::statusChanged(void)
509: {
510: IOReturn err = kIOReturnSuccess;
511:
512: do
513: {
514: if ((err = GetHubStatus(&_hubStatus)))
515: {
516: fatalError(err, "get status (first in hub status change)");
517: break;
518: }
519: _hubStatus.statusFlags = USBToHostWord(_hubStatus.statusFlags);
520: _hubStatus.changeFlags = USBToHostWord(_hubStatus.changeFlags);
521:
522: #if (DEBUGGING_LEVEL > 0)
523: DEBUGLOG("%s: hub status = %x/%x\n", getName(),
524: _hubStatus.statusFlags, _hubStatus.changeFlags);
525: #endif
526:
527: if (_hubStatus.changeFlags & kHubLocalPowerStatusChange)
528: {
529: #if (DEBUGGING_LEVEL > 0)
530: DEBUGLOG("%s: Local Power Status Change detected\n", getName());
531: #endif
532: if ((err = ClearHubFeature(kHubLocalPowerStatusChange)))
533: {
534: fatalError(err, "clear hub power status feature");
535: break;
536: }
537: if ((err = GetHubStatus(&_hubStatus)))
538: {
539: fatalError(err, "get status (second in hub status change)");
540: break;
541: }
542: _hubStatus.statusFlags = USBToHostWord(_hubStatus.statusFlags);
543: _hubStatus.changeFlags = USBToHostWord(_hubStatus.changeFlags);
544: }
545:
546: if (_hubStatus.changeFlags & kHubOverCurrentIndicatorChange)
547: {
548: #if (DEBUGGING_LEVEL > 0)
549: DEBUGLOG("%s: OverCurrent Indicator Change detected\n", getName());
550: #endif
551: if ((err =
552: ClearHubFeature(kHubOverCurrentIndicatorChange)))
553: {
554: fatalError(err, "clear hub over current feature");
555: break;
556: }
557: if ((err = GetHubStatus(&_hubStatus)))
558: {
559: fatalError(err, "get status (second in hub status change)");
560: break;
561: }
562: _hubStatus.statusFlags = USBToHostWord(_hubStatus.statusFlags);
563: _hubStatus.changeFlags = USBToHostWord(_hubStatus.changeFlags);
564: }
565:
566: //DEBUGLOG("%s: calling delay reentering poll loop\n", getName());
567: //USBDelay(10); //FIXME
568:
569: } while(false);
570:
571: return(err == kIOReturnSuccess);
572: }
573:
574: static ErrataListEntry errataList[] = {
575:
576: /* For the Cherry 4 port KB, From Cherry:
577: We use the bcd_releasenumber-highbyte for hardware- and the lowbyte for
578: firmwarestatus. We have 2 different for the hardware 03(eprom) and
579: 06(masked microcontroller). Firmwarestatus is 05 today.
580: So high byte can be 03 or 06 ---- low byte can be 01, 02, 03, 04, 05
581:
582: Currently we are working on a new mask with the new descriptors. The
583: firmwarestatus will be higher than 05.
584: */
585: {0x046a, 0x003, 0x0301, 0x0305, kErrataCaptiveOK}, // Cherry 4 port KB
586: {0x046a, 0x003, 0x0601, 0x0605, kErrataCaptiveOK} // Cherry 4 port KB
587: };
588:
589: #define errataListLength (sizeof(errataList)/sizeof(ErrataListEntry))
590:
591: UInt32 GetErrataBits(IOUSBDeviceDescriptor *desc)
592: {
593: UInt16 vendID, deviceID, revisionID;
594: ErrataListEntry *entryPtr;
595: UInt32 i, errata = 0;
596:
597: // get this chips vendID, deviceID, revisionID
598: vendID = USBToHostWord(desc->vendor);
599: deviceID = USBToHostWord(desc->product);
600: revisionID = USBToHostWord(desc->devRel);
601:
602: for(i=0, entryPtr = errataList; i < errataListLength; i++, entryPtr++)
603: {
604: if (vendID == entryPtr->vendID
605: && deviceID == entryPtr->deviceID
606: && revisionID >= entryPtr->revisionLo
607: && revisionID <= entryPtr->revisionHi)
608: {
609: errata |= entryPtr->errata; // we match, add this errata to our list
610: }
611: }
612: return(errata);
613: }
614:
615: void IOUSBHub::fatalError(IOReturn err, char *str)
616: {
617: DEBUGLOG("IOUSBHub: Error %d: %s\n", err, str);
618: }
619:
620: IOReturn IOUSBHub::GetHubDescriptor(IOUSBHubDescriptor *desc)
621: {
622: IOReturn err = kIOReturnSuccess;
623: IOUSBDevRequest request;
624:
625: #if (DEBUGGING_LEVEL > 0)
626: DEBUGLOG("*********** GET HUB DESCRIPTOR ***********\n");
627: #endif
628:
629: if (!desc) return (kIOReturnBadArgument);
630:
631: request.rqDirection = kUSBIn;
632: request.rqType = kUSBClass;
633: request.rqRecipient = kUSBDevice;
634: request.bRequest = kUSBRqGetDescriptor;
635: OSWriteLittleInt16(&request.wValue, 0, kUSBHubDescriptorType);
636: OSWriteLittleInt16(&request.wIndex, 0, 0);
637: OSWriteLittleInt16(&request.wLength, 0, sizeof(IOUSBHubDescriptor));
638: request.pData = desc;
639:
640: err = _device->deviceRequest(&request);
641:
642: if (err)
643: {
644: /*
645: * Is this a bogus hub? Some hubs require 0 for the descriptor type
646: * to get their device descriptor. This is a bug, but it's actually
647: * spec'd out in the USB 1.1 docs.
648: */
649: OSWriteLittleInt16(&request.wValue, 0, 0);
650: OSWriteLittleInt16(&request.wLength, 0, sizeof(IOUSBHubDescriptor));
651: err = _device->deviceRequest(&request);
652: }
653:
654: if (err)
655: IOLog("%s: error getting hub descriptor. err=%d\n", getName(), err);
656:
657: return(err);
658: }
659:
660: IOReturn IOUSBHub::GetHubStatus(IOUSBHubStatus *status)
661: {
662: IOReturn err = kIOReturnSuccess;
663: IOUSBDevRequest request;
664:
665: #if (DEBUGGING_LEVEL > 0)
666: DEBUGLOG("************* GET HUB STATUS *************\n");
667: #endif
668:
669: request.rqDirection = kUSBIn;
670: request.rqType = kUSBClass;
671: request.rqRecipient = kUSBDevice;
672: request.bRequest = kUSBRqGetStatus;
673: OSWriteLittleInt16(&request.wValue, 0, 0);
674: OSWriteLittleInt16(&request.wIndex, 0, 0);
675: OSWriteLittleInt16(&request.wLength, 0, sizeof(IOUSBHubStatus));
676: request.pData = status;
677:
678: err = _device->deviceRequest(&request);
679:
680: if (err)
681: IOLog("%s: error getting hub status. err=%d\n", getName(), err);
682:
683: return(err);
684: }
685:
686: IOReturn IOUSBHub::GetPortState(UInt8 *state, UInt16 port)
687: {
688: IOReturn err = kIOReturnSuccess;
689: IOUSBDevRequest request;
690:
691: #if (DEBUGGING_LEVEL > 0)
692: DEBUGLOG("************* GET PORT STATE *************\n");
693: #endif
694:
695: request.rqDirection = kUSBIn;
696: request.rqType = kUSBClass;
697: request.rqRecipient = kUSBOther;
698: request.bRequest = kUSBRqGetState;
699: OSWriteLittleInt16(&request.wValue, 0, 0);
700: OSWriteLittleInt16(&request.wIndex, 0, port);
701: OSWriteLittleInt16(&request.wLength, 0, sizeof(*state));
702: request.pData = state;
703:
704: err = _device->deviceRequest(&request);
705:
706: if (err)
707: IOLog("%s: error getting hub state. err=%d\n", getName(), err);
708:
709: return(err);
710: }
711:
712: IOReturn IOUSBHub::ClearHubFeature(UInt16 feature)
713: {
714: IOReturn err = kIOReturnSuccess;
715: IOUSBDevRequest request;
716:
717: #if (DEBUGGING_LEVEL > 0)
718: DEBUGLOG("********** CLEAR HUB FEATURE %d **********\n", feature);
719: #endif
720:
721: request.rqDirection = kUSBOut;
722: request.rqType = kUSBClass;
723: request.rqRecipient = kUSBDevice;
724: request.bRequest = kUSBRqClearFeature;
725: OSWriteLittleInt16(&request.wValue, 0, feature);
726: OSWriteLittleInt16(&request.wIndex, 0, 0);
727: OSWriteLittleInt16(&request.wLength, 0, 0);
728: OSWriteLittleInt16(&request.pData, 0, 0);
729:
730: err = _device->deviceRequest(&request);
731:
732: if (err)
733: IOLog("%s: error clearing hub feature. err=%d\n", getName(), err);
734:
735: return(err);
736: }
737:
738: IOReturn IOUSBHub::GetPortStatus(IOUSBHubPortStatus *status, UInt16 port)
739: {
740: IOReturn err = kIOReturnSuccess;
741: IOUSBDevRequest request;
742:
743: #if (DEBUGGING_LEVEL > 0)
744: DEBUGLOG("*********** GET PORT %d STATUS ************\n", port);
745: #endif
746:
747: request.rqDirection = kUSBIn;
748: request.rqType = kUSBClass;
749: request.rqRecipient = kUSBOther;
750: request.bRequest = kUSBRqGetStatus;
751: OSWriteLittleInt16(&request.wValue, 0, 0);
752: OSWriteLittleInt16(&request.wIndex, 0, port);
753: OSWriteLittleInt16(&request.wLength, 0, sizeof(IOUSBHubPortStatus));
754: request.pData = status;
755:
756: err = _device->deviceRequest(&request);
757:
758: if (err)
759: IOLog("%s: error getting port status. err=%d\n", getName(), err);
760:
761: // Get things the right way round.
762: status->statusFlags = OSReadLittleInt16(&status->statusFlags, 0);
763: status->changeFlags = OSReadLittleInt16(&status->changeFlags, 0);
764:
765: return(err);
766: }
767:
768: IOReturn IOUSBHub::SetPortFeature(UInt16 feature, UInt16 port)
769: {
770: IOReturn err = kIOReturnSuccess;
771: IOUSBDevRequest request;
772:
773: #if (DEBUGGING_LEVEL > 0)
774: DEBUGLOG("********* SET PORT %d FEATURE %d **********\n", port, feature);
775: #endif
776:
777: request.rqDirection = kUSBOut;
778: request.rqType = kUSBClass;
779: request.rqRecipient = kUSBOther;
780: request.bRequest = kUSBRqSetFeature;
781: OSWriteLittleInt16(&request.wValue, 0, feature);
782: OSWriteLittleInt16(&request.wIndex, 0, port);
783: OSWriteLittleInt16(&request.wLength, 0, 0);
784: request.pData = 0;
785:
786: err = _device->deviceRequest(&request);
787:
788: if (err)
789: IOLog("%s: error setting port feature. err=%d\n", getName(), err);
790:
791: return(err);
792: }
793:
794: IOReturn IOUSBHub::ClearPortFeature(UInt16 feature, UInt16 port)
795: {
796: IOReturn err = kIOReturnSuccess;
797: IOUSBDevRequest request;
798:
799: #if (DEBUGGING_LEVEL > 0)
800: DEBUGLOG("******** CLEAR PORT %d FEATURE %d *********\n", port, feature);
801: #endif
802:
803: request.rqDirection = kUSBOut;
804: request.rqType = kUSBClass;
805: request.rqRecipient = kUSBOther;
806: request.bRequest = kUSBRqClearFeature;
807: OSWriteLittleInt16(&request.wValue, 0, feature);
808: OSWriteLittleInt16(&request.wIndex, 0, port);
809: OSWriteLittleInt16(&request.wLength, 0, 0);
810: request.pData = 0;
811:
812: err = _device->deviceRequest(&request);
813:
814: if (err)
815: IOLog("%s: error clearing port feature. err=%d\n", getName(), err);
816:
817: return(err);
818: }
819:
820: void IOUSBHub::PrintHubDescriptor(IOUSBHubDescriptor *desc)
821: {
822: int i = 0;
823: char *characteristics[] =
824: { "ppsw", "nosw", "comp", "ppoc", "nooc", 0 };
825:
826:
827: if (desc->length == 0) return;
828:
829: DEBUGLOG("hub descriptor: (%d bytes)\n", desc->length);
830: DEBUGLOG("\thubType = %d\n", desc->hubType);
831: DEBUGLOG("\tnumPorts = %d\n", desc->numPorts);
832: DEBUGLOG("\tcharacteristics = %x ( ",
833: USBToHostWord(desc->characteristics));
834: do
835: {
836: if (USBToHostWord(desc->characteristics) & (1 << i))
837: DEBUGLOG("%s ", characteristics[i]);
838: } while (characteristics[++i]);
839: DEBUGLOG(")\n");
840: DEBUGLOG("\tpowerOnToGood = %d ms\n", desc->powerOnToGood * 2);
841: DEBUGLOG("\thubCurrent = %d\n", desc->hubCurrent);
842: DEBUGLOG("\tremovablePortFlags = %x %x\n", &desc->removablePortFlags[1], &desc->removablePortFlags[0]);
843: DEBUGLOG("\tpwrCtlPortFlags = %x %x\n", &desc->pwrCtlPortFlags[1], &desc->removablePortFlags[0]);
844: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.