drivers/bluetooth/hci_usb.c

   1 /*
   2    HCI USB driver for Linux Bluetooth protocol stack (BlueZ)
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   5
   6    Copyright (C) 2003 Maxim Krasnyansky <maxk@qualcomm.com>
   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 version 2 as
  10    published by the Free Software Foundation;
  11
  12    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  13    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  14    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  15    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  16    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  17    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  18    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  19    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20
  21    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  22    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  23    SOFTWARE IS DISCLAIMED.
  24 */
  25
  26 /*
  27  * Bluetooth HCI USB driver.
  28  * Based on original USB Bluetooth driver for Linux kernel
  29  *    Copyright (c) 2000 Greg Kroah-Hartman        <greg@kroah.com>
  30  *    Copyright (c) 2000 Mark Douglas Corner       <mcorner@umich.edu>
  31  *
  32  */
  33
  34 #include <linux/module.h>
  35
  36 #include <linux/kernel.h>
  37 #include <linux/init.h>
  38 #include <linux/sched.h>
  39 #include <linux/unistd.h>
  40 #include <linux/types.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/moduleparam.h>
  43
  44 #include <linux/slab.h>
  45 #include <linux/errno.h>
  46 #include <linux/string.h>
  47 #include <linux/skbuff.h>
  48
  49 #include <linux/usb.h>
  50
  51 #include <net/bluetooth/bluetooth.h>
  52 #include <net/bluetooth/hci_core.h>
  53
  54 #include "hci_usb.h"
  55
  56 #ifndef CONFIG_BT_HCIUSB_DEBUG
  57 #undef  BT_DBG
  58 #define BT_DBG(D...)
  59 #endif
  60
  61 #ifndef CONFIG_BT_HCIUSB_ZERO_PACKET
  62 #undef  URB_ZERO_PACKET
  63 #define URB_ZERO_PACKET 0
  64 #endif
  65
  66 static int ignore = 0;
  67 static int ignore_dga = 0;
  68 static int ignore_csr = 0;
  69 static int ignore_sniffer = 0;
  70 static int disable_scofix = 0;
  71 static int force_scofix = 0;
  72 static int reset = 0;
  73
  74 #ifdef CONFIG_BT_HCIUSB_SCO
  75 static int isoc = 2;
  76 #endif
  77
  78 #define VERSION "2.9"
  79
  80 static struct usb_driver hci_usb_driver;
  81
  82 static struct usb_device_id bluetooth_ids[] = {
  83         /* Generic Bluetooth USB device */
  84         { USB_DEVICE_INFO(HCI_DEV_CLASS, HCI_DEV_SUBCLASS, HCI_DEV_PROTOCOL) },
  85
  86         /* AVM BlueFRITZ! USB v2.0 */
  87         { USB_DEVICE(0x057c, 0x3800) },
  88
  89         /* Bluetooth Ultraport Module from IBM */
  90         { USB_DEVICE(0x04bf, 0x030a) },
  91
  92         /* ALPS Modules with non-standard id */
  93         { USB_DEVICE(0x044e, 0x3001) },
  94         { USB_DEVICE(0x044e, 0x3002) },
  95
  96         /* Ericsson with non-standard id */
  97         { USB_DEVICE(0x0bdb, 0x1002) },
  98
  99         /* Canyon CN-BTU1 with HID interfaces */
 100         { USB_DEVICE(0x0c10, 0x0000), .driver_info = HCI_RESET },
 101
 102         { }     /* Terminating entry */
 103 };
 104
 105 MODULE_DEVICE_TABLE (usb, bluetooth_ids);
 106
 107 static struct usb_device_id blacklist_ids[] = {
 108         /* CSR BlueCore devices */
 109         { USB_DEVICE(0x0a12, 0x0001), .driver_info = HCI_CSR },
 110
 111         /* Broadcom BCM2033 without firmware */
 112         { USB_DEVICE(0x0a5c, 0x2033), .driver_info = HCI_IGNORE },
 113
 114         /* Broadcom BCM2035 */
 115         { USB_DEVICE(0x0a5c, 0x2035), .driver_info = HCI_RESET | HCI_WRONG_SCO_MTU },
 116         { USB_DEVICE(0x0a5c, 0x200a), .driver_info = HCI_RESET | HCI_WRONG_SCO_MTU },
 117         { USB_DEVICE(0x0a5c, 0x2009), .driver_info = HCI_BCM92035 },
 118
 119         /* IBM/Lenovo ThinkPad with Broadcom chip */
 120         { USB_DEVICE(0x0a5c, 0x201e), .driver_info = HCI_WRONG_SCO_MTU },
 121         { USB_DEVICE(0x0a5c, 0x2110), .driver_info = HCI_WRONG_SCO_MTU },
 122
 123         /* ANYCOM Bluetooth USB-200 and USB-250 */
 124         { USB_DEVICE(0x0a5c, 0x2111), .driver_info = HCI_RESET },
 125
 126         /* HP laptop with Broadcom chip */
 127         { USB_DEVICE(0x03f0, 0x171d), .driver_info = HCI_WRONG_SCO_MTU },
 128
 129         /* Dell laptop with Broadcom chip */
 130         { USB_DEVICE(0x413c, 0x8126), .driver_info = HCI_WRONG_SCO_MTU },
 131
 132         /* Microsoft Wireless Transceiver for Bluetooth 2.0 */
 133         { USB_DEVICE(0x045e, 0x009c), .driver_info = HCI_RESET },
 134
 135         /* Kensington Bluetooth USB adapter */
 136         { USB_DEVICE(0x047d, 0x105d), .driver_info = HCI_RESET },
 137         { USB_DEVICE(0x047d, 0x105e), .driver_info = HCI_WRONG_SCO_MTU },
 138
 139         /* ISSC Bluetooth Adapter v3.1 */
 140         { USB_DEVICE(0x1131, 0x1001), .driver_info = HCI_RESET },
 141
 142         /* RTX Telecom based adapters with buggy SCO support */
 143         { USB_DEVICE(0x0400, 0x0807), .driver_info = HCI_BROKEN_ISOC },
 144         { USB_DEVICE(0x0400, 0x080a), .driver_info = HCI_BROKEN_ISOC },
 145
 146         /* Belkin F8T012 and F8T013 devices */
 147         { USB_DEVICE(0x050d, 0x0012), .driver_info = HCI_WRONG_SCO_MTU },
 148         { USB_DEVICE(0x050d, 0x0013), .driver_info = HCI_WRONG_SCO_MTU },
 149
 150         /* Digianswer devices */
 151         { USB_DEVICE(0x08fd, 0x0001), .driver_info = HCI_DIGIANSWER },
 152         { USB_DEVICE(0x08fd, 0x0002), .driver_info = HCI_IGNORE },
 153
 154         /* CSR BlueCore Bluetooth Sniffer */
 155         { USB_DEVICE(0x0a12, 0x0002), .driver_info = HCI_SNIFFER },
 156
 157         /* Frontline ComProbe Bluetooth Sniffer */
 158         { USB_DEVICE(0x16d3, 0x0002), .driver_info = HCI_SNIFFER },
 159
 160         { }     /* Terminating entry */
 161 };
 162
 163 static struct _urb *_urb_alloc(int isoc, gfp_t gfp)
 164 {
 165         struct _urb *_urb = kmalloc(sizeof(struct _urb) +
 166                                 sizeof(struct usb_iso_packet_descriptor) * isoc, gfp);
 167         if (_urb) {
 168                 memset(_urb, 0, sizeof(*_urb));
 169                 usb_init_urb(&_urb->urb);
 170         }
 171         return _urb;
 172 }
 173
 174 static struct _urb *_urb_dequeue(struct _urb_queue *q)
 175 {
 176         struct _urb *_urb = NULL;
 177         unsigned long flags;
 178         spin_lock_irqsave(&q->lock, flags);
 179         {
 180                 struct list_head *head = &q->head;
 181                 struct list_head *next = head->next;
 182                 if (next != head) {
 183                         _urb = list_entry(next, struct _urb, list);
 184                         list_del(next); _urb->queue = NULL;
 185                 }
 186         }
 187         spin_unlock_irqrestore(&q->lock, flags);
 188         return _urb;
 189 }
 190
 191 static void hci_usb_rx_complete(struct urb *urb);
 192 static void hci_usb_tx_complete(struct urb *urb);
 193
 194 #define __pending_tx(husb, type)  (&husb->pending_tx[type-1])
 195 #define __pending_q(husb, type)   (&husb->pending_q[type-1])
 196 #define __completed_q(husb, type) (&husb->completed_q[type-1])
 197 #define __transmit_q(husb, type)  (&husb->transmit_q[type-1])
 198 #define __reassembly(husb, type)  (husb->reassembly[type-1])
 199
 200 static inline struct _urb *__get_completed(struct hci_usb *husb, int type)
 201 {
 202         return _urb_dequeue(__completed_q(husb, type));
 203 }
 204
 205 #ifdef CONFIG_BT_HCIUSB_SCO
 206 static void __fill_isoc_desc(struct urb *urb, int len, int mtu)
 207 {
 208         int offset = 0, i;
 209
 210         BT_DBG("len %d mtu %d", len, mtu);
 211
 212         for (i=0; i < HCI_MAX_ISOC_FRAMES && len >= mtu; i++, offset += mtu, len -= mtu) {
 213                 urb->iso_frame_desc[i].offset = offset;
 214                 urb->iso_frame_desc[i].length = mtu;
 215                 BT_DBG("desc %d offset %d len %d", i, offset, mtu);
 216         }
 217         if (len && i < HCI_MAX_ISOC_FRAMES) {
 218                 urb->iso_frame_desc[i].offset = offset;
 219                 urb->iso_frame_desc[i].length = len;
 220                 BT_DBG("desc %d offset %d len %d", i, offset, len);
 221                 i++;
 222         }
 223         urb->number_of_packets = i;
 224 }
 225 #endif
 226
 227 static int hci_usb_intr_rx_submit(struct hci_usb *husb)
 228 {
 229         struct _urb *_urb;
 230         struct urb *urb;
 231         int err, pipe, interval, size;
 232         void *buf;
 233
 234         BT_DBG("%s", husb->hdev->name);
 235
 236         size = le16_to_cpu(husb->intr_in_ep->desc.wMaxPacketSize);
 237
 238         buf = kmalloc(size, GFP_ATOMIC);
 239         if (!buf)
 240                 return -ENOMEM;
 241
 242         _urb = _urb_alloc(0, GFP_ATOMIC);
 243         if (!_urb) {
 244                 kfree(buf);
 245                 return -ENOMEM;
 246         }
 247         _urb->type = HCI_EVENT_PKT;
 248         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 249
 250         urb = &_urb->urb;
 251         pipe     = usb_rcvintpipe(husb->udev, husb->intr_in_ep->desc.bEndpointAddress);
 252         interval = husb->intr_in_ep->desc.bInterval;
 253         usb_fill_int_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb, interval);
 254
 255         err = usb_submit_urb(urb, GFP_ATOMIC);
 256         if (err) {
 257                 BT_ERR("%s intr rx submit failed urb %p err %d",
 258                                 husb->hdev->name, urb, err);
 259                 _urb_unlink(_urb);
 260                 _urb_free(_urb);
 261                 kfree(buf);
 262         }
 263         return err;
 264 }
 265
 266 static int hci_usb_bulk_rx_submit(struct hci_usb *husb)
 267 {
 268         struct _urb *_urb;
 269         struct urb *urb;
 270         int err, pipe, size = HCI_MAX_FRAME_SIZE;
 271         void *buf;
 272
 273         buf = kmalloc(size, GFP_ATOMIC);
 274         if (!buf)
 275                 return -ENOMEM;
 276
 277         _urb = _urb_alloc(0, GFP_ATOMIC);
 278         if (!_urb) {
 279                 kfree(buf);
 280                 return -ENOMEM;
 281         }
 282         _urb->type = HCI_ACLDATA_PKT;
 283         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 284
 285         urb  = &_urb->urb;
 286         pipe = usb_rcvbulkpipe(husb->udev, husb->bulk_in_ep->desc.bEndpointAddress);
 287         usb_fill_bulk_urb(urb, husb->udev, pipe, buf, size, hci_usb_rx_complete, husb);
 288         urb->transfer_flags = 0;
 289
 290         BT_DBG("%s urb %p", husb->hdev->name, urb);
 291
 292         err = usb_submit_urb(urb, GFP_ATOMIC);
 293         if (err) {
 294                 BT_ERR("%s bulk rx submit failed urb %p err %d",
 295                                 husb->hdev->name, urb, err);
 296                 _urb_unlink(_urb);
 297                 _urb_free(_urb);
 298                 kfree(buf);
 299         }
 300         return err;
 301 }
 302
 303 #ifdef CONFIG_BT_HCIUSB_SCO
 304 static int hci_usb_isoc_rx_submit(struct hci_usb *husb)
 305 {
 306         struct _urb *_urb;
 307         struct urb *urb;
 308         int err, mtu, size;
 309         void *buf;
 310
 311         mtu  = le16_to_cpu(husb->isoc_in_ep->desc.wMaxPacketSize);
 312         size = mtu * HCI_MAX_ISOC_FRAMES;
 313
 314         buf = kmalloc(size, GFP_ATOMIC);
 315         if (!buf)
 316                 return -ENOMEM;
 317
 318         _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
 319         if (!_urb) {
 320                 kfree(buf);
 321                 return -ENOMEM;
 322         }
 323         _urb->type = HCI_SCODATA_PKT;
 324         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 325
 326         urb = &_urb->urb;
 327
 328         urb->context  = husb;
 329         urb->dev      = husb->udev;
 330         urb->pipe     = usb_rcvisocpipe(husb->udev, husb->isoc_in_ep->desc.bEndpointAddress);
 331         urb->complete = hci_usb_rx_complete;
 332
 333         urb->interval = husb->isoc_in_ep->desc.bInterval;
 334
 335         urb->transfer_buffer_length = size;
 336         urb->transfer_buffer = buf;
 337         urb->transfer_flags  = URB_ISO_ASAP;
 338
 339         __fill_isoc_desc(urb, size, mtu);
 340
 341         BT_DBG("%s urb %p", husb->hdev->name, urb);
 342
 343         err = usb_submit_urb(urb, GFP_ATOMIC);
 344         if (err) {
 345                 BT_ERR("%s isoc rx submit failed urb %p err %d",
 346                                 husb->hdev->name, urb, err);
 347                 _urb_unlink(_urb);
 348                 _urb_free(_urb);
 349                 kfree(buf);
 350         }
 351         return err;
 352 }
 353 #endif
 354
 355 /* Initialize device */
 356 static int hci_usb_open(struct hci_dev *hdev)
 357 {
 358         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 359         int i, err;
 360         unsigned long flags;
 361
 362         BT_DBG("%s", hdev->name);
 363
 364         if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
 365                 return 0;
 366
 367         write_lock_irqsave(&husb->completion_lock, flags);
 368
 369         err = hci_usb_intr_rx_submit(husb);
 370         if (!err) {
 371                 for (i = 0; i < HCI_MAX_BULK_RX; i++)
 372                         hci_usb_bulk_rx_submit(husb);
 373
 374 #ifdef CONFIG_BT_HCIUSB_SCO
 375                 if (husb->isoc_iface)
 376                         for (i = 0; i < HCI_MAX_ISOC_RX; i++)
 377                                 hci_usb_isoc_rx_submit(husb);
 378 #endif
 379         } else {
 380                 clear_bit(HCI_RUNNING, &hdev->flags);
 381         }
 382
 383         write_unlock_irqrestore(&husb->completion_lock, flags);
 384         return err;
 385 }
 386
 387 /* Reset device */
 388 static int hci_usb_flush(struct hci_dev *hdev)
 389 {
 390         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 391         int i;
 392
 393         BT_DBG("%s", hdev->name);
 394
 395         for (i = 0; i < 4; i++)
 396                 skb_queue_purge(&husb->transmit_q[i]);
 397         return 0;
 398 }
 399
 400 static void hci_usb_unlink_urbs(struct hci_usb *husb)
 401 {
 402         int i;
 403
 404         BT_DBG("%s", husb->hdev->name);
 405
 406         for (i = 0; i < 4; i++) {
 407                 struct _urb *_urb;
 408                 struct urb *urb;
 409
 410                 /* Kill pending requests */
 411                 while ((_urb = _urb_dequeue(&husb->pending_q[i]))) {
 412                         urb = &_urb->urb;
 413                         BT_DBG("%s unlinking _urb %p type %d urb %p",
 414                                         husb->hdev->name, _urb, _urb->type, urb);
 415                         usb_kill_urb(urb);
 416                         _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
 417                 }
 418
 419                 /* Release completed requests */
 420                 while ((_urb = _urb_dequeue(&husb->completed_q[i]))) {
 421                         urb = &_urb->urb;
 422                         BT_DBG("%s freeing _urb %p type %d urb %p",
 423                                         husb->hdev->name, _urb, _urb->type, urb);
 424                         kfree(urb->setup_packet);
 425                         kfree(urb->transfer_buffer);
 426                         _urb_free(_urb);
 427                 }
 428
 429                 /* Release reassembly buffers */
 430                 if (husb->reassembly[i]) {
 431                         kfree_skb(husb->reassembly[i]);
 432                         husb->reassembly[i] = NULL;
 433                 }
 434         }
 435 }
 436
 437 /* Close device */
 438 static int hci_usb_close(struct hci_dev *hdev)
 439 {
 440         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 441         unsigned long flags;
 442
 443         if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
 444                 return 0;
 445
 446         BT_DBG("%s", hdev->name);
 447
 448         /* Synchronize with completion handlers */
 449         write_lock_irqsave(&husb->completion_lock, flags);
 450         write_unlock_irqrestore(&husb->completion_lock, flags);
 451
 452         hci_usb_unlink_urbs(husb);
 453         hci_usb_flush(hdev);
 454         return 0;
 455 }
 456
 457 static int __tx_submit(struct hci_usb *husb, struct _urb *_urb)
 458 {
 459         struct urb *urb = &_urb->urb;
 460         int err;
 461
 462         BT_DBG("%s urb %p type %d", husb->hdev->name, urb, _urb->type);
 463
 464         _urb_queue_tail(__pending_q(husb, _urb->type), _urb);
 465         err = usb_submit_urb(urb, GFP_ATOMIC);
 466         if (err) {
 467                 BT_ERR("%s tx submit failed urb %p type %d err %d",
 468                                 husb->hdev->name, urb, _urb->type, err);
 469                 _urb_unlink(_urb);
 470                 _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
 471         } else
 472                 atomic_inc(__pending_tx(husb, _urb->type));
 473
 474         return err;
 475 }
 476
 477 static inline int hci_usb_send_ctrl(struct hci_usb *husb, struct sk_buff *skb)
 478 {
 479         struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
 480         struct usb_ctrlrequest *dr;
 481         struct urb *urb;
 482
 483         if (!_urb) {
 484                 _urb = _urb_alloc(0, GFP_ATOMIC);
 485                 if (!_urb)
 486                         return -ENOMEM;
 487                 _urb->type = bt_cb(skb)->pkt_type;
 488
 489                 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
 490                 if (!dr) {
 491                         _urb_free(_urb);
 492                         return -ENOMEM;
 493                 }
 494         } else
 495                 dr = (void *) _urb->urb.setup_packet;
 496
 497         dr->bRequestType = husb->ctrl_req;
 498         dr->bRequest = 0;
 499         dr->wIndex   = 0;
 500         dr->wValue   = 0;
 501         dr->wLength  = __cpu_to_le16(skb->len);
 502
 503         urb = &_urb->urb;
 504         usb_fill_control_urb(urb, husb->udev, usb_sndctrlpipe(husb->udev, 0),
 505                 (void *) dr, skb->data, skb->len, hci_usb_tx_complete, husb);
 506
 507         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
 508
 509         _urb->priv = skb;
 510         return __tx_submit(husb, _urb);
 511 }
 512
 513 static inline int hci_usb_send_bulk(struct hci_usb *husb, struct sk_buff *skb)
 514 {
 515         struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
 516         struct urb *urb;
 517         int pipe;
 518
 519         if (!_urb) {
 520                 _urb = _urb_alloc(0, GFP_ATOMIC);
 521                 if (!_urb)
 522                         return -ENOMEM;
 523                 _urb->type = bt_cb(skb)->pkt_type;
 524         }
 525
 526         urb  = &_urb->urb;
 527         pipe = usb_sndbulkpipe(husb->udev, husb->bulk_out_ep->desc.bEndpointAddress);
 528         usb_fill_bulk_urb(urb, husb->udev, pipe, skb->data, skb->len,
 529                         hci_usb_tx_complete, husb);
 530         urb->transfer_flags = URB_ZERO_PACKET;
 531
 532         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
 533
 534         _urb->priv = skb;
 535         return __tx_submit(husb, _urb);
 536 }
 537
 538 #ifdef CONFIG_BT_HCIUSB_SCO
 539 static inline int hci_usb_send_isoc(struct hci_usb *husb, struct sk_buff *skb)
 540 {
 541         struct _urb *_urb = __get_completed(husb, bt_cb(skb)->pkt_type);
 542         struct urb *urb;
 543
 544         if (!_urb) {
 545                 _urb = _urb_alloc(HCI_MAX_ISOC_FRAMES, GFP_ATOMIC);
 546                 if (!_urb)
 547                         return -ENOMEM;
 548                 _urb->type = bt_cb(skb)->pkt_type;
 549         }
 550
 551         BT_DBG("%s skb %p len %d", husb->hdev->name, skb, skb->len);
 552
 553         urb = &_urb->urb;
 554
 555         urb->context  = husb;
 556         urb->dev      = husb->udev;
 557         urb->pipe     = usb_sndisocpipe(husb->udev, husb->isoc_out_ep->desc.bEndpointAddress);
 558         urb->complete = hci_usb_tx_complete;
 559         urb->transfer_flags = URB_ISO_ASAP;
 560
 561         urb->interval = husb->isoc_out_ep->desc.bInterval;
 562
 563         urb->transfer_buffer = skb->data;
 564         urb->transfer_buffer_length = skb->len;
 565
 566         __fill_isoc_desc(urb, skb->len, le16_to_cpu(husb->isoc_out_ep->desc.wMaxPacketSize));
 567
 568         _urb->priv = skb;
 569         return __tx_submit(husb, _urb);
 570 }
 571 #endif
 572
 573 static void hci_usb_tx_process(struct hci_usb *husb)
 574 {
 575         struct sk_buff_head *q;
 576         struct sk_buff *skb;
 577
 578         BT_DBG("%s", husb->hdev->name);
 579
 580         do {
 581                 clear_bit(HCI_USB_TX_WAKEUP, &husb->state);
 582
 583                 /* Process command queue */
 584                 q = __transmit_q(husb, HCI_COMMAND_PKT);
 585                 if (!atomic_read(__pending_tx(husb, HCI_COMMAND_PKT)) &&
 586                                 (skb = skb_dequeue(q))) {
 587                         if (hci_usb_send_ctrl(husb, skb) < 0)
 588                                 skb_queue_head(q, skb);
 589                 }
 590
 591 #ifdef CONFIG_BT_HCIUSB_SCO
 592                 /* Process SCO queue */
 593                 q = __transmit_q(husb, HCI_SCODATA_PKT);
 594                 if (atomic_read(__pending_tx(husb, HCI_SCODATA_PKT)) < HCI_MAX_ISOC_TX &&
 595                                 (skb = skb_dequeue(q))) {
 596                         if (hci_usb_send_isoc(husb, skb) < 0)
 597                                 skb_queue_head(q, skb);
 598                 }
 599 #endif
 600
 601                 /* Process ACL queue */
 602                 q = __transmit_q(husb, HCI_ACLDATA_PKT);
 603                 while (atomic_read(__pending_tx(husb, HCI_ACLDATA_PKT)) < HCI_MAX_BULK_TX &&
 604                                 (skb = skb_dequeue(q))) {
 605                         if (hci_usb_send_bulk(husb, skb) < 0) {
 606                                 skb_queue_head(q, skb);
 607                                 break;
 608                         }
 609                 }
 610         } while(test_bit(HCI_USB_TX_WAKEUP, &husb->state));
 611 }
 612
 613 static inline void hci_usb_tx_wakeup(struct hci_usb *husb)
 614 {
 615         /* Serialize TX queue processing to avoid data reordering */
 616         if (!test_and_set_bit(HCI_USB_TX_PROCESS, &husb->state)) {
 617                 hci_usb_tx_process(husb);
 618                 clear_bit(HCI_USB_TX_PROCESS, &husb->state);
 619         } else
 620                 set_bit(HCI_USB_TX_WAKEUP, &husb->state);
 621 }
 622
 623 /* Send frames from HCI layer */
 624 static int hci_usb_send_frame(struct sk_buff *skb)
 625 {
 626         struct hci_dev *hdev = (struct hci_dev *) skb->dev;
 627         struct hci_usb *husb;
 628
 629         if (!hdev) {
 630                 BT_ERR("frame for uknown device (hdev=NULL)");
 631                 return -ENODEV;
 632         }
 633
 634         if (!test_bit(HCI_RUNNING, &hdev->flags))
 635                 return -EBUSY;
 636
 637         BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len);
 638
 639         husb = (struct hci_usb *) hdev->driver_data;
 640
 641         switch (bt_cb(skb)->pkt_type) {
 642         case HCI_COMMAND_PKT:
 643                 hdev->stat.cmd_tx++;
 644                 break;
 645
 646         case HCI_ACLDATA_PKT:
 647                 hdev->stat.acl_tx++;
 648                 break;
 649
 650 #ifdef CONFIG_BT_HCIUSB_SCO
 651         case HCI_SCODATA_PKT:
 652                 hdev->stat.sco_tx++;
 653                 break;
 654 #endif
 655
 656         default:
 657                 kfree_skb(skb);
 658                 return 0;
 659         }
 660
 661         read_lock(&husb->completion_lock);
 662
 663         skb_queue_tail(__transmit_q(husb, bt_cb(skb)->pkt_type), skb);
 664         hci_usb_tx_wakeup(husb);
 665
 666         read_unlock(&husb->completion_lock);
 667         return 0;
 668 }
 669
 670 static inline int __recv_frame(struct hci_usb *husb, int type, void *data, int count)
 671 {
 672         BT_DBG("%s type %d data %p count %d", husb->hdev->name, type, data, count);
 673
 674         husb->hdev->stat.byte_rx += count;
 675
 676         while (count) {
 677                 struct sk_buff *skb = __reassembly(husb, type);
 678                 struct { int expect; } *scb;
 679                 int len = 0;
 680
 681                 if (!skb) {
 682                         /* Start of the frame */
 683
 684                         switch (type) {
 685                         case HCI_EVENT_PKT:
 686                                 if (count >= HCI_EVENT_HDR_SIZE) {
 687                                         struct hci_event_hdr *h = data;
 688                                         len = HCI_EVENT_HDR_SIZE + h->plen;
 689                                 } else
 690                                         return -EILSEQ;
 691                                 break;
 692
 693                         case HCI_ACLDATA_PKT:
 694                                 if (count >= HCI_ACL_HDR_SIZE) {
 695                                         struct hci_acl_hdr *h = data;
 696                                         len = HCI_ACL_HDR_SIZE + __le16_to_cpu(h->dlen);
 697                                 } else
 698                                         return -EILSEQ;
 699                                 break;
 700 #ifdef CONFIG_BT_HCIUSB_SCO
 701                         case HCI_SCODATA_PKT:
 702                                 if (count >= HCI_SCO_HDR_SIZE) {
 703                                         struct hci_sco_hdr *h = data;
 704                                         len = HCI_SCO_HDR_SIZE + h->dlen;
 705                                 } else
 706                                         return -EILSEQ;
 707                                 break;
 708 #endif
 709                         }
 710                         BT_DBG("new packet len %d", len);
 711
 712                         skb = bt_skb_alloc(len, GFP_ATOMIC);
 713                         if (!skb) {
 714                                 BT_ERR("%s no memory for the packet", husb->hdev->name);
 715                                 return -ENOMEM;
 716                         }
 717                         skb->dev = (void *) husb->hdev;
 718                         bt_cb(skb)->pkt_type = type;
 719
 720                         __reassembly(husb, type) = skb;
 721
 722                         scb = (void *) skb->cb;
 723                         scb->expect = len;
 724                 } else {
 725                         /* Continuation */
 726                         scb = (void *) skb->cb;
 727                         len = scb->expect;
 728                 }
 729
 730                 len = min(len, count);
 731
 732                 memcpy(skb_put(skb, len), data, len);
 733
 734                 scb->expect -= len;
 735                 if (!scb->expect) {
 736                         /* Complete frame */
 737                         __reassembly(husb, type) = NULL;
 738                         bt_cb(skb)->pkt_type = type;
 739                         hci_recv_frame(skb);
 740                 }
 741
 742                 count -= len; data += len;
 743         }
 744         return 0;
 745 }
 746
 747 static void hci_usb_rx_complete(struct urb *urb)
 748 {
 749         struct _urb *_urb = container_of(urb, struct _urb, urb);
 750         struct hci_usb *husb = (void *) urb->context;
 751         struct hci_dev *hdev = husb->hdev;
 752         int err, count = urb->actual_length;
 753
 754         BT_DBG("%s urb %p type %d status %d count %d flags %x", hdev->name, urb,
 755                         _urb->type, urb->status, count, urb->transfer_flags);
 756
 757         read_lock(&husb->completion_lock);
 758
 759         if (!test_bit(HCI_RUNNING, &hdev->flags))
 760                 goto unlock;
 761
 762         if (urb->status || !count)
 763                 goto resubmit;
 764
 765         if (_urb->type == HCI_SCODATA_PKT) {
 766 #ifdef CONFIG_BT_HCIUSB_SCO
 767                 int i;
 768                 for (i=0; i < urb->number_of_packets; i++) {
 769                         BT_DBG("desc %d status %d offset %d len %d", i,
 770                                         urb->iso_frame_desc[i].status,
 771                                         urb->iso_frame_desc[i].offset,
 772                                         urb->iso_frame_desc[i].actual_length);
 773
 774                         if (!urb->iso_frame_desc[i].status)
 775                                 __recv_frame(husb, _urb->type,
 776                                         urb->transfer_buffer + urb->iso_frame_desc[i].offset,
 777                                         urb->iso_frame_desc[i].actual_length);
 778                 }
 779 #else
 780                 ;
 781 #endif
 782         } else {
 783                 err = __recv_frame(husb, _urb->type, urb->transfer_buffer, count);
 784                 if (err < 0) {
 785                         BT_ERR("%s corrupted packet: type %d count %d",
 786                                         husb->hdev->name, _urb->type, count);
 787                         hdev->stat.err_rx++;
 788                 }
 789         }
 790
 791 resubmit:
 792         urb->dev = husb->udev;
 793         err = usb_submit_urb(urb, GFP_ATOMIC);
 794         BT_DBG("%s urb %p type %d resubmit status %d", hdev->name, urb,
 795                         _urb->type, err);
 796
 797 unlock:
 798         read_unlock(&husb->completion_lock);
 799 }
 800
 801 static void hci_usb_tx_complete(struct urb *urb)
 802 {
 803         struct _urb *_urb = container_of(urb, struct _urb, urb);
 804         struct hci_usb *husb = (void *) urb->context;
 805         struct hci_dev *hdev = husb->hdev;
 806
 807         BT_DBG("%s urb %p status %d flags %x", hdev->name, urb,
 808                         urb->status, urb->transfer_flags);
 809
 810         atomic_dec(__pending_tx(husb, _urb->type));
 811
 812         urb->transfer_buffer = NULL;
 813         kfree_skb((struct sk_buff *) _urb->priv);
 814
 815         if (!test_bit(HCI_RUNNING, &hdev->flags))
 816                 return;
 817
 818         if (!urb->status)
 819                 hdev->stat.byte_tx += urb->transfer_buffer_length;
 820         else
 821                 hdev->stat.err_tx++;
 822
 823         read_lock(&husb->completion_lock);
 824
 825         _urb_unlink(_urb);
 826         _urb_queue_tail(__completed_q(husb, _urb->type), _urb);
 827
 828         hci_usb_tx_wakeup(husb);
 829
 830         read_unlock(&husb->completion_lock);
 831 }
 832
 833 static void hci_usb_destruct(struct hci_dev *hdev)
 834 {
 835         struct hci_usb *husb = (struct hci_usb *) hdev->driver_data;
 836
 837         BT_DBG("%s", hdev->name);
 838
 839         kfree(husb);
 840 }
 841
 842 static void hci_usb_notify(struct hci_dev *hdev, unsigned int evt)
 843 {
 844         BT_DBG("%s evt %d", hdev->name, evt);
 845 }
 846
 847 static int hci_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
 848 {
 849         struct usb_device *udev = interface_to_usbdev(intf);
 850         struct usb_host_endpoint *bulk_out_ep = NULL;
 851         struct usb_host_endpoint *bulk_in_ep = NULL;
 852         struct usb_host_endpoint *intr_in_ep = NULL;
 853         struct usb_host_endpoint  *ep;
 854         struct usb_host_interface *uif;
 855         struct usb_interface *isoc_iface;
 856         struct hci_usb *husb;
 857         struct hci_dev *hdev;
 858         int i, e, size, isoc_ifnum, isoc_alts;
 859
 860         BT_DBG("udev %p intf %p", udev, intf);
 861
 862         if (!id->driver_info) {
 863                 const struct usb_device_id *match;
 864                 match = usb_match_id(intf, blacklist_ids);
 865                 if (match)
 866                         id = match;
 867         }
 868
 869         if (ignore || id->driver_info & HCI_IGNORE)
 870                 return -ENODEV;
 871
 872         if (ignore_dga && id->driver_info & HCI_DIGIANSWER)
 873                 return -ENODEV;
 874
 875         if (ignore_csr && id->driver_info & HCI_CSR)
 876                 return -ENODEV;
 877
 878         if (ignore_sniffer && id->driver_info & HCI_SNIFFER)
 879                 return -ENODEV;
 880
 881         if (intf->cur_altsetting->desc.bInterfaceNumber > 0)
 882                 return -ENODEV;
 883
 884         /* Find endpoints that we need */
 885         uif = intf->cur_altsetting;
 886         for (e = 0; e < uif->desc.bNumEndpoints; e++) {
 887                 ep = &uif->endpoint[e];
 888
 889                 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
 890                 case USB_ENDPOINT_XFER_INT:
 891                         if (ep->desc.bEndpointAddress & USB_DIR_IN)
 892                                 intr_in_ep = ep;
 893                         break;
 894
 895                 case USB_ENDPOINT_XFER_BULK:
 896                         if (ep->desc.bEndpointAddress & USB_DIR_IN)
 897                                 bulk_in_ep  = ep;
 898                         else
 899                                 bulk_out_ep = ep;
 900                         break;
 901                 }
 902         }
 903
 904         if (!bulk_in_ep || !bulk_out_ep || !intr_in_ep) {
 905                 BT_DBG("Bulk endpoints not found");
 906                 goto done;
 907         }
 908
 909         if (!(husb = kzalloc(sizeof(struct hci_usb), GFP_KERNEL))) {
 910                 BT_ERR("Can't allocate: control structure");
 911                 goto done;
 912         }
 913
 914         husb->udev = udev;
 915         husb->bulk_out_ep = bulk_out_ep;
 916         husb->bulk_in_ep  = bulk_in_ep;
 917         husb->intr_in_ep  = intr_in_ep;
 918
 919         if (id->driver_info & HCI_DIGIANSWER)
 920                 husb->ctrl_req = USB_TYPE_VENDOR;
 921         else
 922                 husb->ctrl_req = USB_TYPE_CLASS;
 923
 924         /* Find isochronous endpoints that we can use */
 925         size = 0;
 926         isoc_iface = NULL;
 927         isoc_alts  = 0;
 928         isoc_ifnum = 1;
 929
 930 #ifdef CONFIG_BT_HCIUSB_SCO
 931         if (isoc && !(id->driver_info & (HCI_BROKEN_ISOC | HCI_SNIFFER)))
 932                 isoc_iface = usb_ifnum_to_if(udev, isoc_ifnum);
 933
 934         if (isoc_iface) {
 935                 int a;
 936                 struct usb_host_endpoint *isoc_out_ep = NULL;
 937                 struct usb_host_endpoint *isoc_in_ep = NULL;
 938
 939                 for (a = 0; a < isoc_iface->num_altsetting; a++) {
 940                         uif = &isoc_iface->altsetting[a];
 941                         for (e = 0; e < uif->desc.bNumEndpoints; e++) {
 942                                 ep = &uif->endpoint[e];
 943
 944                                 switch (ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
 945                                 case USB_ENDPOINT_XFER_ISOC:
 946                                         if (le16_to_cpu(ep->desc.wMaxPacketSize) < size ||
 947                                                         uif->desc.bAlternateSetting != isoc)
 948                                                 break;
 949                                         size = le16_to_cpu(ep->desc.wMaxPacketSize);
 950
 951                                         isoc_alts = uif->desc.bAlternateSetting;
 952
 953                                         if (ep->desc.bEndpointAddress & USB_DIR_IN)
 954                                                 isoc_in_ep  = ep;
 955                                         else
 956                                                 isoc_out_ep = ep;
 957                                         break;
 958                                 }
 959                         }
 960                 }
 961
 962                 if (!isoc_in_ep || !isoc_out_ep)
 963                         BT_DBG("Isoc endpoints not found");
 964                 else {
 965                         BT_DBG("isoc ifnum %d alts %d", isoc_ifnum, isoc_alts);
 966                         if (usb_driver_claim_interface(&hci_usb_driver, isoc_iface, husb) != 0)
 967                                 BT_ERR("Can't claim isoc interface");
 968                         else if (usb_set_interface(udev, isoc_ifnum, isoc_alts)) {
 969                                 BT_ERR("Can't set isoc interface settings");
 970                                 husb->isoc_iface = isoc_iface;
 971                                 usb_driver_release_interface(&hci_usb_driver, isoc_iface);
 972                                 husb->isoc_iface = NULL;
 973                         } else {
 974                                 husb->isoc_iface  = isoc_iface;
 975                                 husb->isoc_in_ep  = isoc_in_ep;
 976                                 husb->isoc_out_ep = isoc_out_ep;
 977                         }
 978                 }
 979         }
 980 #endif
 981
 982         rwlock_init(&husb->completion_lock);
 983
 984         for (i = 0; i < 4; i++) {
 985                 skb_queue_head_init(&husb->transmit_q[i]);
 986                 _urb_queue_init(&husb->pending_q[i]);
 987                 _urb_queue_init(&husb->completed_q[i]);
 988         }
 989
 990         /* Initialize and register HCI device */
 991         hdev = hci_alloc_dev();
 992         if (!hdev) {
 993                 BT_ERR("Can't allocate HCI device");
 994                 goto probe_error;
 995         }
 996
 997         husb->hdev = hdev;
 998
 999         hdev->type = HCI_USB;
