tools/tools/bus_autoconf/bus_usb.c

   1 /* $FreeBSD: head/tools/tools/bus_autoconf/bus_usb.c 233110 2012-03-18 09:47:27Z hselasky $ */
   2
   3 /*-
   4  * Copyright (c) 2011 Hans Petter Selasky. All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdint.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <err.h>
  33 #include <sysexits.h>
  34 #include <unistd.h>
  35 #include <sys/queue.h>
  36
  37 #include "bus_autoconf.h"
  38 #include "bus_sections.h"
  39 #include "bus_usb.h"
  40
  41 struct usb_blob;
  42 typedef TAILQ_HEAD(,usb_blob) usb_blob_head_t;
  43 typedef TAILQ_ENTRY(usb_blob) usb_blob_entry_t;
  44
  45 static usb_blob_head_t usb_blob_head = TAILQ_HEAD_INITIALIZER(usb_blob_head);
  46 static uint32_t usb_blob_count;
  47
  48 struct usb_blob {
  49         usb_blob_entry_t entry;
  50         struct usb_device_id temp;
  51 };
  52
  53 /*
  54  * To ensure that the correct USB driver is loaded, the driver having
  55  * the most information about the device must be probed first. Then
  56  * more generic drivers shall be probed.
  57  */
  58 static int
  59 usb_compare(const void *_a, const void *_b)
  60 {
  61         const struct usb_device_id *a = _a;
  62         const struct usb_device_id *b = _b;
  63         int retval;
  64
  65         /* vendor matches first */
  66
  67         if (a->match_flag_vendor > b->match_flag_vendor)
  68                 return (-1);
  69         if (a->match_flag_vendor < b->match_flag_vendor)
  70                 return (1);
  71
  72         /* product matches first */
  73
  74         if (a->match_flag_product > b->match_flag_product)
  75                 return (-1);
  76         if (a->match_flag_product < b->match_flag_product)
  77                 return (1);
  78
  79         /* device class matches first */
  80
  81         if (a->match_flag_dev_class > b->match_flag_dev_class)
  82                 return (-1);
  83         if (a->match_flag_dev_class < b->match_flag_dev_class)
  84                 return (1);
  85
  86         if (a->match_flag_dev_subclass > b->match_flag_dev_subclass)
  87                 return (-1);
  88         if (a->match_flag_dev_subclass < b->match_flag_dev_subclass)
  89                 return (1);
  90
  91         /* interface class matches first */
  92
  93         if (a->match_flag_int_class > b->match_flag_int_class)
  94                 return (-1);
  95         if (a->match_flag_int_class < b->match_flag_int_class)
  96                 return (1);
  97
  98         if (a->match_flag_int_subclass > b->match_flag_int_subclass)
  99                 return (-1);
 100         if (a->match_flag_int_subclass < b->match_flag_int_subclass)
 101                 return (1);
 102
 103         if (a->match_flag_int_protocol > b->match_flag_int_protocol)
 104                 return (-1);
 105         if (a->match_flag_int_protocol < b->match_flag_int_protocol)
 106                 return (1);
 107
 108         /* then sort according to value */
 109
 110         if (a->idVendor > b->idVendor)
 111                 return (1);
 112         if (a->idVendor < b->idVendor)
 113                 return (-1);
 114         if (a->idProduct > b->idProduct)
 115                 return (1);
 116         if (a->idProduct < b->idProduct)
 117                 return (-1);
 118         if (a->bDeviceClass > b->bDeviceClass)
 119                 return (1);
 120         if (a->bDeviceClass < b->bDeviceClass)
 121                 return (-1);
 122         if (a->bDeviceSubClass > b->bDeviceSubClass)
 123                 return (1);
 124         if (a->bDeviceSubClass < b->bDeviceSubClass)
 125                 return (-1);
 126         if (a->bDeviceProtocol > b->bDeviceProtocol)
 127                 return (1);
 128         if (a->bDeviceProtocol < b->bDeviceProtocol)
 129                 return (-1);
 130         if (a->bInterfaceClass > b->bInterfaceClass)
 131                 return (1);
 132         if (a->bInterfaceClass < b->bInterfaceClass)
 133                 return (-1);
 134         if (a->bInterfaceSubClass > b->bInterfaceSubClass)
 135                 return (1);
 136         if (a->bInterfaceSubClass < b->bInterfaceSubClass)
 137                 return (-1);
 138         if (a->bInterfaceProtocol > b->bInterfaceProtocol)
 139                 return (1);
 140         if (a->bInterfaceProtocol < b->bInterfaceProtocol)
 141                 return (-1);
 142
 143         /* in the end sort by module name and mode */
 144
 145         retval = strcmp(a->module_name, b->module_name);
 146         if (retval == 0)
 147                 retval = strcmp(a->module_mode, b->module_mode);
 148         return (retval);
 149 }
 150
 151 static void
 152 usb_sort_entries(struct usb_device_id *id, uint32_t nid)
 153 {
 154         qsort(id, nid, sizeof(*id), &usb_compare);
 155 }
 156
 157 static void
 158 usb_import_entry(struct usb_device_id *id, const char *type,
 159     const char *module, const uint8_t *ptr, uint16_t size)
 160 {
 161         const char *mode;
 162
 163         if (strstr(type, "_host_"))
 164                 mode = "host";
 165         else if (strstr(type, "_device_"))
 166                 mode = "device";
 167         else
 168                 mode = "(host|device)";
 169
 170         strlcpy(id->module_name, module, sizeof(id->module_name));
 171         strlcpy(id->module_mode, mode, sizeof(id->module_mode));
 172
 173         /* import data from binary object */
 174
 175         if (format_get_field(type, "mfl_vendor", ptr, size))
 176                 id->match_flag_vendor = 1;
 177         if (format_get_field(type, "mfl_product", ptr, size))
 178                 id->match_flag_product = 1;
 179         if (format_get_field(type, "mfl_dev_lo", ptr, size))
 180                 id->match_flag_dev_lo = 1;
 181         if (format_get_field(type, "mfl_dev_hi", ptr, size))
 182                 id->match_flag_dev_hi = 1;
 183         if (format_get_field(type, "mfl_dev_class", ptr, size))
 184                 id->match_flag_dev_class = 1;
 185         if (format_get_field(type, "mfl_dev_subclass", ptr, size))
 186                 id->match_flag_dev_subclass = 1;
 187         if (format_get_field(type, "mfl_dev_protocol", ptr, size))
 188                 id->match_flag_dev_protocol = 1;
 189         if (format_get_field(type, "mfl_int_class", ptr, size))
 190                 id->match_flag_int_class = 1;
 191         if (format_get_field(type, "mfl_int_subclass", ptr, size))
 192                 id->match_flag_int_subclass = 1;
 193         if (format_get_field(type, "mfl_int_protocol", ptr, size))
 194                 id->match_flag_int_protocol = 1;
 195
 196         id->idVendor = format_get_field(type, "idVendor[0]", ptr, size) |
 197             (format_get_field(type, "idVendor[1]", ptr, size) << 8);
 198         id->idProduct = format_get_field(type, "idProduct[0]", ptr, size) |
 199             (format_get_field(type, "idProduct[1]", ptr, size) << 8);
 200
 201         id->bcdDevice_lo = format_get_field(type, "bcdDevice_lo[0]", ptr, size) |
 202             (format_get_field(type, "bcdDevice_lo[1]", ptr, size) << 8);
 203
 204         id->bcdDevice_hi = format_get_field(type, "bcdDevice_hi[0]", ptr, size) |
 205             (format_get_field(type, "bcdDevice_hi[1]", ptr, size) << 8);
 206
 207         id->bDeviceClass = format_get_field(type, "bDeviceClass", ptr, size);
 208         id->bDeviceSubClass = format_get_field(type, "bDeviceSubClass", ptr, size);
 209         id->bDeviceProtocol = format_get_field(type, "bDeviceProtocol", ptr, size);
 210
 211         id->bInterfaceClass = format_get_field(type, "bInterfaceClass", ptr, size);
 212         id->bInterfaceSubClass = format_get_field(type, "bInterfaceSubClass", ptr, size);
 213         id->bInterfaceProtocol = format_get_field(type, "bInterfaceProtocol", ptr, size);
 214
 215         if (format_get_field(type, "mf_vendor", ptr, size))
 216                 id->match_flag_vendor = 1;
 217         if (format_get_field(type, "mf_product", ptr, size))
 218                 id->match_flag_product = 1;
 219         if (format_get_field(type, "mf_dev_lo", ptr, size))
 220                 id->match_flag_dev_lo = 1;
 221         if (format_get_field(type, "mf_dev_hi", ptr, size))
 222                 id->match_flag_dev_hi = 1;
 223         if (format_get_field(type, "mf_dev_class", ptr, size))
 224                 id->match_flag_dev_class = 1;
 225         if (format_get_field(type, "mf_dev_subclass", ptr, size))
 226                 id->match_flag_dev_subclass = 1;
 227         if (format_get_field(type, "mf_dev_protocol", ptr, size))
 228                 id->match_flag_dev_protocol = 1;
 229         if (format_get_field(type, "mf_int_class", ptr, size))
 230                 id->match_flag_int_class = 1;
 231         if (format_get_field(type, "mf_int_subclass", ptr, size))
 232                 id->match_flag_int_subclass = 1;
 233         if (format_get_field(type, "mf_int_protocol", ptr, size))
 234                 id->match_flag_int_protocol = 1;
 235
 236         /* compute some internal fields */
 237         id->is_iface = id->match_flag_int_class |
 238             id->match_flag_int_protocol |
 239             id->match_flag_int_subclass;
 240
 241         id->is_dev = id->match_flag_dev_class |
 242             id->match_flag_dev_subclass;
 243
 244         id->is_vp = id->match_flag_vendor |
 245             id->match_flag_product;
 246
 247         id->is_any = id->is_vp + id->is_dev + id->is_iface;
 248 }
 249
 250 static uint32_t
 251 usb_dump(struct usb_device_id *id, uint32_t nid)
 252 {
 253         uint32_t n = 1;
 254
 255         if (id->is_any) {
 256                 printf("nomatch 32 {\n"
 257                     "   match \"bus\" \"uhub[0-9]+\";\n"
 258                     "   match \"mode\" \"%s\";\n", id->module_mode);
 259         } else {
 260                 printf("# skipped entry on module %s\n",
 261                     id->module_name);
 262                 return (n);
 263         }
 264
 265         if (id->match_flag_vendor) {
 266                 printf("        match \"vendor\" \"0x%04x\";\n",
 267                     id->idVendor);
 268         }
 269         if (id->match_flag_product) {
 270                 uint32_t x;
 271
 272                 if (id->is_any == 1 && id->is_vp == 1) {
 273                         /* try to join similar entries */
 274                         while (n < nid) {
 275                                 if (id[n].is_any != 1 || id[n].is_vp != 1)
 276                                         break;
 277                                 if (id[n].idVendor != id[0].idVendor)
 278                                         break;
 279                                 if (strcmp(id[n].module_name, id[0].module_name))
 280                                         break;
 281                                 if (strcmp(id[n].module_mode, id[0].module_mode))
 282                                         break;
 283                                 n++;
 284                         }
 285                 }
 286                 if (n == 1) {
 287                         printf("        match \"product\" \"0x%04x\";\n",
 288                             id->idProduct);
 289                 } else {
 290                         printf("        match \"product\" \"(");
 291
 292                         for (x = 0; x != n; x++) {
 293                                 printf("0x%04x%s", id[x].idProduct,
 294                                     (x == (n - 1)) ? "" : "|");
 295                         }
 296
 297                         printf(")\";\n");
 298                 }
 299         }
 300         if (id->match_flag_dev_class) {
 301                 printf("        match \"devclass\" \"0x%02x\";\n",
 302                     id->bDeviceClass);
 303         }
 304         if (id->match_flag_dev_subclass) {
 305                 printf("        match \"devsubclass\" \"0x%02x\";\n",
 306                     id->bDeviceSubClass);
 307         }
 308         if (id->match_flag_int_class) {
 309                 printf("        match \"intclass\" \"0x%02x\";\n",
 310                     id->bInterfaceClass);
 311         }
 312         if (id->match_flag_int_subclass) {
 313                 printf("        match \"intsubclass\" \"0x%02x\";\n",
 314                     id->bInterfaceSubClass);
 315         }
 316         if (id->match_flag_int_protocol) {
 317                 printf("        match \"intprotocol\" \"0x%02x\";\n",
 318                     id->bInterfaceProtocol);
 319         }
 320         printf("        action \"kldload -n %s\";\n"
 321             "};\n\n", id->module_name);
 322
 323         return (n);
 324 }
 325
 326 void
 327 usb_import_entries(const char *section, const char *module,
 328     const uint8_t *ptr, uint32_t len)
 329 {
 330         struct usb_blob *pub;
 331         uint32_t section_size;
 332         uint32_t off;
 333
 334         section_size = format_get_section_size(section);
 335         if (section_size == 0) {
 336                 errx(EX_DATAERR, "Invalid or non-existing "
 337                     "section format '%s'", section);
 338         }
 339         if (len % section_size) {
 340                 errx(EX_DATAERR, "Length %d is not "
 341                     "divisible by %d. Section format '%s'",
 342                     len, section_size, section);
 343         }
 344         for (off = 0; off != len; off += section_size) {
 345                 pub = malloc(sizeof(*pub));
 346                 if (pub == NULL)
 347                         errx(EX_SOFTWARE, "Out of memory");
 348
 349                 memset(pub, 0, sizeof(*pub));
 350
 351                 usb_import_entry(&pub->temp, section,
 352                     module, ptr + off, section_size);
 353
 354                 TAILQ_INSERT_TAIL(&usb_blob_head, pub, entry);
 355
 356                 usb_blob_count++;
 357                 if (usb_blob_count == 0)
 358                         errx(EX_SOFTWARE, "Too many entries");
 359         }
 360 }
 361
 362 void
 363 usb_dump_entries(void)
 364 {
 365         struct usb_blob *pub;
 366         struct usb_device_id *id;
 367         uint32_t x;
 368
 369         id = malloc(usb_blob_count * sizeof(*id));
 370         if (id == NULL)
 371                 errx(EX_SOFTWARE, "Out of memory");
 372
 373         /* make linear array of all USB blobs */
 374         x = 0;
 375         TAILQ_FOREACH(pub, &usb_blob_head, entry)
 376             id[x++] = pub->temp;
 377
 378         usb_sort_entries(id, usb_blob_count);
 379
 380         for (x = 0; x != usb_blob_count;)
 381                 x += usb_dump(id + x, usb_blob_count - x);
 382
 383         free(id);
 384
 385         printf("# %d USB entries processed\n\n", usb_blob_count);
 386 }