[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 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->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;
    }

    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),
                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 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 ((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:
        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);
            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:
        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");
    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_packet  = usb_generic_handle_packet;
    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"
	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
e6a6d5ab AZ	31	int config;
	32
	33	#define CFIFO_LEN_MASK 255
	34	#define DFIFO_LEN_MASK 4095
	35	struct usb_hci_in_fifo_s {
	36	uint8_t data[(DFIFO_LEN_MASK + 1) * 2];
	37	struct {
	38	uint8_t *data;
	39	int len;
	40	} fifo[CFIFO_LEN_MASK + 1];
	41	int dstart, dlen, dsize, start, len;
	42	} evt, acl, sco;
	43
	44	struct usb_hci_out_fifo_s {
	45	uint8_t data[4096];
	46	int len;
	47	} outcmd, outacl, outsco;
	48	};
	49
	50	#define USB_EVT_EP 1
	51	#define USB_ACL_EP 2
	52	#define USB_SCO_EP 3
	53
4696425c GH	54	enum {
	55	STR_MANUFACTURER = 1,
	56	STR_SERIALNUMBER,
	57	};
e6a6d5ab	58
4696425c GH	59	static const USBDescStrings desc_strings = {
	60	[STR_MANUFACTURER] = "QEMU " QEMU_VERSION,
	61	[STR_SERIALNUMBER] = "1",
	62	};
e6a6d5ab	63
4696425c GH	64	static const USBDescIface desc_iface_bluetooth[] = {
	65	{
	66	.bInterfaceNumber = 0,
	67	.bNumEndpoints = 3,
	68	.bInterfaceClass = 0xe0, /* Wireless */
	69	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	70	.bInterfaceProtocol = 0x01, /* Bluetooth */
	71	.eps = (USBDescEndpoint[]) {
	72	{
	73	.bEndpointAddress = USB_DIR_IN \| USB_EVT_EP,
	74	.bmAttributes = USB_ENDPOINT_XFER_INT,
	75	.wMaxPacketSize = 0x10,
	76	.bInterval = 0x02,
	77	},
	78	{
	79	.bEndpointAddress = USB_DIR_OUT \| USB_ACL_EP,
	80	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	81	.wMaxPacketSize = 0x40,
	82	.bInterval = 0x0a,
	83	},
	84	{
	85	.bEndpointAddress = USB_DIR_IN \| USB_ACL_EP,
	86	.bmAttributes = USB_ENDPOINT_XFER_BULK,
	87	.wMaxPacketSize = 0x40,
	88	.bInterval = 0x0a,
	89	},
	90	},
	91	},{
	92	.bInterfaceNumber = 1,
	93	.bAlternateSetting = 0,
	94	.bNumEndpoints = 2,
	95	.bInterfaceClass = 0xe0, /* Wireless */
	96	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	97	.bInterfaceProtocol = 0x01, /* Bluetooth */
	98	.eps = (USBDescEndpoint[]) {
	99	{
	100	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	101	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	102	.wMaxPacketSize = 0,
	103	.bInterval = 0x01,
	104	},
	105	{
	106	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	107	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	108	.wMaxPacketSize = 0,
	109	.bInterval = 0x01,
	110	},
	111	},
	112	},{
	113	.bInterfaceNumber = 1,
	114	.bAlternateSetting = 1,
	115	.bNumEndpoints = 2,
	116	.bInterfaceClass = 0xe0, /* Wireless */
	117	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	118	.bInterfaceProtocol = 0x01, /* Bluetooth */
	119	.eps = (USBDescEndpoint[]) {
	120	{
	121	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	122	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	123	.wMaxPacketSize = 0x09,
	124	.bInterval = 0x01,
	125	},
	126	{
	127	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	128	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	129	.wMaxPacketSize = 0x09,
	130	.bInterval = 0x01,
	131	},
	132	},
	133	},{
	134	.bInterfaceNumber = 1,
	135	.bAlternateSetting = 2,
	136	.bNumEndpoints = 2,
	137	.bInterfaceClass = 0xe0, /* Wireless */
	138	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	139	.bInterfaceProtocol = 0x01, /* Bluetooth */
	140	.eps = (USBDescEndpoint[]) {
	141	{
	142	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	143	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	144	.wMaxPacketSize = 0x11,
	145	.bInterval = 0x01,
	146	},
	147	{
	148	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	149	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	150	.wMaxPacketSize = 0x11,
	151	.bInterval = 0x01,
	152	},
	153	},
	154	},{
	155	.bInterfaceNumber = 1,
	156	.bAlternateSetting = 3,
	157	.bNumEndpoints = 2,
	158	.bInterfaceClass = 0xe0, /* Wireless */
	159	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	160	.bInterfaceProtocol = 0x01, /* Bluetooth */
	161	.eps = (USBDescEndpoint[]) {
	162	{
	163	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	164	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	165	.wMaxPacketSize = 0x19,
	166	.bInterval = 0x01,
	167	},
	168	{
	169	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	170	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	171	.wMaxPacketSize = 0x19,
	172	.bInterval = 0x01,
	173	},
	174	},
	175	},{
	176	.bInterfaceNumber = 1,
	177	.bAlternateSetting = 4,
	178	.bNumEndpoints = 2,
	179	.bInterfaceClass = 0xe0, /* Wireless */
	180	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	181	.bInterfaceProtocol = 0x01, /* Bluetooth */
	182	.eps = (USBDescEndpoint[]) {
	183	{
	184	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	185	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	186	.wMaxPacketSize = 0x21,
	187	.bInterval = 0x01,
	188	},
	189	{
	190	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	191	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	192	.wMaxPacketSize = 0x21,
	193	.bInterval = 0x01,
	194	},
	195	},
	196	},{
	197	.bInterfaceNumber = 1,
	198	.bAlternateSetting = 5,
	199	.bNumEndpoints = 2,
	200	.bInterfaceClass = 0xe0, /* Wireless */
	201	.bInterfaceSubClass = 0x01, /* Radio Frequency */
	202	.bInterfaceProtocol = 0x01, /* Bluetooth */
	203	.eps = (USBDescEndpoint[]) {
	204	{
	205	.bEndpointAddress = USB_DIR_OUT \| USB_SCO_EP,
dd850cf2	206	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	207	.wMaxPacketSize = 0x31,
	208	.bInterval = 0x01,
	209	},
	210	{
	211	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
dd850cf2	212	.bmAttributes = USB_ENDPOINT_XFER_ISOC,
4696425c GH	213	.wMaxPacketSize = 0x31,
	214	.bInterval = 0x01,
	215	},
	216	},
	217	}
	218	};
