[qemu.git] / hw / usb.c

/*
 * QEMU USB emulation
 *
 * Copyright (c) 2005 Fabrice Bellard
 *
 * 2008 Generic packet handler rewrite by Max Krasnyansky
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "qemu-common.h"
#include "usb.h"

void usb_attach(USBPort *port, USBDevice *dev)
{
    if (dev != NULL) {
        /* attach */
        if (port->dev) {
            usb_attach(port, NULL);
        }
        dev->port = port;
        port->dev = dev;
        port->ops->attach(port);
        usb_send_msg(dev, USB_MSG_ATTACH);
    } else {
        /* detach */
        dev = port->dev;
        port->ops->detach(port);
        if (dev) {
            usb_send_msg(dev, USB_MSG_DETACH);
            dev->port = NULL;
            port->dev = NULL;
        }
    }
}

/**********************/

/* generic USB device helpers (you are not forced to use them when
   writing your USB device driver, but they help handling the
   protocol)
*/

#define SETUP_STATE_IDLE 0
#define SETUP_STATE_DATA 1
#define SETUP_STATE_ACK  2

static int do_token_setup(USBDevice *s, USBPacket *p)
{
    int request, value, index;
    int ret = 0;

    if (p->len != 8)
        return USB_RET_STALL;
 
    memcpy(s->setup_buf, p->data, 8);
    s->setup_len   = (s->setup_buf[7] << 8) | s->setup_buf[6];
    s->setup_index = 0;

    request = (s->setup_buf[0] << 8) | s->setup_buf[1];
    value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
    index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
 
    if (s->setup_buf[0] & USB_DIR_IN) {
        ret = s->info->handle_control(s, request, value, index, 
                                      s->setup_len, s->data_buf);
        if (ret < 0)
            return ret;

        if (ret < s->setup_len)
            s->setup_len = ret;
        s->setup_state = SETUP_STATE_DATA;
    } else {
        if (s->setup_len == 0)
            s->setup_state = SETUP_STATE_ACK;
        else
            s->setup_state = SETUP_STATE_DATA;
    }

    return ret;
}

static int do_token_in(USBDevice *s, USBPacket *p)
{
    int request, value, index;
    int ret = 0;

    if (p->devep != 0)
        return s->info->handle_data(s, p);

    request = (s->setup_buf[0] << 8) | s->setup_buf[1];
    value   = (s->setup_buf[3] << 8) | s->setup_buf[2];
    index   = (s->setup_buf[5] << 8) | s->setup_buf[4];
 
    switch(s->setup_state) {
    case SETUP_STATE_ACK:
        if (!(s->setup_buf[0] & USB_DIR_IN)) {
            s->setup_state = SETUP_STATE_IDLE;
            ret = s->info->handle_control(s, request, value, index,
                                          s->setup_len, s->data_buf);
            if (ret > 0)
                return 0;
            return ret;
        }

        /* return 0 byte */
        return 0;

    case SETUP_STATE_DATA:
        if (s->setup_buf[0] & USB_DIR_IN) {
            int len = s->setup_len - s->setup_index;
            if (len > p->len)
                len = p->len;
            memcpy(p->data, s->data_buf + s->setup_index, len);
            s->setup_index += len;
            if (s->setup_index >= s->setup_len)
                s->setup_state = SETUP_STATE_ACK;
            return len;
        }

        s->setup_state = SETUP_STATE_IDLE;
        return USB_RET_STALL;

    default:
        return USB_RET_STALL;
    }
}

static int do_token_out(USBDevice *s, USBPacket *p)
{
    if (p->devep != 0)
        return s->info->handle_data(s, p);

    switch(s->setup_state) {
    case SETUP_STATE_ACK:
        if (s->setup_buf[0] & USB_DIR_IN) {
            s->setup_state = SETUP_STATE_IDLE;
            /* transfer OK */
        } else {
            /* ignore additional output */
        }
        return 0;

    case SETUP_STATE_DATA:
        if (!(s->setup_buf[0] & USB_DIR_IN)) {
            int len = s->setup_len - s->setup_index;
            if (len > p->len)
                len = p->len;
            memcpy(s->data_buf + s->setup_index, p->data, len);
            s->setup_index += len;
            if (s->setup_index >= s->setup_len)
                s->setup_state = SETUP_STATE_ACK;
            return len;
        }

        s->setup_state = SETUP_STATE_IDLE;
        return USB_RET_STALL;

    default:
        return USB_RET_STALL;
    }
}

/*
 * Generic packet handler.
 * Called by the HC (host controller).
 *
 * Returns length of the transaction or one of the USB_RET_XXX codes.
 */
