2 * Linux host USB redirector
4 * Copyright (c) 2005 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 #if defined(__linux__)
28 #include <sys/ioctl.h>
29 /* Some versions of usbdevice_fs.h need __user to be defined for them. */
30 /* This may (harmlessly) conflict with a definition in linux/compiler.h. */
32 #include <linux/usbdevice_fs.h>
33 #include <linux/version.h>
35 /* We redefine it to avoid version problems */
36 struct usb_ctrltransfer
{
46 typedef int USBScanFunc(void *opaque
, int bus_num
, int addr
, int class_id
,
47 int vendor_id
, int product_id
,
48 const char *product_name
, int speed
);
49 static int usb_host_find_device(int *pbus_num
, int *paddr
,
50 char *product_name
, int product_name_size
,
55 #define USBDEVFS_PATH "/proc/bus/usb"
56 #define PRODUCT_NAME_SZ 32
58 typedef struct USBHostDevice
{
63 static void usb_host_handle_reset(USBDevice
*dev
)
66 USBHostDevice
*s
= (USBHostDevice
*)dev
;
67 /* USBDEVFS_RESET, but not the first time as it has already be
68 done by the host OS */
69 ioctl(s
->fd
, USBDEVFS_RESET
);
73 static void usb_host_handle_destroy(USBDevice
*dev
)
75 USBHostDevice
*s
= (USBHostDevice
*)dev
;
82 static int usb_host_handle_control(USBDevice
*dev
,
89 USBHostDevice
*s
= (USBHostDevice
*)dev
;
90 struct usb_ctrltransfer ct
;
93 if (request
== (DeviceOutRequest
| USB_REQ_SET_ADDRESS
)) {
94 /* specific SET_ADDRESS support */
98 ct
.bRequestType
= request
>> 8;
99 ct
.bRequest
= request
;
105 ret
= ioctl(s
->fd
, USBDEVFS_CONTROL
, &ct
);
111 return USB_RET_STALL
;
119 static int usb_host_handle_data(USBDevice
*dev
, int pid
,
121 uint8_t *data
, int len
)
123 USBHostDevice
*s
= (USBHostDevice
*)dev
;
124 struct usbdevfs_bulktransfer bt
;
127 /* XXX: optimize and handle all data types by looking at the
129 if (pid
== USB_TOKEN_IN
)
135 ret
= ioctl(s
->fd
, USBDEVFS_BULK
, &bt
);
143 printf("handle_data: errno=%d\n", errno
);
145 return USB_RET_STALL
;
152 /* XXX: exclude high speed devices or implement EHCI */
153 USBDevice
*usb_host_device_open(const char *devname
)
155 int fd
, interface
, ret
, i
;
157 struct usbdevfs_connectinfo ci
;
160 int descr_len
, dev_descr_len
, config_descr_len
, nb_interfaces
;
162 char product_name
[PRODUCT_NAME_SZ
];
164 if (usb_host_find_device(&bus_num
, &addr
,
165 product_name
, sizeof(product_name
),
169 snprintf(buf
, sizeof(buf
), USBDEVFS_PATH
"/%03d/%03d",
171 fd
= open(buf
, O_RDWR
);
177 /* read the config description */
178 descr_len
= read(fd
, descr
, sizeof(descr
));
179 if (descr_len
<= 0) {
180 perror("read descr");
185 dev_descr_len
= descr
[0];
186 if (dev_descr_len
> descr_len
)
189 config_descr_len
= descr
[i
];
190 if (i
+ config_descr_len
> descr_len
)
192 nb_interfaces
= descr
[i
+ 4];
193 if (nb_interfaces
!= 1) {
194 /* NOTE: currently we grab only one interface */
195 fprintf(stderr
, "usb_host: only one interface supported\n");
199 #ifdef USBDEVFS_DISCONNECT
200 /* earlier Linux 2.4 do not support that */
202 struct usbdevfs_ioctl ctrl
;
203 ctrl
.ioctl_code
= USBDEVFS_DISCONNECT
;
205 ret
= ioctl(fd
, USBDEVFS_IOCTL
, &ctrl
);
206 if (ret
< 0 && errno
!= ENODATA
) {
207 perror("USBDEVFS_DISCONNECT");
213 /* XXX: only grab if all interfaces are free */
215 ret
= ioctl(fd
, USBDEVFS_CLAIMINTERFACE
, &interface
);
217 if (errno
== EBUSY
) {
218 fprintf(stderr
, "usb_host: device already grabbed\n");
220 perror("USBDEVFS_CLAIMINTERFACE");
227 ret
= ioctl(fd
, USBDEVFS_CONNECTINFO
, &ci
);
229 perror("USBDEVFS_CONNECTINFO");
234 printf("host USB device %d.%d grabbed\n", bus_num
, addr
);
237 dev
= qemu_mallocz(sizeof(USBHostDevice
));
242 dev
->dev
.speed
= USB_SPEED_LOW
;
244 dev
->dev
.speed
= USB_SPEED_HIGH
;
245 dev
->dev
.handle_packet
= usb_generic_handle_packet
;
247 dev
->dev
.handle_reset
= usb_host_handle_reset
;
248 dev
->dev
.handle_control
= usb_host_handle_control
;
249 dev
->dev
.handle_data
= usb_host_handle_data
;
250 dev
->dev
.handle_destroy
= usb_host_handle_destroy
;
252 if (product_name
[0] == '\0')
253 snprintf(dev
->dev
.devname
, sizeof(dev
->dev
.devname
),
256 pstrcpy(dev
->dev
.devname
, sizeof(dev
->dev
.devname
),
259 return (USBDevice
*)dev
;
262 static int get_tag_value(char *buf
, int buf_size
,
263 const char *str
, const char *tag
,
264 const char *stopchars
)
268 p
= strstr(str
, tag
);
275 while (*p
!= '\0' && !strchr(stopchars
, *p
)) {
276 if ((q
- buf
) < (buf_size
- 1))
284 static int usb_host_scan(void *opaque
, USBScanFunc
*func
)
289 int bus_num
, addr
, speed
, device_count
, class_id
, product_id
, vendor_id
;
291 char product_name
[512];
293 f
= fopen(USBDEVFS_PATH
"/devices", "r");
295 term_printf("Could not open %s\n", USBDEVFS_PATH
"/devices");
299 bus_num
= addr
= speed
= class_id
= product_id
= vendor_id
= 0;
302 if (fgets(line
, sizeof(line
), f
) == NULL
)
304 if (strlen(line
) > 0)
305 line
[strlen(line
) - 1] = '\0';
306 if (line
[0] == 'T' && line
[1] == ':') {
307 if (device_count
&& (vendor_id
|| product_id
)) {
308 /* New device. Add the previously discovered device. */
309 ret
= func(opaque
, bus_num
, addr
, class_id
, vendor_id
,
310 product_id
, product_name
, speed
);
314 if (get_tag_value(buf
, sizeof(buf
), line
, "Bus=", " ") < 0)
317 if (get_tag_value(buf
, sizeof(buf
), line
, "Dev#=", " ") < 0)
320 if (get_tag_value(buf
, sizeof(buf
), line
, "Spd=", " ") < 0)
322 if (!strcmp(buf
, "480"))
323 speed
= USB_SPEED_HIGH
;
324 else if (!strcmp(buf
, "1.5"))
325 speed
= USB_SPEED_LOW
;
327 speed
= USB_SPEED_FULL
;
328 product_name
[0] = '\0';
333 } else if (line
[0] == 'P' && line
[1] == ':') {
334 if (get_tag_value(buf
, sizeof(buf
), line
, "Vendor=", " ") < 0)
336 vendor_id
= strtoul(buf
, NULL
, 16);
337 if (get_tag_value(buf
, sizeof(buf
), line
, "ProdID=", " ") < 0)
339 product_id
= strtoul(buf
, NULL
, 16);
340 } else if (line
[0] == 'S' && line
[1] == ':') {
341 if (get_tag_value(buf
, sizeof(buf
), line
, "Product=", "") < 0)
343 pstrcpy(product_name
, sizeof(product_name
), buf
);
344 } else if (line
[0] == 'D' && line
[1] == ':') {
345 if (get_tag_value(buf
, sizeof(buf
), line
, "Cls=", " (") < 0)
347 class_id
= strtoul(buf
, NULL
, 16);
351 if (device_count
&& (vendor_id
|| product_id
)) {
352 /* Add the last device. */
353 ret
= func(opaque
, bus_num
, addr
, class_id
, vendor_id
,
354 product_id
, product_name
, speed
);
361 typedef struct FindDeviceState
{
366 char product_name
[PRODUCT_NAME_SZ
];
369 static int usb_host_find_device_scan(void *opaque
, int bus_num
, int addr
,
371 int vendor_id
, int product_id
,
372 const char *product_name
, int speed
)
374 FindDeviceState
*s
= opaque
;
375 if ((vendor_id
== s
->vendor_id
&&
376 product_id
== s
->product_id
) ||
377 (bus_num
== s
->bus_num
&&
379 pstrcpy(s
->product_name
, PRODUCT_NAME_SZ
, product_name
);
380 s
->bus_num
= bus_num
;
389 'bus.addr' (decimal numbers) or
390 'vendor_id:product_id' (hexa numbers) */
391 static int usb_host_find_device(int *pbus_num
, int *paddr
,
392 char *product_name
, int product_name_size
,
399 p
= strchr(devname
, '.');
401 *pbus_num
= strtoul(devname
, NULL
, 0);
402 *paddr
= strtoul(p
+ 1, NULL
, 0);
403 fs
.bus_num
= *pbus_num
;
405 ret
= usb_host_scan(&fs
, usb_host_find_device_scan
);
407 pstrcpy(product_name
, product_name_size
, fs
.product_name
);
410 p
= strchr(devname
, ':');
412 fs
.vendor_id
= strtoul(devname
, NULL
, 16);
413 fs
.product_id
= strtoul(p
+ 1, NULL
, 16);
414 ret
= usb_host_scan(&fs
, usb_host_find_device_scan
);
416 *pbus_num
= fs
.bus_num
;
418 pstrcpy(product_name
, product_name_size
, fs
.product_name
);
425 /**********************/
426 /* USB host device info */
428 struct usb_class_info
{
430 const char *class_name
;
433 static const struct usb_class_info usb_class_info
[] = {
434 { USB_CLASS_AUDIO
, "Audio"},
435 { USB_CLASS_COMM
, "Communication"},
436 { USB_CLASS_HID
, "HID"},
437 { USB_CLASS_HUB
, "Hub" },
438 { USB_CLASS_PHYSICAL
, "Physical" },
439 { USB_CLASS_PRINTER
, "Printer" },
440 { USB_CLASS_MASS_STORAGE
, "Storage" },
441 { USB_CLASS_CDC_DATA
, "Data" },
442 { USB_CLASS_APP_SPEC
, "Application Specific" },
443 { USB_CLASS_VENDOR_SPEC
, "Vendor Specific" },
444 { USB_CLASS_STILL_IMAGE
, "Still Image" },
445 { USB_CLASS_CSCID
, "Smart Card" },
446 { USB_CLASS_CONTENT_SEC
, "Content Security" },
450 static const char *usb_class_str(uint8_t class)
452 const struct usb_class_info
*p
;
453 for(p
= usb_class_info
; p
->class != -1; p
++) {
454 if (p
->class == class)
457 return p
->class_name
;
460 void usb_info_device(int bus_num
, int addr
, int class_id
,
461 int vendor_id
, int product_id
,
462 const char *product_name
,
465 const char *class_str
, *speed_str
;
482 term_printf(" Device %d.%d, speed %s Mb/s\n",
483 bus_num
, addr
, speed_str
);
484 class_str
= usb_class_str(class_id
);
486 term_printf(" %s:", class_str
);
488 term_printf(" Class %02x:", class_id
);
489 term_printf(" USB device %04x:%04x", vendor_id
, product_id
);
490 if (product_name
[0] != '\0')
491 term_printf(", %s", product_name
);
495 static int usb_host_info_device(void *opaque
, int bus_num
, int addr
,
497 int vendor_id
, int product_id
,
498 const char *product_name
,
501 usb_info_device(bus_num
, addr
, class_id
, vendor_id
, product_id
,
502 product_name
, speed
);
506 void usb_host_info(void)
508 usb_host_scan(NULL
, usb_host_info_device
);
513 void usb_host_info(void)
515 term_printf("USB host devices not supported\n");
518 /* XXX: modify configure to compile the right host driver */
519 USBDevice
*usb_host_device_open(const char *devname
)