e6a6d5ab	219
4696425c GH	220	static const USBDescDevice desc_device_bluetooth = {
	221	.bcdUSB = 0x0110,
	222	.bDeviceClass = 0xe0, /* Wireless */
	223	.bDeviceSubClass = 0x01, /* Radio Frequency */
	224	.bDeviceProtocol = 0x01, /* Bluetooth */
	225	.bMaxPacketSize0 = 64,
	226	.bNumConfigurations = 1,
	227	.confs = (USBDescConfig[]) {
	228	{
	229	.bNumInterfaces = 2,
	230	.bConfigurationValue = 1,
	231	.bmAttributes = 0xc0,
	232	.bMaxPower = 0,
	233	.nif = ARRAY_SIZE(desc_iface_bluetooth),
	234	.ifs = desc_iface_bluetooth,
	235	},
	236	},
e6a6d5ab AZ	237	};
e6a6d5ab AZ	238
4696425c GH	239	static const USBDesc desc_bluetooth = {
	240	.id = {
	241	.idVendor = 0x0a12,
	242	.idProduct = 0x0001,
	243	.bcdDevice = 0x1958,
	244	.iManufacturer = STR_MANUFACTURER,
	245	.iProduct = 0,
	246	.iSerialNumber = STR_SERIALNUMBER,
	247	},
	248	.full = &desc_device_bluetooth,
	249	.str = desc_strings,
e6a6d5ab AZ	250	};
	251
	252	static void usb_bt_fifo_reset(struct usb_hci_in_fifo_s *fifo)
	253	{
	254	fifo->dstart = 0;
	255	fifo->dlen = 0;
	256	fifo->dsize = DFIFO_LEN_MASK + 1;
	257	fifo->start = 0;
	258	fifo->len = 0;
	259	}
	260
	261	static void usb_bt_fifo_enqueue(struct usb_hci_in_fifo_s *fifo,
	262	const uint8_t *data, int len)
	263	{
	264	int off = fifo->dstart + fifo->dlen;
	265	uint8_t *buf;
	266
	267	fifo->dlen += len;
	268	if (off <= DFIFO_LEN_MASK) {
	269	if (off + len > DFIFO_LEN_MASK + 1 &&
	270	(fifo->dsize = off + len) > (DFIFO_LEN_MASK + 1) * 2) {
	271	fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
	272	exit(-1);
	273	}
	274	buf = fifo->data + off;
	275	} else {
	276	if (fifo->dlen > fifo->dsize) {
	277	fprintf(stderr, "%s: can't alloc %i bytes\n", __FUNCTION__, len);
	278	exit(-1);
	279	}
	280	buf = fifo->data + off - fifo->dsize;
	281	}
	282
	283	off = (fifo->start + fifo->len ++) & CFIFO_LEN_MASK;
	284	fifo->fifo[off].data = memcpy(buf, data, len);
	285	fifo->fifo[off].len = len;
	286	}
	287
	288	static inline int usb_bt_fifo_dequeue(struct usb_hci_in_fifo_s *fifo,
	289	USBPacket *p)
	290	{
	291	int len;
	292
	293	if (likely(!fifo->len))
	294	return USB_RET_STALL;
	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	}
	313
	314	return len;
	315	}
	316
