[qemu.git] / hw / usb / dev-bluetooth.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 "hw/usb.h"
#include "hw/usb/desc.h"
#include "bt/bt.h"
#include "hw/bt.h"

struct USBBtState {
    USBDevice dev;
    struct HCIInfo *hci;
    USBEndpoint *intr;

    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",
    [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 void usb_bt_fifo_dequeue(struct usb_hci_in_fifo_s *fifo,
                USBPacket *p)
{
    int len;

    assert(fifo->len != 0);

    len = MIN(p->iov.size, fifo->fifo[fifo->start].len);
    usb_packet_copy(p, fifo->fifo[fifo->start].data, len);
    if (len == p->iov.size) {
        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;
    }
}

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),
                USBPacket *p)
{
    usb_packet_copy(p, fifo->data + fifo->len, p->iov.size);
    fifo->len += p->iov.size;
    if (complete(fifo->data, fifo->len)) {
        send(s->hci, fifo->data, fifo->len);
        fifo->len = 0;
    }

    /* 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;
}

static void 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;
    }

    switch (request) {
    case InterfaceRequest | USB_REQ_GET_STATUS:
    case EndpointRequest | USB_REQ_GET_STATUS:
        data[0] = 0x00;
        data[1] = 0x00;
        p->actual_length = 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 ((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, p);
        break;
    default:
    fail:
        p->status = USB_RET_STALL;
        break;
    }
}

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

    if (!s->config)
        goto fail;

    switch (p->pid) {
    case USB_TOKEN_IN:
        switch (p->ep->nr) {
        case USB_EVT_EP:
            if (s->evt.len == 0) {
                p->status = USB_RET_NAK;
                break;
            }
            usb_bt_fifo_dequeue(&s->evt, p);
            break;

        case USB_ACL_EP:
            if (s->evt.len == 0) {
                p->status = USB_RET_STALL;
                break;
            }
            usb_bt_fifo_dequeue(&s->acl, p);
            break;

        case USB_SCO_EP:
            if (s->evt.len == 0) {
                p->status = USB_RET_STALL;
                break;
            }
            usb_bt_fifo_dequeue(&s->sco, p);
            break;

        default:
            goto fail;
        }
        break;

    case USB_TOKEN_OUT:
        switch (p->ep->nr) {
        case USB_ACL_EP:
            usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send,
                            usb_bt_hci_acl_complete, p);
            break;

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

        default:
            goto fail;
        }
        break;

    default:
    fail:
        p->status = USB_RET_STALL;
        break;
    }
}

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

    if (s->evt.len == 0) {
        usb_wakeup(s->intr);
    }
    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)
{
    struct USBBtState *s = DO_UPCAST(struct USBBtState, dev, dev);

    usb_desc_create_serial(dev);
    usb_desc_init(dev);
    s->intr = usb_ep_get(dev, USB_TOKEN_IN, USB_EVT_EP);

    return 0;
}

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

    if (!hci)
        return NULL;
    dev = usb_create_simple(bus, "usb-bt-dongle");
    if (!dev) {
        return NULL;
    }
    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 const VMStateDescription vmstate_usb_bt = {
    .name = "usb-bt",
    .unmigratable = 1,
};

static void usb_bt_class_initfn(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);
    USBDeviceClass *uc = USB_DEVICE_CLASS(klass);

    uc->init           = usb_bt_initfn;
    uc->product_desc   = "QEMU BT dongle";
    uc->usb_desc       = &desc_bluetooth;
    uc->handle_reset   = usb_bt_handle_reset;
    uc->handle_control = usb_bt_handle_control;
    uc->handle_data    = usb_bt_handle_data;
    uc->handle_destroy = usb_bt_handle_destroy;
    dc->vmsd = &vmstate_usb_bt;
}

static TypeInfo bt_info = {
    .name          = "usb-bt-dongle",
    .parent        = TYPE_USB_DEVICE,
    .instance_size = sizeof(struct USBBtState),
    .class_init    = usb_bt_class_initfn,
};

static void usb_bt_register_types(void)
{
    type_register_static(&bt_info);
}

type_init(usb_bt_register_types)
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"
f1ae32a1 GH	22	#include "hw/usb.h"
f1ae32a1 GH	23	#include "hw/usb/desc.h"
927d4878	24	#include "bt/bt.h"
f1ae32a1	25	#include "hw/bt.h"
e6a6d5ab AZ	26
	27	struct USBBtState {
	28	USBDevice dev;
	29	struct HCIInfo *hci;
33c1a685	30	USBEndpoint *intr;
e6a6d5ab	31
e6a6d5ab AZ	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	60	static const USBDescStrings desc_strings = {
93bfef4c	61	[STR_MANUFACTURER] = "QEMU",
4696425c GH	62	[STR_SERIALNUMBER] = "1",
4696425c GH	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
9a77a0f5	289	static inline void usb_bt_fifo_dequeue(struct usb_hci_in_fifo_s *fifo,
e6a6d5ab AZ	290	USBPacket *p)
	291	{
	292	int len;
	293
33c1a685	294	assert(fifo->len != 0);
e6a6d5ab	295
4f4321c1 GH	296	len = MIN(p->iov.size, fifo->fifo[fifo->start].len);
	297	usb_packet_copy(p, fifo->fifo[fifo->start].data, len);
	298	if (len == p->iov.size) {
e6a6d5ab AZ	299	fifo->fifo[fifo->start].len -= len;
	300	fifo->fifo[fifo->start].data += len;
	301	} else {
	302	fifo->start ++;
	303	fifo->start &= CFIFO_LEN_MASK;
	304	fifo->len --;
	305	}
	306
	307	fifo->dstart += len;
	308	fifo->dlen -= len;
	309	if (fifo->dstart >= fifo->dsize) {
	310	fifo->dstart = 0;
	311	fifo->dsize = DFIFO_LEN_MASK + 1;
	312	}
e6a6d5ab AZ	313	}
e6a6d5ab AZ	314
86178a57	315	static inline void usb_bt_fifo_out_enqueue(struct USBBtState *s,
e6a6d5ab AZ	316	struct usb_hci_out_fifo_s *fifo,
	317	void (send)(struct HCIInfo , const uint8_t *, int),
	318	int (complete)(const uint8_t , int),
4f4321c1	319	USBPacket *p)
e6a6d5ab	320	{
4f4321c1 GH	321	usb_packet_copy(p, fifo->data + fifo->len, p->iov.size);
	322	fifo->len += p->iov.size;
	323	if (complete(fifo->data, fifo->len)) {
	324	send(s->hci, fifo->data, fifo->len);
	325	fifo->len = 0;
e6a6d5ab AZ	326	}
	327
	328	/* TODO: do we need to loop? */
	329	}
	330
	331	static int usb_bt_hci_cmd_complete(const uint8_t *data, int len)
	332	{
	333	len -= HCI_COMMAND_HDR_SIZE;
	334	return len >= 0 &&
	335	len >= ((struct hci_command_hdr *) data)->plen;
	336	}
	337
	338	static int usb_bt_hci_acl_complete(const uint8_t *data, int len)
	339	{
	340	len -= HCI_ACL_HDR_SIZE;
	341	return len >= 0 &&
	342	len >= le16_to_cpu(((struct hci_acl_hdr *) data)->dlen);
	343	}
	344
	345	static int usb_bt_hci_sco_complete(const uint8_t *data, int len)
	346	{
	347	len -= HCI_SCO_HDR_SIZE;
	348	return len >= 0 &&
	349	len >= ((struct hci_sco_hdr *) data)->dlen;
	350	}
	351
	352	static void usb_bt_handle_reset(USBDevice *dev)
	353	{
	354	struct USBBtState s = (struct USBBtState ) dev->opaque;
	355
	356	usb_bt_fifo_reset(&s->evt);
	357	usb_bt_fifo_reset(&s->acl);
	358	usb_bt_fifo_reset(&s->sco);
	359	s->outcmd.len = 0;
	360	s->outacl.len = 0;
	361	s->outsco.len = 0;
e6a6d5ab AZ	362	}
e6a6d5ab AZ	363
9a77a0f5	364	static void usb_bt_handle_control(USBDevice dev, USBPacket p,
007fd62f	365	int request, int value, int index, int length, uint8_t *data)
e6a6d5ab AZ	366	{
e6a6d5ab AZ	367	struct USBBtState s = (struct USBBtState ) dev->opaque;
4696425c GH	368	int ret;
4696425c GH	369
007fd62f	370	ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
4696425c	371	if (ret >= 0) {
a980a065 GH	372	switch (request) {
	373	case DeviceRequest \| USB_REQ_GET_CONFIGURATION:
	374	s->config = 0;
	375	break;
	376	case DeviceOutRequest \| USB_REQ_SET_CONFIGURATION:
	377	s->config = 1;
	378	usb_bt_fifo_reset(&s->evt);
	379	usb_bt_fifo_reset(&s->acl);
	380	usb_bt_fifo_reset(&s->sco);
	381	break;
	382	}
9a77a0f5	383	return;
4696425c	384	}
e6a6d5ab AZ	385
e6a6d5ab AZ	386	switch (request) {
e6a6d5ab AZ	387	case InterfaceRequest \| USB_REQ_GET_STATUS:
e6a6d5ab AZ	388	case EndpointRequest \| USB_REQ_GET_STATUS:
ed5a83dd	389	data[0] = 0x00;
e6a6d5ab	390	data[1] = 0x00;
9a77a0f5	391	p->actual_length = 2;
e6a6d5ab	392	break;
e6a6d5ab AZ	393	case InterfaceOutRequest \| USB_REQ_CLEAR_FEATURE:
e6a6d5ab AZ	394	case EndpointOutRequest \| USB_REQ_CLEAR_FEATURE:
ed5a83dd	395	goto fail;
e6a6d5ab AZ	396	case InterfaceOutRequest \| USB_REQ_SET_FEATURE:
e6a6d5ab AZ	397	case EndpointOutRequest \| USB_REQ_SET_FEATURE:
ed5a83dd	398	goto fail;
e6a6d5ab	399	break;
e6a6d5ab AZ	400	case ((USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_DEVICE) << 8):
	401	if (s->config)
	402	usb_bt_fifo_out_enqueue(s, &s->outcmd, s->hci->cmd_send,
4f4321c1	403	usb_bt_hci_cmd_complete, p);
e6a6d5ab AZ	404	break;
	405	default:
	406	fail:
9a77a0f5	407	p->status = USB_RET_STALL;
e6a6d5ab AZ	408	break;
e6a6d5ab AZ	409	}
e6a6d5ab AZ	410	}
e6a6d5ab AZ	411
9a77a0f5	412	static void usb_bt_handle_data(USBDevice dev, USBPacket p)
e6a6d5ab AZ	413	{
e6a6d5ab AZ	414	struct USBBtState s = (struct USBBtState ) dev->opaque;
e6a6d5ab AZ	415
	416	if (!s->config)
	417	goto fail;
	418
	419	switch (p->pid) {
	420	case USB_TOKEN_IN:
079d0b7f	421	switch (p->ep->nr) {
e6a6d5ab	422	case USB_EVT_EP:
33c1a685 HG	423	if (s->evt.len == 0) {
	424	p->status = USB_RET_NAK;
	425	break;
	426	}
9a77a0f5	427	usb_bt_fifo_dequeue(&s->evt, p);
e6a6d5ab AZ	428	break;
	429
	430	case USB_ACL_EP:
33c1a685 HG	431	if (s->evt.len == 0) {
	432	p->status = USB_RET_STALL;
	433	break;
	434	}
9a77a0f5	435	usb_bt_fifo_dequeue(&s->acl, p);
e6a6d5ab AZ	436	break;
	437
	438	case USB_SCO_EP:
33c1a685 HG	439	if (s->evt.len == 0) {
	440	p->status = USB_RET_STALL;
	441	break;
	442	}
9a77a0f5	443	usb_bt_fifo_dequeue(&s->sco, p);
e6a6d5ab AZ	444	break;
	445
	446	default:
	447	goto fail;
	448	}
	449	break;
	450
	451	case USB_TOKEN_OUT:
079d0b7f	452	switch (p->ep->nr) {
e6a6d5ab AZ	453	case USB_ACL_EP:
e6a6d5ab AZ	454	usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send,
4f4321c1	455	usb_bt_hci_acl_complete, p);
e6a6d5ab AZ	456	break;
	457
	458	case USB_SCO_EP:
	459	usb_bt_fifo_out_enqueue(s, &s->outsco, s->hci->sco_send,
4f4321c1	460	usb_bt_hci_sco_complete, p);
e6a6d5ab AZ	461	break;
	462
	463	default:
	464	goto fail;
	465	}
	466	break;
	467
	468	default:
	469	fail:
9a77a0f5	470	p->status = USB_RET_STALL;
e6a6d5ab AZ	471	break;
e6a6d5ab AZ	472	}
e6a6d5ab AZ	473	}
	474
	475	static void usb_bt_out_hci_packet_event(void *opaque,
	476	const uint8_t *data, int len)
	477	{
	478	struct USBBtState s = (struct USBBtState ) opaque;
	479
33c1a685 HG	480	if (s->evt.len == 0) {
	481	usb_wakeup(s->intr);
	482	}
e6a6d5ab AZ	483	usb_bt_fifo_enqueue(&s->evt, data, len);
	484	}
	485
	486	static void usb_bt_out_hci_packet_acl(void *opaque,
	487	const uint8_t *data, int len)
	488	{
	489	struct USBBtState s = (struct USBBtState ) opaque;
	490
	491	usb_bt_fifo_enqueue(&s->acl, data, len);
	492	}
	493
	494	static void usb_bt_handle_destroy(USBDevice *dev)
	495	{
	496	struct USBBtState s = (struct USBBtState ) dev->opaque;
	497
511d2b14 BS	498	s->hci->opaque = NULL;
	499	s->hci->evt_recv = NULL;
	500	s->hci->acl_recv = NULL;
e6a6d5ab AZ	501	}
e6a6d5ab AZ	502
806b6024 GH	503	static int usb_bt_initfn(USBDevice *dev)
806b6024 GH	504	{
33c1a685 HG	505	struct USBBtState *s = DO_UPCAST(struct USBBtState, dev, dev);
33c1a685 HG	506
9d55d1ad	507	usb_desc_create_serial(dev);
a980a065	508	usb_desc_init(dev);
33c1a685 HG	509	s->intr = usb_ep_get(dev, USB_TOKEN_IN, USB_EVT_EP);
33c1a685 HG	510
806b6024 GH	511	return 0;
	512	}
	513
