[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_INT,
                .wMaxPacketSize        = 0,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_INT,
                .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_INT,
                .wMaxPacketSize        = 0x09,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_INT,
                .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_INT,
                .wMaxPacketSize        = 0x11,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_INT,
                .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_INT,
                .wMaxPacketSize        = 0x19,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_INT,
                .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_INT,
                .wMaxPacketSize        = 0x21,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_INT,
                .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_INT,
                .wMaxPacketSize        = 0x31,
                .bInterval             = 0x01,
            },
            {
                .bEndpointAddress      = USB_DIR_IN | USB_SCO_EP,
                .bmAttributes          = USB_ENDPOINT_XFER_INT,
                .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, 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, 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 DeviceRequest | USB_REQ_GET_STATUS:
    case InterfaceRequest | USB_REQ_GET_STATUS:
    case EndpointRequest | USB_REQ_GET_STATUS:
        data[0] = (1 << USB_DEVICE_SELF_POWERED) |
            (dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
        data[1] = 0x00;
        ret = 2;
        break;
    case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
    case InterfaceOutRequest | USB_REQ_CLEAR_FEATURE:
    case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
        if (value == USB_DEVICE_REMOTE_WAKEUP) {
            dev->remote_wakeup = 0;
        } else {
            goto fail;
        }
        ret = 0;
        break;
    case DeviceOutRequest | USB_REQ_SET_FEATURE:
    case InterfaceOutRequest | USB_REQ_SET_FEATURE:
    case EndpointOutRequest | USB_REQ_SET_FEATURE:
        if (value == USB_DEVICE_REMOTE_WAKEUP) {
            dev->remote_wakeup = 1;
        } else {
            goto fail;
        }
        ret = 0;
        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,
	102	.bmAttributes = USB_ENDPOINT_XFER_INT,
	103	.wMaxPacketSize = 0,
	104	.bInterval = 0x01,
	105	},
	106	{
	107	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
	108	.bmAttributes = USB_ENDPOINT_XFER_INT,
	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,
	123	.bmAttributes = USB_ENDPOINT_XFER_INT,
	124	.wMaxPacketSize = 0x09,
	125	.bInterval = 0x01,
	126	},
	127	{
	128	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
129	.bmAttributes = USB_ENDPOINT_XFER_INT,
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,
144	.bmAttributes = USB_ENDPOINT_XFER_INT,
145	.wMaxPacketSize = 0x11,
146	.bInterval = 0x01,
147	},
148	{
149	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
150	.bmAttributes = USB_ENDPOINT_XFER_INT,
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,
165	.bmAttributes = USB_ENDPOINT_XFER_INT,
166	.wMaxPacketSize = 0x19,
167	.bInterval = 0x01,
168	},
169	{
170	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
171	.bmAttributes = USB_ENDPOINT_XFER_INT,
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,
186	.bmAttributes = USB_ENDPOINT_XFER_INT,
187	.wMaxPacketSize = 0x21,
188	.bInterval = 0x01,
189	},
190	{
191	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
192	.bmAttributes = USB_ENDPOINT_XFER_INT,
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,
207	.bmAttributes = USB_ENDPOINT_XFER_INT,
208	.wMaxPacketSize = 0x31,
209	.bInterval = 0x01,
210	},
211	{
212	.bEndpointAddress = USB_DIR_IN \| USB_SCO_EP,
213	.bmAttributes = USB_ENDPOINT_XFER_INT,
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
	375	static int usb_bt_handle_control(USBDevice *dev, int request, int value,
	376	int index, int length, uint8_t *data)
	377	{
	378	struct USBBtState s = (struct USBBtState ) dev->opaque;
4696425c GH	379	int ret;
	380
	381	ret = usb_desc_handle_control(dev, request, value, index, length, data);
	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 AZ	398	switch (request) {
	399	case DeviceRequest \| USB_REQ_GET_STATUS:
	400	case InterfaceRequest \| USB_REQ_GET_STATUS:
	401	case EndpointRequest \| USB_REQ_GET_STATUS:
	402	data[0] = (1 << USB_DEVICE_SELF_POWERED) \|
	403	(dev->remote_wakeup << USB_DEVICE_REMOTE_WAKEUP);
	404	data[1] = 0x00;
	405	ret = 2;
	406	break;
	407	case DeviceOutRequest \| USB_REQ_CLEAR_FEATURE:
	408	case InterfaceOutRequest \| USB_REQ_CLEAR_FEATURE:
	409	case EndpointOutRequest \| USB_REQ_CLEAR_FEATURE:
	410	if (value == USB_DEVICE_REMOTE_WAKEUP) {
	411	dev->remote_wakeup = 0;
	412	} else {
	413	goto fail;
	414	}
	415	ret = 0;
	416	break;
	417	case DeviceOutRequest \| USB_REQ_SET_FEATURE:
	418	case InterfaceOutRequest \| USB_REQ_SET_FEATURE:
	419	case EndpointOutRequest \| USB_REQ_SET_FEATURE:
	420	if (value == USB_DEVICE_REMOTE_WAKEUP) {
	421	dev->remote_wakeup = 1;
	422	} else {
	423	goto fail;
	424	}
	425	ret = 0;
	426	break;
e6a6d5ab AZ	427	case InterfaceRequest \| USB_REQ_GET_INTERFACE:
	428	if (value != 0 \|\| (index & ~1) \|\| length != 1)
	429	goto fail;
	430	if (index == 1)
	431	data[0] = s->altsetting;
	432	else
	433	data[0] = 0;
	434	ret = 1;
	435	break;
	436	case InterfaceOutRequest \| USB_REQ_SET_INTERFACE:
	437	if ((index & ~1) \|\| length != 0 \|\|
	438	(index == 1 && (value < 0 \|\| value > 4)) \|\|
	439	(index == 0 && value != 0)) {
	440	printf("%s: Wrong SET_INTERFACE request (%i, %i)\n",
	441	__FUNCTION__, index, value);
	442	goto fail;
	443	}
	444	s->altsetting = value;
	445	ret = 0;
	446	break;
	447	case ((USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_DEVICE) << 8):
	448	if (s->config)
	449	usb_bt_fifo_out_enqueue(s, &s->outcmd, s->hci->cmd_send,
	450	usb_bt_hci_cmd_complete, data, length);
	451	break;
	452	default:
	453	fail:
	454	ret = USB_RET_STALL;
	455	break;
	456	}
	457	return ret;
	458	}
	459
	460	static int usb_bt_handle_data(USBDevice dev, USBPacket p)
	461	{
	462	struct USBBtState s = (struct USBBtState ) dev->opaque;
	463	int ret = 0;
	464
	465	if (!s->config)
	466	goto fail;
	467
	468	switch (p->pid) {
	469	case USB_TOKEN_IN:
	470	switch (p->devep & 0xf) {
	471	case USB_EVT_EP:
	472	ret = usb_bt_fifo_dequeue(&s->evt, p);
	473	break;
	474
	475	case USB_ACL_EP:
	476	ret = usb_bt_fifo_dequeue(&s->acl, p);
	477	break;
	478
	479	case USB_SCO_EP:
	480	ret = usb_bt_fifo_dequeue(&s->sco, p);
	481	break;
	482
	483	default:
	484	goto fail;
	485	}
	486	break;
	487
	488	case USB_TOKEN_OUT:
	489	switch (p->devep & 0xf) {
	490	case USB_ACL_EP:
491	usb_bt_fifo_out_enqueue(s, &s->outacl, s->hci->acl_send,
492	usb_bt_hci_acl_complete, p->data, p->len);
493	break;
494
495	case USB_SCO_EP:
496	usb_bt_fifo_out_enqueue(s, &s->outsco, s->hci->sco_send,
497	usb_bt_hci_sco_complete, p->data, p->len);
498	break;
499
500	default:
501	goto fail;
502	}
503	break;
504
505	default:
506	fail:
507	ret = USB_RET_STALL;
508	break;
509	}
510
511	return ret;
512	}
513
514	static void usb_bt_out_hci_packet_event(void *opaque,
515	const uint8_t *data, int len)
516	{
517	struct USBBtState s = (struct USBBtState ) opaque;
518
519	usb_bt_fifo_enqueue(&s->evt, data, len);
520	}
521
522	static void usb_bt_out_hci_packet_acl(void *opaque,
523	const uint8_t *data, int len)
524	{
525	struct USBBtState s = (struct USBBtState ) opaque;
526
527	usb_bt_fifo_enqueue(&s->acl, data, len);
528	}
529
530	static void usb_bt_handle_destroy(USBDevice *dev)
531	{
532	struct USBBtState s = (struct USBBtState ) dev->opaque;
533
511d2b14 BS	534	s->hci->opaque = NULL;
	535	s->hci->evt_recv = NULL;
	536	s->hci->acl_recv = NULL;
e6a6d5ab AZ	537	}
e6a6d5ab AZ	538
806b6024 GH	539	static int usb_bt_initfn(USBDevice *dev)
806b6024 GH	540	{
a980a065	541	usb_desc_init(dev);
806b6024 GH	542	return 0;
	543	}
	544
e6a6d5ab AZ	545	USBDevice usb_bt_init(HCIInfo hci)
e6a6d5ab AZ	546	{
806b6024	547	USBDevice *dev;
e6a6d5ab AZ	548	struct USBBtState *s;
e6a6d5ab AZ	549
2d564691 AZ	550	if (!hci)
2d564691 AZ	551	return NULL;
556cd098	552	dev = usb_create_simple(NULL /* FIXME */, "usb-bt-dongle");
806b6024	553	s = DO_UPCAST(struct USBBtState, dev, dev);
e6a6d5ab	554	s->dev.opaque = s;
e6a6d5ab AZ	555
	556	s->hci = hci;
	557	s->hci->opaque = s;
	558	s->hci->evt_recv = usb_bt_out_hci_packet_event;
	559	s->hci->acl_recv = usb_bt_out_hci_packet_acl;
	560
	561	usb_bt_handle_reset(&s->dev);
	562
806b6024 GH	563	return dev;
	564	}
	565
	566	static struct USBDeviceInfo bt_info = {
06384698	567	.product_desc = "QEMU BT dongle",
556cd098	568	.qdev.name = "usb-bt-dongle",
806b6024	569	.qdev.size = sizeof(struct USBBtState),
4696425c	570	.usb_desc = &desc_bluetooth,
806b6024 GH	571	.init = usb_bt_initfn,
	572	.handle_packet = usb_generic_handle_packet,
	573	.handle_reset = usb_bt_handle_reset,
	574	.handle_control = usb_bt_handle_control,
	575	.handle_data = usb_bt_handle_data,
	576	.handle_destroy = usb_bt_handle_destroy,
	577	};
	578
	579	static void usb_bt_register_devices(void)
	580	{
	581	usb_qdev_register(&bt_info);
e6a6d5ab	582	}
806b6024	583	device_init(usb_bt_register_devices)