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         kfree_skb(skb);
 278         return 0;
 279 }
 280
 281 static int bpa10x_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
 282 {
 283         struct bpa10x_data *data = hci_get_drvdata(hdev);
 284         struct usb_ctrlrequest *dr;
 285         struct urb *urb;
 286         unsigned int pipe;
 287         int err;
 288
 289         BT_DBG("%s", hdev->name);
 290
 291         skb->dev = (void *) hdev;
 292
 293         urb = usb_alloc_urb(0, GFP_ATOMIC);
 294         if (!urb)
 295                 return -ENOMEM;
 296
 297         /* Prepend skb with frame type */
 298         *skb_push(skb, 1) = hci_skb_pkt_type(skb);
 299
 300         switch (hci_skb_pkt_type(skb)) {
 301         case HCI_COMMAND_PKT:
 302                 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
 303                 if (!dr) {
 304                         usb_free_urb(urb);
 305                         return -ENOMEM;
 306                 }
 307
 308                 dr->bRequestType = USB_TYPE_VENDOR;
 309                 dr->bRequest     = 0;
 310                 dr->wIndex       = 0;
 311                 dr->wValue       = 0;
 312                 dr->wLength      = __cpu_to_le16(skb->len);
 313
 314                 pipe = usb_sndctrlpipe(data->udev, 0x00);
 315
 316                 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
 317                                 skb->data, skb->len, bpa10x_tx_complete, skb);
 318
 319                 hdev->stat.cmd_tx++;
 320                 break;
 321
 322         case HCI_ACLDATA_PKT:
 323                 pipe = usb_sndbulkpipe(data->udev, 0x02);
 324
 325                 usb_fill_bulk_urb(urb, data->udev, pipe,
 326                                 skb->data, skb->len, bpa10x_tx_complete, skb);
 327
 328                 hdev->stat.acl_tx++;
 329                 break;
 330
 331         case HCI_SCODATA_PKT:
 332                 pipe = usb_sndbulkpipe(data->udev, 0x02);
 333
 334                 usb_fill_bulk_urb(urb, data->udev, pipe,
 335                                 skb->data, skb->len, bpa10x_tx_complete, skb);
 336
 337                 hdev->stat.sco_tx++;
 338                 break;
 339
 340         default:
 341                 usb_free_urb(urb);
 342                 return -EILSEQ;
 343         }
 344
 345         usb_anchor_urb(urb, &data->tx_anchor);
 346
 347         err = usb_submit_urb(urb, GFP_ATOMIC);
 348         if (err < 0) {
 349                 BT_ERR("%s urb %p submission failed", hdev->name, urb);
 350                 kfree(urb->setup_packet);
 351                 usb_unanchor_urb(urb);
 352         }
 353
 354         usb_free_urb(urb);
 355
 356         return 0;
 357 }
 358
 359 static int bpa10x_set_diag(struct hci_dev *hdev, bool enable)
 360 {
 361         const u8 req[] = { 0x00, enable };
 362         struct sk_buff *skb;
 363
 364         BT_DBG("%s", hdev->name);
 365
 366         if (!test_bit(HCI_RUNNING, &hdev->flags))
 367                 return -ENETDOWN;
 368
 369         /* Enable sniffer operation */
 370         skb = __hci_cmd_sync(hdev, 0xfc0e, sizeof(req), req, HCI_INIT_TIMEOUT);
 371         if (IS_ERR(skb))
 372                 return PTR_ERR(skb);
 373
 374         kfree_skb(skb);
 375         return 0;
 376 }
 377
 378 static int bpa10x_probe(struct usb_interface *intf, const struct usb_device_id *id)
 379 {
 380         struct bpa10x_data *data;
 381         struct hci_dev *hdev;
 382         int err;
 383
 384         BT_DBG("intf %p id %p", intf, id);
 385
 386         if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
 387                 return -ENODEV;
 388
 389         data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
 390         if (!data)
 391                 return -ENOMEM;
 392
 393         data->udev = interface_to_usbdev(intf);
 394
 395         init_usb_anchor(&data->tx_anchor);
 396         init_usb_anchor(&data->rx_anchor);
 397
 398         hdev = hci_alloc_dev();
 399         if (!hdev)
 400                 return -ENOMEM;
 401
 402         hdev->bus = HCI_USB;
 403         hci_set_drvdata(hdev, data);
 404
 405         data->hdev = hdev;
 406
 407         SET_HCIDEV_DEV(hdev, &intf->dev);
 408
 409         hdev->open     = bpa10x_open;
 410         hdev->close    = bpa10x_close;
 411         hdev->flush    = bpa10x_flush;
 412         hdev->setup    = bpa10x_setup;
 413         hdev->send     = bpa10x_send_frame;
 414         hdev->set_diag = bpa10x_set_diag;
 415
 416         set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
 417
 418         err = hci_register_dev(hdev);
 419         if (err < 0) {
 420                 hci_free_dev(hdev);
 421                 return err;
 422         }
 423
 424         usb_set_intfdata(intf, data);
 425
 426         return 0;
 427 }
 428
 429 static void bpa10x_disconnect(struct usb_interface *intf)
 430 {
 431         struct bpa10x_data *data = usb_get_intfdata(intf);
 432
 433         BT_DBG("intf %p", intf);
 434
 435         if (!data)
 436                 return;
 437
 438         usb_set_intfdata(intf, NULL);
 439
 440         hci_unregister_dev(data->hdev);
 441
 442         hci_free_dev(data->hdev);
 443         kfree_skb(data->rx_skb[0]);
 444         kfree_skb(data->rx_skb[1]);
 445 }
 446
 447 static struct usb_driver bpa10x_driver = {
 448         .name           = "bpa10x",
 449         .probe          = bpa10x_probe,
 450         .disconnect     = bpa10x_disconnect,
 451         .id_table       = bpa10x_table,
 452         .disable_hub_initiated_lpm = 1,
 453 };
 454
 455 module_usb_driver(bpa10x_driver);
 456
 457 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 458 MODULE_DESCRIPTION("Digianswer Bluetooth USB driver ver " VERSION);
 459 MODULE_VERSION(VERSION);
 460 MODULE_LICENSE("GPL");