![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOUSBUserClient.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOUSBBus|
Return to IOUSBUserClient.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOUSBBus |
1.1 ! root 1: /* ! 2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* ! 23: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 24: * ! 25: * HISTORY ! 26: * 16 Mar 1999 wgulland created. ! 27: * ! 28: */ ! 29: #include <libkern/OSByteOrder.h> ! 30: ! 31: #include <IOKit/assert.h> ! 32: #include <IOKit/IOLib.h> ! 33: #include <IOKit/IOBufferMemoryDescriptor.h> ! 34: #include <IOKit/usb/IOUSBDevice.h> ! 35: #include <IOKit/usb/IOUSBInterface.h> ! 36: #include <IOKit/usb/IOUSBPipe.h> ! 37: ! 38: #include "IOUSBUserClient.h" ! 39: ! 40: #define super IOUserClient ! 41: #define DEBUGGING_LEVEL 0 ! 42: ! 43: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 44: ! 45: OSDefineMetaClass( IOUSBUserClient, IOUserClient ) ! 46: OSDefineAbstractStructors(IOUSBUserClient, IOUserClient) ! 47: ! 48: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 49: ! 50: bool IOUSBUserClient::start( IOService * provider ) ! 51: { ! 52: IOUSBNub *owner = OSDynamicCast(IOUSBNub, provider); ! 53: ! 54: assert(owner); ! 55: if(!super::start(provider)) ! 56: return false; ! 57: ! 58: fPipes[0] = owner->pipeZero(); ! 59: if(!fPipes[0]) ! 60: return false; ! 61: ! 62: // Initialize the call structures valid for IOUSBNub ! 63: fMethods[kUSBSetConfig].object = NULL; ! 64: fMethods[kUSBSetConfig].func = NULL; ! 65: fMethods[kUSBSetConfig].count0 = 1; ! 66: fMethods[kUSBSetConfig].count1 = 0; ! 67: fMethods[kUSBSetConfig].flags = kIOUCScalarIScalarO; ! 68: ! 69: fMethods[kUSBGetConfig].object = provider; ! 70: fMethods[kUSBGetConfig].func = (IOMethod)&IOUSBNub::GetConfiguration; ! 71: fMethods[kUSBGetConfig].count0 = 0; ! 72: fMethods[kUSBGetConfig].count1 = 1; ! 73: fMethods[kUSBGetConfig].flags = kIOUCScalarIScalarO; ! 74: ! 75: fMethods[kUSBGetConfigDescriptor].object = NULL; ! 76: fMethods[kUSBGetConfigDescriptor].func = NULL; ! 77: fMethods[kUSBGetConfigDescriptor].count0 = 1; ! 78: fMethods[kUSBGetConfigDescriptor].count1 = 0xffffffff; // variable ! 79: fMethods[kUSBGetConfigDescriptor].flags = kIOUCScalarIStructO; ! 80: ! 81: fMethods[kUSBControlReqOut].object = this; ! 82: fMethods[kUSBControlReqOut].func = ! 83: (IOMethod)&IOUSBUserClient::ControlReqOut; ! 84: fMethods[kUSBControlReqOut].count0 = 4; ! 85: fMethods[kUSBControlReqOut].count1 = 0xffffffff; // variable ! 86: fMethods[kUSBControlReqOut].flags = kIOUCScalarIStructI; ! 87: ! 88: fMethods[kUSBControlReqIn].object = this; ! 89: fMethods[kUSBControlReqIn].func = ! 90: (IOMethod)&IOUSBUserClient::ControlReqIn; ! 91: fMethods[kUSBControlReqIn].count0 = 4; ! 92: fMethods[kUSBControlReqIn].count1 = 0xffffffff; // variable ! 93: fMethods[kUSBControlReqIn].flags = kIOUCScalarIStructO; ! 94: ! 95: fMethods[kUSBOpenPipe].object = NULL; ! 96: fMethods[kUSBOpenPipe].func = NULL; ! 97: fMethods[kUSBOpenPipe].count0 = 4; ! 98: fMethods[kUSBOpenPipe].count1 = 1; ! 99: fMethods[kUSBOpenPipe].flags = kIOUCScalarIScalarO; ! 100: ! 101: fMethods[kUSBClosePipe].object = this; ! 102: fMethods[kUSBClosePipe].func = ! 103: (IOMethod)&IOUSBUserClient::ClosePipe; ! 104: fMethods[kUSBClosePipe].count0 = 1; ! 105: fMethods[kUSBClosePipe].count1 = 0; ! 106: fMethods[kUSBClosePipe].flags = kIOUCScalarIScalarO; ! 107: ! 108: fMethods[kUSBReadPipe].object = this; ! 109: fMethods[kUSBReadPipe].func = ! 110: (IOMethod)&IOUSBUserClient::ReadPipe; ! 111: fMethods[kUSBReadPipe].count0 = 1; ! 112: fMethods[kUSBReadPipe].count1 = 0xffffffff; // variable ! 113: fMethods[kUSBReadPipe].flags = kIOUCScalarIStructO; ! 114: ! 115: fMethods[kUSBWritePipe].object = this; ! 116: fMethods[kUSBWritePipe].func = ! 117: (IOMethod)&IOUSBUserClient::WritePipe; ! 118: fMethods[kUSBWritePipe].count0 = 1; ! 119: fMethods[kUSBWritePipe].count1 = 0xffffffff; // variable ! 120: fMethods[kUSBWritePipe].flags = kIOUCScalarIStructI; ! 121: ! 122: fMethods[kUSBGetPipeStatus].object = this; ! 123: fMethods[kUSBGetPipeStatus].func = ! 124: (IOMethod)&IOUSBUserClient::getPipeStatus; ! 125: fMethods[kUSBGetPipeStatus].count0 = 1; ! 126: fMethods[kUSBGetPipeStatus].count1 = 0; ! 127: fMethods[kUSBGetPipeStatus].flags = kIOUCScalarIScalarO; ! 128: ! 129: fMethods[kUSBAbortPipe].object = this; ! 130: fMethods[kUSBAbortPipe].func = ! 131: (IOMethod)&IOUSBUserClient::abortPipe; ! 132: fMethods[kUSBAbortPipe].count0 = 1; ! 133: fMethods[kUSBAbortPipe].count1 = 0; ! 134: fMethods[kUSBAbortPipe].flags = kIOUCScalarIScalarO; ! 135: ! 136: fMethods[kUSBResetPipe].object = this; ! 137: fMethods[kUSBResetPipe].func = ! 138: (IOMethod)&IOUSBUserClient::resetPipe; ! 139: fMethods[kUSBResetPipe].count0 = 1; ! 140: fMethods[kUSBResetPipe].count1 = 0; ! 141: fMethods[kUSBResetPipe].flags = kIOUCScalarIScalarO; ! 142: ! 143: fMethods[kUSBSetPipeIdle].object = this; ! 144: fMethods[kUSBSetPipeIdle].func = ! 145: (IOMethod)&IOUSBUserClient::setPipeIdle; ! 146: fMethods[kUSBSetPipeIdle].count0 = 1; ! 147: fMethods[kUSBSetPipeIdle].count1 = 0; ! 148: fMethods[kUSBSetPipeIdle].flags = kIOUCScalarIScalarO; ! 149: ! 150: fMethods[kUSBSetPipeActive].object = this; ! 151: fMethods[kUSBSetPipeActive].func = ! 152: (IOMethod)&IOUSBUserClient::setPipeActive; ! 153: fMethods[kUSBSetPipeActive].count0 = 1; ! 154: fMethods[kUSBSetPipeActive].count1 = 0; ! 155: fMethods[kUSBSetPipeActive].flags = kIOUCScalarIScalarO; ! 156: ! 157: fMethods[kUSBClearPipeStall].object = this; ! 158: fMethods[kUSBClearPipeStall].func = ! 159: (IOMethod)&IOUSBUserClient::clearPipeStall; ! 160: fMethods[kUSBClearPipeStall].count0 = 1; ! 161: fMethods[kUSBClearPipeStall].count1 = 0; ! 162: fMethods[kUSBClearPipeStall].flags = kIOUCScalarIScalarO; ! 163: ! 164: fMethods[kUSBReadPipeOOL].object = this; ! 165: fMethods[kUSBReadPipeOOL].func = ! 166: (IOMethod)&IOUSBUserClient::ReadPipeOOL; ! 167: fMethods[kUSBReadPipeOOL].count0 = 3; ! 168: fMethods[kUSBReadPipeOOL].count1 = 1; ! 169: fMethods[kUSBReadPipeOOL].flags = kIOUCScalarIScalarO; ! 170: ! 171: fAsyncMethods[kUSBReadPipeOOL].object = this; ! 172: fAsyncMethods[kUSBReadPipeOOL].func = ! 173: (IOAsyncMethod)&IOUSBUserClient::ReadPipeAsync; ! 174: fAsyncMethods[kUSBReadPipeOOL].count0 = 3; ! 175: fAsyncMethods[kUSBReadPipeOOL].count1 = 0; ! 176: fAsyncMethods[kUSBReadPipeOOL].flags = kIOUCScalarIScalarO; ! 177: ! 178: fMethods[kUSBWritePipeOOL].object = this; ! 179: fMethods[kUSBWritePipeOOL].func = ! 180: (IOMethod)&IOUSBUserClient::WritePipeOOL; ! 181: fMethods[kUSBWritePipeOOL].count0 = 3; ! 182: fMethods[kUSBWritePipeOOL].count1 = 0; ! 183: fMethods[kUSBWritePipeOOL].flags = kIOUCScalarIScalarO; ! 184: ! 185: fAsyncMethods[kUSBWritePipeOOL].object = this; ! 186: fAsyncMethods[kUSBWritePipeOOL].func = ! 187: (IOAsyncMethod)&IOUSBUserClient::WritePipeAsync; ! 188: fAsyncMethods[kUSBWritePipeOOL].count0 = 3; ! 189: fAsyncMethods[kUSBWritePipeOOL].count1 = 0; ! 190: fAsyncMethods[kUSBWritePipeOOL].flags = kIOUCScalarIScalarO; ! 191: ! 192: fMethods[kUSBControlReqInOOL].object = this; ! 193: fMethods[kUSBControlReqInOOL].func = ! 194: (IOMethod)&IOUSBUserClient::ControlReqInOOL; ! 195: fMethods[kUSBControlReqInOOL].count0 = sizeof(DevReqOOL); ! 196: fMethods[kUSBControlReqInOOL].count1 = sizeof(UInt32); ! 197: fMethods[kUSBControlReqInOOL].flags = kIOUCStructIStructO; ! 198: ! 199: fAsyncMethods[kUSBControlReqInOOL].object = this; ! 200: fAsyncMethods[kUSBControlReqInOOL].func = ! 201: (IOAsyncMethod)&IOUSBUserClient::ControlReqInAsync; ! 202: fAsyncMethods[kUSBControlReqInOOL].count0 = sizeof(DevReqOOL); ! 203: fAsyncMethods[kUSBControlReqInOOL].count1 = 0; ! 204: fAsyncMethods[kUSBControlReqInOOL].flags = kIOUCStructIStructO; ! 205: ! 206: fMethods[kUSBControlReqOutOOL].object = this; ! 207: fMethods[kUSBControlReqOutOOL].func = ! 208: (IOMethod)&IOUSBUserClient::ControlReqOutOOL; ! 209: fMethods[kUSBControlReqOutOOL].count0 = sizeof(DevReqOOL); ! 210: fMethods[kUSBControlReqOutOOL].count1 = 0; ! 211: fMethods[kUSBControlReqOutOOL].flags = kIOUCStructIStructO; ! 212: ! 213: fAsyncMethods[kUSBControlReqOutOOL].object = this; ! 214: fAsyncMethods[kUSBControlReqOutOOL].func = ! 215: (IOAsyncMethod)&IOUSBUserClient::ControlReqOutAsync; ! 216: fAsyncMethods[kUSBControlReqOutOOL].count0 = sizeof(DevReqOOL); ! 217: fAsyncMethods[kUSBControlReqOutOOL].count1 = 0; ! 218: fAsyncMethods[kUSBControlReqOutOOL].flags = kIOUCStructIStructO; ! 219: ! 220: ! 221: fMethods[kUSBResetDevice].object = NULL; ! 222: fMethods[kUSBResetDevice].func = NULL; ! 223: fMethods[kUSBResetDevice].count0 = 0; ! 224: fMethods[kUSBResetDevice].count1 = 0; ! 225: fMethods[kUSBResetDevice].flags = kIOUCScalarIScalarO; ! 226: ! 227: return true; ! 228: } ! 229: ! 230: IOExternalMethod * ! 231: IOUSBUserClient::getExternalMethodForIndex( UInt32 index ) ! 232: { ! 233: if(index >= kNumUSBMethods || fMethods[index].object == NULL) ! 234: return NULL; ! 235: else ! 236: return &fMethods[index]; ! 237: } ! 238: ! 239: IOExternalAsyncMethod * ! 240: IOUSBUserClient::getExternalAsyncMethodForIndex( UInt32 index ) ! 241: { ! 242: if(index >= kNumUSBMethods || fAsyncMethods[index].object == NULL) ! 243: return NULL; ! 244: else ! 245: return &fAsyncMethods[index]; ! 246: } ! 247: ! 248: /* ! 249: * There's a limit of max 6 arguments to user client methods, so the type, recipient and request ! 250: * are packed into one 16 bit integer. ! 251: */ ! 252: IOReturn ! 253: IOUSBUserClient::ControlReqIn(UInt32 pipe, UInt16 bmreqtypeRequest, UInt16 wValue, ! 254: UInt16 wIndex, void *buf, UInt32 *size) ! 255: { ! 256: IOReturn res; ! 257: IOUSBDevRequest req; ! 258: IOUSBPipe *pipeObj; ! 259: ! 260: pipeObj = fPipes[pipe]; ! 261: if(!pipeObj) ! 262: return kIOUSBUnknownPipeErr; ! 263: ! 264: req.rqDirection = kUSBIn; ! 265: req.rqType = (bmreqtypeRequest >> kUSBRqTypeShift) & kUSBRqTypeMask; ! 266: req.rqRecipient = bmreqtypeRequest & kUSBRqRecipientMask; ! 267: req.bRequest = bmreqtypeRequest >> 8; ! 268: OSWriteLittleInt16(&req.wValue, 0, wValue); ! 269: OSWriteLittleInt16(&req.wIndex, 0, wIndex); ! 270: OSWriteLittleInt16(&req.wLength, 0, *size); ! 271: req.pData = buf; ! 272: res = pipeObj->controlRequest(&req); ! 273: ! 274: if(res == kIOReturnSuccess) { ! 275: *size = req.wLenDone; ! 276: } ! 277: else { ! 278: IOLog("IOUSBUserClient::ControlReqIn err:0x%x\n", res); ! 279: *size = 0; ! 280: } ! 281: return res; ! 282: } ! 283: ! 284: /* ! 285: * There's a limit of max 6 arguments to user client methods, so the type, recipient and request ! 286: * are packed into one 16 bit integer. ! 287: */ ! 288: IOReturn ! 289: IOUSBUserClient::ControlReqOut(UInt32 pipe, UInt16 bmreqtypeRequest, UInt16 wValue, ! 290: UInt16 wIndex, void *buf, UInt32 size) ! 291: { ! 292: IOReturn res; ! 293: IOUSBDevRequest req; ! 294: IOUSBPipe *pipeObj; ! 295: ! 296: pipeObj = fPipes[pipe]; ! 297: if(!pipeObj) ! 298: return kIOUSBUnknownPipeErr; ! 299: ! 300: req.rqDirection = kUSBOut; ! 301: req.rqType = (bmreqtypeRequest >> kUSBRqTypeShift) & kUSBRqTypeMask; ! 302: req.rqRecipient = bmreqtypeRequest & kUSBRqRecipientMask; ! 303: req.bRequest = bmreqtypeRequest >> 8; ! 304: OSWriteLittleInt16(&req.wValue, 0, wValue); ! 305: OSWriteLittleInt16(&req.wIndex, 0, wIndex); ! 306: OSWriteLittleInt16(&req.wLength, 0, size); ! 307: req.pData = buf; ! 308: res = pipeObj->controlRequest(&req); ! 309: ! 310: if(kIOReturnSuccess != res) { ! 311: IOLog("IOUSBUserClient::ControlReqOut err:0x%x\n", res); ! 312: } ! 313: return res; ! 314: } ! 315: ! 316: IOReturn ! 317: IOUSBUserClient::ControlReqInOOL(DevReqOOL *reqIn, UInt32 *sizeOut, IOByteCount inCount, ! 318: IOByteCount *outCount) ! 319: { ! 320: IOReturn res; ! 321: IOUSBDevRequestDesc req; ! 322: IOMemoryDescriptor * mem; ! 323: IOUSBPipe * pipeObj; ! 324: ! 325: if(inCount != sizeof(DevReqOOL) || ! 326: *outCount != sizeof(UInt32)) ! 327: return kIOReturnBadArgument; ! 328: ! 329: pipeObj = fPipes[reqIn->pipe]; ! 330: if(!pipeObj) ! 331: return kIOUSBUnknownPipeErr; ! 332: ! 333: mem = IOMemoryDescriptor::withAddress((vm_address_t)reqIn->buf, reqIn->sizeIn, ! 334: kIODirectionIn, ! 335: fTask); ! 336: if(!mem) { ! 337: return kIOReturnNoMemory; ! 338: } ! 339: req.rqDirection = kUSBIn; ! 340: req.rqType = (reqIn->bmreqtype >> kUSBRqTypeShift) & kUSBRqTypeMask; ! 341: req.rqRecipient = reqIn->bmreqtype & kUSBRqRecipientMask; ! 342: req.bRequest = reqIn->request; ! 343: OSWriteLittleInt16(&req.wValue, 0, reqIn->wValue); ! 344: OSWriteLittleInt16(&req.wIndex, 0, reqIn->wIndex); ! 345: OSWriteLittleInt16(&req.wLength, 0, reqIn->sizeIn); ! 346: req.pData = mem; ! 347: ! 348: res = mem->prepare(); ! 349: if(res == kIOReturnSuccess) ! 350: res = pipeObj->controlRequest(&req); ! 351: mem->complete(); ! 352: mem->release(); ! 353: if(res == kIOReturnSuccess) { ! 354: *sizeOut = req.wLenDone; ! 355: } ! 356: else { ! 357: IOLog("IOUSBUserClient::ControlReqInOOL err:0x%x\n", res); ! 358: *sizeOut = 0; ! 359: } ! 360: *outCount = sizeof(UInt32); ! 361: ! 362: return res; ! 363: } ! 364: ! 365: typedef struct AsyncPB { ! 366: OSAsyncReference fAsyncRef; ! 367: UInt32 fMax; ! 368: IOMemoryDescriptor *fMem; ! 369: }; ! 370: ! 371: IOReturn ! 372: IOUSBUserClient::ControlReqInAsync(OSAsyncReference asyncRef, ! 373: DevReqOOL *reqIn, IOByteCount inCount) ! 374: { ! 375: IOReturn res; ! 376: IOUSBDevRequestDesc req; ! 377: IOUSBPipe * pipeObj; ! 378: ! 379: IOUSBCompletion tap; ! 380: AsyncPB * pb = NULL; ! 381: IOMemoryDescriptor * mem = NULL; ! 382: ! 383: if(inCount != sizeof(DevReqOOL)) ! 384: return kIOReturnBadArgument; ! 385: ! 386: pipeObj = fPipes[reqIn->pipe]; ! 387: if(!pipeObj) ! 388: return kIOUSBUnknownPipeErr; ! 389: ! 390: do { ! 391: mem = IOMemoryDescriptor::withAddress((vm_address_t)reqIn->buf, ! 392: reqIn->sizeIn, ! 393: kIODirectionIn, ! 394: fTask); ! 395: if(!mem) { ! 396: res = kIOReturnNoMemory; ! 397: break; ! 398: } ! 399: res = mem->prepare(); ! 400: if(res != kIOReturnSuccess) ! 401: break; ! 402: pb = (AsyncPB *)IOMalloc(sizeof(AsyncPB)); ! 403: if(!pb) { ! 404: res = kIOReturnNoMemory; ! 405: break; ! 406: } ! 407: ! 408: req.rqDirection = kUSBIn; ! 409: req.rqType = (reqIn->bmreqtype >> kUSBRqTypeShift) & kUSBRqTypeMask; ! 410: req.rqRecipient = reqIn->bmreqtype & kUSBRqRecipientMask; ! 411: req.bRequest = reqIn->request; ! 412: OSWriteLittleInt16(&req.wValue, 0, reqIn->wValue); ! 413: OSWriteLittleInt16(&req.wIndex, 0, reqIn->wIndex); ! 414: OSWriteLittleInt16(&req.wLength, 0, reqIn->sizeIn); ! 415: req.pData = mem; ! 416: ! 417: bcopy(asyncRef, pb->fAsyncRef, sizeof(OSAsyncReference)); ! 418: pb->fMax = reqIn->sizeIn; ! 419: pb->fMem = mem; ! 420: tap.target = this; ! 421: tap.action = &ReqComplete; ! 422: tap.parameter = pb; ! 423: res = pipeObj->controlRequest(&req, &tap); ! 424: ! 425: } while (false); ! 426: ! 427: if(res != kIOReturnSuccess) { ! 428: IOLog("ControlReqInAsync err 0x%x\n", res); ! 429: if(mem) { ! 430: mem->complete(); ! 431: mem->release(); ! 432: } ! 433: if(pb) ! 434: IOFree(pb, sizeof(*pb)); ! 435: } ! 436: ! 437: return res; ! 438: } ! 439: ! 440: void ! 441: IOUSBUserClient::ReqComplete(void *obj, void *param, IOReturn res, UInt32 remaining) ! 442: { ! 443: void * args[1]; ! 444: AsyncPB * pb = (AsyncPB *)param; ! 445: ! 446: if(res == kIOReturnSuccess) { ! 447: args[0] = (void *)(pb->fMax - remaining); ! 448: } ! 449: else { ! 450: IOLog("IOUSBUserClient::ReqComplete err:0x%x\n", res); ! 451: args[0] = 0; ! 452: } ! 453: pb->fMem->complete(); ! 454: pb->fMem->release(); ! 455: sendAsyncResult(pb->fAsyncRef, res, args, 1); ! 456: ! 457: IOFree(pb, sizeof(*pb)); ! 458: } ! 459: ! 460: IOReturn ! 461: IOUSBUserClient::ControlReqOutOOL(DevReqOOL *reqIn, IOByteCount inCount) ! 462: { ! 463: IOReturn res; ! 464: IOUSBDevRequestDesc req; ! 465: IOMemoryDescriptor * mem; ! 466: IOUSBPipe * pipeObj; ! 467: ! 468: if(inCount != sizeof(DevReqOOL)) ! 469: return kIOReturnBadArgument; ! 470: ! 471: pipeObj = fPipes[reqIn->pipe]; ! 472: if(!pipeObj) ! 473: return kIOUSBUnknownPipeErr; ! 474: ! 475: ! 476: mem = IOMemoryDescriptor::withAddress((vm_address_t)reqIn->buf, ! 477: reqIn->sizeIn, kIODirectionOut, fTask); ! 478: if(!mem) { ! 479: return kIOReturnNoMemory; ! 480: } ! 481: req.rqDirection = kUSBOut; ! 482: req.rqType = (reqIn->bmreqtype >> kUSBRqTypeShift) & kUSBRqTypeMask; ! 483: req.rqRecipient = reqIn->bmreqtype & kUSBRqRecipientMask; ! 484: req.bRequest = reqIn->request; ! 485: OSWriteLittleInt16(&req.wValue, 0, reqIn->wValue); ! 486: OSWriteLittleInt16(&req.wIndex, 0, reqIn->wIndex); ! 487: OSWriteLittleInt16(&req.wLength, 0, reqIn->sizeIn); ! 488: req.pData = mem; ! 489: ! 490: res = mem->prepare(); ! 491: if(res == kIOReturnSuccess) ! 492: res = pipeObj->controlRequest(&req); ! 493: mem->complete(); ! 494: mem->release(); ! 495: return res; ! 496: } ! 497: ! 498: IOReturn ! 499: IOUSBUserClient::ControlReqOutAsync(OSAsyncReference asyncRef, ! 500: DevReqOOL *reqIn, IOByteCount inCount) ! 501: { ! 502: IOReturn res; ! 503: IOUSBDevRequestDesc req; ! 504: IOUSBPipe * pipeObj; ! 505: ! 506: IOUSBCompletion tap; ! 507: AsyncPB * pb = NULL; ! 508: IOMemoryDescriptor * mem = NULL; ! 509: ! 510: if(inCount != sizeof(DevReqOOL)) ! 511: return kIOReturnBadArgument; ! 512: ! 513: pipeObj = fPipes[reqIn->pipe]; ! 514: if(!pipeObj) ! 515: return kIOUSBUnknownPipeErr; ! 516: ! 517: do { ! 518: mem = IOMemoryDescriptor::withAddress((vm_address_t)reqIn->buf, ! 519: reqIn->sizeIn, ! 520: kIODirectionOut, ! 521: fTask); ! 522: if(!mem) { ! 523: res = kIOReturnNoMemory; ! 524: break; ! 525: } ! 526: res = mem->prepare(); ! 527: if(res != kIOReturnSuccess) ! 528: break; ! 529: pb = (AsyncPB *)IOMalloc(sizeof(AsyncPB)); ! 530: if(!pb) { ! 531: res = kIOReturnNoMemory; ! 532: break; ! 533: } ! 534: ! 535: req.rqDirection = kUSBOut; ! 536: req.rqType = (reqIn->bmreqtype >> kUSBRqTypeShift) & kUSBRqTypeMask; ! 537: req.rqRecipient = reqIn->bmreqtype & kUSBRqRecipientMask; ! 538: req.bRequest = reqIn->request; ! 539: OSWriteLittleInt16(&req.wValue, 0, reqIn->wValue); ! 540: OSWriteLittleInt16(&req.wIndex, 0, reqIn->wIndex); ! 541: OSWriteLittleInt16(&req.wLength, 0, reqIn->sizeIn); ! 542: req.pData = mem; ! 543: ! 544: bcopy(asyncRef, pb->fAsyncRef, sizeof(OSAsyncReference)); ! 545: pb->fMax = reqIn->sizeIn; ! 546: pb->fMem = mem; ! 547: tap.target = this; ! 548: tap.action = &ReqComplete; // Want same number of reply args as for ControlReqIn ! 549: tap.parameter = pb; ! 550: res = pipeObj->controlRequest(&req, &tap); ! 551: ! 552: } while (false); ! 553: ! 554: if(res != kIOReturnSuccess) { ! 555: IOLog("controlRequest err 0x%x\n", res); ! 556: if(mem) { ! 557: mem->complete(); ! 558: mem->release(); ! 559: } ! 560: if(pb) ! 561: IOFree(pb, sizeof(*pb)); ! 562: } ! 563: ! 564: return res; ! 565: } ! 566: ! 567: ! 568: // Controlling pipe state ! 569: ! 570: IOReturn IOUSBUserClient::getPipeStatus(UInt32 pipe) ! 571: { ! 572: IOUSBPipe *pipeObj; ! 573: pipeObj = fPipes[pipe]; ! 574: if(!pipeObj) ! 575: return kIOUSBUnknownPipeErr; ! 576: return pipeObj->status(); ! 577: } ! 578: ! 579: IOReturn IOUSBUserClient::abortPipe(UInt32 pipe) ! 580: { ! 581: IOUSBPipe *pipeObj; ! 582: pipeObj = fPipes[pipe]; ! 583: if(!pipeObj) ! 584: return kIOUSBUnknownPipeErr; ! 585: return pipeObj->abort(); ! 586: } ! 587: ! 588: IOReturn IOUSBUserClient::resetPipe(UInt32 pipe) ! 589: { ! 590: IOUSBPipe *pipeObj; ! 591: pipeObj = fPipes[pipe]; ! 592: if(!pipeObj) ! 593: return kIOUSBUnknownPipeErr; ! 594: return pipeObj->reset(); ! 595: } ! 596: ! 597: IOReturn IOUSBUserClient::setPipeIdle(UInt32 pipe) ! 598: { ! 599: return(0); ! 600: } ! 601: ! 602: IOReturn IOUSBUserClient::setPipeActive(UInt32 pipe) ! 603: { ! 604: return(0); ! 605: } ! 606: ! 607: IOReturn IOUSBUserClient::clearPipeStall(UInt32 pipe) ! 608: { ! 609: IOUSBPipe *pipeObj; ! 610: pipeObj = fPipes[pipe]; ! 611: if(!pipeObj) ! 612: return kIOUSBUnknownPipeErr; ! 613: return pipeObj->clearStall(); ! 614: } ! 615: ! 616: IOReturn ! 617: IOUSBUserClient::ReadPipe(UInt32 pipe, void *buf, UInt32 *size) ! 618: { ! 619: IOReturn res; ! 620: IOMemoryDescriptor * mem; ! 621: IOUSBPipe * pipeObj; ! 622: ! 623: pipeObj = fPipes[pipe]; ! 624: if(!pipeObj) ! 625: return kIOUSBUnknownPipeErr; ! 626: ! 627: mem = IOMemoryDescriptor::withAddress(buf, *size, kIODirectionIn); ! 628: if(!mem) { ! 629: *size = 0; ! 630: return kIOReturnNoMemory; ! 631: } ! 632: res = pipeObj->read(mem, 0, size); ! 633: if(kIOReturnSuccess != res) ! 634: *size = 0; ! 635: mem->release(); ! 636: ! 637: return res; ! 638: } ! 639: ! 640: IOReturn ! 641: IOUSBUserClient::WritePipe(UInt32 pipe, void *buf, UInt32 size) ! 642: { ! 643: IOReturn res; ! 644: IOMemoryDescriptor * mem; ! 645: IOUSBPipe * pipeObj; ! 646: ! 647: pipeObj = fPipes[pipe]; ! 648: if(!pipeObj) ! 649: return kIOUSBUnknownPipeErr; ! 650: ! 651: mem = IOMemoryDescriptor::withAddress(buf, size, kIODirectionOut); ! 652: if(!mem) { ! 653: res = kIOReturnNoMemory; ! 654: } ! 655: else { ! 656: res = pipeObj->write(mem); ! 657: mem->release(); ! 658: } ! 659: return res; ! 660: } ! 661: ! 662: /* ! 663: * Out of line version of read pipe - the buffer isn't mapped (yet) into the kernel task ! 664: */ ! 665: IOReturn ! 666: IOUSBUserClient::ReadPipeOOL(UInt32 pipe, void *buf, UInt32 sizeIn, UInt32 *sizeOut) ! 667: { ! 668: IOReturn res; ! 669: IOMemoryDescriptor * mem; ! 670: IOUSBPipe * pipeObj; ! 671: ! 672: pipeObj = fPipes[pipe]; ! 673: if(!pipeObj) ! 674: return kIOUSBUnknownPipeErr; ! 675: ! 676: mem = IOMemoryDescriptor::withAddress((vm_address_t)buf, sizeIn, ! 677: kIODirectionIn, ! 678: fTask); ! 679: if(!mem) { ! 680: *sizeOut = 0; ! 681: return kIOReturnNoMemory; ! 682: } ! 683: res = mem->prepare(); ! 684: if(res == kIOReturnSuccess) ! 685: res = pipeObj->read(mem, 0, sizeOut); ! 686: mem->complete(); ! 687: if(kIOReturnSuccess != res) ! 688: *sizeOut = 0; ! 689: mem->release(); ! 690: ! 691: return res; ! 692: } ! 693: ! 694: /* ! 695: * Out of line version of write pipe - the buffer isn't mapped (yet) into the kernel task ! 696: */ ! 697: IOReturn ! 698: IOUSBUserClient::WritePipeOOL(UInt32 pipe, void *buf, UInt32 size) ! 699: { ! 700: IOReturn res; ! 701: IOMemoryDescriptor * mem; ! 702: IOUSBPipe * pipeObj; ! 703: ! 704: pipeObj = fPipes[pipe]; ! 705: if(!pipeObj) ! 706: return kIOUSBUnknownPipeErr; ! 707: ! 708: mem = IOMemoryDescriptor::withAddress((vm_address_t)buf, size, ! 709: kIODirectionOut, ! 710: fTask); ! 711: if(!mem) { ! 712: res = kIOReturnNoMemory; ! 713: } ! 714: else { ! 715: res = mem->prepare(); ! 716: if(res == kIOReturnSuccess) ! 717: res = pipeObj->write(mem); ! 718: mem->complete(); ! 719: mem->release(); ! 720: } ! 721: return res; ! 722: } ! 723: ! 724: /* ! 725: * Async version of read pipe - the buffer isn't mapped (yet) into the kernel task ! 726: */ ! 727: IOReturn ! 728: IOUSBUserClient::ReadPipeAsync(OSAsyncReference asyncRef, ! 729: UInt32 pipe, void *buf, UInt32 size) ! 730: { ! 731: IOReturn res; ! 732: IOUSBPipe * pipeObj; ! 733: IOUSBCompletion tap; ! 734: IOMemoryDescriptor * mem = NULL; ! 735: AsyncPB * pb = NULL; ! 736: ! 737: pipeObj = fPipes[pipe]; ! 738: if(!pipeObj) ! 739: return kIOUSBUnknownPipeErr; ! 740: ! 741: do { ! 742: mem = IOMemoryDescriptor::withAddress((vm_address_t)buf, size, ! 743: kIODirectionIn, ! 744: fTask); ! 745: if(!mem) { ! 746: res = kIOReturnNoMemory; ! 747: break; ! 748: } ! 749: res = mem->prepare(); ! 750: if(res != kIOReturnSuccess) ! 751: break; ! 752: ! 753: pb = (AsyncPB *)IOMalloc(sizeof(AsyncPB)); ! 754: if(!pb) { ! 755: res = kIOReturnNoMemory; ! 756: break; ! 757: } ! 758: ! 759: bcopy(asyncRef, pb->fAsyncRef, sizeof(OSAsyncReference)); ! 760: pb->fMax = size; ! 761: pb->fMem = mem; ! 762: tap.target = this; ! 763: tap.action = &ReqComplete; ! 764: tap.parameter = pb; ! 765: res = pipeObj->read(mem, &tap, NULL); ! 766: } while (false); ! 767: if(res != kIOReturnSuccess) { ! 768: if(mem) { ! 769: mem->complete(); ! 770: mem->release(); ! 771: } ! 772: if(pb) ! 773: IOFree(pb, sizeof(*pb)); ! 774: } ! 775: ! 776: return res; ! 777: } ! 778: ! 779: /* ! 780: * Async version of write pipe - the buffer isn't mapped (yet) into the kernel task ! 781: */ ! 782: IOReturn ! 783: IOUSBUserClient::WritePipeAsync(OSAsyncReference asyncRef, ! 784: UInt32 pipe, void *buf, UInt32 size) ! 785: { ! 786: IOReturn res; ! 787: IOUSBPipe * pipeObj; ! 788: IOUSBCompletion tap; ! 789: IOMemoryDescriptor * mem = NULL; ! 790: AsyncPB * pb = NULL; ! 791: ! 792: pipeObj = fPipes[pipe]; ! 793: if(!pipeObj) ! 794: return kIOUSBUnknownPipeErr; ! 795: ! 796: do { ! 797: mem = IOMemoryDescriptor::withAddress((vm_address_t)buf, size, ! 798: kIODirectionOut, ! 799: fTask); ! 800: if(!mem) { ! 801: res = kIOReturnNoMemory; ! 802: break; ! 803: } ! 804: res = mem->prepare(); ! 805: if(res != kIOReturnSuccess) ! 806: break; ! 807: ! 808: pb = (AsyncPB *)IOMalloc(sizeof(AsyncPB)); ! 809: if(!pb) { ! 810: res = kIOReturnNoMemory; ! 811: break; ! 812: } ! 813: ! 814: bcopy(asyncRef, pb->fAsyncRef, sizeof(OSAsyncReference)); ! 815: pb->fMax = size; ! 816: pb->fMem = mem; ! 817: tap.target = this; ! 818: tap.action = &ReqComplete; ! 819: tap.parameter = pb; ! 820: res = pipeObj->write(mem, &tap); ! 821: } while (false); ! 822: if(res != kIOReturnSuccess) { ! 823: if(mem) { ! 824: mem->complete(); ! 825: mem->release(); ! 826: } ! 827: if(pb) ! 828: IOFree(pb, sizeof(*pb)); ! 829: } ! 830: return res; ! 831: } ! 832: ! 833: IOReturn IOUSBUserClient::ClosePipe(UInt32 pipe) ! 834: { ! 835: fPipes[pipe] = 0; ! 836: return kIOReturnSuccess; ! 837: } ! 838: ! 839: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 840: ! 841: OSDefineMetaClassAndStructors(IOUSBDeviceUserClient, IOUSBUserClient) ! 842: ! 843: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 844: ! 845: IOUSBDeviceUserClient *IOUSBDeviceUserClient::withTask(task_t owningTask) ! 846: { ! 847: IOUSBDeviceUserClient *me; ! 848: ! 849: me = new IOUSBDeviceUserClient; ! 850: if(me) { ! 851: if(!me->init()) { ! 852: me->release(); ! 853: return NULL; ! 854: } ! 855: me->fTask = owningTask; ! 856: } ! 857: return me; ! 858: } ! 859: ! 860: bool IOUSBDeviceUserClient::start( IOService * provider ) ! 861: { ! 862: assert(OSDynamicCast(IOUSBDevice, provider)); ! 863: if(!IOUSBUserClient::start(provider)) ! 864: return false; ! 865: fOwner = (IOUSBDevice *)provider; ! 866: fOwner->retain(); ! 867: fInterfaces = OSSet::withCapacity(1); ! 868: if(!fInterfaces) ! 869: return false; ! 870: ! 871: // initialize the call structures valid for IOUSBDevice ! 872: fMethods[kUSBSetConfig].object = provider; ! 873: fMethods[kUSBSetConfig].func = (IOMethod)&IOUSBDevice::SetConfiguration; ! 874: fMethods[kUSBSetConfig].count0 = 1; ! 875: fMethods[kUSBSetConfig].count1 = 0; ! 876: fMethods[kUSBSetConfig].flags = kIOUCScalarIScalarO; ! 877: ! 878: fMethods[kUSBGetConfigDescriptor].object = this; ! 879: fMethods[kUSBGetConfigDescriptor].func = ! 880: (IOMethod)&IOUSBDeviceUserClient::GetConfigDescriptor; ! 881: fMethods[kUSBGetConfigDescriptor].count0 = 1; ! 882: fMethods[kUSBGetConfigDescriptor].count1 = 0xffffffff; // variable ! 883: fMethods[kUSBGetConfigDescriptor].flags = kIOUCScalarIStructO; ! 884: ! 885: fMethods[kUSBOpenPipe].object = this; ! 886: fMethods[kUSBOpenPipe].func = ! 887: (IOMethod)&IOUSBDeviceUserClient::OpenPipe; ! 888: fMethods[kUSBOpenPipe].count0 = 4; ! 889: fMethods[kUSBOpenPipe].count1 = 1; ! 890: fMethods[kUSBOpenPipe].flags = kIOUCScalarIScalarO; ! 891: ! 892: fMethods[kUSBResetDevice].object = provider; ! 893: fMethods[kUSBResetDevice].func = ! 894: (IOMethod)&IOUSBDevice::resetDevice; ! 895: fMethods[kUSBResetDevice].count0 = 0; ! 896: fMethods[kUSBResetDevice].count1 = 0; ! 897: fMethods[kUSBResetDevice].flags = kIOUCScalarIScalarO; ! 898: ! 899: return true; ! 900: } ! 901: ! 902: IOReturn IOUSBDeviceUserClient::clientClose( void ) ! 903: { ! 904: if(fInterfaces) { ! 905: OSCollectionIterator *iter; ! 906: ! 907: iter = OSCollectionIterator::withCollection(fInterfaces); ! 908: if(iter) { ! 909: OSObject *obj; ! 910: while( (obj=iter->getNextObject()) ) { ! 911: ((IOService *)obj)->close(this); ! 912: } ! 913: iter->release(); ! 914: } ! 915: fInterfaces->release(); ! 916: fInterfaces = NULL; ! 917: } ! 918: if(fOwner) { ! 919: detach( fOwner); ! 920: fOwner->release(); ! 921: fOwner = NULL; ! 922: } ! 923: return IOUSBUserClient::clientClose(); ! 924: } ! 925: ! 926: IOReturn ! 927: IOUSBDeviceUserClient::OpenPipe(UInt32 configIndex, ! 928: UInt32 intfNo, UInt32 altSet, UInt32 endPtOff, UInt32 *pipe) ! 929: { ! 930: IOReturn res; ! 931: IOUSBInterface *intf; ! 932: const IOUSBInterfaceDescriptor *id = NULL; ! 933: UInt8 configVal; ! 934: IOUSBDevice::FindInterfaceRequest request; ! 935: UInt32 i; ! 936: const IOUSBConfigurationDescriptor *config; ! 937: ! 938: config = fOwner->getFullConfigurationDescriptor(configIndex); ! 939: configVal = config->configValue; ! 940: ! 941: intf = NULL; ! 942: request.theClass = 0; ! 943: request.subClass = 0; ! 944: request.protocol = 0; ! 945: request.maxPower = 0; ! 946: ! 947: while( (intf = fOwner->findNextInterface(intf, &request))) { ! 948: if(intf->getConfigValue() == configVal) { ! 949: id = intf->interfaceDescriptor(); ! 950: if(id->interfaceNumber == intfNo && ! 951: id->alternateSetting == altSet) ! 952: break; ! 953: } ! 954: intf->release(); ! 955: // Reset request fields to wildcard values. ! 956: request.theClass = 0; ! 957: request.subClass = 0; ! 958: request.protocol = 0; ! 959: request.maxPower = 0; ! 960: } ! 961: ! 962: if(!intf) ! 963: return kIOUSBInterfaceNotFound; ! 964: ! 965: if(id->numEndpoints <= endPtOff) ! 966: return kIOUSBUnknownPipeErr; ! 967: ! 968: do { ! 969: IOUSBFindEndpointRequest findPipe; ! 970: IOUSBPipe *pipeObj; ! 971: if(!fInterfaces->member(intf)) { ! 972: if(!intf->open(this)) { ! 973: res = kIOReturnExclusiveAccess; ! 974: break; ! 975: } ! 976: fInterfaces->setObject(intf); ! 977: } ! 978: ! 979: // Loop through pipes the requested number of times ! 980: pipeObj = NULL; ! 981: endPtOff++; // Easier to be 1-based. ! 982: for(i=0; i<endPtOff; i++) { ! 983: findPipe.type = kUSBAnyType; ! 984: findPipe.direction = kUSBAnyDirn; ! 985: pipeObj = intf->findNextPipe(pipeObj, &findPipe); ! 986: if(pipeObj == NULL) { ! 987: res = kIOUSBEndpointNotFound; ! 988: break; ! 989: } ! 990: } ! 991: if(i != endPtOff) { ! 992: res = kIOUSBEndpointNotFound; ! 993: break; ! 994: } ! 995: for(i=1; i<kUSBMaxPipes; i++) { ! 996: if(!fPipes[i]) { ! 997: fPipes[i] = pipeObj; ! 998: break; ! 999: } ! 1000: } ! 1001: if(i >= kUSBMaxPipes) { ! 1002: res = kIOUSBTooManyPipesErr; ! 1003: break; ! 1004: } ! 1005: *pipe = i; ! 1006: res = kIOReturnSuccess; ! 1007: } while(false); ! 1008: if(intf) ! 1009: intf->release(); ! 1010: return res; ! 1011: } ! 1012: ! 1013: IOReturn ! 1014: IOUSBDeviceUserClient::GetConfigDescriptor(UInt8 configIndex, ! 1015: IOUSBConfigurationDescriptorPtr desc, UInt32 *size) ! 1016: { ! 1017: UInt16 length; ! 1018: const IOUSBConfigurationDescriptor *cached; ! 1019: ! 1020: cached = fOwner->getFullConfigurationDescriptor(configIndex); ! 1021: length = OSReadLittleInt16(&cached->totalLength, 0); ! 1022: if(length < *size) ! 1023: *size = length; ! 1024: bcopy(cached, desc, *size); ! 1025: return kIOReturnSuccess; ! 1026: } ! 1027: ! 1028: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 1029: ! 1030: OSDefineMetaClassAndStructors(IOUSBInterfaceUserClient, IOUSBUserClient) ! 1031: ! 1032: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ ! 1033: ! 1034: IOUSBInterfaceUserClient *IOUSBInterfaceUserClient::withTask(task_t owningTask) ! 1035: { ! 1036: IOUSBInterfaceUserClient *me; ! 1037: ! 1038: me = new IOUSBInterfaceUserClient; ! 1039: if(me) { ! 1040: if(!me->init()) { ! 1041: me->release(); ! 1042: return NULL; ! 1043: } ! 1044: me->fTask = owningTask; ! 1045: } ! 1046: return me; ! 1047: } ! 1048: ! 1049: bool IOUSBInterfaceUserClient::start( IOService * provider ) ! 1050: { ! 1051: assert(OSDynamicCast(IOUSBInterface, provider)); ! 1052: if(!IOUSBUserClient::start(provider)) ! 1053: return false; ! 1054: fOwner = (IOUSBInterface *)provider; ! 1055: fOwner->retain(); ! 1056: ! 1057: // initialize the call structures valid for IOUSBInterface ! 1058: fMethods[kUSBGetConfigDescriptor].object = this; ! 1059: fMethods[kUSBGetConfigDescriptor].func = ! 1060: (IOMethod)&IOUSBInterfaceUserClient::GetConfigDescriptor; ! 1061: fMethods[kUSBGetConfigDescriptor].count0 = 1; ! 1062: fMethods[kUSBGetConfigDescriptor].count1 = 0xffffffff; // variable ! 1063: fMethods[kUSBGetConfigDescriptor].flags = kIOUCScalarIStructO; ! 1064: ! 1065: fMethods[kUSBOpenPipe].object = this; ! 1066: fMethods[kUSBOpenPipe].func = ! 1067: (IOMethod)&IOUSBInterfaceUserClient::OpenPipe; ! 1068: fMethods[kUSBOpenPipe].count0 = 4; ! 1069: fMethods[kUSBOpenPipe].count1 = 1; ! 1070: fMethods[kUSBOpenPipe].flags = kIOUCScalarIScalarO; ! 1071: ! 1072: return true; ! 1073: } ! 1074: ! 1075: IOReturn IOUSBInterfaceUserClient::clientClose( void ) ! 1076: { ! 1077: if(fOwner) { ! 1078: if(fOpen) { ! 1079: fOwner->close(this); ! 1080: fOpen = false; ! 1081: } ! 1082: detach( fOwner); ! 1083: fOwner->release(); ! 1084: fOwner = NULL; ! 1085: } ! 1086: return IOUSBUserClient::clientClose(); ! 1087: } ! 1088: ! 1089: IOReturn ! 1090: IOUSBInterfaceUserClient::OpenPipe(UInt32 configIndex, ! 1091: UInt32 intfNo, UInt32 altSet, UInt32 endPtOff, UInt32 *pipe) ! 1092: { ! 1093: IOReturn res; ! 1094: const IOUSBInterfaceDescriptor *id = fOwner->interfaceDescriptor(); ! 1095: UInt32 i; ! 1096: const IOUSBConfigurationDescriptor *config; ! 1097: ! 1098: config = fOwner->device()->getFullConfigurationDescriptor(configIndex); ! 1099: ! 1100: if(config->configValue != fOwner->getConfigValue()) ! 1101: return kIOUSBConfigNotFound; ! 1102: ! 1103: if(intfNo != id->interfaceNumber || ! 1104: altSet != id->alternateSetting) ! 1105: return kIOUSBInterfaceNotFound; ! 1106: ! 1107: if(id->numEndpoints <= endPtOff) ! 1108: return kIOUSBUnknownPipeErr; ! 1109: ! 1110: do { ! 1111: IOUSBFindEndpointRequest findPipe; ! 1112: IOUSBPipe *pipeObj; ! 1113: if(!fOpen) { ! 1114: if(!fOwner->open(this)) { ! 1115: res = kIOReturnExclusiveAccess; ! 1116: break; ! 1117: } ! 1118: fOpen = true; ! 1119: } ! 1120: ! 1121: // Loop through pipes the requested number of times ! 1122: pipeObj = NULL; ! 1123: endPtOff++; // Easier to be 1-based. ! 1124: for(i=0; i<endPtOff; i++) { ! 1125: findPipe.type = kUSBAnyType; ! 1126: findPipe.direction = kUSBAnyDirn; ! 1127: pipeObj = fOwner->findNextPipe(pipeObj, &findPipe); ! 1128: if(pipeObj == NULL) { ! 1129: res = kIOUSBEndpointNotFound; ! 1130: break; ! 1131: } ! 1132: } ! 1133: if(i != endPtOff) { ! 1134: res = kIOUSBEndpointNotFound; ! 1135: break; ! 1136: } ! 1137: for(i=1; i<kUSBMaxPipes; i++) { ! 1138: if(!fPipes[i]) { ! 1139: fPipes[i] = pipeObj; ! 1140: break; ! 1141: } ! 1142: } ! 1143: if(i >= kUSBMaxPipes) { ! 1144: res = kIOUSBTooManyPipesErr; ! 1145: break; ! 1146: } ! 1147: *pipe = i; ! 1148: res = kIOReturnSuccess; ! 1149: } while(false); ! 1150: return res; ! 1151: } ! 1152: ! 1153: IOReturn ! 1154: IOUSBInterfaceUserClient::GetConfigDescriptor(UInt8 configIndex, ! 1155: IOUSBConfigurationDescriptorPtr desc, UInt32 *size) ! 1156: { ! 1157: UInt16 length; ! 1158: const IOUSBConfigurationDescriptor *cached; ! 1159: ! 1160: cached = fOwner->device()->getFullConfigurationDescriptor(configIndex); ! 1161: length = OSReadLittleInt16(&cached->totalLength, 0); ! 1162: if(length < *size) ! 1163: *size = length; ! 1164: bcopy(cached, desc, *size); ! 1165: return kIOReturnSuccess; ! 1166: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.