source: src/linux/universal/linux-3.18/drivers/usb/core/config.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

File size: 24.5 KB
Line 
1#include <linux/usb.h>
2#include <linux/usb/ch9.h>
3#include <linux/usb/hcd.h>
4#include <linux/usb/quirks.h>
5#include <linux/module.h>
6#include <linux/slab.h>
7#include <linux/device.h>
8#include <asm/byteorder.h>
9#include "usb.h"
10
11
12#define USB_MAXALTSETTING               128     /* Hard limit */
13
14#define USB_MAXCONFIG                   8       /* Arbitrary limit */
15
16
17static inline const char *plural(int n)
18{
19        return (n == 1 ? "" : "s");
20}
21
22static int find_next_descriptor(unsigned char *buffer, int size,
23    int dt1, int dt2, int *num_skipped)
24{
25        struct usb_descriptor_header *h;
26        int n = 0;
27        unsigned char *buffer0 = buffer;
28
29        /* Find the next descriptor of type dt1 or dt2 */
30        while (size > 0) {
31                h = (struct usb_descriptor_header *) buffer;
32                if (h->bDescriptorType == dt1 || h->bDescriptorType == dt2)
33                        break;
34                buffer += h->bLength;
35                size -= h->bLength;
36                ++n;
37        }
38
39        /* Store the number of descriptors skipped and return the
40         * number of bytes skipped */
41        if (num_skipped)
42                *num_skipped = n;
43        return buffer - buffer0;
44}
45
46static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
47                int inum, int asnum, struct usb_host_endpoint *ep,
48                unsigned char *buffer, int size)
49{
50        struct usb_ss_ep_comp_descriptor *desc;
51        int max_tx;
52
53        /* The SuperSpeed endpoint companion descriptor is supposed to
54         * be the first thing immediately following the endpoint descriptor.
55         */
56        desc = (struct usb_ss_ep_comp_descriptor *) buffer;
57        if (desc->bDescriptorType != USB_DT_SS_ENDPOINT_COMP ||
58                        size < USB_DT_SS_EP_COMP_SIZE) {
59                dev_warn(ddev, "No SuperSpeed endpoint companion for config %d "
60                                " interface %d altsetting %d ep %d: "
61                                "using minimum values\n",
62                                cfgno, inum, asnum, ep->desc.bEndpointAddress);
63
64                /* Fill in some default values.
65                 * Leave bmAttributes as zero, which will mean no streams for
66                 * bulk, and isoc won't support multiple bursts of packets.
67                 * With bursts of only one packet, and a Mult of 1, the max
68                 * amount of data moved per endpoint service interval is one
69                 * packet.
70                 */
71                ep->ss_ep_comp.bLength = USB_DT_SS_EP_COMP_SIZE;
72                ep->ss_ep_comp.bDescriptorType = USB_DT_SS_ENDPOINT_COMP;
73                if (usb_endpoint_xfer_isoc(&ep->desc) ||
74                                usb_endpoint_xfer_int(&ep->desc))
75                        ep->ss_ep_comp.wBytesPerInterval =
76                                        ep->desc.wMaxPacketSize;
77                return;
78        }
79
80        memcpy(&ep->ss_ep_comp, desc, USB_DT_SS_EP_COMP_SIZE);
81
82        /* Check the various values */
83        if (usb_endpoint_xfer_control(&ep->desc) && desc->bMaxBurst != 0) {
84                dev_warn(ddev, "Control endpoint with bMaxBurst = %d in "
85                                "config %d interface %d altsetting %d ep %d: "
86                                "setting to zero\n", desc->bMaxBurst,
87                                cfgno, inum, asnum, ep->desc.bEndpointAddress);
88                ep->ss_ep_comp.bMaxBurst = 0;
89        } else if (desc->bMaxBurst > 15) {
90                dev_warn(ddev, "Endpoint with bMaxBurst = %d in "
91                                "config %d interface %d altsetting %d ep %d: "
92                                "setting to 15\n", desc->bMaxBurst,
93                                cfgno, inum, asnum, ep->desc.bEndpointAddress);
94                ep->ss_ep_comp.bMaxBurst = 15;
95        }
96
97        if ((usb_endpoint_xfer_control(&ep->desc) ||
98                        usb_endpoint_xfer_int(&ep->desc)) &&
99                                desc->bmAttributes != 0) {
100                dev_warn(ddev, "%s endpoint with bmAttributes = %d in "
101                                "config %d interface %d altsetting %d ep %d: "
102                                "setting to zero\n",
103                                usb_endpoint_xfer_control(&ep->desc) ? "Control" : "Bulk",
104                                desc->bmAttributes,
105                                cfgno, inum, asnum, ep->desc.bEndpointAddress);
106                ep->ss_ep_comp.bmAttributes = 0;
107        } else if (usb_endpoint_xfer_bulk(&ep->desc) &&
108                        desc->bmAttributes > 16) {
109                dev_warn(ddev, "Bulk endpoint with more than 65536 streams in "
110                                "config %d interface %d altsetting %d ep %d: "
111                                "setting to max\n",
112                                cfgno, inum, asnum, ep->desc.bEndpointAddress);
113                ep->ss_ep_comp.bmAttributes = 16;
114        } else if (usb_endpoint_xfer_isoc(&ep->desc) &&
115                   USB_SS_MULT(desc->bmAttributes) > 3) {
116                dev_warn(ddev, "Isoc endpoint has Mult of %d in "
117                                "config %d interface %d altsetting %d ep %d: "
118                                "setting to 3\n",
119                                USB_SS_MULT(desc->bmAttributes),
120                                cfgno, inum, asnum, ep->desc.bEndpointAddress);
121                ep->ss_ep_comp.bmAttributes = 2;
122        }
123
124        if (usb_endpoint_xfer_isoc(&ep->desc))
125                max_tx = (desc->bMaxBurst + 1) *
126                        (USB_SS_MULT(desc->bmAttributes)) *
127                        usb_endpoint_maxp(&ep->desc);
128        else if (usb_endpoint_xfer_int(&ep->desc))
129                max_tx = usb_endpoint_maxp(&ep->desc) *
130                        (desc->bMaxBurst + 1);
131        else
132                max_tx = 999999;
133        if (le16_to_cpu(desc->wBytesPerInterval) > max_tx) {
134                dev_warn(ddev, "%s endpoint with wBytesPerInterval of %d in "
135                                "config %d interface %d altsetting %d ep %d: "
136                                "setting to %d\n",
137                                usb_endpoint_xfer_isoc(&ep->desc) ? "Isoc" : "Int",
138                                le16_to_cpu(desc->wBytesPerInterval),
139                                cfgno, inum, asnum, ep->desc.bEndpointAddress,
140                                max_tx);
141                ep->ss_ep_comp.wBytesPerInterval = cpu_to_le16(max_tx);
142        }
143}
144
145static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum,
146    int asnum, struct usb_host_interface *ifp, int num_ep,
147    unsigned char *buffer, int size)
148{
149        unsigned char *buffer0 = buffer;
150        struct usb_endpoint_descriptor *d;
151        struct usb_host_endpoint *endpoint;
152        int n, i, j, retval;
153
154        d = (struct usb_endpoint_descriptor *) buffer;
155        buffer += d->bLength;
156        size -= d->bLength;
157
158        if (d->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE)
159                n = USB_DT_ENDPOINT_AUDIO_SIZE;
160        else if (d->bLength >= USB_DT_ENDPOINT_SIZE)
161                n = USB_DT_ENDPOINT_SIZE;
162        else {
163                dev_warn(ddev, "config %d interface %d altsetting %d has an "
164                    "invalid endpoint descriptor of length %d, skipping\n",
165                    cfgno, inum, asnum, d->bLength);
166                goto skip_to_next_endpoint_or_interface_descriptor;
167        }
168
169        i = d->bEndpointAddress & ~USB_ENDPOINT_DIR_MASK;
170        if (i >= 16 || i == 0) {
171                dev_warn(ddev, "config %d interface %d altsetting %d has an "
172                    "invalid endpoint with address 0x%X, skipping\n",
173                    cfgno, inum, asnum, d->bEndpointAddress);
174                goto skip_to_next_endpoint_or_interface_descriptor;
175        }
176
177        /* Only store as many endpoints as we have room for */
178        if (ifp->desc.bNumEndpoints >= num_ep)
179                goto skip_to_next_endpoint_or_interface_descriptor;
180
181        endpoint = &ifp->endpoint[ifp->desc.bNumEndpoints];
182        ++ifp->desc.bNumEndpoints;
183
184        memcpy(&endpoint->desc, d, n);
185        INIT_LIST_HEAD(&endpoint->urb_list);
186
187        /*
188         * Fix up bInterval values outside the legal range.
189         * Use 10 or 8 ms if no proper value can be guessed.
190         */
191        i = 0;          /* i = min, j = max, n = default */
192        j = 255;
193        if (usb_endpoint_xfer_int(d)) {
194                i = 1;
195                switch (to_usb_device(ddev)->speed) {
196                case USB_SPEED_SUPER:
197                case USB_SPEED_HIGH:
198                        /*
199                         * Many device manufacturers are using full-speed
200                         * bInterval values in high-speed interrupt endpoint
201                         * descriptors. Try to fix those and fall back to an
202                         * 8-ms default value otherwise.
203                         */
204                        n = fls(d->bInterval*8);
205                        if (n == 0)
206                                n = 7;  /* 8 ms = 2^(7-1) uframes */
207                        j = 16;
208
209                        /*
210                         * Adjust bInterval for quirked devices.
211                         */
212                        /*
213                         * This quirk fixes bIntervals reported in ms.
214                         */
215                        if (to_usb_device(ddev)->quirks &
216                                USB_QUIRK_LINEAR_FRAME_INTR_BINTERVAL) {
217                                n = clamp(fls(d->bInterval) + 3, i, j);
218                                i = j = n;
219                        }
220                        /*
221                         * This quirk fixes bIntervals reported in
222                         * linear microframes.
223                         */
224                        if (to_usb_device(ddev)->quirks &
225                                USB_QUIRK_LINEAR_UFRAME_INTR_BINTERVAL) {
226                                n = clamp(fls(d->bInterval), i, j);
227                                i = j = n;
228                        }
229                        break;
230                default:                /* USB_SPEED_FULL or _LOW */
231                        /*
232                         * For low-speed, 10 ms is the official minimum.
233                         * But some "overclocked" devices might want faster
234                         * polling so we'll allow it.
235                         */
236                        n = 10;
237                        break;
238                }
239        } else if (usb_endpoint_xfer_isoc(d)) {
240                i = 1;
241                j = 16;
242                switch (to_usb_device(ddev)->speed) {
243                case USB_SPEED_HIGH:
244                        n = 7;          /* 8 ms = 2^(7-1) uframes */
245                        break;
246                default:                /* USB_SPEED_FULL */
247                        n = 4;          /* 8 ms = 2^(4-1) frames */
248                        break;
249                }
250        }
251        if (d->bInterval < i || d->bInterval > j) {
252                dev_warn(ddev, "config %d interface %d altsetting %d "
253                    "endpoint 0x%X has an invalid bInterval %d, "
254                    "changing to %d\n",
255                    cfgno, inum, asnum,
256                    d->bEndpointAddress, d->bInterval, n);
257                endpoint->desc.bInterval = n;
258        }
259
260        /* Some buggy low-speed devices have Bulk endpoints, which is
261         * explicitly forbidden by the USB spec.  In an attempt to make
262         * them usable, we will try treating them as Interrupt endpoints.
263         */
264        if (to_usb_device(ddev)->speed == USB_SPEED_LOW &&
265                        usb_endpoint_xfer_bulk(d)) {
266                dev_warn(ddev, "config %d interface %d altsetting %d "
267                    "endpoint 0x%X is Bulk; changing to Interrupt\n",
268                    cfgno, inum, asnum, d->bEndpointAddress);
269                endpoint->desc.bmAttributes = USB_ENDPOINT_XFER_INT;
270                endpoint->desc.bInterval = 1;
271                if (usb_endpoint_maxp(&endpoint->desc) > 8)
272                        endpoint->desc.wMaxPacketSize = cpu_to_le16(8);
273        }
274
275        /*
276         * Some buggy high speed devices have bulk endpoints using
277         * maxpacket sizes other than 512.  High speed HCDs may not
278         * be able to handle that particular bug, so let's warn...
279         */
280        if (to_usb_device(ddev)->speed == USB_SPEED_HIGH
281                        && usb_endpoint_xfer_bulk(d)) {
282                unsigned maxp;
283
284                maxp = usb_endpoint_maxp(&endpoint->desc) & 0x07ff;
285                if (maxp != 512)
286                        dev_warn(ddev, "config %d interface %d altsetting %d "
287                                "bulk endpoint 0x%X has invalid maxpacket %d\n",
288                                cfgno, inum, asnum, d->bEndpointAddress,
289                                maxp);
290        }
291
292        /* Parse a possible SuperSpeed endpoint companion descriptor */
293        if (to_usb_device(ddev)->speed == USB_SPEED_SUPER)
294                usb_parse_ss_endpoint_companion(ddev, cfgno,
295                                inum, asnum, endpoint, buffer, size);
296
297        /* Skip over any Class Specific or Vendor Specific descriptors;
298         * find the next endpoint or interface descriptor */
299        endpoint->extra = buffer;
300        i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT,
301                        USB_DT_INTERFACE, &n);
302        endpoint->extralen = i;
303        retval = buffer - buffer0 + i;
304        if (n > 0)
305                dev_dbg(ddev, "skipped %d descriptor%s after %s\n",
306                    n, plural(n), "endpoint");
307        return retval;
308
309skip_to_next_endpoint_or_interface_descriptor:
310        i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT,
311            USB_DT_INTERFACE, NULL);
312        return buffer - buffer0 + i;
313}
314
315void usb_release_interface_cache(struct kref *ref)
316{
317        struct usb_interface_cache *intfc = ref_to_usb_interface_cache(ref);
318        int j;
319
320        for (j = 0; j < intfc->num_altsetting; j++) {
321                struct usb_host_interface *alt = &intfc->altsetting[j];
322
323                kfree(alt->endpoint);
324                kfree(alt->string);
325        }
326        kfree(intfc);
327}
328
329static int usb_parse_interface(struct device *ddev, int cfgno,
330    struct usb_host_config *config, unsigned char *buffer, int size,
331    u8 inums[], u8 nalts[])
332{
333        unsigned char *buffer0 = buffer;
334        struct usb_interface_descriptor *d;
335        int inum, asnum;
336        struct usb_interface_cache *intfc;
337        struct usb_host_interface *alt;
338        int i, n;
339        int len, retval;
340        int num_ep, num_ep_orig;
341
342        d = (struct usb_interface_descriptor *) buffer;
343        buffer += d->bLength;
344        size -= d->bLength;
345
346        if (d->bLength < USB_DT_INTERFACE_SIZE)
347                goto skip_to_next_interface_descriptor;
348
349        /* Which interface entry is this? */
350        intfc = NULL;
351        inum = d->bInterfaceNumber;
352        for (i = 0; i < config->desc.bNumInterfaces; ++i) {
353                if (inums[i] == inum) {
354                        intfc = config->intf_cache[i];
355                        break;
356                }
357        }
358        if (!intfc || intfc->num_altsetting >= nalts[i])
359                goto skip_to_next_interface_descriptor;
360
361        /* Check for duplicate altsetting entries */
362        asnum = d->bAlternateSetting;
363        for ((i = 0, alt = &intfc->altsetting[0]);
364              i < intfc->num_altsetting;
365             (++i, ++alt)) {
366                if (alt->desc.bAlternateSetting == asnum) {
367                        dev_warn(ddev, "Duplicate descriptor for config %d "
368                            "interface %d altsetting %d, skipping\n",
369                            cfgno, inum, asnum);
370                        goto skip_to_next_interface_descriptor;
371                }
372        }
373
374        ++intfc->num_altsetting;
375        memcpy(&alt->desc, d, USB_DT_INTERFACE_SIZE);
376
377        /* Skip over any Class Specific or Vendor Specific descriptors;
378         * find the first endpoint or interface descriptor */
379        alt->extra = buffer;
380        i = find_next_descriptor(buffer, size, USB_DT_ENDPOINT,
381            USB_DT_INTERFACE, &n);
382        alt->extralen = i;
383        if (n > 0)
384                dev_dbg(ddev, "skipped %d descriptor%s after %s\n",
385                    n, plural(n), "interface");
386        buffer += i;
387        size -= i;
388
389        /* Allocate space for the right(?) number of endpoints */
390        num_ep = num_ep_orig = alt->desc.bNumEndpoints;
391        alt->desc.bNumEndpoints = 0;            /* Use as a counter */
392        if (num_ep > USB_MAXENDPOINTS) {
393                dev_warn(ddev, "too many endpoints for config %d interface %d "
394                    "altsetting %d: %d, using maximum allowed: %d\n",
395                    cfgno, inum, asnum, num_ep, USB_MAXENDPOINTS);
396                num_ep = USB_MAXENDPOINTS;
397        }
398
399        if (num_ep > 0) {
400                /* Can't allocate 0 bytes */
401                len = sizeof(struct usb_host_endpoint) * num_ep;
402                alt->endpoint = kzalloc(len, GFP_KERNEL);
403                if (!alt->endpoint)
404                        return -ENOMEM;
405        }
406
407        /* Parse all the endpoint descriptors */
408        n = 0;
409        while (size > 0) {
410                if (((struct usb_descriptor_header *) buffer)->bDescriptorType
411                     == USB_DT_INTERFACE)
412                        break;
413                retval = usb_parse_endpoint(ddev, cfgno, inum, asnum, alt,
414                    num_ep, buffer, size);
415                if (retval < 0)
416                        return retval;
417                ++n;
418
419                buffer += retval;
420                size -= retval;
421        }
422
423        if (n != num_ep_orig)
424                dev_warn(ddev, "config %d interface %d altsetting %d has %d "
425                    "endpoint descriptor%s, different from the interface "
426                    "descriptor's value: %d\n",
427                    cfgno, inum, asnum, n, plural(n), num_ep_orig);
428        return buffer - buffer0;
429
430skip_to_next_interface_descriptor:
431        i = find_next_descriptor(buffer, size, USB_DT_INTERFACE,
432            USB_DT_INTERFACE, NULL);
433        return buffer - buffer0 + i;
434}
435
436static int usb_parse_configuration(struct usb_device *dev, int cfgidx,
437    struct usb_host_config *config, unsigned char *buffer, int size)
438{
439        struct device *ddev = &dev->dev;
440        unsigned char *buffer0 = buffer;
441        int cfgno;
442        int nintf, nintf_orig;
443        int i, j, n;
444        struct usb_interface_cache *intfc;
445        unsigned char *buffer2;
446        int size2;
447        struct usb_descriptor_header *header;
448        int len, retval;
449        u8 inums[USB_MAXINTERFACES], nalts[USB_MAXINTERFACES];
450        unsigned iad_num = 0;
451
452        memcpy(&config->desc, buffer, USB_DT_CONFIG_SIZE);
453        if (config->desc.bDescriptorType != USB_DT_CONFIG ||
454            config->desc.bLength < USB_DT_CONFIG_SIZE ||
455            config->desc.bLength > size) {
456                dev_err(ddev, "invalid descriptor for config index %d: "
457                    "type = 0x%X, length = %d\n", cfgidx,
458                    config->desc.bDescriptorType, config->desc.bLength);
459                return -EINVAL;
460        }
461        cfgno = config->desc.bConfigurationValue;
462
463        buffer += config->desc.bLength;
464        size -= config->desc.bLength;
465
466        nintf = nintf_orig = config->desc.bNumInterfaces;
467        if (nintf > USB_MAXINTERFACES) {
468                dev_warn(ddev, "config %d has too many interfaces: %d, "
469                    "using maximum allowed: %d\n",
470                    cfgno, nintf, USB_MAXINTERFACES);
471                nintf = USB_MAXINTERFACES;
472        }
473
474        /* Go through the descriptors, checking their length and counting the
475         * number of altsettings for each interface */
476        n = 0;
477        for ((buffer2 = buffer, size2 = size);
478              size2 > 0;
479             (buffer2 += header->bLength, size2 -= header->bLength)) {
480
481                if (size2 < sizeof(struct usb_descriptor_header)) {
482                        dev_warn(ddev, "config %d descriptor has %d excess "
483                            "byte%s, ignoring\n",
484                            cfgno, size2, plural(size2));
485                        break;
486                }
487
488                header = (struct usb_descriptor_header *) buffer2;
489                if ((header->bLength > size2) || (header->bLength < 2)) {
490                        dev_warn(ddev, "config %d has an invalid descriptor "
491                            "of length %d, skipping remainder of the config\n",
492                            cfgno, header->bLength);
493                        break;
494                }
495
496                if (header->bDescriptorType == USB_DT_INTERFACE) {
497                        struct usb_interface_descriptor *d;
498                        int inum;
499
500                        d = (struct usb_interface_descriptor *) header;
501                        if (d->bLength < USB_DT_INTERFACE_SIZE) {
502                                dev_warn(ddev, "config %d has an invalid "
503                                    "interface descriptor of length %d, "
504                                    "skipping\n", cfgno, d->bLength);
505                                continue;
506                        }
507
508                        inum = d->bInterfaceNumber;
509
510                        if ((dev->quirks & USB_QUIRK_HONOR_BNUMINTERFACES) &&
511                            n >= nintf_orig) {
512                                dev_warn(ddev, "config %d has more interface "
513                                    "descriptors, than it declares in "
514                                    "bNumInterfaces, ignoring interface "
515                                    "number: %d\n", cfgno, inum);
516                                continue;
517                        }
518
519                        if (inum >= nintf_orig)
520                                dev_warn(ddev, "config %d has an invalid "
521                                    "interface number: %d but max is %d\n",
522                                    cfgno, inum, nintf_orig - 1);
523
524                        /* Have we already encountered this interface?
525                         * Count its altsettings */
526                        for (i = 0; i < n; ++i) {
527                                if (inums[i] == inum)
528                                        break;
529                        }
530                        if (i < n) {
531                                if (nalts[i] < 255)
532                                        ++nalts[i];
533                        } else if (n < USB_MAXINTERFACES) {
534                                inums[n] = inum;
535                                nalts[n] = 1;
536                                ++n;
537                        }
538
539                } else if (header->bDescriptorType ==
540                                USB_DT_INTERFACE_ASSOCIATION) {
541                        if (iad_num == USB_MAXIADS) {
542                                dev_warn(ddev, "found more Interface "
543                                               "Association Descriptors "
544                                               "than allocated for in "
545                                               "configuration %d\n", cfgno);
546                        } else {
547                                config->intf_assoc[iad_num] =
548                                        (struct usb_interface_assoc_descriptor
549                                        *)header;
550                                iad_num++;
551                        }
552
553                } else if (header->bDescriptorType == USB_DT_DEVICE ||
554                            header->bDescriptorType == USB_DT_CONFIG)
555                        dev_warn(ddev, "config %d contains an unexpected "
556                            "descriptor of type 0x%X, skipping\n",
557                            cfgno, header->bDescriptorType);
558
559        }       /* for ((buffer2 = buffer, size2 = size); ...) */
560        size = buffer2 - buffer;
561        config->desc.wTotalLength = cpu_to_le16(buffer2 - buffer0);
562
563        if (n != nintf)
564                dev_warn(ddev, "config %d has %d interface%s, different from "
565                    "the descriptor's value: %d\n",
566                    cfgno, n, plural(n), nintf_orig);
567        else if (n == 0)
568                dev_warn(ddev, "config %d has no interfaces?\n", cfgno);
569        config->desc.bNumInterfaces = nintf = n;
570
571        /* Check for missing interface numbers */
572        for (i = 0; i < nintf; ++i) {
573                for (j = 0; j < nintf; ++j) {
574                        if (inums[j] == i)
575                                break;
576                }
577                if (j >= nintf)
578                        dev_warn(ddev, "config %d has no interface number "
579                            "%d\n", cfgno, i);
580        }
581
582        /* Allocate the usb_interface_caches and altsetting arrays */
583        for (i = 0; i < nintf; ++i) {
584                j = nalts[i];
585                if (j > USB_MAXALTSETTING) {
586                        dev_warn(ddev, "too many alternate settings for "
587                            "config %d interface %d: %d, "
588                            "using maximum allowed: %d\n",
589                            cfgno, inums[i], j, USB_MAXALTSETTING);
590                        nalts[i] = j = USB_MAXALTSETTING;
591                }
592
593                len = sizeof(*intfc) + sizeof(struct usb_host_interface) * j;
594                config->intf_cache[i] = intfc = kzalloc(len, GFP_KERNEL);
595                if (!intfc)
596                        return -ENOMEM;
597                kref_init(&intfc->ref);
598        }
599
600        /* FIXME: parse the BOS descriptor */
601
602        /* Skip over any Class Specific or Vendor Specific descriptors;
603         * find the first interface descriptor */
604        config->extra = buffer;
605        i = find_next_descriptor(buffer, size, USB_DT_INTERFACE,
606            USB_DT_INTERFACE, &n);
607        config->extralen = i;
608        if (n > 0)
609                dev_dbg(ddev, "skipped %d descriptor%s after %s\n",
610                    n, plural(n), "configuration");
611        buffer += i;
612        size -= i;
613
614        /* Parse all the interface/altsetting descriptors */
615        while (size > 0) {
616                retval = usb_parse_interface(ddev, cfgno, config,
617                    buffer, size, inums, nalts);
618                if (retval < 0)
619                        return retval;
620
621                buffer += retval;
622                size -= retval;
623        }
624
625        /* Check for missing altsettings */
626        for (i = 0; i < nintf; ++i) {
627                intfc = config->intf_cache[i];
628                for (j = 0; j < intfc->num_altsetting; ++j) {
629                        for (n = 0; n < intfc->num_altsetting; ++n) {
630                                if (intfc->altsetting[n].desc.
631                                    bAlternateSetting == j)
632                                        break;
633                        }
634                        if (n >= intfc->num_altsetting)
635                                dev_warn(ddev, "config %d interface %d has no "
636                                    "altsetting %d\n", cfgno, inums[i], j);
637                }
638        }
639
640        return 0;
641}
642
643/* hub-only!! ... and only exported for reset/reinit path.
644 * otherwise used internally on disconnect/destroy path
645 */
646void usb_destroy_configuration(struct usb_device *dev)
647{
648        int c, i;
649
650        if (!dev->config)
651                return;
652
653        if (dev->rawdescriptors) {
654                for (i = 0; i < dev->descriptor.bNumConfigurations; i++)
655                        kfree(dev->rawdescriptors[i]);
656
657                kfree(dev->rawdescriptors);
658                dev->rawdescriptors = NULL;
659        }
660
661        for (c = 0; c < dev->descriptor.bNumConfigurations; c++) {
662                struct usb_host_config *cf = &dev->config[c];
663
664                kfree(cf->string);
665                for (i = 0; i < cf->desc.bNumInterfaces; i++) {
666                        if (cf->intf_cache[i])
667                                kref_put(&cf->intf_cache[i]->ref,
668                                          usb_release_interface_cache);
669                }
670        }
671        kfree(dev->config);
672        dev->config = NULL;
673}
674
675
676/*
677 * Get the USB config descriptors, cache and parse'em
678 *
679 * hub-only!! ... and only in reset path, or usb_new_device()
680 * (used by real hubs and virtual root hubs)
681 */
682int usb_get_configuration(struct usb_device *dev)
683{
684        struct device *ddev = &dev->dev;
685        int ncfg = dev->descriptor.bNumConfigurations;
686        int result = 0;
687        unsigned int cfgno, length;
688        unsigned char *bigbuffer;
689        struct usb_config_descriptor *desc;
690
691        cfgno = 0;
692        result = -ENOMEM;
693        if (ncfg > USB_MAXCONFIG) {
694                dev_warn(ddev, "too many configurations: %d, "
695                    "using maximum allowed: %d\n", ncfg, USB_MAXCONFIG);
696                dev->descriptor.bNumConfigurations = ncfg = USB_MAXCONFIG;
697        }
698
699        if (ncfg < 1) {
700                dev_err(ddev, "no configurations\n");
701                return -EINVAL;
702        }
703
704        length = ncfg * sizeof(struct usb_host_config);
705        dev->config = kzalloc(length, GFP_KERNEL);
706        if (!dev->config)
707                goto err2;
708
709        length = ncfg * sizeof(char *);
710        dev->rawdescriptors = kzalloc(length, GFP_KERNEL);
711        if (!dev->rawdescriptors)
712                goto err2;
713
714        desc = kmalloc(USB_DT_CONFIG_SIZE, GFP_KERNEL);
715        if (!desc)
716                goto err2;
717
718        result = 0;
719        for (; cfgno < ncfg; cfgno++) {
720                /* We grab just the first descriptor so we know how long
721                 * the whole configuration is */
722                result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,
723                    desc, USB_DT_CONFIG_SIZE);
724                if (result < 0) {
725                        dev_err(ddev, "unable to read config index %d "
726                            "descriptor/%s: %d\n", cfgno, "start", result);
727                        if (result != -EPIPE)
728                                goto err;
729                        dev_err(ddev, "chopping to %d config(s)\n", cfgno);
730                        dev->descriptor.bNumConfigurations = cfgno;
731                        break;
732                } else if (result < 4) {
733                        dev_err(ddev, "config index %d descriptor too short "
734                            "(expected %i, got %i)\n", cfgno,
735                            USB_DT_CONFIG_SIZE, result);
736                        result = -EINVAL;
737                        goto err;
738                }
739                length = max((int) le16_to_cpu(desc->wTotalLength),
740                    USB_DT_CONFIG_SIZE);
741
742                /* Now that we know the length, get the whole thing */
743                bigbuffer = kmalloc(length, GFP_KERNEL);
744                if (!bigbuffer) {
745                        result = -ENOMEM;
746                        goto err;
747                }
748
749                if (dev->quirks & USB_QUIRK_DELAY_INIT)
750                        msleep(100);
751
752                result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,
753                    bigbuffer, length);
754                if (result < 0) {
755                        dev_err(ddev, "unable to read config index %d "
756                            "descriptor/%s\n", cfgno, "all");
757                        kfree(bigbuffer);
758                        goto err;
759                }
760                if (result < length) {
761                        dev_warn(ddev, "config index %d descriptor too short "
762                            "(expected %i, got %i)\n", cfgno, length, result);
763                        length = result;
764                }
765
766                dev->rawdescriptors[cfgno] = bigbuffer;
767
768                result = usb_parse_configuration(dev, cfgno,
769                    &dev->config[cfgno], bigbuffer, length);
770                if (result < 0) {
771                        ++cfgno;
772                        goto err;
773                }
774        }
775        result = 0;
776
777err:
778        kfree(desc);
779        dev->descriptor.bNumConfigurations = cfgno;
780err2:
781        if (result == -ENOMEM)
782                dev_err(ddev, "out of memory\n");
783        return result;
784}
785
786void usb_release_bos_descriptor(struct usb_device *dev)
787{
788        if (dev->bos) {
789                kfree(dev->bos->desc);
790                kfree(dev->bos);
791                dev->bos = NULL;
792        }
793}
794
795/* Get BOS descriptor set */
796int usb_get_bos_descriptor(struct usb_device *dev)
797{
798        struct device *ddev = &dev->dev;
799        struct usb_bos_descriptor *bos;
800        struct usb_dev_cap_header *cap;
801        unsigned char *buffer;
802        int length, total_len, num, i;
803        int ret;
804
805        bos = kzalloc(sizeof(struct usb_bos_descriptor), GFP_KERNEL);
806        if (!bos)
807                return -ENOMEM;
808
809        /* Get BOS descriptor */
810        ret = usb_get_descriptor(dev, USB_DT_BOS, 0, bos, USB_DT_BOS_SIZE);
811        if (ret < USB_DT_BOS_SIZE) {
812                dev_err(ddev, "unable to get BOS descriptor\n");
813                if (ret >= 0)
814                        ret = -ENOMSG;
815                kfree(bos);
816                return ret;
817        }
818
819        length = bos->bLength;
820        total_len = le16_to_cpu(bos->wTotalLength);
821        num = bos->bNumDeviceCaps;
822        kfree(bos);
823        if (total_len < length)
824                return -EINVAL;
825
826        dev->bos = kzalloc(sizeof(struct usb_host_bos), GFP_KERNEL);
827        if (!dev->bos)
828                return -ENOMEM;
829
830        /* Now let's get the whole BOS descriptor set */
831        buffer = kzalloc(total_len, GFP_KERNEL);
832        if (!buffer) {
833                ret = -ENOMEM;
834                goto err;
835        }
836        dev->bos->desc = (struct usb_bos_descriptor *)buffer;
837
838        ret = usb_get_descriptor(dev, USB_DT_BOS, 0, buffer, total_len);
839        if (ret < total_len) {
840                dev_err(ddev, "unable to get BOS descriptor set\n");
841                if (ret >= 0)
842                        ret = -ENOMSG;
843                goto err;
844        }
845        total_len -= length;
846
847        for (i = 0; i < num; i++) {
848                buffer += length;
849                cap = (struct usb_dev_cap_header *)buffer;
850                length = cap->bLength;
851
852                if (total_len < length)
853                        break;
854                total_len -= length;
855
856                if (cap->bDescriptorType != USB_DT_DEVICE_CAPABILITY) {
857                        dev_warn(ddev, "descriptor type invalid, skip\n");
858                        continue;
859                }
860
861                switch (cap->bDevCapabilityType) {
862                case USB_CAP_TYPE_WIRELESS_USB:
863                        /* Wireless USB cap descriptor is handled by wusb */
864                        break;
865                case USB_CAP_TYPE_EXT:
866                        dev->bos->ext_cap =
867                                (struct usb_ext_cap_descriptor *)buffer;
868                        break;
869                case USB_SS_CAP_TYPE:
870                        dev->bos->ss_cap =
871                                (struct usb_ss_cap_descriptor *)buffer;
872                        break;
873                case CONTAINER_ID_TYPE:
874                        dev->bos->ss_id =
875                                (struct usb_ss_container_id_descriptor *)buffer;
876                        break;
877                default:
878                        break;
879                }
880        }
881
882        return 0;
883
884err:
885        usb_release_bos_descriptor(dev);
886        return ret;
887}
Note: See TracBrowser for help on using the repository browser.