![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to usl.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 / Library|
Return to usl.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvUSBCMD / Library |
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: usl.c ! 27: ! 28: Contains: USB Services Library source code. ! 29: ! 30: Version: Neptune 1.0 ! 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: USB ! 41: ! 42: Writers: ! 43: ! 44: (DF) David Ferguson ! 45: (TC) Tom Clark ! 46: (BG) Bill Galcher ! 47: (DKF) David Ferguson ! 48: (CJK) Craig Keithley ! 49: (BT) Barry Twycross ! 50: ! 51: Change History (most recent first): ! 52: ! 53: <USB76> 11/25/98 TC Add calls to USBExpertStatusLevel. ! 54: <USB75> 11/16/98 BT Mark pipe stalled on allocate to check open pipe is clearing it ! 55: properly. ! 56: <USB74> 11/8/98 TC We need to assign a unique DeviceRef for UIM's. So when creating ! 57: DeviceRefs, don't return one that matches kUIMRefID. ! 58: <USB73> 11/6/98 TC Formalize parameter names for uslRefToBus. ! 59: <USB72> 11/6/98 BT ref to bus function ! 60: <USB71> 10/29/98 BT Close old configurations on reset or reconfiguration. ! 61: <USB70> 10/21/98 DF Add uslDeviceAddrToBus function ! 62: <USB69> 10/7/98 BT Fix hub not killing children ! 63: <USB68> 9/17/98 BT 1.1 rules for captive devices. ! 64: <USB67> 8/24/98 BT Eliminate old checkPB version, add new one for Isoc ! 65: <USB66> 8/13/98 BT Add multibus support ! 66: <USB65> 7/10/98 BT Device zero has a valid ref, delete device deletes mem even ! 67: after trashing device and ref. ! 68: <USB64> 7/9/98 BT Fix previous fixes. Device refs can also be validated ! 69: <USB63> 7/9/98 BT Clean up after delete device and config clash. ! 70: <USB62> 6/13/98 BT Eliminate V1 param blocks ! 71: <USB61> 6/10/98 CJK add uslGetDeviceRefByID function (thanks Barry!) ! 72: <USB60> 6/5/98 BT Delete mem properly in delete device ! 73: <USB59> 6/5/98 TC Change uxBusRef to USBBusRef. ! 74: <USB58> 6/3/98 BT Make dispose interface ref able to ignore call back ! 75: <USB57> 5/21/98 BT Don't initialise redundant firstConf field in dev structure ! 76: <USB56> 5/20/98 BT Add check for V2 param block function ! 77: <USB55> 5/19/98 BG Fixed ZeroMem() be a little easier for MrC to swallow. ! 78: <USB54> 5/17/98 BT Impliment new interface ref correctly, add some functions to ! 79: support config stuff ! 80: <USB53> 5/12/98 BT New interface handling ! 81: <USB52> 5/8/98 BT Add open interface for Tom ! 82: <USB51> 4/26/98 BT Add pipe state control ! 83: <USB50> 4/24/98 BT Add clear endpoint stall ! 84: <USB49> 4/24/98 CJK change string for status message ! 85: <USB48> 4/21/98 BT Allow requests to device zero, pipe zero. ! 86: <USB47> 4/20/98 BT Add abort pipe ! 87: <USB46> 4/16/98 BT Add back UIMpriv prototypes ! 88: <USB45> 4/15/98 BT Remove redundant diagnostic ! 89: <USB44> 4/15/98 BT Fix wrong flags check. ! 90: <USB43> 4/14/98 BT Impliment device remove ! 91: <USB42> 4/9/98 CJK remove uimpriv.h ! 92: <USB41> 4/9/98 BT Use USB.h ! 93: <40> 4/8/98 BT More error checking ! 94: <39> 4/6/98 BT Change w names ! 95: <38> 4/6/98 BT New param block names ! 96: <37> 4/2/98 BT Start on config/interface/endpoint stuff. First caching config ! 97: descriptors. ! 98: <36> 3/24/98 BT Record device speed in device structure. (Fixes low speed int ! 99: pipe problems.) ! 100: <35> 3/24/98 BT Fix recording of Maxpacketsize ! 101: <34> 3/19/98 BT Stop double inititialisation ! 102: <33> 3/19/98 BT Open bulk takes max poacket size in usbValue. ! 103: <32> 3/18/98 BT Add remove device. ! 104: <31> 3/5/98 BT Add interrupt pipe ! 105: <USB30> 2/17/98 DKF Fix a typo in the error codes ! 106: <29> 2/16/98 BT Direct notifications to expert ! 107: <28> 2/9/98 BT Add add interface stuff ! 108: <27> 2/8/98 BT Power Allocation stuff ! 109: <26> 2/5/98 BT Add status notification stuff ! 110: <25> 2/4/98 BT Add ref/port info to expert notify] ! 111: <24> 2/4/98 BT More USBprobe support ! 112: <23> 2/3/98 BT Fix uslControlPacket to have errors. Add mnore support for ! 113: usbProbe. Also add USBExpertNotify ! 114: <22> 2/2/98 BT Add bulk stuff ! 115: <21> 1/29/98 BT Utility stuff split off ! 116: <20> 1/26/98 CJK Change to use USBDeviceDescriptor (instead of just ! 117: deviceDescriptor) ! 118: <19> 1/26/98 BT Mangle names after design review, finish up ! 119: <18> 1/26/98 BT Mangle names after design review ! 120: <17> 1/26/98 BT Make expert notify public ! 121: <16> 1/26/98 BT Fix status in USB delay function ! 122: <15> 1/23/98 BT Add USB delay function ! 123: <14> 1/20/98 BT Increase number of timers ! 124: <13> 1/19/98 BT Fix race condition ! 125: <12> 1/15/98 BT Use new USBClassDrivers.h ! 126: <11> 1/14/98 BT Remove outdated expert stuff ! 127: <10> 1/13/98 BT User timer services for task time, starting implimenting Int ! 128: transactions (not finished) ! 129: <9> 12/23/97 BT Remove obsolete include ! 130: <8> 12/19/97 BT Add add and remove bus. ! 131: <7> 12/19/97 BT UIM now a Shared lib ! 132: <6> 12/18/97 BT Changed expert proc declaratiopn in USLInitialise ! 133: <5> 12/18/97 BT Fix header dependancies, add expert call back ! 134: <4> 12/17/97 BT Fix header ! 135: <3> 12/17/97 BT First checking to BBS ! 136: */ ! 137: ! 138: ! 139: ! 140: /* ************* Includes ************* */ ! 141: #include "../USB.h" ! 142: #include "../USBpriv.h" ! 143: #include "../driverservices.h" ! 144: ! 145: #include "uslpriv.h" ! 146: #include "../uimpriv.h" // This does need to be included. It contains prototypes ! 147: // Stupid MPW just doesn't tell ! 148: /***************************************************************************** ! 149: ! 150: Data Structures ! 151: ! 152: There is an array of devices. ! 153: ! 154: Each device entry has information specific to it. It also holds and array of ! 155: indexes of pipes (open endpoints) for the device. ! 156: ! 157: Each open pipe holds information specific to it. ! 158: ! 159: Devices are refrenced by device IDs, which are currently an index in tot the ! 160: devices table in the lower bits and random number in the high bits. This ! 161: knowledge is kept to a few functions and could be changed. ! 162: ! 163: The pipe refs are similarly indexes in to the pipes array. ! 164: ! 165: ******************************************************************************/ ! 166: ! 167: static pipe AllPipes[kUSBMaxPipes]; ! 168: static usbDevice devices[kUSBMaxDevices]; ! 169: ! 170: enum{ ! 171: kUSBInterfaceShift = 8, ! 172: kUSBMaxInterface = 1 << kUSBInterfaceShift, ! 173: kUSBIntefaceMask = kUSBMaxInterface-1 ! 174: }; ! 175: static uslInterface interfaces[kUSBMaxInterface]; ! 176: ! 177: //static usbDevice *devices; ! 178: ! 179: static Boolean initialised; ! 180: ! 181: ! 182: /* ************* CallBack prototyopes. ************* */ ! 183: /* These need to be referenced before the properplace for their definition */ ! 184: static void controlCallBack( ! 185: UInt32 refcon, /* General Purpose reference supplied by call */ ! 186: OSStatus status, /* normal or error condition */ ! 187: short shortFall); /* how much less than requested transferred */ ! 188: ! 189: ! 190: ! 191: ! 192: /* ************* Actual Code *************** */ ! 193: ! 194: /* This doesn't work without length bytes in the strings */ ! 195: ! 196: OSStatus USBServicesGetVersion(UInt32 ID, VersRec *vers, UInt32 versSize) ! 197: { ! 198: #if 0 ! 199: static VersRec ID1= ! 200: #if kOverrideIndividualVersions ! 201: { ! 202: {kPKGHexMajorVers, kPKGHexMinorVers, kPKGCurrentRelease, kPKGReleaseStage}, ! 203: 0, /* Country code */ ! 204: "\p"kPKGStringVersShort, "\p"kPKGStringVers1Long ! 205: ! 206: }, ! 207: #else ! 208: { ! 209: {kSRVHexMajorVers, kSRVHexMinorVers, kSRVCurrentRelease, kSRVReleaseStage}, ! 210: 0, /* Country code */ ! 211: kMNGRStringVersShort kMNGRStringVers1Long ! 212: ! 213: }, ! 214: #endif ! 215: ID2 = { ! 216: {kPKGHexMajorVers, kPKGHexMinorVers, kPKGCurrentRelease, kPKGReleaseStage}, ! 217: 0, /* Country code */ ! 218: kPKGStringVersShort kPKGStringVers1Long ! 219: ! 220: }, ! 221: *theVers; ! 222: ! 223: if( (ID == 0) || (ID > 2) ) ! 224: { ! 225: return(paramErr); ! 226: } ! 227: if(ID == 1) ! 228: { ! 229: theVers = &ID1; ! 230: } ! 231: else ! 232: { ! 233: theVers = &ID2; ! 234: } ! 235: if(versSize > sizeof(VersRec) ) ! 236: { ! 237: versSize = sizeof(VersRec); ! 238: } ! 239: usb_BlockMoveData(theVers, vers, versSize); ! 240: #endif ! 241: ID = 0; ! 242: vers = 0; ! 243: versSize = 0; ! 244: return(noErr); ! 245: } ! 246: /* ******** Interfaces ********** */ ! 247: ! 248: /* This impliments the arbitrary high bits as a counter. */ ! 249: static USBInterfaceRef MakeInterfaceRef(UInt16 addr) ! 250: { ! 251: static long strangeCounter = 0x980508; ! 252: long shiftedCounter; ! 253: ! 254: strangeCounter++; ! 255: shiftedCounter = strangeCounter << kUSBInterfaceShift; ! 256: if(shiftedCounter == 0) ! 257: { ! 258: shiftedCounter = ++strangeCounter << kUSBInterfaceShift; ! 259: } ! 260: return(addr | shiftedCounter | 0x80000000); // high bit is one ! 261: } ! 262: ! 263: /* Given a interfaceRef find the pointer to its structure */ ! 264: ! 265: OSStatus findInterface(USBInterfaceRef InterfaceRef, uslInterface **p) ! 266: { ! 267: InterfacesIdx idx; ! 268: uslInterface *theInterface; ! 269: ! 270: idx = InterfaceRef & kUSBIntefaceMask; ! 271: theInterface = & interfaces[idx]; ! 272: *p = theInterface; ! 273: if(theInterface->ref == InterfaceRef) ! 274: { ! 275: #if 0 ! 276: if(theInterface->state != kUSBActive) ! 277: { ! 278: if(theInterface->state == kUSBIdle) ! 279: { ! 280: return(kUSBInterfaceIdleError); ! 281: } ! 282: else ! 283: { ! 284: return(kUSBInterfaceStalledError); ! 285: } ! 286: } ! 287: #endif ! 288: return(noErr); ! 289: } ! 290: *p = nil; ! 291: return(kUSBUnknownInterfaceErr); ! 292: } ! 293: ! 294: ! 295: /* This probably is not the best method for Interfaces */ ! 296: static InterfacesIdx AllocInterfaceIdx(void) ! 297: { ! 298: static InterfacesIdx current; ! 299: InterfacesIdx new; ! 300: unsigned counted; ! 301: ! 302: /* Allocates a Interface. This implimentation has a pointer to */ ! 303: /* the next Interface to be allocated, which is incrimented each */ ! 304: /* time. If that Interface is in use, the list is search linearly */ ! 305: /* from that point for the next free Interface */ ! 306: /* Same as packet allocator */ ! 307: ! 308: /* Do we need to use atomicTestAndSet for this? */ ! 309: /* Not if transactions are queued */ ! 310: ! 311: new = current; ! 312: counted = 0; ! 313: ! 314: while(counted < kUSBMaxInterface) ! 315: { ! 316: if(interfaces[new].ref == 0) /* Zero not a valid Interface ref */ ! 317: { ! 318: break; ! 319: } ! 320: counted++; ! 321: new++; ! 322: if(new > kUSBMaxInterface) ! 323: { ! 324: new = 0; ! 325: } ! 326: ! 327: } ! 328: if(counted < kUSBMaxInterface) ! 329: { ! 330: if(counted > 0) ! 331: { ! 332: /* maybe keep track of these at some time */ ! 333: } ! 334: interfaces[new].ref = 0; ! 335: } ! 336: else ! 337: { ! 338: /* maybe keep track of these at some time */ ! 339: new = -1; ! 340: } ! 341: ! 342: current++; ! 343: if(current > kUSBMaxInterface) ! 344: { ! 345: current = 0; ! 346: } ! 347: return(new); ! 348: } ! 349: ! 350: /* Allocate a new Interface structure for the given device and endpoint */ ! 351: uslInterface *AllocInterface(USBDeviceRef device) ! 352: { ! 353: long newIdx; ! 354: ! 355: newIdx = AllocInterfaceIdx(); ! 356: if(newIdx == -1) ! 357: { ! 358: return(nil); ! 359: } ! 360: interfaces[newIdx].ref = MakeInterfaceRef(newIdx); ! 361: interfaces[newIdx].device = device; ! 362: return(&interfaces[newIdx]); ! 363: } ! 364: ! 365: ! 366: static void deallocAllDeviceInterfaces(USBDeviceRef ID) ! 367: { ! 368: int i; ! 369: for(i = 0; i<kUSBMaxInterface ; i++) ! 370: { ! 371: if(interfaces[i].device == ID) ! 372: { ! 373: USBExpertStatusLevel(4, interfaces[i].ref, "USL - Delete undeleted interface", 0); ! 374: ! 375: interfaces[i].device = 0; ! 376: interfaces[i].interfaceNum = 0; ! 377: interfaces[i].alt = 0; ! 378: interfaces[i].ref = 0; ! 379: } ! 380: } ! 381: ! 382: ! 383: } ! 384: ! 385: /* ************* Device Table maintainance internal functions *************/ ! 386: unsigned makeDeviceIdx(USBDeviceRef device) ! 387: { ! 388: return(device & kUSBDeviceIDMask); ! 389: } ! 390: ! 391: Boolean uslIsInterfaceRef(USBInterfaceRef interf) ! 392: { ! 393: return((interf & 0x80000000) != 0); ! 394: } ! 395: ! 396: usbDevice *getDevicePtrFromIdx(unsigned deviceIndex) ! 397: { ! 398: if(deviceIndex > kUSBMaxDevices) ! 399: { ! 400: return(nil); ! 401: } ! 402: return(&devices[deviceIndex]); ! 403: } ! 404: ! 405: USBDeviceRef uslGetDeviceRefByID(unsigned short deviceID, USBBusRef bus); ! 406: ! 407: USBDeviceRef uslGetDeviceRefByID(unsigned short deviceID, USBBusRef bus) ! 408: { ! 409: usbDevice *device; ! 410: if(bus != 1) ! 411: { ! 412: return(kUSBUnknownDeviceErr); ! 413: } ! 414: device = getDevicePtrFromIdx(deviceID); ! 415: if(device == nil) ! 416: { ! 417: return(kUSBUnknownDeviceErr); ! 418: } ! 419: return(device->ID); ! 420: ! 421: } ! 422: ! 423: usbDevice *getDevicePtr(USBDeviceRef device) ! 424: { ! 425: unsigned deviceIndex; ! 426: ! 427: if( (device & 0x80000000) != 0) ! 428: { ! 429: OSStatus err; ! 430: uslInterface *intrfc; ! 431: ! 432: err = findInterface(device, &intrfc); ! 433: if(intrfc == nil) ! 434: { ! 435: return(nil); ! 436: } ! 437: device = intrfc->device; ! 438: } ! 439: ! 440: deviceIndex = makeDeviceIdx(device); ! 441: if(devices[deviceIndex].ID == device) ! 442: { ! 443: return(&devices[deviceIndex]); ! 444: } ! 445: return(nil); ! 446: } ! 447: ! 448: OSStatus uslRefToBus(USBReference ref, USBBusRef *bus) ! 449: { ! 450: usbDevice *dev; ! 451: dev = getDevicePtr(ref); ! 452: if(dev != nil) ! 453: { ! 454: if(bus != nil) ! 455: { ! 456: *bus = dev->bus; ! 457: } ! 458: return(noErr); ! 459: } ! 460: else ! 461: { ! 462: return(kUSBUnknownDeviceErr); ! 463: } ! 464: ! 465: } ! 466: ! 467: ! 468: /* This one is a prober only hack function */ ! 469: UInt32 uslDeviceAddrToBus(UInt16 addr) ! 470: { ! 471: unsigned deviceIndex; ! 472: ! 473: for(deviceIndex = 0; deviceIndex < kUSBMaxDevices; deviceIndex++) ! 474: { ! 475: if ((devices[deviceIndex].ID != 0) && (devices[deviceIndex].usbAddress == addr)) ! 476: { ! 477: return(devices[deviceIndex].bus); ! 478: } ! 479: } ! 480: return (0xffff); // indicate that we couldn't find a bus ! 481: } ! 482: ! 483: ! 484: ! 485: static void initialiseOneDevice(usbDevice *device) ! 486: { /* Shared by delete device */ ! 487: device->ID = 0; ! 488: } ! 489: ! 490: static void initialiseDevices(void) ! 491: { ! 492: unsigned deviceIndex; ! 493: ! 494: for(deviceIndex = 0; deviceIndex < kUSBMaxDevices; deviceIndex++) ! 495: { ! 496: initialiseOneDevice(&devices[deviceIndex]); ! 497: } ! 498: ! 499: } ! 500: ! 501: UInt8 getNewAddress(void) ! 502: { ! 503: static int addr = -1; ! 504: int counted = 1; ! 505: if(addr == -1) ! 506: { ! 507: AbsoluteTime t; ! 508: t = UpTime(); ! 509: //naga addr = t.lo & 0x7f; ! 510: addr = t & 0x7f; ! 511: } ! 512: do{ ! 513: addr++; ! 514: if(addr > 127) ! 515: { ! 516: addr = 1; ! 517: } ! 518: if(devices[addr].ID == 0) ! 519: { ! 520: break; ! 521: } ! 522: }while(counted++ <= 127); ! 523: ! 524: if(counted > 127) ! 525: { ! 526: addr = 0; ! 527: } ! 528: ! 529: USBExpertStatusLevel(4, 0, "USL - New device:", addr); // Paging Mr. Twycross ! 530: kprintf("****getNewAddress returning addr=%d***\n",addr); ! 531: return(addr); ! 532: } ! 533: ! 534: ! 535: /* This impliments the arbitrary high bits as a counter. */ ! 536: USBDeviceRef MakeDevRef(UInt32 bus, UInt16 addr) ! 537: { ! 538: static long strangeCounter = 0x090263; ! 539: long shiftedCounter; ! 540: ! 541: strangeCounter++; ! 542: shiftedCounter = strangeCounter << kUSBDeviceIDShift; ! 543: if(shiftedCounter == 0) ! 544: { ! 545: shiftedCounter = ++strangeCounter << kUSBDeviceIDShift; ! 546: } ! 547: ! 548: bus = 0; // currenty not used. ! 549: return( (addr + shiftedCounter) & 0x7fffffff); // High bit is zero ! 550: } ! 551: ! 552: /* ************* Pipe Table Maintainance internal functions ************* */ ! 553: ! 554: /* So that stale pipeRefs can not be reused, the pipe ref is */ ! 555: /* the index into the pipe table (the interesting part) */ ! 556: /* and an arbitrary value stuffing the high bits. */ ! 557: /* A pipe ref is only accepted if it matches the pipeRef */ ! 558: /* stored in the pipe structure. */ ! 559: ! 560: /* This impliments the arbitrary high bits as a counter. */ ! 561: static USBPipeRef MakePipeRef(long pipeIdx) ! 562: { ! 563: static long strangeCounter = 0x230259; ! 564: long shiftedCounter; ! 565: ! 566: strangeCounter++; ! 567: shiftedCounter = strangeCounter << kUSBMaxPipeIDShift; ! 568: if(shiftedCounter == 0) ! 569: { ! 570: shiftedCounter = ++strangeCounter << kUSBMaxPipeIDShift; ! 571: } ! 572: return(pipeIdx + shiftedCounter); ! 573: } ! 574: ! 575: /* Given a pipeRef find the pointer to its structure */ ! 576: ! 577: OSStatus findPipe(USBPipeRef pipeRef, pipe **p) ! 578: { ! 579: pipesIdx idx; ! 580: pipe *thePipe; ! 581: ! 582: idx = pipeRef & kUSBPipeIDMask; ! 583: thePipe = & AllPipes[idx]; ! 584: *p = thePipe; ! 585: if(thePipe->ref == pipeRef) ! 586: { ! 587: if(thePipe->state != kUSBActive) ! 588: { ! 589: if(thePipe->state == kUSBIdle) ! 590: { ! 591: return(kUSBPipeIdleError); ! 592: } ! 593: else ! 594: { ! 595: return(kUSBPipeStalledError); ! 596: } ! 597: } ! 598: return(noErr); ! 599: } ! 600: *p = nil; // BT some things rely on this being nil if no pipe, oops. ! 601: return(kUSBUnknownPipeErr); ! 602: } ! 603: ! 604: ! 605: /* This probably is not the best method for pipes */ ! 606: static pipesIdx AllocPipeIdx(void) ! 607: { ! 608: static pipesIdx current; ! 609: pipesIdx new; ! 610: unsigned counted; ! 611: ! 612: /* Allocates a pipe. This implimentation has a pointer to */ ! 613: /* the next pipe to be allocated, which is incrimented each */ ! 614: /* time. If that pipe is in use, the list is search linearly */ ! 615: /* from that point for the next free pipe */ ! 616: /* Same as packet allocator */ ! 617: ! 618: /* Do we need to use atomicTestAndSet for this? */ ! 619: /* Not if transactions are queued */ ! 620: ! 621: new = current; ! 622: counted = 0; ! 623: ! 624: while(counted < kUSBMaxPipes) ! 625: { ! 626: if(AllPipes[new].ref == 0) /* Zero not a valid pipe ref */ ! 627: { ! 628: break; ! 629: } ! 630: counted++; ! 631: new++; ! 632: if(new > kUSBMaxPipes) ! 633: { ! 634: new = 0; ! 635: } ! 636: ! 637: } ! 638: if(counted < kUSBMaxPipes) ! 639: { ! 640: if(counted > 0) ! 641: { ! 642: /* maybe keep track of these at some time */ ! 643: } ! 644: AllPipes[new].ref = 0; ! 645: AllPipes[new].state = kUSBStalled; // This is just here to tell me an open pipe forgot to set state ! 646: } ! 647: else ! 648: { ! 649: /* maybe keep track of these at some time */ ! 650: new = -1; ! 651: } ! 652: ! 653: current++; ! 654: if(current > kUSBMaxPipes) ! 655: { ! 656: current = 0; ! 657: } ! 658: return(new); ! 659: } ! 660: ! 661: int makeDevPipeIdx( UInt8 endpoint, UInt8 direction) ! 662: { ! 663: int devPipeIdx; ! 664: devPipeIdx = endpoint-1; ! 665: if(direction != kUSBOut) ! 666: { ! 667: devPipeIdx += kUSBMaxEndptPerDevice/2; ! 668: } ! 669: return(devPipeIdx); ! 670: } ! 671: ! 672: /* Given a device and an endpoint, wheres the pipe? */ ! 673: pipe *getPipe(usbDevice *device, UInt8 endpoint, UInt8 direction) ! 674: { ! 675: pipesIdx index; ! 676: index = device->pipes[makeDevPipeIdx(endpoint, direction)]; ! 677: if(index == -1) ! 678: { ! 679: return(nil); ! 680: } ! 681: else ! 682: { ! 683: return(&AllPipes[index]); ! 684: } ! 685: } ! 686: ! 687: pipe *getPipeByIdx(pipesIdx idx) ! 688: { ! 689: if(idx > kUSBMaxPipes) ! 690: { ! 691: return(nil); ! 692: } ! 693: ! 694: return(&AllPipes[idx]); ! 695: ! 696: } ! 697: ! 698: /* Allocate a new pipe structure for the given device and endpoint */ ! 699: pipe *AllocPipe(usbDevice *device, UInt8 endpoint, UInt8 direction) ! 700: { ! 701: long newIdx; ! 702: ! 703: newIdx = AllocPipeIdx(); ! 704: if(newIdx == -1) ! 705: { ! 706: return(nil); ! 707: } ! 708: device->pipes[makeDevPipeIdx(endpoint, direction)] = newIdx; ! 709: AllPipes[newIdx].ref = MakePipeRef(newIdx); ! 710: return(&AllPipes[newIdx]); ! 711: } ! 712: ! 713: ! 714: /* XXXXXXXX More to be done */ ! 715: void deallocPipe(usbDevice *device, UInt8 endpoint, UInt8 direction) ! 716: { ! 717: pipesIdx index; ! 718: int devPipeIdx; ! 719: ! 720: devPipeIdx = makeDevPipeIdx(endpoint, direction); ! 721: index = device->pipes[devPipeIdx]; ! 722: AllPipes[index].ref = 0; ! 723: AllPipes[index].state = kUSBStalled; // This is just here to tell me an open pipe forgot to set state ! 724: device->pipes[devPipeIdx] = -1; ! 725: } ! 726: ! 727: ! 728: OSStatus uslClosePipe(pipesIdx pipe) ! 729: { ! 730: OSStatus err; ! 731: if(pipe == -1) ! 732: { ! 733: return(noErr); ! 734: } ! 735: if(AllPipes[pipe].type == kUSBControl) ! 736: { ! 737: kprintf("uslClosePipe:calling UIMControlEDDelete\n"); ! 738: err = UIMControlEDDelete(AllPipes[pipe].bus, AllPipes[pipe].devAddress, AllPipes[pipe].endPt); ! 739: } ! 740: else ! 741: { ! 742: err = UIMEDDelete(AllPipes[pipe].bus, AllPipes[pipe].devAddress, AllPipes[pipe].endPt, AllPipes[pipe].direction); ! 743: } ! 744: ! 745: AllPipes[pipe].ref = 0; ! 746: AllPipes[pipe].state = kUSBStalled; // This is just here to tell me an open pipe forgot to set state ! 747: return(noErr); ! 748: } ! 749: ! 750: void uslCloseNonDefaultPipes(usbDevice *deviceP) ! 751: { ! 752: int i; ! 753: for(i = 0; i< kUSBMaxEndptPerDevice; i++) ! 754: { ! 755: uslClosePipe(deviceP->pipes[i]); ! 756: deviceP->pipes[i] = -1; ! 757: } ! 758: } ! 759: ! 760: void uslCloseInterfacePipes(USBInterfaceRef iRef, usbDevice *deviceP) ! 761: { ! 762: int i; ! 763: for(i = 0; i< kUSBMaxEndptPerDevice; i++) ! 764: { ! 765: if(AllPipes[deviceP->pipes[i]].devIntfRef == iRef) ! 766: { ! 767: uslClosePipe(deviceP->pipes[i]); ! 768: deviceP->pipes[i] = -1; ! 769: } ! 770: } ! 771: } ! 772: ! 773: ! 774: OSStatus validateRef(USBReference ref, UInt32 *bus) ! 775: { ! 776: OSStatus err; ! 777: usbDevice *dev; ! 778: pipe *p; ! 779: ! 780: dev = getDevicePtr(ref); ! 781: if(dev != nil) ! 782: { ! 783: if(bus != nil) ! 784: { ! 785: *bus = dev->bus; ! 786: } ! 787: return(noErr); ! 788: } ! 789: err = findPipe(ref, &p); ! 790: if(p != nil) ! 791: { ! 792: if(bus != nil) ! 793: { ! 794: *bus = p->bus; ! 795: } ! 796: return(noErr); ! 797: } ! 798: if(uslHubValidateDevZero(ref, bus)) ! 799: { ! 800: return(noErr); ! 801: } ! 802: USBExpertStatusLevel(2, ref, "USL - Invalid ref passed to USL", 0); ! 803: ! 804: return(kUSBUnknownDeviceErr); ! 805: } ! 806: ! 807: Boolean isSameDevice(USBReference ref, USBDeviceRef devRef) ! 808: { // true if the ref refers to the device ! 809: usbDevice *dev; ! 810: OSStatus err; ! 811: pipe *p; ! 812: ! 813: dev = getDevicePtr(ref); ! 814: if(dev == nil) ! 815: { ! 816: err = findPipe(ref, &p); ! 817: if(p == nil) ! 818: { ! 819: return(false); ! 820: } ! 821: ! 822: dev = getDevicePtr(p->devIntfRef); ! 823: } ! 824: if(dev != nil) ! 825: { ! 826: if(dev->ID == devRef) ! 827: { ! 828: return(true); ! 829: } ! 830: } ! 831: return(false); ! 832: } ! 833: ! 834: static void ZeroMem(void *addr, UInt32 len) ! 835: { ! 836: UInt8 *byteAddr; ! 837: ! 838: if(len == 0) ! 839: return; ! 840: ! 841: byteAddr = (UInt8 *) addr; ! 842: while(len--) ! 843: { ! 844: *byteAddr++ = 0; ! 845: } ! 846: } ! 847: ! 848: ! 849: void uslUnconfigureDevice(usbDevice *device) ! 850: { ! 851: uslCloseNonDefaultPipes(device); ! 852: deallocAllDeviceInterfaces(device->ID); ! 853: device->currentConfiguration = 0; ! 854: } ! 855: ! 856: OSStatus uslDeleteDevice(USBPB *pb, usbDevice *device) ! 857: { /* All pipes are closed, kill off the device */ ! 858: OSStatus retVal = noErr; ! 859: void *allConfDesc; ! 860: ! 861: if(device->configLock != 0) ! 862: { ! 863: USBExpertStatusLevel(2, device->ID, "USL - Device busy when deleting: Address ==", device->usbAddress); ! 864: device->killMe = true; ! 865: if(device->configLock != 0) ! 866: { // Make sure it hasn't been asynchronously unlocked ! 867: return(noErr); ! 868: } ! 869: USBExpertStatusLevel(2, device->ID, "USL - Device no longer busy: Address ==", device->usbAddress); ! 870: } ! 871: ! 872: USBExpertStatusLevel(4, 0, "USL - Deleting device: Address ==", device->usbAddress); ! 873: ! 874: allConfDesc = device->allConfigDescriptors; ! 875: ! 876: deallocAllDeviceInterfaces(device->ID); ! 877: ! 878: /* Zero out the structure, not strictly necessary, but prudent */ ! 879: /* This bit relies on allConfigDescriptors being the second field after ID */ ! 880: ZeroMem(&device->allConfigDescriptors, sizeof(usbDevice)-OFFSET(usbDevice, allConfigDescriptors)); ! 881: ! 882: initialiseOneDevice(device); ! 883: ! 884: if(allConfDesc != nil) ! 885: { ! 886: if(CurrentExecutionLevel() != kTaskLevel) ! 887: { ! 888: if(pb->usbCompletion == kUSBNoCallBack) ! 889: { ! 890: retVal = kUSBCompletionError; ! 891: } ! 892: else ! 893: { ! 894: pb->usbBuffer = allConfDesc; ! 895: retVal = kUSBPending; ! 896: uslDeallocMem(pb); ! 897: } ! 898: } ! 899: else ! 900: { ! 901: PoolDeallocate(device->allConfigDescriptors); ! 902: } ! 903: } ! 904: ! 905: return(retVal); ! 906: } ! 907: ! 908: ! 909: /* Given a pipeRef, whats the pipe index? */ ! 910: long recoverPipeIdx(USBPipeRef pipeRef) ! 911: { ! 912: if(pipeRef == 0) ! 913: { ! 914: return(-1); ! 915: } ! 916: ! 917: return(pipeRef & kUSBPipeIDMask); ! 918: } ! 919: ! 920: ! 921: /* GIven a pipeRef, find the pipe structure */ ! 922: pipe *GetPipePtr(USBPipeRef pipeRef) ! 923: { ! 924: pipe *retPipe = nil; ! 925: long pipeIdx; ! 926: do{ ! 927: pipeIdx = recoverPipeIdx(pipeRef); ! 928: if(pipeIdx == -1) ! 929: { ! 930: break; ! 931: } ! 932: ! 933: retPipe = &AllPipes[pipeIdx]; ! 934: ! 935: if(pipeRef != retPipe->ref) ! 936: { ! 937: retPipe = nil; ! 938: break; ! 939: } ! 940: ! 941: }while(0); ! 942: ! 943: return(retPipe); ! 944: } ! 945: ! 946: /* Mark all pipes unused */ ! 947: static void initialisePipes(void) ! 948: { ! 949: long index, index2; ! 950: ! 951: /* Mark all pipes close */ ! 952: for(index = 0; index < kUSBMaxDevices; index++) ! 953: { ! 954: for(index2 = 0; index2 < kUSBMaxEndptPerDevice; index2++) ! 955: { ! 956: devices[index].pipes[index2] = -1; ! 957: } ! 958: } ! 959: ! 960: ! 961: } ! 962: #define kUIMRefID 0x061563 ! 963: /* This needs to take account of bus in some manner */ ! 964: USBDeviceRef addNewDevice(UInt32 bus, UInt16 addr, UInt8 speed, UInt8 maxPacket, UInt32 power) ! 965: { ! 966: USBDeviceRef new; ! 967: usbDevice *dev; ! 968: long pipeIdx; ! 969: pipe *pipe0; ! 970: ! 971: new = 0; ! 972: ! 973: do{ /* for error checking */ ! 974: ! 975: if( (addr == 0) || (addr > kUSBMaxDevice) ) ! 976: { ! 977: break; ! 978: } ! 979: ! 980: if(UIMControlEDCreate(bus, addr, 0, maxPacket, speed) != noErr) ! 981: { ! 982: break; ! 983: } ! 984: ! 985: ! 986: dev = &devices[addr]; ! 987: if(dev->ID != 0) ! 988: { ! 989: break; ! 990: } ! 991: ! 992: do ! 993: { ! 994: new = MakeDevRef(bus, addr); ! 995: }while (new == kUIMRefID); ! 996: ! 997: dev->bus = bus; ! 998: dev->ID = new; ! 999: dev->usbAddress = addr; ! 1000: dev->speed = speed; ! 1001: dev->powerAvailable = power; ! 1002: USBExpertStatusLevel(4, dev->ID, "USL - New device power:", power); ! 1003: ! 1004: pipeIdx = AllocPipeIdx(); ! 1005: if(pipeIdx == -1) ! 1006: { ! 1007: break; ! 1008: } ! 1009: dev->pipe0 = pipeIdx; ! 1010: pipe0 = &AllPipes[pipeIdx]; ! 1011: ! 1012: /* this is repeated with open control endpoint. Should be consolodated */ ! 1013: pipe0->bus = bus; ! 1014: pipe0->devIntfRef = new; ! 1015: pipe0->endPt = 0; ! 1016: pipe0->ref = MakePipeRef(pipeIdx); ! 1017: pipe0->devAddress = addr; ! 1018: pipe0->type = kUSBControl; ! 1019: pipe0->state = kUSBActive; ! 1020: for(pipeIdx = 0; pipeIdx < kUSBMaxEndptPerDevice; pipeIdx++) ! 1021: { ! 1022: dev->pipes[pipeIdx] = -1; ! 1023: } ! 1024: ! 1025: }while(0); ! 1026: ! 1027: return(new); ! 1028: } ! 1029: ! 1030: ! 1031: ! 1032: /* ************* Functions dealing with transactions ************* */ ! 1033: ! 1034: /* Each pipe has a number of possible transactions outstanding */ ! 1035: /* on it at one time. The pipe structure has 2 tables one of the */ ! 1036: /* UIM transaction ref for these and another parallel one which */ ! 1037: /* has the index of the packet its using */ ! 1038: ! 1039: ! 1040: ! 1041: /* ************* Actual Functions ************* */ ! 1042: ! 1043: ! 1044: ! 1045: ! 1046: ! 1047: USBPipeRef getPipeZero(USBDeviceRef device) ! 1048: { ! 1049: usbDevice *deviceP; ! 1050: pipesIdx pipe0Idx; ! 1051: USBPipeRef retVal = 0; ! 1052: ! 1053: /* Validate device */ ! 1054: deviceP = getDevicePtr(device); ! 1055: ! 1056: if(deviceP == nil) ! 1057: { ! 1058: return(0); ! 1059: } ! 1060: pipe0Idx = deviceP->pipe0; ! 1061: if( (pipe0Idx < 0) || (pipe0Idx > kUSBMaxPipes) ) ! 1062: { ! 1063: return(0); ! 1064: } ! 1065: return(AllPipes[pipe0Idx].ref); ! 1066: } ! 1067: ! 1068: ! 1069: OSStatus USBServicesInitialise(void *exProc) ! 1070: { ! 1071: kprintf("***USBServicesInitialize:calling severel inits***\n"); ! 1072: if(initialised) ! 1073: { ! 1074: return(kUSBAlreadyOpenErr); ! 1075: } ! 1076: SetExpertFunction(exProc); ! 1077: ! 1078: initialiseDevices(); ! 1079: initialisePipes(); ! 1080: initialiseHubs(); ! 1081: initialiseDelays(); ! 1082: initialiseNotifications(); ! 1083: ! 1084: initialised = true; ! 1085: ! 1086: return(noErr); ! 1087: } ! 1088: ! 1089: void USBServicesFinalise(void) ! 1090: { ! 1091: if(!initialised) ! 1092: { ! 1093: return;//(paramErr); ! 1094: } ! 1095: finaliseHubs(); ! 1096: finaliseDelays(); ! 1097: finaliseNotifications(); ! 1098: ! 1099: initialised = false; ! 1100: } ! 1101: ! 1102: ! 1103: Boolean checkPBVersionIsoc(USBPB *pb, UInt32 flags) ! 1104: { ! 1105: if( ( (pb->pbVersion == 0x109) || (pb->pbVersion == 0x109) )&& ! 1106: (pb->pbLength >= sizeof(USBPB)) && ! 1107: ( (pb->usbCompletion != nil) && (pb->usbCompletion != (void *)-1) ) && ! 1108: ((pb->usbFlags & ~flags) == 0) ) ! 1109: { ! 1110: pb->usbStatus = noErr; ! 1111: return(true); ! 1112: } ! 1113: else ! 1114: { ! 1115: if((pb->pbVersion != 0x109) && (pb->pbVersion != 0x109) ) ! 1116: { ! 1117: USBExpertStatusLevel(2, pb->usbReference, "USL error - Bad param block version", pb->pbVersion); ! 1118: pb->usbStatus = kUSBPBVersionError; ! 1119: } ! 1120: else if(pb->pbLength < sizeof(USBPB)) ! 1121: { ! 1122: USBExpertStatusLevel(2, pb->usbReference, "USL error - small param block version", pb->pbLength); ! 1123: pb->usbStatus = kUSBPBLengthError; ! 1124: } ! 1125: else if( (pb->usbCompletion == nil) || (pb->usbCompletion == (void *)-1) ) ! 1126: { ! 1127: USBExpertStatusLevel(2, pb->usbReference, "USL error - bad completion function", (UInt32)pb->usbCompletion); ! 1128: pb->usbStatus = kUSBCompletionError; ! 1129: } ! 1130: else if((pb->usbFlags & ~flags) != 0) ! 1131: { ! 1132: USBExpertStatusLevel(2, pb->usbReference, "USL error - bad flags", pb->usbFlags & ~flags); ! 1133: pb->usbStatus = kUSBFlagsError; ! 1134: } ! 1135: else ! 1136: { ! 1137: USBExpertStatusLevel(2, pb->usbReference, "USL error - What??", 0); ! 1138: pb->usbStatus = paramErr; ! 1139: } ! 1140: return(false); ! 1141: } ! 1142: } ! 1143: ! 1144: Boolean checkPBVersion(USBPB *pb, UInt32 flags) ! 1145: { ! 1146: if( ( (pb->pbVersion == 2) || (pb->pbVersion == 0x100) || (pb->pbVersion == 0x109))&& ! 1147: (pb->pbLength >= sizeof(USBPB)) && ! 1148: ( (pb->usbCompletion != nil) && (pb->usbCompletion != (void *)-1) ) && ! 1149: ((pb->usbFlags & ~flags) == 0) ) ! 1150: { ! 1151: pb->usbStatus = noErr; ! 1152: return(true); ! 1153: } ! 1154: else ! 1155: { ! 1156: if((pb->pbVersion != 2) && (pb->pbVersion != 0x100) && (pb->pbVersion != 0x109) ) ! 1157: { ! 1158: USBExpertStatusLevel(2, pb->usbReference, "USL error - Bad param block version", pb->pbVersion); ! 1159: pb->usbStatus = kUSBPBVersionError; ! 1160: } ! 1161: else if(pb->pbLength < sizeof(USBPB)) ! 1162: { ! 1163: USBExpertStatusLevel(2, pb->usbReference, "USL error - small param block version", pb->pbLength); ! 1164: pb->usbStatus = kUSBPBLengthError; ! 1165: } ! 1166: else if( (pb->usbCompletion == nil) || (pb->usbCompletion == (void *)-1) ) ! 1167: { ! 1168: USBExpertStatusLevel(2, pb->usbReference, "USL error - bad completion function", (UInt32)pb->usbCompletion); ! 1169: pb->usbStatus = kUSBCompletionError; ! 1170: } ! 1171: else if((pb->usbFlags & ~flags) != 0) ! 1172: { ! 1173: USBExpertStatusLevel(2, pb->usbReference, "USL error - bad flags", pb->usbFlags & ~flags); ! 1174: pb->usbStatus = kUSBFlagsError; ! 1175: } ! 1176: else ! 1177: { ! 1178: USBExpertStatusLevel(2, pb->usbReference, "USL error - What??", 0); ! 1179: pb->usbStatus = paramErr; ! 1180: } ! 1181: return(false); ! 1182: } ! 1183: } ! 1184: ! 1185: ! 1186: ! 1187: UInt8 USBMakeBMRequestType(USBDirection direction, USBRqType type, USBRqRecipient recipient) ! 1188: { ! 1189: UInt8 rq = 0xff; ! 1190: do{ ! 1191: if(direction == kUSBNone) ! 1192: { ! 1193: direction = kUSBOut; ! 1194: } ! 1195: if(direction != kUSBOut && direction != kUSBIn) ! 1196: { ! 1197: break; ! 1198: } ! 1199: if(type < kUSBStandard || type > kUSBVendor) ! 1200: { ! 1201: break; ! 1202: } ! 1203: if(recipient < kUSBDevice || recipient > kUSBOther) ! 1204: { ! 1205: break; ! 1206: } ! 1207: ! 1208: rq = recipient + (type << kUSBRqTypeShift) + (direction << kUSBRqDirnShift); ! 1209: ! 1210: }while(0); ! 1211: return(rq); ! 1212: } ! 1213: ! 1214: ! 1215: ! 1216: OSStatus USBDisposeInterfaceRef(USBPB *pb) ! 1217: { ! 1218: // --> usbReference --> interface ! 1219: OSStatus err; ! 1220: uslInterface *intfrc; ! 1221: Boolean nocallBack = false; ! 1222: ! 1223: if(pb->usbCompletion == kUSBNoCallBack) ! 1224: { ! 1225: nocallBack = true; ! 1226: pb->usbCompletion = (void *)-2; ! 1227: } ! 1228: ! 1229: if(!checkPBVersion(pb, 0)) ! 1230: { ! 1231: return(pb->usbStatus); ! 1232: } ! 1233: err = findInterface(pb->usbReference, &intfrc); ! 1234: if(intfrc == nil) ! 1235: { ! 1236: USBExpertStatusLevel(4, pb->usbReference, "USL - Interface to dispose not found", 0); ! 1237: return(kUSBUnknownInterfaceErr); ! 1238: } ! 1239: intfrc->device = 0; ! 1240: intfrc->interfaceNum = 0; ! 1241: intfrc->alt = 0; ! 1242: intfrc->ref = 0; ! 1243: ! 1244: if(nocallBack) ! 1245: { ! 1246: pb->usbCompletion = kUSBNoCallBack; ! 1247: } ! 1248: else ! 1249: { ! 1250: (*pb->usbCompletion)(pb); ! 1251: } ! 1252: return(kUSBPending); ! 1253: } ! 1254:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.