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

/*
 * QEMU Bluetooth HCI USB Transport Layer v1.0
 *
 * Copyright (C) 2007 OpenMoko, Inc.
 * Copyright (C) 2008 Andrzej Zaborowski  <balrog@zabor.org>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 or
 * (at your option) version 3 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include "qemu-common.h"
#include "usb.h"
#include "usb-desc.h"
#include "net.h"
#include "bt.h"

struct USBBtState {
    USBDevice dev;
    struct HCIInfo *hci;

    int altsetting;
    int config;

#define CFIFO_LEN_MASK	255
#define DFIFO_LEN_MASK	4095
    struct usb_hci_in_fifo_s {
        uint8_t data[(DFIFO_LEN_MASK + 1) * 2];
        struct {
            uint8_t *data;
            int len;
        } fifo[CFIFO_LEN_MASK + 1];
        int dstart, dlen, dsize, start, len;
    } evt, acl, sco;

    struct usb_hci_out_fifo_s {
        uint8_t data[4096];
	int len;
    } outcmd, outacl, outsco;
};

#define USB_EVT_EP	1
#define USB_ACL_EP	2
#define USB_SCO_EP	3

enum {
    STR_MANUFACTURER = 1,
    STR_SERIALNUMBER,
};

static const USBDescStrings desc_strings = {
    [STR_MANUFACTURER]     = "QEMU " QEMU_VERSION,
    [STR_SERIALNUMBER]     = "1",
};

static const USBDescIface desc_iface_bluetooth[] = {
    {
        .bInterfaceNumber              = 0,
        .bNumEndpoints                 = 3,
        .bInterfaceClass               = 0xe0, /* Wireless */
        .bInterfaceSubClass            = 0x01, /* Radio Frequency */
        .bInterfaceProtocol            = 0x01, /* Bluetooth */
        .eps = (USBDescEndpoint[]) {
            {
                .bEndpointAddress      = USB_DIR_IN | USB_EVT_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_INT,
                .wMaxPacketSize        = 0x10,
                .bInterval             = 0x02,
            },
            {
                .bEndpointAddress      = USB_DIR_OUT | USB_ACL_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_BULK,
                .wMaxPacketSize        = 0x40,
                .bInterval             = 0x0a,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_ACL_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_BULK,
                .wMaxPacketSize        = 0x40,
                .bInterval             = 0x0a,
            },
        },
    },{
        .bInterfaceNumber              = 1,
        .bAlternateSetting             = 0,
        .bNumEndpoints                 = 2,
        .bInterfaceClass               = 0xe0, /* Wireless */
        .bInterfaceSubClass            = 0x01, /* Radio Frequency */
        .bInterfaceProtocol            = 0x01, /* Bluetooth */
        .eps = (USBDescEndpoint[]) {
            {
                .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0,
                .bInterval             = 0x01,
            },
        },
    },{
        .bInterfaceNumber              = 1,
        .bAlternateSetting             = 1,
        .bNumEndpoints                 = 2,
        .bInterfaceClass               = 0xe0, /* Wireless */
        .bInterfaceSubClass            = 0x01, /* Radio Frequency */
        .bInterfaceProtocol            = 0x01, /* Bluetooth */
        .eps = (USBDescEndpoint[]) {
            {
                .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x09,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x09,
                .bInterval             = 0x01,
            },
        },
    },{
        .bInterfaceNumber              = 1,
        .bAlternateSetting             = 2,
        .bNumEndpoints                 = 2,
        .bInterfaceClass               = 0xe0, /* Wireless */
        .bInterfaceSubClass            = 0x01, /* Radio Frequency */
        .bInterfaceProtocol            = 0x01, /* Bluetooth */
        .eps = (USBDescEndpoint[]) {
            {
                .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x11,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x11,
                .bInterval             = 0x01,
            },
        },
    },{
        .bInterfaceNumber              = 1,
        .bAlternateSetting             = 3,
        .bNumEndpoints                 = 2,
        .bInterfaceClass               = 0xe0, /* Wireless */
        .bInterfaceSubClass            = 0x01, /* Radio Frequency */
        .bInterfaceProtocol            = 0x01, /* Bluetooth */
        .eps = (USBDescEndpoint[]) {
            {
                .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x19,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x19,
                .bInterval             = 0x01,
            },
        },
    },{
        .bInterfaceNumber              = 1,
        .bAlternateSetting             = 4,
        .bNumEndpoints                 = 2,
        .bInterfaceClass               = 0xe0, /* Wireless */
        .bInterfaceSubClass            = 0x01, /* Radio Frequency */
        .bInterfaceProtocol            = 0x01, /* Bluetooth */
        .eps = (USBDescEndpoint[]) {
            {
                .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x21,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x21,
                .bInterval             = 0x01,
            },
        },
    },{
        .bInterfaceNumber              = 1,
        .bAlternateSetting             = 5,
        .bNumEndpoints                 = 2,
        .bInterfaceClass               = 0xe0, /* Wireless */
        .bInterfaceSubClass            = 0x01, /* Radio Frequency */
        .bInterfaceProtocol            = 0x01, /* Bluetooth */
        .eps = (USBDescEndpoint[]) {
            {
                .bEndpointAddress      = USB_DIR_OUT | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x31,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_ISOC,
                .wMaxPacketSize        = 0x31,
                .bInterval             = 0x01,
            },
        },
    }
};

