blob: d1bb809512fa3a05486d844f9a2effa3051fbd31 [file] [log] [blame]
Marcel Holtmann5e23b922007-10-20 14:12:34 +02001/*
2 *
3 * Generic Bluetooth USB driver
4 *
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +02005 * Copyright (C) 2005-2008 Marcel Holtmann <marcel@holtmann.org>
Marcel Holtmann5e23b922007-10-20 14:12:34 +02006 *
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
Oliver Neukum7bee5492009-08-24 23:44:59 +020038#define VERSION "0.6"
Marcel Holtmanncfeb4142008-08-07 22:26:56 +020039
40static int ignore_dga;
41static int ignore_csr;
42static int ignore_sniffer;
43static int disable_scofix;
44static int force_scofix;
Marcel Holtmann7a9d4022008-11-30 12:17:26 +010045
46static int reset = 1;
Marcel Holtmanncfeb4142008-08-07 22:26:56 +020047
48static struct usb_driver btusb_driver;
49
50#define BTUSB_IGNORE 0x01
Marcel Holtmann7a9d4022008-11-30 12:17:26 +010051#define BTUSB_DIGIANSWER 0x02
52#define BTUSB_CSR 0x04
53#define BTUSB_SNIFFER 0x08
54#define BTUSB_BCM92035 0x10
55#define BTUSB_BROKEN_ISOC 0x20
56#define BTUSB_WRONG_SCO_MTU 0x40
Marcel Holtmann5e23b922007-10-20 14:12:34 +020057
58static struct usb_device_id btusb_table[] = {
59 /* Generic Bluetooth USB device */
60 { USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
61
Cyril Lacoux0a79f672010-07-14 10:29:27 +040062 /* Apple iMac11,1 */
63 { USB_DEVICE(0x05ac, 0x8215) },
64
Nobuhiro Iwamatsu9c047152010-08-20 16:24:06 +090065 /* Apple MacBookPro6,2 */
66 { USB_DEVICE(0x05ac, 0x8218) },
67
Marcel Holtmanncfeb4142008-08-07 22:26:56 +020068 /* AVM BlueFRITZ! USB v2.0 */
69 { USB_DEVICE(0x057c, 0x3800) },
70
71 /* Bluetooth Ultraport Module from IBM */
72 { USB_DEVICE(0x04bf, 0x030a) },
73
74 /* ALPS Modules with non-standard id */
75 { USB_DEVICE(0x044e, 0x3001) },
76 { USB_DEVICE(0x044e, 0x3002) },
77
78 /* Ericsson with non-standard id */
79 { USB_DEVICE(0x0bdb, 0x1002) },
80
81 /* Canyon CN-BTU1 with HID interfaces */
Marcel Holtmann7a9d4022008-11-30 12:17:26 +010082 { USB_DEVICE(0x0c10, 0x0000) },
Marcel Holtmanncfeb4142008-08-07 22:26:56 +020083
Marcel Holtmann5e23b922007-10-20 14:12:34 +020084 { } /* Terminating entry */
85};
86
87MODULE_DEVICE_TABLE(usb, btusb_table);
88
89static struct usb_device_id blacklist_table[] = {
Marcel Holtmanncfeb4142008-08-07 22:26:56 +020090 /* CSR BlueCore devices */
91 { USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },
92
93 /* Broadcom BCM2033 without firmware */
94 { USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },
95
96 /* Broadcom BCM2035 */
Marcel Holtmann7a9d4022008-11-30 12:17:26 +010097 { USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },
98 { USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },
99 { USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200100
101 /* Broadcom BCM2045 */
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100102 { USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },
103 { USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },
Marcel Holtmannbdbef3d2008-09-23 00:16:35 +0200104
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200105 /* IBM/Lenovo ThinkPad with Broadcom chip */
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100106 { USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },
107 { USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200108
109 /* HP laptop with Broadcom chip */
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100110 { USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200111
112 /* Dell laptop with Broadcom chip */
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100113 { USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200114
Marcel Holtmann5ddd4a62008-11-30 12:17:27 +0100115 /* Dell Wireless 370 and 410 devices */
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100116 { USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },
Marcel Holtmann5ddd4a62008-11-30 12:17:27 +0100117 { USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200118
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100119 /* Belkin F8T012 and F8T013 devices */
120 { USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },
121 { USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200122
Marcel Holtmann5ddd4a62008-11-30 12:17:27 +0100123 /* Asus WL-BTD202 device */
124 { USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },
125
126 /* Kensington Bluetooth USB adapter */
127 { USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },
128
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200129 /* RTX Telecom based adapters with buggy SCO support */
130 { USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },
131 { USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },
132
133 /* CONWISE Technology based adapters with buggy SCO support */
134 { USB_DEVICE(0x0e5e, 0x6622), .driver_info = BTUSB_BROKEN_ISOC },
135
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200136 /* Digianswer devices */
137 { USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },
138 { USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },
139
140 /* CSR BlueCore Bluetooth Sniffer */
141 { USB_DEVICE(0x0a12, 0x0002), .driver_info = BTUSB_SNIFFER },
142
143 /* Frontline ComProbe Bluetooth Sniffer */
144 { USB_DEVICE(0x16d3, 0x0002), .driver_info = BTUSB_SNIFFER },
145
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200146 { } /* Terminating entry */
147};
148
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200149#define BTUSB_MAX_ISOC_FRAMES 10
150
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200151#define BTUSB_INTR_RUNNING 0
152#define BTUSB_BULK_RUNNING 1
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200153#define BTUSB_ISOC_RUNNING 2
Oliver Neukum7bee5492009-08-24 23:44:59 +0200154#define BTUSB_SUSPENDING 3
Gustavo F. Padovan08b8b6c2010-07-16 17:20:33 -0300155#define BTUSB_DID_ISO_RESUME 4
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200156
157struct btusb_data {
158 struct hci_dev *hdev;
159 struct usb_device *udev;
Marcel Holtmann5fbcd262008-09-23 00:16:36 +0200160 struct usb_interface *intf;
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200161 struct usb_interface *isoc;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200162
163 spinlock_t lock;
164
165 unsigned long flags;
166
167 struct work_struct work;
Oliver Neukum7bee5492009-08-24 23:44:59 +0200168 struct work_struct waker;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200169
170 struct usb_anchor tx_anchor;
171 struct usb_anchor intr_anchor;
172 struct usb_anchor bulk_anchor;
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200173 struct usb_anchor isoc_anchor;
Oliver Neukum7bee5492009-08-24 23:44:59 +0200174 struct usb_anchor deferred;
175 int tx_in_flight;
176 spinlock_t txlock;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200177
178 struct usb_endpoint_descriptor *intr_ep;
179 struct usb_endpoint_descriptor *bulk_tx_ep;
180 struct usb_endpoint_descriptor *bulk_rx_ep;
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200181 struct usb_endpoint_descriptor *isoc_tx_ep;
182 struct usb_endpoint_descriptor *isoc_rx_ep;
183
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100184 __u8 cmdreq_type;
185
Marcel Holtmann43c2e572009-02-04 17:41:38 +0100186 unsigned int sco_num;
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200187 int isoc_altsetting;
Marcel Holtmann6a88adf2008-11-30 12:17:14 +0100188 int suspend_count;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200189};
190
Oliver Neukum7bee5492009-08-24 23:44:59 +0200191static int inc_tx(struct btusb_data *data)
192{
193 unsigned long flags;
194 int rv;
195
196 spin_lock_irqsave(&data->txlock, flags);
197 rv = test_bit(BTUSB_SUSPENDING, &data->flags);
198 if (!rv)
199 data->tx_in_flight++;
200 spin_unlock_irqrestore(&data->txlock, flags);
201
202 return rv;
203}
204
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200205static void btusb_intr_complete(struct urb *urb)
206{
207 struct hci_dev *hdev = urb->context;
208 struct btusb_data *data = hdev->driver_data;
209 int err;
210
211 BT_DBG("%s urb %p status %d count %d", hdev->name,
212 urb, urb->status, urb->actual_length);
213
214 if (!test_bit(HCI_RUNNING, &hdev->flags))
215 return;
216
217 if (urb->status == 0) {
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200218 hdev->stat.byte_rx += urb->actual_length;
219
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200220 if (hci_recv_fragment(hdev, HCI_EVENT_PKT,
221 urb->transfer_buffer,
222 urb->actual_length) < 0) {
223 BT_ERR("%s corrupted event packet", hdev->name);
224 hdev->stat.err_rx++;
225 }
226 }
227
228 if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
229 return;
230
Oliver Neukum7bee5492009-08-24 23:44:59 +0200231 usb_mark_last_busy(data->udev);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200232 usb_anchor_urb(urb, &data->intr_anchor);
233
234 err = usb_submit_urb(urb, GFP_ATOMIC);
235 if (err < 0) {
236 BT_ERR("%s urb %p failed to resubmit (%d)",
237 hdev->name, urb, -err);
238 usb_unanchor_urb(urb);
239 }
240}
241
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100242static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200243{
244 struct btusb_data *data = hdev->driver_data;
245 struct urb *urb;
246 unsigned char *buf;
247 unsigned int pipe;
248 int err, size;
249
250 BT_DBG("%s", hdev->name);
251
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200252 if (!data->intr_ep)
253 return -ENODEV;
254
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100255 urb = usb_alloc_urb(0, mem_flags);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200256 if (!urb)
257 return -ENOMEM;
258
259 size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
260
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100261 buf = kmalloc(size, mem_flags);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200262 if (!buf) {
263 usb_free_urb(urb);
264 return -ENOMEM;
265 }
266
267 pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
268
269 usb_fill_int_urb(urb, data->udev, pipe, buf, size,
270 btusb_intr_complete, hdev,
271 data->intr_ep->bInterval);
272
273 urb->transfer_flags |= URB_FREE_BUFFER;
274
275 usb_anchor_urb(urb, &data->intr_anchor);
276
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100277 err = usb_submit_urb(urb, mem_flags);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200278 if (err < 0) {
279 BT_ERR("%s urb %p submission failed (%d)",
280 hdev->name, urb, -err);
281 usb_unanchor_urb(urb);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200282 }
283
284 usb_free_urb(urb);
285
286 return err;
287}
288
289static void btusb_bulk_complete(struct urb *urb)
290{
291 struct hci_dev *hdev = urb->context;
292 struct btusb_data *data = hdev->driver_data;
293 int err;
294
295 BT_DBG("%s urb %p status %d count %d", hdev->name,
296 urb, urb->status, urb->actual_length);
297
298 if (!test_bit(HCI_RUNNING, &hdev->flags))
299 return;
300
301 if (urb->status == 0) {
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200302 hdev->stat.byte_rx += urb->actual_length;
303
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200304 if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,
305 urb->transfer_buffer,
306 urb->actual_length) < 0) {
307 BT_ERR("%s corrupted ACL packet", hdev->name);
308 hdev->stat.err_rx++;
309 }
310 }
311
312 if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
313 return;
314
315 usb_anchor_urb(urb, &data->bulk_anchor);
Oliver Neukum652fd782009-12-16 19:23:43 +0100316 usb_mark_last_busy(data->udev);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200317
318 err = usb_submit_urb(urb, GFP_ATOMIC);
319 if (err < 0) {
320 BT_ERR("%s urb %p failed to resubmit (%d)",
321 hdev->name, urb, -err);
322 usb_unanchor_urb(urb);
323 }
324}
325
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100326static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200327{
328 struct btusb_data *data = hdev->driver_data;
329 struct urb *urb;
330 unsigned char *buf;
331 unsigned int pipe;
Vikram Kandukuri290ba202009-07-02 14:31:59 +0530332 int err, size = HCI_MAX_FRAME_SIZE;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200333
334 BT_DBG("%s", hdev->name);
335
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200336 if (!data->bulk_rx_ep)
337 return -ENODEV;
338
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100339 urb = usb_alloc_urb(0, mem_flags);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200340 if (!urb)
341 return -ENOMEM;
342
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100343 buf = kmalloc(size, mem_flags);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200344 if (!buf) {
345 usb_free_urb(urb);
346 return -ENOMEM;
347 }
348
349 pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
350
351 usb_fill_bulk_urb(urb, data->udev, pipe,
352 buf, size, btusb_bulk_complete, hdev);
353
354 urb->transfer_flags |= URB_FREE_BUFFER;
355
Oliver Neukum7bee5492009-08-24 23:44:59 +0200356 usb_mark_last_busy(data->udev);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200357 usb_anchor_urb(urb, &data->bulk_anchor);
358
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100359 err = usb_submit_urb(urb, mem_flags);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200360 if (err < 0) {
361 BT_ERR("%s urb %p submission failed (%d)",
362 hdev->name, urb, -err);
363 usb_unanchor_urb(urb);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200364 }
365
366 usb_free_urb(urb);
367
368 return err;
369}
370
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200371static void btusb_isoc_complete(struct urb *urb)
372{
373 struct hci_dev *hdev = urb->context;
374 struct btusb_data *data = hdev->driver_data;
375 int i, err;
376
377 BT_DBG("%s urb %p status %d count %d", hdev->name,
378 urb, urb->status, urb->actual_length);
379
380 if (!test_bit(HCI_RUNNING, &hdev->flags))
381 return;
382
383 if (urb->status == 0) {
384 for (i = 0; i < urb->number_of_packets; i++) {
385 unsigned int offset = urb->iso_frame_desc[i].offset;
386 unsigned int length = urb->iso_frame_desc[i].actual_length;
387
388 if (urb->iso_frame_desc[i].status)
389 continue;
390
391 hdev->stat.byte_rx += length;
392
393 if (hci_recv_fragment(hdev, HCI_SCODATA_PKT,
394 urb->transfer_buffer + offset,
395 length) < 0) {
396 BT_ERR("%s corrupted SCO packet", hdev->name);
397 hdev->stat.err_rx++;
398 }
399 }
400 }
401
402 if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
403 return;
404
405 usb_anchor_urb(urb, &data->isoc_anchor);
406
407 err = usb_submit_urb(urb, GFP_ATOMIC);
408 if (err < 0) {
409 BT_ERR("%s urb %p failed to resubmit (%d)",
410 hdev->name, urb, -err);
411 usb_unanchor_urb(urb);
412 }
413}
414
415static void inline __fill_isoc_descriptor(struct urb *urb, int len, int mtu)
416{
417 int i, offset = 0;
418
419 BT_DBG("len %d mtu %d", len, mtu);
420
421 for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
422 i++, offset += mtu, len -= mtu) {
423 urb->iso_frame_desc[i].offset = offset;
424 urb->iso_frame_desc[i].length = mtu;
425 }
426
427 if (len && i < BTUSB_MAX_ISOC_FRAMES) {
428 urb->iso_frame_desc[i].offset = offset;
429 urb->iso_frame_desc[i].length = len;
430 i++;
431 }
432
433 urb->number_of_packets = i;
434}
435
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100436static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200437{
438 struct btusb_data *data = hdev->driver_data;
439 struct urb *urb;
440 unsigned char *buf;
441 unsigned int pipe;
442 int err, size;
443
444 BT_DBG("%s", hdev->name);
445
446 if (!data->isoc_rx_ep)
447 return -ENODEV;
448
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100449 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200450 if (!urb)
451 return -ENOMEM;
452
453 size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
454 BTUSB_MAX_ISOC_FRAMES;
455
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100456 buf = kmalloc(size, mem_flags);
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200457 if (!buf) {
458 usb_free_urb(urb);
459 return -ENOMEM;
460 }
461
462 pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
463
464 urb->dev = data->udev;
465 urb->pipe = pipe;
466 urb->context = hdev;
467 urb->complete = btusb_isoc_complete;
468 urb->interval = data->isoc_rx_ep->bInterval;
469
470 urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;
471 urb->transfer_buffer = buf;
472 urb->transfer_buffer_length = size;
473
474 __fill_isoc_descriptor(urb, size,
475 le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
476
477 usb_anchor_urb(urb, &data->isoc_anchor);
478
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100479 err = usb_submit_urb(urb, mem_flags);
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200480 if (err < 0) {
481 BT_ERR("%s urb %p submission failed (%d)",
482 hdev->name, urb, -err);
483 usb_unanchor_urb(urb);
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200484 }
485
486 usb_free_urb(urb);
487
488 return err;
489}
490
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200491static void btusb_tx_complete(struct urb *urb)
492{
493 struct sk_buff *skb = urb->context;
494 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
Oliver Neukum7bee5492009-08-24 23:44:59 +0200495 struct btusb_data *data = hdev->driver_data;
496
497 BT_DBG("%s urb %p status %d count %d", hdev->name,
498 urb, urb->status, urb->actual_length);
499
500 if (!test_bit(HCI_RUNNING, &hdev->flags))
501 goto done;
502
503 if (!urb->status)
504 hdev->stat.byte_tx += urb->transfer_buffer_length;
505 else
506 hdev->stat.err_tx++;
507
508done:
509 spin_lock(&data->txlock);
510 data->tx_in_flight--;
511 spin_unlock(&data->txlock);
512
513 kfree(urb->setup_packet);
514
515 kfree_skb(skb);
516}
517
518static void btusb_isoc_tx_complete(struct urb *urb)
519{
520 struct sk_buff *skb = urb->context;
521 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200522
523 BT_DBG("%s urb %p status %d count %d", hdev->name,
524 urb, urb->status, urb->actual_length);
525
526 if (!test_bit(HCI_RUNNING, &hdev->flags))
527 goto done;
528
529 if (!urb->status)
530 hdev->stat.byte_tx += urb->transfer_buffer_length;
531 else
532 hdev->stat.err_tx++;
533
534done:
535 kfree(urb->setup_packet);
536
537 kfree_skb(skb);
538}
539
540static int btusb_open(struct hci_dev *hdev)
541{
542 struct btusb_data *data = hdev->driver_data;
543 int err;
544
545 BT_DBG("%s", hdev->name);
546
Oliver Neukum7bee5492009-08-24 23:44:59 +0200547 err = usb_autopm_get_interface(data->intf);
548 if (err < 0)
549 return err;
550
551 data->intf->needs_remote_wakeup = 1;
552
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200553 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
Oliver Neukum7bee5492009-08-24 23:44:59 +0200554 goto done;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200555
556 if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
Oliver Neukum7bee5492009-08-24 23:44:59 +0200557 goto done;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200558
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100559 err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
Marcel Holtmann43c2e572009-02-04 17:41:38 +0100560 if (err < 0)
561 goto failed;
562
563 err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200564 if (err < 0) {
Marcel Holtmann43c2e572009-02-04 17:41:38 +0100565 usb_kill_anchored_urbs(&data->intr_anchor);
566 goto failed;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200567 }
568
Marcel Holtmann43c2e572009-02-04 17:41:38 +0100569 set_bit(BTUSB_BULK_RUNNING, &data->flags);
570 btusb_submit_bulk_urb(hdev, GFP_KERNEL);
571
Oliver Neukum7bee5492009-08-24 23:44:59 +0200572done:
573 usb_autopm_put_interface(data->intf);
Marcel Holtmann43c2e572009-02-04 17:41:38 +0100574 return 0;
575
576failed:
577 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
578 clear_bit(HCI_RUNNING, &hdev->flags);
Oliver Neukum7bee5492009-08-24 23:44:59 +0200579 usb_autopm_put_interface(data->intf);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200580 return err;
581}
582
Oliver Neukum7bee5492009-08-24 23:44:59 +0200583static void btusb_stop_traffic(struct btusb_data *data)
584{
585 usb_kill_anchored_urbs(&data->intr_anchor);
586 usb_kill_anchored_urbs(&data->bulk_anchor);
587 usb_kill_anchored_urbs(&data->isoc_anchor);
588}
589
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200590static int btusb_close(struct hci_dev *hdev)
591{
592 struct btusb_data *data = hdev->driver_data;
Oliver Neukum7bee5492009-08-24 23:44:59 +0200593 int err;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200594
595 BT_DBG("%s", hdev->name);
596
597 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
598 return 0;
599
Marcel Holtmanne8c3c3d2008-09-23 00:16:36 +0200600 cancel_work_sync(&data->work);
Linus Torvalds404291a2009-11-11 13:32:29 -0800601 cancel_work_sync(&data->waker);
Marcel Holtmanne8c3c3d2008-09-23 00:16:36 +0200602
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200603 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200604 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200605 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
Oliver Neukum7bee5492009-08-24 23:44:59 +0200606
607 btusb_stop_traffic(data);
608 err = usb_autopm_get_interface(data->intf);
609 if (err < 0)
Oliver Neukum7b8e2c12009-11-13 14:26:23 +0100610 goto failed;
Oliver Neukum7bee5492009-08-24 23:44:59 +0200611
612 data->intf->needs_remote_wakeup = 0;
613 usb_autopm_put_interface(data->intf);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200614
Oliver Neukum7b8e2c12009-11-13 14:26:23 +0100615failed:
616 usb_scuttle_anchored_urbs(&data->deferred);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200617 return 0;
618}
619
620static int btusb_flush(struct hci_dev *hdev)
621{
622 struct btusb_data *data = hdev->driver_data;
623
624 BT_DBG("%s", hdev->name);
625
626 usb_kill_anchored_urbs(&data->tx_anchor);
627
628 return 0;
629}
630
631static int btusb_send_frame(struct sk_buff *skb)
632{
633 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
634 struct btusb_data *data = hdev->driver_data;
635 struct usb_ctrlrequest *dr;
636 struct urb *urb;
637 unsigned int pipe;
638 int err;
639
640 BT_DBG("%s", hdev->name);
641
642 if (!test_bit(HCI_RUNNING, &hdev->flags))
643 return -EBUSY;
644
645 switch (bt_cb(skb)->pkt_type) {
646 case HCI_COMMAND_PKT:
647 urb = usb_alloc_urb(0, GFP_ATOMIC);
648 if (!urb)
649 return -ENOMEM;
650
651 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
652 if (!dr) {
653 usb_free_urb(urb);
654 return -ENOMEM;
655 }
656
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100657 dr->bRequestType = data->cmdreq_type;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200658 dr->bRequest = 0;
659 dr->wIndex = 0;
660 dr->wValue = 0;
661 dr->wLength = __cpu_to_le16(skb->len);
662
663 pipe = usb_sndctrlpipe(data->udev, 0x00);
664
665 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
666 skb->data, skb->len, btusb_tx_complete, skb);
667
668 hdev->stat.cmd_tx++;
669 break;
670
671 case HCI_ACLDATA_PKT:
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200672 if (!data->bulk_tx_ep || hdev->conn_hash.acl_num < 1)
673 return -ENODEV;
674
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200675 urb = usb_alloc_urb(0, GFP_ATOMIC);
676 if (!urb)
677 return -ENOMEM;
678
679 pipe = usb_sndbulkpipe(data->udev,
680 data->bulk_tx_ep->bEndpointAddress);
681
682 usb_fill_bulk_urb(urb, data->udev, pipe,
683 skb->data, skb->len, btusb_tx_complete, skb);
684
685 hdev->stat.acl_tx++;
686 break;
687
688 case HCI_SCODATA_PKT:
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200689 if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1)
690 return -ENODEV;
691
692 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);
693 if (!urb)
694 return -ENOMEM;
695
696 pipe = usb_sndisocpipe(data->udev,
697 data->isoc_tx_ep->bEndpointAddress);
698
699 urb->dev = data->udev;
700 urb->pipe = pipe;
701 urb->context = skb;
Oliver Neukum7bee5492009-08-24 23:44:59 +0200702 urb->complete = btusb_isoc_tx_complete;
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200703 urb->interval = data->isoc_tx_ep->bInterval;
704
705 urb->transfer_flags = URB_ISO_ASAP;
706 urb->transfer_buffer = skb->data;
707 urb->transfer_buffer_length = skb->len;
708
709 __fill_isoc_descriptor(urb, skb->len,
710 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
711
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200712 hdev->stat.sco_tx++;
Oliver Neukum7bee5492009-08-24 23:44:59 +0200713 goto skip_waking;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200714
715 default:
716 return -EILSEQ;
717 }
718
Oliver Neukum7bee5492009-08-24 23:44:59 +0200719 err = inc_tx(data);
720 if (err) {
721 usb_anchor_urb(urb, &data->deferred);
722 schedule_work(&data->waker);
723 err = 0;
724 goto done;
725 }
726
727skip_waking:
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200728 usb_anchor_urb(urb, &data->tx_anchor);
729
730 err = usb_submit_urb(urb, GFP_ATOMIC);
731 if (err < 0) {
732 BT_ERR("%s urb %p submission failed", hdev->name, urb);
733 kfree(urb->setup_packet);
734 usb_unanchor_urb(urb);
Oliver Neukum7bee5492009-08-24 23:44:59 +0200735 } else {
736 usb_mark_last_busy(data->udev);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200737 }
738
739 usb_free_urb(urb);
740
Oliver Neukum7bee5492009-08-24 23:44:59 +0200741done:
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200742 return err;
743}
744
745static void btusb_destruct(struct hci_dev *hdev)
746{
747 struct btusb_data *data = hdev->driver_data;
748
749 BT_DBG("%s", hdev->name);
750
751 kfree(data);
752}
753
754static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
755{
756 struct btusb_data *data = hdev->driver_data;
757
758 BT_DBG("%s evt %d", hdev->name, evt);
759
Marcel Holtmann43c2e572009-02-04 17:41:38 +0100760 if (hdev->conn_hash.sco_num != data->sco_num) {
761 data->sco_num = hdev->conn_hash.sco_num;
762 schedule_work(&data->work);
Marcel Holtmanna780efa2008-11-30 12:17:12 +0100763 }
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200764}
765
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200766static int inline __set_isoc_interface(struct hci_dev *hdev, int altsetting)
767{
768 struct btusb_data *data = hdev->driver_data;
769 struct usb_interface *intf = data->isoc;
770 struct usb_endpoint_descriptor *ep_desc;
771 int i, err;
772
773 if (!data->isoc)
774 return -ENODEV;
775
776 err = usb_set_interface(data->udev, 1, altsetting);
777 if (err < 0) {
778 BT_ERR("%s setting interface failed (%d)", hdev->name, -err);
779 return err;
780 }
781
782 data->isoc_altsetting = altsetting;
783
784 data->isoc_tx_ep = NULL;
785 data->isoc_rx_ep = NULL;
786
787 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
788 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
789
790 if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
791 data->isoc_tx_ep = ep_desc;
792 continue;
793 }
794
795 if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
796 data->isoc_rx_ep = ep_desc;
797 continue;
798 }
799 }
800
801 if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
802 BT_ERR("%s invalid SCO descriptors", hdev->name);
803 return -ENODEV;
804 }
805
806 return 0;
807}
808
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200809static void btusb_work(struct work_struct *work)
810{
811 struct btusb_data *data = container_of(work, struct btusb_data, work);
812 struct hci_dev *hdev = data->hdev;
Oliver Neukum7bee5492009-08-24 23:44:59 +0200813 int err;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200814
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200815 if (hdev->conn_hash.sco_num > 0) {
Gustavo F. Padovan08b8b6c2010-07-16 17:20:33 -0300816 if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
Oliver Neukum7bee5492009-08-24 23:44:59 +0200817 err = usb_autopm_get_interface(data->isoc);
818 if (err < 0) {
819 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
820 usb_kill_anchored_urbs(&data->isoc_anchor);
821 return;
822 }
823
Gustavo F. Padovan08b8b6c2010-07-16 17:20:33 -0300824 set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
Oliver Neukum7bee5492009-08-24 23:44:59 +0200825 }
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200826 if (data->isoc_altsetting != 2) {
827 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
828 usb_kill_anchored_urbs(&data->isoc_anchor);
829
830 if (__set_isoc_interface(hdev, 2) < 0)
831 return;
832 }
833
834 if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100835 if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200836 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
837 else
Marcel Holtmann2eda66f2008-11-30 12:17:10 +0100838 btusb_submit_isoc_urb(hdev, GFP_KERNEL);
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200839 }
840 } else {
841 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
842 usb_kill_anchored_urbs(&data->isoc_anchor);
843
844 __set_isoc_interface(hdev, 0);
Gustavo F. Padovan08b8b6c2010-07-16 17:20:33 -0300845 if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
Oliver Neukum7bee5492009-08-24 23:44:59 +0200846 usb_autopm_put_interface(data->isoc);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200847 }
848}
849
Oliver Neukum7bee5492009-08-24 23:44:59 +0200850static void btusb_waker(struct work_struct *work)
851{
852 struct btusb_data *data = container_of(work, struct btusb_data, waker);
853 int err;
854
855 err = usb_autopm_get_interface(data->intf);
856 if (err < 0)
857 return;
858
859 usb_autopm_put_interface(data->intf);
860}
861
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200862static int btusb_probe(struct usb_interface *intf,
863 const struct usb_device_id *id)
864{
865 struct usb_endpoint_descriptor *ep_desc;
866 struct btusb_data *data;
867 struct hci_dev *hdev;
868 int i, err;
869
870 BT_DBG("intf %p id %p", intf, id);
871
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200872 /* interface numbers are hardcoded in the spec */
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200873 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
874 return -ENODEV;
875
876 if (!id->driver_info) {
877 const struct usb_device_id *match;
878 match = usb_match_id(intf, blacklist_table);
879 if (match)
880 id = match;
881 }
882
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200883 if (id->driver_info == BTUSB_IGNORE)
884 return -ENODEV;
885
886 if (ignore_dga && id->driver_info & BTUSB_DIGIANSWER)
887 return -ENODEV;
888
889 if (ignore_csr && id->driver_info & BTUSB_CSR)
890 return -ENODEV;
891
892 if (ignore_sniffer && id->driver_info & BTUSB_SNIFFER)
893 return -ENODEV;
894
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200895 data = kzalloc(sizeof(*data), GFP_KERNEL);
896 if (!data)
897 return -ENOMEM;
898
899 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
900 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
901
902 if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
903 data->intr_ep = ep_desc;
904 continue;
905 }
906
907 if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
908 data->bulk_tx_ep = ep_desc;
909 continue;
910 }
911
912 if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
913 data->bulk_rx_ep = ep_desc;
914 continue;
915 }
916 }
917
918 if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) {
919 kfree(data);
920 return -ENODEV;
921 }
922
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100923 data->cmdreq_type = USB_TYPE_CLASS;
924
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200925 data->udev = interface_to_usbdev(intf);
Marcel Holtmann5fbcd262008-09-23 00:16:36 +0200926 data->intf = intf;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200927
928 spin_lock_init(&data->lock);
929
930 INIT_WORK(&data->work, btusb_work);
Oliver Neukum7bee5492009-08-24 23:44:59 +0200931 INIT_WORK(&data->waker, btusb_waker);
932 spin_lock_init(&data->txlock);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200933
934 init_usb_anchor(&data->tx_anchor);
935 init_usb_anchor(&data->intr_anchor);
936 init_usb_anchor(&data->bulk_anchor);
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200937 init_usb_anchor(&data->isoc_anchor);
Oliver Neukum7bee5492009-08-24 23:44:59 +0200938 init_usb_anchor(&data->deferred);
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200939
940 hdev = hci_alloc_dev();
941 if (!hdev) {
942 kfree(data);
943 return -ENOMEM;
944 }
945
Marcel Holtmannc13854c2010-02-08 15:27:07 +0100946 hdev->bus = HCI_USB;
Marcel Holtmann5e23b922007-10-20 14:12:34 +0200947 hdev->driver_data = data;
948
949 data->hdev = hdev;
950
951 SET_HCIDEV_DEV(hdev, &intf->dev);
952
953 hdev->open = btusb_open;
954 hdev->close = btusb_close;
955 hdev->flush = btusb_flush;
956 hdev->send = btusb_send_frame;
957 hdev->destruct = btusb_destruct;
958 hdev->notify = btusb_notify;
959
960 hdev->owner = THIS_MODULE;
961
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100962 /* Interface numbers are hardcoded in the specification */
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200963 data->isoc = usb_ifnum_to_if(data->udev, 1);
964
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100965 if (!reset)
966 set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200967
968 if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {
969 if (!disable_scofix)
970 set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
971 }
972
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200973 if (id->driver_info & BTUSB_BROKEN_ISOC)
974 data->isoc = NULL;
975
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100976 if (id->driver_info & BTUSB_DIGIANSWER) {
977 data->cmdreq_type = USB_TYPE_VENDOR;
978 set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);
979 }
980
981 if (id->driver_info & BTUSB_CSR) {
982 struct usb_device *udev = data->udev;
983
984 /* Old firmware would otherwise execute USB reset */
985 if (le16_to_cpu(udev->descriptor.bcdDevice) < 0x117)
986 set_bit(HCI_QUIRK_NO_RESET, &hdev->quirks);
987 }
988
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200989 if (id->driver_info & BTUSB_SNIFFER) {
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200990 struct usb_device *udev = data->udev;
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200991
Marcel Holtmann7a9d4022008-11-30 12:17:26 +0100992 /* New sniffer firmware has crippled HCI interface */
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200993 if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
994 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +0200995
996 data->isoc = NULL;
Marcel Holtmanncfeb4142008-08-07 22:26:56 +0200997 }
998
999 if (id->driver_info & BTUSB_BCM92035) {
1000 unsigned char cmd[] = { 0x3b, 0xfc, 0x01, 0x00 };
1001 struct sk_buff *skb;
1002
1003 skb = bt_skb_alloc(sizeof(cmd), GFP_KERNEL);
1004 if (skb) {
1005 memcpy(skb_put(skb, sizeof(cmd)), cmd, sizeof(cmd));
1006 skb_queue_tail(&hdev->driver_init, skb);
1007 }
1008 }
Marcel Holtmann5e23b922007-10-20 14:12:34 +02001009
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +02001010 if (data->isoc) {
1011 err = usb_driver_claim_interface(&btusb_driver,
Marcel Holtmann5fbcd262008-09-23 00:16:36 +02001012 data->isoc, data);
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +02001013 if (err < 0) {
1014 hci_free_dev(hdev);
1015 kfree(data);
1016 return err;
1017 }
1018 }
1019
Marcel Holtmann5e23b922007-10-20 14:12:34 +02001020 err = hci_register_dev(hdev);
1021 if (err < 0) {
1022 hci_free_dev(hdev);
1023 kfree(data);
1024 return err;
1025 }
1026
1027 usb_set_intfdata(intf, data);
1028
1029 return 0;
1030}
1031
1032static void btusb_disconnect(struct usb_interface *intf)
1033{
1034 struct btusb_data *data = usb_get_intfdata(intf);
1035 struct hci_dev *hdev;
1036
1037 BT_DBG("intf %p", intf);
1038
1039 if (!data)
1040 return;
1041
1042 hdev = data->hdev;
1043
Marcel Holtmann5fbcd262008-09-23 00:16:36 +02001044 __hci_dev_hold(hdev);
Marcel Holtmann9bfa35f2008-08-18 13:23:52 +02001045
Marcel Holtmann5fbcd262008-09-23 00:16:36 +02001046 usb_set_intfdata(data->intf, NULL);
1047
1048 if (data->isoc)
1049 usb_set_intfdata(data->isoc, NULL);
Marcel Holtmann5e23b922007-10-20 14:12:34 +02001050
1051 hci_unregister_dev(hdev);
1052
Marcel Holtmann5fbcd262008-09-23 00:16:36 +02001053 if (intf == data->isoc)
1054 usb_driver_release_interface(&btusb_driver, data->intf);
1055 else if (data->isoc)
1056 usb_driver_release_interface(&btusb_driver, data->isoc);
1057
1058 __hci_dev_put(hdev);
1059
Marcel Holtmann5e23b922007-10-20 14:12:34 +02001060 hci_free_dev(hdev);
1061}
1062
Oliver Neukum7bee5492009-08-24 23:44:59 +02001063#ifdef CONFIG_PM
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001064static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
1065{
1066 struct btusb_data *data = usb_get_intfdata(intf);
1067
1068 BT_DBG("intf %p", intf);
1069
1070 if (data->suspend_count++)
1071 return 0;
1072
Oliver Neukum7bee5492009-08-24 23:44:59 +02001073 spin_lock_irq(&data->txlock);
Alan Sternfb34d532009-11-13 11:53:59 -05001074 if (!((message.event & PM_EVENT_AUTO) && data->tx_in_flight)) {
Oliver Neukum7bee5492009-08-24 23:44:59 +02001075 set_bit(BTUSB_SUSPENDING, &data->flags);
1076 spin_unlock_irq(&data->txlock);
1077 } else {
1078 spin_unlock_irq(&data->txlock);
1079 data->suspend_count--;
1080 return -EBUSY;
1081 }
1082
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001083 cancel_work_sync(&data->work);
1084
Oliver Neukum7bee5492009-08-24 23:44:59 +02001085 btusb_stop_traffic(data);
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001086 usb_kill_anchored_urbs(&data->tx_anchor);
1087
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001088 return 0;
1089}
1090
Oliver Neukum7bee5492009-08-24 23:44:59 +02001091static void play_deferred(struct btusb_data *data)
1092{
1093 struct urb *urb;
1094 int err;
1095
1096 while ((urb = usb_get_from_anchor(&data->deferred))) {
1097 err = usb_submit_urb(urb, GFP_ATOMIC);
1098 if (err < 0)
1099 break;
1100
1101 data->tx_in_flight++;
1102 }
1103 usb_scuttle_anchored_urbs(&data->deferred);
1104}
1105
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001106static int btusb_resume(struct usb_interface *intf)
1107{
1108 struct btusb_data *data = usb_get_intfdata(intf);
1109 struct hci_dev *hdev = data->hdev;
Oliver Neukum7bee5492009-08-24 23:44:59 +02001110 int err = 0;
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001111
1112 BT_DBG("intf %p", intf);
1113
1114 if (--data->suspend_count)
1115 return 0;
1116
1117 if (!test_bit(HCI_RUNNING, &hdev->flags))
Oliver Neukum7bee5492009-08-24 23:44:59 +02001118 goto done;
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001119
1120 if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
1121 err = btusb_submit_intr_urb(hdev, GFP_NOIO);
1122 if (err < 0) {
1123 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
Oliver Neukum7bee5492009-08-24 23:44:59 +02001124 goto failed;
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001125 }
1126 }
1127
1128 if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
Marcel Holtmann43c2e572009-02-04 17:41:38 +01001129 err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
1130 if (err < 0) {
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001131 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
Oliver Neukum7bee5492009-08-24 23:44:59 +02001132 goto failed;
1133 }
1134
1135 btusb_submit_bulk_urb(hdev, GFP_NOIO);
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001136 }
1137
1138 if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
1139 if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)
1140 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1141 else
1142 btusb_submit_isoc_urb(hdev, GFP_NOIO);
1143 }
1144
Oliver Neukum7bee5492009-08-24 23:44:59 +02001145 spin_lock_irq(&data->txlock);
1146 play_deferred(data);
1147 clear_bit(BTUSB_SUSPENDING, &data->flags);
1148 spin_unlock_irq(&data->txlock);
1149 schedule_work(&data->work);
1150
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001151 return 0;
Oliver Neukum7bee5492009-08-24 23:44:59 +02001152
1153failed:
1154 usb_scuttle_anchored_urbs(&data->deferred);
1155done:
1156 spin_lock_irq(&data->txlock);
1157 clear_bit(BTUSB_SUSPENDING, &data->flags);
1158 spin_unlock_irq(&data->txlock);
1159
1160 return err;
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001161}
Oliver Neukum7bee5492009-08-24 23:44:59 +02001162#endif
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001163
Marcel Holtmann5e23b922007-10-20 14:12:34 +02001164static struct usb_driver btusb_driver = {
1165 .name = "btusb",
1166 .probe = btusb_probe,
1167 .disconnect = btusb_disconnect,
Oliver Neukum7bee5492009-08-24 23:44:59 +02001168#ifdef CONFIG_PM
Marcel Holtmann6a88adf2008-11-30 12:17:14 +01001169 .suspend = btusb_suspend,
1170 .resume = btusb_resume,
Oliver Neukum7bee5492009-08-24 23:44:59 +02001171#endif
Marcel Holtmann5e23b922007-10-20 14:12:34 +02001172 .id_table = btusb_table,
Oliver Neukum7bee5492009-08-24 23:44:59 +02001173 .supports_autosuspend = 1,
Marcel Holtmann5e23b922007-10-20 14:12:34 +02001174};
1175
1176static int __init btusb_init(void)
1177{
1178 BT_INFO("Generic Bluetooth USB driver ver %s", VERSION);
1179
1180 return usb_register(&btusb_driver);
1181}
1182
1183static void __exit btusb_exit(void)
1184{
1185 usb_deregister(&btusb_driver);
1186}
1187
1188module_init(btusb_init);
1189module_exit(btusb_exit);
1190
Marcel Holtmanncfeb4142008-08-07 22:26:56 +02001191module_param(ignore_dga, bool, 0644);
1192MODULE_PARM_DESC(ignore_dga, "Ignore devices with id 08fd:0001");
1193
1194module_param(ignore_csr, bool, 0644);
1195MODULE_PARM_DESC(ignore_csr, "Ignore devices with id 0a12:0001");
1196
1197module_param(ignore_sniffer, bool, 0644);
1198MODULE_PARM_DESC(ignore_sniffer, "Ignore devices with id 0a12:0002");
1199
1200module_param(disable_scofix, bool, 0644);
1201MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
1202
1203module_param(force_scofix, bool, 0644);
1204MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
1205
1206module_param(reset, bool, 0644);
1207MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
1208
Marcel Holtmann5e23b922007-10-20 14:12:34 +02001209MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1210MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);
1211MODULE_VERSION(VERSION);
1212MODULE_LICENSE("GPL");