[qemu.git] / hw / usb-hid.c

/*
 * QEMU USB HID devices
 * 
 * Copyright (c) 2005 Fabrice Bellard
 * 
 * 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 "vl.h"

/* HID interface requests */
#define GET_REPORT   0xa101
#define GET_IDLE     0xa102
#define GET_PROTOCOL 0xa103
#define SET_IDLE     0x210a
#define SET_PROTOCOL 0x210b

#define USB_MOUSE  1
#define USB_TABLET 2

typedef struct USBMouseState {
    USBDevice dev;
    int dx, dy, dz, buttons_state;
    int x, y;
    int kind;
    int mouse_grabbed;
} USBMouseState;

/* mostly the same values as the Bochs USB Mouse device */
static const uint8_t qemu_mouse_dev_descriptor[] = {
	0x12,       /*  u8 bLength; */
	0x01,       /*  u8 bDescriptorType; Device */
	0x10, 0x00, /*  u16 bcdUSB; v1.0 */

	0x00,	    /*  u8  bDeviceClass; */
	0x00,	    /*  u8  bDeviceSubClass; */
	0x00,       /*  u8  bDeviceProtocol; [ low/full speeds only ] */
	0x08,       /*  u8  bMaxPacketSize0; 8 Bytes */

	0x27, 0x06, /*  u16 idVendor; */
 	0x01, 0x00, /*  u16 idProduct; */
	0x00, 0x00, /*  u16 bcdDevice */

	0x03,       /*  u8  iManufacturer; */
	0x02,       /*  u8  iProduct; */
	0x01,       /*  u8  iSerialNumber; */
	0x01        /*  u8  bNumConfigurations; */
};

static const uint8_t qemu_mouse_config_descriptor[] = {
	/* one configuration */
	0x09,       /*  u8  bLength; */
	0x02,       /*  u8  bDescriptorType; Configuration */
	0x22, 0x00, /*  u16 wTotalLength; */
	0x01,       /*  u8  bNumInterfaces; (1) */
	0x01,       /*  u8  bConfigurationValue; */
	0x04,       /*  u8  iConfiguration; */
	0xa0,       /*  u8  bmAttributes; 
				 Bit 7: must be set,
				     6: Self-powered,
				     5: Remote wakeup,
				     4..0: resvd */
	50,         /*  u8  MaxPower; */
      
	/* USB 1.1:
	 * USB 2.0, single TT organization (mandatory):
	 *	one interface, protocol 0
	 *
	 * USB 2.0, multiple TT organization (optional):
	 *	two interfaces, protocols 1 (like single TT)
	 *	and 2 (multiple TT mode) ... config is
	 *	sometimes settable
	 *	NOT IMPLEMENTED
	 */

	/* one interface */
	0x09,       /*  u8  if_bLength; */
	0x04,       /*  u8  if_bDescriptorType; Interface */
	0x00,       /*  u8  if_bInterfaceNumber; */
	0x00,       /*  u8  if_bAlternateSetting; */
	0x01,       /*  u8  if_bNumEndpoints; */
	0x03,       /*  u8  if_bInterfaceClass; */
	0x01,       /*  u8  if_bInterfaceSubClass; */
	0x02,       /*  u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
	0x05,       /*  u8  if_iInterface; */
     
        /* HID descriptor */
        0x09,        /*  u8  bLength; */
        0x21,        /*  u8 bDescriptorType; */
        0x01, 0x00,  /*  u16 HID_class */
        0x00,        /*  u8 country_code */
        0x01,        /*  u8 num_descriptors */
        0x22,        /*  u8 type; Report */
        50, 0,       /*  u16 len */

	/* one endpoint (status change endpoint) */
	0x07,       /*  u8  ep_bLength; */
	0x05,       /*  u8  ep_bDescriptorType; Endpoint */
	0x81,       /*  u8  ep_bEndpointAddress; IN Endpoint 1 */
 	0x03,       /*  u8  ep_bmAttributes; Interrupt */
 	0x03, 0x00, /*  u16 ep_wMaxPacketSize; */
	0x0a,       /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
};