static const USBDescDevice desc_device_bluetooth = {
    .bcdUSB                        = 0x0110,
    .bDeviceClass                  = 0xe0, /* Wireless */
    .bDeviceSubClass               = 0x01, /* Radio Frequency */
    .bDeviceProtocol               = 0x01, /* Bluetooth */
    .bMaxPacketSize0               = 64,
    .bNumConfigurations            = 1,
    .confs = (USBDescConfig[]) {
        {
            .bNumInterfaces        = 2,
            .bConfigurationValue   = 1,
            .bmAttributes          = 0xc0,
            .bMaxPower             = 0,
            .nif = ARRAY_SIZE(desc_iface_bluetooth),
            .ifs = desc_iface_bluetooth,
        },
    },
};

static const USBDesc desc_bluetooth = {
    .id = {
        .idVendor          = 0x0a12,
        .idProduct         = 0x0001,
        .bcdDevice         = 0x1958,
        .iManufacturer     = STR_MANUFACTURER,
        .iProduct          = 0,
        .iSerialNumber     = STR_SERIALNUMBER,
    },
    .full = &desc_device_bluetooth,
    .str  = desc_strings,
};

static void usb_bt_fifo_reset(struct usb_hci_in_fifo_s *fifo)
{
    fifo->dstart = 0;
    fifo->dlen = 0;
    fifo->dsize = DFIFO_LEN_MASK + 1;
    fifo->start = 0;
    fifo->len = 0;
}

static void usb_bt_fifo_enqueue(struct usb_hci_in_fifo_s *fifo,
                const uint8_t *data, int len)
{
    int off = fifo->dstart + fifo->dlen;
    uint8_t *buf;

    fifo->dlen += len;
    if (off <= DFIFO_LEN_MASK) {
        if (off + len > DFIFO_LEN_MASK + 1 &&
                        (fifo->dsize = off + len) > (DFIFO_LEN_MASK + 1) * 2) {
            fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
            exit(-1);
        }
        buf = fifo->data + off;
    } else {
        if (fifo->dlen > fifo->dsize) {
            fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
            exit(-1);
        }
        buf = fifo->data + off - fifo->dsize;
    }

    off = (fifo->start + fifo->len ++) & CFIFO_LEN_MASK;
    fifo->fifo[off].data = memcpy(buf, data, len);
    fifo->fifo[off].len = len;
}

static inline int usb_bt_fifo_dequeue(struct usb_hci_in_fifo_s *fifo,
                USBPacket *p)
{
    int len;

    if (likely(!fifo->len))
        return USB_RET_STALL;

    len = MIN(p->len, fifo->fifo[fifo->start].len);
    memcpy(p->data, fifo->fifo[fifo->start].data, len);
    if (len == p->len) {
        fifo->fifo[fifo->start].len -= len;
        fifo->fifo[fifo->start].data += len;
    } else {
        fifo->start ++;
        fifo->start &= CFIFO_LEN_MASK;
        fifo->len --;
    }

    fifo->dstart += len;
    fifo->dlen -= len;
    if (fifo->dstart >= fifo->dsize) {
        fifo->dstart = 0;
        fifo->dsize = DFIFO_LEN_MASK + 1;
    }

    return len;
}

static inline void usb_bt_fifo_out_enqueue(struct USBBtState *s,
                struct usb_hci_out_fifo_s *fifo,
                void (*send)(struct HCIInfo *, const uint8_t *, int),
                int (*complete)(const uint8_t *, int),
                const uint8_t *data, int len)
{
    if (fifo->len) {
        memcpy(fifo->data + fifo->len, data, len);
        fifo->len += len;
        if (complete(fifo->data, fifo->len)) {
            send(s->hci, fifo->data, fifo->len);
            fifo->len = 0;
        }
    } else if (complete(data, len))
        send(s->hci, data, len);
    else {
        memcpy(fifo->data, data, len);
        fifo->len = len;
    }

    /* TODO: do we need to loop? */
}

