![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uslPipe.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 uslPipe.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: uslPipe.c ! 27: ! 28: Contains: xxx put contents here xxx ! 29: ! 30: Version: xxx put version here xxx ! 31: ! 32: Copyright: � 1998 by Apple Computer, Inc., all rights reserved. ! 33: ! 34: File Ownership: ! 35: ! 36: DRI: xxx put dri here xxx ! 37: ! 38: Other Contact: xxx put other contact here xxx ! 39: ! 40: Technology: xxx put technology here xxx ! 41: ! 42: Writers: ! 43: ! 44: (BT) Barry Twycross ! 45: ! 46: Change History (most recent first): ! 47: ! 48: <USB18> 11/16/98 BT Clear pipe state on open ! 49: <USB17> 11/5/98 BT Fix returning noErr instead of pending. ! 50: <USB16> 10/22/98 BT Fix wrong status for deleted devices. ! 51: <USB15> 10/12/98 BT Add addressed device request ! 52: <USB14> 9/29/98 BT Use real frame timing ! 53: <USB13> 8/31/98 BT Add isoc pipes ! 54: <USB12> 8/25/98 BT Isoc name changes ! 55: <USB11> 8/24/98 BT Isoc param block definition ! 56: <USB10> 8/13/98 BT Add multibus support ! 57: <USB9> 8/13/98 BT Allow zero length transactions ! 58: <USB8> 7/23/98 BT Cut annoying message ! 59: <USB7> 7/7/98 BT Avoid control reentrancy problem by making sure they're done at ! 60: secondary interrupt time. ! 61: <USB6> 5/21/98 BT Don't corrupt usbBuffer when diverting to opendevice. ! 62: <USB5> 5/20/98 BT Find implicit dev config ! 63: <USB4> 5/20/98 BT Fix pipe devidx field ! 64: <USB3> 5/17/98 BT Device request doesn't squash reqcount, buffer. Add internal ! 65: open pipe for config interface ! 66: <USB2> 4/28/98 BT Add bulk performance monitoring. ! 67: <USB1> 4/26/98 BT first checked in ! 68: */ ! 69: ! 70: #include "../USB.h" ! 71: #include "../USBpriv.h" ! 72: ! 73: #include "uslpriv.h" ! 74: #include "../uimpriv.h" ! 75: ! 76: #include "../driverservices.h" ! 77: ! 78: ! 79: static pipe pipeZeroZero; // the default pipe to device zero ! 80: ! 81: #if 0 ! 82: static OSStatus uslOpenControlEndpoint(struct USBPB *pb) ! 83: { ! 84: usbDevice *deviceP; ! 85: OSStatus retVal = kUSBInternalErr; ! 86: pipe *newPipe; ! 87: ! 88: do{ /* For error recovery */ ! 89: ! 90: /* Validate device */ ! 91: deviceP = getDevicePtr(pb->usbReference); ! 92: ! 93: if(deviceP == nil) ! 94: { ! 95: retVal = kUSBUnknownDeviceErr; ! 96: break; ! 97: } ! 98: ! 99: #if 0 ! 100: /* Validate endpoint */ ! 101: if(deviceP->numberOfEndpoints >= endpoint) ! 102: { ! 103: retVal = kUSBUnknownEndpointErr; ! 104: break; ! 105: } ! 106: #endif ! 107: ! 108: newPipe = getPipe(deviceP, pb->usbValue2); ! 109: ! 110: if(newPipe != nil) ! 111: { ! 112: retVal = kUSBAlreadyOpenErr; ! 113: break; ! 114: } ! 115: ! 116: /* This endpoint has not yet been opened. */ ! 117: if(pb->usbValue2 == 0) /* Endpoint zero is a control endpoint */ ! 118: { ! 119: retVal = kUSBUnknownEndpointErr; ! 120: break; ! 121: } ! 122: ! 123: ! 124: /* Allocate a new pipe */ ! 125: newPipe = AllocPipe(deviceP, pb->usbValue2); ! 126: if(newPipe == nil) ! 127: { ! 128: retVal = kUSBTooManyPipesErr; ! 129: break; ! 130: } ! 131: /* Fill in pertinent information for this pipe instantiation */ ! 132: newPipe->deviceIdx = makeDeviceIdx(pb->usbReference); ! 133: newPipe->intrfc = pb->usbReference; ! 134: newPipe->endPt = pb->usbValue2; ! 135: newPipe->devAddress = deviceP->usbAddress; ! 136: newPipe->flags = pb->usbFlags; ! 137: newPipe->state = kUSBActive; ! 138: ! 139: #if 0 ! 140: retVal = UIMSetupControlEndpoint(newPipe->addEnd, &newPipe->uimRef, ! 141: newPipe->maxPacket, controlCallBack, newPipe->iflags, newPipe->addEnd /* refCon */); ! 142: #endif ! 143: ! 144: if(retVal != kUSBNoErr) ! 145: { ! 146: deallocPipe(deviceP, pb->usbValue2); ! 147: break; ! 148: } ! 149: ! 150: ! 151: pb->usbReference = newPipe->ref; ! 152: ! 153: /* Just assume you can have an endpoint zero for now. */ ! 154: /* Shouldn't this be already open */ ! 155: ! 156: #if 0 ! 157: /* XXXXXXXX In real version should add something here */ ! 158: if(pipeH->type != kUSBControlType) ! 159: { ! 160: retVal = kUSBIncorrectTypeErr; ! 161: break; ! 162: } ! 163: #endif ! 164: ! 165: ! 166: retVal = kUSBNoErr; ! 167: ! 168: break; ! 169: }while(0); /* End error checking */ ! 170: ! 171: return(retVal); ! 172: } ! 173: #endif ! 174: ! 175: static OSStatus uslOpenInterruptEndpoint(USBPB *pb) ! 176: { ! 177: usbDevice *deviceP; ! 178: OSStatus retVal = kUSBInternalErr; ! 179: pipe *newPipe; ! 180: ! 181: do{ /* For error recovery */ ! 182: ! 183: /* Validate device */ ! 184: deviceP = getDevicePtr(pb->usbReference); ! 185: ! 186: if(deviceP == nil) ! 187: { ! 188: retVal = kUSBUnknownDeviceErr; ! 189: break; ! 190: } ! 191: ! 192: #if 0 ! 193: /* Validate endpoint */ ! 194: if(deviceP->numberOfEndpoints >= endpoint) ! 195: { ! 196: retVal = kUSBUnknownEndpointErr; ! 197: break; ! 198: } ! 199: #endif ! 200: ! 201: newPipe = getPipe(deviceP, pb->usbOther, kUSBIn); ! 202: ! 203: if(newPipe != nil) ! 204: { ! 205: retVal = kUSBAlreadyOpenErr; ! 206: break; ! 207: } ! 208: ! 209: /* This endpoint has not yet been opened. */ ! 210: if(pb->usbOther == 0) /* Int pipe can't be zero */ ! 211: { ! 212: retVal = kUSBIncorrectTypeErr; ! 213: break; ! 214: } ! 215: ! 216: ! 217: /* Allocate a new pipe */ ! 218: newPipe = AllocPipe(deviceP, pb->usbOther, kUSBIn); ! 219: if(newPipe == nil) ! 220: { ! 221: retVal = kUSBTooManyPipesErr; ! 222: break; ! 223: } ! 224: ! 225: /* Fill in pertinent information for this pipe instantiation */ ! 226: newPipe->bus = deviceP->bus; ! 227: newPipe->devIntfRef = pb->usbReference; ! 228: newPipe->endPt = pb->usbOther; ! 229: newPipe->direction = kUSBIn; ! 230: newPipe->devAddress = deviceP->usbAddress; ! 231: newPipe->flags = pb->usbFlags; ! 232: newPipe->type = kUSBInterrupt; ! 233: newPipe->maxPacket = pb->usb.cntl.WValue; ! 234: newPipe->state = kUSBActive; ! 235: pb->usbReference = 0; ! 236: ! 237: retVal = UIMInterruptEDCreate(newPipe->bus, ! 238: newPipe->devAddress, ! 239: pb->usbOther, /* User gives Endpoint number here */ ! 240: pb->usb.cntl.WValue, /* System fills in Max packet size here */ ! 241: deviceP->speed); ! 242: ! 243: pb->usbStatus = retVal; ! 244: if(retVal != kUSBNoErr) ! 245: { ! 246: deallocPipe(deviceP, pb->usbOther, kUSBIn); ! 247: break; ! 248: } ! 249: ! 250: pb->usbReference = newPipe->ref; ! 251: if(pb->usbCompletion != nil) ! 252: { ! 253: (*pb->usbCompletion)(pb); ! 254: } ! 255: ! 256: break; ! 257: }while(0); /* End error checking */ ! 258: ! 259: return(retVal); ! 260: } ! 261: ! 262: ! 263: static OSStatus uslOpenIsocEndpoint(USBPB *pb) ! 264: { ! 265: usbDevice *deviceP; ! 266: OSStatus retVal = kUSBInternalErr; ! 267: pipe *newPipe; ! 268: USBDirection usbDirection; ! 269: ! 270: do{ /* For error recovery */ ! 271: ! 272: /* Validate device */ ! 273: deviceP = getDevicePtr(pb->usbReference); ! 274: ! 275: if(deviceP == nil) ! 276: { ! 277: retVal = kUSBUnknownDeviceErr; ! 278: break; ! 279: } ! 280: ! 281: #if 0 ! 282: /* Validate endpoint */ ! 283: if(deviceP->numberOfEndpoints >= endpoint) ! 284: { ! 285: retVal = kUSBUnknownEndpointErr; ! 286: break; ! 287: } ! 288: #endif ! 289: ! 290: usbDirection = pb->usbFlags & 0xff; ! 291: newPipe = getPipe(deviceP, pb->usbOther, usbDirection); ! 292: ! 293: if(newPipe != nil) ! 294: { ! 295: retVal = kUSBAlreadyOpenErr; ! 296: break; ! 297: } ! 298: ! 299: /* This endpoint has not yet been opened. */ ! 300: if(pb->usbOther == 0) /* Isoc pipe can't be zero */ ! 301: { ! 302: retVal = kUSBIncorrectTypeErr; ! 303: break; ! 304: } ! 305: ! 306: ! 307: /* Allocate a new pipe */ ! 308: newPipe = AllocPipe(deviceP, pb->usbOther, usbDirection); ! 309: if(newPipe == nil) ! 310: { ! 311: retVal = kUSBTooManyPipesErr; ! 312: break; ! 313: } ! 314: ! 315: /* Fill in pertinent information for this pipe instantiation */ ! 316: newPipe->bus = deviceP->bus; ! 317: newPipe->devIntfRef = pb->usbReference; ! 318: newPipe->endPt = pb->usbOther; ! 319: newPipe->direction = usbDirection; ! 320: newPipe->devAddress = deviceP->usbAddress; ! 321: newPipe->flags = pb->usbFlags; ! 322: newPipe->type = kUSBIsoc; ! 323: newPipe->maxPacket = pb->usb.cntl.WValue; ! 324: newPipe->state = kUSBActive; ! 325: pb->usbReference = 0; ! 326: ! 327: retVal = UIMIsocEDCreate(newPipe->bus, ! 328: newPipe->devAddress, ! 329: pb->usbOther, /* User gives Endpoint number here */ ! 330: usbDirection, ! 331: pb->usb.cntl.WValue); /* System fills in Max packet size here */ ! 332: ! 333: pb->usbStatus = retVal; ! 334: if(retVal != kUSBNoErr) ! 335: { ! 336: deallocPipe(deviceP, pb->usbOther, usbDirection); ! 337: break; ! 338: } ! 339: ! 340: pb->usbReference = newPipe->ref; ! 341: if(pb->usbCompletion != nil) ! 342: { ! 343: (*pb->usbCompletion)(pb); ! 344: } ! 345: ! 346: break; ! 347: }while(0); /* End error checking */ ! 348: ! 349: return(retVal); ! 350: } ! 351: ! 352: ! 353: static OSStatus uslOpenBulkEndpoint(USBPB *pb) ! 354: { ! 355: usbDevice *deviceP; ! 356: OSStatus retVal = kUSBInternalErr; ! 357: pipe *newPipe; ! 358: USBDirection usbDirection; ! 359: ! 360: do{ /* For error recovery */ ! 361: ! 362: /* Validate device */ ! 363: deviceP = getDevicePtr(pb->usbReference); ! 364: ! 365: if(deviceP == nil) ! 366: { ! 367: retVal = kUSBUnknownDeviceErr; ! 368: break; ! 369: } ! 370: ! 371: #if 0 ! 372: /* Validate endpoint */ ! 373: if(deviceP->numberOfEndpoints >= endpoint) ! 374: { ! 375: retVal = kUSBUnknownEndpointErr; ! 376: break; ! 377: } ! 378: #endif ! 379: ! 380: usbDirection = pb->usbFlags & 0xff; ! 381: ! 382: newPipe = getPipe(deviceP, pb->usbOther, usbDirection); ! 383: ! 384: if(newPipe != nil) ! 385: { ! 386: retVal = kUSBAlreadyOpenErr; ! 387: break; ! 388: } ! 389: ! 390: /* This endpoint has not yet been opened. */ ! 391: if(pb->usbOther == 0) /* Not default pipe */ ! 392: { ! 393: retVal = kUSBIncorrectTypeErr; ! 394: break; ! 395: } ! 396: ! 397: ! 398: /* Allocate a new pipe */ ! 399: newPipe = AllocPipe(deviceP, pb->usbOther, usbDirection ); ! 400: if(newPipe == nil) ! 401: { ! 402: retVal = kUSBTooManyPipesErr; ! 403: break; ! 404: } ! 405: /* Fill in pertinent information for this pipe instantiation */ ! 406: newPipe->bus = deviceP->bus; ! 407: newPipe->devIntfRef = pb->usbReference; ! 408: newPipe->endPt = pb->usbOther; ! 409: newPipe->direction = usbDirection; ! 410: newPipe->devAddress = deviceP->usbAddress; ! 411: newPipe->flags = pb->usbFlags; ! 412: newPipe->type = kUSBBulk; ! 413: newPipe->maxPacket = pb->usb.cntl.WValue; ! 414: newPipe->state = kUSBActive; ! 415: ! 416: retVal = UIMBulkEDCreate(newPipe->bus, ! 417: newPipe->devAddress, ! 418: pb->usbOther, /* User gives Endpoint number here */ ! 419: usbDirection, ! 420: pb->usb.cntl.WValue); ! 421: ! 422: if(retVal != kUSBNoErr) ! 423: { ! 424: deallocPipe(deviceP, pb->usbOther, usbDirection ); ! 425: break; ! 426: } ! 427: ! 428: pb->usbReference = newPipe->ref; ! 429: ! 430: retVal = kUSBNoErr; ! 431: if(pb->usbCompletion != nil) ! 432: { ! 433: (*pb->usbCompletion)(pb); ! 434: } ! 435: ! 436: break; ! 437: }while(0); /* End error checking */ ! 438: ! 439: return(retVal); ! 440: } ! 441: ! 442: static OSStatus usbSIControlPacket(void *p1, void *addrEp) ! 443: { // p1 is pointer to paramblock ! 444: // second param has addr and endpoint munged together ! 445: UInt32 p2; ! 446: UInt8 addr, endPt; ! 447: OSStatus err; ! 448: USBPB *pb; ! 449: UInt32 bus; ! 450: ! 451: p2 = (UInt32)addrEp; ! 452: bus = p2 >> 16; ! 453: addr = (p2>>8) & 0xff; ! 454: endPt = p2 & 0xf; ! 455: ! 456: err = usbControlPacket(bus, p1, addr, endPt); ! 457: if(err != noErr) ! 458: { ! 459: pb = p1; ! 460: if( (pb->usbCompletion != nil) && (pb->usbCompletion != (void *)-1) ) ! 461: { ! 462: pb->usbStatus = err; ! 463: (*pb->usbCompletion)(pb); ! 464: } ! 465: } ! 466: return(noErr); ! 467: } ! 468: ! 469: /* We need to make sure these are queued as well */ ! 470: OSStatus xUSLControlRequest(UInt32 bus, USBPB *pb, pipe *thisPipe) ! 471: { ! 472: setupPacket *packet; ! 473: OSStatus err = kUSBPending; ! 474: ! 475: USBDirection direction; ! 476: USBRqType type; ! 477: USBRqRecipient recipient; ! 478: USBRequest request; ! 479: UInt16 transferSize; ! 480: //kprintf("xUSLControlRequest:ref=0x%x,device=%d\n",thisPipe->ref,thisPipe->devAddress); ! 481: do{ ! 482: direction = pb->usb.cntl.BMRequestType >> 7; ! 483: type = (pb->usb.cntl.BMRequestType >> 5) & 3; ! 484: recipient = pb->usb.cntl.BMRequestType & 31; ! 485: request = pb->usb.cntl.BRequest; ! 486: ! 487: /* FInd the packet in the param block */ ! 488: packet = (void *)&pb->usb.cntl.BMRequestType; ! 489: ! 490: /* Check the direction flag */ ! 491: if(kUSBNone == direction || pb->usbReqCount == 0 || pb->usbBuffer == nil) ! 492: { ! 493: transferSize = 0; /* Don't sit on reqcount and buffer */ ! 494: direction = kUSBOut; ! 495: } ! 496: else ! 497: { ! 498: transferSize = pb->usbReqCount; ! 499: } ! 500: ! 501: /* Put together the bitmap request type byte */ ! 502: if(packet->byte[bmRqType] == 0xff) ! 503: { ! 504: err = kUSBRqErr; ! 505: break; ! 506: } ! 507: ! 508: /* Check the request is a valid one */ ! 509: if( (type == kUSBStandard) && ! 510: (request < kUSBRqGetStatus || request > kUSBRqSyncFrame || ! 511: request == kUSBRqReserved1 || request == kUSBRqReserved2) ) ! 512: { ! 513: err = kUSBUnknownRequestErr; ! 514: break; ! 515: } ! 516: ! 517: /* Put together the rest of the packet */ ! 518: packet->word[wValue] = HostToUSBWord(pb->usb.cntl.WValue); ! 519: packet->word[wIndex] = HostToUSBWord(pb->usb.cntl.WIndex); ! 520: packet->word[wLength] = HostToUSBWord(transferSize); ! 521: ! 522: pb->usbStatus = kUSBPending; ! 523: if(CurrentExecutionLevel() == kSecondaryInterruptLevel) ! 524: { ! 525: err = usbControlPacket(bus, pb, thisPipe->devAddress, thisPipe->endPt); ! 526: } ! 527: else ! 528: { ! 529: #if 0 ! 530: static pipe *rootHub; ! 531: // temp hack. ! 532: // If we're not being called at secondary int, avoid reentrancy prob ! 533: // by arranging to be called at secondary int. ! 534: ! 535: // First try to suppress root hub messages ! 536: if(rootHub == nil) // assume first seen pipe is root hub ! 537: { ! 538: rootHub = thisPipe; ! 539: } ! 540: if(thisPipe != rootHub) ! 541: { ! 542: USBExpertStatus(-1, "\pUSL - Queueing secondary interrupt Control", thisPipe->devAddress); ! 543: } ! 544: #endif ! 545: // now queue the call back. address and endpoint munged into second parameter ! 546: err = QueueSecondaryInterruptHandler(usbSIControlPacket, nil, pb, ! 547: (void *)( ! 548: (bus << 16) + ! 549: ((UInt32)thisPipe->devAddress << 8) + ! 550: ((UInt32)thisPipe->endPt) ! 551: ) ); ! 552: } ! 553: ! 554: /* Processing now continues in controlCallBack */ ! 555: ! 556: ! 557: }while(0); ! 558: ! 559: if(err == noErr) ! 560: { ! 561: err = kUSBPending; ! 562: } ! 563: else ! 564: { ! 565: pb->usbStatus = err; ! 566: } ! 567: return(err); ! 568: } ! 569: ! 570: OSStatus uslDeviceRequest(USBPB *pb) ! 571: { ! 572: USBReference ref0, ref; ! 573: pipe *thisPipe; ! 574: OSStatus retVal = noErr; ! 575: UInt32 bus=0; ! 576: ! 577: do{ ! 578: ref = pb->usbReference; ! 579: ! 580: if((pb->usbFlags & kUSBAddressRequest) != 0) ! 581: { ! 582: USBRqRecipient recipient; ! 583: recipient = pb->usb.cntl.BMRequestType & 31; ! 584: if(recipient == kUSBInterface) ! 585: { ! 586: uslInterface *ifc; ! 587: retVal = findInterface(ref, &ifc); ! 588: if(ifc != nil) ! 589: { ! 590: pb->usb.cntl.WIndex = ifc->interfaceNum; ! 591: } ! 592: } ! 593: else if(recipient == kUSBEndpoint) ! 594: { ! 595: thisPipe = GetPipePtr(ref); ! 596: if(thisPipe != 0) ! 597: { ! 598: ref = thisPipe->devIntfRef; ! 599: pb->usb.cntl.WIndex = thisPipe->endPt; ! 600: if(thisPipe->direction == kUSBIn) ! 601: { ! 602: pb->usb.cntl.WIndex |= 0x80; ! 603: } ! 604: } ! 605: else ! 606: { ! 607: retVal = kUSBUnknownPipeErr; ! 608: } ! 609: } ! 610: else ! 611: { ! 612: retVal = paramErr; ! 613: } ! 614: if(retVal != noErr) ! 615: { ! 616: pb->usbStatus = retVal; ! 617: break; ! 618: } ! 619: } ! 620: ! 621: ref0 = getPipeZero(ref); ! 622: if(ref0 == nil) ! 623: { ! 624: if(uslHubValidateDevZero(ref, &bus)) ! 625: { ! 626: thisPipe = &pipeZeroZero; ! 627: thisPipe->bus = bus; ! 628: } ! 629: else ! 630: { ! 631: retVal = kUSBUnknownDeviceErr; ! 632: break; ! 633: } ! 634: } ! 635: else ! 636: { ! 637: thisPipe = GetPipePtr(ref0); ! 638: if(thisPipe == nil) ! 639: { ! 640: pb->usbStatus = kUSBUnknownPipeErr; ! 641: break; ! 642: } ! 643: } ! 644: retVal = xUSLControlRequest(thisPipe->bus, pb, thisPipe); ! 645: if(retVal != kUSBPending) ! 646: { ! 647: break; ! 648: } ! 649: ! 650: }while(0); ! 651: return(retVal); ! 652: } ! 653: ! 654: ! 655: ! 656: OSStatus USBDeviceRequest(USBPB *pb) ! 657: { ! 658: if(!checkPBVersion(pb, kUSBAddressRequest)) ! 659: { ! 660: return(pb->usbStatus); ! 661: } ! 662: ! 663: /* Short circuit config device requests */ ! 664: if( (pb->pbVersion != 1) && // requires 0.02 PB ! 665: (pb->usb.cntl.BMRequestType == 0) && ! 666: (pb->usb.cntl.BRequest == kUSBRqSetConfig) ) ! 667: { ! 668: pb->usbReqCount = 0; ! 669: pb->usbActCount = 0; ! 670: ! 671: pb->addrStash = (UInt32)pb->usbBuffer; ! 672: pb->usbBuffer = 0; ! 673: return(uslOpenDevice(pb)); ! 674: } ! 675: ! 676: return(uslDeviceRequest(pb)); ! 677: } ! 678: ! 679: ! 680: /* xxxx do checking that params are correct, now we have config desc */ ! 681: ! 682: /* xxxx do checking that params are correct, now we have config desc */ ! 683: static OSStatus uslOpenPipe(USBPB *pb) ! 684: { ! 685: ! 686: switch(pb->usbClassType) ! 687: { ! 688: case kUSBBulk: ! 689: return(uslOpenBulkEndpoint(pb)); ! 690: break; ! 691: ! 692: case kUSBInterrupt: ! 693: return(uslOpenInterruptEndpoint(pb)); ! 694: break; ! 695: ! 696: case kUSBIsoc: ! 697: return(uslOpenIsocEndpoint(pb)); ! 698: break; ! 699: ! 700: case kUSBControl: ! 701: //OSStatus uslOpenControlEndpoint(USBPB *pb); ! 702: return(kUSBIncorrectTypeErr); ! 703: break; ! 704: ! 705: default: ! 706: return(kUSBIncorrectTypeErr); ! 707: break; ! 708: ! 709: } ! 710: } ! 711: ! 712: OSStatus USBOpenPipe(USBPB *pb) ! 713: { ! 714: if(!checkPBVersion(pb, kUSBAnyDirn)) ! 715: { ! 716: return(pb->usbStatus); ! 717: } ! 718: ! 719: return(uslOpenPipe(pb)); ! 720: ! 721: } ! 722: ! 723: ! 724: OSStatus uslOpenPipeImmed(USBInterfaceRef intrfc, USBEndPointDescriptor *endp) ! 725: { ! 726: /* this relies on USBOpenPipe, and the bulk and interrupt opens */ ! 727: /* completing immediatly and not caring if the completion is zero */ ! 728: USBPB pb; ! 729: ! 730: pb.usbReference = intrfc; ! 731: pb.usbCompletion = nil; ! 732: ! 733: if((endp->endpointAddress & 0x80) == 0) ! 734: { ! 735: pb.usbFlags = kUSBOut; ! 736: } ! 737: else ! 738: { ! 739: pb.usbFlags = kUSBIn; ! 740: } ! 741: ! 742: pb.usbClassType = endp->attributes&3; // endpoint type ! 743: pb.usbOther = endp->endpointAddress & 0xf; ! 744: pb.usb.cntl.WValue = USBToHostWord(endp->maxPacketSize); ! 745: return(uslOpenPipe(&pb)); ! 746: } ! 747: ! 748: ! 749: void resolvePerformance(USBPB *pb) ! 750: { ! 751: pipe *thisPipe; ! 752: OSStatus err; ! 753: ! 754: err = findPipe(pb->usbReference, &thisPipe); ! 755: if( (thisPipe != nil) && (thisPipe->monitorPerformance) ) ! 756: { ! 757: pb->usbFrame = deltaFrames(pb->usbFrame, thisPipe->bus); ! 758: AddAtomic(pb->usbFrame, (void *)&thisPipe->transferTime); ! 759: AddAtomic(pb->usbActCount, (void *)&thisPipe->bytesTransfered); ! 760: pb->usbFlags = 0; ! 761: } ! 762: } ! 763: ! 764: OSStatus USBBulkRead(USBPB *pb) ! 765: { ! 766: pipe *thisPipe; ! 767: OSStatus retVal; ! 768: if(!checkPBVersion(pb, 0)) ! 769: { ! 770: return(pb->usbStatus); ! 771: } ! 772: ! 773: retVal = kUSBPending; ! 774: pb->usbStatus = retVal; ! 775: do{ ! 776: /* Find our pipe structure for this */ ! 777: retVal = findPipe(pb->usbReference, &thisPipe); ! 778: if(retVal != noErr) ! 779: { ! 780: break; ! 781: } ! 782: ! 783: if(thisPipe->monitorPerformance) ! 784: { ! 785: pb->usbFlags = 1; ! 786: pb->usbFrame = deltaFrames(0, thisPipe->bus); ! 787: } ! 788: ! 789: /* Validate its a bulk out pipe */ ! 790: if( (thisPipe->direction != kUSBIn) || (thisPipe->type != kUSBBulk) ) ! 791: { ! 792: retVal = kUSBIncorrectTypeErr; ! 793: break; ! 794: } ! 795: ! 796: /* BT 13Aug98, allow zero length transactions, they're valid. */ ! 797: ! 798: retVal = usbBulkPacket(thisPipe->bus, pb, thisPipe->devAddress, thisPipe->endPt, kUSBIn); ! 799: /* Processing now continues in bulkCallBack */ ! 800: ! 801: ! 802: }while(0); ! 803: ! 804: if(retVal == noErr) ! 805: { ! 806: retVal = kUSBPending; ! 807: } ! 808: else ! 809: { ! 810: pb->usbStatus = retVal; ! 811: } ! 812: return(retVal); ! 813: } ! 814: ! 815: OSStatus USBIntRead(USBPB *pb) ! 816: { ! 817: pipe *thisPipe; ! 818: OSStatus retVal; ! 819: ! 820: if(!checkPBVersion(pb, 0)) ! 821: { ! 822: return(pb->usbStatus); ! 823: } ! 824: ! 825: retVal = kUSBPending; ! 826: pb->usbStatus = retVal; ! 827: do{ ! 828: /* Find our pipe structure for this */ ! 829: retVal = findPipe(pb->usbReference, &thisPipe); ! 830: if(retVal != noErr) ! 831: { ! 832: break; ! 833: } ! 834: ! 835: if(thisPipe->monitorPerformance) ! 836: { ! 837: pb->usbFrame = deltaFrames(0, thisPipe->bus); ! 838: } ! 839: ! 840: /* Validate its a bulk out pipe */ ! 841: if( (thisPipe->direction != kUSBIn) || (thisPipe->type != kUSBInterrupt) ) ! 842: { ! 843: retVal = kUSBIncorrectTypeErr; ! 844: break; ! 845: } ! 846: ! 847: /* BT 13Aug98, allow zero length transactions, they're valid. */ ! 848: ! 849: kprintf("USBIntRead:calling usbIntPacket\n"); ! 850: retVal = usbIntPacket(thisPipe->bus, pb, thisPipe->devAddress, thisPipe->endPt, kUSBIn); ! 851: /* Processing now continues in intCallBack */ ! 852: ! 853: ! 854: }while(0); ! 855: if(retVal == noErr) ! 856: { ! 857: retVal = kUSBPending; ! 858: } ! 859: else ! 860: { ! 861: pb->usbStatus = retVal; ! 862: } ! 863: return(retVal); ! 864: } ! 865: ! 866: OSStatus USBIsocRead(USBPB *pb) ! 867: { ! 868: pipe *thisPipe; ! 869: OSStatus retVal; ! 870: ! 871: if(!checkPBVersionIsoc(pb, 0)) ! 872: { ! 873: return(pb->usbStatus); ! 874: } ! 875: ! 876: retVal = kUSBPending; ! 877: pb->usbStatus = retVal; ! 878: do{ ! 879: /* Find our pipe structure for this */ ! 880: retVal = findPipe(pb->usbReference, &thisPipe); ! 881: if(retVal != noErr) ! 882: { ! 883: break; ! 884: } ! 885: ! 886: /* Validate its a bulk out pipe */ ! 887: if( (thisPipe->direction != kUSBIn) || (thisPipe->type != kUSBIsoc) ) ! 888: { ! 889: retVal = kUSBIncorrectTypeErr; ! 890: break; ! 891: } ! 892: ! 893: retVal = usbIsocPacket(thisPipe->bus, pb, thisPipe->devAddress, thisPipe->endPt, kUSBIn); ! 894: /* Processing now continues in bulkCallBack */ ! 895: ! 896: ! 897: }while(0); ! 898: if(retVal == noErr) ! 899: { ! 900: retVal = kUSBPending; ! 901: } ! 902: else ! 903: { ! 904: pb->usbStatus = retVal; ! 905: } ! 906: return(retVal); ! 907: } ! 908: ! 909: OSStatus USBBulkWrite(USBPB *pb) ! 910: { ! 911: pipe *thisPipe; ! 912: OSStatus retVal; ! 913: if(!checkPBVersion(pb, 0)) ! 914: { ! 915: return(pb->usbStatus); ! 916: } ! 917: ! 918: retVal = kUSBPending; ! 919: pb->usbStatus = retVal; ! 920: do{ ! 921: /* Find our pipe structure for this */ ! 922: retVal = findPipe(pb->usbReference, &thisPipe); ! 923: if(retVal != noErr) ! 924: { ! 925: break; ! 926: } ! 927: ! 928: if(thisPipe->monitorPerformance) ! 929: { ! 930: pb->usbFlags = 1; ! 931: pb->usbFrame = deltaFrames(0, thisPipe->bus); ! 932: } ! 933: ! 934: /* Validate its a bulk out pipe */ ! 935: if( (thisPipe->direction != kUSBOut) || (thisPipe->type != kUSBBulk) ) ! 936: { ! 937: retVal = kUSBIncorrectTypeErr; ! 938: break; ! 939: } ! 940: ! 941: /* BT 13Aug98, allow zero length transactions, they're valid. */ ! 942: ! 943: retVal = usbBulkPacket(thisPipe->bus, pb, thisPipe->devAddress, thisPipe->endPt, kUSBOut); ! 944: /* Processing now continues in controlCallBack */ ! 945: ! 946: ! 947: }while(0); ! 948: if(retVal == noErr) ! 949: { ! 950: retVal = kUSBPending; ! 951: } ! 952: else ! 953: { ! 954: pb->usbStatus = retVal; ! 955: } ! 956: return(retVal); ! 957: } ! 958: ! 959: OSStatus USBIsocWrite(USBPB *pb) ! 960: { ! 961: pipe *thisPipe; ! 962: OSStatus retVal; ! 963: if(!checkPBVersionIsoc(pb, 0)) ! 964: { ! 965: return(pb->usbStatus); ! 966: } ! 967: ! 968: retVal = kUSBPending; ! 969: pb->usbStatus = retVal; ! 970: do{ ! 971: /* Find our pipe structure for this */ ! 972: retVal = findPipe(pb->usbReference, &thisPipe); ! 973: if(retVal != noErr) ! 974: { ! 975: break; ! 976: } ! 977: ! 978: /* Validate its a bulk out pipe */ ! 979: if( (thisPipe->direction != kUSBOut) || (thisPipe->type != kUSBIsoc) ) ! 980: { ! 981: retVal = kUSBIncorrectTypeErr; ! 982: break; ! 983: } ! 984: ! 985: retVal = usbIsocPacket(thisPipe->bus, pb, thisPipe->devAddress, thisPipe->endPt, kUSBOut); ! 986: /* Processing now continues in controlCallBack */ ! 987: ! 988: ! 989: }while(0); ! 990: if(retVal == noErr) ! 991: { ! 992: retVal = kUSBPending; ! 993: } ! 994: else ! 995: { ! 996: pb->usbStatus = retVal; ! 997: } ! 998: return(retVal); ! 999: } ! 1000: ! 1001: OSStatus uslMonitorBulkPerformanceByReference(USBPipeRef ref, UInt32 what, ! 1002: UInt32 *lastRead, UInt32 *bytesTransfered, UInt32 *transferTime) ! 1003: { ! 1004: pipe *thisPipe; ! 1005: OSStatus err = noErr; ! 1006: ! 1007: do{ ! 1008: /* Note this can't be a device ref, they're automatically cleared */ ! 1009: /* Find the pipe struct */ ! 1010: err = findPipe(ref, &thisPipe); ! 1011: if(thisPipe == nil) ! 1012: { ! 1013: break; ! 1014: } ! 1015: ! 1016: /* Do something here */ ! 1017: switch(what) ! 1018: { ! 1019: case 0: ! 1020: /* stop monitoring this pipe */ ! 1021: if(thisPipe->monitorPerformance) ! 1022: { ! 1023: thisPipe->monitorPerformance = false; ! 1024: } ! 1025: else ! 1026: { ! 1027: err = kUSBNotFound; ! 1028: } ! 1029: break; ! 1030: ! 1031: case 1: ! 1032: /* Start monitoring pipe */ ! 1033: if(thisPipe->monitorPerformance) ! 1034: { ! 1035: err = kUSBAlreadyOpenErr; ! 1036: } ! 1037: else ! 1038: { ! 1039: thisPipe->monitorPerformance = true; ! 1040: thisPipe->lastRead = deltaFrames(0, thisPipe->bus); ! 1041: } ! 1042: break; ! 1043: ! 1044: case 2: ! 1045: /* Get stats, don't clear */ ! 1046: if(thisPipe->monitorPerformance) ! 1047: { ! 1048: *lastRead = thisPipe->lastRead; ! 1049: thisPipe->lastRead = deltaFrames(0, thisPipe->bus); ! 1050: *bytesTransfered = thisPipe->bytesTransfered; ! 1051: *transferTime = thisPipe->transferTime; ! 1052: } ! 1053: else ! 1054: { ! 1055: err = kUSBNotFound; ! 1056: } ! 1057: break; ! 1058: ! 1059: case 3: ! 1060: /* Get stats clear */ ! 1061: if(thisPipe->monitorPerformance) ! 1062: { ! 1063: thisPipe->monitorPerformance = true; ! 1064: } ! 1065: *lastRead = thisPipe->lastRead; ! 1066: thisPipe->lastRead = deltaFrames(0, thisPipe->bus); ! 1067: *bytesTransfered = thisPipe->bytesTransfered; ! 1068: *transferTime = thisPipe->transferTime; ! 1069: ! 1070: AddAtomic(-*bytesTransfered, (void *)&thisPipe->bytesTransfered); ! 1071: AddAtomic(-*transferTime, (void *)&thisPipe->transferTime); ! 1072: ! 1073: break; ! 1074: ! 1075: } ! 1076: ! 1077: }while(0); ! 1078: ! 1079: return(err); ! 1080: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.