![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOUSBDevice.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 IOUSBDevice.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) 1998 Apple Computer, Inc. All rights reserved.
24: *
25: * HISTORY
26: * 08 Dec 98 ehewitt created.
27: *
28: */
29:
30: #include <libkern/OSByteOrder.h>
31:
32: #include <libkern/c++/OSDictionary.h>
33: #include <IOKit/IOMemoryDescriptor.h>
34: #include <libkern/c++/OSData.h>
35:
36: #include <IOKit/usb/USB.h>
37: #include <IOKit/usb/IOUSBController.h>
38: #include <IOKit/usb/IOUSBDevice.h>
39: #include <IOKit/usb/IOUSBInterface.h>
40: #include <IOKit/usb/IOUSBPipe.h>
41:
42: #include "IOUSBUserClient.h"
43: #include "IOUSBHub.h"
44:
45: #define super IOUSBNub
46:
47: static int devdebug = 0;
48: #define DEBUGLOG if (devdebug) kprintf
49:
50: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
51:
52: OSDefineMetaClassAndStructors(IOUSBDevice, IOUSBNub)
53:
54: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
55:
56: void IOUSBDevice::setPort(IOUSBHubPort *port)
57: {
58: _port = port;
59: }
60:
61: bool IOUSBDevice::init(OSDictionary * propTable)
62: {
63: if(!IOUSBNub::init(propTable))
64: return false;
65: if(_descriptor.numConf) {
66: _configList = (UInt8 **)IOMalloc(sizeof(UInt8 *) * _descriptor.numConf);
67: if(!_configList)
68: return false;
69: bzero(_configList, sizeof(UInt8 *) * _descriptor.numConf);
70: }
71: return true;
72: }
73:
74: void IOUSBDevice::free()
75: {
76: if(_configList) {
77: int i;
78: for(i=0; i<_descriptor.numConf; i++) {
79: if(_configList[i]) {
80: int len = OSReadLittleInt16(&((IOUSBConfigurationDescriptor *)_configList[i])->totalLength, 0);
81: IOFree(_configList[i], len+2);
82: _configList[i] = NULL;
83: }
84: }
85: IOFree(_configList, sizeof(UInt8 *) * _descriptor.numConf);
86: }
87: IOUSBNub::free();
88: }
89:
90: bool IOUSBDevice::attach(IOService *provider)
91: {
92: IOReturn err;
93: char name[128];
94:
95: if( !IOUSBNub::attach(provider))
96: return (false);
97: // Set controller if we weren't given one earlier.
98: if(_controller == NULL)
99: _controller = OSDynamicCast(IOUSBController, provider);
100: if(_controller == NULL)
101: return false;
102:
103: // Don't do this until we have a controller
104: _endpointZero.length = sizeof(_endpointZero);
105: _endpointZero.descriptorType = kUSBEndpointDesc;
106: _endpointZero.endpointAddress = 0;
107: _endpointZero.attributes = kUSBControl;
108: OSWriteLittleInt16(&_endpointZero.maxPacketSizeLo, 0, _descriptor.maxPacketSize);
109: _endpointZero.interval = 0;
110:
111: _pipeZero = IOUSBPipe::toEndpoint(&_endpointZero, _speed, _address, _controller);
112:
113: if(_descriptor.prodIdx) {
114: err = GetStringDescriptor(_descriptor.prodIdx, name, sizeof(name));
115: if(err == kIOReturnSuccess) {
116: setName(name);
117: setProperty("USB Product Name", name);
118: }
119: }
120: if(_descriptor.manuIdx) {
121: err = GetStringDescriptor(_descriptor.manuIdx, name, sizeof(name));
122: if(err == kIOReturnSuccess) {
123: setProperty("USB Vendor Name", name);
124: }
125: }
126: if(_descriptor.serialIdx) {
127: err = GetStringDescriptor(_descriptor.serialIdx, name, sizeof(name));
128: if(err == kIOReturnSuccess) {
129: setProperty("USB Serial Number", name);
130: }
131: }
132: return true;
133: }
134:
135: // Stop all activity, reset device, restart.
136: IOReturn IOUSBDevice::resetDevice()
137: {
138: IOReturn err;
139:
140: if(_pipeZero) {
141: _pipeZero->release();
142: _pipeZero = NULL;
143: }
144: err = _port->resetDevice();
145:
146: // Recreate pipe 0 object
147: if(err == kIOReturnSuccess) {
148: _pipeZero = IOUSBPipe::toEndpoint(&_endpointZero, _speed, _address, _controller);
149: if(!_pipeZero)
150: err = kIOReturnNoMemory;
151: }
152:
153: return err;
154: }
155:
156: /******************************************************
157: * Helper Methods
158: ******************************************************/
159:
160: const IOUSBConfigurationDescriptor *
161: IOUSBDevice::findConfig(UInt8 configValue, int *configIndex)
162: {
163: int i;
164: const IOUSBConfigurationDescriptor *cd = NULL;
165:
166: for(i = 0; i < _descriptor.numConf; i++) {
167: cd = getFullConfigurationDescriptor(i);
168: if(!cd)
169: continue;
170: if(cd->configValue == configValue)
171: break;
172: }
173: if(cd && configIndex)
174: *configIndex = i;
175:
176: return cd;
177: }
178:
179: // Finding the correct interface
180: /*
181: * findNextInterface
182: * This method should really be rewritten to use iterators or
183: * be broken out into more functions without a request structure.
184: * Or even better, make the interfaces and endpoint objects that
185: * have their own methods for this stuff.
186: *
187: * returns:
188: * next interface matching criteria. 0 if no matches
189: */
190: IOUSBInterface *
191: IOUSBDevice::findNextInterface(IOUSBInterface *current,
192: FindInterfaceRequest *request)
193: {
194: const IOUSBConfigurationDescriptor *cd;
195: const IOUSBInterfaceDescriptor * id;
196: const IOUSBDescriptorHeader * pos = NULL;
197: bool found;
198: int configIndex;
199: if(current == NULL) {
200: configIndex = 0;
201: cd = getFullConfigurationDescriptor(configIndex);
202: if(!cd)
203: return NULL;
204: pos = (IOUSBDescriptorHeader *)cd;
205: }
206: else {
207: cd = findConfig(current->getConfigValue(), &configIndex);
208: if(!cd)
209: return NULL;
210: pos = (IOUSBDescriptorHeader *)cd;
211: while((pos = findNextDescriptor(pos, kUSBInterfaceDesc))) {
212: if(bcmp(pos, current->interfaceDescriptor(),
213: sizeof(IOUSBInterfaceDescriptor)) == 0) {
214: break;
215: }
216: }
217: }
218: while (configIndex < _descriptor.numConf)
219: {
220: pos = findNextDescriptor(pos, kUSBInterfaceDesc);
221: if(pos == NULL) {
222: // End of that configuration
223: configIndex++;
224: if(configIndex >= _descriptor.numConf)
225: break;
226:
227: cd = getFullConfigurationDescriptor(configIndex);
228: continue;
229: }
230: id = (const IOUSBInterfaceDescriptor *)pos;
231:
232: // check the request parameters
233: found = true;
234: if (request->theClass != 0 && request->theClass != id->interfaceClass)
235: found = false; // this is not it
236: if (request->subClass != 0 && request->subClass != id->interfaceSubClass)
237: found = false; // this is not it
238: if (request->protocol != 0 && request->protocol != id->interfaceProtocol)
239: found = false; // this is not it
240: if (request->maxPower != 0 && request->maxPower < cd->maxPower)
241: found = false; // draws too much power
242: if (id->alternateSetting != 0)
243: found = false; // Only want main setting
244:
245: if (found)
246: {
247: request->theClass = id->interfaceClass;
248: request->subClass = id->interfaceSubClass;
249: request->protocol = id->interfaceProtocol;
250: request->maxPower = cd->maxPower;
251: request->busPowered = cd->attributes & kUSBAtrBusPowered ? 2 : 1;
252: request->selfPowered = cd->attributes & kUSBAtrSelfPowered ? 2 : 1;
253: request->remoteWakeup = cd->attributes & kUSBAtrRemoteWakeup ? 2 : 1;
254: return(GetInterface(id, cd));
255: }
256: }
257: return(0);
258: }
259:
260: const IOUSBConfigurationDescriptor *IOUSBDevice::getFullConfigurationDescriptor(UInt8 index)
261: {
262: IOReturn err;
263:
264: if(_configList[index] == NULL) {
265: int len;
266: IOUSBConfigurationDescriptor temp;
267: err = GetConfigDescriptor(index, &temp, sizeof(temp));
268: if (err) {
269: DEBUGLOG("getFullConfigurationDescriptor: Error 0x%x getting configuration descriptor\n", err);
270: return(0);
271: }
272: len = OSReadLittleInt16(&temp.totalLength, 0);
273: _configList[index] = (UInt8 *)IOMalloc(len + 2);
274: if(_configList[index] == NULL)
275: return 0;
276: err = GetConfigDescriptor(index, _configList[index], len);
277: if (err) {
278: DEBUGLOG("getFullConfigurationDescriptor: Error %d getting full configuration\n", err);
279: return(0);
280: }
281: *(_configList[index]+len) = 0; // A Known ~Elephant.
282: *(_configList[index]+len+1) = 0;// A Known ~Elephant.
283: }
284: return (IOUSBConfigurationDescriptor *)_configList[index];
285: }
286:
287: /*
288: * GetConfigDescriptor:
289: * In: pointer to buffer for config descriptor, length to get
290: * Assumes: desc is has enough space to put it all
291: */
292: IOReturn IOUSBDevice::GetConfigDescriptor(UInt8 configIndex,
293: void *desc, int len)
294: {
295: IOReturn err = kIOReturnSuccess;
296: IOUSBDevRequest request;
297:
298: DEBUGLOG("********** GET CONFIG DESCRIPTOR (%d)**********\n", len);
299:
300: /*
301: * with config descriptors, the device will send back all descriptors,
302: * if the request is big enough.
303: */
304:
305: request.rqDirection = kUSBIn;
306: request.rqType = kUSBStandard;
307: request.rqRecipient = kUSBDevice;
308: request.bRequest = kUSBRqGetDescriptor;
309: OSWriteLittleInt16(&request.wValue, 0, (kUSBConfDesc << 8) + configIndex);
310: OSWriteLittleInt16(&request.wIndex, 0, 0);
311: OSWriteLittleInt16(&request.wLength, 0, len);
312: request.pData = desc;
313:
314: err = deviceRequest(&request);
315:
316: if (err)
317: {
318: DEBUGLOG("%s: error getting device config descriptor. err=0x%x\n", getName(), err);
319: }
320:
321: return(err);
322: }
323:
324: IOReturn IOUSBDevice::SetConfiguration(UInt8 configNumber)
325: {
326: IOReturn err = kIOReturnSuccess;
327: IOUSBDevRequest request;
328:
329: DEBUGLOG("********** SET CONFIGURATION TO %d **********\n", configNumber);
330:
331: request.rqDirection = kUSBOut;
332: request.rqType = kUSBStandard;
333: request.rqRecipient = kUSBDevice;
334: request.bRequest = kUSBRqSetConfig;
335: OSWriteLittleInt16(&request.wValue, 0, configNumber);
336: OSWriteLittleInt16(&request.wIndex, 0, 0);
337: OSWriteLittleInt16(&request.wLength, 0, 0);
338: request.pData = 0;
339:
340: err = deviceRequest(&request);
341:
342: if (err)
343: {
344: DEBUGLOG("%s: error setting config. err=%d\n", getName(), err);
345: }
346:
347: return(err);
348: }
349:
350: IOUSBInterface * IOUSBDevice::GetInterface(const IOUSBInterfaceDescriptor *interface,
351: const IOUSBConfigurationDescriptor *config)
352: {
353: OSDictionary * propTable = 0;
354: OSArray * epArray = 0;
355: IOUSBInterface * newDevice = 0;
356: OSData * data;
357: OSNumber * offset;
358: int i;
359: char location[8];
360: OSIterator * clients;
361: /*
362: * First see if the interface has already been created,
363: * ie. there's already one with the given interface descriptor and config descriptor
364: */
365: clients = getClientIterator();
366: if(clients) {
367: OSObject *next;
368: while((next = clients->getNextObject())) {
369: IOUSBInterface *testIt = OSDynamicCast(IOUSBInterface, next);
370: if(testIt) {
371: if(config->configValue == testIt->getConfigValue() &&
372: bcmp(interface, testIt->interfaceDescriptor(), sizeof(IOUSBInterfaceDescriptor)) == 0) {
373: newDevice = testIt;
374: break;
375: }
376: }
377: }
378: clients->release();
379: }
380: if(newDevice) {
381: newDevice->retain();
382: return newDevice;
383: }
384: do {
385: propTable = OSDictionary::withCapacity(13);
386: if (!propTable)
387: continue;
388:
389: data = OSData::withBytes( &_descriptor, sizeof( _descriptor ));
390: if (data) {
391: propTable->setObject("device descriptor", data);
392: data->release();
393: }
394: offset = OSNumber::withNumber(interface->interfaceClass, 8);
395: if(offset) {
396: propTable->setObject("class", offset);
397: offset->release();
398: }
399: offset = OSNumber::withNumber(interface->interfaceSubClass, 8);
400: if(offset) {
401: propTable->setObject("subClass", offset);
402: offset->release();
403: }
404: offset = OSNumber::withNumber(interface->interfaceProtocol, 8);
405: if(offset) {
406: propTable->setObject("protocol", offset);
407: offset->release();
408: }
409: offset = OSNumber::withNumber(OSReadLittleInt16(&_descriptor.vendor, 0), 16);
410: if(offset) {
411: propTable->setObject("vendor", offset);
412: offset->release();
413: }
414: offset = OSNumber::withNumber(OSReadLittleInt16(&_descriptor.product, 0), 16);
415: if(offset) {
416: propTable->setObject("product", offset);
417: offset->release();
418: }
419: offset = OSNumber::withNumber(OSReadLittleInt16(&_descriptor.devRel, 0), 16);
420: if(offset) {
421: propTable->setObject("version", offset);
422: offset->release();
423: }
424: data = OSData::withBytes(&_address, sizeof( _address ));
425: if (data) {
426: propTable->setObject("device address", data);
427: data->release();
428: }
429: data = OSData::withBytes( config,
430: sizeof( *config ));
431: if (data) {
432: propTable->setObject("configuration descriptor", data);
433: data->release();
434: }
435: data = OSData::withBytes( interface,
436: sizeof(*interface));
437: if (data) {
438: propTable->setObject("interface descriptor", data);
439: data->release();
440: }
441: data = OSData::withBytes(&_busPowerAvailable, sizeof(_busPowerAvailable));
442: if (data) {
443: propTable->setObject("bus power available", data);
444: data->release();
445: }
446: data = OSData::withBytes(&_speed, sizeof(_speed));
447: if (data) {
448: propTable->setObject("low speed device", data);
449: data->release();
450: }
451:
452: epArray = OSArray::withCapacity(interface->numEndpoints);
453: if (!epArray)
454: continue;
455: IOUSBEndpointDescriptor *ep = (IOUSBEndpointDescriptor *)interface;
456: for(i=0; i<interface->numEndpoints; i++) {
457: ep = (IOUSBEndpointDescriptor *)findNextDescriptor(ep, kUSBEndpointDesc);
458: if(!ep)
459: break;
460: data = OSData::withBytes(ep, sizeof(IOUSBEndpointDescriptor));
461: if (data) {
462: epArray->setObject(i, data);
463: data->release();
464: }
465: }
466: propTable->setObject("Endpoints", epArray);
467: epArray->release();
468:
469: newDevice = createInterface(propTable, config, interface);
470:
471: if (!newDevice )
472: continue;
473:
474: propTable->release(); // done with it after init
475: propTable = 0;
476:
477: sprintf( location, "%x", _address );
478: newDevice->setLocation(location);
479: if (!newDevice->attach(this))
480: break;
481:
482: return(newDevice);
483:
484: } while (false);
485:
486: if (propTable)
487: propTable->release();
488: if (epArray)
489: epArray->release();
490: if (newDevice)
491: newDevice->release();
492:
493: return(NULL);
494: }
495:
496: IOUSBInterface *
497: IOUSBDevice::createInterface(OSDictionary *table,
498: const IOUSBConfigurationDescriptor *config,
499: const IOUSBInterfaceDescriptor *interface)
500: {
501: IOUSBInterface *newIface;
502:
503: newIface = new IOUSBInterface;
504: if(!newIface)
505: return NULL;
506: if(!newIface->init(table, config, interface)) {
507: newIface->release();
508: newIface = NULL;
509: }
510: return newIface;
511: }
512:
513: // Copy data into supplied buffer, up to 'len' bytes.
514: IOReturn IOUSBDevice::getConfigurationDescriptor(UInt8 configValue, void *data, UInt32 len)
515: {
516: unsigned int toCopy;
517: const IOUSBConfigurationDescriptor *cd;
518: cd = findConfig(configValue);
519: if(!cd)
520: return kIOUSBConfigNotFound;
521:
522: toCopy = OSReadLittleInt16(&cd->totalLength, 0);
523: if(len < toCopy)
524: toCopy = len;
525: bcopy(cd, data, toCopy);
526: return kIOReturnSuccess;
527: }
528:
529:
530: /**
531: ** IOUserClient methods
532: **/
533:
534: IOReturn IOUSBDevice::newUserClient( task_t owningTask,
535: void * /* security_id */,
536: UInt32 type,
537: IOUserClient ** handler )
538:
539: {
540: IOReturn err = kIOReturnSuccess;
541: IOUSBDeviceUserClient * client;
542:
543: if( type != kIOUSBDeviceConnectType)
544: return( kIOReturnBadArgument);
545:
546: client = IOUSBDeviceUserClient::withTask(owningTask);
547:
548: if( !client || (false == client->attach( this )) ||
549: (false == client->start( this )) ) {
550: if(client) {
551: client->detach( this );
552: client->release();
553: }
554: err = kIOReturnNoMemory;
555: }
556:
557: *handler = client;
558: return( err );
559: }
560:
561:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.