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     port->attach(port, dev);

    32 }

    33 

    34 /**********************/

    35 

    36 /* generic USB device helpers (you are not forced to use them when

    37    writing your USB device driver, but they help handling the

    38    protocol)

    39 */

    40 

    41 #define SETUP_STATE_IDLE 0

    42 #define SETUP_STATE_DATA 1

    43 #define SETUP_STATE_ACK  2

    44 

    45 static int do_token_setup(USBDevice *s, USBPacket *p)

    46 {

    47     int request, value, index;

    48     int ret = 0;

    49 

    50     if (p->len != 8)

    51         return USB_RET_STALL;

    52  

    53     memcpy(s->setup_buf, p->data, 8);

    54     s->setup_len   = (s->setup_buf[7] << 8) | s->setup_buf[6];

    55     s->setup_index = 0;

    56 

    57     request = (s->setup_buf[0] << 8) | s->setup_buf[1];

    58     value   = (s->setup_buf[3] << 8) | s->setup_buf[2];

    59     index   = (s->setup_buf[5] << 8) | s->setup_buf[4];

    60  

    61     if (s->setup_buf[0] & USB_DIR_IN) {

    62         ret = s->handle_control(s, request, value, index, 

    63                                 s->setup_len, s->data_buf);

    64         if (ret < 0)

    65             return ret;

    66 

    67         if (ret < s->setup_len)

    68             s->setup_len = ret;

    69         s->setup_state = SETUP_STATE_DATA;

    70     } else {

    71         if (s->setup_len == 0)

    72             s->setup_state = SETUP_STATE_ACK;

    73         else

    74             s->setup_state = SETUP_STATE_DATA;

    75     }

    76 

    77     return ret;

    78 }

    79 

    80 static int do_token_in(USBDevice *s, USBPacket *p)

    81 {

    82     int request, value, index;

    83     int ret = 0;

    84 

    85     if (p->devep != 0)

    86         return s->handle_data(s, p);

    87 

    88     request = (s->setup_buf[0] << 8) | s->setup_buf[1];

    89     value   = (s->setup_buf[3] << 8) | s->setup_buf[2];

    90     index   = (s->setup_buf[5] << 8) | s->setup_buf[4];

    91  

    92     switch(s->setup_state) {

    93     case SETUP_STATE_ACK:

    94         if (!(s->setup_buf[0] & USB_DIR_IN)) {

    95             s->setup_state = SETUP_STATE_IDLE;

    96             ret = s->handle_control(s, request, value, index,

    97                                     s->setup_len, s->data_buf);

    98             if (ret > 0)

    99                 return 0;

   100             return ret;

   101         }

   102 

   103         /* return 0 byte */

   104         return 0;

   105 

   106     case SETUP_STATE_DATA:

   107         if (s->setup_buf[0] & USB_DIR_IN) {

   108             int len = s->setup_len - s->setup_index;

   109             if (len > p->len)

   110                 len = p->len;

   111             memcpy(p->data, s->data_buf + s->setup_index, len);

   112             s->setup_index += len;

   113             if (s->setup_index >= s->setup_len)

   114                 s->setup_state = SETUP_STATE_ACK;

   115             return len;

   116         }

   117 

   118         s->setup_state = SETUP_STATE_IDLE;

   119         return USB_RET_STALL;

   120 

   121     default:

   122         return USB_RET_STALL;

   123     }

   124 }

   125 

   126 static int do_token_out(USBDevice *s, USBPacket *p)

   127 {

   128     if (p->devep != 0)

   129         return s->handle_data(s, p);

   130 

   131     switch(s->setup_state) {

   132     case SETUP_STATE_ACK:

   133         if (s->setup_buf[0] & USB_DIR_IN) {

   134             s->setup_state = SETUP_STATE_IDLE;

   135             /* transfer OK */

   136         } else {

   137             /* ignore additional output */

   138         }

   139         return 0;

   140 

   141     case SETUP_STATE_DATA:

   142         if (!(s->setup_buf[0] & USB_DIR_IN)) {

   143             int len = s->setup_len - s->setup_index;

   144             if (len > p->len)

   145                 len = p->len;

   146             memcpy(s->data_buf + s->setup_index, p->data, len);

   147             s->setup_index += len;

   148             if (s->setup_index >= s->setup_len)

   149                 s->setup_state = SETUP_STATE_ACK;

   150             return len;

   151         }

   152 

   153         s->setup_state = SETUP_STATE_IDLE;

   154         return USB_RET_STALL;

   155 

   156     default:

   157         return USB_RET_STALL;

   158     }

   159 }

   160 

   161 /*

   162  * Generic packet handler.

   163  * Called by the HC (host controller).

   164  *

   165  * Returns length of the transaction or one of the USB_RET_XXX codes.

   166  */

   167 int usb_generic_handle_packet(USBDevice *s, USBPacket *p)

   168 {

   169     switch(p->pid) {

   170     case USB_MSG_ATTACH:

   171         s->state = USB_STATE_ATTACHED;

   172         return 0;

   173 

   174     case USB_MSG_DETACH:

   175         s->state = USB_STATE_NOTATTACHED;

   176         return 0;

   177 

   178     case USB_MSG_RESET:

   179         s->remote_wakeup = 0;

   180         s->addr = 0;

   181         s->state = USB_STATE_DEFAULT;

   182         s->handle_reset(s);

   183         return 0;

   184     }

   185 

   186     /* Rest of the PIDs must match our address */

   187     if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr)

   188         return USB_RET_NODEV;

   189 

   190     switch (p->pid) {

   191     case USB_TOKEN_SETUP:

   192         return do_token_setup(s, p);

   193 

   194     case USB_TOKEN_IN:

   195         return do_token_in(s, p);

   196 

   197     case USB_TOKEN_OUT:

   198         return do_token_out(s, p);

   199  

   200     default:

   201         return USB_RET_STALL;

   202     }

   203 }

   204 

   205 /* XXX: fix overflow */

   206 int set_usb_string(uint8_t *buf, const char *str)

   207 {

   208     int len, i;

   209     uint8_t *q;

   210 

   211     q = buf;

   212     len = strlen(str);

   213     *q++ = 2 * len + 2;

   214     *q++ = 3;

   215     for(i = 0; i < len; i++) {

   216         *q++ = str[i];

   217         *q++ = 0;

   218     }

   219     return q - buf;

   220 }

   221 

   222 /* Send an internal message to a USB device.  */

   223 void usb_send_msg(USBDevice *dev, int msg)

   224 {

   225     USBPacket p;

   226     memset(&p, 0, sizeof(p));

   227     p.pid = msg;

   228     dev->handle_packet(dev, &p);

   229 

   230     /* This _must_ be synchronous */

   231 }