commands/usbtest.c

   1 /* usbtest.c - test module for USB */
   2 /*
   3  *  GRUB  --  GRand Unified Bootloader
   4  *  Copyright (C) 2008  Free Software Foundation, Inc.
   5  *
   6  *  GRUB is free software: you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation, either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  GRUB is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <grub/types.h>
  21 #include <grub/misc.h>
  22 #include <grub/mm.h>
  23 #include <grub/err.h>
  24 #include <grub/dl.h>
  25 #include <grub/usb.h>
  26 #include <grub/command.h>
  27
  28 static const char *usb_classes[] =
  29   {
  30     "",
  31     "Audio",
  32     "Communication Interface",
  33     "HID",
  34     "",
  35     "Physical",
  36     "Image",
  37     "Printer",
  38     "Mass Storage",
  39     "Hub",
  40     "Data Interface",
  41     "Smart Card",
  42     "Content Security",
  43     "Video"
  44   };
  45
  46 static const char *usb_endp_type[] =
  47   {
  48     "Control",
  49     "Isochronous",
  50     "Bulk",
  51     "Interrupt"
  52   };
  53
  54 static const char *usb_devspeed[] =
  55   {
  56     "",
  57     "Low",
  58     "Full",
  59     "High"
  60   };
  61
  62 static void
  63 usb_print_str (const char *description, grub_usb_device_t dev, int idx)
  64 {
  65   char *name;
  66   /* XXX: LANGID  */
  67
  68   if (! idx)
  69     return;
  70
  71   grub_usb_get_string (dev, idx, 0x0409, &name);
  72   grub_printf ("%s: `%s'\n", description, name);
  73   grub_free (name);
  74 }
  75
  76 static int
  77 usb_iterate (grub_usb_device_t dev)
  78 {
  79   struct grub_usb_desc_device *descdev;
  80   int i;
  81
  82   descdev = &dev->descdev;
  83
  84   usb_print_str ("Product", dev, descdev->strprod);
  85   usb_print_str ("Vendor", dev, descdev->strvendor);
  86   usb_print_str ("Serial", dev, descdev->strserial);
  87
  88   if (descdev->class > 0 && descdev->class <= 0x0E)
  89     grub_printf ("Class: (0x%02x) %s, Subclass: 0x%02x, Protocol: 0x%02x\n",
  90                  descdev->class, usb_classes[descdev->class],
  91                  descdev->subclass, descdev->protocol);
  92   grub_printf ("USB version %d.%d, VendorID: 0x%02x, ProductID: 0x%02x, #conf: %d\n",
  93                descdev->usbrel >> 8, (descdev->usbrel >> 4) & 0x0F,
  94                descdev->vendorid, descdev->prodid, descdev->configcnt);
  95
  96   grub_printf ("%s speed device\n", usb_devspeed[dev->speed]);
  97
  98   for (i = 0; i < descdev->configcnt; i++)
  99     {
 100       struct grub_usb_desc_config *config;
 101
 102       config = dev->config[i].descconf;
 103       usb_print_str ("Configuration:", dev, config->strconfig);
 104     }
 105
 106   for (i = 0; i < dev->config[0].descconf->numif; i++)
 107     {
 108       int j;
 109       struct grub_usb_desc_if *interf;
 110       interf = dev->config[0].interf[i].descif;
 111
 112       grub_printf ("Interface #%d: #Endpoints: %d   ",
 113                    i, interf->endpointcnt);
 114       if (interf->class > 0 && interf->class <= 0x0E)
 115         grub_printf ("Class: (0x%02x) %s, Subclass: 0x%02x, Protocol: 0x%02x\n",
 116                      interf->class, usb_classes[interf->class],
 117                      interf->subclass, interf->protocol);
 118
 119       usb_print_str ("Interface", dev, interf->strif);
 120
 121       for (j = 0; j < interf->endpointcnt; j++)
 122         {
 123           struct grub_usb_desc_endp *endp;
 124           endp = &dev->config[0].interf[i].descendp[j];
 125
 126           grub_printf ("Endpoint #%d: %s, max packed size: %d, transfer type: %s, latency: %d\n",
 127                        endp->endp_addr & 15,
 128                        (endp->endp_addr & 128) ? "IN" : "OUT",
 129                        endp->maxpacket, usb_endp_type[endp->attrib & 3],
 130                        endp->interval);
 131         }
 132     }
 133
 134   grub_printf("\n");
 135
 136   return 0;
 137 }
 138
 139 static grub_err_t
 140 grub_cmd_usbtest (grub_command_t cmd __attribute__ ((unused)),
 141                   int argc __attribute__ ((unused)),
 142                   char **args __attribute__ ((unused)))
 143 {
 144   grub_printf ("USB devices:\n\n");
 145   grub_usb_iterate (usb_iterate);
 146
 147   return 0;
 148 }
 149
 150 static grub_command_t cmd;
 151
 152 GRUB_MOD_INIT(usbtest)
 153 {
 154   cmd = grub_register_command ("usb", grub_cmd_usbtest,
 155                                0, "Test USB support");
 156 }
 157
 158 GRUB_MOD_FINI(usbtest)
 159 {
 160   grub_unregister_command (cmd);
 161 }