86178a57	317	static inline void usb_bt_fifo_out_enqueue(struct USBBtState *s,
e6a6d5ab AZ	318	struct usb_hci_out_fifo_s *fifo,
	319	void (send)(struct HCIInfo , const uint8_t *, int),
	320	int (complete)(const uint8_t , int),
4f4321c1	321	USBPacket *p)
e6a6d5ab	322	{
4f4321c1 GH	323	usb_packet_copy(p, fifo->data + fifo->len, p->iov.size);
	324	fifo->len += p->iov.size;
	325	if (complete(fifo->data, fifo->len)) {
	326	send(s->hci, fifo->data, fifo->len);
	327	fifo->len = 0;
e6a6d5ab AZ	328	}
	329
	330	/* TODO: do we need to loop? */
	331	}
	332
	333	static int usb_bt_hci_cmd_complete(const uint8_t *data, int len)
	334	{
	335	len -= HCI_COMMAND_HDR_SIZE;
	336	return len >= 0 &&
	337	len >= ((struct hci_command_hdr *) data)->plen;
	338	}
	339
	340	static int usb_bt_hci_acl_complete(const uint8_t *data, int len)
	341	{
	342	len -= HCI_ACL_HDR_SIZE;
	343	return len >= 0 &&
	344	len >= le16_to_cpu(((struct hci_acl_hdr *) data)->dlen);
	345	}
	346
	347	static int usb_bt_hci_sco_complete(const uint8_t *data, int len)
	348	{
	349	len -= HCI_SCO_HDR_SIZE;
	350	return len >= 0 &&
	351	len >= ((struct hci_sco_hdr *) data)->dlen;
	352	}
	353
	354	static void usb_bt_handle_reset(USBDevice *dev)
	355	{
	356	struct USBBtState s = (struct USBBtState ) dev->opaque;
	357
	358	usb_bt_fifo_reset(&s->evt);
	359	usb_bt_fifo_reset(&s->acl);
	360	usb_bt_fifo_reset(&s->sco);
	361	s->outcmd.len = 0;
	362	s->outacl.len = 0;
	363	s->outsco.len = 0;
e6a6d5ab AZ	364	}
e6a6d5ab AZ	365
007fd62f HG	366	static int usb_bt_handle_control(USBDevice dev, USBPacket p,
007fd62f HG	367	int request, int value, int index, int length, uint8_t *data)
e6a6d5ab AZ	368	{
e6a6d5ab AZ	369	struct USBBtState s = (struct USBBtState ) dev->opaque;
4696425c GH	370	int ret;
4696425c GH	371
007fd62f	372	ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
4696425c	373	if (ret >= 0) {
a980a065 GH	374	switch (request) {
	375	case DeviceRequest \| USB_REQ_GET_CONFIGURATION:
	376	s->config = 0;
	377	break;
	378	case DeviceOutRequest \| USB_REQ_SET_CONFIGURATION:
	379	s->config = 1;
	380	usb_bt_fifo_reset(&s->evt);
	381	usb_bt_fifo_reset(&s->acl);
	382	usb_bt_fifo_reset(&s->sco);
	383	break;
	384	}
4696425c GH	385	return ret;
4696425c GH	386	}
e6a6d5ab	387
4696425c	388	ret = 0;
e6a6d5ab	389	switch (request) {
e6a6d5ab AZ	390	case InterfaceRequest \| USB_REQ_GET_STATUS:
e6a6d5ab AZ	391	case EndpointRequest \| USB_REQ_GET_STATUS:
ed5a83dd	392	data[0] = 0x00;
e6a6d5ab AZ	393	data[1] = 0x00;
	394	ret = 2;
	395	break;
e6a6d5ab AZ	396	case InterfaceOutRequest \| USB_REQ_CLEAR_FEATURE:
e6a6d5ab AZ	397	case EndpointOutRequest \| USB_REQ_CLEAR_FEATURE:
ed5a83dd	398	goto fail;
e6a6d5ab AZ	399	case InterfaceOutRequest \| USB_REQ_SET_FEATURE:
e6a6d5ab AZ	400	case EndpointOutRequest \| USB_REQ_SET_FEATURE:
ed5a83dd	401	goto fail;
e6a6d5ab	402	break;
e6a6d5ab AZ	403	case ((USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_DEVICE) << 8):
	404	if (s->config)
	405	usb_bt_fifo_out_enqueue(s, &s->outcmd, s->hci->cmd_send,
4f4321c1	406	usb_bt_hci_cmd_complete, p);
e6a6d5ab AZ	407	break;
	408	default:
	409	fail:
	410	ret = USB_RET_STALL;
	411	break;
	412	}
	413	return ret;
	414	}
	415
	416	static int usb_bt_handle_data(USBDevice dev, USBPacket p)
	417	{
	418	struct USBBtState s = (struct USBBtState ) dev->opaque;
	419	int ret = 0;
	420
	421	if (!s->config)
	422	goto fail;
	423
	424	switch (p->pid) {
	425	case USB_TOKEN_IN:
	426	switch (p->devep & 0xf) {
	427	case USB_EVT_EP:
	428	ret = usb_bt_fifo_dequeue(&s->evt, p);
	429	break;
	430
	431	case USB_ACL_EP:
	432	ret = usb_bt_fifo_dequeue(&s->acl, p);
	433	break;
	434
	435	case USB_SCO_EP:
	436	ret = usb_bt_fifo_dequeue(&s->sco, p);
	437	break;
	438
	439	default:
	440	goto fail;
	441	}
	442	break;
	443
	444	case USB_TOKEN_OUT:
	445	switch (p->devep & 0xf) {
	446	case USB_ACL_EP:
	447	usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send,
4f4321c1	448	usb_bt_hci_acl_complete, p);
e6a6d5ab AZ	449	break;
	450
	451	case USB_SCO_EP:
	452	usb_bt_fifo_out_enqueue(s, &s->outsco, s->hci->sco_send,
4f4321c1	453	usb_bt_hci_sco_complete, p);
e6a6d5ab AZ	454	break;
	455
	456	default:
	457	goto fail;
	458	}
	459	break;
	460
	461	default:
	462	fail:
	463	ret = USB_RET_STALL;
	464	break;
	465	}
	466
	467	return ret;
	468	}
	469
	470	static void usb_bt_out_hci_packet_event(void *opaque,
	471	const uint8_t *data, int len)
	472	{
	473	struct USBBtState s = (struct USBBtState ) opaque;
	474
	475	usb_bt_fifo_enqueue(&s->evt, data, len);
	476	}
	477
	478	static void usb_bt_out_hci_packet_acl(void *opaque,
	479	const uint8_t *data, int len)
	480	{
	481	struct USBBtState s = (struct USBBtState ) opaque;
	482
	483	usb_bt_fifo_enqueue(&s->acl, data, len);
	484	}
	485
	486	static void usb_bt_handle_destroy(USBDevice *dev)
	487	{
	488	struct USBBtState s = (struct USBBtState ) dev->opaque;
	489
511d2b14 BS	490	s->hci->opaque = NULL;
	491	s->hci->evt_recv = NULL;
	492	s->hci->acl_recv = NULL;
e6a6d5ab AZ	493	}
e6a6d5ab AZ	494
806b6024 GH	495	static int usb_bt_initfn(USBDevice *dev)
806b6024 GH	496	{
a980a065	497	usb_desc_init(dev);
806b6024 GH	498	return 0;
	499	}
	500