static int usb_bt_hci_cmd_complete(const uint8_t *data, int len)
{
    len -= HCI_COMMAND_HDR_SIZE;
    return len >= 0 &&
            len >= ((struct hci_command_hdr *) data)->plen;
}

static int usb_bt_hci_acl_complete(const uint8_t *data, int len)
{
    len -= HCI_ACL_HDR_SIZE;
    return len >= 0 &&
            len >= le16_to_cpu(((struct hci_acl_hdr *) data)->dlen);
}

static int usb_bt_hci_sco_complete(const uint8_t *data, int len)
{
    len -= HCI_SCO_HDR_SIZE;
    return len >= 0 &&
            len >= ((struct hci_sco_hdr *) data)->dlen;
}

static void usb_bt_handle_reset(USBDevice *dev)
{
    struct USBBtState *s = (struct USBBtState *) dev->opaque;

    usb_bt_fifo_reset(&s->evt);
    usb_bt_fifo_reset(&s->acl);
    usb_bt_fifo_reset(&s->sco);
    s->outcmd.len = 0;
    s->outacl.len = 0;
    s->outsco.len = 0;
    s->altsetting = 0;
}

static int usb_bt_handle_control(USBDevice *dev, USBPacket *p,
               int request, int value, int index, int length, uint8_t *data)
{
    struct USBBtState *s = (struct USBBtState *) dev->opaque;
    int ret;

    ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
    if (ret >= 0) {
        switch (request) {
        case DeviceRequest | USB_REQ_GET_CONFIGURATION:
            s->config = 0;
            break;
        case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
            s->config = 1;
            usb_bt_fifo_reset(&s->evt);
            usb_bt_fifo_reset(&s->acl);
            usb_bt_fifo_reset(&s->sco);
            break;
        }
        return ret;
    }

    ret = 0;
    switch (request) {
    case InterfaceRequest | USB_REQ_GET_STATUS:
    case EndpointRequest | USB_REQ_GET_STATUS:
        data[0] = 0x00;
        data[1] = 0x00;
        ret = 2;
        break;
    case InterfaceOutRequest | USB_REQ_CLEAR_FEATURE:
    case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
        goto fail;
    case InterfaceOutRequest | USB_REQ_SET_FEATURE:
    case EndpointOutRequest | USB_REQ_SET_FEATURE:
        goto fail;
        break;
    case InterfaceRequest | USB_REQ_GET_INTERFACE:
        if (value != 0 || (index & ~1) || length != 1)
            goto fail;
        if (index == 1)
            data[0] = s->altsetting;
        else
            data[0] = 0;
        ret = 1;
        break;
    case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
        if ((index & ~1) || length != 0 ||
                        (index == 1 && (value < 0 || value > 4)) ||
                        (index == 0 && value != 0)) {
            printf("%s: Wrong SET_INTERFACE request (%i, %i)\n",
                            __FUNCTION__, index, value);
            goto fail;
        }
        s->altsetting = value;
        ret = 0;
        break;
    case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_DEVICE) << 8):
        if (s->config)
            usb_bt_fifo_out_enqueue(s, &s->outcmd, s->hci->cmd_send,
                            usb_bt_hci_cmd_complete, data, length);
        break;
    default:
    fail:
        ret = USB_RET_STALL;
        break;
    }
    return ret;
}

static int usb_bt_handle_data(USBDevice *dev, USBPacket *p)
{
    struct USBBtState *s = (struct USBBtState *) dev->opaque;
    int ret = 0;

    if (!s->config)
        goto fail;

    switch (p->pid) {
    case USB_TOKEN_IN:
        switch (p->devep & 0xf) {
        case USB_EVT_EP:
            ret = usb_bt_fifo_dequeue(&s->evt, p);
            break;

        case USB_ACL_EP:
            ret = usb_bt_fifo_dequeue(&s->acl, p);
            break;

        case USB_SCO_EP:
            ret = usb_bt_fifo_dequeue(&s->sco, p);
            break;

        default:
            goto fail;
        }
        break;

    case USB_TOKEN_OUT:
        switch (p->devep & 0xf) {
        case USB_ACL_EP:
            usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send,
                            usb_bt_hci_acl_complete, p->data, p->len);
            break;

        case USB_SCO_EP:
            usb_bt_fifo_out_enqueue(s, &s->outsco, s->hci->sco_send,
                            usb_bt_hci_sco_complete, p->data, p->len);
            break;

        default:
            goto fail;
        }
        break;

    default:
    fail:
        ret = USB_RET_STALL;
        break;
    }

    return ret;
}

