File:  [Qemu by Fabrice Bellard] / qemu / usb-linux.c
Revision 1.1.1.6 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 16:50:33 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0105, qemu0104, qemu0103, qemu0102, qemu0101, qemu0100, HEAD
qemu 0.10.0

    1: /*
    2:  * Linux host USB redirector
    3:  *
    4:  * Copyright (c) 2005 Fabrice Bellard
    5:  *
    6:  * Copyright (c) 2008 Max Krasnyansky
    7:  *      Support for host device auto connect & disconnect
    8:  *      Major rewrite to support fully async operation
    9:  *
   10:  * Copyright 2008 TJ <linux@tjworld.net>
   11:  *      Added flexible support for /dev/bus/usb /sys/bus/usb/devices in addition
   12:  *      to the legacy /proc/bus/usb USB device discovery and handling
   13:  *
   14:  * Permission is hereby granted, free of charge, to any person obtaining a copy
   15:  * of this software and associated documentation files (the "Software"), to deal
   16:  * in the Software without restriction, including without limitation the rights
   17:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   18:  * copies of the Software, and to permit persons to whom the Software is
   19:  * furnished to do so, subject to the following conditions:
   20:  *
   21:  * The above copyright notice and this permission notice shall be included in
   22:  * all copies or substantial portions of the Software.
   23:  *
   24:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   25:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   26:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
   27:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   28:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   29:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   30:  * THE SOFTWARE.
   31:  */
   32: 
   33: #include "qemu-common.h"
   34: #include "qemu-timer.h"
   35: #include "console.h"
   36: 
   37: #include <dirent.h>
   38: #include <sys/ioctl.h>
   39: #include <signal.h>
   40: 
   41: #include <linux/usbdevice_fs.h>
   42: #include <linux/version.h>
   43: #include "hw/usb.h"
   44: 
   45: /* We redefine it to avoid version problems */
   46: struct usb_ctrltransfer {
   47:     uint8_t  bRequestType;
   48:     uint8_t  bRequest;
   49:     uint16_t wValue;
   50:     uint16_t wIndex;
   51:     uint16_t wLength;
   52:     uint32_t timeout;
   53:     void *data;
   54: };
   55: 
   56: struct usb_ctrlrequest {
   57:     uint8_t bRequestType;
   58:     uint8_t bRequest;
   59:     uint16_t wValue;
   60:     uint16_t wIndex;
   61:     uint16_t wLength;
   62: };
   63: 
   64: typedef int USBScanFunc(void *opaque, int bus_num, int addr, int class_id,
   65:                         int vendor_id, int product_id,
   66:                         const char *product_name, int speed);
   67: static int usb_host_find_device(int *pbus_num, int *paddr,
   68:                                 char *product_name, int product_name_size,
   69:                                 const char *devname);
   70: //#define DEBUG
   71: 
   72: #ifdef DEBUG
   73: #define dprintf printf
   74: #else
   75: #define dprintf(...)
   76: #endif
   77: 
   78: #define USBDBG_DEVOPENED "husb: opened %s/devices\n"
   79: 
   80: #define USBPROCBUS_PATH "/proc/bus/usb"
   81: #define PRODUCT_NAME_SZ 32
   82: #define MAX_ENDPOINTS 16
   83: #define USBDEVBUS_PATH "/dev/bus/usb"
   84: #define USBSYSBUS_PATH "/sys/bus/usb"
   85: 
   86: static char *usb_host_device_path;
   87: 
   88: #define USB_FS_NONE 0
   89: #define USB_FS_PROC 1
   90: #define USB_FS_DEV 2
   91: #define USB_FS_SYS 3
   92: 
   93: static int usb_fs_type;
   94: 
   95: /* endpoint association data */
   96: struct endp_data {
   97:     uint8_t type;
   98:     uint8_t halted;
   99: };
  100: 
  101: enum {
  102:     CTRL_STATE_IDLE = 0,
  103:     CTRL_STATE_SETUP,
  104:     CTRL_STATE_DATA,
  105:     CTRL_STATE_ACK
  106: };
  107: 
  108: /*
  109:  * Control transfer state.
  110:  * Note that 'buffer' _must_ follow 'req' field because 
  111:  * we need contigious buffer when we submit control URB.
  112:  */ 
  113: struct ctrl_struct {
  114:     uint16_t len;
  115:     uint16_t offset;
  116:     uint8_t  state;
  117:     struct   usb_ctrlrequest req;
  118:     uint8_t  buffer[1024];
  119: };
  120: 
  121: typedef struct USBHostDevice {
  122:     USBDevice dev;
  123:     int       fd;
  124: 
  125:     uint8_t   descr[1024];
  126:     int       descr_len;
  127:     int       configuration;
  128:     int       ninterfaces;
  129:     int       closing;
  130: 
  131:     struct ctrl_struct ctrl;
  132:     struct endp_data endp_table[MAX_ENDPOINTS];
  133: 
  134:     /* Host side address */
  135:     int bus_num;
  136:     int addr;
  137: 
  138:     struct USBHostDevice *next;
  139: } USBHostDevice;
  140: 
  141: static int is_isoc(USBHostDevice *s, int ep)
  142: {
  143:     return s->endp_table[ep - 1].type == USBDEVFS_URB_TYPE_ISO;
  144: }
  145: 
  146: static int is_halted(USBHostDevice *s, int ep)
  147: {
  148:     return s->endp_table[ep - 1].halted;
  149: }
  150: 
  151: static void clear_halt(USBHostDevice *s, int ep)
  152: {
  153:     s->endp_table[ep - 1].halted = 0;
  154: }
  155: 
  156: static void set_halt(USBHostDevice *s, int ep)
  157: {
  158:     s->endp_table[ep - 1].halted = 1;
  159: }
  160: 
  161: static USBHostDevice *hostdev_list;
  162: 
  163: static void hostdev_link(USBHostDevice *dev)
  164: {
  165:     dev->next = hostdev_list;
  166:     hostdev_list = dev;
  167: }
  168: 
  169: static void hostdev_unlink(USBHostDevice *dev)
  170: {
  171:     USBHostDevice *pdev = hostdev_list;
  172:     USBHostDevice **prev = &hostdev_list;
  173: 
  174:     while (pdev) {
  175: 	if (pdev == dev) {
  176:             *prev = dev->next;
  177:             return;
  178:         }
  179: 
  180:         prev = &pdev->next;
  181:         pdev = pdev->next;
  182:     }
  183: }
  184: 
  185: static USBHostDevice *hostdev_find(int bus_num, int addr)
  186: {
  187:     USBHostDevice *s = hostdev_list;
  188:     while (s) {
  189:         if (s->bus_num == bus_num && s->addr == addr)
  190:             return s;
  191:         s = s->next;
  192:     }
  193:     return NULL;
  194: }
  195: 
  196: /* 
  197:  * Async URB state.
  198:  * We always allocate one isoc descriptor even for bulk transfers
  199:  * to simplify allocation and casts. 
  200:  */
  201: typedef struct AsyncURB
  202: {
  203:     struct usbdevfs_urb urb;
  204:     struct usbdevfs_iso_packet_desc isocpd;
  205: 
  206:     USBPacket     *packet;
  207:     USBHostDevice *hdev;
  208: } AsyncURB;
  209: 
  210: static AsyncURB *async_alloc(void)
  211: {
  212:     return (AsyncURB *) qemu_mallocz(sizeof(AsyncURB));
  213: }
  214: 
  215: static void async_free(AsyncURB *aurb)
  216: {
  217:     qemu_free(aurb);
  218: }
  219: 
  220: static void async_complete_ctrl(USBHostDevice *s, USBPacket *p)
  221: {
  222:     switch(s->ctrl.state) {
  223:     case CTRL_STATE_SETUP:
  224:         if (p->len < s->ctrl.len)
  225:             s->ctrl.len = p->len;
  226:         s->ctrl.state = CTRL_STATE_DATA;
  227:         p->len = 8;
  228:         break;
  229: 
  230:     case CTRL_STATE_ACK:
  231:         s->ctrl.state = CTRL_STATE_IDLE;
  232:         p->len = 0;
  233:         break;
  234: 
  235:     default:
  236:         break;
  237:     }
  238: }
  239: 
  240: static void async_complete(void *opaque)
  241: {
  242:     USBHostDevice *s = opaque;
  243:     AsyncURB *aurb;
  244: 
  245:     while (1) {
  246:     	USBPacket *p;
  247: 
  248: 	int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb);
  249:         if (r < 0) {
  250:             if (errno == EAGAIN)
  251:                 return;
  252: 
  253:             if (errno == ENODEV && !s->closing) {
  254:                 printf("husb: device %d.%d disconnected\n", s->bus_num, s->addr);
  255: 	        usb_device_del_addr(0, s->dev.addr);
  256:                 return;
  257:             }
  258: 
  259:             dprintf("husb: async. reap urb failed errno %d\n", errno);
  260:             return;
  261:         }
  262: 
  263:         p = aurb->packet;
  264: 
  265: 	dprintf("husb: async completed. aurb %p status %d alen %d\n", 
  266:                 aurb, aurb->urb.status, aurb->urb.actual_length);
  267: 
  268: 	if (p) {
  269:             switch (aurb->urb.status) {
  270:             case 0:
  271:                 p->len = aurb->urb.actual_length;
  272:                 if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL)
  273:                     async_complete_ctrl(s, p);
  274:                 break;
  275: 
  276:             case -EPIPE:
  277:                 set_halt(s, p->devep);
  278:                 /* fall through */
  279:             default:
  280:                 p->len = USB_RET_NAK;
  281:                 break;
  282:             }
  283: 
  284:             usb_packet_complete(p);
  285: 	}
  286: 
  287:         async_free(aurb);
  288:     }
  289: }
  290: 
  291: static void async_cancel(USBPacket *unused, void *opaque)
  292: {
  293:     AsyncURB *aurb = opaque;
  294:     USBHostDevice *s = aurb->hdev;
  295: 
  296:     dprintf("husb: async cancel. aurb %p\n", aurb);
  297: 
  298:     /* Mark it as dead (see async_complete above) */
  299:     aurb->packet = NULL;
  300: 
  301:     int r = ioctl(s->fd, USBDEVFS_DISCARDURB, aurb);
  302:     if (r < 0) {
  303:         dprintf("husb: async. discard urb failed errno %d\n", errno);
  304:     }
  305: }
  306: 
  307: static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
  308: {
  309:     int dev_descr_len, config_descr_len;
  310:     int interface, nb_interfaces, nb_configurations;
  311:     int ret, i;
  312: 
  313:     if (configuration == 0) /* address state - ignore */
  314:         return 1;
  315: 
  316:     dprintf("husb: claiming interfaces. config %d\n", configuration);
  317: 
  318:     i = 0;
  319:     dev_descr_len = dev->descr[0];
  320:     if (dev_descr_len > dev->descr_len)
  321:         goto fail;
  322:     nb_configurations = dev->descr[17];
  323: 
  324:     i += dev_descr_len;
  325:     while (i < dev->descr_len) {
  326:         dprintf("husb: i is %d, descr_len is %d, dl %d, dt %d\n", i, dev->descr_len,
  327:                dev->descr[i], dev->descr[i+1]);
  328: 
  329:         if (dev->descr[i+1] != USB_DT_CONFIG) {
  330:             i += dev->descr[i];
  331:             continue;
  332:         }
  333:         config_descr_len = dev->descr[i];
  334: 
  335: 	printf("husb: config #%d need %d\n", dev->descr[i + 5], configuration); 
  336: 
  337:         if (configuration < 0 || configuration == dev->descr[i + 5]) {
  338:             configuration = dev->descr[i + 5];
  339:             break;
  340:         }
  341: 
  342:         i += config_descr_len;
  343:     }
  344: 
  345:     if (i >= dev->descr_len) {
  346:         fprintf(stderr, "husb: update iface failed. no matching configuration\n");
  347:         goto fail;
  348:     }
  349:     nb_interfaces = dev->descr[i + 4];
  350: 
  351: #ifdef USBDEVFS_DISCONNECT
  352:     /* earlier Linux 2.4 do not support that */
  353:     {
  354:         struct usbdevfs_ioctl ctrl;
  355:         for (interface = 0; interface < nb_interfaces; interface++) {
  356:             ctrl.ioctl_code = USBDEVFS_DISCONNECT;
  357:             ctrl.ifno = interface;
  358:             ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
  359:             if (ret < 0 && errno != ENODATA) {
  360:                 perror("USBDEVFS_DISCONNECT");
  361:                 goto fail;
  362:             }
  363:         }
  364:     }
  365: #endif
  366: 
  367:     /* XXX: only grab if all interfaces are free */
  368:     for (interface = 0; interface < nb_interfaces; interface++) {
  369:         ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
  370:         if (ret < 0) {
  371:             if (errno == EBUSY) {
  372:                 printf("husb: update iface. device already grabbed\n");
  373:             } else {
  374:                 perror("husb: failed to claim interface");
  375:             }
  376:         fail:
  377:             return 0;
  378:         }
  379:     }
  380: 
  381:     printf("husb: %d interfaces claimed for configuration %d\n",
  382:            nb_interfaces, configuration);
  383: 
  384:     dev->ninterfaces   = nb_interfaces;
  385:     dev->configuration = configuration;
  386:     return 1;
  387: }
  388: 
  389: static int usb_host_release_interfaces(USBHostDevice *s)
  390: {
  391:     int ret, i;
  392: 
  393:     dprintf("husb: releasing interfaces\n");
  394: 
  395:     for (i = 0; i < s->ninterfaces; i++) {
  396:         ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
  397:         if (ret < 0) {
  398:             perror("husb: failed to release interface");
  399:             return 0;
  400:         }
  401:     }
  402: 
  403:     return 1;
  404: }
  405: 
  406: static void usb_host_handle_reset(USBDevice *dev)
  407: {
  408:     USBHostDevice *s = (USBHostDevice *) dev;
  409: 
  410:     dprintf("husb: reset device %u.%u\n", s->bus_num, s->addr);
  411: 
  412:     ioctl(s->fd, USBDEVFS_RESET);
  413: 
  414:     usb_host_claim_interfaces(s, s->configuration);
  415: }
  416: 
  417: static void usb_host_handle_destroy(USBDevice *dev)
  418: {
  419:     USBHostDevice *s = (USBHostDevice *)dev;
  420: 
  421:     s->closing = 1;
  422: 
  423:     qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
  424: 
  425:     hostdev_unlink(s);
  426: 
  427:     async_complete(s);
  428: 
  429:     if (s->fd >= 0)
  430:         close(s->fd);
  431: 
  432:     qemu_free(s);
  433: }
  434: 
  435: static int usb_linux_update_endp_table(USBHostDevice *s);
  436: 
  437: static int usb_host_handle_data(USBHostDevice *s, USBPacket *p)
  438: {
  439:     struct usbdevfs_urb *urb;
  440:     AsyncURB *aurb;
  441:     int ret;
  442: 
  443:     aurb = async_alloc();
  444:     aurb->hdev   = s;
  445:     aurb->packet = p;
  446: 
  447:     urb = &aurb->urb;
  448: 
  449:     if (p->pid == USB_TOKEN_IN)
  450:     	urb->endpoint = p->devep | 0x80;
  451:     else
  452:     	urb->endpoint = p->devep;
  453: 
  454:     if (is_halted(s, p->devep)) {
  455: 	ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &urb->endpoint);
  456:         if (ret < 0) {
  457:             dprintf("husb: failed to clear halt. ep 0x%x errno %d\n", 
  458:                    urb->endpoint, errno);
  459:             return USB_RET_NAK;
  460:         }
  461:         clear_halt(s, p->devep);
  462:     }
  463: 
  464:     urb->buffer        = p->data;
  465:     urb->buffer_length = p->len;
  466: 
  467:     if (is_isoc(s, p->devep)) {
  468:         /* Setup ISOC transfer */
  469:         urb->type     = USBDEVFS_URB_TYPE_ISO;
  470:         urb->flags    = USBDEVFS_URB_ISO_ASAP;
  471:         urb->number_of_packets = 1;
  472:         urb->iso_frame_desc[0].length = p->len;
  473:     } else {
  474:         /* Setup bulk transfer */
  475:         urb->type     = USBDEVFS_URB_TYPE_BULK;
  476:     }
  477: 
  478:     urb->usercontext = s;
  479: 
  480:     ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
  481: 
  482:     dprintf("husb: data submit. ep 0x%x len %u aurb %p\n", urb->endpoint, p->len, aurb);
  483: 
  484:     if (ret < 0) {
  485:         dprintf("husb: submit failed. errno %d\n", errno);
  486:         async_free(aurb);
  487: 
  488:         switch(errno) {
  489:         case ETIMEDOUT:
  490:             return USB_RET_NAK;
  491:         case EPIPE:
  492:         default:
  493:             return USB_RET_STALL;
  494:         }
  495:     }
  496: 
  497:     usb_defer_packet(p, async_cancel, aurb);
  498:     return USB_RET_ASYNC;
  499: }
  500: 
  501: static int ctrl_error(void)
  502: {
  503:     if (errno == ETIMEDOUT)
  504:         return USB_RET_NAK;
  505:     else 
  506:         return USB_RET_STALL;
  507: }
  508: 
  509: static int usb_host_set_address(USBHostDevice *s, int addr)
  510: {
  511:     dprintf("husb: ctrl set addr %u\n", addr);
  512:     s->dev.addr = addr;
  513:     return 0;
  514: }
  515: 
  516: static int usb_host_set_config(USBHostDevice *s, int config)
  517: {
  518:     usb_host_release_interfaces(s);
  519: 
  520:     int ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
  521:  
  522:     dprintf("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
  523:     
  524:     if (ret < 0)
  525:         return ctrl_error();
  526:  
  527:     usb_host_claim_interfaces(s, config);
  528:     return 0;
  529: }
  530: 
  531: static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
  532: {
  533:     struct usbdevfs_setinterface si;
  534:     int ret;
  535: 
  536:     si.interface  = iface;
  537:     si.altsetting = alt;
  538:     ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
  539:     
  540:     dprintf("husb: ctrl set iface %d altset %d ret %d errno %d\n", 
  541:     	iface, alt, ret, errno);
  542:     
  543:     if (ret < 0)
  544:         return ctrl_error();
  545: 
  546:     usb_linux_update_endp_table(s);
  547:     return 0;
  548: }
  549: 
  550: static int usb_host_handle_control(USBHostDevice *s, USBPacket *p)
  551: {
  552:     struct usbdevfs_urb *urb;
  553:     AsyncURB *aurb;
  554:     int ret, value, index;
  555: 
  556:     /* 
  557:      * Process certain standard device requests.
  558:      * These are infrequent and are processed synchronously.
  559:      */
  560:     value = le16_to_cpu(s->ctrl.req.wValue);
  561:     index = le16_to_cpu(s->ctrl.req.wIndex);
  562: 
  563:     dprintf("husb: ctrl type 0x%x req 0x%x val 0x%x index %u len %u\n",
  564:         s->ctrl.req.bRequestType, s->ctrl.req.bRequest, value, index, 
  565:         s->ctrl.len);
  566: 
  567:     if (s->ctrl.req.bRequestType == 0) {
  568:         switch (s->ctrl.req.bRequest) {
  569:         case USB_REQ_SET_ADDRESS:
  570:             return usb_host_set_address(s, value);
  571: 
  572:         case USB_REQ_SET_CONFIGURATION:
  573:             return usb_host_set_config(s, value & 0xff);
  574:         }
  575:     }
  576: 
  577:     if (s->ctrl.req.bRequestType == 1 &&
  578:                   s->ctrl.req.bRequest == USB_REQ_SET_INTERFACE)
  579:         return usb_host_set_interface(s, index, value);
  580: 
  581:     /* The rest are asynchronous */
  582: 
  583:     aurb = async_alloc();
  584:     aurb->hdev   = s;
  585:     aurb->packet = p;
  586: 
  587:     /* 
  588:      * Setup ctrl transfer.
  589:      *
  590:      * s->ctrl is layed out such that data buffer immediately follows
  591:      * 'req' struct which is exactly what usbdevfs expects.
  592:      */ 
  593:     urb = &aurb->urb;
  594: 
  595:     urb->type     = USBDEVFS_URB_TYPE_CONTROL;
  596:     urb->endpoint = p->devep;
  597: 
  598:     urb->buffer        = &s->ctrl.req;
  599:     urb->buffer_length = 8 + s->ctrl.len;
  600: 
  601:     urb->usercontext = s;
  602: 
  603:     ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
  604: 
  605:     dprintf("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
  606: 
  607:     if (ret < 0) {
  608:         dprintf("husb: submit failed. errno %d\n", errno);
  609:         async_free(aurb);
  610: 
  611:         switch(errno) {
  612:         case ETIMEDOUT:
  613:             return USB_RET_NAK;
  614:         case EPIPE:
  615:         default:
  616:             return USB_RET_STALL;
  617:         }
  618:     }
  619: 
  620:     usb_defer_packet(p, async_cancel, aurb);
  621:     return USB_RET_ASYNC;
  622: }
  623: 
  624: static int do_token_setup(USBDevice *dev, USBPacket *p)
  625: {
  626:     USBHostDevice *s = (USBHostDevice *) dev;
  627:     int ret = 0;
  628: 
  629:     if (p->len != 8)
  630:         return USB_RET_STALL;
  631:  
  632:     memcpy(&s->ctrl.req, p->data, 8);
  633:     s->ctrl.len    = le16_to_cpu(s->ctrl.req.wLength);
  634:     s->ctrl.offset = 0;
  635:     s->ctrl.state  = CTRL_STATE_SETUP;
  636: 
  637:     if (s->ctrl.req.bRequestType & USB_DIR_IN) {
  638:         ret = usb_host_handle_control(s, p);
  639:         if (ret < 0)
  640:             return ret;
  641: 
  642:         if (ret < s->ctrl.len)
  643:             s->ctrl.len = ret;
  644:         s->ctrl.state = CTRL_STATE_DATA;
  645:     } else {
  646:         if (s->ctrl.len == 0)
  647:             s->ctrl.state = CTRL_STATE_ACK;
  648:         else
  649:             s->ctrl.state = CTRL_STATE_DATA;
  650:     }
  651: 
  652:     return ret;
  653: }
  654: 
  655: static int do_token_in(USBDevice *dev, USBPacket *p)
  656: {
  657:     USBHostDevice *s = (USBHostDevice *) dev;
  658:     int ret = 0;
  659: 
  660:     if (p->devep != 0)
  661:         return usb_host_handle_data(s, p);
  662: 
  663:     switch(s->ctrl.state) {
  664:     case CTRL_STATE_ACK:
  665:         if (!(s->ctrl.req.bRequestType & USB_DIR_IN)) {
  666:             ret = usb_host_handle_control(s, p);
  667:             if (ret == USB_RET_ASYNC)
  668:                 return USB_RET_ASYNC;
  669: 
  670:             s->ctrl.state = CTRL_STATE_IDLE;
  671:             return ret > 0 ? 0 : ret;
  672:         }
  673: 
  674:         return 0;
  675: 
  676:     case CTRL_STATE_DATA:
  677:         if (s->ctrl.req.bRequestType & USB_DIR_IN) {
  678:             int len = s->ctrl.len - s->ctrl.offset;
  679:             if (len > p->len)
  680:                 len = p->len;
  681:             memcpy(p->data, s->ctrl.buffer + s->ctrl.offset, len);
  682:             s->ctrl.offset += len;
  683:             if (s->ctrl.offset >= s->ctrl.len)
  684:                 s->ctrl.state = CTRL_STATE_ACK;
  685:             return len;
  686:         }
  687: 
  688:         s->ctrl.state = CTRL_STATE_IDLE;
  689:         return USB_RET_STALL;
  690: 
  691:     default:
  692:         return USB_RET_STALL;
  693:     }
  694: }
  695: 
  696: static int do_token_out(USBDevice *dev, USBPacket *p)
  697: {
  698:     USBHostDevice *s = (USBHostDevice *) dev;
  699: 
  700:     if (p->devep != 0)
  701:         return usb_host_handle_data(s, p);
  702: 
  703:     switch(s->ctrl.state) {
  704:     case CTRL_STATE_ACK:
  705:         if (s->ctrl.req.bRequestType & USB_DIR_IN) {
  706:             s->ctrl.state = CTRL_STATE_IDLE;
  707:             /* transfer OK */
  708:         } else {
  709:             /* ignore additional output */
  710:         }
  711:         return 0;
  712: 
  713:     case CTRL_STATE_DATA:
  714:         if (!(s->ctrl.req.bRequestType & USB_DIR_IN)) {
  715:             int len = s->ctrl.len - s->ctrl.offset;
  716:             if (len > p->len)
  717:                 len = p->len;
  718:             memcpy(s->ctrl.buffer + s->ctrl.offset, p->data, len);
  719:             s->ctrl.offset += len;
  720:             if (s->ctrl.offset >= s->ctrl.len)
  721:                 s->ctrl.state = CTRL_STATE_ACK;
  722:             return len;
  723:         }
  724: 
  725:         s->ctrl.state = CTRL_STATE_IDLE;
  726:         return USB_RET_STALL;
  727: 
  728:     default:
  729:         return USB_RET_STALL;
  730:     }
  731: }
  732: 
  733: /*
  734:  * Packet handler.
  735:  * Called by the HC (host controller).
  736:  *
  737:  * Returns length of the transaction or one of the USB_RET_XXX codes.
  738:  */
  739: static int usb_host_handle_packet(USBDevice *s, USBPacket *p)
  740: {
  741:     switch(p->pid) {
  742:     case USB_MSG_ATTACH:
  743:         s->state = USB_STATE_ATTACHED;
  744:         return 0;
  745: 
  746:     case USB_MSG_DETACH:
  747:         s->state = USB_STATE_NOTATTACHED;
  748:         return 0;
  749: 
  750:     case USB_MSG_RESET:
  751:         s->remote_wakeup = 0;
  752:         s->addr = 0;
  753:         s->state = USB_STATE_DEFAULT;
  754:         s->handle_reset(s);
  755:         return 0;
  756:     }
  757: 
  758:     /* Rest of the PIDs must match our address */
  759:     if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr)
  760:         return USB_RET_NODEV;
  761: 
  762:     switch (p->pid) {
  763:     case USB_TOKEN_SETUP:
  764:         return do_token_setup(s, p);
  765: 
  766:     case USB_TOKEN_IN:
  767:         return do_token_in(s, p);
  768: 
  769:     case USB_TOKEN_OUT:
  770:         return do_token_out(s, p);
  771:  
  772:     default:
  773:         return USB_RET_STALL;
  774:     }
  775: }
  776: 
  777: /* returns 1 on problem encountered or 0 for success */
  778: static int usb_linux_update_endp_table(USBHostDevice *s)
  779: {
  780:     uint8_t *descriptors;
  781:     uint8_t devep, type, configuration, alt_interface;
  782:     struct usb_ctrltransfer ct;
  783:     int interface, ret, length, i;
  784: 
  785:     ct.bRequestType = USB_DIR_IN;
  786:     ct.bRequest = USB_REQ_GET_CONFIGURATION;
  787:     ct.wValue = 0;
  788:     ct.wIndex = 0;
  789:     ct.wLength = 1;
  790:     ct.data = &configuration;
  791:     ct.timeout = 50;
  792: 
  793:     ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
  794:     if (ret < 0) {
  795:         perror("usb_linux_update_endp_table");
  796:         return 1;
  797:     }
  798: 
  799:     /* in address state */
  800:     if (configuration == 0)
  801:         return 1;
  802: 
  803:     /* get the desired configuration, interface, and endpoint descriptors
  804:      * from device description */
  805:     descriptors = &s->descr[18];
  806:     length = s->descr_len - 18;
  807:     i = 0;
  808: 
  809:     if (descriptors[i + 1] != USB_DT_CONFIG ||
  810:         descriptors[i + 5] != configuration) {
  811:         dprintf("invalid descriptor data - configuration\n");
  812:         return 1;
  813:     }
  814:     i += descriptors[i];
  815: 
  816:     while (i < length) {
  817:         if (descriptors[i + 1] != USB_DT_INTERFACE ||
  818:             (descriptors[i + 1] == USB_DT_INTERFACE &&
  819:              descriptors[i + 4] == 0)) {
  820:             i += descriptors[i];
  821:             continue;
  822:         }
  823: 
  824:         interface = descriptors[i + 2];
  825: 
  826:         ct.bRequestType = USB_DIR_IN | USB_RECIP_INTERFACE;
  827:         ct.bRequest = USB_REQ_GET_INTERFACE;
  828:         ct.wValue = 0;
  829:         ct.wIndex = interface;
  830:         ct.wLength = 1;
  831:         ct.data = &alt_interface;
  832:         ct.timeout = 50;
  833: 
  834:         ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct);
  835:         if (ret < 0) {
  836:             perror("usb_linux_update_endp_table");
  837:             return 1;
  838:         }
  839: 
  840:         /* the current interface descriptor is the active interface
  841:          * and has endpoints */
  842:         if (descriptors[i + 3] != alt_interface) {
  843:             i += descriptors[i];
  844:             continue;
  845:         }
  846: 
  847:         /* advance to the endpoints */
  848:         while (i < length && descriptors[i +1] != USB_DT_ENDPOINT)
  849:             i += descriptors[i];
  850: 
  851:         if (i >= length)
  852:             break;
  853: 
  854:         while (i < length) {
  855:             if (descriptors[i + 1] != USB_DT_ENDPOINT)
  856:                 break;
  857: 
  858:             devep = descriptors[i + 2];
  859:             switch (descriptors[i + 3] & 0x3) {
  860:             case 0x00:
  861:                 type = USBDEVFS_URB_TYPE_CONTROL;
  862:                 break;
  863:             case 0x01:
  864:                 type = USBDEVFS_URB_TYPE_ISO;
  865:                 break;
  866:             case 0x02:
  867:                 type = USBDEVFS_URB_TYPE_BULK;
  868:                 break;
  869:             case 0x03:
  870:                 type = USBDEVFS_URB_TYPE_INTERRUPT;
  871:                 break;
  872:             default:
  873:                 dprintf("usb_host: malformed endpoint type\n");
  874:                 type = USBDEVFS_URB_TYPE_BULK;
  875:             }
  876:             s->endp_table[(devep & 0xf) - 1].type = type;
  877:             s->endp_table[(devep & 0xf) - 1].halted = 0;
  878: 
  879:             i += descriptors[i];
  880:         }
  881:     }
  882:     return 0;
  883: }
  884: 
  885: static USBDevice *usb_host_device_open_addr(int bus_num, int addr, const char *prod_name)
  886: {
  887:     int fd = -1, ret;
  888:     USBHostDevice *dev = NULL;
  889:     struct usbdevfs_connectinfo ci;
  890:     char buf[1024];
  891: 
  892:     dev = qemu_mallocz(sizeof(USBHostDevice));
  893: 
  894:     dev->bus_num = bus_num;
  895:     dev->addr = addr;
  896: 
  897:     printf("husb: open device %d.%d\n", bus_num, addr);
  898: 
  899:     if (!usb_host_device_path) {
  900:         perror("husb: USB Host Device Path not set");
  901:         goto fail;
  902:     }
  903:     snprintf(buf, sizeof(buf), "%s/%03d/%03d", usb_host_device_path,
  904:              bus_num, addr);
  905:     fd = open(buf, O_RDWR | O_NONBLOCK);
  906:     if (fd < 0) {
  907:         perror(buf);
  908:         goto fail;
  909:     }
  910:     dprintf("husb: opened %s\n", buf);
  911: 
  912:     /* read the device description */
  913:     dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
  914:     if (dev->descr_len <= 0) {
  915:         perror("husb: reading device data failed");
  916:         goto fail;
  917:     }
  918: 
  919: #ifdef DEBUG
  920:     {
  921:         int x;
  922:         printf("=== begin dumping device descriptor data ===\n");
  923:         for (x = 0; x < dev->descr_len; x++)
  924:             printf("%02x ", dev->descr[x]);
  925:         printf("\n=== end dumping device descriptor data ===\n");
  926:     }
  927: #endif
  928: 
  929:     dev->fd = fd;
  930: 
  931:     /* 
  932:      * Initial configuration is -1 which makes us claim first 
  933:      * available config. We used to start with 1, which does not
  934:      * always work. I've seen devices where first config starts 
  935:      * with 2.
  936:      */
  937:     if (!usb_host_claim_interfaces(dev, -1))
  938:         goto fail;
  939: 
  940:     ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
  941:     if (ret < 0) {
  942:         perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
  943:         goto fail;
  944:     }
  945: 
  946:     printf("husb: grabbed usb device %d.%d\n", bus_num, addr);
  947: 
  948:     ret = usb_linux_update_endp_table(dev);
  949:     if (ret)
  950:         goto fail;
  951: 
  952:     if (ci.slow)
  953:         dev->dev.speed = USB_SPEED_LOW;
  954:     else
  955:         dev->dev.speed = USB_SPEED_HIGH;
  956: 
  957:     dev->dev.handle_packet  = usb_host_handle_packet;
  958:     dev->dev.handle_reset   = usb_host_handle_reset;
  959:     dev->dev.handle_destroy = usb_host_handle_destroy;
  960: 
  961:     if (!prod_name || prod_name[0] == '\0')
  962:         snprintf(dev->dev.devname, sizeof(dev->dev.devname),
  963:                  "host:%d.%d", bus_num, addr);
  964:     else
  965:         pstrcpy(dev->dev.devname, sizeof(dev->dev.devname),
  966:                 prod_name);
  967: 
  968:     /* USB devio uses 'write' flag to check for async completions */
  969:     qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
  970: 
  971:     hostdev_link(dev);
  972: 
  973:     return (USBDevice *) dev;
  974: 
  975: fail:
  976:     if (dev)
  977:         qemu_free(dev);
  978: 
  979:     close(fd);
  980:     return NULL;
  981: }
  982: 
  983: static int usb_host_auto_add(const char *spec);
  984: static int usb_host_auto_del(const char *spec);
  985: 
  986: USBDevice *usb_host_device_open(const char *devname)
  987: {
  988:     int bus_num, addr;
  989:     char product_name[PRODUCT_NAME_SZ];
  990: 
  991:     if (strstr(devname, "auto:")) {
  992:         usb_host_auto_add(devname);
  993:         return NULL;
  994:     }
  995: 
  996:     if (usb_host_find_device(&bus_num, &addr, product_name, sizeof(product_name),
  997:                              devname) < 0)
  998:         return NULL;
  999: 
 1000:     if (hostdev_find(bus_num, addr)) {
 1001:        term_printf("husb: host usb device %d.%d is already open\n", bus_num, addr);
 1002:        return NULL;
 1003:     }
 1004: 
 1005:     return usb_host_device_open_addr(bus_num, addr, product_name);
 1006: }
 1007: 
 1008: int usb_host_device_close(const char *devname)
 1009: {
 1010:     char product_name[PRODUCT_NAME_SZ];
 1011:     int bus_num, addr;
 1012:     USBHostDevice *s;
 1013: 
 1014:     if (strstr(devname, "auto:"))
 1015:         return usb_host_auto_del(devname);
 1016: 
 1017:     if (usb_host_find_device(&bus_num, &addr, product_name, sizeof(product_name),
 1018:                              devname) < 0)
 1019:         return -1;
 1020:  
 1021:     s = hostdev_find(bus_num, addr);
 1022:     if (s) {
 1023:         usb_device_del_addr(0, s->dev.addr);
 1024:         return 0;
 1025:     }
 1026: 
 1027:     return -1;
 1028: }
 1029:  
 1030: static int get_tag_value(char *buf, int buf_size,
 1031:                          const char *str, const char *tag,
 1032:                          const char *stopchars)
 1033: {
 1034:     const char *p;
 1035:     char *q;
 1036:     p = strstr(str, tag);
 1037:     if (!p)
 1038:         return -1;
 1039:     p += strlen(tag);
 1040:     while (qemu_isspace(*p))
 1041:         p++;
 1042:     q = buf;
 1043:     while (*p != '\0' && !strchr(stopchars, *p)) {
 1044:         if ((q - buf) < (buf_size - 1))
 1045:             *q++ = *p;
 1046:         p++;
 1047:     }
 1048:     *q = '\0';
 1049:     return q - buf;
 1050: }
 1051: 
 1052: /*
 1053:  * Use /proc/bus/usb/devices or /dev/bus/usb/devices file to determine
 1054:  * host's USB devices. This is legacy support since many distributions
 1055:  * are moving to /sys/bus/usb
 1056:  */
 1057: static int usb_host_scan_dev(void *opaque, USBScanFunc *func)
 1058: {
 1059:     FILE *f = 0;
 1060:     char line[1024];
 1061:     char buf[1024];
 1062:     int bus_num, addr, speed, device_count, class_id, product_id, vendor_id;
 1063:     char product_name[512];
 1064:     int ret = 0;
 1065: 
 1066:     if (!usb_host_device_path) {
 1067:         perror("husb: USB Host Device Path not set");
 1068:         goto the_end;
 1069:     }
 1070:     snprintf(line, sizeof(line), "%s/devices", usb_host_device_path);
 1071:     f = fopen(line, "r");
 1072:     if (!f) {
 1073:         perror("husb: cannot open devices file");
 1074:         goto the_end;
 1075:     }
 1076: 
 1077:     device_count = 0;
 1078:     bus_num = addr = speed = class_id = product_id = vendor_id = 0;
 1079:     for(;;) {
 1080:         if (fgets(line, sizeof(line), f) == NULL)
 1081:             break;
 1082:         if (strlen(line) > 0)
 1083:             line[strlen(line) - 1] = '\0';
 1084:         if (line[0] == 'T' && line[1] == ':') {
 1085:             if (device_count && (vendor_id || product_id)) {
 1086:                 /* New device.  Add the previously discovered device.  */
 1087:                 ret = func(opaque, bus_num, addr, class_id, vendor_id,
 1088:                            product_id, product_name, speed);
 1089:                 if (ret)
 1090:                     goto the_end;
 1091:             }
 1092:             if (get_tag_value(buf, sizeof(buf), line, "Bus=", " ") < 0)
 1093:                 goto fail;
 1094:             bus_num = atoi(buf);
 1095:             if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0)
 1096:                 goto fail;
 1097:             addr = atoi(buf);
 1098:             if (get_tag_value(buf, sizeof(buf), line, "Spd=", " ") < 0)
 1099:                 goto fail;
 1100:             if (!strcmp(buf, "480"))
 1101:                 speed = USB_SPEED_HIGH;
 1102:             else if (!strcmp(buf, "1.5"))
 1103:                 speed = USB_SPEED_LOW;
 1104:             else
 1105:                 speed = USB_SPEED_FULL;
 1106:             product_name[0] = '\0';
 1107:             class_id = 0xff;
 1108:             device_count++;
 1109:             product_id = 0;
 1110:             vendor_id = 0;
 1111:         } else if (line[0] == 'P' && line[1] == ':') {
 1112:             if (get_tag_value(buf, sizeof(buf), line, "Vendor=", " ") < 0)
 1113:                 goto fail;
 1114:             vendor_id = strtoul(buf, NULL, 16);
 1115:             if (get_tag_value(buf, sizeof(buf), line, "ProdID=", " ") < 0)
 1116:                 goto fail;
 1117:             product_id = strtoul(buf, NULL, 16);
 1118:         } else if (line[0] == 'S' && line[1] == ':') {
 1119:             if (get_tag_value(buf, sizeof(buf), line, "Product=", "") < 0)
 1120:                 goto fail;
 1121:             pstrcpy(product_name, sizeof(product_name), buf);
 1122:         } else if (line[0] == 'D' && line[1] == ':') {
 1123:             if (get_tag_value(buf, sizeof(buf), line, "Cls=", " (") < 0)
 1124:                 goto fail;
 1125:             class_id = strtoul(buf, NULL, 16);
 1126:         }
 1127:     fail: ;
 1128:     }
 1129:     if (device_count && (vendor_id || product_id)) {
 1130:         /* Add the last device.  */
 1131:         ret = func(opaque, bus_num, addr, class_id, vendor_id,
 1132:                    product_id, product_name, speed);
 1133:     }
 1134:  the_end:
 1135:     if (f)
 1136:         fclose(f);
 1137:     return ret;
 1138: }
 1139: 
 1140: /*
 1141:  * Read sys file-system device file
 1142:  *
 1143:  * @line address of buffer to put file contents in
 1144:  * @line_size size of line
 1145:  * @device_file path to device file (printf format string)
 1146:  * @device_name device being opened (inserted into device_file)
 1147:  *
 1148:  * @return 0 failed, 1 succeeded ('line' contains data)
 1149:  */
 1150: static int usb_host_read_file(char *line, size_t line_size, const char *device_file, const char *device_name)
 1151: {
 1152:     FILE *f;
 1153:     int ret = 0;
 1154:     char filename[PATH_MAX];
 1155: 
 1156:     snprintf(filename, PATH_MAX, USBSYSBUS_PATH "/devices/%s/%s", device_name,
 1157:              device_file);
 1158:     f = fopen(filename, "r");
 1159:     if (f) {
 1160:         fgets(line, line_size, f);
 1161:         fclose(f);
 1162:         ret = 1;
 1163:     } else {
 1164:         term_printf("husb: could not open %s\n", filename);
 1165:     }
 1166: 
 1167:     return ret;
 1168: }
 1169: 
 1170: /*
 1171:  * Use /sys/bus/usb/devices/ directory to determine host's USB
 1172:  * devices.
 1173:  *
 1174:  * This code is based on Robert Schiele's original patches posted to
 1175:  * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
 1176:  */
 1177: static int usb_host_scan_sys(void *opaque, USBScanFunc *func)
 1178: {
 1179:     DIR *dir = 0;
 1180:     char line[1024];
 1181:     int bus_num, addr, speed, class_id, product_id, vendor_id;
 1182:     int ret = 0;
 1183:     char product_name[512];
 1184:     struct dirent *de;
 1185: 
 1186:     dir = opendir(USBSYSBUS_PATH "/devices");
 1187:     if (!dir) {
 1188:         perror("husb: cannot open devices directory");
 1189:         goto the_end;
 1190:     }
 1191: 
 1192:     while ((de = readdir(dir))) {
 1193:         if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
 1194:             char *tmpstr = de->d_name;
 1195:             if (!strncmp(de->d_name, "usb", 3))
 1196:                 tmpstr += 3;
 1197:             bus_num = atoi(tmpstr);
 1198: 
 1199:             if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name))
 1200:                 goto the_end;
 1201:             if (sscanf(line, "%d", &addr) != 1)
 1202:                 goto the_end;
 1203: 
 1204:             if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
 1205:                                     de->d_name))
 1206:                 goto the_end;
 1207:             if (sscanf(line, "%x", &class_id) != 1)
 1208:                 goto the_end;
 1209: 
 1210:             if (!usb_host_read_file(line, sizeof(line), "idVendor", de->d_name))
 1211:                 goto the_end;
 1212:             if (sscanf(line, "%x", &vendor_id) != 1)
 1213:                 goto the_end;
 1214: 
 1215:             if (!usb_host_read_file(line, sizeof(line), "idProduct",
 1216:                                     de->d_name))
 1217:                 goto the_end;
 1218:             if (sscanf(line, "%x", &product_id) != 1)
 1219:                 goto the_end;
 1220: 
 1221:             if (!usb_host_read_file(line, sizeof(line), "product",
 1222:                                     de->d_name)) {
 1223:                 *product_name = 0;
 1224:             } else {
 1225:                 if (strlen(line) > 0)
 1226:                     line[strlen(line) - 1] = '\0';
 1227:                 pstrcpy(product_name, sizeof(product_name), line);
 1228:             }
 1229: 
 1230:             if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name))
 1231:                 goto the_end;
 1232:             if (!strcmp(line, "480\n"))
 1233:                 speed = USB_SPEED_HIGH;
 1234:             else if (!strcmp(line, "1.5\n"))
 1235:                 speed = USB_SPEED_LOW;
 1236:             else
 1237:                 speed = USB_SPEED_FULL;
 1238: 
 1239:             ret = func(opaque, bus_num, addr, class_id, vendor_id,
 1240:                        product_id, product_name, speed);
 1241:             if (ret)
 1242:                 goto the_end;
 1243:         }
 1244:     }
 1245:  the_end:
 1246:     if (dir)
 1247:         closedir(dir);
 1248:     return ret;
 1249: }
 1250: 
 1251: /*
 1252:  * Determine how to access the host's USB devices and call the
 1253:  * specific support function.
 1254:  */
 1255: static int usb_host_scan(void *opaque, USBScanFunc *func)
 1256: {
 1257:     FILE *f = 0;
 1258:     DIR *dir = 0;
 1259:     int ret = 0;
 1260:     const char *fs_type[] = {"unknown", "proc", "dev", "sys"};
 1261:     char devpath[PATH_MAX];
 1262: 
 1263:     /* only check the host once */
 1264:     if (!usb_fs_type) {
 1265:         f = fopen(USBPROCBUS_PATH "/devices", "r");
 1266:         if (f) {
 1267:             /* devices found in /proc/bus/usb/ */
 1268:             strcpy(devpath, USBPROCBUS_PATH);
 1269:             usb_fs_type = USB_FS_PROC;
 1270:             fclose(f);
 1271:             dprintf(USBDBG_DEVOPENED, USBPROCBUS_PATH);
 1272:             goto found_devices;
 1273:         }
 1274:         /* try additional methods if an access method hasn't been found yet */
 1275:         f = fopen(USBDEVBUS_PATH "/devices", "r");
 1276:         if (f) {
 1277:             /* devices found in /dev/bus/usb/ */
 1278:             strcpy(devpath, USBDEVBUS_PATH);
 1279:             usb_fs_type = USB_FS_DEV;
 1280:             fclose(f);
 1281:             dprintf(USBDBG_DEVOPENED, USBDEVBUS_PATH);
 1282:             goto found_devices;
 1283:         }
 1284:         dir = opendir(USBSYSBUS_PATH "/devices");
 1285:         if (dir) {
 1286:             /* devices found in /dev/bus/usb/ (yes - not a mistake!) */
 1287:             strcpy(devpath, USBDEVBUS_PATH);
 1288:             usb_fs_type = USB_FS_SYS;
 1289:             closedir(dir);
 1290:             dprintf(USBDBG_DEVOPENED, USBSYSBUS_PATH);
 1291:             goto found_devices;
 1292:         }
 1293:     found_devices:
 1294:         if (!usb_fs_type) {
 1295:             term_printf("husb: unable to access USB devices\n");
 1296:             return -ENOENT;
 1297:         }
 1298: 
 1299:         /* the module setting (used later for opening devices) */
 1300:         usb_host_device_path = qemu_mallocz(strlen(devpath)+1);
 1301:         strcpy(usb_host_device_path, devpath);
 1302:         term_printf("husb: using %s file-system with %s\n", fs_type[usb_fs_type], usb_host_device_path);
 1303:     }
 1304: 
 1305:     switch (usb_fs_type) {
 1306:     case USB_FS_PROC:
 1307:     case USB_FS_DEV:
 1308:         ret = usb_host_scan_dev(opaque, func);
 1309:         break;
 1310:     case USB_FS_SYS:
 1311:         ret = usb_host_scan_sys(opaque, func);
 1312:         break;
 1313:     default:
 1314:         ret = -EINVAL;
 1315:         break;
 1316:     }
 1317:     return ret;
 1318: }
 1319: 
 1320: struct USBAutoFilter {
 1321:     struct USBAutoFilter *next;
 1322:     int bus_num;
 1323:     int addr;
 1324:     int vendor_id;
 1325:     int product_id;
 1326: };
 1327: 
 1328: static QEMUTimer *usb_auto_timer;
 1329: static struct USBAutoFilter *usb_auto_filter;
 1330: 
 1331: static int usb_host_auto_scan(void *opaque, int bus_num, int addr,
 1332:                      int class_id, int vendor_id, int product_id,
 1333:                      const char *product_name, int speed)
 1334: {
 1335:     struct USBAutoFilter *f;
 1336:     struct USBDevice *dev;
 1337: 
 1338:     /* Ignore hubs */
 1339:     if (class_id == 9)
 1340:         return 0;
 1341: 
 1342:     for (f = usb_auto_filter; f; f = f->next) {
 1343: 	if (f->bus_num >= 0 && f->bus_num != bus_num)
 1344:             continue;
 1345: 
 1346: 	if (f->addr >= 0 && f->addr != addr)
 1347:             continue;
 1348: 
 1349: 	if (f->vendor_id >= 0 && f->vendor_id != vendor_id)
 1350:             continue;
 1351: 
 1352: 	if (f->product_id >= 0 && f->product_id != product_id)
 1353:             continue;
 1354: 
 1355:         /* We got a match */
 1356: 
 1357:         /* Allredy attached ? */
 1358:         if (hostdev_find(bus_num, addr))
 1359:             return 0;
 1360: 
 1361:         dprintf("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
 1362: 
 1363: 	dev = usb_host_device_open_addr(bus_num, addr, product_name);
 1364: 	if (dev)
 1365: 	    usb_device_add_dev(dev);
 1366:     }
 1367: 
 1368:     return 0;
 1369: }
 1370: 
 1371: static void usb_host_auto_timer(void *unused)
 1372: {
 1373:     usb_host_scan(NULL, usb_host_auto_scan);
 1374:     qemu_mod_timer(usb_auto_timer, qemu_get_clock(rt_clock) + 2000);
 1375: }
 1376: 
 1377: /*
 1378:  * Autoconnect filter
 1379:  * Format:
 1380:  *    auto:bus:dev[:vid:pid]
 1381:  *    auto:bus.dev[:vid:pid]
 1382:  *
 1383:  *    bus  - bus number    (dec, * means any)
 1384:  *    dev  - device number (dec, * means any)
 1385:  *    vid  - vendor id     (hex, * means any)
 1386:  *    pid  - product id    (hex, * means any)
 1387:  *
 1388:  *    See 'lsusb' output.
 1389:  */
 1390: static int parse_filter(const char *spec, struct USBAutoFilter *f)
 1391: {
 1392:     enum { BUS, DEV, VID, PID, DONE };
 1393:     const char *p = spec;
 1394:     int i;
 1395: 
 1396:     f->bus_num    = -1;
 1397:     f->addr       = -1;
 1398:     f->vendor_id  = -1;
 1399:     f->product_id = -1;
 1400: 
 1401:     for (i = BUS; i < DONE; i++) {
 1402:     	p = strpbrk(p, ":.");
 1403:     	if (!p) break;
 1404:         p++;
 1405:  
 1406:     	if (*p == '*')
 1407:             continue;
 1408: 
 1409:         switch(i) {
 1410:         case BUS: f->bus_num = strtol(p, NULL, 10);    break;
 1411:         case DEV: f->addr    = strtol(p, NULL, 10);    break;
 1412:         case VID: f->vendor_id  = strtol(p, NULL, 16); break;
 1413:         case PID: f->product_id = strtol(p, NULL, 16); break;
 1414:         }
 1415:     }
 1416: 
 1417:     if (i < DEV) {
 1418:         fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
 1419:         return -1;
 1420:     }
 1421: 
 1422:     return 0;
 1423: }
 1424: 
 1425: static int match_filter(const struct USBAutoFilter *f1, 
 1426:                         const struct USBAutoFilter *f2)
 1427: {
 1428:     return f1->bus_num    == f2->bus_num &&
 1429:            f1->addr       == f2->addr &&
 1430:            f1->vendor_id  == f2->vendor_id &&
 1431:            f1->product_id == f2->product_id;
 1432: }
 1433: 
 1434: static int usb_host_auto_add(const char *spec)
 1435: {
 1436:     struct USBAutoFilter filter, *f;
 1437: 
 1438:     if (parse_filter(spec, &filter) < 0)
 1439:         return -1;
 1440: 
 1441:     f = qemu_mallocz(sizeof(*f));
 1442: 
 1443:     *f = filter; 
 1444: 
 1445:     if (!usb_auto_filter) {
 1446:         /*
 1447:          * First entry. Init and start the monitor.
 1448:          * Right now we're using timer to check for new devices.
 1449:          * If this turns out to be too expensive we can move that into a 
 1450:          * separate thread.
 1451:          */
 1452: 	usb_auto_timer = qemu_new_timer(rt_clock, usb_host_auto_timer, NULL);
 1453: 	if (!usb_auto_timer) {
 1454:             fprintf(stderr, "husb: failed to allocate auto scan timer\n");
 1455:             qemu_free(f);
 1456:             return -1;
 1457:         }
 1458: 
 1459:         /* Check for new devices every two seconds */
 1460:         qemu_mod_timer(usb_auto_timer, qemu_get_clock(rt_clock) + 2000);
 1461:     }
 1462: 
 1463:     dprintf("husb: added auto filter: bus_num %d addr %d vid %d pid %d\n",
 1464: 	f->bus_num, f->addr, f->vendor_id, f->product_id);
 1465: 
 1466:     f->next = usb_auto_filter;
 1467:     usb_auto_filter = f;
 1468: 
 1469:     return 0;
 1470: }
 1471: 
 1472: static int usb_host_auto_del(const char *spec)
 1473: {
 1474:     struct USBAutoFilter *pf = usb_auto_filter;
 1475:     struct USBAutoFilter **prev = &usb_auto_filter;
 1476:     struct USBAutoFilter filter;
 1477: 
 1478:     if (parse_filter(spec, &filter) < 0)
 1479:         return -1;
 1480: 
 1481:     while (pf) {
 1482:         if (match_filter(pf, &filter)) {
 1483:             dprintf("husb: removed auto filter: bus_num %d addr %d vid %d pid %d\n",
 1484: 	             pf->bus_num, pf->addr, pf->vendor_id, pf->product_id);
 1485: 
 1486:             *prev = pf->next;
 1487: 
 1488: 	    if (!usb_auto_filter) {
 1489:                 /* No more filters. Stop scanning. */
 1490:                 qemu_del_timer(usb_auto_timer);
 1491:                 qemu_free_timer(usb_auto_timer);
 1492:             }
 1493: 
 1494:             return 0;
 1495:         }
 1496: 
 1497:         prev = &pf->next;
 1498:         pf   = pf->next;
 1499:     }
 1500: 
 1501:     return -1;
 1502: }
 1503: 
 1504: typedef struct FindDeviceState {
 1505:     int vendor_id;
 1506:     int product_id;
 1507:     int bus_num;
 1508:     int addr;
 1509:     char product_name[PRODUCT_NAME_SZ];
 1510: } FindDeviceState;
 1511: 
 1512: static int usb_host_find_device_scan(void *opaque, int bus_num, int addr,
 1513:                                      int class_id,
 1514:                                      int vendor_id, int product_id,
 1515:                                      const char *product_name, int speed)
 1516: {
 1517:     FindDeviceState *s = opaque;
 1518:     if ((vendor_id == s->vendor_id &&
 1519:         product_id == s->product_id) ||
 1520:         (bus_num == s->bus_num &&
 1521:         addr == s->addr)) {
 1522:         pstrcpy(s->product_name, PRODUCT_NAME_SZ, product_name);
 1523:         s->bus_num = bus_num;
 1524:         s->addr = addr;
 1525:         return 1;
 1526:     } else {
 1527:         return 0;
 1528:     }
 1529: }
 1530: 
 1531: /* the syntax is :
 1532:    'bus.addr' (decimal numbers) or
 1533:    'vendor_id:product_id' (hexa numbers) */
 1534: static int usb_host_find_device(int *pbus_num, int *paddr,
 1535:                                 char *product_name, int product_name_size,
 1536:                                 const char *devname)
 1537: {
 1538:     const char *p;
 1539:     int ret;
 1540:     FindDeviceState fs;
 1541: 
 1542:     p = strchr(devname, '.');
 1543:     if (p) {
 1544:         *pbus_num = strtoul(devname, NULL, 0);
 1545:         *paddr = strtoul(p + 1, NULL, 0);
 1546:         fs.bus_num = *pbus_num;
 1547:         fs.addr = *paddr;
 1548:         ret = usb_host_scan(&fs, usb_host_find_device_scan);
 1549:         if (ret)
 1550:             pstrcpy(product_name, product_name_size, fs.product_name);
 1551:         return 0;
 1552:     }
 1553: 
 1554:     p = strchr(devname, ':');
 1555:     if (p) {
 1556:         fs.vendor_id = strtoul(devname, NULL, 16);
 1557:         fs.product_id = strtoul(p + 1, NULL, 16);
 1558:         ret = usb_host_scan(&fs, usb_host_find_device_scan);
 1559:         if (ret) {
 1560:             *pbus_num = fs.bus_num;
 1561:             *paddr = fs.addr;
 1562:             pstrcpy(product_name, product_name_size, fs.product_name);
 1563:             return 0;
 1564:         }
 1565:     }
 1566:     return -1;
 1567: }
 1568: 
 1569: /**********************/
 1570: /* USB host device info */
 1571: 
 1572: struct usb_class_info {
 1573:     int class;
 1574:     const char *class_name;
 1575: };
 1576: 
 1577: static const struct usb_class_info usb_class_info[] = {
 1578:     { USB_CLASS_AUDIO, "Audio"},
 1579:     { USB_CLASS_COMM, "Communication"},
 1580:     { USB_CLASS_HID, "HID"},
 1581:     { USB_CLASS_HUB, "Hub" },
 1582:     { USB_CLASS_PHYSICAL, "Physical" },
 1583:     { USB_CLASS_PRINTER, "Printer" },
 1584:     { USB_CLASS_MASS_STORAGE, "Storage" },
 1585:     { USB_CLASS_CDC_DATA, "Data" },
 1586:     { USB_CLASS_APP_SPEC, "Application Specific" },
 1587:     { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
 1588:     { USB_CLASS_STILL_IMAGE, "Still Image" },
 1589:     { USB_CLASS_CSCID, "Smart Card" },
 1590:     { USB_CLASS_CONTENT_SEC, "Content Security" },
 1591:     { -1, NULL }
 1592: };
 1593: 
 1594: static const char *usb_class_str(uint8_t class)
 1595: {
 1596:     const struct usb_class_info *p;
 1597:     for(p = usb_class_info; p->class != -1; p++) {
 1598:         if (p->class == class)
 1599:             break;
 1600:     }
 1601:     return p->class_name;
 1602: }
 1603: 
 1604: static void usb_info_device(int bus_num, int addr, int class_id,
 1605:                             int vendor_id, int product_id,
 1606:                             const char *product_name,
 1607:                             int speed)
 1608: {
 1609:     const char *class_str, *speed_str;
 1610: 
 1611:     switch(speed) {
 1612:     case USB_SPEED_LOW:
 1613:         speed_str = "1.5";
 1614:         break;
 1615:     case USB_SPEED_FULL:
 1616:         speed_str = "12";
 1617:         break;
 1618:     case USB_SPEED_HIGH:
 1619:         speed_str = "480";
 1620:         break;
 1621:     default:
 1622:         speed_str = "?";
 1623:         break;
 1624:     }
 1625: 
 1626:     term_printf("  Device %d.%d, speed %s Mb/s\n",
 1627:                 bus_num, addr, speed_str);
 1628:     class_str = usb_class_str(class_id);
 1629:     if (class_str)
 1630:         term_printf("    %s:", class_str);
 1631:     else
 1632:         term_printf("    Class %02x:", class_id);
 1633:     term_printf(" USB device %04x:%04x", vendor_id, product_id);
 1634:     if (product_name[0] != '\0')
 1635:         term_printf(", %s", product_name);
 1636:     term_printf("\n");
 1637: }
 1638: 
 1639: static int usb_host_info_device(void *opaque, int bus_num, int addr,
 1640:                                 int class_id,
 1641:                                 int vendor_id, int product_id,
 1642:                                 const char *product_name,
 1643:                                 int speed)
 1644: {
 1645:     usb_info_device(bus_num, addr, class_id, vendor_id, product_id,
 1646:                     product_name, speed);
 1647:     return 0;
 1648: }
 1649: 
 1650: static void dec2str(int val, char *str, size_t size)
 1651: {
 1652:     if (val == -1)
 1653:         snprintf(str, size, "*");
 1654:     else
 1655:         snprintf(str, size, "%d", val); 
 1656: }
 1657: 
 1658: static void hex2str(int val, char *str, size_t size)
 1659: {
 1660:     if (val == -1)
 1661:         snprintf(str, size, "*");
 1662:     else
 1663:         snprintf(str, size, "%x", val);
 1664: }
 1665: 
 1666: void usb_host_info(void)
 1667: {
 1668:     struct USBAutoFilter *f;
 1669: 
 1670:     usb_host_scan(NULL, usb_host_info_device);
 1671: 
 1672:     if (usb_auto_filter)
 1673:         term_printf("  Auto filters:\n");
 1674:     for (f = usb_auto_filter; f; f = f->next) {
 1675:         char bus[10], addr[10], vid[10], pid[10];
 1676:         dec2str(f->bus_num, bus, sizeof(bus));
 1677:         dec2str(f->addr, addr, sizeof(addr));
 1678:         hex2str(f->vendor_id, vid, sizeof(vid));
 1679:         hex2str(f->product_id, pid, sizeof(pid));
 1680:     	term_printf("    Device %s.%s ID %s:%s\n", bus, addr, vid, pid);
 1681:     }
 1682: }

unix.superglobalmegacorp.com