1000         hdev->driver_data = husb;
1001         SET_HCIDEV_DEV(hdev, &intf->dev);
1002
1003         hdev->open     = hci_usb_open;
1004         hdev->close    = hci_usb_close;
1005         hdev->flush    = hci_usb_flush;
1006         hdev->send     = hci_usb_send_frame;
1007         hdev->destruct = hci_usb_destruct;
1008         hdev->notify   = hci_usb_notify;
1009
1010         hdev->owner = THIS_MODULE;
1011
1012         if (reset || id->driver_info & HCI_RESET)
1013                 set_bit(HCI_QUIRK_RESET_ON_INIT, &hdev->quirks);
1014
1015         if (force_scofix || id->driver_info & HCI_WRONG_SCO_MTU) {
1016                 if (!disable_scofix)
1017                         set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
1018         }
1019
1020         if (id->driver_info & HCI_SNIFFER) {
1021                 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
1022                         set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
1023         }
1024
1025         if (id->driver_info & HCI_BCM92035) {
1026                 unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };
1027                 struct sk_buff *skb;
1028
1029                 skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
1030                 if (skb) {
1031                         memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
1032                         skb_queue_tail(&hdev->driver_init, skb);
1033                 }
1034         }
1035
1036         if (hci_register_dev(hdev) < 0) {
1037                 BT_ERR("Can't register HCI device");
1038                 hci_free_dev(hdev);
1039                 goto probe_error;
1040         }
1041
1042         usb_set_intfdata(intf, husb);
1043         return 0;
1044
1045 probe_error:
1046         if (husb->isoc_iface)
1047                 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1048         kfree(husb);
1049
1050 done:
1051         return -EIO;
1052 }
1053
1054 static void hci_usb_disconnect(struct usb_interface *intf)
1055 {
1056         struct hci_usb *husb = usb_get_intfdata(intf);
1057         struct hci_dev *hdev;
1058
1059         if (!husb || intf == husb->isoc_iface)
1060                 return;
1061
1062         usb_set_intfdata(intf, NULL);
1063         hdev = husb->hdev;
1064
1065         BT_DBG("%s", hdev->name);
1066
1067         hci_usb_close(hdev);
1068
1069         if (husb->isoc_iface)
1070                 usb_driver_release_interface(&hci_usb_driver, husb->isoc_iface);
1071
1072         if (hci_unregister_dev(hdev) < 0)
1073                 BT_ERR("Can't unregister HCI device %s", hdev->name);
1074
1075         hci_free_dev(hdev);
1076 }
1077
1078 static int hci_usb_suspend(struct usb_interface *intf, pm_message_t message)
1079 {
1080         struct hci_usb *husb = usb_get_intfdata(intf);
1081         struct list_head killed;
1082         unsigned long flags;
1083         int i;
1084
1085         if (!husb || intf == husb->isoc_iface)
1086                 return 0;
1087
1088         hci_suspend_dev(husb->hdev);
1089
1090         INIT_LIST_HEAD(&killed);
1091
1092         for (i = 0; i < 4; i++) {
1093                 struct _urb_queue *q = &husb->pending_q[i];
1094                 struct _urb *_urb, *_tmp;
1095
1096                 while ((_urb = _urb_dequeue(q))) {
1097                         /* reset queue since _urb_dequeue sets it to NULL */
1098                         _urb->queue = q;
1099                         usb_kill_urb(&_urb->urb);
1100                         list_add(&_urb->list, &killed);
1101                 }
1102
1103                 spin_lock_irqsave(&q->lock, flags);
1104
1105                 list_for_each_entry_safe(_urb, _tmp, &killed, list) {
1106                         list_move_tail(&_urb->list, &q->head);
1107                 }
1108
1109                 spin_unlock_irqrestore(&q->lock, flags);
1110         }
1111
1112         return 0;
1113 }
1114
1115 static int hci_usb_resume(struct usb_interface *intf)
1116 {
1117         struct hci_usb *husb = usb_get_intfdata(intf);
1118         unsigned long flags;
1119         int i, err = 0;
1120
1121         if (!husb || intf == husb->isoc_iface)
1122                 return 0;
1123
1124         for (i = 0; i < 4; i++) {
1125                 struct _urb_queue *q = &husb->pending_q[i];
1126                 struct _urb *_urb;
1127
1128                 spin_lock_irqsave(&q->lock, flags);
1129
1130                 list_for_each_entry(_urb, &q->head, list) {
1131                         err = usb_submit_urb(&_urb->urb, GFP_ATOMIC);
1132                         if (err)
1133                                 break;
1134                 }
1135
1136                 spin_unlock_irqrestore(&q->lock, flags);
1137
1138                 if (err)
1139                         return -EIO;
1140         }
1141
1142         hci_resume_dev(husb->hdev);
1143
1144         return 0;
1145 }
1146
1147 static struct usb_driver hci_usb_driver = {
1148         .name           = "hci_usb",
1149         .probe          = hci_usb_probe,
1150         .disconnect     = hci_usb_disconnect,
1151         .suspend        = hci_usb_suspend,
1152         .resume         = hci_usb_resume,
1153         .id_table       = bluetooth_ids,
1154 };
1155
1156 static int __init hci_usb_init(void)
1157 {
1158         int err;
1159
1160         BT_INFO("HCI USB driver ver %s", VERSION);
1161
1162         if ((err = usb_register(&hci_usb_driver)) < 0)
1163                 BT_ERR("Failed to register HCI USB driver");
1164
1165         return err;
1166 }
1167
1168 static void __exit hci_usb_exit(void)
1169 {
1170         usb_deregister(&hci_usb_driver);
1171 }
1172
1173 module_init(hci_usb_init);
1174 module_exit(hci_usb_exit);
1175
1176 module_param(ignore, bool, 0644);
1177 MODULE_PARM_DESC(ignore, "Ignore devices from the matching table");
1178
1179 module_param(ignore_dga, bool, 0644);
1180 MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");
1181
1182 module_param(ignore_csr, bool, 0644);
1183 MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
1184
1185 module_param(ignore_sniffer, bool, 0644);
1186 MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
1187
1188 module_param(disable_scofix, bool, 0644);
1189 MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
1190
1191 module_param(force_scofix, bool, 0644);
1192 MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
1193
1194 module_param(reset, bool, 0644);
1195 MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
1196
1197 #ifdef CONFIG_BT_HCIUSB_SCO
1198 module_param(isoc, int, 0644);
1199 MODULE_PARM_DESC(isoc, "Set isochronous transfers for SCO over HCI support");
1200 #endif
1201
1202 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1203 MODULE_DESCRIPTION("Bluetooth HCI USB driver ver " VERSION);
1204 MODULE_VERSION(VERSION);
1205 MODULE_LICENSE("GPL");