drivers/bluetooth/bpa10x.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *
0004  *  Digianswer Bluetooth USB driver
0005  *
0006  *  Copyright (C) 2004-2007  Marcel Holtmann <marcel@holtmann.org>
0007  */
0008
0009 #include <linux/kernel.h>
0010 #include <linux/module.h>
0011 #include <linux/init.h>
0012 #include <linux/slab.h>
0013 #include <linux/types.h>
0014 #include <linux/sched.h>
0015 #include <linux/errno.h>
0016 #include <linux/skbuff.h>
0017
0018 #include <linux/usb.h>
0019
0020 #include <net/bluetooth/bluetooth.h>
0021 #include <net/bluetooth/hci_core.h>
0022
0023 #include "h4_recv.h"
0024
0025 #define VERSION "0.11"
0026
0027 static const struct usb_device_id bpa10x_table[] = {
0028     /* Tektronix BPA 100/105 (Digianswer) */
0029     { USB_DEVICE(0x08fd, 0x0002) },
0030
0031     { } /* Terminating entry */
0032 };
0033
0034 MODULE_DEVICE_TABLE(usb, bpa10x_table);
0035
0036 struct bpa10x_data {
0037     struct hci_dev    *hdev;
0038     struct usb_device *udev;
0039
0040     struct usb_anchor tx_anchor;
0041     struct usb_anchor rx_anchor;
0042
0043     struct sk_buff *rx_skb[2];
0044 };
0045
0046 static void bpa10x_tx_complete(struct urb *urb)
0047 {
0048     struct sk_buff *skb = urb->context;
0049     struct hci_dev *hdev = (struct hci_dev *) skb->dev;
0050
0051     BT_DBG("%s urb %p status %d count %d", hdev->name,
0052                     urb, urb->status, urb->actual_length);
0053
0054     if (!test_bit(HCI_RUNNING, &hdev->flags))
0055         goto done;
0056
0057     if (!urb->status)
0058         hdev->stat.byte_tx += urb->transfer_buffer_length;
0059     else
0060         hdev->stat.err_tx++;
0061
0062 done:
0063     kfree(urb->setup_packet);
0064
0065     kfree_skb(skb);
0066 }
0067
0068 #define HCI_VENDOR_HDR_SIZE 5
0069
0070 #define HCI_RECV_VENDOR \
0071     .type = HCI_VENDOR_PKT, \
0072     .hlen = HCI_VENDOR_HDR_SIZE, \
0073     .loff = 3, \
0074     .lsize = 2, \
0075     .maxlen = HCI_MAX_FRAME_SIZE
0076
0077 static const struct h4_recv_pkt bpa10x_recv_pkts[] = {
0078     { H4_RECV_ACL,     .recv = hci_recv_frame },
0079     { H4_RECV_SCO,     .recv = hci_recv_frame },
0080     { H4_RECV_EVENT,   .recv = hci_recv_frame },
0081     { HCI_RECV_VENDOR, .recv = hci_recv_diag  },
0082 };
0083
0084 static void bpa10x_rx_complete(struct urb *urb)
0085 {
0086     struct hci_dev *hdev = urb->context;
0087     struct bpa10x_data *data = hci_get_drvdata(hdev);
0088     int err;
0089
0090     BT_DBG("%s urb %p status %d count %d", hdev->name,
0091                     urb, urb->status, urb->actual_length);
0092
0093     if (!test_bit(HCI_RUNNING, &hdev->flags))
0094         return;
0095
0096     if (urb->status == 0) {
0097         bool idx = usb_pipebulk(urb->pipe);
0098
0099         data->rx_skb[idx] = h4_recv_buf(hdev, data->rx_skb[idx],
0100                         urb->transfer_buffer,
0101                         urb->actual_length,
0102                         bpa10x_recv_pkts,
0103                         ARRAY_SIZE(bpa10x_recv_pkts));
0104         if (IS_ERR(data->rx_skb[idx])) {
0105             bt_dev_err(hdev, "corrupted event packet");
0106             hdev->stat.err_rx++;
0107             data->rx_skb[idx] = NULL;
0108         }
0109     }
0110
0111     usb_anchor_urb(urb, &data->rx_anchor);
0112
0113     err = usb_submit_urb(urb, GFP_ATOMIC);
0114     if (err < 0) {
0115         bt_dev_err(hdev, "urb %p failed to resubmit (%d)", urb, -err);
0116         usb_unanchor_urb(urb);
0117     }
0118 }
0119
0120 static inline int bpa10x_submit_intr_urb(struct hci_dev *hdev)
0121 {
0122     struct bpa10x_data *data = hci_get_drvdata(hdev);
0123     struct urb *urb;
0124     unsigned char *buf;
0125     unsigned int pipe;
0126     int err, size = 16;
0127
0128     BT_DBG("%s", hdev->name);
0129
0130     urb = usb_alloc_urb(0, GFP_KERNEL);
0131     if (!urb)
0132         return -ENOMEM;
0133
0134     buf = kmalloc(size, GFP_KERNEL);
0135     if (!buf) {
0136         usb_free_urb(urb);
0137         return -ENOMEM;
0138     }
0139
0140     pipe = usb_rcvintpipe(data->udev, 0x81);
0141
0142     usb_fill_int_urb(urb, data->udev, pipe, buf, size,
0143                         bpa10x_rx_complete, hdev, 1);
0144
0145     urb->transfer_flags |= URB_FREE_BUFFER;
0146
0147     usb_anchor_urb(urb, &data->rx_anchor);
0148
0149     err = usb_submit_urb(urb, GFP_KERNEL);
0150     if (err < 0) {
0151         bt_dev_err(hdev, "urb %p submission failed (%d)", urb, -err);
0152         usb_unanchor_urb(urb);
0153     }
0154
0155     usb_free_urb(urb);
0156
0157     return err;
0158 }
0159
0160 static inline int bpa10x_submit_bulk_urb(struct hci_dev *hdev)
0161 {
0162     struct bpa10x_data *data = hci_get_drvdata(hdev);
0163     struct urb *urb;
0164     unsigned char *buf;
0165     unsigned int pipe;
0166     int err, size = 64;
0167
0168     BT_DBG("%s", hdev->name);
0169
0170     urb = usb_alloc_urb(0, GFP_KERNEL);
0171     if (!urb)
0172         return -ENOMEM;
0173
0174     buf = kmalloc(size, GFP_KERNEL);
0175     if (!buf) {
0176         usb_free_urb(urb);
0177         return -ENOMEM;
0178     }
0179
0180     pipe = usb_rcvbulkpipe(data->udev, 0x82);
0181
0182     usb_fill_bulk_urb(urb, data->udev, pipe,
0183                     buf, size, bpa10x_rx_complete, hdev);
0184
0185     urb->transfer_flags |= URB_FREE_BUFFER;
0186
0187     usb_anchor_urb(urb, &data->rx_anchor);
0188
0189     err = usb_submit_urb(urb, GFP_KERNEL);
0190     if (err < 0) {
0191         bt_dev_err(hdev, "urb %p submission failed (%d)", urb, -err);
0192         usb_unanchor_urb(urb);
0193     }
0194
0195     usb_free_urb(urb);
0196
0197     return err;
0198 }
0199
0200 static int bpa10x_open(struct hci_dev *hdev)
0201 {
0202     struct bpa10x_data *data = hci_get_drvdata(hdev);
0203     int err;
0204
0205     BT_DBG("%s", hdev->name);
0206
0207     err = bpa10x_submit_intr_urb(hdev);
0208     if (err < 0)
0209         goto error;
0210
0211     err = bpa10x_submit_bulk_urb(hdev);
0212     if (err < 0)
0213         goto error;
0214
0215     return 0;
0216
0217 error:
0218     usb_kill_anchored_urbs(&data->rx_anchor);
0219
0220     return err;
0221 }
0222
0223 static int bpa10x_close(struct hci_dev *hdev)
0224 {
0225     struct bpa10x_data *data = hci_get_drvdata(hdev);
0226
0227     BT_DBG("%s", hdev->name);
0228
0229     usb_kill_anchored_urbs(&data->rx_anchor);
0230
0231     return 0;
0232 }
0233
0234 static int bpa10x_flush(struct hci_dev *hdev)
0235 {
0236     struct bpa10x_data *data = hci_get_drvdata(hdev);
0237
0238     BT_DBG("%s", hdev->name);
0239
0240     usb_kill_anchored_urbs(&data->tx_anchor);
0241
0242     return 0;
0243 }
0244
0245 static int bpa10x_setup(struct hci_dev *hdev)
0246 {
0247     static const u8 req[] = { 0x07 };
0248     struct sk_buff *skb;
0249
0250     BT_DBG("%s", hdev->name);
0251
0252     /* Read revision string */
0253     skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
0254     if (IS_ERR(skb))
0255         return PTR_ERR(skb);
0256
0257     bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
0258
0259     hci_set_fw_info(hdev, "%s", skb->data + 1);
0260
0261     kfree_skb(skb);
0262     return 0;
0263 }
0264
0265 static int bpa10x_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
0266 {
0267     struct bpa10x_data *data = hci_get_drvdata(hdev);
0268     struct usb_ctrlrequest *dr;
0269     struct urb *urb;
0270     unsigned int pipe;
0271     int err;
0272
0273     BT_DBG("%s", hdev->name);
0274
0275     skb->dev = (void *) hdev;
0276
0277     urb = usb_alloc_urb(0, GFP_KERNEL);
0278     if (!urb)
0279         return -ENOMEM;
0280
0281     /* Prepend skb with frame type */
0282     *(u8 *)skb_push(skb, 1) = hci_skb_pkt_type(skb);
0283
0284     switch (hci_skb_pkt_type(skb)) {
0285     case HCI_COMMAND_PKT:
0286         dr = kmalloc(sizeof(*dr), GFP_KERNEL);
0287         if (!dr) {
0288             usb_free_urb(urb);
0289             return -ENOMEM;
0290         }
0291
0292         dr->bRequestType = USB_TYPE_VENDOR;
0293         dr->bRequest     = 0;
0294         dr->wIndex       = 0;
0295         dr->wValue       = 0;
0296         dr->wLength      = __cpu_to_le16(skb->len);
0297
0298         pipe = usb_sndctrlpipe(data->udev, 0x00);
0299
0300         usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
0301                 skb->data, skb->len, bpa10x_tx_complete, skb);
0302
0303         hdev->stat.cmd_tx++;
0304         break;
0305
0306     case HCI_ACLDATA_PKT:
0307         pipe = usb_sndbulkpipe(data->udev, 0x02);
0308
0309         usb_fill_bulk_urb(urb, data->udev, pipe,
0310                 skb->data, skb->len, bpa10x_tx_complete, skb);
0311
0312         hdev->stat.acl_tx++;
0313         break;
0314
0315     case HCI_SCODATA_PKT:
0316         pipe = usb_sndbulkpipe(data->udev, 0x02);
0317
0318         usb_fill_bulk_urb(urb, data->udev, pipe,
0319                 skb->data, skb->len, bpa10x_tx_complete, skb);
0320
0321         hdev->stat.sco_tx++;
0322         break;
0323
0324     default:
0325         usb_free_urb(urb);
0326         return -EILSEQ;
0327     }
0328
0329     usb_anchor_urb(urb, &data->tx_anchor);
0330
0331     err = usb_submit_urb(urb, GFP_KERNEL);
0332     if (err < 0) {
0333         bt_dev_err(hdev, "urb %p submission failed", urb);
0334         kfree(urb->setup_packet);
0335         usb_unanchor_urb(urb);
0336     }
0337
0338     usb_free_urb(urb);
0339
0340     return err;
0341 }
0342
0343 static int bpa10x_set_diag(struct hci_dev *hdev, bool enable)
0344 {
0345     const u8 req[] = { 0x00, enable };
0346     struct sk_buff *skb;
0347
0348     BT_DBG("%s", hdev->name);
0349
0350     if (!test_bit(HCI_RUNNING, &hdev->flags))
0351         return -ENETDOWN;
0352
0353     /* Enable sniffer operation */
0354     skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
0355     if (IS_ERR(skb))
0356         return PTR_ERR(skb);
0357
0358     kfree_skb(skb);
0359     return 0;
0360 }
0361
0362 static int bpa10x_probe(struct usb_interface *intf,
0363             const struct usb_device_id *id)
0364 {
0365     struct bpa10x_data *data;
0366     struct hci_dev *hdev;
0367     int err;
0368
0369     BT_DBG("intf %p id %p", intf, id);
0370
0371     if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
0372         return -ENODEV;
0373
0374     data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
0375     if (!data)
0376         return -ENOMEM;
0377
0378     data->udev = interface_to_usbdev(intf);
0379
0380     init_usb_anchor(&data->tx_anchor);
0381     init_usb_anchor(&data->rx_anchor);
0382
0383     hdev = hci_alloc_dev();
0384     if (!hdev)
0385         return -ENOMEM;
0386
0387     hdev->bus = HCI_USB;
0388     hci_set_drvdata(hdev, data);
0389
0390     data->hdev = hdev;
0391
0392     SET_HCIDEV_DEV(hdev, &intf->dev);
0393
0394     hdev->open     = bpa10x_open;
0395     hdev->close    = bpa10x_close;
0396     hdev->flush    = bpa10x_flush;
0397     hdev->setup    = bpa10x_setup;
0398     hdev->send     = bpa10x_send_frame;
0399     hdev->set_diag = bpa10x_set_diag;
0400
0401     set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
0402
0403     err = hci_register_dev(hdev);
0404     if (err < 0) {
0405         hci_free_dev(hdev);
0406         return err;
0407     }
0408
0409     usb_set_intfdata(intf, data);
0410
0411     return 0;
0412 }
0413
0414 static void bpa10x_disconnect(struct usb_interface *intf)
0415 {
0416     struct bpa10x_data *data = usb_get_intfdata(intf);
0417
0418     BT_DBG("intf %p", intf);
0419
0420     if (!data)
0421         return;
0422
0423     usb_set_intfdata(intf, NULL);
0424
0425     hci_unregister_dev(data->hdev);
0426
0427     hci_free_dev(data->hdev);
0428     kfree_skb(data->rx_skb[0]);
0429     kfree_skb(data->rx_skb[1]);
0430 }
0431
0432 static struct usb_driver bpa10x_driver = {
0433     .name       = "bpa10x",
0434     .probe      = bpa10x_probe,
0435     .disconnect = bpa10x_disconnect,
0436     .id_table   = bpa10x_table,
0437     .disable_hub_initiated_lpm = 1,
0438 };
0439
0440 module_usb_driver(bpa10x_driver);
0441
0442 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
0443 MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION);
0444 MODULE_VERSION(VERSION);
0445 MODULE_LICENSE("GPL");