e6a6d5ab AZ	501	USBDevice usb_bt_init(HCIInfo hci)
e6a6d5ab AZ	502	{
806b6024	503	USBDevice *dev;
e6a6d5ab AZ	504	struct USBBtState *s;
e6a6d5ab AZ	505
2d564691 AZ	506	if (!hci)
2d564691 AZ	507	return NULL;
556cd098	508	dev = usb_create_simple(NULL /* FIXME */, "usb-bt-dongle");
2af2a1b8 GH	509	if (!dev) {
	510	return NULL;
	511	}
806b6024	512	s = DO_UPCAST(struct USBBtState, dev, dev);
e6a6d5ab	513	s->dev.opaque = s;
e6a6d5ab AZ	514
	515	s->hci = hci;
	516	s->hci->opaque = s;
	517	s->hci->evt_recv = usb_bt_out_hci_packet_event;
	518	s->hci->acl_recv = usb_bt_out_hci_packet_acl;
	519
	520	usb_bt_handle_reset(&s->dev);
	521
806b6024 GH	522	return dev;
	523	}
	524
2474e505 GH	525	static const VMStateDescription vmstate_usb_bt = {
	526	.name = "usb-bt",
	527	.unmigratable = 1,
	528	};
	529
62aed765 AL	530	static void usb_bt_class_initfn(ObjectClass klass, void data)
62aed765 AL	531	{
39bffca2	532	DeviceClass *dc = DEVICE_CLASS(klass);
62aed765 AL	533	USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
	534
	535	uc->init = usb_bt_initfn;
	536	uc->product_desc = "QEMU BT dongle";
	537	uc->usb_desc = &desc_bluetooth;
	538	uc->handle_packet = usb_generic_handle_packet;
	539	uc->handle_reset = usb_bt_handle_reset;
	540	uc->handle_control = usb_bt_handle_control;
	541	uc->handle_data = usb_bt_handle_data;
	542	uc->handle_destroy = usb_bt_handle_destroy;
39bffca2	543	dc->vmsd = &vmstate_usb_bt;
62aed765 AL	544	}
62aed765 AL	545
39bffca2 AL	546	static TypeInfo bt_info = {
	547	.name = "usb-bt-dongle",
	548	.parent = TYPE_USB_DEVICE,
	549	.instance_size = sizeof(struct USBBtState),
	550	.class_init = usb_bt_class_initfn,
806b6024 GH	551	};
806b6024 GH	552
83f7d43a	553	static void usb_bt_register_types(void)
806b6024	554	{
39bffca2	555	type_register_static(&bt_info);
e6a6d5ab	556	}
83f7d43a AF	557
83f7d43a AF	558	type_init(usb_bt_register_types)