![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HubClassDriver.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 / HubClassDriver|
Return to HubClassDriver.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvUSBCMD / HubClassDriver |
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: HubClassDriver.c
27:
28: Contains: xxx put contents here xxx
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: Barry Twycross
37:
38: Other Contact: xxx put other contact here xxx
39:
40: Technology: xxx put technology here xxx
41:
42: Writers:
43:
44: (TC) Tom Clark
45: (BG) Bill Galcher
46: (DF) David Ferguson
47: (BT) Barry Twycross
48: (CJK) Craig Keithley
49:
50: Change History (most recent first):
51:
52: <USB90> 11/18/98 BT Free up port after reset completes.
53: <USB89> 11/4/98 BT Fix dead device giving up on aborted error, and reading of all
54: of device descriptor on second attach.
55: <USB88> 10/15/98 BT Change to 1.1 max packet discovery
56: <USB87> 10/12/98 BT Add power qualification to find next interface
57: <USB86> 10/8/98 BT Fix dead device handling
58: <USB85> 10/3/98 BT More reset port stuff
59: <USB84> 9/29/98 BT More port reset function
60: <USB83> 9/28/98 BT Add Cherry KB revs to errata. Add device reset framework.
61: Rewrite interrupt handler.
62: <USB82> 9/17/98 BT Add hub errata, make work with Cherry 4 port.
63: <USB81> 9/17/98 BT 1.1 rules for captive devices.
64: <USB80> 9/16/98 BT Re enable port if it strangly changes to disabled.
65: <USB79> 9/11/98 BT Improve are we there yet fn
66: <USB78> 9/10/98 BT Improved improved enumeration, check last port
67: <USB77> 9/10/98 BT Add are we finished query
68: <USB76> 9/9/98 BT Fix MCT hub strangeness
69: <USB75> 8/25/98 BT Isoc name changes
70: <USB74> 8/20/98 BT Clean up interfaces on delete
71: <USB73> 7/23/98 BT Check port status after 100ms wait on attach.
72: <USB72> 7/10/98 BT Fix fast and hot replugging issues.
73: <USB71> 6/24/98 BT Fix memory leak fix so it doesn't use deallocated pb
74: <USB70> 6/24/98 BT Fix memory leak with more than 4 ports, when deallocating
75: <USB69> 6/24/98 DF handle an AbortError specially.
76: <USB68> 6/15/98 BT Cope with 1.1 hubs speed detection
77: <USB67> 6/13/98 TC Pass hubDevRef rather then hubRef when insufficent power
78: encountered.
79: <USB66> 6/11/98 CJK add reserved params to USBExpertSetDevicePowerStatus. Wanted to
80: get it into the USB.i before freezing C1
81: <USB65> 6/11/98 BT Add power state notification message
82: <USB64> 6/5/98 BT Delete device may complete async now.
83: <USB63> 6/3/98 BT Fix device vs interface ref talking to expert
84: <USB62> 5/28/98 CJK change file creater to 'MPS '
85: <USB61> 5/20/98 BT Configure interface takes alt param
86: <USB60> 5/20/98 BT Fix alt usage in interface functions
87: <USB59> 5/20/98 BT Update to V2 param block
88: <USB58> 5/19/98 BG Add prototype for USBExpertRemoveDeviceDriver() and
89: USBExpertInstallDeviceDriver() til they (hopefully) get
90: mentioned in an appropriate header file.
91: <USB57> 5/14/98 DF add more status message for power changes and overcurrent
92: indicators
93: <USB56> 5/12/98 BT New interface stuff
94: <USB55> 4/29/98 BT Fix reset change connection state in dead driver
95: <USB54> 4/27/98 BT Fix hot unplugging.
96: <USB53> 4/27/98 DF Use pascal strings for status & errors
97: <USB52> 4/23/98 BT Always remove any device on connction state change
98: <USB51> 4/23/98 BT Use 1 byte interrupts
99: <USB50> 4/23/98 BT Fix deadlock if device does not enumerate.
100: <USB49> 4/22/98 BT Allow not broken devices to be attached
101: <USB48> 4/21/98 BT Allow for other than 8 bytes max packet
102: <USB47> 4/21/98 BT Switch order of read device descriptor and set address
103: <USB46> 4/20/98 BT Use device not hub status for power supply detection.
104: <USB45> 4/19/98 BT Add hub status change logic.
105: <USB44> 4/16/98 BT Centralise error handling.
106: <USB43> 4/15/98 BT remove debugger
107: <USB42> 4/15/98 BT More error checking and robustness vs dead devices.
108: <USB41> 4/14/98 BT Add extra delay, some hubs seem not to appreciate things.
109: <USB40> 4/14/98 BT Add kill hub for when its unpo='lugged
110: <39> 4/10/98 BT Add call to USBHubDeviceRemoved
111: <USB38> 4/10/98 BT Add 100ms power up delay on connect.
112: <USB37> 4/9/98 BT Fix reset timing and use USB.h
113: <USB36> 4/9/98 DF Fix to work with MasterInterfaces
114: <35> 4/8/98 BT fix flags, add dynamic port allocation
115: <34> 4/7/98 BT Change to new PB names
116: <33> 4/6/98 BT Change paramblock version to 0.01
117: <32> 4/2/98 BT Avoid C++ keywords (class)
118: <31> 3/31/98 CJK Modify the few remaining error messages to be prefixed by "Hub
119: Driver"
120: <30> 3/31/98 CJK Change ExpertStatus strings from pstrings to cstrings.
121: <29> 3/27/98 BT Cope with captive ports
122: <28> 3/20/98 BT Don't use 1 byte max packet sizes.
123: <27> 3/18/98 BT Hot unplugging
124: <26> 3/11/98 BT Fix driver tripping over itself on too many interrupts
125: <25> 3/6/98 CJK change hanlder to handler. Remove DebugStr (link was
126: complaining about it).
127: <24> 3/5/98 BT Make hub more than single pluggable.
128: <23> 3/5/98 BT Add interrupt pipe, and one hot plug
129: <22> 2/24/98 BT Support atmel and other hubs which use different descriptor
130: indexes.
131: <21> 2/23/98 BT Make more forgiving of different hubs
132: <20> 2/10/98 BT Fix get wIndex in get device descriptor.
133: <19> 2/8/98 BT More Power allocation stuff
134: <18> 2/8/98 BT Power Allocation stuff
135: <17> 2/5/98 BT Add status notification stuff
136: <16> 2/4/98 BT More hub driver cleanup extend
137: <15> 2/4/98 BT Update to include new USL features and power allocation stuff.
138: <14> 1/26/98 CJK Change to use USBDeviceDescriptor (instead of just
139: devicedescriptor)
140: <13> 1/26/98 BT Fix name changes
141: <12> 1/26/98 BT Mangle names after design review
142: <11> 1/26/98 BT Make expert notify public
143: <10> 1/20/98 BT Add port indicator as debug aid, now works
144: <9> 1/20/98 BT Making functions static
145: <8> 1/15/98 CJK Change include of USL.h to USBServicesLib.h
146: <7> 1/14/98 BT Use new USBClassDrivers.h
147: <6> 1/14/98 BT Change outdated pre expert stuff to real expert
148: <5> 1/13/98 BT Making timers internal
149: <4> 12/18/97 BT Add reentracy check and change notify proc notification
150: <3> 12/17/97 BT Bring in my hub driver from the USL
151: <2> 12/4/97 CJK Add BBS file header
152: <1> 12/4/97 CJK First checked in
153: */
154:
155: #include "../USB.h"
156:
157: #include "hub.h"
158: #include "../driverservices.h"
159:
160:
161: enum{ /* States the hub driver can be in */
162: kNormal = 0,
163: kDead,
164: kDeviceZero,
165: kDeadDeviceZero,
166: kSetAddress,
167: kSetAddressFailed
168: };
169:
170: enum{
171: kHubIsCompound = 0x040 // Hub decriptor characteristics
172: };
173:
174: enum{
175: kMaxPorts = 4, // Initial allocation of ports, can be expanded
176: kInitialRetries = 4
177: };
178:
179:
180:
181: typedef struct{
182: UInt16 status;
183: UInt16 change;
184: } HubStatus;
185:
186:
187: typedef struct{
188: UInt32 (*handler)(USBPB *pb);
189: UInt32 bit;
190: UInt32 clearFeature;
191: }portStatusChangeVector;
192:
193:
194: static UInt32 defDoNothingChangeHandler(USBPB *pb);
195: static UInt32 deadConnectionChangeHandler(USBPB *pb);
196: static UInt32 defOverCrntChangeHandler(USBPB *pb);
197: static UInt32 defResetChangeHandler(USBPB *pb);
198: static UInt32 defSuspendChangeHandler(USBPB *pb);
199: static UInt32 defEndableChangeHandler(USBPB *pb);
200: static UInt32 defConnectionChangeHandler(USBPB *pb);
201: static OSStatus HubAreWeFinishedYet(void);
202: static OSStatus killHub(USBDeviceRef device);
203:
204: static portStatusChangeVector defaultPortVectors[]={
205: {defOverCrntChangeHandler, kHubPortOverCurrent, kUSBHubPortOverCurrentChangeFeature},
206: {defResetChangeHandler, kHubPortBeingReset, kUSBHubPortResetChangeFeature},
207: {defSuspendChangeHandler, kHubPortSuspend, kUSBHubPortSuspendChangeFeature},
208: {defEndableChangeHandler, kHubPortEnabled, kUSBHubPortEnableChangeFeature},
209: {defConnectionChangeHandler, kHubPortConnection, kUSBHubPortConnectionChangeFeature},
210: };
211:
212: enum{
213: numChangeHandlers = sizeof(defaultPortVectors)/sizeof(portStatusChangeVector),
214:
215:
216: kVectorContinueImmed = 0,
217: kVectorContinueDelayed = 1,
218: kVectorfinishedImmed = 2,
219: kVectorNotfinished = 3,
220:
221: kPortWhichVectorShift = 8,
222: kPortWhichVector1 = (1<<kPortWhichVectorShift),
223: kPortHandlerStageMask = kPortWhichVector1-1,
224:
225: kPortVectorStageShift = 16,
226: kPortVectorStage1 = (1<<kPortVectorStageShift),
227: kPortVectorStageMask = kPortVectorStage1-1
228: };
229:
230: typedef struct{
231: USBPB pb;
232: USBPB *portRequestPB;
233: portStatusChangeVector changeHandler[numChangeHandlers];
234: unsigned char *errorString;
235: USBDeviceDescriptor desc;
236: USBHubPortStatus portStatus;
237: USBDeviceRef newDevRef;
238: USBDeviceRef devZeroRef;
239: UInt16 value;
240: UInt16 state;
241: int portIndex;
242: int onError;
243: int retries;
244: int delay;
245: UInt8 portByte;
246: UInt8 portMask;
247: }perPort;
248:
249:
250:
251: static perPort staticPorts[kMaxPorts+1], *ports = staticPorts;
252: static int numPorts;
253: static UInt32 busPowerAvail;
254: static UInt32 powerForCaptive;
255: static Boolean startExternal;
256: static Boolean selfPowered;
257: static Boolean selfPowerGood;
258: static Boolean busPowered;
259: static Boolean busPowerGood;
260: static HubStatus hubStatus;
261: static UInt16 deviceStatus;
262: static UInt32 hubSubClass = 1;
263: static UInt8 intPipeNumber;
264: static USBDeviceRef hubRef, hubDevRef;
265: static UInt16 intPipeMaxPacket;
266: static hubDescriptor hubDesc;
267: static UInt32 intFrame;
268: static numCaptive;
269: static UInt32 errataBits;
270: #if 1
271:
272:
273:
274: static void hubAddDeviceHandler(USBPB *pb);
275: static void doPortResetHandler(USBPB *pb);
276:
277:
278: /* Incorporate debugging strings */
279: #define noteError(s) pp->errorString = s;
280:
281: #else
282:
283: /* eliminate Error strings */
284: #define noteError(s)
285:
286: #endif
287:
288: /*
289: This is copied wholesale from the UIM.
290:
291: This table contains the list of errata that are necessary for known problems with particular hub
292: The format is vendorID, product ID, lowest revisionID needing errata, highest rev needing errata, errataBits
293: The result of all matches is ORed together, so more than one entry may match. Typically for a given errata a
294: list of hubs revisions that this applies to is supplied.
295: */
296: enum{
297: kErrataCaptiveOK = 1
298: };
299:
300: typedef struct {
301: UInt16 vendID;
302: UInt16 deviceID;
303: UInt16 revisionLo;
304: UInt16 revisionHi;
305: UInt32 errata;
306: }ErrataListEntry;
307:
308: static ErrataListEntry errataList[] = {
309:
310: /* For the Cherry 4 port KB, From Cherry:
311: We use the bcd_releasenumber-highbyte for hardware- and the lowbyte for
312: firmwarestatus. We have 2 different for the hardware 03(eprom) and
313: 06(masked microcontroller). Firmwarestatus is 05 today.
314: So high byte can be 03 or 06 ---- low byte can be 01, 02, 03, 04, 05
315:
316: Currently we are working on a new mask with the new descriptors. The
317: firmwarestatus will be higher than 05.
318: */
319: {0x046a, 0x003, 0x0301, 0x0305, kErrataCaptiveOK}, // Cherry 4 port KB
320: {0x046a, 0x003, 0x0601, 0x0605, kErrataCaptiveOK} // Cherry 4 port KB
321: };
322:
323: #define errataListLength (sizeof(errataList)/sizeof(ErrataListEntry))
324:
325: static UInt32 GetErrataBits(USBDeviceDescriptor *desc)
326: {
327: UInt32 vendID, deviceID, revisionID;
328: ErrataListEntry *entryPtr;
329: UInt32 i, errata = 0;
330:
331: // get this chips vendID, deviceID, revisionID
332: vendID = USBToHostWord(desc->vendor);
333: deviceID = USBToHostWord(desc->product);
334: revisionID = USBToHostWord(desc->devRel);
335: for(i=0, entryPtr = errataList; i<errataListLength; i++, entryPtr++){
336: if (vendID == entryPtr->vendID && deviceID == entryPtr->deviceID &&
337: revisionID >= entryPtr->revisionLo && revisionID <= entryPtr->revisionHi){
338: errata |= entryPtr->errata; // we match, add this errata to our list
339: }
340: }
341: return(errata);
342: }
343:
344: static Boolean bit(long value, long mask)
345: {
346: return( (value & mask) != 0);
347: }
348:
349: static Boolean immediateError(OSStatus err)
350: {
351: Boolean result;
352: result = false;
353: if((err != kUSBPending) && (err != noErr))
354: {
355: //Debugger();
356: result = true;
357: }
358: // return((err != kUSBPending) && (err != noErr) );
359: return(result );
360: }
361:
362: static void initPortVectors(portStatusChangeVector *changeHandler)
363: {
364: int vector;
365: for(vector = 0; vector < numChangeHandlers; vector++)
366: {
367: changeHandler[vector] = defaultPortVectors[vector];
368: }
369: }
370:
371: static void setDeadPortVectors(portStatusChangeVector *changeHandler)
372: {
373: int vector;
374: initPortVectors(changeHandler);
375: for(vector = 0; vector < numChangeHandlers; vector++)
376: {
377: changeHandler[vector].handler = defDoNothingChangeHandler;
378: }
379: }
380:
381:
382: static void setPortVector(portStatusChangeVector *changeHandler, void *routine, UInt32 condition)
383: {
384: int vector;
385: for(vector = 0; vector < numChangeHandlers; vector++)
386: {
387: if(condition == changeHandler[vector].bit)
388: {
389: if(routine == nil)
390: {
391: changeHandler[vector].handler = defaultPortVectors[vector].handler;
392: }
393: else
394: {
395: changeHandler[vector].handler = routine;
396: }
397: }
398: }
399: }
400:
401:
402: static void HubFatalError(perPort *pp, OSStatus err, unsigned char *str, UInt32 num)
403: {
404: // Debugger();
405: USBExpertFatalError(hubDevRef, err, str, num);
406:
407: if(!pp->state != kDead)
408: {
409: USBExpertStatus(hubDevRef, "******* DEVICE IS DEAD ********", 0);
410: if(pp->newDevRef != 0)
411: {
412: pp->pb.usbReference = pp->newDevRef;
413: pp->pb.usbCompletion = kUSBNoCallBack;
414: (void)USBHubDeviceRemoved(&pp->pb);
415: USBExpertRemoveDeviceDriver(pp->newDevRef);
416: }
417: }
418: pp->pb.usbRefcon = 0;
419: pp->delay = 0;
420: pp->state = kDead;
421: setDeadPortVectors(pp->changeHandler);
422: setPortVector(pp->changeHandler, deadConnectionChangeHandler, kHubPortConnection);
423: pp->newDevRef = 0;
424: pp->retries = kInitialRetries;
425: }
426:
427: OSStatus HubAreWeFinishedYet(void)
428: {
429: enum{
430: hubTimeOut = 256
431: };
432: USBPB pb={0,0, sizeof(USBPB), kUSBCurrentPBVersion, 0, 0, 0 ,0, 0, 0, 0, 0, 0, 0};
433: int i;
434: OSStatus retVal = noErr;
435: static Boolean finished;
436: static UInt32 firstFrame=0, askCount=0;
437:
438: if(finished)
439: {
440: return(kUSBNoErr);
441: }
442:
443: if(firstFrame == 0)
444: {
445: pb.usbCompletion = kUSBNoCallBack;
446: pb.usbReference = hubDevRef;
447: USBGetFrameNumberImmediate(&pb);
448: firstFrame = pb.usbFrame;
449: }
450: askCount++;
451:
452: // USBExpertStatus(hubDevRef, "Hub driver - Are we finished", hubDevRef);
453: if(intFrame == 0)
454: {
455: //USBExpertStatus(hubDevRef, "Hub driver - Not got to int handler yet", 0);
456: retVal = kUSBDeviceBusy;
457: }
458:
459: if(retVal == noErr)
460: {
461: if(intFrame == 0xffffffff)
462: {
463: //USBExpertStatus(hubDevRef, "Hub driver - Int already happened", 0);
464: }
465: else
466: {
467: pb.usbCompletion = kUSBNoCallBack;
468: pb.usbReference = hubDevRef;
469: if(USBGetFrameNumberImmediate(&pb) != noErr)
470: {
471: USBExpertStatus(hubDevRef, "Hub driver - Failed to get frame", pb.usbStatus);
472: intFrame = 0xffffffff;
473: pb.usbFrame = 0;
474: }
475: //USBExpertStatus(hubDevRef, "Hub driver - num frames", pb.usbFrame - intFrame);
476: if( (pb.usbFrame - intFrame) < hubTimeOut)
477: {
478: //USBExpertStatus(hubDevRef, "Hub driver - no timeout yet", 0);
479: retVal = kUSBDeviceBusy;
480: }
481: }
482: }
483: if(retVal == noErr)
484: {
485: //USBExpertStatus(hubDevRef, "Hub driver - check if any port busy", 0);
486: finished = true;
487: for(i = 1; i<=numPorts; i++)
488: {
489: if(ports[i].pb.usbRefcon != 0)
490: {
491: //USBExpertStatus(hubDevRef, "Hub driver - port busy:", i);
492: //USBExpertStatus(hubDevRef, "Hub driver - port ref:", ports[i].pb.usbRefcon);
493: finished = false;
494: }
495: }
496: }
497:
498: if(retVal != noErr)
499: {
500: finished = false;
501: return(retVal);
502: }
503: if(finished && (firstFrame != 0xffffffff) )
504: {
505: #if 0
506: if(intFrame == 0xffffffff)
507: {
508: USBExpertStatus(hubDevRef, "Hub driver - Finished Enumeration Int happened", hubDevRef);
509: }
510: else
511: {
512: USBExpertStatus(hubDevRef, "Hub driver - Finished Enumeration Timed out", hubDevRef);
513: }
514: #endif
515: // USBExpertStatus(hubDevRef, "Hub driver - Ask count", askCount);
516: pb.usbCompletion = kUSBNoCallBack;
517: pb.usbReference = hubDevRef;
518: USBGetFrameNumberImmediate(&pb);
519: // USBExpertStatus(hubDevRef, "Hub driver - Ask time", pb.usbFrame - firstFrame);
520: firstFrame = 0xffffffff;
521: }
522:
523: return(finished?kUSBNoErr:kUSBDeviceBusy);
524: }
525:
526:
527: static void detachDevice(USBPB *pb)
528: {
529: perPort *pp;
530: pp = (void *)pb; /* parameter block has been extended */
531:
532: if(pb->usbStatus != noErr)
533: {
534: if( (pp->onError == 0) && (pp->retries == 0) )
535: {
536: /* no idea what to do now?? */
537: USBExpertFatalError(hubDevRef, pb->usbStatus, pp->errorString, 1);
538:
539: pb->usbRefcon = 0;
540: /* Mark port as errored */
541: return;
542: }
543: else
544: {
545: USBExpertStatus(hubDevRef, pp->errorString, 2);
546: pb->usbRefcon = pp->onError;
547: pp->retries--;
548:
549: if(pp->retries == 1)
550: {
551: pp->delay = -3;
552: }
553: else if(pp->retries == 0)
554: {
555: pp->delay = -30;
556: }
557: /* we'll delay comming back to here */
558: pb->usbReqCount = 0;
559: /* pb->usbFlags = kUSBtaskTime */
560: // USBDelay(pb);
561: }
562:
563: }
564:
565: pp->onError = 0;
566: if(pp->delay != 0)
567: {
568: pp->delay = -pp->delay;
569: if(pp->delay > 0)
570: {
571: pb->usbReqCount = pp->delay;
572: USBDelay(pb);
573: return;
574: }
575: }
576:
577:
578: do{switch(pb->usbRefcon++)
579: {
580: case 1:
581: /* Power off the port */
582:
583: /* Maybe should only do this if there is power switching */
584:
585: pb->usbReference = hubRef;
586:
587: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
588: pb->usb.cntl.BRequest = kUSBRqClearFeature;
589: pb->usb.cntl.WValue = kUSBHubPortPowerFeature;
590: pb->usb.cntl.WIndex = pp->portIndex;
591: pb->usbReqCount = 0;
592: pb->usbBuffer = nil;
593:
594: noteError("Hub Driver - Powering off port");
595: if(immediateError(USBDeviceRequest(pb)))
596: {
597: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
598: }
599: break;
600:
601: case 2:
602: pb->usbReqCount = 100; // wait 100ms
603: USBDelay(pb);
604: break;
605:
606: case 3:
607: /* Power on the port */
608:
609: /* Maybe should only do this if there is power switching */
610: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
611: pb->usb.cntl.BRequest = kUSBRqSetFeature;
612: pb->usb.cntl.WValue = kUSBHubPortPowerFeature;
613: pb->usb.cntl.WIndex = pp->portIndex;
614: pb->usbReqCount = 0;
615: pb->usbBuffer = nil;
616:
617: noteError("Hub Driver - Powering on port again");
618: if(immediateError(USBDeviceRequest(pb)))
619: {
620: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
621: }
622: break;
623:
624: case 4:
625: pp->state = kDead;
626: pb->usbRefcon = 0;
627: break;
628:
629: default:
630: noteError("Hub dead Driver Error - Unused case in detach device");
631: USBExpertFatalError(hubDevRef, kUSBInternalErr, pp->errorString, pb->usbRefcon);
632: break;
633: }
634: break; /* only execute once, unless continue used */
635: }while(1); /* so case can be reentered with a continue */
636:
637:
638: }
639:
640:
641: static Boolean handleError(USBPB *pb)
642: {
643: perPort *pp;
644: pp = (void *)pb; /* parameter block has been extended */
645: if(pb->usbStatus != noErr)
646: {
647: if( (pb->usbStatus == kUSBAbortedError) && (pp->state != kDead) &(pp->state != kDeadDeviceZero) )
648: {
649: /* If the hub watchdog times this out, we may get an aborted error */
650: /* We do need to do something about this */
651: if(pp->state == kDeviceZero)
652: {
653: pb->usbStatus = noErr;
654: pp->state = kDeadDeviceZero;
655: return(false);
656: }
657: USBExpertFatalError(hubDevRef, hubDevRef, "Hub driver - Processing Aborted - Exiting", pb->usbStatus);
658: pb->usbRefcon = 0;
659: return(true);
660: }
661: if( (pp->onError == 0) || (pp->retries == 0) )
662: {
663: if(pp->state == kDeviceZero)
664: {
665: pp->state = kDeadDeviceZero;
666: return(false);
667: }
668: else if(pp->state == kSetAddress)
669: {
670: /* set address failed, need to turn off this device */
671: USBExpertStatus(hubDevRef, "Hub driver - set address failed, turning off device", 0);
672: pp->retries = kInitialRetries;
673: pb->usbRefcon = 1;
674: pb->usbStatus = noErr;
675: pp->state = kSetAddressFailed;
676: pb->usbFlags = 0;
677: pp->delay = 0;
678: pb->usbCompletion = detachDevice;
679: detachDevice(pb);
680: return(true);
681: }
682:
683: if(pp->state == kDead)
684: {
685: USBExpertFatalError(hubDevRef, pb->usbStatus, pp->errorString, 1);
686: }
687: else
688: {
689: /* no idea what to do now?? */
690: HubFatalError(pp, pb->usbStatus, pp->errorString, 1);
691: }
692: pb->usbRefcon = 0;
693: return(true);
694: }
695: else
696: {
697: USBExpertStatus(hubDevRef, pp->errorString, 2);
698: pb->usbRefcon = pp->onError;
699: pp->retries--;
700:
701: if(pp->retries == 1)
702: {
703: pp->delay = -3;
704: }
705: else if(pp->retries == 0)
706: {
707: pp->delay = -30;
708: }
709: }
710: }
711:
712: pp->onError = 0;
713:
714: if(pp->delay != 0)
715: {
716: pp->delay = -pp->delay;
717: if(pp->delay > 0)
718: {
719: pb->usbReqCount = pp->delay;
720: USBDelay(pb); // Should check for error here
721: return(true);
722: }
723: }
724:
725: return(false); /* tell function to carry on */
726: }
727:
728: static UInt32 resetChangeHandler(USBPB *pb)
729: {
730: perPort *pp;
731:
732: pp = (void *)pb; /* parameter block has been extended */
733:
734: do{switch(pb->usbRefcon >> kPortVectorStageShift)
735: {
736: case 1:
737: if(pp->state == kDeadDeviceZero)
738: {
739: pb->usbRefcon += kPortVectorStage1;
740: continue; // we need to fall forwards to set address
741: }
742:
743: if(bit(pp->portStatus.portFlags, kHubPortBeingReset))
744: {
745: USBExpertStatus(hubDevRef, "Hub Driver Error - Port not finished resetting, retrying", pb->usbRefcon);
746: // we should never be here, just wait for another status change int
747: return(kVectorContinueImmed);
748: }
749:
750: if(pp->state == kDeadDeviceZero)
751: {
752: pb->usbRefcon += kPortVectorStage1;
753: continue; // we need to fall forwards to set address
754: }
755:
756:
757: /* Now wait 10 ms after reset */
758: /* Do fancy things with perPort to shorten this when looping */
759:
760: pb->usbReqCount = 7; // This should be ready in 10ms
761: // However devices don't have to respond for another 10ms
762: // The set address below, won't arrive before 20ms
763: // Thats 17 + at least 3ms one each for each of 3 controlls
764:
765: //pb->usbReqCount = 10; // On root hub things are happening too quickly.
766: // I'll have to fix that, in the meantime amke it 20
767:
768: noteError("Hub Driver - Calling USBDelay");
769: //USBExpertStatus(hubDevRef, "Hub Driver - calling delay", pb->usbReqCount);
770: if(immediateError(USBDelay(pb)))
771: {
772: pb->usbRefcon += kPortVectorStage1;
773: resetChangeHandler(pb);
774: }
775: break;
776:
777: case 2:
778: if(pp->state == kDeadDeviceZero)
779: {
780: pb->usbRefcon += kPortVectorStage1;
781: continue; // we need to fall forwards to set address
782: }
783:
784: pb->usbFlags = ((pp->portStatus.portFlags & kHubPortSpeed) != 0); /* 1 if low speed */
785: //pb->usb.cntl.WValue = 8; // max packet size
786:
787: // This should make no difference. For 1.1 max packet size discovery
788: pb->usb.cntl.WValue = 64; // max packet size
789:
790: pb->usbReference = pp->newDevRef;
791:
792: noteError("Hub Driver Error - configuring endpoint zero");
793: if(immediateError(USBHubConfigurePipeZero(pb)))
794: {
795: USBExpertStatus(hubDevRef, "Config pipe zero failed", pb->usbStatus);
796: pb->usbRefcon += kPortVectorStage1;
797: resetChangeHandler(pb);
798: }
799: break;
800:
801: case 3:
802: if(pp->state == kDeadDeviceZero)
803: {
804: pb->usbRefcon += kPortVectorStage1;
805: continue; // we need to fall forwards to set address
806: }
807: pb->usbFlags = 0; // tidy up after above
808:
809: /* now do a device request to find out what it is */
810:
811:
812: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBStandard, kUSBDevice);
813: pb->usb.cntl.BRequest = kUSBRqGetDescriptor;
814: pb->usb.cntl.WValue = (kUSBDeviceDesc << 8) + 0/*index*/;
815: pb->usb.cntl.WIndex = 0;
816: //pb->usbReqCount = OFFSET(USBDeviceDescriptor, descEnd);
817:
818: // For 1.1 max packet size discovery, we're relying on numConf being zero here
819: pb->usbReqCount = 8;
820: pp->desc.numConf = 0; // This is the flag to read the rest.
821: // Do not forget numConf for 1.1 discovery, or take out check below
822:
823: /* did we get here because the get descriptor failed? */
824: if(pb->usbStatus == kUSBOverRunErr)
825: { /* endpoint zero max packet too large. Read first */
826: /* 8 bytes to get the value you need */
827: USBExpertStatus(hubDevRef, "Hub driver - overrun error reading device descriptor:", pb->usbActCount);
828: pb->usbReqCount = 8;
829: pp->desc.numConf = 0; // make a note to read all of this
830: }
831:
832: pb->usbBuffer = &pp->desc;
833:
834: pp->onError = pb->usbRefcon-kPortVectorStage1; /* do a retry on error */
835: /* the get descriptor seems to screw up most often */
836: noteError("Hub Driver Error - kUSBRqGetDescriptor (get device descriptor after a SetAddress)");
837: if(immediateError(USBDeviceRequest(pb)))
838: {
839: pb->usbRefcon += kPortVectorStage1;
840: resetChangeHandler(pb);
841: }
842: break;
843:
844: case 4:
845: if( (hubDesc.removablePortFlags[pp->portByte] & pp->portMask) != 0)
846: {
847: pb->usbOther = powerForCaptive;
848: }
849: else
850: {
851: pb->usbOther = selfPowerGood?kUSB500mAAvailable:kUSB100mAAvailable;
852: }
853:
854:
855: /* Now address the device */
856:
857: pb->usb.cntl.WValue = pp->desc.maxPacketSize;
858: pp->newDevRef = 0; // if set address fails, don't try to remove old
859: pp->onError = pb->usbRefcon; /* Go back to start, via next case */
860: pb->usbFlags = ((pp->portStatus.portFlags & kHubPortSpeed) != 0); /* 1 if low speed */
861: pb->usbFlags |= kUSBHubPower;
862:
863: pp->state = kSetAddress; /* If this fails, detatch */
864: noteError("Hub Driver Error - Setting the device address");
865: if(immediateError(USBHubSetAddress(pb)))
866: {
867: pb->usbRefcon += kPortVectorStage1;
868: resetChangeHandler(pb);
869: }
870:
871: break;
872:
873: case 5:
874: if( (pp->state == kDeadDeviceZero) || (pb->usbReference == 0) )
875: {
876: noteError("Hub Driver Error - dead set address");
877: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
878: return(kVectorfinishedImmed);
879: }
880:
881: pb->usbFlags = 0;
882: pp->state = kNormal; /* no longer need special handling to avoid deadlock */
883:
884: if(pb->usbStatus != noErr)
885: {
886: /* an error setting the addres, so go back and try resetting again */
887: pb->usbRefcon = 1;
888: pb->usbStatus = noErr;
889: pb->usbCompletion = hubAddDeviceHandler;
890: pb->usbReqCount = 1;
891: setPortVector(pp->changeHandler, 0, kHubPortBeingReset);
892: USBDelay(pb);
893: break;
894: }
895:
896: /* refernce is now new device ref, no longer dev zero */
897:
898: pp->newDevRef = pb->usbReference;
899:
900: if(pp->desc.numConf == 0) // don't have full descriptor, try again */
901: {
902: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBStandard, kUSBDevice);
903: pb->usb.cntl.BRequest = kUSBRqGetDescriptor;
904: pb->usb.cntl.WValue = (kUSBDeviceDesc << 8) + 0/*index*/;
905: pb->usb.cntl.WIndex = 0;
906: pb->usbReqCount = OFFSET(USBDeviceDescriptor, descEnd);
907: pb->usbBuffer = &pp->desc;
908:
909: pp->onError = pb->usbRefcon-kPortVectorStage1; /* do a retry on error */
910: /* the get descriptor seems to screw up most often */
911: noteError("Hub Driver Error - kUSBRqGetDescriptor (get device descriptor after a SetAddress)");
912: if(immediateError(USBDeviceRequest(pb)))
913: {
914: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
915: }
916: }
917: else
918: {
919: pb->usbRefcon += kPortVectorStage1;
920: continue;
921: }
922: break;
923:
924: case 6:
925:
926: /* FInally use the data gathered */
927: USBExpertInstallDeviceDriver(pb->usbReference, &pp->desc, hubDevRef, pp->portIndex, pb->usbOther);
928: /* Call to the expert */
929:
930: setPortVector(pp->changeHandler, 0, kHubPortBeingReset);
931: return(kVectorfinishedImmed);
932: break;
933:
934: default:
935: noteError("Hub Driver Error - Unused case in reset change handler");
936: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
937: break;
938: }
939: break; /* only execute once, unless continue used */
940: }while(1); /* so case can be reentered with a continue */
941:
942: return(kVectorNotfinished);
943: }
944:
945: static void hubAddDeviceHandler(USBPB *pb)
946: {
947: perPort *pp;
948:
949: if(handleError(pb))
950: return;
951: pp = (void *)pb; /* parameter block has been extended */
952:
953: do{switch(pb->usbRefcon++)
954: {
955:
956: case 1:
957: pb->usbReference = hubRef;
958:
959: /* Check if the port is suspended */
960: if(bit(pp->portStatus.portFlags, kHubPortSuspend))
961: {
962: /* resume the port */
963: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
964: pb->usb.cntl.BRequest = kUSBRqClearFeature;
965: pb->usb.cntl.WValue = kUSBHubPortSuspecdFeature;
966: pb->usb.cntl.WIndex = pp->portIndex;
967: pb->usbReqCount = 0;
968: pb->usbBuffer = nil;
969:
970: noteError("Hub Driver - kUSBRqClearFeature (clearing 'port suspend' feature)");
971: if(immediateError(USBDeviceRequest(pb)))
972: {
973: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
974: }
975: }
976: else
977: {
978: continue;
979: }
980:
981: break;
982:
983: case 2:
984: /* Tell the USB to add the device */
985: // pb->usbFlags = ((pp->portStatus.portFlags & kHubPortSpeed) != 0); /* 1 if low speed */
986: // Speed no longer set in add device
987:
988: noteError("Hub Driver - Device found, calling USBHubAddDevice");
989: USBExpertStatus(hubDevRef, "Hub Driver - Device found, calling USBHubAddDevice. Port", pp->portIndex);
990: if(immediateError(USBHubAddDevice(pb)))
991: {
992: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
993: }
994: break;
995:
996: case 3:
997: pb->usbFlags = 0;
998: /* We're called back when its time to reset */
999: pp->state = kDeviceZero; /* remeber to clean up if fails */
1000:
1001: /* remember the ref to the new device (as dev zero) */
1002: pp->newDevRef = pb->usbReference;
1003:
1004: pb->usbReference = hubRef;
1005:
1006: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
1007: pb->usb.cntl.BRequest = kUSBRqSetFeature;
1008: pb->usb.cntl.WValue = kUSBHubPortResetFeature;
1009: pb->usb.cntl.WIndex = pp->portIndex;
1010: pb->usbReqCount = 0;
1011: pb->usbBuffer = nil;
1012:
1013: setPortVector(pp->changeHandler, resetChangeHandler, kHubPortBeingReset);
1014:
1015: noteError("Hub Driver Error - kUSBRqSetFeature (resetting port)");
1016: if(immediateError(USBDeviceRequest(pb)))
1017: {
1018: hubAddDeviceHandler(pb);
1019: }
1020:
1021: break;
1022:
1023: case 4:
1024: pb->usbRefcon = 0; /* this continues via the status change handler */
1025: break;
1026:
1027: default:
1028: noteError("Hub Driver Error - Unused case in add device");
1029: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
1030: break;
1031: }
1032: break; /* only execute once, unless continue used */
1033: }while(1); /* so case can be reentered with a continue */
1034: }
1035:
1036: static UInt32 doPortResetChangeHandler(USBPB *pb)
1037: {
1038: perPort *pp;
1039:
1040: pp = (void *)pb; /* parameter block has been extended */
1041:
1042: do{switch(pb->usbRefcon >> kPortVectorStageShift)
1043: {
1044: case 1:
1045: if(pp->state == kDeadDeviceZero)
1046: {
1047: pb->usbRefcon += kPortVectorStage1;
1048: continue; // we need to fall forwards to set address
1049: }
1050:
1051: if(bit(pp->portStatus.portFlags, kHubPortBeingReset))
1052: {
1053: USBExpertStatus(hubDevRef, "Hub Driver Error - Port not finished resetting, retrying", pb->usbRefcon);
1054: // we should never be here, just wait for another status change int
1055: return(kVectorContinueImmed);
1056: }
1057:
1058: if(pp->state == kDeadDeviceZero)
1059: {
1060: pb->usbRefcon += kPortVectorStage1;
1061: continue; // we need to fall forwards to set address
1062: }
1063:
1064:
1065: /* Now wait 10 ms after reset */
1066: /* Do fancy things with perPort to shorten this when looping */
1067:
1068: pb->usbReqCount = 7; // This should be ready in 10ms
1069: // However devices don't have to respond for another 10ms
1070: // The set address below, won't arrive before 20ms
1071: // Thats 17 + at least 3ms one each for each of 3 controlls
1072:
1073: //pb->usbReqCount = 10; // On root hub things are happening too quickly.
1074: // I'll have to fix that, in the meantime amke it 20
1075:
1076: noteError("Hub Driver - Calling USBDelay");
1077: //USBExpertStatus(hubDevRef, "Hub Driver - calling delay", pb->usbReqCount);
1078: if(immediateError(USBDelay(pb)))
1079: {
1080: pb->usbRefcon += kPortVectorStage1;
1081: doPortResetChangeHandler(pb);
1082: }
1083: break;
1084:
1085: case 2:
1086: if(pp->state == kDeadDeviceZero)
1087: {
1088: pb->usbRefcon += kPortVectorStage1;
1089: continue; // we need to fall forwards to set address
1090: }
1091:
1092: pb->usbFlags = ((pp->portStatus.portFlags & kHubPortSpeed) != 0); /* 1 if low speed */
1093: pb->usb.cntl.WValue = 8; // max packet size
1094:
1095: pb->usbReference = pp->devZeroRef;
1096:
1097: noteError("Hub Driver Error - configuring endpoint zero");
1098: if(immediateError(USBHubConfigurePipeZero(pb)))
1099: {
1100: USBExpertStatus(hubDevRef, "Config pipe zero failed", pb->usbStatus);
1101: pb->usbRefcon += kPortVectorStage1;
1102: doPortResetChangeHandler(pb);
1103: }
1104: break;
1105:
1106: case 3:
1107: if(pp->state == kDeadDeviceZero)
1108: {
1109: pb->usbRefcon += kPortVectorStage1;
1110: continue; // we need to fall forwards to set address
1111: }
1112: pb->usbFlags = 0; // tidy up after above
1113:
1114: /* now do a device request to find out what it is */
1115:
1116:
1117: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBStandard, kUSBDevice);
1118: pb->usb.cntl.BRequest = kUSBRqGetDescriptor;
1119: pb->usb.cntl.WValue = (kUSBDeviceDesc << 8) + 0/*index*/;
1120: pb->usb.cntl.WIndex = 0;
1121: pb->usbReqCount = OFFSET(USBDeviceDescriptor, descEnd);
1122:
1123: /* did we get here because the get descriptor failed? */
1124: if(pb->usbStatus == kUSBOverRunErr)
1125: { /* endpoint zero max packet too large. Read first */
1126: /* 8 bytes to get the value you need */
1127: USBExpertStatus(hubDevRef, "Hub driver - overrun error reading device descriptor:", pb->usbActCount);
1128: pb->usbReqCount = 8;
1129: pp->desc.numConf = 0; // make a note to read all of this
1130: }
1131:
1132: pb->usbBuffer = &pp->desc;
1133:
1134: pp->onError = pb->usbRefcon-kPortVectorStage1; /* do a retry on error */
1135: /* the get descriptor seems to screw up most often */
1136: noteError("Hub Driver Error - kUSBRqGetDescriptor (get device descriptor after a SetAddress)");
1137: if(immediateError(USBDeviceRequest(pb)))
1138: {
1139: pb->usbRefcon += kPortVectorStage1;
1140: doPortResetChangeHandler(pb);
1141: }
1142: break;
1143:
1144: case 4:
1145: if( (hubDesc.removablePortFlags[pp->portByte] & pp->portMask) != 0)
1146: {
1147: pb->usbOther = powerForCaptive;
1148: }
1149: else
1150: {
1151: pb->usbOther = selfPowerGood?kUSB500mAAvailable:kUSB100mAAvailable;
1152: }
1153:
1154: /* Now address the device */
1155: pb->usbReference = pp->newDevRef;
1156: pb->usb.cntl.WValue = pp->desc.maxPacketSize;
1157: pp->devZeroRef = 0; // if set address fails, don't try to remove old
1158: pp->onError = pb->usbRefcon; /* Go back to start, via next case */
1159: pb->usbFlags = ((pp->portStatus.portFlags & kHubPortSpeed) != 0); /* 1 if low speed */
1160: pb->usbFlags |= kUSBHubPower | kUSBHubReaddress;
1161:
1162: pp->state = kSetAddress; /* If this fails, detatch */
1163: noteError("Hub Driver Error - Setting the device address");
1164: if(immediateError(USBHubSetAddress(pb)))
1165: {
1166: pb->usbRefcon += kPortVectorStage1;
1167: doPortResetChangeHandler(pb);
1168: }
1169:
1170: break;
1171:
1172: case 5:
1173: if( (pp->state == kDeadDeviceZero) || (pb->usbReference == 0) )
1174: {
1175: /* If you want to try again with dead devices this is the place to do it */
1176: noteError("Hub Driver Error - dead set address");
1177: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1178: return(kVectorfinishedImmed);
1179: }
1180:
1181: pb->usbFlags = 0;
1182: pp->state = kNormal; /* no longer need special handling to avoid deadlock */
1183:
1184: if(pb->usbStatus != noErr)
1185: {
1186: pb->usbRefcon += kPortVectorStage1;
1187: continue; // we need to fall forwards to set address
1188: }
1189:
1190: /* refernce is now new device ref, no longer dev zero */
1191:
1192: pp->devZeroRef = pb->usbReference;
1193:
1194: if(pp->desc.numConf == 0) // don't have full descriptor, try again */
1195: {
1196: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBStandard, kUSBDevice);
1197: pb->usb.cntl.BRequest = kUSBRqGetDescriptor;
1198: pb->usb.cntl.WValue = (kUSBDeviceDesc << 8) + 0/*index*/;
1199: pb->usb.cntl.WIndex = 0;
1200: pb->usbReqCount = OFFSET(USBDeviceDescriptor, descEnd);
1201: pb->usbBuffer = &pp->desc;
1202:
1203: pp->onError = pb->usbRefcon-kPortVectorStage1; /* do a retry on error */
1204: /* the get descriptor seems to screw up most often */
1205: noteError("Hub Driver Error - kUSBRqGetDescriptor (get device descriptor after a SetAddress)");
1206: if(immediateError(USBDeviceRequest(pb)))
1207: {
1208: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1209: }
1210: }
1211: else
1212: {
1213: pb->usbRefcon += kPortVectorStage1;
1214: continue;
1215: }
1216: break;
1217:
1218: case 6:
1219:
1220: /* FInally use the data gathered */
1221: setPortVector(pp->changeHandler, 0, kHubPortBeingReset);
1222: pp->portRequestPB->usbStatus = pb->usbStatus;
1223: pb = pp->portRequestPB;
1224: pp->portRequestPB = nil; // The port is now free
1225:
1226: if( (pb->usbCompletion != nil) || (pb->usbCompletion != (void *)-1) )
1227: {
1228: (*pb->usbCompletion)(pb);
1229: }
1230: return(kVectorfinishedImmed);
1231: break;
1232:
1233: default:
1234: noteError("Hub Driver Error - Unused case in port reset change handler");
1235: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
1236: break;
1237: }
1238: break; /* only execute once, unless continue used */
1239: }while(1); /* so case can be reentered with a continue */
1240:
1241: return(kVectorNotfinished);
1242: }
1243:
1244: static void doPortResetHandler(USBPB *pb)
1245: {
1246: perPort *pp;
1247:
1248: if(handleError(pb))
1249: return;
1250: pp = (void *)pb; /* parameter block has been extended */
1251:
1252: do{switch(pb->usbRefcon++)
1253: {
1254:
1255: case 1:
1256: pb->usbReference = hubRef;
1257:
1258: /* Check if the port is suspended */
1259: if(bit(pp->portStatus.portFlags, kHubPortSuspend))
1260: {
1261: /* resume the port */
1262: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
1263: pb->usb.cntl.BRequest = kUSBRqClearFeature;
1264: pb->usb.cntl.WValue = kUSBHubPortSuspecdFeature;
1265: pb->usb.cntl.WIndex = pp->portIndex;
1266: pb->usbReqCount = 0;
1267: pb->usbBuffer = nil;
1268:
1269: noteError("Hub Driver - kUSBRqClearFeature (clearing 'port suspend' feature)");
1270: if(immediateError(USBDeviceRequest(pb)))
1271: {
1272: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1273: }
1274: }
1275: else
1276: {
1277: continue;
1278: }
1279:
1280: break;
1281:
1282: case 2:
1283: /* Tell the USB to add the device */
1284: // pb->usbFlags = ((pp->portStatus.portFlags & kHubPortSpeed) != 0); /* 1 if low speed */
1285: // Speed no longer set in add device
1286:
1287: noteError("Hub Driver - Resetting device");
1288: USBExpertStatus(hubDevRef, "Hub Driver - Waiting to reset device", 0);
1289: if(immediateError(USBHubAddDevice(pb)))
1290: {
1291: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1292: }
1293: break;
1294:
1295: case 3:
1296: pb->usbFlags = 0;
1297: /* We're called back when its time to reset */
1298: pp->state = kDeviceZero; /* remeber to clean up if fails */
1299:
1300: /* remember the ref to the new device (as dev zero) */
1301: pp->devZeroRef = pb->usbReference;
1302:
1303: pb->usbReference = hubRef;
1304:
1305: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
1306: pb->usb.cntl.BRequest = kUSBRqSetFeature;
1307: pb->usb.cntl.WValue = kUSBHubPortResetFeature;
1308: pb->usb.cntl.WIndex = pp->portIndex;
1309: pb->usbReqCount = 0;
1310: pb->usbBuffer = nil;
1311:
1312: setPortVector(pp->changeHandler, doPortResetChangeHandler, kHubPortBeingReset);
1313:
1314: noteError("Hub Driver Error - kUSBRqSetFeature (resetting port)");
1315: if(immediateError(USBDeviceRequest(pb)))
1316: {
1317: doPortResetHandler(pb);
1318: }
1319:
1320: break;
1321:
1322: case 4:
1323: pb->usbRefcon = 0; /* this continues via the status change handler */
1324: break;
1325:
1326: default:
1327: noteError("Hub Driver Error - Unused case in reset device");
1328: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
1329: break;
1330: }
1331: break; /* only execute once, unless continue used */
1332: }while(1); /* so case can be reentered with a continue */
1333: }
1334:
1335: static void hubStatusChangeHandler(USBPB *pb)
1336: {
1337: perPort *pp;
1338: static void *oldHandler;
1339: static UInt32 oldRefcon;
1340: static USBReference oldRef;
1341:
1342: if(pb->usbCompletion != hubStatusChangeHandler)
1343: {
1344: oldHandler = pb->usbCompletion;
1345: pb->usbCompletion = hubStatusChangeHandler;
1346: oldRefcon = pb->usbRefcon;
1347: pb->usbRefcon = 1;
1348: oldRef = pb->usbReference;
1349: pb->usbReference = hubRef;
1350: USBExpertStatus(hubDevRef, "Hub Status change",0);
1351: }
1352:
1353: pp = (void *)pb; /* parameter block has been extended */
1354: if(handleError(pb))
1355: return;
1356:
1357: do{switch(pb->usbRefcon++)
1358: {
1359: case 1:
1360: /* Now get hub status */
1361: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBDevice);
1362: pb->usb.cntl.BRequest = kUSBRqGetStatus;
1363: pb->usb.cntl.WValue = 0;
1364: pb->usb.cntl.WIndex = 0;
1365: pb->usbReqCount = sizeof(hubStatus);
1366: pb->usbBuffer = &hubStatus;
1367:
1368: noteError("Hub Driver Error - kUSBRqGetStatus (get status before turning on ports)");
1369: if(immediateError(USBDeviceRequest(pb)))
1370: {
1371: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1372: }
1373:
1374: break;
1375:
1376: case 2:
1377: hubStatus.status = USBToHostWord(hubStatus.status);
1378: hubStatus.change = USBToHostWord(hubStatus.change);
1379: if(bit(hubStatus.change, kHubLocalPowerStatusChange) )
1380: {
1381: USBExpertStatus(hubDevRef, "Hub Driver - Local Power Status Change detected",0);
1382: /* Reset the change enable status */
1383: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBDevice);
1384: pb->usb.cntl.BRequest = kUSBRqClearFeature;
1385: pb->usb.cntl.WValue = kUSBHubLocalPowerChangeFeature;
1386: pb->usb.cntl.WIndex = 0;
1387: pb->usbReqCount = 0;
1388: pb->usbBuffer = nil;
1389:
1390: noteError("Hub Driver Error - kUSBRqClearFeature (clear 'hub local power change' feature)");
1391: if(immediateError(USBDeviceRequest(pb)))
1392: {
1393: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1394: }
1395: }
1396: else
1397: {
1398: pb->usbRefcon+=2; /* Skip the next status */
1399: continue; /* Carry on with next case */
1400: }
1401: break;
1402:
1403: case 3:
1404: /* Now get hub status */
1405: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBDevice);
1406: pb->usb.cntl.BRequest = kUSBRqGetStatus;
1407: pb->usb.cntl.WValue = 0;
1408: pb->usb.cntl.WIndex = 0;
1409: pb->usbReqCount = sizeof(hubStatus);
1410: pb->usbBuffer = &hubStatus;
1411:
1412: noteError("Hub Driver Error - kUSBRqGetStatus (get status before turning on ports)");
1413: if(immediateError(USBDeviceRequest(pb)))
1414: {
1415: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1416: }
1417: break;
1418:
1419: case 4:
1420: hubStatus.status = USBToHostWord(hubStatus.status);
1421: hubStatus.change = USBToHostWord(hubStatus.change);
1422: continue;
1423: break;
1424:
1425: case 5:
1426: if(bit(hubStatus.change, kHubOverCurrentIndicatorChange) )
1427: {
1428: USBExpertStatus(hubDevRef, "Hub Driver - OverCurrent Indicator Change detected",0);
1429: /* Reset the change enable status */
1430: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBDevice);
1431: pb->usb.cntl.BRequest = kUSBRqClearFeature;
1432: pb->usb.cntl.WValue = kUSBHubOverCurrentChangeFeature;
1433: pb->usb.cntl.WIndex = 0;
1434: pb->usbReqCount = 0;
1435: pb->usbBuffer = nil;
1436:
1437: noteError("Hub Driver Error - kUSBRqClearFeature (clear 'hub local power change' feature)");
1438: if(immediateError(USBDeviceRequest(pb)))
1439: {
1440: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1441: }
1442: }
1443: else
1444: {
1445: pb->usbRefcon+=2; /* Skip the next status */
1446: continue; /* Carry on with next case */
1447: }
1448: break;
1449:
1450: case 6:
1451: /* Now get hub status */
1452: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBDevice);
1453: pb->usb.cntl.BRequest = kUSBRqGetStatus;
1454: pb->usb.cntl.WValue = 0;
1455: pb->usb.cntl.WIndex = 0;
1456: pb->usbReqCount = sizeof(hubStatus);
1457: pb->usbBuffer = &hubStatus;
1458:
1459: noteError("Hub Driver Error - kUSBRqGetStatus (get status before turning on ports)");
1460: if(immediateError(USBDeviceRequest(pb)))
1461: {
1462: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1463: }
1464: break;
1465:
1466: case 7:
1467: hubStatus.status = USBToHostWord(hubStatus.status);
1468: hubStatus.change = USBToHostWord(hubStatus.change);
1469: continue;
1470: break;
1471:
1472: case 8:
1473: pb->usbCompletion = oldHandler;
1474: pb->usbRefcon = oldRefcon;
1475: pb->usbReference = oldRef;
1476:
1477: pb->usbReqCount = 10;
1478: USBExpertStatus(hubDevRef, "Hub Driver - calling delay reentering poll loop", 10);
1479: USBDelay(pb);
1480: break;
1481:
1482: default:
1483: noteError("Hub Driver Error - Unused case in hub status change handler");
1484: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
1485: break;
1486: }
1487: break; /* only execute once, unless continue used */
1488: }while(1); /* so case can be reentered with a continue */
1489: }
1490:
1491:
1492: static UInt32 defDoNothingChangeHandler(USBPB *pb)
1493: {
1494: pb = 0;
1495: return(kVectorContinueImmed);
1496: }
1497:
1498: static UInt32 deadConnectionChangeHandler(USBPB *pb)
1499: {
1500: perPort *pp;
1501: pp = (void *)pb; /* parameter block has been extended */
1502: if(!bit(pp->portStatus.portFlags, kHubPortConnection))
1503: {
1504: USBExpertStatus(hubDevRef, "Hub dead driver - disconnect", 0);
1505: pp->state = kNormal;
1506: pp->retries = kInitialRetries;
1507: initPortVectors(pp->changeHandler);
1508: pp->delay = 0;
1509: }
1510: return(kVectorContinueImmed);
1511: }
1512:
1513: static UInt32 defOverCrntChangeHandler(USBPB *pb)
1514: {
1515: perPort *pp;
1516: pp = (void *)pb; /* parameter block has been extended */
1517: USBExpertStatus(hubDevRef, "Hub Driver - Over current change notification", 0);
1518: pp->state = kDead;
1519: return(kVectorContinueImmed);
1520: }
1521:
1522: static UInt32 defResetChangeHandler(USBPB *pb)
1523: {
1524: perPort *pp;
1525: pp = (void *)pb; /* parameter block has been extended */
1526: USBExpertStatus(hubDevRef, "Hub Driver - Resett change notification", 0);
1527: pp->state = kDead;
1528: return(kVectorContinueImmed);
1529: }
1530:
1531: static UInt32 defSuspendChangeHandler(USBPB *pb)
1532: {
1533: perPort *pp;
1534: pp = (void *)pb; /* parameter block has been extended */
1535: USBExpertStatus(hubDevRef, "Hub Driver - Resett change notification", 0);
1536: return(kVectorContinueImmed);
1537: }
1538:
1539: static UInt32 defEndableChangeHandler(USBPB *pb)
1540: {
1541: perPort *pp;
1542: pp = (void *)pb; /* parameter block has been extended */
1543: do{switch(pb->usbRefcon >> kPortVectorStageShift)
1544: {
1545: case 1:
1546: if(!bit(pp->portStatus.portFlags, kHubPortEnabled) &&
1547: !bit(pp->portStatus.portChangeFlags, kHubPortConnection) )
1548: {
1549: /* The hub gave us an enable status change and we're now disabled, strange */
1550: /* Cosmo does this sometimes, try Re-enabling the port */
1551: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
1552: pb->usb.cntl.BRequest = kUSBRqSetFeature;
1553: pb->usb.cntl.WValue = kUSBHubPortEnablenFeature;
1554: pb->usb.cntl.WIndex = pp->portIndex;
1555: pb->usbReqCount = 0;
1556: pb->usbBuffer = nil;
1557:
1558: USBExpertStatus(hubDevRef, "Hub driver - re-enabling dead port", pp->portIndex);
1559: noteError("Hub Driver Error - kUSBRqSetFeature (trying to re-enable port)");
1560: if(immediateError(USBDeviceRequest(pb)))
1561: {
1562: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1563: }
1564: }
1565: else
1566: {
1567: return(kVectorContinueImmed);
1568: }
1569: break;
1570:
1571: case 2:
1572: return(kVectorContinueImmed);
1573: break;
1574:
1575: default:
1576: noteError("Hub Driver Error - Unused case in enable change handler");
1577: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
1578: break;
1579: }
1580: break; /* only execute once, unless continue used */
1581: }while(1); /* so case can be reentered with a continue */
1582: return(kVectorNotfinished);
1583: }
1584:
1585: static UInt32 defConnectionChangeHandler(USBPB *pb)
1586: {
1587: perPort *pp;
1588: OSStatus err;
1589:
1590: pp = (void *)pb; /* parameter block has been extended */
1591: do{switch(pb->usbRefcon >> kPortVectorStageShift)
1592: {
1593: case 1:
1594: pb->usbReqCount = 97; /* Power on wait 100ms, plus at least 3 control requests */
1595: pb->usbFlags = 0;
1596: pb->usbStatus = noErr;
1597:
1598: //USBExpertStatus(hubDevRef, "Hub Driver - PS2 calling delay", 100);
1599: noteError("Hub Driver Error - delaying before adding device");
1600: if(immediateError(USBDelay(pb)))
1601: {
1602: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1603: }
1604: break;
1605:
1606: case 2:
1607:
1608: /* If we get to here, there was a connection change */
1609: /* if we already have a device it must have been disconnected */
1610: /* at sometime. We should kill it before serviceing a connect event */
1611: if(pp->newDevRef != 0)
1612: { /* already removed, dead device?? */
1613: pb->usbReference = pp->newDevRef;
1614: USBExpertStatus(hubDevRef, "Hub driver - Removing dead device:", pb->usbRefcon);
1615: noteError("Hub Driver Error - removing dead device");
1616: err = USBHubDeviceRemoved(pb);
1617: if(immediateError(err))
1618: { /* hub error procedures not needed for this */
1619: USBExpertFatalError(hubDevRef, pb->usbStatus, pp->errorString, 0);
1620: break;
1621: }
1622: if(err == noErr)
1623: { /* completed immediatly */
1624: pb->usbRefcon += kPortVectorStage1;
1625: continue;
1626: }
1627: }
1628: else
1629: {
1630: pb->usbRefcon += kPortVectorStage1;
1631: continue;
1632: }
1633: break;
1634:
1635: case 3:
1636:
1637: if(pp->newDevRef != 0)
1638: { /* this bit transplanted from end of case above */
1639: USBExpertRemoveDeviceDriver(pp->newDevRef);
1640: pp->newDevRef = 0;
1641:
1642:
1643: pp->delay = 0;
1644: pp->retries = kInitialRetries;
1645: /* Disconnection on the port */
1646: }
1647:
1648: // BT 23Jul98 Check port again after delay. Get bounced connections
1649: /* Do a port status request on current port */
1650: pb->usbReference = hubRef;
1651: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBOther);
1652: pb->usb.cntl.BRequest = kUSBRqGetStatus;
1653: pb->usb.cntl.WValue = 0; /* Standard type 0 and index 0 */
1654: pb->usb.cntl.WIndex = pp->portIndex;
1655: pb->usbReqCount = sizeof(USBHubPortStatus);
1656: pb->usbBuffer = &pp->portStatus;
1657:
1658: noteError("Hub Driver Error - kUSBRqGetStatus (after delay)");
1659: if(immediateError(USBDeviceRequest(pb)))
1660: {
1661: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1662: }
1663: break;
1664:
1665: case 4:
1666: pp->portStatus.portChangeFlags = USBToHostWord(pp->portStatus.portChangeFlags);
1667: pp->portStatus.portFlags = USBToHostWord(pp->portStatus.portFlags);
1668:
1669: // USBExpertStatus(hubDevRef, "Hub driver - port status", pp->portStatus.portFlags);
1670: // USBExpertStatus(hubDevRef, "Hub driver - port change", pp->portStatus.portChangeFlags);
1671: if(bit(pp->portStatus.portChangeFlags, kHubPortConnection) )
1672: {
1673: USBExpertStatus(hubDevRef, "Hub driver - Connection bounce:", pb->usbReference);
1674:
1675: return(kVectorContinueImmed);
1676: }
1677:
1678: if( bit(pp->portStatus.portFlags, kHubPortConnection) )
1679: { /* We have a connection on this port */
1680:
1681: pb->usbCompletion = hubAddDeviceHandler;
1682: pb->usbRefcon = 1;
1683: pb->usbStatus = noErr;
1684: pb->usbFlags = 0;
1685:
1686: hubAddDeviceHandler(pb);
1687: }
1688: else
1689: {
1690: return(kVectorfinishedImmed);
1691: }
1692: break;
1693:
1694: default:
1695: noteError("Hub Driver Error - Unused case in connection change handler");
1696: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
1697: break;
1698: }
1699: break; /* only execute once, unless continue used */
1700: }while(1); /* so case can be reentered with a continue */
1701: return(kVectorNotfinished);
1702: }
1703:
1704:
1705: static void portStatusChangedHandler(USBPB *pb)
1706: {
1707: perPort *pp;
1708: int which, ret;
1709: static getDescLoop;
1710:
1711: pp = (void *)pb; /* parameter block has been extended */
1712:
1713: if(handleError(pb))
1714: return;
1715:
1716: do{switch( (pb->usbRefcon++) & kPortHandlerStageMask)
1717: {
1718: case 1:
1719:
1720: pb->usbReference = hubRef;
1721:
1722: /* Do a port status request on current port */
1723: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBOther);
1724: pb->usb.cntl.BRequest = kUSBRqGetStatus;
1725: pb->usb.cntl.WValue = 0; /* Standard type 0 and index 0 */
1726: pb->usb.cntl.WIndex = pp->portIndex;
1727: pb->usbReqCount = sizeof(USBHubPortStatus);
1728: pb->usbBuffer = &pp->portStatus;
1729:
1730: pb->usbFlags = 0; // These were getting set during error processing
1731:
1732: noteError("Hub Driver Error - kUSBRqGetStatus (first after port status change)");
1733: if(immediateError(USBDeviceRequest(pb)))
1734: {
1735: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1736: }
1737: break;
1738:
1739: case 2:
1740: pp->portStatus.portChangeFlags = USBToHostWord(pp->portStatus.portChangeFlags);
1741: pp->portStatus.portFlags = USBToHostWord(pp->portStatus.portFlags);
1742:
1743: getDescLoop = (pb->usbRefcon & kPortHandlerStageMask);
1744: continue;
1745: break;
1746:
1747: case 3:
1748: pb->usbRefcon &= kPortHandlerStageMask;
1749:
1750: for(which = 0; which<numChangeHandlers; which++)
1751: {
1752: if( (pp->portStatus.portChangeFlags & pp->changeHandler[which].bit) != 0 )
1753: {
1754: pb->usbRefcon += which*kPortWhichVector1;
1755: break;
1756: }
1757: }
1758: if(which >= numChangeHandlers)
1759: {
1760: pb->usbRefcon = 0; // Handled all changed bits
1761: }
1762: else
1763: {
1764: continue;
1765: }
1766: break;
1767:
1768: case 4:
1769: which = (pb->usbRefcon & kPortVectorStageMask) >> kPortWhichVectorShift;
1770:
1771: /* Reset the changed status */
1772: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
1773: pb->usb.cntl.BRequest = kUSBRqClearFeature;
1774: pb->usb.cntl.WValue = pp->changeHandler[which].clearFeature;
1775: pb->usb.cntl.WIndex = pp->portIndex;
1776: pb->usbReqCount = 0;
1777: pb->usbBuffer = nil;
1778:
1779: noteError("Hub Driver Error - kUSBRqClearFeature (clear port vector bit feature)");
1780: if(immediateError(USBDeviceRequest(pb)))
1781: {
1782: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1783: }
1784: break;
1785:
1786: case 5:
1787: pb->usbReference = hubRef;
1788:
1789: /* Do a port status request on current port */
1790: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBOther);
1791: pb->usb.cntl.BRequest = kUSBRqGetStatus;
1792: pb->usb.cntl.WValue = 0; /* Standard type 0 and index 0 */
1793: pb->usb.cntl.WIndex = pp->portIndex;
1794: pb->usbReqCount = sizeof(USBHubPortStatus);
1795: pb->usbBuffer = &pp->portStatus;
1796:
1797: noteError("Hub Driver Error - kUSBRqGetStatus (second after port status change)");
1798: if(immediateError(USBDeviceRequest(pb)))
1799: {
1800: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1801: }
1802: break;
1803:
1804: case 6:
1805: pp->portStatus.portChangeFlags = USBToHostWord(pp->portStatus.portChangeFlags);
1806: pp->portStatus.portFlags = USBToHostWord(pp->portStatus.portFlags);
1807: continue;
1808:
1809: case 7:
1810:
1811: which = (pb->usbRefcon & kPortVectorStageMask) >> kPortWhichVectorShift;
1812: pb->usbRefcon--; // come back to here for completion
1813: pb->usbRefcon += kPortVectorStage1; // Step the handlers stage on
1814:
1815: ret = (*pp->changeHandler[which].handler)(pb);
1816:
1817: if( (kVectorContinueImmed == ret) || (kVectorContinueDelayed == ret) )
1818: {
1819: pb->usbRefcon = getDescLoop;
1820: if(kVectorContinueImmed == ret)
1821: {
1822: continue;
1823: }
1824: }
1825: else if(kVectorfinishedImmed == ret)
1826: {
1827: pb->usbRefcon = 0;
1828: }
1829: else if(kVectorNotfinished == ret)
1830: {
1831: }
1832: break;
1833:
1834: default:
1835: noteError("Hub Driver Error - Unused case in port status change handler");
1836: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
1837: break;
1838: }
1839: break; /* only execute once, unless continue used */
1840: }while(1); /* so case can be reentered with a continue */
1841: }
1842:
1843:
1844: static void intPipeHandler(USBPB *pb)
1845: {
1846: perPort *pp, *intPort;
1847: static UInt8 buffer[256/8+1];
1848: static numBytes;
1849: static readPipeLoop;
1850: int byteCounter, bitMask, portIndex;
1851:
1852: if(handleError(pb))
1853: return;
1854:
1855: pp = (void *)pb; /* parameter block has been extended */
1856:
1857: do{switch(pb->usbRefcon++)
1858: {
1859: case 1:
1860: pb->usbReference = hubRef;
1861: /* Open the pipes (there's only one) in the interface */
1862: pb->usb.cntl.WValue = 0;
1863: pb->usbFlags = 0;
1864:
1865: pb->usbReqCount = 0;
1866: pb->usbActCount = 0;
1867: pb->usbBuffer = 0;
1868:
1869: pb->usbOther = 0; // alternative interface
1870:
1871: noteError("Hub Driver Error - USBConfigureInterface");
1872: if(immediateError(USBConfigureInterface(pb)))
1873: {
1874: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1875: }
1876: break;
1877:
1878: case 2:
1879:
1880: /* Find out when we first ask for the int, so enumeration */
1881: /* completion can work out its not going to happen. */
1882: pb->usbFlags = 0;
1883: if(USBGetFrameNumberImmediate(pb) != noErr)
1884: {
1885: USBExpertStatus(hubDevRef, "Hub driver - Frame number error:", pb->usbReference);
1886: intFrame = 1;
1887: }
1888: else
1889: {
1890: intFrame = pb->usbFrame;
1891: }
1892:
1893: /* New reads to this pipe will go to the same place we are */
1894: readPipeLoop = pb->usbRefcon;
1895:
1896: /* Find the pipe ref for the (only) pipe */
1897: pb->usbFlags = kUSBIn;
1898: pb->usbClassType = kUSBInterrupt;
1899: noteError("Hub Driver Error - finding interrupt pipe");
1900: if(immediateError(USBFindNextPipe(pb)))
1901: {
1902: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1903: }
1904: break;
1905:
1906: case 3:
1907: pb->usbFlags = 0;
1908:
1909: /* reference is now int pipe */
1910: numBytes = (numPorts+1)/8+1;
1911: pb->usbReqCount = numBytes;
1912: pb->usbBuffer = buffer;
1913: noteError("Hub Driver Error - Reading interrupt pipe");
1914: if(immediateError(USBIntRead(pb)))
1915: {
1916: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
1917: }
1918: break;
1919:
1920: case 4:
1921:
1922: /* Now interpret the status returned */
1923: pb->usbRefcon = readPipeLoop; /* end up back at the beginning */
1924:
1925: bitMask = 2;
1926: byteCounter = 0;
1927: for(portIndex = 1; portIndex <= numPorts; portIndex++)
1928: {
1929: if( (buffer[byteCounter] & bitMask) != 0 )
1930: {
1931: intPort = &ports[portIndex]; // Do it this way so debugger can see pp
1932: if(intPort->pb.usbRefcon != 0)
1933: {
1934: // Maybe want to count failures here
1935: USBExpertStatus(hubDevRef, "Hub Driver - Interrupt while hub was busy", portIndex);
1936: }
1937: else
1938: {
1939: intFrame = 0xffffffff; /* note an interrupt happened. */
1940: intPort->pb.usbStatus = noErr;
1941: intPort->pb.usbRefcon = 1;
1942: intPort->pb.usbCompletion = portStatusChangedHandler;
1943: portStatusChangedHandler(&intPort->pb);
1944: }
1945: }
1946: bitMask <<= 1;
1947: if(bitMask > 128)
1948: {
1949: bitMask = 1;
1950: byteCounter++;
1951: }
1952: }
1953:
1954: if((buffer[0] & 1) != 0)
1955: { /* hub status changed */
1956: intFrame = 0xffffffff; /* note an interrupt happened. */
1957: hubStatusChangeHandler(pb);
1958: break;
1959: }
1960: else
1961: {
1962: OSStatus ret_status;
1963:
1964: if(HubAreWeFinishedYet() == noErr)
1965: {
1966: pb->usbReqCount = 255;
1967: }
1968: else
1969: {
1970: pb->usbReqCount = 20;
1971: }
1972: noteError("Hub Driver - Delay after hub status change");
1973: //USBExpertStatus(hubDevRef, "Hub Driver - Pipe calling delay", pb->usbReqCount);
1974: if(immediateError(ret_status = USBDelay(pb)))
1975: {
1976: kprintf("USB: immediateError delay %d\n", ret_status);
1977: HubFatalError(pp, pb->usbStatus, pp->errorString, pb->usbReqCount);
1978: }
1979: }
1980: break;
1981: default:
1982: noteError("Hub Driver Error - Unused case in interrupt handler");
1983: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
1984: break;
1985: }
1986: break; /* only execute once, unless continue used */
1987: }while(1); /* so case can be reentered with a continue */
1988: }
1989:
1990:
1991: static void startPorts(USBPB *pb)
1992: {
1993: perPort *pp;
1994: int currentPort, byte, mask;
1995:
1996: if(handleError(pb))
1997: return;
1998:
1999: pp = (void *)pb; /* parameter block has been extended */
2000:
2001: do{switch(pb->usbRefcon++)
2002: {
2003: case 1:
2004:
2005: /* These help with port removable and power flags */
2006: byte = 0;
2007: mask = 2; /* First bit is reserved */
2008:
2009: for(currentPort = 1; currentPort <= numPorts; currentPort++)
2010: {
2011:
2012: pp = &ports[currentPort];
2013: pp->pb = *pb;
2014: pp->pb.pbLength = sizeof(perPort);
2015: pp->pb.pbVersion = kUSBCurrentPBVersion;
2016:
2017: initPortVectors(pp->changeHandler);
2018:
2019: pp->portIndex = currentPort;
2020: pp->retries = kInitialRetries;
2021: pp->delay = 0;
2022:
2023: /* Setup port mask for this port, ready for next */
2024: pp->portByte = byte;
2025: pp->portMask = mask;
2026: if( startExternal || ( (hubDesc.removablePortFlags[byte] & mask) != 0) )
2027: {
2028: startPorts(&pp->pb); /* Carry on with next case, with new pb */
2029: }
2030:
2031: mask <<= 1;
2032: if(mask > 0x80)
2033: {
2034: mask = 1;
2035: byte++;
2036: }
2037: }
2038:
2039:
2040: break;
2041:
2042: case 2:
2043: /* Power the port */
2044:
2045: /* Maybe should only do this if there is power switching */
2046: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
2047: pb->usb.cntl.BRequest = kUSBRqSetFeature;
2048: pb->usb.cntl.WValue = kUSBHubPortPowerFeature;
2049: pb->usb.cntl.WIndex = pp->portIndex;
2050: pb->usbReqCount = 0;
2051: pb->usbBuffer = nil;
2052:
2053: noteError("Hub Driver - kUSBRqSetFeature (Powering on port)");
2054: if(immediateError(USBDeviceRequest(pb)))
2055: {
2056: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2057: }
2058: break;
2059:
2060: case 3:
2061: if( (hubDesc.removablePortFlags[pp->portByte] & pp->portMask) == 0)
2062: {
2063: pb->usbRefcon = 0;
2064: break; // This is all done by the int handler hopefully.
2065: /* Tell the world we're finsihed */
2066: }
2067: // This for static hub
2068: // Debugger();
2069: /* wait for the power on good time */
2070:
2071: pb->usbReqCount = hubDesc.powerOnToGood * 2;
2072: /* pb->usbFlags = kUSBtaskTime */
2073:
2074: //USBExpertStatus(hubDevRef, "Hub Driver - Power on calling delay", pb->usbReqCount);
2075: noteError("Hub Driver - Waiting for port to power on");
2076: if(immediateError(USBDelay(pb)))
2077: {
2078: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2079: }
2080: break;
2081:
2082: case 4:
2083: /* We should now be in the disconnected state */
2084:
2085: /* Do a port request on current port */
2086: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBOther);
2087: pb->usb.cntl.BRequest = kUSBRqGetStatus;
2088: pb->usb.cntl.WValue = 0; /* Standard type 0 and index 0 */
2089: pb->usb.cntl.WIndex = pp->portIndex;
2090: pb->usbReqCount = sizeof(USBHubPortStatus);
2091: pb->usbBuffer = &pp->portStatus;
2092:
2093: noteError("Hub Driver - kUSBRqGetStatus (after power on)");
2094: if(immediateError(USBDeviceRequest(pb)))
2095: {
2096: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2097: }
2098: break;
2099:
2100: case 5:
2101: pp->portStatus.portChangeFlags = USBToHostWord(pp->portStatus.portChangeFlags);
2102: pp->portStatus.portFlags = USBToHostWord(pp->portStatus.portFlags);
2103: /* we now have port status */
2104: if(bit(pp->portStatus.portChangeFlags, kHubPortConnection) )
2105: {
2106: /* Reset the change connection status */
2107: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBOut, kUSBClass, kUSBOther);
2108: pb->usb.cntl.BRequest = kUSBRqClearFeature;
2109: pb->usb.cntl.WValue = kUSBHubPortConnectionChangeFeature;
2110: pb->usb.cntl.WIndex = pp->portIndex;
2111: pb->usbReqCount = 0;
2112: pb->usbBuffer = nil;
2113:
2114: noteError("Hub Driver - kUSBRqClearFeature (clear 'port change connection' feature");
2115: if(immediateError(USBDeviceRequest(pb)))
2116: {
2117: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2118: }
2119:
2120: }
2121: else
2122: {
2123: pb->usbRefcon+=2; /* Skip the next status */
2124: continue; /* Carry on with next case */
2125: }
2126: break;
2127:
2128: case 6:
2129: /* We should now be in the disconnected state */
2130: /* Do a port request on current port */
2131: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBOther);
2132: pb->usb.cntl.BRequest = kUSBRqGetStatus;
2133: pb->usb.cntl.WValue = 0; /* Standard type 0 and index 0 */
2134: pb->usb.cntl.WIndex = pp->portIndex;
2135: pb->usbReqCount = sizeof(USBHubPortStatus);
2136: pb->usbBuffer = &pp->portStatus;
2137:
2138: noteError("Hub Driver - kUSBRqGetStatus (after change connection)");
2139: if(immediateError(USBDeviceRequest(pb)))
2140: {
2141: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2142: }
2143: break;
2144:
2145: case 7:
2146: pp->portStatus.portChangeFlags = USBToHostWord(pp->portStatus.portChangeFlags);
2147: pp->portStatus.portFlags = USBToHostWord(pp->portStatus.portFlags);
2148: continue;
2149: break;
2150:
2151: case 8:
2152: if( bit(pp->portStatus.portFlags, kHubPortConnection) )
2153: { /* We have a connection on this port */
2154:
2155: pb->usbCompletion = hubAddDeviceHandler;
2156: pb->usbRefcon = 1;
2157: pb->usbStatus = noErr;
2158:
2159: hubAddDeviceHandler(pb);
2160: }
2161: else
2162: {
2163: pb->usbRefcon = 0; // this should never happen, but don't freeze port
2164: }
2165: // Static hub
2166: break;
2167:
2168: default:
2169: noteError("Hub Driver Error - Unused case in start ports");
2170: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
2171: break;
2172: }
2173: break; /* only execute once, unless continue used */
2174: }while(1); /* so case can be reentered with a continue */
2175: }
2176:
2177:
2178: static void hubHandler(USBPB *pb)
2179: {
2180: perPort *pp;
2181: USBDeviceDescriptor *desc;
2182: static USBConfigurationDescriptor conf;
2183: UInt32 powerStatus;
2184:
2185: if(handleError(pb))
2186: return;
2187:
2188: pp = (void *)pb; /* parameter block has been extended */
2189: kprintf("hubHandler:usbRefcon=%d,ref=0x%x\n",pb->usbRefcon,pb->usbReference);
2190: do{switch(pb->usbRefcon++)
2191: {
2192: case 1:
2193: hubRef = pb->usbReference; /* remember who we are */
2194: hubDevRef = hubRef; /* remember the dev ref to talk to expt */
2195:
2196: desc = pb->usbBuffer;
2197:
2198: errataBits = GetErrataBits(desc);
2199: if(errataBits != 0)
2200: {
2201: USBExpertStatus(hubDevRef, "Hub Driver - Using errata:", errataBits);
2202: }
2203:
2204: hubSubClass = desc->deviceSubClass; /* Old hubs = 1, new hubs = 0 it seems */
2205: noteError("Hub Driver Error - Device not recognized");
2206: if(desc->numConf != 1)
2207: {
2208: USBExpertStatus(hubDevRef, "Hub Driver - Device has more than 1 configuration. Using first", numPorts);
2209: }
2210: /* get the full config descriptor */
2211: if(hubSubClass == 1)
2212: {
2213: pp->value = 0; /* Hope 0 is the first one */
2214: }
2215: else
2216: {
2217: pp->value = 1; /* Hope 1 is the first one */
2218: }
2219: pp->onError = pb->usbRefcon; /* Try the clause below again on error */
2220: #if 0
2221: // This bit tests device reset. You don't normally want it here
2222: if(hubSubClass == 1)
2223: {
2224: continue;
2225: }
2226: pb->usbFlags = 0;
2227: noteError("Hub Driver Error - hub reset");
2228: kprintf("hubHandler:calling USBResetDevice: ref=0x%x\n",pb->usbReference);
2229: if(immediateError(USBResetDevice(pb)))
2230: {
2231: USBExpertStatus(hubDevRef, "Hub driver - Immediate error testing reset", pb->usbStatus);
2232: continue;
2233: //HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2234: }
2235: #else
2236: continue;
2237: #endif
2238: break;
2239:
2240: case 2:
2241: pb->usbClassType = kUSBHubClass; /* hub class */
2242: pb->usbSubclass = hubSubClass; /* hub subclass, as in the device descriptor */
2243: /* Could make this wild, but devices which have these different are bad */
2244: pb->usbProtocol = 0; /* any protocol */
2245:
2246: pb->usbReqCount = 0;
2247: pb->usbActCount = 0;
2248: pb->usbBuffer = 0;
2249:
2250: pb->usb.cntl.WValue = 0; // first config
2251: pb->usb.cntl.WIndex = 0; // first interface
2252: pb->usbOther = 0xff;// first alt
2253:
2254: pb->usbReqCount = busPowerAvail;
2255: pp->onError = pb->usbRefcon;
2256:
2257: noteError("Hub Driver - Getting interface");
2258: kprintf("hubHandler:case 2 calling USBFindNextInterface: ref=0x%x\n",pb->usbReference);
2259: if(immediateError(USBFindNextInterface(pb)))
2260: { /* this should return immediatly */
2261: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2262: break; /* Nothing else to do now */
2263: }
2264:
2265: break;
2266:
2267: case 3:
2268: if(pb->usbStatus == kUSBDevicePowerProblem)
2269: {
2270: noteError("Hub Driver - Insufficient power to configure hub");
2271: USBExpertSetDevicePowerStatus(hubDevRef, 0, 0, kUSBDevicePower_BusPowerInsufficient, busPowerAvail, kUSB500mAAvailable); // TC: <USB67>
2272: }
2273:
2274: if(pb->usbStatus != noErr)
2275: {
2276: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2277: break;
2278: }
2279: pb->usbReqCount = sizeof(conf);
2280: pb->usbBuffer = &conf;
2281:
2282: noteError("Hub Driver - Getting config descriptor");
2283: kprintf("hubHandler:case 3 calling USBGetConfig: ref=0x%x\n",pb->usbReference);
2284: if(immediateError(USBGetConfigurationDescriptor(pb)))
2285: { /* this should return immediatly */
2286: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2287: break; /* Nothing else to do now */
2288: }
2289:
2290: break;
2291:
2292: case 4:
2293:
2294: /* Work out some power bits */
2295:
2296: busPowered = (conf.attributes & kUSBAtrBusPowered) != 0;
2297: selfPowered = (conf.attributes & kUSBAtrSelfPowered) != 0;
2298:
2299: noteError("Hub Driver Error - Illegal device configuration, no power");
2300: if( !(busPowered || selfPowered) )
2301: { /* Neither slef nor bus powered, its dead!!! */
2302: HubFatalError(pp, kUSBUnknownDeviceErr, pp->errorString, 0);
2303: break; /* Now what ?? */
2304: }
2305:
2306: /* these got set up to read the descriptor. */
2307: pb->usbReqCount = 0;
2308: pb->usbActCount = 0;
2309: pb->usbBuffer = 0;
2310:
2311: /* for error recovery */
2312: pp->value = 1-pp->value;
2313:
2314: /* There is an interface for us, Configure the device */
2315: //pb->usb.cntl.WValue = pb->usbValue4; // have to sort out this
2316: noteError("Hub Driver Error - Getting full configuration descriptor");
2317: kprintf("HubClassDriver.c:case 4 SetConfig: ref=0x%x\n",pb->usbReference);
2318: if(immediateError(USBSetConfiguration(pb)))
2319: {
2320: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2321: }
2322: kprintf("hubDriver:setconfig complete****\n");
2323: break;
2324:
2325: case 5:
2326:
2327:
2328: /* find an interface ref to work with */
2329: noteError("Hub Driver Error - USBNewInterfaceRef");
2330: kprintf("HubClassDriver.c:case 5 calling USBNewInterfaceRef\n");
2331: if(immediateError(USBNewInterfaceRef(pb)))
2332: {
2333: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2334: }
2335: break;
2336:
2337:
2338:
2339: case 6:
2340: /* Now remember the interface ref */
2341: hubRef = pb->usbReference;
2342:
2343: /* Mess with get hub descriptor */
2344: if(hubSubClass == 0)
2345: {
2346: pp->value = 0; /* Standard type 0 and index 0 */
2347: }
2348: else
2349: {
2350: pp->value = 0x2900; /* for atmel Standard type 0 and index 0 */
2351: }
2352: pp->onError = pb->usbRefcon; /* Try the clause below again on error */
2353: continue;
2354: break;
2355:
2356:
2357: case 7:
2358: /* Switch the value for retry */
2359: pp->value = 0x2900 - pp->value;
2360: pb->usb.cntl.WValue = pp->value;
2361:
2362: /* Start things off, lets find out what the hub is */
2363: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBClass, kUSBDevice);
2364: pb->usb.cntl.BRequest = kUSBRqGetDescriptor;
2365: pb->usb.cntl.WIndex = 0;
2366: pb->usbReqCount = sizeof(hubDescriptor) -1;
2367: pb->usbBuffer = &hubDesc.length;
2368:
2369: noteError("Hub Driver Error - kUSBRqGetDescriptor (get device descriptor)");
2370: if(immediateError(USBDeviceRequest(pb)))
2371: {
2372: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2373: }
2374: break;
2375:
2376: case 8:
2377: /* Hub get descriptor now finished */
2378: numPorts = hubDesc.numPorts;
2379: {
2380: /* Unpack the port flags */
2381: int numFlags, i;
2382: numFlags = (numPorts+1)/8+1;
2383: for(i = 0; i < numFlags; i++)
2384: {
2385: hubDesc.pwrCtlPortFlags[i] = hubDesc.removablePortFlags[numFlags+i];
2386: hubDesc.removablePortFlags[numFlags+i] = 0;
2387: }
2388: }
2389:
2390: /* Work out some bits for compound devices */
2391: numCaptive = 0;
2392: // if(hubDesc.characteristics & kHubIsCompound)
2393: {
2394: int i, portMask = 2, portByte = 0;
2395: for(i = 1; i<=numPorts; i++)
2396: {
2397: if( (hubDesc.removablePortFlags[portByte] & portMask) != 0)
2398: {
2399: numCaptive++;
2400: }
2401: portMask <<= 1;
2402: if(portMask > 0x80)
2403: {
2404: portMask = 1;
2405: portByte++;
2406: }
2407: }
2408: }
2409:
2410: if(numPorts > kMaxPorts)
2411: {
2412: /* Need to allocate more port structs here */
2413: USBExpertStatus(hubDevRef, "Hub Driver - Allocating more ports", numPorts);
2414:
2415: pb->usbReqCount = (numPorts+1)*sizeof(perPort);
2416: pp->onError = pb->usbRefcon;
2417: noteError("Hub Driver Error - Allocating memory for ports");
2418: USBAllocMem(pb);
2419: }
2420: else
2421: {
2422: pb->usbRefcon++;
2423: continue;
2424: }
2425: break;
2426:
2427: case 9:
2428: /* new ports allocated */
2429: if(pb->usbBuffer == nil)
2430: {
2431: /* carry on with only pre allocated ports */
2432: numPorts = kMaxPorts;
2433: USBExpertStatus(hubDevRef, "Hub Driver Error - Allocating more ports failed", numPorts);
2434: continue;
2435: }
2436: else
2437: {
2438: USBExpertStatus(hubDevRef, "Hub Driver - More ports allcated", pb->usbActCount);
2439: ports = pb->usbBuffer;
2440: ports[0] = *pp;
2441: pb = (void *)ports;
2442: continue;
2443: }
2444: break;
2445:
2446: case 10:
2447: if(busPowered)
2448: {
2449: UInt32 pHub, pAvailForPorts,pNeededForPorts;
2450: /* Note hub current in units of 1mA, everything else in units of 2mA */
2451: pHub = hubDesc.hubCurrent/2;
2452: //USBExpertStatus(hubDevRef, "Hub Driver - *Power* pHub:", pHub);
2453: //USBExpertStatus(hubDevRef, "Hub Driver - *Power* busPowerAvail:", busPowerAvail);
2454: if(pHub > busPowerAvail)
2455: {
2456: /* this is illegal??? */
2457: USBExpertStatus(hubDevRef, "Hub Driver - Hub needs more power than available", pb->usbActCount);
2458: USBExpertSetDevicePowerStatus(hubDevRef, 0, 0, kUSBDevicePower_BusPowerInsufficient, busPowerAvail, pHub); // TC: <USB67>
2459: break; /* Thats that. */
2460: }
2461: pAvailForPorts = busPowerAvail-pHub;
2462: //USBExpertStatus(hubDevRef, "Hub Driver - *Power* pAvailForPorts:", pAvailForPorts);
2463: pNeededForPorts = (numPorts-numCaptive)*kUSB100mA;
2464: //USBExpertStatus(hubDevRef, "Hub Driver - *Power* numPorts:", numPorts);
2465: //USBExpertStatus(hubDevRef, "Hub Driver - *Power* numCaptive:", numCaptive);
2466: //USBExpertStatus(hubDevRef, "Hub Driver - *Power* pNeededForPorts:", pNeededForPorts);
2467: busPowerGood = pAvailForPorts >= pNeededForPorts;
2468: //USBExpertStatus(hubDevRef, "Hub Driver - *Power* busPowerGood:", busPowerGood);
2469: if(numCaptive > 0)
2470: {
2471: if(busPowerGood)
2472: {
2473: powerForCaptive = (pAvailForPorts - pNeededForPorts)/numCaptive;
2474: }
2475: else
2476: {
2477: powerForCaptive = pAvailForPorts/numCaptive;
2478: }
2479: }
2480:
2481: if( (errataBits & kErrataCaptiveOK) != 0)
2482: {
2483: powerForCaptive = kUSB100mAAvailable;
2484: }
2485: }
2486:
2487: if(selfPowered)
2488: {
2489: /* Now get power status before turning on ports */
2490: pb->usb.cntl.BMRequestType = USBMakeBMRequestType(kUSBIn, kUSBStandard, kUSBDevice);
2491: pb->usb.cntl.BRequest = kUSBRqGetStatus;
2492: pb->usb.cntl.WValue = 0;
2493: pb->usb.cntl.WIndex = 0;
2494: pb->usbReqCount = sizeof(deviceStatus);
2495: pb->usbBuffer = &deviceStatus;
2496:
2497: noteError("Hub Driver Error - kUSBRqGetStatus (get status before turning on ports)");
2498: if(immediateError(USBDeviceRequest(pb)))
2499: {
2500: HubFatalError(pp, pb->usbStatus, pp->errorString, 0);
2501: }
2502: }
2503: else
2504: {
2505: continue;
2506: }
2507: break;
2508:
2509: case 11:
2510:
2511: /* Now have hub power status */
2512: if(selfPowered)
2513: {
2514: deviceStatus = USBToHostWord(deviceStatus);
2515: selfPowerGood = ((deviceStatus & 1) != 0);
2516: }
2517:
2518: //OSStatus USBExpertSetDevicePowerStatus(USBDeviceRef ref, UInt32 powerStatus, UInt32 busPowerAvailable, UInt32 busPowerNeeded )
2519:
2520: if(selfPowered && busPowered)
2521: {
2522: /* Duel power hub */
2523: if(selfPowerGood)
2524: {
2525: powerStatus = kUSBDevicePower_PowerOK;
2526: USBExpertStatus(hubDevRef, "Hub attached - Self/Bus powered, power supply good", 0);
2527: }
2528: else
2529: {
2530: powerStatus = kUSBDevicePower_SelfPowerInsufficient;
2531: USBExpertStatus(hubDevRef, "Hub attached - Self/Bus powered, no external power", 0);
2532: }
2533: }
2534: else
2535: {
2536: /* Single power hub */
2537: if(selfPowered)
2538: {
2539: if(selfPowerGood)
2540: {
2541: powerStatus = kUSBDevicePower_PowerOK;
2542: USBExpertStatus(hubDevRef, "Externally powered Hub attached - power supply good", 0);
2543: }
2544: else
2545: {
2546: powerStatus = kUSBDevicePower_SelfPowerInsufficient;
2547: USBExpertStatus(hubDevRef, "Externally powered Hub attached - no external power", 0);
2548: }
2549: }
2550: else
2551: {
2552: powerStatus = kUSBDevicePower_BusPowerInsufficient;
2553: USBExpertStatus(hubDevRef, "Bus powered Hub attached", 0);
2554: }
2555:
2556: }
2557:
2558:
2559: startExternal = (busPowerGood || selfPowerGood);
2560: if( !startExternal )
2561: { /* not plugged in or bus powered on a bus powered hub */
2562: USBExpertStatus(kUSBUnknownDeviceErr, "Hub Driver Error - Insufficient power to turn on ports", 0);
2563: USBExpertSetDevicePowerStatus(hubDevRef, 0, 0, powerStatus, busPowerAvail, busPowered?kUSB500mAAvailable:0); // TC: <USB67>
2564: if(!busPowered)
2565: {
2566: /* may be able to turn on compound devices */
2567: break; /* Now what ?? */
2568: }
2569: }
2570:
2571: //USBExpertStatus(kUSBUnknownDeviceErr, "Hub Starting ports, ext:", startExternal);
2572: //USBExpertStatus(kUSBUnknownDeviceErr, "Hub compound power:", powerForCaptive);
2573: pb->usbStatus = noErr;
2574: pb->usbCompletion = startPorts;
2575: pb->usbRefcon = 1;
2576: startPorts(pb);
2577:
2578: pb->usbCompletion = intPipeHandler;
2579: pb->usbRefcon = 1;
2580: pb->usbStatus = noErr;
2581: pp = (void *)pb;
2582: pp->retries = kInitialRetries;
2583: intPipeHandler(pb);
2584:
2585: break;
2586:
2587: default:
2588: noteError("Hub Driver Error - Unused case in hub handler");
2589: HubFatalError(pp, kUSBInternalErr, pp->errorString, pb->usbRefcon);
2590: break;
2591: }
2592: break; /* only execute once, unless continue used */
2593: }while(1); /* so case can be reentered with a continue */
2594: }
2595:
2596: #if 0
2597: ExtPower
2598: Good off
2599:
2600: Bus Self
2601:
2602: 0 0 Illegal config
2603:
2604: 0 1 Always 100mA per port
2605:
2606: 1 0 500mA 0 (dead)
2607:
2608: 1 1 500 100
2609:
2610: #endif
2611:
2612:
2613: OSStatus killHub(USBDeviceRef device)
2614: { /* This hub has died, kill its children */
2615: int i;
2616: perPort *pp;
2617: USBPB *pb;
2618:
2619: pp = &ports[0];
2620: if(device != hubDevRef)
2621: {
2622: HubFatalError(pp, kUSBUnknownDeviceErr, "Hub driver - Kill hub called with wrong ref num", 0);
2623: return(kUSBUnknownDeviceErr);
2624: }
2625:
2626:
2627: for(i = 1; i<= numPorts; i++)
2628: {
2629: pp = &ports[i];
2630: pb = &pp->pb;
2631: pb->usbReference = pp->newDevRef;
2632: pb->usbCompletion = kUSBNoCallBack; // we're supposed to be called at task time
2633: if(pp->newDevRef != 0)
2634: {
2635: USBExpertStatus(hubDevRef, "Hub driver - Removing dead child:", pb->usbReference);
2636: noteError("Hub Driver Error - removing dead child");
2637: if(immediateError(USBHubDeviceRemoved(pb)))
2638: {
2639: USBExpertStatus(hubDevRef, "Hub driver - Failed to remove dead child:", pb->usbReference);
2640: }
2641:
2642: USBExpertRemoveDeviceDriver(pp->newDevRef);
2643:
2644: pp->newDevRef = 0;
2645: pb->usbRefcon = 0;
2646:
2647: pp->delay = 0;
2648: pp->retries = kInitialRetries;
2649: }
2650: }
2651:
2652: pp = &ports[0];
2653: pb = &pp->pb;
2654: if(pb->usbStatus == kUSBPending)
2655: {
2656: HubFatalError(pp, kUSBPending, "Hub driver - transaction still outstanding", 0);
2657: return(kUSBAlreadyOpenErr);
2658: }
2659:
2660: if(staticPorts != ports)
2661: { /* we allocated our own */
2662: USBExpertStatus(hubDevRef, "Hub driver - Deallocating allocated ports", 0);
2663: pp = &staticPorts[0];
2664: pb = &pp->pb; // make sure to use a static port for this.
2665: pb->usbCompletion = kUSBNoCallBack;
2666: pb->usbBuffer = ports;
2667:
2668: if(immediateError(USBDeallocMem(pb)))
2669: {
2670: USBExpertStatus(hubDevRef, "Hub driver - Failed to deallocate:", pb->usbStatus);
2671: }
2672: }
2673:
2674:
2675:
2676: pb->usbReference = hubRef;
2677: pb->usbCompletion = kUSBNoCallBack;
2678: pb->usbFlags = 0;
2679: USBDisposeInterfaceRef(pb);
2680:
2681: return(noErr);
2682: }
2683:
2684: static OSStatus resetPortRequest(USBPB *pb, UInt32 port)
2685: {
2686: pb = &ports[port].pb;
2687:
2688: pb->usbCompletion = doPortResetHandler;
2689: pb->usbRefcon = 1;
2690: pb->usbStatus = noErr;
2691: pb->usbFlags = 0;
2692:
2693: doPortResetHandler(pb);
2694: return(kUSBPending);
2695: }
2696:
2697: static OSStatus resetPortPowerRequest(USBPB *pb, UInt32 port)
2698: {
2699: USBExpertStatus(hubDevRef, "Hub driver - port power request, not implimented", port);
2700: pb=0;
2701: return(kUSBUnknownRequestErr);
2702: }
2703:
2704: static OSStatus resetRequest(USBPB *pb, UInt32 port)
2705: {
2706: if(bit(pb->usbFlags, kUSBPowerReset))
2707: {
2708: return(resetPortPowerRequest(pb, port));
2709: }
2710: else
2711: {
2712: return(resetPortRequest(pb, port));
2713: }
2714: }
2715:
2716: OSStatus HubChildMessage(USBReference deviceRef, USBPB *pb)
2717: {
2718: int port=1;
2719: Boolean busy;
2720: OSStatus err;
2721:
2722: // USBExpertStatus(hubDevRef, "Hub driver - Child message for device:", deviceRef);
2723: while(port<= numPorts)
2724: {
2725: if(ports[port].newDevRef == deviceRef)
2726: {
2727: break;
2728: }
2729: port++;
2730: }
2731: if(port > numPorts)
2732: {
2733: return(kUSBUnknownDeviceErr);
2734: }
2735:
2736: busy = !CompareAndSwap(nil, (UInt32)pb, (UInt32 *)&ports[port].portRequestPB);
2737: if(!busy)
2738: {
2739: busy = !CompareAndSwap(0, 1, &ports[port].pb.usbRefcon);
2740: if(busy)
2741: {
2742: ports[port].portRequestPB = nil; /* port is otherwise busy, so clear request */
2743: }
2744: }
2745: if(busy)
2746: {
2747: USBExpertStatus(hubDevRef, "Hub driver - request on busy port:", port);
2748: return(kUSBDeviceBusy);
2749: }
2750:
2751: // USBExpertStatus(hubDevRef, "Hub driver - Child message for port:", port);
2752:
2753: if(pb->usb.hub.Request == kUSBHubPortResetRequest)
2754: {
2755: err = resetRequest(pb, port);
2756: }
2757: else
2758: {
2759: err = kUSBUnknownRequestErr;
2760: }
2761: if(err != kUSBPending)
2762: {
2763: ports[port].portRequestPB = nil;
2764: ports[port].pb.usbRefcon = 0;
2765: }
2766: return(err);
2767: }
2768:
2769: void HubDriverEntry(USBDeviceRef device, USBDeviceDescriptor *desc, UInt32 busPowerAvailable)
2770: {
2771: static Boolean beenThereDoneThat = false;
2772: //VersRec vers;
2773: //OSStatus err;
2774:
2775: if(beenThereDoneThat)
2776: {
2777: USBExpertFatalError(device, kUSBInternalErr, "Hub driver called second time", 0);
2778: return;
2779: }
2780: //Hot Plug n Play
2781: //naga beenThereDoneThat = true;
2782:
2783: // err = USBServicesGetVersion(1, &vers, sizeof(vers));
2784: // err = USBServicesGetVersion(2, &vers, sizeof(vers));
2785:
2786: ports[0].pb.pbLength = sizeof(perPort);
2787: ports[0].pb.pbVersion = kUSBCurrentHubPB;
2788: ports[0].pb.usbStatus = noErr;
2789: ports[0].pb.usbReference = device;
2790: ports[0].pb.usbCompletion = hubHandler;
2791: ports[0].pb.usbRefcon = 1;
2792: ports[0].pb.usbBuffer = desc;
2793:
2794: ports[0].retries = kInitialRetries;
2795: ports[0].delay = 0;
2796: ports[0].errorString = "";
2797:
2798: busPowerAvail = busPowerAvailable;
2799: kprintf("HubDriverEntry:calling hubHandler:ref=0x%x\n",ports[0].pb.usbReference);
2800: hubHandler(&ports[0].pb);
2801: }
2802:
2803:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.