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