drivers/bluetooth/bpa10x.c

   1 /*
   2  *
   3  *  Digianswer Bluetooth USB driver
   4  *
   5  *  Copyright (C) 2004-2007  Marcel Holtmann <marcel@holtmann.org>
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/slab.h>
  28 #include <linux/types.h>
  29 #include <linux/sched.h>
  30 #include <linux/errno.h>
  31 #include <linux/skbuff.h>
  32
  33 #include <linux/usb.h>
  34
  35 #include <net/bluetooth/bluetooth.h>
  36 #include <net/bluetooth/hci_core.h>
  37
  38 #include "hci_uart.h"
  39
  40 #define VERSION "0.11"
  41
  42 static const struct usb_device_id bpa10x_table[] = {
  43         /* Tektronix BPA 100/105 (Digianswer) */
  44         { USB_DEVICE(0x08fd, 0x0002) },
  45
  46         { }     /* Terminating entry */
  47 };
  48
  49 MODULE_DEVICE_TABLE(usb, bpa10x_table);
  50
  51 struct bpa10x_data {
  52         struct hci_dev    *hdev;
  53         struct usb_device *udev;
  54
  55         struct usb_anchor tx_anchor;
  56         struct usb_anchor rx_anchor;
  57
  58         struct sk_buff *rx_skb[2];
  59 };
  60
  61 static void bpa10x_tx_complete(struct urb *urb)
  62 {
  63         struct sk_buff *skb = urb->context;
  64         struct hci_dev *hdev = (struct hci_dev *) skb->dev;
  65
  66         BT_DBG("%s urb %p status %d count %d", hdev->name,
  67                                         urb, urb->status, urb->actual_length);
  68
  69         if (!test_bit(HCI_RUNNING, &hdev->flags))
  70                 goto done;
  71
  72         if (!urb->status)
  73                 hdev->stat.byte_tx += urb->transfer_buffer_length;
  74         else
  75                 hdev->stat.err_tx++;
  76
  77 done:
  78         kfree(urb->setup_packet);
  79
  80         kfree_skb(skb);
  81 }
  82
  83 #define HCI_VENDOR_HDR_SIZE 5
  84
  85 #define HCI_RECV_VENDOR \
  86         .type = HCI_VENDOR_PKT, \
  87         .hlen = HCI_VENDOR_HDR_SIZE, \
  88         .loff = 3, \
  89         .lsize = 2, \
  90         .maxlen = HCI_MAX_FRAME_SIZE
  91
  92 static const struct h4_recv_pkt bpa10x_recv_pkts[] = {
  93         { H4_RECV_ACL,     .recv = hci_recv_frame },
  94         { H4_RECV_SCO,     .recv = hci_recv_frame },
  95         { H4_RECV_EVENT,   .recv = hci_recv_frame },
  96         { HCI_RECV_VENDOR, .recv = hci_recv_diag  },
  97 };
  98
  99 static void bpa10x_rx_complete(struct urb *urb)
 100 {
 101         struct hci_dev *hdev = urb->context;
 102         struct bpa10x_data *data = hci_get_drvdata(hdev);
 103         int err;
 104
 105         BT_DBG("%s urb %p status %d count %d", hdev->name,
 106                                         urb, urb->status, urb->actual_length);
 107
 108         if (!test_bit(HCI_RUNNING, &hdev->flags))
 109                 return;
 110
 111         if (urb->status == 0) {
 112                 bool idx = usb_pipebulk(urb->pipe);
 113
 114                 data->rx_skb[idx] = h4_recv_buf(hdev, data->rx_skb[idx],
 115                                                 urb->transfer_buffer,
 116                                                 urb->actual_length,
 117                                                 bpa10x_recv_pkts,
 118                                                 ARRAY_SIZE(bpa10x_recv_pkts));
 119                 if (IS_ERR(data->rx_skb[idx])) {
 120                         bt_dev_err(hdev, "corrupted event packet");
 121                         hdev->stat.err_rx++;
 122                         data->rx_skb[idx] = NULL;
 123                 }
 124         }
 125
 126         usb_anchor_urb(urb, &data->rx_anchor);
 127
 128         err = usb_submit_urb(urb, GFP_ATOMIC);
 129         if (err < 0) {
 130                 bt_dev_err(hdev, "urb %p failed to resubmit (%d)", urb, -err);
 131                 usb_unanchor_urb(urb);
 132         }
 133 }
 134
 135 static inline int bpa10x_submit_intr_urb(struct hci_dev *hdev)
 136 {
 137         struct bpa10x_data *data = hci_get_drvdata(hdev);
 138         struct urb *urb;
 139         unsigned char *buf;
 140         unsigned int pipe;
 141         int err, size = 16;
 142
 143         BT_DBG("%s", hdev->name);
 144
 145         urb = usb_alloc_urb(0, GFP_KERNEL);
 146         if (!urb)
 147                 return -ENOMEM;
 148
 149         buf = kmalloc(size, GFP_KERNEL);
 150         if (!buf) {
 151                 usb_free_urb(urb);
 152                 return -ENOMEM;
 153         }
 154
 155         pipe = usb_rcvintpipe(data->udev, 0x81);
 156
 157         usb_fill_int_urb(urb, data->udev, pipe, buf, size,
 158                                                 bpa10x_rx_complete, hdev, 1);
 159
 160         urb->transfer_flags |= URB_FREE_BUFFER;
 161
 162         usb_anchor_urb(urb, &data->rx_anchor);
 163
 164         err = usb_submit_urb(urb, GFP_KERNEL);
 165         if (err < 0) {
 166                 bt_dev_err(hdev, "urb %p submission failed (%d)", urb, -err);
 167                 usb_unanchor_urb(urb);
 168         }
 169
 170         usb_free_urb(urb);
 171
 172         return err;
 173 }
 174
 175 static inline int bpa10x_submit_bulk_urb(struct hci_dev *hdev)
 176 {
 177         struct bpa10x_data *data = hci_get_drvdata(hdev);
 178         struct urb *urb;
 179         unsigned char *buf;
 180         unsigned int pipe;
 181         int err, size = 64;
 182
 183         BT_DBG("%s", hdev->name);
 184
 185         urb = usb_alloc_urb(0, GFP_KERNEL);
 186         if (!urb)
 187                 return -ENOMEM;
 188
 189         buf = kmalloc(size, GFP_KERNEL);
 190         if (!buf) {
 191                 usb_free_urb(urb);
 192                 return -ENOMEM;
 193         }
 194
 195         pipe = usb_rcvbulkpipe(data->udev, 0x82);
 196
 197         usb_fill_bulk_urb(urb, data->udev, pipe,
 198                                         buf, size, bpa10x_rx_complete, hdev);
 199
 200         urb->transfer_flags |= URB_FREE_BUFFER;
 201
 202         usb_anchor_urb(urb, &data->rx_anchor);
 203
 204         err = usb_submit_urb(urb, GFP_KERNEL);
 205         if (err < 0) {
 206                 bt_dev_err(hdev, "urb %p submission failed (%d)", urb, -err);
 207                 usb_unanchor_urb(urb);
 208         }
 209
 210         usb_free_urb(urb);
 211
 212         return err;
 213 }
 214
 215 static int bpa10x_open(struct hci_dev *hdev)
 216 {
 217         struct bpa10x_data *data = hci_get_drvdata(hdev);
 218         int err;
 219
 220         BT_DBG("%s", hdev->name);
 221
 222         err = bpa10x_submit_intr_urb(hdev);
 223         if (err < 0)
 224                 goto error;
 225
 226         err = bpa10x_submit_bulk_urb(hdev);
 227         if (err < 0)
 228                 goto error;
 229
 230         return 0;
 231
 232 error:
 233         usb_kill_anchored_urbs(&data->rx_anchor);
 234
 235         return err;
 236 }
 237
 238 static int bpa10x_close(struct hci_dev *hdev)
 239 {
 240         struct bpa10x_data *data = hci_get_drvdata(hdev);
 241
 242         BT_DBG("%s", hdev->name);
 243
 244         usb_kill_anchored_urbs(&data->rx_anchor);
 245
 246         return 0;
 247 }
 248
 249 static int bpa10x_flush(struct hci_dev *hdev)
 250 {
 251         struct bpa10x_data *data = hci_get_drvdata(hdev);
 252
 253         BT_DBG("%s", hdev->name);
 254
 255         usb_kill_anchored_urbs(&data->tx_anchor);
 256
 257         return 0;
 258 }
 259
 260 static int bpa10x_setup(struct hci_dev *hdev)
 261 {
 262         const u8 req[] = { 0x07 };
 263         struct sk_buff *skb;
 264
 265         BT_DBG("%s", hdev->name);
 266
 267         /* Read revision string */
 268         skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
 269         if (IS_ERR(skb))
 270                 return PTR_ERR(skb);
 271
 272         bt_dev_info(hdev, "%s", (char *)(skb->data + 1));
 273
 274         hci_set_fw_info(hdev, "%s", skb->data + 1);
 275
 276         kfree_skb(skb);
 277         return 0;
 278 }
 279
 280 static int bpa10x_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 281 {
 282         struct bpa10x_data *data = hci_get_drvdata(hdev);
 283         struct usb_ctrlrequest *dr;
 284         struct urb *urb;
 285         unsigned int pipe;
 286         int err;
 287
 288         BT_DBG("%s", hdev->name);
 289
 290         skb->dev = (void *) hdev;
 291
 292         urb = usb_alloc_urb(0, GFP_ATOMIC);
 293         if (!urb)
 294                 return -ENOMEM;
 295
 296         /* Prepend skb with frame type */
 297         *(u8 *)skb_push(skb, 1) = hci_skb_pkt_type(skb);
 298
 299         switch (hci_skb_pkt_type(skb)) {
 300         case HCI_COMMAND_PKT:
 301                 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
 302                 if (!dr) {
 303                         usb_free_urb(urb);
 304                         return -ENOMEM;
 305                 }
 306
 307                 dr->bRequestType = USB_TYPE_VENDOR;
 308                 dr->bRequest     = 0;
 309                 dr->wIndex       = 0;
 310                 dr->wValue       = 0;
 311                 dr->wLength      = __cpu_to_le16(skb->len);
 312
 313                 pipe = usb_sndctrlpipe(data->udev, 0x00);
 314
 315                 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
 316                                 skb->data, skb->len, bpa10x_tx_complete, skb);
 317
 318                 hdev->stat.cmd_tx++;
 319                 break;
 320
 321         case HCI_ACLDATA_PKT:
 322                 pipe = usb_sndbulkpipe(data->udev, 0x02);
 323
 324                 usb_fill_bulk_urb(urb, data->udev, pipe,
 325                                 skb->data, skb->len, bpa10x_tx_complete, skb);
 326
 327                 hdev->stat.acl_tx++;
 328                 break;
 329
 330         case HCI_SCODATA_PKT:
 331                 pipe = usb_sndbulkpipe(data->udev, 0x02);
 332
 333                 usb_fill_bulk_urb(urb, data->udev, pipe,
 334                                 skb->data, skb->len, bpa10x_tx_complete, skb);
 335
 336                 hdev->stat.sco_tx++;
 337                 break;
 338
 339         default:
 340                 usb_free_urb(urb);
 341                 return -EILSEQ;
 342         }
 343
 344         usb_anchor_urb(urb, &data->tx_anchor);
 345
 346         err = usb_submit_urb(urb, GFP_ATOMIC);
 347         if (err < 0) {
 348                 bt_dev_err(hdev, "urb %p submission failed", urb);
 349                 kfree(urb->setup_packet);
 350                 usb_unanchor_urb(urb);
 351         }
 352
 353         usb_free_urb(urb);
 354
 355         return 0;
 356 }
 357
 358 static int bpa10x_set_diag(struct hci_dev *hdev, bool enable)
 359 {
 360         const u8 req[] = { 0x00, enable };
 361         struct sk_buff *skb;
 362
 363         BT_DBG("%s", hdev->name);
 364
 365         if (!test_bit(HCI_RUNNING, &hdev->flags))
 366                 return -ENETDOWN;
 367
 368         /* Enable sniffer operation */
 369         skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
 370         if (IS_ERR(skb))
 371                 return PTR_ERR(skb);
 372
 373         kfree_skb(skb);
 374         return 0;
 375 }
 376
 377 static int bpa10x_probe(struct usb_interface *intf, const struct usb_device_id *id)
 378 {
 379         struct bpa10x_data *data;
 380         struct hci_dev *hdev;
 381         int err;
 382
 383         BT_DBG("intf %p id %p", intf, id);
 384
 385         if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
 386                 return -ENODEV;
 387
 388         data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
 389         if (!data)
 390                 return -ENOMEM;
 391
 392         data->udev = interface_to_usbdev(intf);
 393
 394         init_usb_anchor(&data->tx_anchor);
 395         init_usb_anchor(&data->rx_anchor);
 396
 397         hdev = hci_alloc_dev();
 398         if (!hdev)
 399                 return -ENOMEM;
 400
 401         hdev->bus = HCI_USB;
 402         hci_set_drvdata(hdev, data);
 403
 404         data->hdev = hdev;
 405
 406         SET_HCIDEV_DEV(hdev, &intf->dev);
 407
 408         hdev->open     = bpa10x_open;
 409         hdev->close    = bpa10x_close;
 410         hdev->flush    = bpa10x_flush;
 411         hdev->setup    = bpa10x_setup;
 412         hdev->send     = bpa10x_send_frame;
 413         hdev->set_diag = bpa10x_set_diag;
 414
 415         set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
 416
 417         err = hci_register_dev(hdev);
 418         if (err < 0) {
 419                 hci_free_dev(hdev);
 420                 return err;
 421         }
 422
 423         usb_set_intfdata(intf, data);
 424
 425         return 0;
 426 }
 427
 428 static void bpa10x_disconnect(struct usb_interface *intf)
 429 {
 430         struct bpa10x_data *data = usb_get_intfdata(intf);
 431
 432         BT_DBG("intf %p", intf);
 433
 434         if (!data)
 435                 return;
 436
 437         usb_set_intfdata(intf, NULL);
 438
 439         hci_unregister_dev(data->hdev);
 440
 441         hci_free_dev(data->hdev);
 442         kfree_skb(data->rx_skb[0]);
 443         kfree_skb(data->rx_skb[1]);
 444 }
 445
 446 static struct usb_driver bpa10x_driver = {
 447         .name           = "bpa10x",
 448         .probe          = bpa10x_probe,
 449         .disconnect     = bpa10x_disconnect,
 450         .id_table       = bpa10x_table,
 451         .disable_hub_initiated_lpm = 1,
 452 };
 453
 454 module_usb_driver(bpa10x_driver);
 455
 456 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 457 MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION);
 458 MODULE_VERSION(VERSION);
 459 MODULE_LICENSE("GPL");