static const uint8_t qemu_tablet_config_descriptor[] = {
	/* one configuration */
	0x09,       /*  u8  bLength; */
	0x02,       /*  u8  bDescriptorType; Configuration */
	0x22, 0x00, /*  u16 wTotalLength; */
	0x01,       /*  u8  bNumInterfaces; (1) */
	0x01,       /*  u8  bConfigurationValue; */
	0x04,       /*  u8  iConfiguration; */
	0xa0,       /*  u8  bmAttributes; 
				 Bit 7: must be set,
				     6: Self-powered,
				     5: Remote wakeup,
				     4..0: resvd */
	50,         /*  u8  MaxPower; */
      
	/* USB 1.1:
	 * USB 2.0, single TT organization (mandatory):
	 *	one interface, protocol 0
	 *
	 * USB 2.0, multiple TT organization (optional):
	 *	two interfaces, protocols 1 (like single TT)
	 *	and 2 (multiple TT mode) ... config is
	 *	sometimes settable
	 *	NOT IMPLEMENTED
	 */

	/* one interface */
	0x09,       /*  u8  if_bLength; */
	0x04,       /*  u8  if_bDescriptorType; Interface */
	0x00,       /*  u8  if_bInterfaceNumber; */
	0x00,       /*  u8  if_bAlternateSetting; */
	0x01,       /*  u8  if_bNumEndpoints; */
	0x03,       /*  u8  if_bInterfaceClass; */
	0x01,       /*  u8  if_bInterfaceSubClass; */
	0x02,       /*  u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
	0x05,       /*  u8  if_iInterface; */

        /* HID descriptor */
        0x09,        /*  u8  bLength; */
        0x21,        /*  u8 bDescriptorType; */
        0x01, 0x00,  /*  u16 HID_class */
        0x00,        /*  u8 country_code */
        0x01,        /*  u8 num_descriptors */
        0x22,        /*  u8 type; Report */
        74, 0,       /*  u16 len */

	/* one endpoint (status change endpoint) */
	0x07,       /*  u8  ep_bLength; */
	0x05,       /*  u8  ep_bDescriptorType; Endpoint */
	0x81,       /*  u8  ep_bEndpointAddress; IN Endpoint 1 */
 	0x03,       /*  u8  ep_bmAttributes; Interrupt */
 	0x08, 0x00, /*  u16 ep_wMaxPacketSize; */
	0x03,       /*  u8  ep_bInterval; (255ms -- usb 2.0 spec) */
};

static const uint8_t qemu_mouse_hid_report_descriptor[] = {
    0x05, 0x01, 0x09, 0x02, 0xA1, 0x01, 0x09, 0x01, 
    0xA1, 0x00, 0x05, 0x09, 0x19, 0x01, 0x29, 0x03,
    0x15, 0x00, 0x25, 0x01, 0x95, 0x03, 0x75, 0x01, 
    0x81, 0x02, 0x95, 0x01, 0x75, 0x05, 0x81, 0x01,
    0x05, 0x01, 0x09, 0x30, 0x09, 0x31, 0x15, 0x81, 
    0x25, 0x7F, 0x75, 0x08, 0x95, 0x02, 0x81, 0x06,
    0xC0, 0xC0,
};

static const uint8_t qemu_tablet_hid_report_descriptor[] = {
        0x05, 0x01, /* Usage Page Generic Desktop */
        0x09, 0x01, /* Usage Mouse */
        0xA1, 0x01, /* Collection Application */
        0x09, 0x01, /* Usage Pointer */
        0xA1, 0x00, /* Collection Physical */
        0x05, 0x09, /* Usage Page Button */
        0x19, 0x01, /* Usage Minimum Button 1 */
        0x29, 0x03, /* Usage Maximum Button 3 */
        0x15, 0x00, /* Logical Minimum 0 */
        0x25, 0x01, /* Logical Maximum 1 */
        0x95, 0x03, /* Report Count 3 */
        0x75, 0x01, /* Report Size 1 */
        0x81, 0x02, /* Input (Data, Var, Abs) */
        0x95, 0x01, /* Report Count 1 */
        0x75, 0x05, /* Report Size 5 */
        0x81, 0x01, /* Input (Cnst, Var, Abs) */
        0x05, 0x01, /* Usage Page Generic Desktop */
        0x09, 0x30, /* Usage X */
        0x09, 0x31, /* Usage Y */
        0x15, 0x00, /* Logical Minimum 0 */
        0x26, 0xFF, 0x7F, /* Logical Maximum 0x7fff */
        0x35, 0x00, /* Physical Minimum 0 */
        0x46, 0xFE, 0x7F, /* Physical Maximum 0x7fff */
        0x75, 0x10, /* Report Size 16 */
        0x95, 0x02, /* Report Count 2 */
        0x81, 0x02, /* Input (Data, Var, Abs) */
        0x05, 0x01, /* Usage Page Generic Desktop */
        0x09, 0x38, /* Usage Wheel */
        0x15, 0x81, /* Logical Minimum -127 */
        0x25, 0x7F, /* Logical Maximum 127 */
        0x35, 0x00, /* Physical Minimum 0 (same as logical) */
        0x45, 0x00, /* Physical Maximum 0 (same as logical) */
        0x75, 0x08, /* Report Size 8 */
        0x95, 0x01, /* Report Count 1 */
        0x81, 0x02, /* Input (Data, Var, Rel) */
        0xC0,       /* End Collection */
        0xC0,       /* End Collection */
};

static void usb_mouse_event(void *opaque,
                            int dx1, int dy1, int dz1, int buttons_state)
{
    USBMouseState *s = opaque;

    s->dx += dx1;
    s->dy += dy1;
    s->dz += dz1;
    s->buttons_state = buttons_state;
}

static void usb_tablet_event(void *opaque,
			     int x, int y, int dz, int buttons_state)
{
    USBMouseState *s = opaque;

    s->x = x;
    s->y = y;
    s->dz += dz;
    s->buttons_state = buttons_state;
}

static inline int int_clamp(int val, int vmin, int vmax)
{
    if (val < vmin)
        return vmin;
    else if (val > vmax)
        return vmax;
    else
        return val;
}