3741715c	514	USBDevice usb_bt_init(USBBus bus, HCIInfo *hci)
e6a6d5ab	515	{
806b6024	516	USBDevice *dev;
e6a6d5ab AZ	517	struct USBBtState *s;
e6a6d5ab AZ	518
2d564691 AZ	519	if (!hci)
2d564691 AZ	520	return NULL;
3741715c	521	dev = usb_create_simple(bus, "usb-bt-dongle");
2af2a1b8 GH	522	if (!dev) {
	523	return NULL;
	524	}
806b6024	525	s = DO_UPCAST(struct USBBtState, dev, dev);
e6a6d5ab	526	s->dev.opaque = s;
e6a6d5ab AZ	527
	528	s->hci = hci;
	529	s->hci->opaque = s;
	530	s->hci->evt_recv = usb_bt_out_hci_packet_event;
	531	s->hci->acl_recv = usb_bt_out_hci_packet_acl;
	532
	533	usb_bt_handle_reset(&s->dev);
	534
806b6024 GH	535	return dev;
	536	}
	537
2474e505 GH	538	static const VMStateDescription vmstate_usb_bt = {
	539	.name = "usb-bt",
	540	.unmigratable = 1,
	541	};
	542
62aed765 AL	543	static void usb_bt_class_initfn(ObjectClass klass, void data)
62aed765 AL	544	{
39bffca2	545	DeviceClass *dc = DEVICE_CLASS(klass);
62aed765 AL	546	USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
	547
	548	uc->init = usb_bt_initfn;
	549	uc->product_desc = "QEMU BT dongle";
	550	uc->usb_desc = &desc_bluetooth;
62aed765 AL	551	uc->handle_reset = usb_bt_handle_reset;
	552	uc->handle_control = usb_bt_handle_control;
	553	uc->handle_data = usb_bt_handle_data;
	554	uc->handle_destroy = usb_bt_handle_destroy;
39bffca2	555	dc->vmsd = &vmstate_usb_bt;
62aed765 AL	556	}
62aed765 AL	557
39bffca2 AL	558	static TypeInfo bt_info = {
	559	.name = "usb-bt-dongle",
	560	.parent = TYPE_USB_DEVICE,
	561	.instance_size = sizeof(struct USBBtState),
	562	.class_init = usb_bt_class_initfn,
806b6024 GH	563	};
806b6024 GH	564
83f7d43a	565	static void usb_bt_register_types(void)
806b6024	566	{
39bffca2	567	type_register_static(&bt_info);
e6a6d5ab	568	}
83f7d43a AF	569
83f7d43a AF	570	type_init(usb_bt_register_types)