int usb_generic_handle_packet(USBDevice *s, USBPacket *p)
{
    switch(p->pid) {
    case USB_MSG_ATTACH:
        s->state = USB_STATE_ATTACHED;
        return 0;

    case USB_MSG_DETACH:
        s->state = USB_STATE_NOTATTACHED;
        return 0;

    case USB_MSG_RESET:
        s->remote_wakeup = 0;
        s->addr = 0;
        s->state = USB_STATE_DEFAULT;
        s->info->handle_reset(s);
        return 0;
    }

    /* Rest of the PIDs must match our address */
    if (s->state < USB_STATE_DEFAULT || p->devaddr != s->addr)
        return USB_RET_NODEV;

    switch (p->pid) {
    case USB_TOKEN_SETUP:
        return do_token_setup(s, p);

    case USB_TOKEN_IN:
        return do_token_in(s, p);

    case USB_TOKEN_OUT:
        return do_token_out(s, p);
 
    default:
        return USB_RET_STALL;
    }
}

/* XXX: fix overflow */
int set_usb_string(uint8_t *buf, const char *str)
{
    int len, i;
    uint8_t *q;

    q = buf;
    len = strlen(str);
    *q++ = 2 * len + 2;
    *q++ = 3;
    for(i = 0; i < len; i++) {
        *q++ = str[i];
        *q++ = 0;
    }
    return q - buf;
}

/* Send an internal message to a USB device.  */
void usb_send_msg(USBDevice *dev, int msg)
{
    USBPacket p;
    memset(&p, 0, sizeof(p));
    p.pid = msg;
    dev->info->handle_packet(dev, &p);

    /* This _must_ be synchronous */
}
Commit	Line	Data
bb36d470 FB	1	/*
	2	* QEMU USB emulation
	3	*
	4	* Copyright (c) 2005 Fabrice Bellard
5fafdf24	5	*
89b9b79f AL	6	* 2008 Generic packet handler rewrite by Max Krasnyansky
89b9b79f AL	7	*
bb36d470 FB	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	*/
87ecb68b PB	26	#include "qemu-common.h"
87ecb68b PB	27	#include "usb.h"
bb36d470 FB	28
	29	void usb_attach(USBPort port, USBDevice dev)
	30	{
618c169b GH	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	}
bb36d470 FB	50	}
	51
	52	/**********************/
89b9b79f	53
bb36d470 FB	54	/* generic USB device helpers (you are not forced to use them when
bb36d470 FB	55	writing your USB device driver, but they help handling the
5fafdf24	56	protocol)
bb36d470 FB	57	*/
	58
	59	#define SETUP_STATE_IDLE 0
	60	#define SETUP_STATE_DATA 1
	61	#define SETUP_STATE_ACK 2
	62
89b9b79f AL	63	static int do_token_setup(USBDevice s, USBPacket p)
	64	{
	65	int request, value, index;
	66	int ret = 0;
	67
	68	if (p->len != 8)
	69	return USB_RET_STALL;
	70
	71	memcpy(s->setup_buf, p->data, 8);
	72	s->setup_len = (s->setup_buf[7] << 8) \| s->setup_buf[6];
	73	s->setup_index = 0;
	74
	75	request = (s->setup_buf[0] << 8) \| s->setup_buf[1];
	76	value = (s->setup_buf[3] << 8) \| s->setup_buf[2];
	77	index = (s->setup_buf[5] << 8) \| s->setup_buf[4];
	78
	79	if (s->setup_buf[0] & USB_DIR_IN) {
806b6024 GH	80	ret = s->info->handle_control(s, request, value, index,
806b6024 GH	81	s->setup_len, s->data_buf);
89b9b79f AL	82	if (ret < 0)
	83	return ret;
	84
	85	if (ret < s->setup_len)
	86	s->setup_len = ret;
	87	s->setup_state = SETUP_STATE_DATA;
	88	} else {
	89	if (s->setup_len == 0)
	90	s->setup_state = SETUP_STATE_ACK;
	91	else
	92	s->setup_state = SETUP_STATE_DATA;
	93	}
	94
	95	return ret;
	96	}
	97
	98	static int do_token_in(USBDevice s, USBPacket p)
