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_ERR("%s corrupted event packet", hdev->name);
 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_ERR("%s urb %p failed to resubmit (%d)",
 131                                                 hdev->name, urb, -err);
 132                 usb_unanchor_urb(urb);
 133         }
 134 }
 135
 136 static inline int bpa10x_submit_intr_urb(struct hci_dev *hdev)
 137 {
 138         struct bpa10x_data *data = hci_get_drvdata(hdev);
 139         struct urb *urb;
 140         unsigned char *buf;
 141         unsigned int pipe;
 142         int err, size = 16;
 143
 144         BT_DBG("%s", hdev->name);
 145
 146         urb = usb_alloc_urb(0, GFP_KERNEL);
 147         if (!urb)
 148                 return -ENOMEM;
 149
 150         buf = kmalloc(size, GFP_KERNEL);
 151         if (!buf) {
 152                 usb_free_urb(urb);
 153                 return -ENOMEM;
 154         }
 155
 156         pipe = usb_rcvintpipe(data->udev, 0x81);
 157
 158         usb_fill_int_urb(urb, data->udev, pipe, buf, size,
 159                                                 bpa10x_rx_complete, hdev, 1);
 160
 161         urb->transfer_flags |= URB_FREE_BUFFER;
 162
 163         usb_anchor_urb(urb, &data->rx_anchor);
 164
 165         err = usb_submit_urb(urb, GFP_KERNEL);
 166         if (err < 0) {
 167                 BT_ERR("%s urb %p submission failed (%d)",
 168                                                 hdev->name, urb, -err);
 169                 usb_unanchor_urb(urb);
 170         }
 171
 172         usb_free_urb(urb);
 173
 174         return err;
 175 }
 176
 177 static inline int bpa10x_submit_bulk_urb(struct hci_dev *hdev)
 178 {
 179         struct bpa10x_data *data = hci_get_drvdata(hdev);
 180         struct urb *urb;
 181         unsigned char *buf;
 182         unsigned int pipe;
 183         int err, size = 64;
 184
 185         BT_DBG("%s", hdev->name);
 186
 187         urb = usb_alloc_urb(0, GFP_KERNEL);
 188         if (!urb)
 189                 return -ENOMEM;
 190
 191         buf = kmalloc(size, GFP_KERNEL);
 192         if (!buf) {
 193                 usb_free_urb(urb);
 194                 return -ENOMEM;
 195         }
 196
 197         pipe = usb_rcvbulkpipe(data->udev, 0x82);
 198
 199         usb_fill_bulk_urb(urb, data->udev, pipe,
 200                                         buf, size, bpa10x_rx_complete, hdev);
 201
 202         urb->transfer_flags |= URB_FREE_BUFFER;
 203
 204         usb_anchor_urb(urb, &data->rx_anchor);
 205
 206         err = usb_submit_urb(urb, GFP_KERNEL);
 207         if (err < 0) {
 208                 BT_ERR("%s urb %p submission failed (%d)",
 209                                                 hdev->name, urb, -err);
 210                 usb_unanchor_urb(urb);
 211         }
 212
 213         usb_free_urb(urb);
 214
 215         return err;
 216 }
 217
 218 static int bpa10x_open(struct hci_dev *hdev)
 219 {
 220         struct bpa10x_data *data = hci_get_drvdata(hdev);
 221         int err;
 222
 223         BT_DBG("%s", hdev->name);
 224
 225         err = bpa10x_submit_intr_urb(hdev);
 226         if (err < 0)
 227                 goto error;
 228
 229         err = bpa10x_submit_bulk_urb(hdev);
 230         if (err < 0)
 231                 goto error;
 232
 233         return 0;
 234
 235 error:
 236         usb_kill_anchored_urbs(&data->rx_anchor);
 237
 238         return err;
 239 }
 240
 241 static int bpa10x_close(struct hci_dev *hdev)
 242 {
 243         struct bpa10x_data *data = hci_get_drvdata(hdev);
 244
 245         BT_DBG("%s", hdev->name);
 246
 247         usb_kill_anchored_urbs(&data->rx_anchor);
 248
 249         return 0;
 250 }
 251
 252 static int bpa10x_flush(struct hci_dev *hdev)
 253 {
 254         struct bpa10x_data *data = hci_get_drvdata(hdev);
 255
 256         BT_DBG("%s", hdev->name);
 257
 258         usb_kill_anchored_urbs(&data->tx_anchor);
 259
 260         return 0;
 261 }
 262
 263 static int bpa10x_setup(struct hci_dev *hdev)
 264 {
 265         const u8 req[] = { 0x07 };
 266         struct sk_buff *skb;
 267
 268         BT_DBG("%s", hdev->name);
 269
 270         /* Read revision string */
 271         skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
 272         if (IS_ERR(skb))
 273                 return PTR_ERR(skb);
 274
 275         BT_INFO("%s: %s", hdev->name, (char *)(skb->data + 1));
 276
 277         hci_set_fw_info(hdev, "%s", skb->data + 1);
 278
 279         kfree_skb(skb);
 280         return 0;
 281 }
 282
 283 static int bpa10x_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 284 {
 285         struct bpa10x_data *data = hci_get_drvdata(hdev);
 286         struct usb_ctrlrequest *dr;
 287         struct urb *urb;
 288         unsigned int pipe;
 289         int err;
 290
 291         BT_DBG("%s", hdev->name);
 292
 293         skb->dev = (void *) hdev;
 294
 295         urb = usb_alloc_urb(0, GFP_ATOMIC);
 296         if (!urb)
 297                 return -ENOMEM;
 298
 299         /* Prepend skb with frame type */
 300         *skb_push(skb, 1) = hci_skb_pkt_type(skb);
 301
 302         switch (hci_skb_pkt_type(skb)) {
 303         case HCI_COMMAND_PKT:
 304                 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
 305                 if (!dr) {
 306                         usb_free_urb(urb);
 307                         return -ENOMEM;
 308                 }
 309
 310                 dr->bRequestType = USB_TYPE_VENDOR;
 311                 dr->bRequest     = 0;
 312                 dr->wIndex       = 0;
 313                 dr->wValue       = 0;
 314                 dr->wLength      = __cpu_to_le16(skb->len);
 315
 316                 pipe = usb_sndctrlpipe(data->udev, 0x00);
 317
 318                 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
 319                                 skb->data, skb->len, bpa10x_tx_complete, skb);
 320
 321                 hdev->stat.cmd_tx++;
 322                 break;
 323
 324         case HCI_ACLDATA_PKT:
 325                 pipe = usb_sndbulkpipe(data->udev, 0x02);
 326
 327                 usb_fill_bulk_urb(urb, data->udev, pipe,
 328                                 skb->data, skb->len, bpa10x_tx_complete, skb);
 329
 330                 hdev->stat.acl_tx++;
 331                 break;
 332
 333         case HCI_SCODATA_PKT:
 334                 pipe = usb_sndbulkpipe(data->udev, 0x02);
 335
 336                 usb_fill_bulk_urb(urb, data->udev, pipe,
 337                                 skb->data, skb->len, bpa10x_tx_complete, skb);
 338
 339                 hdev->stat.sco_tx++;
 340                 break;
 341
 342         default:
 343                 usb_free_urb(urb);
 344                 return -EILSEQ;
 345         }
 346
 347         usb_anchor_urb(urb, &data->tx_anchor);
 348
 349         err = usb_submit_urb(urb, GFP_ATOMIC);
 350         if (err < 0) {
 351                 BT_ERR("%s urb %p submission failed", hdev->name, urb);
 352                 kfree(urb->setup_packet);
 353                 usb_unanchor_urb(urb);
 354         }
 355
 356         usb_free_urb(urb);
 357
 358         return 0;
 359 }
 360
 361 static int bpa10x_set_diag(struct hci_dev *hdev, bool enable)
 362 {
 363         const u8 req[] = { 0x00, enable };
 364         struct sk_buff *skb;
 365
 366         BT_DBG("%s", hdev->name);
 367
 368         if (!test_bit(HCI_RUNNING, &hdev->flags))
 369                 return -ENETDOWN;
 370
 371         /* Enable sniffer operation */
 372         skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
 373         if (IS_ERR(skb))
 374                 return PTR_ERR(skb);
 375
 376         kfree_skb(skb);
 377         return 0;
 378 }
 379
 380 static int bpa10x_probe(struct usb_interface *intf, const struct usb_device_id *id)
 381 {
 382         struct bpa10x_data *data;
 383         struct hci_dev *hdev;
 384         int err;
 385
 386         BT_DBG("intf %p id %p", intf, id);
 387
 388         if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
 389                 return -ENODEV;
 390
 391         data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
 392         if (!data)
 393                 return -ENOMEM;
 394
 395         data->udev = interface_to_usbdev(intf);
 396
 397         init_usb_anchor(&data->tx_anchor);
 398         init_usb_anchor(&data->rx_anchor);
 399
 400         hdev = hci_alloc_dev();
 401         if (!hdev)
 402                 return -ENOMEM;
 403
 404         hdev->bus = HCI_USB;
 405         hci_set_drvdata(hdev, data);
 406
 407         data->hdev = hdev;
 408
 409         SET_HCIDEV_DEV(hdev, &intf->dev);
 410
 411         hdev->open     = bpa10x_open;
 412         hdev->close    = bpa10x_close;
 413         hdev->flush    = bpa10x_flush;
 414         hdev->setup    = bpa10x_setup;
 415         hdev->send     = bpa10x_send_frame;
 416         hdev->set_diag = bpa10x_set_diag;
 417
 418         set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
 419
 420         err = hci_register_dev(hdev);
 421         if (err < 0) {
 422                 hci_free_dev(hdev);
 423                 return err;
 424         }
 425
 426         usb_set_intfdata(intf, data);
 427
 428         return 0;
 429 }
 430
 431 static void bpa10x_disconnect(struct usb_interface *intf)
 432 {
 433         struct bpa10x_data *data = usb_get_intfdata(intf);
 434
 435         BT_DBG("intf %p", intf);
 436
 437         if (!data)
 438                 return;
 439
 440         usb_set_intfdata(intf, NULL);
 441
 442         hci_unregister_dev(data->hdev);
 443
 444         hci_free_dev(data->hdev);
 445         kfree_skb(data->rx_skb[0]);
 446         kfree_skb(data->rx_skb[1]);
 447 }
 448
 449 static struct usb_driver bpa10x_driver = {
 450         .name           = "bpa10x",
 451         .probe          = bpa10x_probe,
 452         .disconnect     = bpa10x_disconnect,
 453         .id_table       = bpa10x_table,
 454         .disable_hub_initiated_lpm = 1,
 455 };
 456
 457 module_usb_driver(bpa10x_driver);
 458
 459 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 460 MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION);
 461 MODULE_VERSION(VERSION);
 462 MODULE_LICENSE("GPL");