static void usb_bt_out_hci_packet_event(void *opaque,
                const uint8_t *data, int len)
{
    struct USBBtState *s = (struct USBBtState *) opaque;

    usb_bt_fifo_enqueue(&s->evt, data, len);
}

static void usb_bt_out_hci_packet_acl(void *opaque,
                const uint8_t *data, int len)
{
    struct USBBtState *s = (struct USBBtState *) opaque;

    usb_bt_fifo_enqueue(&s->acl, data, len);
}

static void usb_bt_handle_destroy(USBDevice *dev)
{
    struct USBBtState *s = (struct USBBtState *) dev->opaque;

    s->hci->opaque = NULL;
    s->hci->evt_recv = NULL;
    s->hci->acl_recv = NULL;
}

static int usb_bt_initfn(USBDevice *dev)
{
    usb_desc_init(dev);
    return 0;
}

USBDevice *usb_bt_init(HCIInfo *hci)
{
    USBDevice *dev;
    struct USBBtState *s;

    if (!hci)
        return NULL;
    dev = usb_create_simple(NULL /* FIXME */, "usb-bt-dongle");
    s = DO_UPCAST(struct USBBtState, dev, dev);
    s->dev.opaque = s;

    s->hci = hci;
    s->hci->opaque = s;
    s->hci->evt_recv = usb_bt_out_hci_packet_event;
    s->hci->acl_recv = usb_bt_out_hci_packet_acl;

    usb_bt_handle_reset(&s->dev);

    return dev;
}

static struct USBDeviceInfo bt_info = {
    .product_desc   = "QEMU BT dongle",
    .qdev.name      = "usb-bt-dongle",
    .qdev.size      = sizeof(struct USBBtState),
    .usb_desc       = &desc_bluetooth,
    .init           = usb_bt_initfn,
    .handle_packet  = usb_generic_handle_packet,
    .handle_reset   = usb_bt_handle_reset,
    .handle_control = usb_bt_handle_control,
    .handle_data    = usb_bt_handle_data,
    .handle_destroy = usb_bt_handle_destroy,
};

static void usb_bt_register_devices(void)
{
    usb_qdev_register(&bt_info);
}
device_init(usb_bt_register_devices)
Commit	Line	Data
e6a6d5ab AZ	1	/*
	2	* QEMU Bluetooth HCI USB Transport Layer v1.0
	3	*
	4	* Copyright (C) 2007 OpenMoko, Inc.
	5	* Copyright (C) 2008 Andrzej Zaborowski <balrog@zabor.org>
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License as
	9	* published by the Free Software Foundation; either version 2 or
	10	* (at your option) version 3 of the License.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
fad6cb1a	17	* You should have received a copy of the GNU General Public License along
8167ee88	18	* with this program; if not, see <http://www.gnu.org/licenses/>.
e6a6d5ab AZ	19	*/
	20
	21	#include "qemu-common.h"
	22	#include "usb.h"
4696425c	23	#include "usb-desc.h"
e6a6d5ab AZ	24	#include "net.h"
	25	#include "bt.h"
	26
	27	struct USBBtState {
	28	USBDevice dev;
	29	struct HCIInfo *hci;
	30
	31	int altsetting;
	32	int config;
	33
	34	#define CFIFO_LEN_MASK 255
	35	#define DFIFO_LEN_MASK 4095
	36	struct usb_hci_in_fifo_s {
	37	uint8_t data[(DFIFO_LEN_MASK + 1) * 2];
	38	struct {
	39	uint8_t *data;
	40	int len;
	41	} fifo[CFIFO_LEN_MASK + 1];
	42	int dstart, dlen, dsize, start, len;
	43	} evt, acl, sco;
	44
	45	struct usb_hci_out_fifo_s {
	46	uint8_t data[4096];
	47	int len;
	48	} outcmd, outacl, outsco;
	49	};
	50
	51	#define USB_EVT_EP 1
	52	#define USB_ACL_EP 2
	53	#define USB_SCO_EP 3
	54
4696425c GH	55	enum {
	56	STR_MANUFACTURER = 1,
	57	STR_SERIALNUMBER,
	58	};