bb36d470	99	{
89b9b79f AL	100	int request, value, index;
	101	int ret = 0;
	102
	103	if (p->devep != 0)
806b6024	104	return s->info->handle_data(s, p);
89b9b79f AL	105
	106	request = (s->setup_buf[0] << 8) \| s->setup_buf[1];
	107	value = (s->setup_buf[3] << 8) \| s->setup_buf[2];
	108	index = (s->setup_buf[5] << 8) \| s->setup_buf[4];
	109
	110	switch(s->setup_state) {
	111	case SETUP_STATE_ACK:
	112	if (!(s->setup_buf[0] & USB_DIR_IN)) {
	113	s->setup_state = SETUP_STATE_IDLE;
806b6024 GH	114	ret = s->info->handle_control(s, request, value, index,
806b6024 GH	115	s->setup_len, s->data_buf);
89b9b79f AL	116	if (ret > 0)
	117	return 0;
	118	return ret;
	119	}
	120
	121	/* return 0 byte */
	122	return 0;
	123
	124	case SETUP_STATE_DATA:
	125	if (s->setup_buf[0] & USB_DIR_IN) {
	126	int len = s->setup_len - s->setup_index;
	127	if (len > p->len)
	128	len = p->len;
	129	memcpy(p->data, s->data_buf + s->setup_index, len);
	130	s->setup_index += len;
	131	if (s->setup_index >= s->setup_len)
	132	s->setup_state = SETUP_STATE_ACK;
	133	return len;
	134	}
	135
	136	s->setup_state = SETUP_STATE_IDLE;
	137	return USB_RET_STALL;
	138
	139	default:
	140	return USB_RET_STALL;
	141	}
	142	}
	143
	144	static int do_token_out(USBDevice s, USBPacket p)
	145	{
	146	if (p->devep != 0)
806b6024	147	return s->info->handle_data(s, p);
89b9b79f AL	148
	149	switch(s->setup_state) {
	150	case SETUP_STATE_ACK:
	151	if (s->setup_buf[0] & USB_DIR_IN) {
	152	s->setup_state = SETUP_STATE_IDLE;
	153	/* transfer OK */
	154	} else {
	155	/* ignore additional output */
	156	}
	157	return 0;
	158
	159	case SETUP_STATE_DATA:
	160	if (!(s->setup_buf[0] & USB_DIR_IN)) {
	161	int len = s->setup_len - s->setup_index;
	162	if (len > p->len)
	163	len = p->len;
	164	memcpy(s->data_buf + s->setup_index, p->data, len);
	165	s->setup_index += len;
	166	if (s->setup_index >= s->setup_len)
	167	s->setup_state = SETUP_STATE_ACK;
	168	return len;
	169	}
	170
	171	s->setup_state = SETUP_STATE_IDLE;
	172	return USB_RET_STALL;
	173
	174	default:
	175	return USB_RET_STALL;
	176	}
	177	}
bb36d470	178
89b9b79f AL	179	/*
	180	* Generic packet handler.
	181	* Called by the HC (host controller).
	182	*
	183	* Returns length of the transaction or one of the USB_RET_XXX codes.
	184	*/
	185	int usb_generic_handle_packet(USBDevice s, USBPacket p)
	186	{
4d611c9a	187	switch(p->pid) {
bb36d470 FB	188	case USB_MSG_ATTACH:
bb36d470 FB	189	s->state = USB_STATE_ATTACHED;
89b9b79f AL	190	return 0;
89b9b79f AL	191
bb36d470 FB	192	case USB_MSG_DETACH:
bb36d470 FB	193	s->state = USB_STATE_NOTATTACHED;
89b9b79f AL	194	return 0;
89b9b79f AL	195
bb36d470 FB	196	case USB_MSG_RESET:
	197	s->remote_wakeup = 0;
	198	s->addr = 0;
	199	s->state = USB_STATE_DEFAULT;
806b6024	200	s->info->handle_reset(s);
89b9b79f AL	201	return 0;
	202	}
	203
	204	/* Rest of the PIDs must match our address */
	205	if (s->state < USB_STATE_DEFAULT \|\| p->devaddr != s->addr)
	206	return USB_RET_NODEV;
	207
	208	switch (p->pid) {
bb36d470	209	case USB_TOKEN_SETUP:
89b9b79f AL	210	return do_token_setup(s, p);
89b9b79f AL	211
bb36d470	212	case USB_TOKEN_IN:
89b9b79f AL	213	return do_token_in(s, p);
89b9b79f AL	214
bb36d470	215	case USB_TOKEN_OUT:
89b9b79f AL	216	return do_token_out(s, p);
89b9b79f AL	217
bb36d470	218	default:
89b9b79f	219	return USB_RET_STALL;
bb36d470	220	}
bb36d470 FB	221	}
	222
	223	/* XXX: fix overflow */
	224	int set_usb_string(uint8_t buf, const char str)
	225	{
	226	int len, i;
	227	uint8_t *q;
	228
	229	q = buf;
	230	len = strlen(str);
ce5c37c2	231	q++ = 2 len + 2;
bb36d470 FB	232	*q++ = 3;
	233	for(i = 0; i < len; i++) {
	234	*q++ = str[i];
	235	*q++ = 0;
	236	}
	237	return q - buf;
	238	}
4d611c9a PB	239
	240	/* Send an internal message to a USB device. */
	241	void usb_send_msg(USBDevice *dev, int msg)
	242	{
	243	USBPacket p;
	244	memset(&p, 0, sizeof(p));
	245	p.pid = msg;
806b6024	246	dev->info->handle_packet(dev, &p);
4d611c9a	247
89b9b79f AL	248	/* This _must_ be synchronous */
89b9b79f AL	249	}