static int usb_mouse_poll(USBMouseState *s, uint8_t *buf, int len)
{
    int dx, dy, dz, b, l;

    if (!s->mouse_grabbed) {
	qemu_add_mouse_event_handler(usb_mouse_event, s, 0);
	s->mouse_grabbed = 1;
    }
    
    dx = int_clamp(s->dx, -128, 127);
    dy = int_clamp(s->dy, -128, 127);
    dz = int_clamp(s->dz, -128, 127);

    s->dx -= dx;
    s->dy -= dy;
    s->dz -= dz;
    
    b = 0;
    if (s->buttons_state & MOUSE_EVENT_LBUTTON)
        b |= 0x01;
    if (s->buttons_state & MOUSE_EVENT_RBUTTON)
        b |= 0x02;
    if (s->buttons_state & MOUSE_EVENT_MBUTTON)
        b |= 0x04;
    
    buf[0] = b;
    buf[1] = dx;
    buf[2] = dy;
    l = 3;
    if (len >= 4) {
        buf[3] = dz;
        l = 4;
    }
    return l;
}

static int usb_tablet_poll(USBMouseState *s, uint8_t *buf, int len)
{
    int dz, b, l;

    if (!s->mouse_grabbed) {
	qemu_add_mouse_event_handler(usb_tablet_event, s, 1);
	s->mouse_grabbed = 1;
    }
    
    dz = int_clamp(s->dz, -128, 127);
    s->dz -= dz;

    /* Appears we have to invert the wheel direction */
    dz = 0 - dz;
    b = 0;
    if (s->buttons_state & MOUSE_EVENT_LBUTTON)
        b |= 0x01;
    if (s->buttons_state & MOUSE_EVENT_RBUTTON)
        b |= 0x02;
    if (s->buttons_state & MOUSE_EVENT_MBUTTON)
        b |= 0x04;

    buf[0] = b;
    buf[1] = s->x & 0xff;
    buf[2] = s->x >> 8;
    buf[3] = s->y & 0xff;
    buf[4] = s->y >> 8;
    buf[5] = dz;
    l = 6;

    return l;
}

static void usb_mouse_handle_reset(USBDevice *dev)
{
    USBMouseState *s = (USBMouseState *)dev;

    s->dx = 0;
    s->dy = 0;
    s->dz = 0;
    s->x = 0;
    s->y = 0;
    s->buttons_state = 0;
}