e6a6d5ab	59
4696425c GH	60	static const USBDescStrings desc_strings = {
	61	[STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
	62	[STR_SERIALNUMBER] = "1",
	63	};
e6a6d5ab	64
4696425c GH	65	static const USBDescIface desc_iface_bluetooth[] = {
	66	{
	67	.bInterfaceNumber = 0,
	68	.bNumEndpoints = 3,
	69	.bInterfaceClass = 0xe0, /* Wireless */
	70	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	71	.bInterfaceProtocol = 0x01, /* Bluetooth */
	72	.eps = (USBDescEndpoint[]) {
	73	{
	74	.bEndpointAddress = USB_DIR_IN \| USB_EVT_EP,
	75	.bmAttributes = USB_ENDPOINT_XFER_INT,
	76	.wMaxPacketSize = 0x10,
	77	.bInterval = 0x02,
	78	},
	79	{
	80	.bEndpointAddress = USB_DIR_OUT \| USB_ACL_EP,
	81	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	82	.wMaxPacketSize = 0x40,
	83	.bInterval = 0x0a,
	84	},
	85	{
	86	.bEndpointAddress = USB_DIR_IN \| USB_ACL_EP,
	87	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	88	.wMaxPacketSize = 0x40,
	89	.bInterval = 0x0a,
	90	},
	91	},
	92	},{
	93	.bInterfaceNumber = 1,
	94	.bAlternateSetting = 0,
	95	.bNumEndpoints = 2,
	96	.bInterfaceClass = 0xe0, /* Wireless */
	97	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	98	.bInterfaceProtocol = 0x01, /* Bluetooth */
	99	.eps = (USBDescEndpoint[]) {
	100	{
	101	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	102	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	103	.wMaxPacketSize = 0,
	104	.bInterval = 0x01,
	105	},
	106	{
	107	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	108	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	109	.wMaxPacketSize = 0,
	110	.bInterval = 0x01,
	111	},
	112	},
	113	},{
	114	.bInterfaceNumber = 1,
	115	.bAlternateSetting = 1,
	116	.bNumEndpoints = 2,
	117	.bInterfaceClass = 0xe0, /* Wireless */
	118	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	119	.bInterfaceProtocol = 0x01, /* Bluetooth */
	120	.eps = (USBDescEndpoint[]) {
	121	{
	122	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	123	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	124	.wMaxPacketSize = 0x09,
	125	.bInterval = 0x01,
	126	},
	127	{
	128	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	129	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	130	.wMaxPacketSize = 0x09,
	131	.bInterval = 0x01,
	132	},
	133	},
	134	},{
	135	.bInterfaceNumber = 1,
	136	.bAlternateSetting = 2,
	137	.bNumEndpoints = 2,
	138	.bInterfaceClass = 0xe0, /* Wireless */
	139	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	140	.bInterfaceProtocol = 0x01, /* Bluetooth */
	141	.eps = (USBDescEndpoint[]) {
	142	{
	143	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	144	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	145	.wMaxPacketSize = 0x11,
	146	.bInterval = 0x01,
	147	},
	148	{
	149	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	150	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	151	.wMaxPacketSize = 0x11,
	152	.bInterval = 0x01,
	153	},
	154	},
	155	},{
	156	.bInterfaceNumber = 1,
	157	.bAlternateSetting = 3,
	158	.bNumEndpoints = 2,
	159	.bInterfaceClass = 0xe0, /* Wireless */
	160	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	161	.bInterfaceProtocol = 0x01, /* Bluetooth */
	162	.eps = (USBDescEndpoint[]) {
	163	{
	164	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	165	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	166	.wMaxPacketSize = 0x19,
	167	.bInterval = 0x01,
	168	},
	169	{
	170	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	171	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	172	.wMaxPacketSize = 0x19,
	173	.bInterval = 0x01,
	174	},
	175	},
	176	},{
	177	.bInterfaceNumber = 1,
	178	.bAlternateSetting = 4,
	179	.bNumEndpoints = 2,
	180	.bInterfaceClass = 0xe0, /* Wireless */
	181	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	182	.bInterfaceProtocol = 0x01, /* Bluetooth */
	183	.eps = (USBDescEndpoint[]) {
	184	{
	185	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	186	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	187	.wMaxPacketSize = 0x21,
	188	.bInterval = 0x01,
	189	},
	190	{
	191	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	192	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	193	.wMaxPacketSize = 0x21,
	194	.bInterval = 0x01,
	195	},
	196	},
	197	},{
	198	.bInterfaceNumber = 1,
	199	.bAlternateSetting = 5,
	200	.bNumEndpoints = 2,
	201	.bInterfaceClass = 0xe0, /* Wireless */
	202	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	203	.bInterfaceProtocol = 0x01, /* Bluetooth */
	204	.eps = (USBDescEndpoint[]) {
	205	{
	206	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	207	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	208	.wMaxPacketSize = 0x31,
	209	.bInterval = 0x01,
	210	},
	211	{
	212	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	213	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	214	.wMaxPacketSize = 0x31,
	215	.bInterval = 0x01,
	216	},
	217	},
	218	}
	219	};
e6a6d5ab	220
4696425c GH	221	static const USBDescDevice desc_device_bluetooth = {
	222	.bcdUSB = 0x0110,
	223	.bDeviceClass = 0xe0, /* Wireless */
	224	.bDeviceSubClass = 0x01, /* Radio Frequency */
	225	.bDeviceProtocol = 0x01, /* Bluetooth */
	226	.bMaxPacketSize0 = 64,
	227	.bNumConfigurations = 1,
	228	.confs = (USBDescConfig[]) {
	229	{
	230	.bNumInterfaces = 2,
	231	.bConfigurationValue = 1,
	232	.bmAttributes = 0xc0,
	233	.bMaxPower = 0,
	234	.nif = ARRAY_SIZE(desc_iface_bluetooth),
	235	.ifs = desc_iface_bluetooth,
	236	},
	237	},
e6a6d5ab AZ	238	};
e6a6d5ab AZ	239
4696425c GH	240	static const USBDesc desc_bluetooth = {
	241	.id = {
	242	.idVendor = 0x0a12,
	243	.idProduct = 0x0001,
	244	.bcdDevice = 0x1958,
	245	.iManufacturer = STR_MANUFACTURER,
	246	.iProduct = 0,
	247	.iSerialNumber = STR_SERIALNUMBER,
	248	},
	249	.full = &desc_device_bluetooth,
	250	.str = desc_strings,
e6a6d5ab AZ	251	};
	252
	253	static void usb_bt_fifo_reset(struct usb_hci_in_fifo_s *fifo)
	254	{
	255	fifo->dstart = 0;
	256	fifo->dlen = 0;
	257	fifo->dsize = DFIFO_LEN_MASK + 1;
	258	fifo->start = 0;
	259	fifo->len = 0;
	260	}
	261
	262	static void usb_bt_fifo_enqueue(struct usb_hci_in_fifo_s *fifo,
	263	const uint8_t *data, int len)
	264	{
	265	int off = fifo->dstart + fifo->dlen;
	266	uint8_t *buf;
	267
	268	fifo->dlen += len;
	269	if (off <= DFIFO_LEN_MASK) {
	270	if (off + len > DFIFO_LEN_MASK + 1 &&
	271	(fifo->dsize = off + len) > (DFIFO_LEN_MASK + 1) * 2) {
	272	fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
	273	exit(-1);
	274	}
	275	buf = fifo->data + off;
	276	} else {
	277	if (fifo->dlen > fifo->dsize) {
	278	fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
	279	exit(-1);
	280	}
	281	buf = fifo->data + off - fifo->dsize;
	282	}
	283
	284	off = (fifo->start + fifo->len ++) & CFIFO_LEN_MASK;
	285	fifo->fifo[off].data = memcpy(buf, data, len);
	286	fifo->fifo[off].len = len;
	287	}
	288
	289	static inline int usb_bt_fifo_dequeue(struct usb_hci_in_fifo_s *fifo,
	290	USBPacket *p)
	291	{
	292	int len;
	293
	294	if (likely(!fifo->len))
	295	return USB_RET_STALL;
	296
	297	len = MIN(p->len, fifo->fifo[fifo->start].len);
	298	memcpy(p->data, fifo->fifo[fifo->start].data, len);
	299	if (len == p->len) {
	300	fifo->fifo[fifo->start].len -= len;
	301	fifo->fifo[fifo->start].data += len;
	302	} else {
	303	fifo->start ++;
	304	fifo->start &= CFIFO_LEN_MASK;
	305	fifo->len --;
	306	}
	307
	308	fifo->dstart += len;
	309	fifo->dlen -= len;
	310	if (fifo->dstart >= fifo->dsize) {
	311	fifo->dstart = 0;
	312	fifo->dsize = DFIFO_LEN_MASK + 1;
	313	}
	314
315	return len;
316	}
317
86178a57	318	static inline void usb_bt_fifo_out_enqueue(struct USBBtState *s,
e6a6d5ab AZ	319	struct usb_hci_out_fifo_s *fifo,
	320	void (send)(struct HCIInfo , const uint8_t *, int),
	321	int (complete)(const uint8_t , int),
	322	const uint8_t *data, int len)
	323	{
	324	if (fifo->len) {
	325	memcpy(fifo->data + fifo->len, data, len);
	326	fifo->len += len;
	327	if (complete(fifo->data, fifo->len)) {
	328	send(s->hci, fifo->data, fifo->len);
	329	fifo->len = 0;
	330	}
	331	} else if (complete(data, len))
	332	send(s->hci, data, len);
	333	else {
	334	memcpy(fifo->data, data, len);
	335	fifo->len = len;
	336	}
	337
	338	/* TODO: do we need to loop? */
	339	}
	340
	341	static int usb_bt_hci_cmd_complete(const uint8_t *data, int len)
	342	{
	343	len -= HCI_COMMAND_HDR_SIZE;
	344	return len >= 0 &&
	345	len >= ((struct hci_command_hdr *) data)->plen;
	346	}
	347
	348	static int usb_bt_hci_acl_complete(const uint8_t *data, int len)
	349	{
	350	len -= HCI_ACL_HDR_SIZE;
	351	return len >= 0 &&
	352	len >= le16_to_cpu(((struct hci_acl_hdr *) data)->dlen);
	353	}
	354
	355	static int usb_bt_hci_sco_complete(const uint8_t *data, int len)
	356	{
	357	len -= HCI_SCO_HDR_SIZE;
	358	return len >= 0 &&
	359	len >= ((struct hci_sco_hdr *) data)->dlen;
	360	}
	361
	362	static void usb_bt_handle_reset(USBDevice *dev)
	363	{
	364	struct USBBtState s = (struct USBBtState ) dev->opaque;
	365
	366	usb_bt_fifo_reset(&s->evt);
	367	usb_bt_fifo_reset(&s->acl);
	368	usb_bt_fifo_reset(&s->sco);
	369	s->outcmd.len = 0;
	370	s->outacl.len = 0;
	371	s->outsco.len = 0;
	372	s->altsetting = 0;
	373	}
	374
007fd62f HG	375	static int usb_bt_handle_control(USBDevice dev, USBPacket p,
007fd62f HG	376	int request, int value, int index, int length, uint8_t *data)
e6a6d5ab AZ	377	{
e6a6d5ab AZ	378	struct USBBtState s = (struct USBBtState ) dev->opaque;
4696425c GH	379	int ret;
4696425c GH	380
007fd62f	381	ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
4696425c	382	if (ret >= 0) {
a980a065 GH	383	switch (request) {
	384	case DeviceRequest \| USB_REQ_GET_CONFIGURATION:
	385	s->config = 0;
	386	break;
	387	case DeviceOutRequest \| USB_REQ_SET_CONFIGURATION:
	388	s->config = 1;
	389	usb_bt_fifo_reset(&s->evt);
	390	usb_bt_fifo_reset(&s->acl);
	391	usb_bt_fifo_reset(&s->sco);
	392	break;
	393	}
4696425c GH	394	return ret;
4696425c GH	395	}
e6a6d5ab	396
4696425c	397	ret = 0;
e6a6d5ab	398	switch (request) {
e6a6d5ab AZ	399	case InterfaceRequest \| USB_REQ_GET_STATUS:
e6a6d5ab AZ	400	case EndpointRequest \| USB_REQ_GET_STATUS:
ed5a83dd	401	data[0] = 0x00;
e6a6d5ab AZ	402	data[1] = 0x00;
	403	ret = 2;
	404	break;
e6a6d5ab AZ	405	case InterfaceOutRequest \| USB_REQ_CLEAR_FEATURE:
e6a6d5ab AZ	406	case EndpointOutRequest \| USB_REQ_CLEAR_FEATURE:
ed5a83dd	407	goto fail;
e6a6d5ab AZ	408	case InterfaceOutRequest \| USB_REQ_SET_FEATURE:
e6a6d5ab AZ	409	case EndpointOutRequest \| USB_REQ_SET_FEATURE:
ed5a83dd	410	goto fail;
e6a6d5ab	411	break;
e6a6d5ab AZ	412	case InterfaceRequest \| USB_REQ_GET_INTERFACE:
	413	if (value != 0 \|\| (index & ~1) \|\| length != 1)
	414	goto fail;
	415	if (index == 1)
	416	data[0] = s->altsetting;
	417	else
	418	data[0] = 0;
	419	ret = 1;
	420	break;
	421	case InterfaceOutRequest \| USB_REQ_SET_INTERFACE:
	422	if ((index & ~1) \|\| length != 0 \|\|
	423	(index == 1 && (value < 0 \|\| value > 4)) \|\|
	424	(index == 0 && value != 0)) {
	425	printf("%s: Wrong SET_INTERFACE request (%i, %i)\n",
	426	__FUNCTION__, index, value);
	427	goto fail;
	428	}
	429	s->altsetting = value;
	430	ret = 0;
	431	break;
	432	case ((USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_DEVICE) << 8):
	433	if (s->config)
	434	usb_bt_fifo_out_enqueue(s, &s->outcmd, s->hci->cmd_send,
	435	usb_bt_hci_cmd_complete, data, length);
	436	break;
	437	default:
	438	fail:
	439	ret = USB_RET_STALL;
	440	break;
	441	}
	442	return ret;
	443	}
	444
	445	static int usb_bt_handle_data(USBDevice dev, USBPacket p)
	446	{
	447	struct USBBtState s = (struct USBBtState ) dev->opaque;
	448	int ret = 0;
	449
	450	if (!s->config)
	451	goto fail;
	452
	453	switch (p->pid) {
	454	case USB_TOKEN_IN:
	455	switch (p->devep & 0xf) {
	456	case USB_EVT_EP:
	457	ret = usb_bt_fifo_dequeue(&s->evt, p);
	458	break;
	459
	460	case USB_ACL_EP:
	461	ret = usb_bt_fifo_dequeue(&s->acl, p);
	462	break;
	463
	464	case USB_SCO_EP:
	465	ret = usb_bt_fifo_dequeue(&s->sco, p);
	466	break;
	467
	468	default:
	469	goto fail;
	470	}
	471	break;
	472
	473	case USB_TOKEN_OUT:
	474	switch (p->devep & 0xf) {
	475	case USB_ACL_EP:
476	usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send,
477	usb_bt_hci_acl_complete, p->data, p->len);
478	break;
479
480	case USB_SCO_EP:
481	usb_bt_fifo_out_enqueue(s, &s->outsco, s->hci->sco_send,
482	usb_bt_hci_sco_complete, p->data, p->len);
483	break;
484
485	default:
486	goto fail;
487	}
488	break;
489
490	default:
491	fail:
492	ret = USB_RET_STALL;
493	break;
494	}
495
496	return ret;
497	}
498
499	static void usb_bt_out_hci_packet_event(void *opaque,
500	const uint8_t *data, int len)
501	{
502	struct USBBtState s = (struct USBBtState ) opaque;
503
504	usb_bt_fifo_enqueue(&s->evt, data, len);
505	}
506
507	static void usb_bt_out_hci_packet_acl(void *opaque,
508	const uint8_t *data, int len)
509	{
510	struct USBBtState s = (struct USBBtState ) opaque;
511
512	usb_bt_fifo_enqueue(&s->acl, data, len);
513	}
514
515	static void usb_bt_handle_destroy(USBDevice *dev)
516	{
517	struct USBBtState s = (struct USBBtState ) dev->opaque;
518
511d2b14 BS	519	s->hci->opaque = NULL;
	520	s->hci->evt_recv = NULL;
	521	s->hci->acl_recv = NULL;
e6a6d5ab AZ	522	}
e6a6d5ab AZ	523
806b6024 GH	524	static int usb_bt_initfn(USBDevice *dev)
806b6024 GH	525	{
a980a065	526	usb_desc_init(dev);
806b6024 GH	527	return 0;
	528	}
	529
