source: grub-pc/trunk/fuentes/grub-core/commands/usbtest.c @ 22

Last change on this file since 22 was 22, checked in by mabarracus, 4 years ago

updated version and apply net.ifnames=0 into debian/rules

File size: 5.4 KB
Line 
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/charset.h>
23#include <grub/mm.h>
24#include <grub/err.h>
25#include <grub/dl.h>
26#include <grub/usb.h>
27#include <grub/command.h>
28#include <grub/i18n.h>
29
30GRUB_MOD_LICENSE ("GPLv3+");
31
32static const char *usb_classes[] =
33  {
34    "Unknown",
35    "Audio",
36    "Communication Interface",
37    "HID",
38    "Unknown",
39    "Physical",
40    "Image",
41    "Printer",
42    "Mass Storage",
43    "Hub",
44    "Data Interface",
45    "Smart Card",
46    "Content Security",
47    "Video"
48  };
49
50static const char *usb_endp_type[] =
51  {
52    "Control",
53    "Isochronous",
54    "Bulk",
55    "Interrupt"
56  };
57
58static const char *usb_devspeed[] =
59  {
60    "",
61    "Low",
62    "Full",
63    "High"
64  };
65
66static grub_usb_err_t
67grub_usb_get_string (grub_usb_device_t dev, grub_uint8_t index, int langid,
68                     char **string)
69{
70  struct grub_usb_desc_str descstr;
71  struct grub_usb_desc_str *descstrp;
72  grub_usb_err_t err;
73
74  /* Only get the length.  */
75  err = grub_usb_control_msg (dev, 1 << 7,
76                              0x06, (3 << 8) | index,
77                              langid, 1, (char *) &descstr);
78  if (err)
79    return err;
80
81  descstrp = grub_malloc (descstr.length);
82  if (! descstrp)
83    return GRUB_USB_ERR_INTERNAL;
84  err = grub_usb_control_msg (dev, 1 << 7,
85                              0x06, (3 << 8) | index,
86                              langid, descstr.length, (char *) descstrp);
87
88  if (descstrp->length == 0)
89    {
90      grub_free (descstrp);
91      *string = grub_strdup ("");
92      if (! *string)
93        return GRUB_USB_ERR_INTERNAL;
94      return GRUB_USB_ERR_NONE;
95    }
96
97  *string = grub_malloc (descstr.length * 2 + 1);
98  if (! *string)
99    {
100      grub_free (descstrp);
101      return GRUB_USB_ERR_INTERNAL;
102    }
103
104  *grub_utf16_to_utf8 ((grub_uint8_t *) *string, descstrp->str,
105                       descstrp->length / 2 - 1) = 0;
106  grub_free (descstrp);
107
108  return GRUB_USB_ERR_NONE;
109}
110
111static void
112usb_print_str (const char *description, grub_usb_device_t dev, int idx)
113{
114  char *name = NULL;
115  grub_usb_err_t err;
116  /* XXX: LANGID  */
117
118  if (! idx)
119    return;
120
121  err = grub_usb_get_string (dev, idx, 0x0409, &name);
122  if (err)
123    grub_printf ("Error %d retrieving %s\n", err, description);
124  else
125    {
126      grub_printf ("%s: `%s'\n", description, name);
127      grub_free (name);
128    }
129}
130
131static int
132usb_iterate (grub_usb_device_t dev, void *data __attribute__ ((unused)))
133{
134  struct grub_usb_desc_device *descdev;
135  int i;
136
137  descdev = &dev->descdev;
138
139  usb_print_str ("Product", dev, descdev->strprod);
140  usb_print_str ("Vendor", dev, descdev->strvendor);
141  usb_print_str ("Serial", dev, descdev->strserial);
142
143  grub_printf ("Class: (0x%02x) %s, Subclass: 0x%02x, Protocol: 0x%02x\n",
144               descdev->class, descdev->class < ARRAY_SIZE (usb_classes)
145               ? usb_classes[descdev->class] : "Unknown",
146               descdev->subclass, descdev->protocol);
147  grub_printf ("USB version %d.%d, VendorID: 0x%02x, ProductID: 0x%02x, #conf: %d\n",
148               descdev->usbrel >> 8, (descdev->usbrel >> 4) & 0x0F,
149               descdev->vendorid, descdev->prodid, descdev->configcnt);
150
151  grub_printf ("%s speed device\n", usb_devspeed[dev->speed]);
152
153  for (i = 0; i < descdev->configcnt; i++)
154    {
155      struct grub_usb_desc_config *config;
156
157      config = dev->config[i].descconf;
158      usb_print_str ("Configuration:", dev, config->strconfig);
159    }
160
161  for (i = 0; i < dev->config[0].descconf->numif; i++)
162    {
163      int j;
164      struct grub_usb_desc_if *interf;
165      interf = dev->config[0].interf[i].descif;
166
167      grub_printf ("Interface #%d: #Endpoints: %d   ",
168                   i, interf->endpointcnt);
169      grub_printf ("Class: (0x%02x) %s, Subclass: 0x%02x, Protocol: 0x%02x\n",
170                   interf->class, interf->class < ARRAY_SIZE (usb_classes)
171                   ? usb_classes[interf->class] : "Unknown",
172                   interf->subclass, interf->protocol);
173
174      usb_print_str ("Interface", dev, interf->strif);
175
176      for (j = 0; j < interf->endpointcnt; j++)
177        {
178          struct grub_usb_desc_endp *endp;
179          endp = &dev->config[0].interf[i].descendp[j];
180
181          grub_printf ("Endpoint #%d: %s, max packed size: %d, transfer type: %s, latency: %d\n",
182                       endp->endp_addr & 15,
183                       (endp->endp_addr & 128) ? "IN" : "OUT",
184                       endp->maxpacket, usb_endp_type[endp->attrib & 3],
185                       endp->interval);
186        }
187    }
188
189  grub_printf("\n");
190
191  return 0;
192}
193
194static grub_err_t
195grub_cmd_usbtest (grub_command_t cmd __attribute__ ((unused)),
196                  int argc __attribute__ ((unused)),
197                  char **args __attribute__ ((unused)))
198{
199  grub_usb_poll_devices (1);
200
201  grub_printf ("USB devices:\n\n");
202  grub_usb_iterate (usb_iterate, NULL);
203
204  return 0;
205}
206
207static grub_command_t cmd;
208
209GRUB_MOD_INIT(usbtest)
210{
211  cmd = grub_register_command ("usb", grub_cmd_usbtest,
212                               0, N_("Test USB support."));
213}
214
215GRUB_MOD_FINI(usbtest)
216{
217  grub_unregister_command (cmd);
218}
Note: See TracBrowser for help on using the repository browser.