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 #include "iov.h"
  29
  30 void usb_attach(USBPort *port)
  31 {
  32     USBDevice *dev = port->dev;
  33
  34     assert(dev != NULL);
  35     assert(dev->attached);
  36     port->ops->attach(port);
  37     usb_send_msg(dev, USB_MSG_ATTACH);
  38 }
  39
  40 void usb_detach(USBPort *port)
  41 {
  42     USBDevice *dev = port->dev;
  43
  44     assert(dev != NULL);
  45     port->ops->detach(port);
  46     usb_send_msg(dev, USB_MSG_DETACH);
  47 }
  48
  49 void usb_wakeup(USBDevice *dev)
  50 {
  51     if (dev->remote_wakeup && dev->port && dev->port->ops->wakeup) {
  52         dev->port->ops->wakeup(dev->port);
  53     }
  54 }
  55
  56 /**********************/
  57
  58 /* generic USB device helpers (you are not forced to use them when
  59    writing your USB device driver, but they help handling the
  60    protocol)
  61 */
  62
  63 #define SETUP_STATE_IDLE  0
  64 #define SETUP_STATE_SETUP 1
  65 #define SETUP_STATE_DATA  2
  66 #define SETUP_STATE_ACK   3
  67
  68 static int do_token_setup(USBDevice *s, USBPacket *p)
  69 {
  70     int request, value, index;
  71     int ret = 0;
  72
  73     if (p->iov.size != 8) {
  74         return USB_RET_STALL;
  75     }
  76
  77     usb_packet_copy(p, s->setup_buf, p->iov.size);
  78     s->setup_len   = (s->setup_buf[7] << 8) | s->setup_buf[6];
  79     s->setup_index = 0;
  80
  81     request = (s->setup_buf[0] << 8) | s->setup_buf[1];
  82     value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
  83     index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
  84
  85     if (s->setup_buf[0] & USB_DIR_IN) {
  86         ret = s->info->handle_control(s, p, request, value, index,
  87                                       s->setup_len, s->data_buf);
  88         if (ret == USB_RET_ASYNC) {
  89              s->setup_state = SETUP_STATE_SETUP;
  90              return USB_RET_ASYNC;
  91         }
  92         if (ret < 0)
  93             return ret;
  94
  95         if (ret < s->setup_len)
  96             s->setup_len = ret;
  97         s->setup_state = SETUP_STATE_DATA;
  98     } else {
  99         if (s->setup_len > sizeof(s->data_buf)) {
 100             fprintf(stderr,
 101                 "usb_generic_handle_packet: ctrl buffer too small (%d > %zu)\n",
 102                 s->setup_len, sizeof(s->data_buf));
 103             return USB_RET_STALL;
 104         }
 105         if (s->setup_len == 0)
 106             s->setup_state = SETUP_STATE_ACK;
 107         else
 108             s->setup_state = SETUP_STATE_DATA;
 109     }
 110
 111     return ret;
 112 }
 113
 114 static int do_token_in(USBDevice *s, USBPacket *p)
 115 {
 116     int request, value, index;
 117     int ret = 0;
 118
 119     if (p->devep != 0)
 120         return s->info->handle_data(s, p);
 121
 122     request = (s->setup_buf[0] << 8) | s->setup_buf[1];
 123     value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
 124     index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
 125
 126     switch(s->setup_state) {
 127     case SETUP_STATE_ACK:
 128         if (!(s->setup_buf[0] & USB_DIR_IN)) {
 129             ret = s->info->handle_control(s, p, request, value, index,
 130                                           s->setup_len, s->data_buf);
 131             if (ret == USB_RET_ASYNC) {
 132                 return USB_RET_ASYNC;
 133             }
 134             s->setup_state = SETUP_STATE_IDLE;
 135             if (ret > 0)
 136                 return 0;
 137             return ret;
 138         }
 139
 140         /* return 0 byte */
 141         return 0;
 142
 143     case SETUP_STATE_DATA:
 144         if (s->setup_buf[0] & USB_DIR_IN) {
 145             int len = s->setup_len - s->setup_index;
 146             if (len > p->iov.size) {
 147                 len = p->iov.size;
 148             }
 149             usb_packet_copy(p, s->data_buf + s->setup_index, len);
 150             s->setup_index += len;
 151             if (s->setup_index >= s->setup_len)
 152                 s->setup_state = SETUP_STATE_ACK;
 153             return len;
 154         }
 155
 156         s->setup_state = SETUP_STATE_IDLE;
 157         return USB_RET_STALL;
 158
 159     default:
 160         return USB_RET_STALL;
 161     }
 162 }
 163
 164 static int do_token_out(USBDevice *s, USBPacket *p)
 165 {
 166     if (p->devep != 0)
 167         return s->info->handle_data(s, p);
 168
 169     switch(s->setup_state) {
 170     case SETUP_STATE_ACK:
 171         if (s->setup_buf[0] & USB_DIR_IN) {
 172             s->setup_state = SETUP_STATE_IDLE;
 173             /* transfer OK */
 174         } else {
 175             /* ignore additional output */
 176         }
 177         return 0;
 178
 179     case SETUP_STATE_DATA:
 180         if (!(s->setup_buf[0] & USB_DIR_IN)) {
 181             int len = s->setup_len - s->setup_index;
 182             if (len > p->iov.size) {
 183                 len = p->iov.size;
 184             }
 185             usb_packet_copy(p, s->data_buf + s->setup_index, len);
 186             s->setup_index += len;
 187             if (s->setup_index >= s->setup_len)
 188                 s->setup_state = SETUP_STATE_ACK;
 189             return len;
 190         }
 191
 192         s->setup_state = SETUP_STATE_IDLE;
 193         return USB_RET_STALL;
 194
 195     default:
 196         return USB_RET_STALL;
 197     }
 198 }
 199
 200 /*
 201  * Generic packet handler.
 202  * Called by the HC (host controller).
 203  *
 204  * Returns length of the transaction or one of the USB_RET_XXX codes.
 205  */
 206 int usb_generic_handle_packet(USBDevice *s, USBPacket *p)
 207 {
 208     switch(p->pid) {
 209     case USB_MSG_ATTACH:
 210         s->state = USB_STATE_ATTACHED;
 211         if (s->info->handle_attach) {
 212             s->info->handle_attach(s);
 213         }
 214         return 0;
 215
 216     case USB_MSG_DETACH:
 217         s->state = USB_STATE_NOTATTACHED;
 218         return 0;
 219
 220     case USB_MSG_RESET:
 221         s->remote_wakeup = 0;
 222         s->addr = 0;
 223         s->state = USB_STATE_DEFAULT;
 224         if (s->info->handle_reset) {
 225             s->info->handle_reset(s);
 226         }
 227         return 0;
 228     }
 229
 230     /* Rest of the PIDs must match our address */
 231     if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr)
 232         return USB_RET_NODEV;
 233
 234     switch (p->pid) {
 235     case USB_TOKEN_SETUP:
 236         return do_token_setup(s, p);
 237
 238     case USB_TOKEN_IN:
 239         return do_token_in(s, p);
 240
 241     case USB_TOKEN_OUT:
 242         return do_token_out(s, p);
 243
 244     default:
 245         return USB_RET_STALL;
 246     }
 247 }
 248
 249 /* ctrl complete function for devices which use usb_generic_handle_packet and
 250    may return USB_RET_ASYNC from their handle_control callback. Device code
 251    which does this *must* call this function instead of the normal
 252    usb_packet_complete to complete their async control packets. */
 253 void usb_generic_async_ctrl_complete(USBDevice *s, USBPacket *p)
 254 {
 255     if (p->result < 0) {
 256         s->setup_state = SETUP_STATE_IDLE;
 257     }
 258
 259     switch (s->setup_state) {
 260     case SETUP_STATE_SETUP:
 261         if (p->result < s->setup_len) {
 262             s->setup_len = p->result;
 263         }
 264         s->setup_state = SETUP_STATE_DATA;
 265         p->result = 8;
 266         break;
 267
 268     case SETUP_STATE_ACK:
 269         s->setup_state = SETUP_STATE_IDLE;
 270         p->result = 0;
 271         break;
 272
 273     default:
 274         break;
 275     }
 276     usb_packet_complete(s, p);
 277 }
 278
 279 /* XXX: fix overflow */
 280 int set_usb_string(uint8_t *buf, const char *str)
 281 {
 282     int len, i;
 283     uint8_t *q;
 284
 285     q = buf;
 286     len = strlen(str);
 287     *q++ = 2 * len + 2;
 288     *q++ = 3;
 289     for(i = 0; i < len; i++) {
 290         *q++ = str[i];
 291         *q++ = 0;
 292     }
 293     return q - buf;
 294 }
 295
 296 /* Send an internal message to a USB device.  */
 297 void usb_send_msg(USBDevice *dev, int msg)
 298 {
 299     USBPacket p;
 300     int ret;
 301
 302     memset(&p, 0, sizeof(p));
 303     p.pid = msg;
 304     ret = usb_handle_packet(dev, &p);
 305     /* This _must_ be synchronous */
 306     assert(ret != USB_RET_ASYNC);
 307 }
 308
 309 /* Hand over a packet to a device for processing.  Return value
 310    USB_RET_ASYNC indicates the processing isn't finished yet, the
 311    driver will call usb_packet_complete() when done processing it. */
 312 int usb_handle_packet(USBDevice *dev, USBPacket *p)
 313 {
 314     int ret;
 315
 316     assert(p->owner == NULL);
 317     ret = dev->info->handle_packet(dev, p);
 318     if (ret == USB_RET_ASYNC) {
 319         if (p->owner == NULL) {
 320             p->owner = dev;
 321         } else {
 322             /* We'll end up here when usb_handle_packet is called
 323              * recursively due to a hub being in the chain.  Nothing
 324              * to do.  Leave p->owner pointing to the device, not the
 325              * hub. */;
 326         }
 327     }
 328     return ret;
 329 }
 330
 331 /* Notify the controller that an async packet is complete.  This should only
 332    be called for packets previously deferred by returning USB_RET_ASYNC from
 333    handle_packet. */
 334 void usb_packet_complete(USBDevice *dev, USBPacket *p)
 335 {
 336     /* Note: p->owner != dev is possible in case dev is a hub */
 337     assert(p->owner != NULL);
 338     p->owner = NULL;
 339     dev->port->ops->complete(dev->port, p);
 340 }
 341
 342 /* Cancel an active packet.  The packed must have been deferred by
 343    returning USB_RET_ASYNC from handle_packet, and not yet
 344    completed.  */
 345 void usb_cancel_packet(USBPacket * p)
 346 {
 347     assert(p->owner != NULL);
 348     p->owner->info->cancel_packet(p->owner, p);
 349     p->owner = NULL;
 350 }
 351
 352
 353 void usb_packet_init(USBPacket *p)
 354 {
 355     qemu_iovec_init(&p->iov, 1);
 356 }
 357
 358 void usb_packet_setup(USBPacket *p, int pid, uint8_t addr, uint8_t ep)
 359 {
 360     p->pid = pid;
 361     p->devaddr = addr;
 362     p->devep = ep;
 363     p->result = 0;
 364     qemu_iovec_reset(&p->iov);
 365 }
 366
 367 void usb_packet_addbuf(USBPacket *p, void *ptr, size_t len)
 368 {
 369     qemu_iovec_add(&p->iov, ptr, len);
 370 }
 371
 372 void usb_packet_copy(USBPacket *p, void *ptr, size_t bytes)
 373 {
 374     assert(p->result >= 0);
 375     assert(p->result + bytes <= p->iov.size);
 376     switch (p->pid) {
 377     case USB_TOKEN_SETUP:
 378     case USB_TOKEN_OUT:
 379         iov_to_buf(p->iov.iov, p->iov.niov, ptr, p->result, bytes);
 380         break;
 381     case USB_TOKEN_IN:
 382         iov_from_buf(p->iov.iov, p->iov.niov, ptr, p->result, bytes);
 383         break;
 384     default:
 385         fprintf(stderr, "%s: invalid pid: %x\n", __func__, p->pid);
 386         abort();
 387     }
 388     p->result += bytes;
 389 }
 390
 391 void usb_packet_skip(USBPacket *p, size_t bytes)
 392 {
 393     assert(p->result >= 0);
 394     assert(p->result + bytes <= p->iov.size);
 395     if (p->pid == USB_TOKEN_IN) {
 396         iov_clear(p->iov.iov, p->iov.niov, p->result, bytes);
 397     }
 398     p->result += bytes;
 399 }
 400
 401 void usb_packet_cleanup(USBPacket *p)
 402 {
 403     qemu_iovec_destroy(&p->iov);
 404 }