3 #include <linux/module.h>
4 #include <linux/init.h>
5 #include <linux/slab.h>
6 #include <asm/byteorder.h>
8 #include "../usb_wrapper.h"
11 #define USB_MAXALTSETTING 128 /* Hard limit */
12 #define USB_MAXENDPOINTS 30 /* Hard limit */
14 /* these maximums are arbitrary */
15 #define USB_MAXCONFIG 8
16 #define USB_ALTSETTINGALLOC 4
17 #define USB_MAXINTERFACES 32
19 static int usb_parse_endpoint(struct usb_host_endpoint
*endpoint
, unsigned char *buffer
, int size
)
21 struct usb_descriptor_header
*header
;
23 int parsed
= 0, len
, numskipped
;
25 header
= (struct usb_descriptor_header
*)buffer
;
27 /* Everything should be fine being passed into here, but we sanity */
29 if (header
->bLength
> size
) {
30 err("ran out of descriptors parsing");
34 if (header
->bDescriptorType
!= USB_DT_ENDPOINT
) {
35 warn("unexpected descriptor 0x%X, expecting endpoint, 0x%X",
36 header
->bDescriptorType
, USB_DT_ENDPOINT
);
40 if (header
->bLength
== USB_DT_ENDPOINT_AUDIO_SIZE
)
41 memcpy(&endpoint
->desc
, buffer
, USB_DT_ENDPOINT_AUDIO_SIZE
);
43 memcpy(&endpoint
->desc
, buffer
, USB_DT_ENDPOINT_SIZE
);
45 le16_to_cpus(&endpoint
->desc
.wMaxPacketSize
);
47 buffer
+= header
->bLength
;
48 size
-= header
->bLength
;
49 parsed
+= header
->bLength
;
51 /* Skip over the rest of the Class Specific or Vendor Specific */
55 while (size
>= sizeof(struct usb_descriptor_header
)) {
56 header
= (struct usb_descriptor_header
*)buffer
;
58 if (header
->bLength
< 2) {
59 err("invalid descriptor length of %d", header
->bLength
);
63 /* If we find another "proper" descriptor then we're done */
64 if ((header
->bDescriptorType
== USB_DT_ENDPOINT
) ||
65 (header
->bDescriptorType
== USB_DT_INTERFACE
) ||
66 (header
->bDescriptorType
== USB_DT_CONFIG
) ||
67 (header
->bDescriptorType
== USB_DT_DEVICE
))
70 dbg("skipping descriptor 0x%X",
71 header
->bDescriptorType
);
74 buffer
+= header
->bLength
;
75 size
-= header
->bLength
;
76 parsed
+= header
->bLength
;
79 dbg("skipped %d class/vendor specific endpoint descriptors", numskipped
);
81 /* Copy any unknown descriptors into a storage area for drivers */
83 len
= (int)(buffer
- begin
);
85 endpoint
->extra
= NULL
;
86 endpoint
->extralen
= 0;
90 endpoint
->extra
= kmalloc(len
, GFP_KERNEL
);
92 if (!endpoint
->extra
) {
93 err("couldn't allocate memory for endpoint extra descriptors");
94 endpoint
->extralen
= 0;
98 memcpy(endpoint
->extra
, begin
, len
);
99 endpoint
->extralen
= len
;
104 static int usb_parse_interface(struct usb_interface
*interface
, unsigned char *buffer
, int size
)
106 int i
, len
, numskipped
, retval
, parsed
= 0;
107 struct usb_descriptor_header
*header
;
108 struct usb_host_interface
*ifp
;
109 unsigned char *begin
;
111 interface
->act_altsetting
= 0;
112 interface
->num_altsetting
= 0;
113 interface
->max_altsetting
= USB_ALTSETTINGALLOC
;
114 device_initialize(&interface
->dev
);
116 interface
->altsetting
= kmalloc(sizeof(*interface
->altsetting
) * interface
->max_altsetting
,
119 if (!interface
->altsetting
) {
120 err("couldn't kmalloc interface->altsetting");
125 struct usb_interface_descriptor
*d
;
127 if (interface
->num_altsetting
>= interface
->max_altsetting
) {
128 struct usb_host_interface
*ptr
;
131 oldmas
= interface
->max_altsetting
;
132 interface
->max_altsetting
+= USB_ALTSETTINGALLOC
;
133 if (interface
->max_altsetting
> USB_MAXALTSETTING
) {
134 warn("too many alternate settings (incr %d max %d)\n",
135 USB_ALTSETTINGALLOC
, USB_MAXALTSETTING
);
139 ptr
= kmalloc(sizeof(*ptr
) * interface
->max_altsetting
, GFP_KERNEL
);
141 err("couldn't kmalloc interface->altsetting");
144 memcpy(ptr
, interface
->altsetting
, sizeof(*interface
->altsetting
) * oldmas
);
145 kfree(interface
->altsetting
);
146 interface
->altsetting
= ptr
;
149 ifp
= interface
->altsetting
+ interface
->num_altsetting
;
150 ifp
->endpoint
= NULL
;
153 interface
->num_altsetting
++;
155 memcpy(ifp
, buffer
, USB_DT_INTERFACE_SIZE
);
157 /* Skip over the interface */
158 buffer
+= ifp
->desc
.bLength
;
159 parsed
+= ifp
->desc
.bLength
;
160 size
-= ifp
->desc
.bLength
;
165 /* Skip over any interface, class or vendor descriptors */
166 while (size
>= sizeof(struct usb_descriptor_header
)) {
167 header
= (struct usb_descriptor_header
*)buffer
;
169 if (header
->bLength
< 2) {
170 err("invalid descriptor length of %d", header
->bLength
);
174 /* If we find another "proper" descriptor then we're done */
175 if ((header
->bDescriptorType
== USB_DT_INTERFACE
) ||
176 (header
->bDescriptorType
== USB_DT_ENDPOINT
) ||
177 (header
->bDescriptorType
== USB_DT_CONFIG
) ||
178 (header
->bDescriptorType
== USB_DT_DEVICE
))
183 buffer
+= header
->bLength
;
184 parsed
+= header
->bLength
;
185 size
-= header
->bLength
;
189 dbg("skipped %d class/vendor specific interface descriptors", numskipped
);
191 /* Copy any unknown descriptors into a storage area for */
192 /* drivers to later parse */
193 len
= (int)(buffer
- begin
);
195 ifp
->extra
= kmalloc(len
, GFP_KERNEL
);
198 err("couldn't allocate memory for interface extra descriptors");
202 memcpy(ifp
->extra
, begin
, len
);
206 /* Did we hit an unexpected descriptor? */
207 header
= (struct usb_descriptor_header
*)buffer
;
208 if ((size
>= sizeof(struct usb_descriptor_header
)) &&
209 ((header
->bDescriptorType
== USB_DT_CONFIG
) ||
210 (header
->bDescriptorType
== USB_DT_DEVICE
)))
213 if (ifp
->desc
.bNumEndpoints
> USB_MAXENDPOINTS
) {
214 warn("too many endpoints");
218 ifp
->endpoint
= (struct usb_host_endpoint
*)
219 kmalloc(ifp
->desc
.bNumEndpoints
*
220 sizeof(struct usb_host_endpoint
), GFP_KERNEL
);
221 if (!ifp
->endpoint
) {
222 err("out of memory");
226 memset(ifp
->endpoint
, 0, ifp
->desc
.bNumEndpoints
*
227 sizeof(struct usb_host_endpoint
));
229 for (i
= 0; i
< ifp
->desc
.bNumEndpoints
; i
++) {
230 header
= (struct usb_descriptor_header
*)buffer
;
232 if (header
->bLength
> size
) {
233 err("ran out of descriptors parsing");
237 retval
= usb_parse_endpoint(ifp
->endpoint
+ i
, buffer
, size
);
246 /* We check to see if it's an alternate to this one */
247 d
= (struct usb_interface_descriptor
*)buffer
;
248 if (size
< USB_DT_INTERFACE_SIZE
249 || d
->bDescriptorType
!= USB_DT_INTERFACE
250 || !d
->bAlternateSetting
)
257 int usb_parse_configuration(struct usb_host_config
*config
, char *buffer
)
260 struct usb_descriptor_header
*header
;
262 memcpy(&config
->desc
, buffer
, USB_DT_CONFIG_SIZE
);
263 le16_to_cpus(&config
->desc
.wTotalLength
);
264 size
= config
->desc
.wTotalLength
;
266 if (config
->desc
.bNumInterfaces
> USB_MAXINTERFACES
) {
267 warn("too many interfaces");
271 config
->interface
= (struct usb_interface
*)
272 kmalloc(config
->desc
.bNumInterfaces
*
273 sizeof(struct usb_interface
), GFP_KERNEL
);
274 dbg("kmalloc IF %p, numif %i", config
->interface
, config
->desc
.bNumInterfaces
);
275 if (!config
->interface
) {
276 err("out of memory");
280 memset(config
->interface
, 0,
281 config
->desc
.bNumInterfaces
* sizeof(struct usb_interface
));
283 buffer
+= config
->desc
.bLength
;
284 size
-= config
->desc
.bLength
;
286 config
->extra
= NULL
;
287 config
->extralen
= 0;
289 for (i
= 0; i
< config
->desc
.bNumInterfaces
; i
++) {
293 /* Skip over the rest of the Class Specific or Vendor */
294 /* Specific descriptors */
297 while (size
>= sizeof(struct usb_descriptor_header
)) {
298 header
= (struct usb_descriptor_header
*)buffer
;
300 if ((header
->bLength
> size
) || (header
->bLength
< 2)) {
301 err("invalid descriptor length of %d", header
->bLength
);
305 /* If we find another "proper" descriptor then we're done */
306 if ((header
->bDescriptorType
== USB_DT_ENDPOINT
) ||
307 (header
->bDescriptorType
== USB_DT_INTERFACE
) ||
308 (header
->bDescriptorType
== USB_DT_CONFIG
) ||
309 (header
->bDescriptorType
== USB_DT_DEVICE
))
312 dbg("skipping descriptor 0x%X", header
->bDescriptorType
);
315 buffer
+= header
->bLength
;
316 size
-= header
->bLength
;
319 dbg("skipped %d class/vendor specific endpoint descriptors", numskipped
);
321 /* Copy any unknown descriptors into a storage area for */
322 /* drivers to later parse */
323 len
= (int)(buffer
- begin
);
325 if (config
->extralen
) {
326 warn("extra config descriptor");
328 config
->extra
= kmalloc(len
, GFP_KERNEL
);
329 if (!config
->extra
) {
330 err("couldn't allocate memory for config extra descriptors");
331 config
->extralen
= 0;
335 memcpy(config
->extra
, begin
, len
);
336 config
->extralen
= len
;
340 retval
= usb_parse_interface(config
->interface
+ i
, buffer
, size
);
351 // hub-only!! ... and only exported for reset/reinit path.
352 // otherwise used internally on disconnect/destroy path
353 void usb_destroy_configuration(struct usb_device
*dev
)
360 if (dev
->rawdescriptors
) {
361 for (i
= 0; i
< dev
->descriptor
.bNumConfigurations
; i
++)
362 kfree(dev
->rawdescriptors
[i
]);
364 kfree(dev
->rawdescriptors
);
367 for (c
= 0; c
< dev
->descriptor
.bNumConfigurations
; c
++) {
368 struct usb_host_config
*cf
= &dev
->config
[c
];
373 for (i
= 0; i
< cf
->desc
.bNumInterfaces
; i
++) {
374 struct usb_interface
*ifp
=
377 if (!ifp
->altsetting
)
380 for (j
= 0; j
< ifp
->num_altsetting
; j
++) {
381 struct usb_host_interface
*as
=
391 for(k
= 0; k
< as
->desc
.bNumEndpoints
; k
++) {
392 if(as
->endpoint
[k
].extra
) {
393 kfree(as
->endpoint
[k
].extra
);
399 kfree(ifp
->altsetting
);
401 kfree(cf
->interface
);
407 // hub-only!! ... and only in reset path, or usb_new_device()
408 // (used by real hubs and virtual root hubs)
409 int usb_get_configuration(struct usb_device
*dev
)
412 unsigned int cfgno
, length
;
413 unsigned char *buffer
;
414 unsigned char *bigbuffer
;
415 struct usb_config_descriptor
*desc
;
417 if (dev
->descriptor
.bNumConfigurations
> USB_MAXCONFIG
) {
418 warn("too many configurations");
422 if (dev
->descriptor
.bNumConfigurations
< 1) {
423 warn("not enough configurations");
427 dev
->config
= (struct usb_host_config
*)
428 kmalloc(dev
->descriptor
.bNumConfigurations
*
429 sizeof(struct usb_host_config
), GFP_KERNEL
);
431 err("out of memory");
434 memset(dev
->config
, 0, dev
->descriptor
.bNumConfigurations
*
435 sizeof(struct usb_host_config
));
437 dev
->rawdescriptors
= (char **)kmalloc(sizeof(char *) *
438 dev
->descriptor
.bNumConfigurations
, GFP_KERNEL
);
439 if (!dev
->rawdescriptors
) {
440 err("out of memory");
444 buffer
= kmalloc(8, GFP_KERNEL
);
446 err("unable to allocate memory for configuration descriptors");
449 desc
= (struct usb_config_descriptor
*)buffer
;
451 for (cfgno
= 0; cfgno
< dev
->descriptor
.bNumConfigurations
; cfgno
++) {
452 /* We grab the first 8 bytes so we know how long the whole */
453 /* configuration is */
454 result
= usb_get_descriptor(dev
, USB_DT_CONFIG
, cfgno
, buffer
, 8);
457 err("unable to get descriptor");
460 err("config descriptor too short (expected %i, got %i)", 8, result
);
466 /* Get the full buffer */
467 length
= le16_to_cpu(desc
->wTotalLength
);
469 bigbuffer
= kmalloc(length
, GFP_KERNEL
);
471 err("unable to allocate memory for configuration descriptors");
476 /* Now that we know the length, get the whole thing */
477 result
= usb_get_descriptor(dev
, USB_DT_CONFIG
, cfgno
, bigbuffer
, length
);
479 err("couldn't get all of config descriptors");
484 if (result
< length
) {
485 err("config descriptor too short (expected %i, got %i)", length
, result
);
491 dev
->rawdescriptors
[cfgno
] = bigbuffer
;
493 result
= usb_parse_configuration(&dev
->config
[cfgno
], bigbuffer
);
495 dbg("descriptor data left");
496 else if (result
< 0) {
506 dev
->descriptor
.bNumConfigurations
= cfgno
;