e6a6d5ab AZ	530	USBDevice usb_bt_init(HCIInfo hci)
e6a6d5ab AZ	531	{
806b6024	532	USBDevice *dev;
e6a6d5ab AZ	533	struct USBBtState *s;
e6a6d5ab AZ	534
2d564691 AZ	535	if (!hci)
2d564691 AZ	536	return NULL;
556cd098	537	dev = usb_create_simple(NULL /* FIXME */, "usb-bt-dongle");
806b6024	538	s = DO_UPCAST(struct USBBtState, dev, dev);
e6a6d5ab	539	s->dev.opaque = s;
e6a6d5ab AZ	540
	541	s->hci = hci;
	542	s->hci->opaque = s;
	543	s->hci->evt_recv = usb_bt_out_hci_packet_event;
	544	s->hci->acl_recv = usb_bt_out_hci_packet_acl;
	545
	546	usb_bt_handle_reset(&s->dev);
	547
806b6024 GH	548	return dev;
	549	}
	550
	551	static struct USBDeviceInfo bt_info = {
06384698	552	.product_desc = "QEMU BT dongle",
556cd098	553	.qdev.name = "usb-bt-dongle",
806b6024	554	.qdev.size = sizeof(struct USBBtState),
4696425c	555	.usb_desc = &desc_bluetooth,
806b6024 GH	556	.init = usb_bt_initfn,
	557	.handle_packet = usb_generic_handle_packet,
	558	.handle_reset = usb_bt_handle_reset,
	559	.handle_control = usb_bt_handle_control,
	560	.handle_data = usb_bt_handle_data,
	561	.handle_destroy = usb_bt_handle_destroy,
	562	};
	563
	564	static void usb_bt_register_devices(void)
	565	{
	566	usb_qdev_register(&bt_info);
e6a6d5ab	567	}
806b6024	568	device_init(usb_bt_register_devices)