hw/usb.c

   1 /*
   2  * QEMU USB emulation
   3  *
   4  * Copyright (c) 2005 Fabrice Bellard
   5  *
   6  * 2008 Generic packet handler rewrite by Max Krasnyansky
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24  * THE SOFTWARE.
  25  */
  26 #include "qemu-common.h"
  27 #include "usb.h"
  28
  29 void usb_attach(USBPort *port, USBDevice *dev)
  30 {
  31     if (dev != NULL) {
  32         /* attach */
  33         if (port->dev) {
  34             usb_attach(port, NULL);
  35         }
  36         dev->port = port;
  37         port->dev = dev;
  38         port->ops->attach(port);
  39         usb_send_msg(dev, USB_MSG_ATTACH);
  40     } else {
  41         /* detach */
  42         dev = port->dev;
  43         port->ops->detach(port);
  44         if (dev) {
  45             usb_send_msg(dev, USB_MSG_DETACH);
  46             dev->port = NULL;
  47             port->dev = NULL;
  48         }
  49     }
  50 }
  51
  52 void usb_wakeup(USBDevice *dev)
  53 {
  54     if (dev->remote_wakeup && dev->port && dev->port->ops->wakeup) {
  55         dev->port->ops->wakeup(dev);
  56     }
  57 }
  58
  59 /**********************/
  60
  61 /* generic USB device helpers (you are not forced to use them when
  62    writing your USB device driver, but they help handling the
  63    protocol)
  64 */
  65
  66 #define SETUP_STATE_IDLE 0
  67 #define SETUP_STATE_DATA 1
  68 #define SETUP_STATE_ACK  2
  69
  70 static int do_token_setup(USBDevice *s, USBPacket *p)
  71 {
  72     int request, value, index;
  73     int ret = 0;
  74
  75     if (p->len != 8)
  76         return USB_RET_STALL;
  77
  78     memcpy(s->setup_buf, p->data, 8);
  79     s->setup_len   = (s->setup_buf[7] << 8) | s->setup_buf[6];
  80     s->setup_index = 0;
  81
  82     request = (s->setup_buf[0] << 8) | s->setup_buf[1];
  83     value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
  84     index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
  85
  86     if (s->setup_buf[0] & USB_DIR_IN) {
  87         ret = s->info->handle_control(s, p, request, value, index,
  88                                       s->setup_len, s->data_buf);
  89         if (ret < 0)
  90             return ret;
  91
  92         if (ret < s->setup_len)
  93             s->setup_len = ret;
  94         s->setup_state = SETUP_STATE_DATA;
  95     } else {
  96         if (s->setup_len > sizeof(s->data_buf)) {
  97             fprintf(stderr,
  98                 "usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n",
  99                 s->setup_len, sizeof(s->data_buf));
 100             return USB_RET_STALL;
 101         }
 102         if (s->setup_len == 0)
 103             s->setup_state = SETUP_STATE_ACK;
 104         else
 105             s->setup_state = SETUP_STATE_DATA;
 106     }
 107
 108     return ret;
 109 }
 110
 111 static int do_token_in(USBDevice *s, USBPacket *p)
 112 {
 113     int request, value, index;
 114     int ret = 0;
 115
 116     if (p->devep != 0)
 117         return s->info->handle_data(s, p);
 118
 119     request = (s->setup_buf[0] << 8) | s->setup_buf[1];
 120     value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
 121     index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
 122
 123     switch(s->setup_state) {
 124     case SETUP_STATE_ACK:
 125         if (!(s->setup_buf[0] & USB_DIR_IN)) {
 126             ret = s->info->handle_control(s, p, request, value, index,
 127                                           s->setup_len, s->data_buf);
 128             if (ret == USB_RET_ASYNC) {
 129                 return USB_RET_ASYNC;
 130             }
 131             s->setup_state = SETUP_STATE_IDLE;
 132             if (ret > 0)
 133                 return 0;
 134             return ret;
 135         }
 136
 137         /* return 0 byte */
 138         return 0;
 139
 140     case SETUP_STATE_DATA:
 141         if (s->setup_buf[0] & USB_DIR_IN) {
 142             int len = s->setup_len - s->setup_index;
 143             if (len > p->len)
 144                 len = p->len;
 145             memcpy(p->data, s->data_buf + s->setup_index, len);
 146             s->setup_index += len;
 147             if (s->setup_index >= s->setup_len)
 148                 s->setup_state = SETUP_STATE_ACK;
 149             return len;
 150         }
 151
 152         s->setup_state = SETUP_STATE_IDLE;
 153         return USB_RET_STALL;
 154
 155     default:
 156         return USB_RET_STALL;
 157     }
 158 }
 159
 160 static int do_token_out(USBDevice *s, USBPacket *p)
 161 {
 162     if (p->devep != 0)
 163         return s->info->handle_data(s, p);
 164
 165     switch(s->setup_state) {
 166     case SETUP_STATE_ACK:
 167         if (s->setup_buf[0] & USB_DIR_IN) {
 168             s->setup_state = SETUP_STATE_IDLE;
 169             /* transfer OK */
 170         } else {
 171             /* ignore additional output */
 172         }
 173         return 0;
 174
 175     case SETUP_STATE_DATA:
 176         if (!(s->setup_buf[0] & USB_DIR_IN)) {
 177             int len = s->setup_len - s->setup_index;
 178             if (len > p->len)
 179                 len = p->len;
 180             memcpy(s->data_buf + s->setup_index, p->data, len);
 181             s->setup_index += len;
 182             if (s->setup_index >= s->setup_len)
 183                 s->setup_state = SETUP_STATE_ACK;
 184             return len;
 185         }
 186
 187         s->setup_state = SETUP_STATE_IDLE;
 188         return USB_RET_STALL;
 189
 190     default:
 191         return USB_RET_STALL;
 192     }
 193 }
 194
 195 /*
 196  * Generic packet handler.
 197  * Called by the HC (host controller).
 198  *
 199  * Returns length of the transaction or one of the USB_RET_XXX codes.
 200  */
 201 int usb_generic_handle_packet(USBDevice *s, USBPacket *p)
 202 {
 203     switch(p->pid) {
 204     case USB_MSG_ATTACH:
 205         s->state = USB_STATE_ATTACHED;
 206         if (s->info->handle_attach) {
 207             s->info->handle_attach(s);
 208         }
 209         return 0;
 210
 211     case USB_MSG_DETACH:
 212         s->state = USB_STATE_NOTATTACHED;
 213         return 0;
 214
 215     case USB_MSG_RESET:
 216         s->remote_wakeup = 0;
 217         s->addr = 0;
 218         s->state = USB_STATE_DEFAULT;
 219         if (s->info->handle_reset) {
 220             s->info->handle_reset(s);
 221         }
 222         return 0;
 223     }
 224
 225     /* Rest of the PIDs must match our address */
 226     if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr)
 227         return USB_RET_NODEV;
 228
 229     switch (p->pid) {
 230     case USB_TOKEN_SETUP:
 231         return do_token_setup(s, p);
 232
 233     case USB_TOKEN_IN:
 234         return do_token_in(s, p);
 235
 236     case USB_TOKEN_OUT:
 237         return do_token_out(s, p);
 238
 239     default:
 240         return USB_RET_STALL;
 241     }
 242 }
 243
 244 /* XXX: fix overflow */
 245 int set_usb_string(uint8_t *buf, const char *str)
 246 {
 247     int len, i;
 248     uint8_t *q;
 249
 250     q = buf;
 251     len = strlen(str);
 252     *q++ = 2 * len + 2;
 253     *q++ = 3;
 254     for(i = 0; i < len; i++) {
 255         *q++ = str[i];
 256         *q++ = 0;
 257     }
 258     return q - buf;
 259 }
 260
 261 /* Send an internal message to a USB device.  */
 262 void usb_send_msg(USBDevice *dev, int msg)
 263 {
 264     USBPacket p;
 265     memset(&p, 0, sizeof(p));
 266     p.pid = msg;
 267     dev->info->handle_packet(dev, &p);
 268
 269     /* This _must_ be synchronous */
 270 }