static int usb_mouse_handle_control(USBDevice *dev, int request, int value,
                                  int index, int length, uint8_t *data)
{
    USBMouseState *s = (USBMouseState *)dev;
    int ret = 0;

    switch(request) {
    case DeviceRequest | USB_REQ_GET_STATUS:
        data[0] = (1 << USB_DEVICE_SELF_POWERED) |
            (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
        data[1] = 0x00;
        ret = 2;
        break;
    case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
        if (value == USB_DEVICE_REMOTE_WAKEUP) {
            dev->remote_wakeup = 0;
        } else {
            goto fail;
        }
        ret = 0;
        break;
    case DeviceOutRequest | USB_REQ_SET_FEATURE:
        if (value == USB_DEVICE_REMOTE_WAKEUP) {
            dev->remote_wakeup = 1;
        } else {
            goto fail;
        }
        ret = 0;
        break;
    case DeviceOutRequest | USB_REQ_SET_ADDRESS:
        dev->addr = value;
        ret = 0;
        break;
    case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
        switch(value >> 8) {
        case USB_DT_DEVICE:
            memcpy(data, qemu_mouse_dev_descriptor, 
                   sizeof(qemu_mouse_dev_descriptor));
            ret = sizeof(qemu_mouse_dev_descriptor);
            break;
        case USB_DT_CONFIG:
	    if (s->kind == USB_MOUSE) {
		memcpy(data, qemu_mouse_config_descriptor, 
		       sizeof(qemu_mouse_config_descriptor));
		ret = sizeof(qemu_mouse_config_descriptor);
	    } else if (s->kind == USB_TABLET) {
		memcpy(data, qemu_tablet_config_descriptor, 
		       sizeof(qemu_tablet_config_descriptor));
		ret = sizeof(qemu_tablet_config_descriptor);
	    }		
            break;
        case USB_DT_STRING:
            switch(value & 0xff) {
            case 0:
                /* language ids */
                data[0] = 4;
                data[1] = 3;
                data[2] = 0x09;
                data[3] = 0x04;
                ret = 4;
                break;
            case 1:
                /* serial number */
                ret = set_usb_string(data, "1");
                break;
            case 2:
                /* product description */
		if (s->kind == USB_MOUSE)
		    ret = set_usb_string(data, "QEMU USB Mouse");
		else if (s->kind == USB_TABLET)
		    ret = set_usb_string(data, "QEMU USB Tablet");
                break;
            case 3:
                /* vendor description */
                ret = set_usb_string(data, "QEMU " QEMU_VERSION);
                break;
            case 4:
                ret = set_usb_string(data, "HID Mouse");
                break;
            case 5:
                ret = set_usb_string(data, "Endpoint1 Interrupt Pipe");
                break;
            default:
                goto fail;
            }
            break;
        default:
            goto fail;
        }
        break;
    case DeviceRequest | USB_REQ_GET_CONFIGURATION:
        data[0] = 1;
        ret = 1;
        break;
    case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
        ret = 0;
        break;
    case DeviceRequest | USB_REQ_GET_INTERFACE:
        data[0] = 0;
        ret = 1;
        break;
    case DeviceOutRequest | USB_REQ_SET_INTERFACE:
        ret = 0;
        break;
        /* hid specific requests */
    case InterfaceRequest | USB_REQ_GET_DESCRIPTOR:
        switch(value >> 8) {
        case 0x22:
	    if (s->kind == USB_MOUSE) {
		memcpy(data, qemu_mouse_hid_report_descriptor, 
		       sizeof(qemu_mouse_hid_report_descriptor));
		ret = sizeof(qemu_mouse_hid_report_descriptor);
	    } else if (s->kind == USB_TABLET) {
		memcpy(data, qemu_tablet_hid_report_descriptor, 
		       sizeof(qemu_tablet_hid_report_descriptor));
		ret = sizeof(qemu_tablet_hid_report_descriptor);
	    }
	    break;
        default:
            goto fail;
        }
        break;
    case GET_REPORT:
	if (s->kind == USB_MOUSE)
	    ret = usb_mouse_poll(s, data, length);
	else if (s->kind == USB_TABLET)
	    ret = usb_tablet_poll(s, data, length);
        break;
    case SET_IDLE:
        ret = 0;
        break;
    default:
    fail:
        ret = USB_RET_STALL;
        break;
    }
    return ret;
}

static int usb_mouse_handle_data(USBDevice *dev, USBPacket *p)
{
    USBMouseState *s = (USBMouseState *)dev;
    int ret = 0;

    switch(p->pid) {
    case USB_TOKEN_IN:
        if (p->devep == 1) {
	    if (s->kind == USB_MOUSE)
		ret = usb_mouse_poll(s, p->data, p->len);
	    else if (s->kind == USB_TABLET)
		ret = usb_tablet_poll(s, p->data, p->len);
        } else {
            goto fail;
        }
        break;
    case USB_TOKEN_OUT:
    default:
    fail:
        ret = USB_RET_STALL;
        break;
    }
    return ret;
}

static void usb_mouse_handle_destroy(USBDevice *dev)
{
    USBMouseState *s = (USBMouseState *)dev;

    qemu_add_mouse_event_handler(NULL, NULL, 0);
    qemu_free(s);
}

USBDevice *usb_tablet_init(void)
{
    USBMouseState *s;

    s = qemu_mallocz(sizeof(USBMouseState));
    if (!s)
        return NULL;
    s->dev.speed = USB_SPEED_FULL;
    s->dev.handle_packet = usb_generic_handle_packet;

    s->dev.handle_reset = usb_mouse_handle_reset;
    s->dev.handle_control = usb_mouse_handle_control;
    s->dev.handle_data = usb_mouse_handle_data;
    s->dev.handle_destroy = usb_mouse_handle_destroy;
    s->kind = USB_TABLET;

    pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Tablet");

    return (USBDevice *)s;
}

USBDevice *usb_mouse_init(void)
{
    USBMouseState *s;

    s = qemu_mallocz(sizeof(USBMouseState));
    if (!s)
        return NULL;
    s->dev.speed = USB_SPEED_FULL;
    s->dev.handle_packet = usb_generic_handle_packet;

    s->dev.handle_reset = usb_mouse_handle_reset;
    s->dev.handle_control = usb_mouse_handle_control;
    s->dev.handle_data = usb_mouse_handle_data;
    s->dev.handle_destroy = usb_mouse_handle_destroy;
    s->kind = USB_MOUSE;

    pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Mouse");

    return (USBDevice *)s;
}
Commit	Line	Data
59ae540c FB	1	/*
	2	* QEMU USB HID devices
	3	*
	4	* Copyright (c) 2005 Fabrice Bellard
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24	#include "vl.h"
	25
	26	/* HID interface requests */
	27	#define GET_REPORT 0xa101
	28	#define GET_IDLE 0xa102
	29	#define GET_PROTOCOL 0xa103
	30	#define SET_IDLE 0x210a
	31	#define SET_PROTOCOL 0x210b
	32
09b26c5e FB	33	#define USB_MOUSE 1
	34	#define USB_TABLET 2
	35
59ae540c FB	36	typedef struct USBMouseState {
	37	USBDevice dev;
	38	int dx, dy, dz, buttons_state;
09b26c5e FB	39	int x, y;
	40	int kind;
	41	int mouse_grabbed;
59ae540c FB	42	} USBMouseState;
	43
	44	/* mostly the same values as the Bochs USB Mouse device */
	45	static const uint8_t qemu_mouse_dev_descriptor[] = {
	46	0x12, /* u8 bLength; */
	47	0x01, /* u8 bDescriptorType; Device */
	48	0x10, 0x00, /* u16 bcdUSB; v1.0 */
	49
	50	0x00, /* u8 bDeviceClass; */
	51	0x00, /* u8 bDeviceSubClass; */
	52	0x00, /* u8 bDeviceProtocol; [ low/full speeds only ] */
	53	0x08, /* u8 bMaxPacketSize0; 8 Bytes */
	54
	55	0x27, 0x06, /* u16 idVendor; */
	56	0x01, 0x00, /* u16 idProduct; */
	57	0x00, 0x00, /* u16 bcdDevice */
	58
	59	0x03, /* u8 iManufacturer; */
	60	0x02, /* u8 iProduct; */
	61	0x01, /* u8 iSerialNumber; */
	62	0x01 /* u8 bNumConfigurations; */
	63	};
	64
	65	static const uint8_t qemu_mouse_config_descriptor[] = {
	66	/* one configuration */
	67	0x09, /* u8 bLength; */
	68	0x02, /* u8 bDescriptorType; Configuration */
	69	0x22, 0x00, /* u16 wTotalLength; */
	70	0x01, /* u8 bNumInterfaces; (1) */
	71	0x01, /* u8 bConfigurationValue; */
	72	0x04, /* u8 iConfiguration; */
	73	0xa0, /* u8 bmAttributes;
	74	Bit 7: must be set,
	75	6: Self-powered,
	76	5: Remote wakeup,
	77	4..0: resvd */
	78	50, /* u8 MaxPower; */
	79
	80	/* USB 1.1:
	81	* USB 2.0, single TT organization (mandatory):
	82	* one interface, protocol 0
	83	*
	84	* USB 2.0, multiple TT organization (optional):
	85	* two interfaces, protocols 1 (like single TT)
	86	* and 2 (multiple TT mode) ... config is
	87	* sometimes settable
	88	* NOT IMPLEMENTED
	89	*/
	90
	91	/* one interface */
	92	0x09, /* u8 if_bLength; */
	93	0x04, /* u8 if_bDescriptorType; Interface */
	94	0x00, /* u8 if_bInterfaceNumber; */
	95	0x00, /* u8 if_bAlternateSetting; */
	96	0x01, /* u8 if_bNumEndpoints; */
	97	0x03, /* u8 if_bInterfaceClass; */
	98	0x01, /* u8 if_bInterfaceSubClass; */
	99	0x02, /* u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
	100	0x05, /* u8 if_iInterface; */
	101
09b26c5e FB	102	/* HID descriptor */
	103	0x09, /* u8 bLength; */
	104	0x21, /* u8 bDescriptorType; */
	105	0x01, 0x00, /* u16 HID_class */
	106	0x00, /* u8 country_code */
	107	0x01, /* u8 num_descriptors */
	108	0x22, /* u8 type; Report */
	109	50, 0, /* u16 len */
	110
59ae540c FB	111	/* one endpoint (status change endpoint) */
	112	0x07, /* u8 ep_bLength; */
	113	0x05, /* u8 ep_bDescriptorType; Endpoint */
	114	0x81, /* u8 ep_bEndpointAddress; IN Endpoint 1 */
	115	0x03, /* u8 ep_bmAttributes; Interrupt */
	116	0x03, 0x00, /* u16 ep_wMaxPacketSize; */
	117	0x0a, /* u8 ep_bInterval; (255ms -- usb 2.0 spec) */
09b26c5e FB	118	};
	119
	120	static const uint8_t qemu_tablet_config_descriptor[] = {
	121	/* one configuration */
	122	0x09, /* u8 bLength; */
	123	0x02, /* u8 bDescriptorType; Configuration */
	124	0x22, 0x00, /* u16 wTotalLength; */
	125	0x01, /* u8 bNumInterfaces; (1) */
	126	0x01, /* u8 bConfigurationValue; */
	127	0x04, /* u8 iConfiguration; */
	128	0xa0, /* u8 bmAttributes;
	129	Bit 7: must be set,
	130	6: Self-powered,
	131	5: Remote wakeup,
	132	4..0: resvd */
	133	50, /* u8 MaxPower; */
	134
	135	/* USB 1.1:
	136	* USB 2.0, single TT organization (mandatory):
	137	* one interface, protocol 0
	138	*
	139	* USB 2.0, multiple TT organization (optional):
	140	* two interfaces, protocols 1 (like single TT)
	141	* and 2 (multiple TT mode) ... config is
	142	* sometimes settable
	143	* NOT IMPLEMENTED
	144	*/
	145
	146	/* one interface */
	147	0x09, /* u8 if_bLength; */
	148	0x04, /* u8 if_bDescriptorType; Interface */
	149	0x00, /* u8 if_bInterfaceNumber; */
	150	0x00, /* u8 if_bAlternateSetting; */
	151	0x01, /* u8 if_bNumEndpoints; */
	152	0x03, /* u8 if_bInterfaceClass; */
	153	0x01, /* u8 if_bInterfaceSubClass; */
	154	0x02, /* u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
	155	0x05, /* u8 if_iInterface; */
59ae540c FB	156
	157	/* HID descriptor */
	158	0x09, /* u8 bLength; */
	159	0x21, /* u8 bDescriptorType; */
	160	0x01, 0x00, /* u16 HID_class */
	161	0x00, /* u8 country_code */
	162	0x01, /* u8 num_descriptors */
	163	0x22, /* u8 type; Report */
09b26c5e FB	164	74, 0, /* u16 len */
	165
	166	/* one endpoint (status change endpoint) */
	167	0x07, /* u8 ep_bLength; */
	168	0x05, /* u8 ep_bDescriptorType; Endpoint */
	169	0x81, /* u8 ep_bEndpointAddress; IN Endpoint 1 */
	170	0x03, /* u8 ep_bmAttributes; Interrupt */
	171	0x08, 0x00, /* u16 ep_wMaxPacketSize; */
	172	0x03, /* u8 ep_bInterval; (255ms -- usb 2.0 spec) */
59ae540c FB	173	};
	174
	175	static const uint8_t qemu_mouse_hid_report_descriptor[] = {
	176	0x05, 0x01, 0x09, 0x02, 0xA1, 0x01, 0x09, 0x01,
	177	0xA1, 0x00, 0x05, 0x09, 0x19, 0x01, 0x29, 0x03,
	178	0x15, 0x00, 0x25, 0x01, 0x95, 0x03, 0x75, 0x01,
	179	0x81, 0x02, 0x95, 0x01, 0x75, 0x05, 0x81, 0x01,
	180	0x05, 0x01, 0x09, 0x30, 0x09, 0x31, 0x15, 0x81,
	181	0x25, 0x7F, 0x75, 0x08, 0x95, 0x02, 0x81, 0x06,
	182	0xC0, 0xC0,
	183	};
	184
09b26c5e FB	185	static const uint8_t qemu_tablet_hid_report_descriptor[] = {
	186	0x05, 0x01, /* Usage Page Generic Desktop */
	187	0x09, 0x01, /* Usage Mouse */
	188	0xA1, 0x01, /* Collection Application */
	189	0x09, 0x01, /* Usage Pointer */
	190	0xA1, 0x00, /* Collection Physical */
	191	0x05, 0x09, /* Usage Page Button */
	192	0x19, 0x01, /* Usage Minimum Button 1 */
	193	0x29, 0x03, /* Usage Maximum Button 3 */
	194	0x15, 0x00, /* Logical Minimum 0 */
	195	0x25, 0x01, /* Logical Maximum 1 */
	196	0x95, 0x03, /* Report Count 3 */
	197	0x75, 0x01, /* Report Size 1 */
	198	0x81, 0x02, /* Input (Data, Var, Abs) */
	199	0x95, 0x01, /* Report Count 1 */
	200	0x75, 0x05, /* Report Size 5 */
	201	0x81, 0x01, /* Input (Cnst, Var, Abs) */
	202	0x05, 0x01, /* Usage Page Generic Desktop */
	203	0x09, 0x30, /* Usage X */
	204	0x09, 0x31, /* Usage Y */
	205	0x15, 0x00, /* Logical Minimum 0 */
	206	0x26, 0xFF, 0x7F, /* Logical Maximum 0x7fff */
	207	0x35, 0x00, /* Physical Minimum 0 */
	208	0x46, 0xFE, 0x7F, /* Physical Maximum 0x7fff */
	209	0x75, 0x10, /* Report Size 16 */
	210	0x95, 0x02, /* Report Count 2 */
	211	0x81, 0x02, /* Input (Data, Var, Abs) */
	212	0x05, 0x01, /* Usage Page Generic Desktop */
	213	0x09, 0x38, /* Usage Wheel */
	214	0x15, 0x81, /* Logical Minimum -127 */
	215	0x25, 0x7F, /* Logical Maximum 127 */
	216	0x35, 0x00, /* Physical Minimum 0 (same as logical) */
	217	0x45, 0x00, /* Physical Maximum 0 (same as logical) */
	218	0x75, 0x08, /* Report Size 8 */
	219	0x95, 0x01, /* Report Count 1 */
	220	0x81, 0x02, /* Input (Data, Var, Rel) */
	221	0xC0, /* End Collection */
	222	0xC0, /* End Collection */
	223	};
	224
59ae540c FB	225	static void usb_mouse_event(void *opaque,
	226	int dx1, int dy1, int dz1, int buttons_state)
	227	{
	228	USBMouseState *s = opaque;
	229
	230	s->dx += dx1;
	231	s->dy += dy1;
	232	s->dz += dz1;
	233	s->buttons_state = buttons_state;
	234	}
	235
09b26c5e FB	236	static void usb_tablet_event(void *opaque,
	237	int x, int y, int dz, int buttons_state)
	238	{
	239	USBMouseState *s = opaque;
	240
	241	s->x = x;
	242	s->y = y;
	243	s->dz += dz;
	244	s->buttons_state = buttons_state;
	245	}
	246
59ae540c FB	247	static inline int int_clamp(int val, int vmin, int vmax)
	248	{
	249	if (val < vmin)
	250	return vmin;
	251	else if (val > vmax)
	252	return vmax;
	253	else
	254	return val;
	255	}
	256
	257	static int usb_mouse_poll(USBMouseState s, uint8_t buf, int len)
	258	{
	259	int dx, dy, dz, b, l;
	260
09b26c5e FB	261	if (!s->mouse_grabbed) {
	262	qemu_add_mouse_event_handler(usb_mouse_event, s, 0);
	263	s->mouse_grabbed = 1;
	264	}
	265
59ae540c FB	266	dx = int_clamp(s->dx, -128, 127);
	267	dy = int_clamp(s->dy, -128, 127);
	268	dz = int_clamp(s->dz, -128, 127);
	269
	270	s->dx -= dx;
	271	s->dy -= dy;
	272	s->dz -= dz;
	273
	274	b = 0;
	275	if (s->buttons_state & MOUSE_EVENT_LBUTTON)
	276	b \|= 0x01;
	277	if (s->buttons_state & MOUSE_EVENT_RBUTTON)
	278	b \|= 0x02;
	279	if (s->buttons_state & MOUSE_EVENT_MBUTTON)
	280	b \|= 0x04;
	281
	282	buf[0] = b;
	283	buf[1] = dx;
	284	buf[2] = dy;
	285	l = 3;
	286	if (len >= 4) {
	287	buf[3] = dz;
	288	l = 4;
	289	}
	290	return l;
	291	}
	292
09b26c5e FB	293	static int usb_tablet_poll(USBMouseState s, uint8_t buf, int len)
	294	{
	295	int dz, b, l;
	296
	297	if (!s->mouse_grabbed) {
	298	qemu_add_mouse_event_handler(usb_tablet_event, s, 1);
	299	s->mouse_grabbed = 1;
	300	}
	301
	302	dz = int_clamp(s->dz, -128, 127);
	303	s->dz -= dz;
	304
	305	/* Appears we have to invert the wheel direction */
	306	dz = 0 - dz;
	307	b = 0;
	308	if (s->buttons_state & MOUSE_EVENT_LBUTTON)
	309	b \|= 0x01;
	310	if (s->buttons_state & MOUSE_EVENT_RBUTTON)
	311	b \|= 0x02;
	312	if (s->buttons_state & MOUSE_EVENT_MBUTTON)
	313	b \|= 0x04;
	314
	315	buf[0] = b;
	316	buf[1] = s->x & 0xff;
	317	buf[2] = s->x >> 8;
	318	buf[3] = s->y & 0xff;
	319	buf[4] = s->y >> 8;
	320	buf[5] = dz;
	321	l = 6;
	322
	323	return l;
	324	}
	325
059809e4	326	static void usb_mouse_handle_reset(USBDevice *dev)
59ae540c FB	327	{
	328	USBMouseState s = (USBMouseState )dev;
	329
	330	s->dx = 0;
	331	s->dy = 0;
	332	s->dz = 0;
09b26c5e FB	333	s->x = 0;
09b26c5e FB	334	s->y = 0;
59ae540c FB	335	s->buttons_state = 0;
	336	}
	337
	338	static int usb_mouse_handle_control(USBDevice *dev, int request, int value,
	339	int index, int length, uint8_t *data)
	340	{
	341	USBMouseState s = (USBMouseState )dev;
09b26c5e	342	int ret = 0;
59ae540c FB	343
	344	switch(request) {
	345	case DeviceRequest \| USB_REQ_GET_STATUS:
	346	data[0] = (1 << USB_DEVICE_SELF_POWERED) \|
	347	(dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
	348	data[1] = 0x00;
	349	ret = 2;
	350	break;
	351	case DeviceOutRequest \| USB_REQ_CLEAR_FEATURE:
	352	if (value == USB_DEVICE_REMOTE_WAKEUP) {
	353	dev->remote_wakeup = 0;
	354	} else {
	355	goto fail;
	356	}
	357	ret = 0;
	358	break;
	359	case DeviceOutRequest \| USB_REQ_SET_FEATURE:
	360	if (value == USB_DEVICE_REMOTE_WAKEUP) {
	361	dev->remote_wakeup = 1;
	362	} else {
	363	goto fail;
	364	}
	365	ret = 0;
	366	break;
	367	case DeviceOutRequest \| USB_REQ_SET_ADDRESS:
	368	dev->addr = value;
	369	ret = 0;
	370	break;
	371	case DeviceRequest \| USB_REQ_GET_DESCRIPTOR:
	372	switch(value >> 8) {
	373	case USB_DT_DEVICE:
	374	memcpy(data, qemu_mouse_dev_descriptor,
	375	sizeof(qemu_mouse_dev_descriptor));
	376	ret = sizeof(qemu_mouse_dev_descriptor);
	377	break;
	378	case USB_DT_CONFIG:
09b26c5e FB	379	if (s->kind == USB_MOUSE) {
	380	memcpy(data, qemu_mouse_config_descriptor,
	381	sizeof(qemu_mouse_config_descriptor));
	382	ret = sizeof(qemu_mouse_config_descriptor);
	383	} else if (s->kind == USB_TABLET) {
	384	memcpy(data, qemu_tablet_config_descriptor,
	385	sizeof(qemu_tablet_config_descriptor));
	386	ret = sizeof(qemu_tablet_config_descriptor);
	387	}
59ae540c FB	388	break;
	389	case USB_DT_STRING:
	390	switch(value & 0xff) {
	391	case 0:
	392	/* language ids */
	393	data[0] = 4;
	394	data[1] = 3;
	395	data[2] = 0x09;
	396	data[3] = 0x04;
	397	ret = 4;
	398	break;
	399	case 1:
	400	/* serial number */
	401	ret = set_usb_string(data, "1");
	402	break;
	403	case 2:
	404	/* product description */
09b26c5e FB	405	if (s->kind == USB_MOUSE)
	406	ret = set_usb_string(data, "QEMU USB Mouse");
	407	else if (s->kind == USB_TABLET)
	408	ret = set_usb_string(data, "QEMU USB Tablet");
59ae540c FB	409	break;
	410	case 3:
	411	/* vendor description */
	412	ret = set_usb_string(data, "QEMU " QEMU_VERSION);
	413	break;
	414	case 4:
	415	ret = set_usb_string(data, "HID Mouse");
	416	break;
	417	case 5:
	418	ret = set_usb_string(data, "Endpoint1 Interrupt Pipe");
	419	break;
	420	default:
	421	goto fail;
	422	}
	423	break;
	424	default:
	425	goto fail;
	426	}
	427	break;
	428	case DeviceRequest \| USB_REQ_GET_CONFIGURATION:
	429	data[0] = 1;
	430	ret = 1;
	431	break;
	432	case DeviceOutRequest \| USB_REQ_SET_CONFIGURATION:
	433	ret = 0;
	434	break;
	435	case DeviceRequest \| USB_REQ_GET_INTERFACE:
	436	data[0] = 0;
	437	ret = 1;
	438	break;
	439	case DeviceOutRequest \| USB_REQ_SET_INTERFACE:
	440	ret = 0;
	441	break;
	442	/* hid specific requests */
	443	case InterfaceRequest \| USB_REQ_GET_DESCRIPTOR:
	444	switch(value >> 8) {
	445	case 0x22:
09b26c5e FB	446	if (s->kind == USB_MOUSE) {
	447	memcpy(data, qemu_mouse_hid_report_descriptor,
	448	sizeof(qemu_mouse_hid_report_descriptor));
	449	ret = sizeof(qemu_mouse_hid_report_descriptor);
	450	} else if (s->kind == USB_TABLET) {
	451	memcpy(data, qemu_tablet_hid_report_descriptor,
	452	sizeof(qemu_tablet_hid_report_descriptor));
	453	ret = sizeof(qemu_tablet_hid_report_descriptor);
	454	}
	455	break;
59ae540c FB	456	default:
	457	goto fail;
	458	}
	459	break;
	460	case GET_REPORT:
09b26c5e FB	461	if (s->kind == USB_MOUSE)
	462	ret = usb_mouse_poll(s, data, length);
	463	else if (s->kind == USB_TABLET)
	464	ret = usb_tablet_poll(s, data, length);
59ae540c FB	465	break;
	466	case SET_IDLE:
	467	ret = 0;
	468	break;
	469	default:
	470	fail:
	471	ret = USB_RET_STALL;
	472	break;
	473	}
	474	return ret;
	475	}
	476
4d611c9a	477	static int usb_mouse_handle_data(USBDevice dev, USBPacket p)
59ae540c FB	478	{
59ae540c FB	479	USBMouseState s = (USBMouseState )dev;
09b26c5e	480	int ret = 0;
59ae540c	481
4d611c9a	482	switch(p->pid) {
59ae540c	483	case USB_TOKEN_IN:
4d611c9a	484	if (p->devep == 1) {
09b26c5e	485	if (s->kind == USB_MOUSE)
4d611c9a	486	ret = usb_mouse_poll(s, p->data, p->len);
09b26c5e	487	else if (s->kind == USB_TABLET)
4d611c9a	488	ret = usb_tablet_poll(s, p->data, p->len);
59ae540c FB	489	} else {
	490	goto fail;
	491	}
	492	break;
	493	case USB_TOKEN_OUT:
	494	default:
	495	fail:
	496	ret = USB_RET_STALL;
	497	break;
	498	}
	499	return ret;
	500	}
	501
059809e4 FB	502	static void usb_mouse_handle_destroy(USBDevice *dev)
	503	{
	504	USBMouseState s = (USBMouseState )dev;
	505
	506	qemu_add_mouse_event_handler(NULL, NULL, 0);
	507	qemu_free(s);
	508	}
	509
09b26c5e FB	510	USBDevice *usb_tablet_init(void)
	511	{
	512	USBMouseState *s;
	513
	514	s = qemu_mallocz(sizeof(USBMouseState));
	515	if (!s)
	516	return NULL;
	517	s->dev.speed = USB_SPEED_FULL;
	518	s->dev.handle_packet = usb_generic_handle_packet;
	519
	520	s->dev.handle_reset = usb_mouse_handle_reset;
	521	s->dev.handle_control = usb_mouse_handle_control;
	522	s->dev.handle_data = usb_mouse_handle_data;
059809e4	523	s->dev.handle_destroy = usb_mouse_handle_destroy;
09b26c5e FB	524	s->kind = USB_TABLET;
09b26c5e FB	525
1f6e24e7 FB	526	pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Tablet");
1f6e24e7 FB	527
09b26c5e FB	528	return (USBDevice *)s;
	529	}
	530
59ae540c FB	531	USBDevice *usb_mouse_init(void)
	532	{
	533	USBMouseState *s;
	534
	535	s = qemu_mallocz(sizeof(USBMouseState));
	536	if (!s)
	537	return NULL;
	538	s->dev.speed = USB_SPEED_FULL;
	539	s->dev.handle_packet = usb_generic_handle_packet;
	540
	541	s->dev.handle_reset = usb_mouse_handle_reset;
	542	s->dev.handle_control = usb_mouse_handle_control;
	543	s->dev.handle_data = usb_mouse_handle_data;
059809e4	544	s->dev.handle_destroy = usb_mouse_handle_destroy;
09b26c5e	545	s->kind = USB_MOUSE;
59ae540c	546
1f6e24e7 FB	547	pstrcpy(s->dev.devname, sizeof(s->dev.devname), "QEMU USB Mouse");
1f6e24e7 FB	548
59ae540c FB	549	return (USBDevice *)s;
59ae540c FB	550	}