source: src/linux/universal/linux-3.18/drivers/bluetooth/btusb.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

File size: 57.8 KB
Line 
1/*
2 *
3 *  Generic Bluetooth USB driver
4 *
5 *  Copyright (C) 2005-2008  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/module.h>
25#include <linux/usb.h>
26#include <linux/firmware.h>
27
28#include <net/bluetooth/bluetooth.h>
29#include <net/bluetooth/hci_core.h>
30
31#define VERSION "0.6"
32
33static bool disable_scofix;
34static bool force_scofix;
35
36static bool reset = 1;
37
38static struct usb_driver btusb_driver;
39
40#define BTUSB_IGNORE            0x01
41#define BTUSB_DIGIANSWER        0x02
42#define BTUSB_CSR               0x04
43#define BTUSB_SNIFFER           0x08
44#define BTUSB_BCM92035          0x10
45#define BTUSB_BROKEN_ISOC       0x20
46#define BTUSB_WRONG_SCO_MTU     0x40
47#define BTUSB_ATH3012           0x80
48#define BTUSB_INTEL             0x100
49#define BTUSB_INTEL_BOOT        0x200
50#define BTUSB_BCM_PATCHRAM      0x400
51#define BTUSB_MARVELL           0x800
52
53static const struct usb_device_id btusb_table[] = {
54        /* Generic Bluetooth USB device */
55        { USB_DEVICE_INFO(0xe0, 0x01, 0x01) },
56
57        /* Apple-specific (Broadcom) devices */
58        { USB_VENDOR_AND_INTERFACE_INFO(0x05ac, 0xff, 0x01, 0x01) },
59
60        /* MediaTek MT76x0E */
61        { USB_DEVICE(0x0e8d, 0x763f) },
62
63        /* Broadcom SoftSailing reporting vendor specific */
64        { USB_DEVICE(0x0a5c, 0x21e1) },
65
66        /* Apple MacBookPro 7,1 */
67        { USB_DEVICE(0x05ac, 0x8213) },
68
69        /* Apple iMac11,1 */
70        { USB_DEVICE(0x05ac, 0x8215) },
71
72        /* Apple MacBookPro6,2 */
73        { USB_DEVICE(0x05ac, 0x8218) },
74
75        /* Apple MacBookAir3,1, MacBookAir3,2 */
76        { USB_DEVICE(0x05ac, 0x821b) },
77
78        /* Apple MacBookAir4,1 */
79        { USB_DEVICE(0x05ac, 0x821f) },
80
81        /* Apple MacBookPro8,2 */
82        { USB_DEVICE(0x05ac, 0x821a) },
83
84        /* Apple MacMini5,1 */
85        { USB_DEVICE(0x05ac, 0x8281) },
86
87        /* AVM BlueFRITZ! USB v2.0 */
88        { USB_DEVICE(0x057c, 0x3800) },
89
90        /* Bluetooth Ultraport Module from IBM */
91        { USB_DEVICE(0x04bf, 0x030a) },
92
93        /* ALPS Modules with non-standard id */
94        { USB_DEVICE(0x044e, 0x3001) },
95        { USB_DEVICE(0x044e, 0x3002) },
96
97        /* Ericsson with non-standard id */
98        { USB_DEVICE(0x0bdb, 0x1002) },
99
100        /* Canyon CN-BTU1 with HID interfaces */
101        { USB_DEVICE(0x0c10, 0x0000) },
102
103        /* Broadcom BCM20702A0 */
104        { USB_DEVICE(0x0489, 0xe042) },
105        { USB_DEVICE(0x04ca, 0x2003) },
106        { USB_DEVICE(0x0b05, 0x17b5) },
107        { USB_DEVICE(0x0b05, 0x17cb) },
108        { USB_DEVICE(0x413c, 0x8197) },
109
110        /* Broadcom BCM20702B0 (Dynex/Insignia) */
111        { USB_DEVICE(0x19ff, 0x0239), .driver_info = BTUSB_BCM_PATCHRAM },
112
113        /* Foxconn - Hon Hai */
114        { USB_VENDOR_AND_INTERFACE_INFO(0x0489, 0xff, 0x01, 0x01) },
115
116        /* Lite-On Technology - Broadcom based */
117        { USB_VENDOR_AND_INTERFACE_INFO(0x04ca, 0xff, 0x01, 0x01),
118          .driver_info = BTUSB_BCM_PATCHRAM },
119
120        /* Broadcom devices with vendor specific id */
121        { USB_VENDOR_AND_INTERFACE_INFO(0x0a5c, 0xff, 0x01, 0x01),
122          .driver_info = BTUSB_BCM_PATCHRAM },
123
124        /* ASUSTek Computer - Broadcom based */
125        { USB_VENDOR_AND_INTERFACE_INFO(0x0b05, 0xff, 0x01, 0x01),
126          .driver_info = BTUSB_BCM_PATCHRAM },
127
128        /* ASUSTek Computer - Broadcom based */
129        { USB_VENDOR_AND_INTERFACE_INFO(0x0b05, 0xff, 0x01, 0x01) },
130
131        /* Belkin F8065bf - Broadcom based */
132        { USB_VENDOR_AND_INTERFACE_INFO(0x050d, 0xff, 0x01, 0x01) },
133
134        /* IMC Networks - Broadcom based */
135        { USB_VENDOR_AND_INTERFACE_INFO(0x13d3, 0xff, 0x01, 0x01) },
136
137        /* Toshiba Corp - Broadcom based */
138        { USB_VENDOR_AND_INTERFACE_INFO(0x0930, 0xff, 0x01, 0x01),
139          .driver_info = BTUSB_BCM_PATCHRAM },
140
141        /* Intel Bluetooth USB Bootloader (RAM module) */
142        { USB_DEVICE(0x8087, 0x0a5a),
143          .driver_info = BTUSB_INTEL_BOOT | BTUSB_BROKEN_ISOC },
144
145        { }     /* Terminating entry */
146};
147
148MODULE_DEVICE_TABLE(usb, btusb_table);
149
150static const struct usb_device_id blacklist_table[] = {
151        /* CSR BlueCore devices */
152        { USB_DEVICE(0x0a12, 0x0001), .driver_info = BTUSB_CSR },
153
154        /* Broadcom BCM2033 without firmware */
155        { USB_DEVICE(0x0a5c, 0x2033), .driver_info = BTUSB_IGNORE },
156
157        /* Atheros 3011 with sflash firmware */
158        { USB_DEVICE(0x0489, 0xe027), .driver_info = BTUSB_IGNORE },
159        { USB_DEVICE(0x0489, 0xe03d), .driver_info = BTUSB_IGNORE },
160        { USB_DEVICE(0x04f2, 0xaff1), .driver_info = BTUSB_IGNORE },
161        { USB_DEVICE(0x0930, 0x0215), .driver_info = BTUSB_IGNORE },
162        { USB_DEVICE(0x0cf3, 0x3002), .driver_info = BTUSB_IGNORE },
163        { USB_DEVICE(0x0cf3, 0xe019), .driver_info = BTUSB_IGNORE },
164        { USB_DEVICE(0x13d3, 0x3304), .driver_info = BTUSB_IGNORE },
165
166        /* Atheros AR9285 Malbec with sflash firmware */
167        { USB_DEVICE(0x03f0, 0x311d), .driver_info = BTUSB_IGNORE },
168
169        /* Atheros 3012 with sflash firmware */
170        { USB_DEVICE(0x0489, 0xe04d), .driver_info = BTUSB_ATH3012 },
171        { USB_DEVICE(0x0489, 0xe04e), .driver_info = BTUSB_ATH3012 },
172        { USB_DEVICE(0x0489, 0xe056), .driver_info = BTUSB_ATH3012 },
173        { USB_DEVICE(0x0489, 0xe057), .driver_info = BTUSB_ATH3012 },
174        { USB_DEVICE(0x0489, 0xe05f), .driver_info = BTUSB_ATH3012 },
175        { USB_DEVICE(0x0489, 0xe076), .driver_info = BTUSB_ATH3012 },
176        { USB_DEVICE(0x0489, 0xe078), .driver_info = BTUSB_ATH3012 },
177        { USB_DEVICE(0x0489, 0xe095), .driver_info = BTUSB_ATH3012 },
178        { USB_DEVICE(0x04c5, 0x1330), .driver_info = BTUSB_ATH3012 },
179        { USB_DEVICE(0x04ca, 0x3004), .driver_info = BTUSB_ATH3012 },
180        { USB_DEVICE(0x04ca, 0x3005), .driver_info = BTUSB_ATH3012 },
181        { USB_DEVICE(0x04ca, 0x3006), .driver_info = BTUSB_ATH3012 },
182        { USB_DEVICE(0x04ca, 0x3007), .driver_info = BTUSB_ATH3012 },
183        { USB_DEVICE(0x04ca, 0x3008), .driver_info = BTUSB_ATH3012 },
184        { USB_DEVICE(0x04ca, 0x300b), .driver_info = BTUSB_ATH3012 },
185        { USB_DEVICE(0x04ca, 0x300d), .driver_info = BTUSB_ATH3012 },
186        { USB_DEVICE(0x04ca, 0x300f), .driver_info = BTUSB_ATH3012 },
187        { USB_DEVICE(0x04ca, 0x3010), .driver_info = BTUSB_ATH3012 },
188        { USB_DEVICE(0x04ca, 0x3014), .driver_info = BTUSB_ATH3012 },
189        { USB_DEVICE(0x04ca, 0x3018), .driver_info = BTUSB_ATH3012 },
190        { USB_DEVICE(0x0930, 0x0219), .driver_info = BTUSB_ATH3012 },
191        { USB_DEVICE(0x0930, 0x0220), .driver_info = BTUSB_ATH3012 },
192        { USB_DEVICE(0x0930, 0x0227), .driver_info = BTUSB_ATH3012 },
193        { USB_DEVICE(0x0b05, 0x17d0), .driver_info = BTUSB_ATH3012 },
194        { USB_DEVICE(0x0cf3, 0x0036), .driver_info = BTUSB_ATH3012 },
195        { USB_DEVICE(0x0cf3, 0x3004), .driver_info = BTUSB_ATH3012 },
196        { USB_DEVICE(0x0cf3, 0x3008), .driver_info = BTUSB_ATH3012 },
197        { USB_DEVICE(0x0cf3, 0x311d), .driver_info = BTUSB_ATH3012 },
198        { USB_DEVICE(0x0cf3, 0x311e), .driver_info = BTUSB_ATH3012 },
199        { USB_DEVICE(0x0cf3, 0x311f), .driver_info = BTUSB_ATH3012 },
200        { USB_DEVICE(0x0cf3, 0x3121), .driver_info = BTUSB_ATH3012 },
201        { USB_DEVICE(0x0cf3, 0x817a), .driver_info = BTUSB_ATH3012 },
202        { USB_DEVICE(0x0cf3, 0xe003), .driver_info = BTUSB_ATH3012 },
203        { USB_DEVICE(0x0cf3, 0xe004), .driver_info = BTUSB_ATH3012 },
204        { USB_DEVICE(0x0cf3, 0xe005), .driver_info = BTUSB_ATH3012 },
205        { USB_DEVICE(0x0cf3, 0xe006), .driver_info = BTUSB_ATH3012 },
206        { USB_DEVICE(0x13d3, 0x3362), .driver_info = BTUSB_ATH3012 },
207        { USB_DEVICE(0x13d3, 0x3375), .driver_info = BTUSB_ATH3012 },
208        { USB_DEVICE(0x13d3, 0x3393), .driver_info = BTUSB_ATH3012 },
209        { USB_DEVICE(0x13d3, 0x3395), .driver_info = BTUSB_ATH3012 },
210        { USB_DEVICE(0x13d3, 0x3402), .driver_info = BTUSB_ATH3012 },
211        { USB_DEVICE(0x13d3, 0x3408), .driver_info = BTUSB_ATH3012 },
212        { USB_DEVICE(0x13d3, 0x3423), .driver_info = BTUSB_ATH3012 },
213        { USB_DEVICE(0x13d3, 0x3432), .driver_info = BTUSB_ATH3012 },
214        { USB_DEVICE(0x13d3, 0x3472), .driver_info = BTUSB_ATH3012 },
215        { USB_DEVICE(0x13d3, 0x3474), .driver_info = BTUSB_ATH3012 },
216        { USB_DEVICE(0x13d3, 0x3487), .driver_info = BTUSB_ATH3012 },
217        { USB_DEVICE(0x13d3, 0x3490), .driver_info = BTUSB_ATH3012 },
218
219        /* Atheros AR5BBU12 with sflash firmware */
220        { USB_DEVICE(0x0489, 0xe02c), .driver_info = BTUSB_IGNORE },
221
222        /* Atheros AR5BBU12 with sflash firmware */
223        { USB_DEVICE(0x0489, 0xe036), .driver_info = BTUSB_ATH3012 },
224        { USB_DEVICE(0x0489, 0xe03c), .driver_info = BTUSB_ATH3012 },
225
226        /* Broadcom BCM2035 */
227        { USB_DEVICE(0x0a5c, 0x2009), .driver_info = BTUSB_BCM92035 },
228        { USB_DEVICE(0x0a5c, 0x200a), .driver_info = BTUSB_WRONG_SCO_MTU },
229        { USB_DEVICE(0x0a5c, 0x2035), .driver_info = BTUSB_WRONG_SCO_MTU },
230
231        /* Broadcom BCM2045 */
232        { USB_DEVICE(0x0a5c, 0x2039), .driver_info = BTUSB_WRONG_SCO_MTU },
233        { USB_DEVICE(0x0a5c, 0x2101), .driver_info = BTUSB_WRONG_SCO_MTU },
234
235        /* IBM/Lenovo ThinkPad with Broadcom chip */
236        { USB_DEVICE(0x0a5c, 0x201e), .driver_info = BTUSB_WRONG_SCO_MTU },
237        { USB_DEVICE(0x0a5c, 0x2110), .driver_info = BTUSB_WRONG_SCO_MTU },
238
239        /* HP laptop with Broadcom chip */
240        { USB_DEVICE(0x03f0, 0x171d), .driver_info = BTUSB_WRONG_SCO_MTU },
241
242        /* Dell laptop with Broadcom chip */
243        { USB_DEVICE(0x413c, 0x8126), .driver_info = BTUSB_WRONG_SCO_MTU },
244
245        /* Dell Wireless 370 and 410 devices */
246        { USB_DEVICE(0x413c, 0x8152), .driver_info = BTUSB_WRONG_SCO_MTU },
247        { USB_DEVICE(0x413c, 0x8156), .driver_info = BTUSB_WRONG_SCO_MTU },
248
249        /* Belkin F8T012 and F8T013 devices */
250        { USB_DEVICE(0x050d, 0x0012), .driver_info = BTUSB_WRONG_SCO_MTU },
251        { USB_DEVICE(0x050d, 0x0013), .driver_info = BTUSB_WRONG_SCO_MTU },
252
253        /* Asus WL-BTD202 device */
254        { USB_DEVICE(0x0b05, 0x1715), .driver_info = BTUSB_WRONG_SCO_MTU },
255
256        /* Kensington Bluetooth USB adapter */
257        { USB_DEVICE(0x047d, 0x105e), .driver_info = BTUSB_WRONG_SCO_MTU },
258
259        /* RTX Telecom based adapters with buggy SCO support */
260        { USB_DEVICE(0x0400, 0x0807), .driver_info = BTUSB_BROKEN_ISOC },
261        { USB_DEVICE(0x0400, 0x080a), .driver_info = BTUSB_BROKEN_ISOC },
262
263        /* CONWISE Technology based adapters with buggy SCO support */
264        { USB_DEVICE(0x0e5e, 0x6622), .driver_info = BTUSB_BROKEN_ISOC },
265
266        /* Digianswer devices */
267        { USB_DEVICE(0x08fd, 0x0001), .driver_info = BTUSB_DIGIANSWER },
268        { USB_DEVICE(0x08fd, 0x0002), .driver_info = BTUSB_IGNORE },
269
270        /* CSR BlueCore Bluetooth Sniffer */
271        { USB_DEVICE(0x0a12, 0x0002),
272          .driver_info = BTUSB_SNIFFER | BTUSB_BROKEN_ISOC },
273
274        /* Frontline ComProbe Bluetooth Sniffer */
275        { USB_DEVICE(0x16d3, 0x0002),
276          .driver_info = BTUSB_SNIFFER | BTUSB_BROKEN_ISOC },
277
278        /* Intel Bluetooth device */
279        { USB_DEVICE(0x8087, 0x07dc), .driver_info = BTUSB_INTEL },
280        { USB_DEVICE(0x8087, 0x0a2a), .driver_info = BTUSB_INTEL },
281
282        /* Marvell device */
283        { USB_DEVICE(0x1286, 0x2044), .driver_info = BTUSB_MARVELL },
284        { USB_DEVICE(0x1286, 0x2046), .driver_info = BTUSB_MARVELL },
285
286        { }     /* Terminating entry */
287};
288
289#define BTUSB_MAX_ISOC_FRAMES   10
290
291#define BTUSB_INTR_RUNNING      0
292#define BTUSB_BULK_RUNNING      1
293#define BTUSB_ISOC_RUNNING      2
294#define BTUSB_SUSPENDING        3
295#define BTUSB_DID_ISO_RESUME    4
296
297struct btusb_data {
298        struct hci_dev       *hdev;
299        struct usb_device    *udev;
300        struct usb_interface *intf;
301        struct usb_interface *isoc;
302
303        unsigned long flags;
304
305        struct work_struct work;
306        struct work_struct waker;
307
308        struct usb_anchor deferred;
309        struct usb_anchor tx_anchor;
310        int tx_in_flight;
311        spinlock_t txlock;
312
313        struct usb_anchor intr_anchor;
314        struct usb_anchor bulk_anchor;
315        struct usb_anchor isoc_anchor;
316        spinlock_t rxlock;
317
318        struct sk_buff *evt_skb;
319        struct sk_buff *acl_skb;
320        struct sk_buff *sco_skb;
321
322        struct usb_endpoint_descriptor *intr_ep;
323        struct usb_endpoint_descriptor *bulk_tx_ep;
324        struct usb_endpoint_descriptor *bulk_rx_ep;
325        struct usb_endpoint_descriptor *isoc_tx_ep;
326        struct usb_endpoint_descriptor *isoc_rx_ep;
327
328        __u8 cmdreq_type;
329
330        unsigned int sco_num;
331        int isoc_altsetting;
332        int suspend_count;
333};
334
335static inline void btusb_free_frags(struct btusb_data *data)
336{
337        unsigned long flags;
338
339        spin_lock_irqsave(&data->rxlock, flags);
340
341        kfree_skb(data->evt_skb);
342        data->evt_skb = NULL;
343
344        kfree_skb(data->acl_skb);
345        data->acl_skb = NULL;
346
347        kfree_skb(data->sco_skb);
348        data->sco_skb = NULL;
349
350        spin_unlock_irqrestore(&data->rxlock, flags);
351}
352
353static int btusb_recv_intr(struct btusb_data *data, void *buffer, int count)
354{
355        struct sk_buff *skb;
356        int err = 0;
357
358        spin_lock(&data->rxlock);
359        skb = data->evt_skb;
360
361        while (count) {
362                int len;
363
364                if (!skb) {
365                        skb = bt_skb_alloc(HCI_MAX_EVENT_SIZE, GFP_ATOMIC);
366                        if (!skb) {
367                                err = -ENOMEM;
368                                break;
369                        }
370
371                        bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
372                        bt_cb(skb)->expect = HCI_EVENT_HDR_SIZE;
373                }
374
375                len = min_t(uint, bt_cb(skb)->expect, count);
376                memcpy(skb_put(skb, len), buffer, len);
377
378                count -= len;
379                buffer += len;
380                bt_cb(skb)->expect -= len;
381
382                if (skb->len == HCI_EVENT_HDR_SIZE) {
383                        /* Complete event header */
384                        bt_cb(skb)->expect = hci_event_hdr(skb)->plen;
385
386                        if (skb_tailroom(skb) < bt_cb(skb)->expect) {
387                                kfree_skb(skb);
388                                skb = NULL;
389
390                                err = -EILSEQ;
391                                break;
392                        }
393                }
394
395                if (bt_cb(skb)->expect == 0) {
396                        /* Complete frame */
397                        hci_recv_frame(data->hdev, skb);
398                        skb = NULL;
399                }
400        }
401
402        data->evt_skb = skb;
403        spin_unlock(&data->rxlock);
404
405        return err;
406}
407
408static int btusb_recv_bulk(struct btusb_data *data, void *buffer, int count)
409{
410        struct sk_buff *skb;
411        int err = 0;
412
413        spin_lock(&data->rxlock);
414        skb = data->acl_skb;
415
416        while (count) {
417                int len;
418
419                if (!skb) {
420                        skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC);
421                        if (!skb) {
422                                err = -ENOMEM;
423                                break;
424                        }
425
426                        bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT;
427                        bt_cb(skb)->expect = HCI_ACL_HDR_SIZE;
428                }
429
430                len = min_t(uint, bt_cb(skb)->expect, count);
431                memcpy(skb_put(skb, len), buffer, len);
432
433                count -= len;
434                buffer += len;
435                bt_cb(skb)->expect -= len;
436
437                if (skb->len == HCI_ACL_HDR_SIZE) {
438                        __le16 dlen = hci_acl_hdr(skb)->dlen;
439
440                        /* Complete ACL header */
441                        bt_cb(skb)->expect = __le16_to_cpu(dlen);
442
443                        if (skb_tailroom(skb) < bt_cb(skb)->expect) {
444                                kfree_skb(skb);
445                                skb = NULL;
446
447                                err = -EILSEQ;
448                                break;
449                        }
450                }
451
452                if (bt_cb(skb)->expect == 0) {
453                        /* Complete frame */
454                        hci_recv_frame(data->hdev, skb);
455                        skb = NULL;
456                }
457        }
458
459        data->acl_skb = skb;
460        spin_unlock(&data->rxlock);
461
462        return err;
463}
464
465static int btusb_recv_isoc(struct btusb_data *data, void *buffer, int count)
466{
467        struct sk_buff *skb;
468        int err = 0;
469
470        spin_lock(&data->rxlock);
471        skb = data->sco_skb;
472
473        while (count) {
474                int len;
475
476                if (!skb) {
477                        skb = bt_skb_alloc(HCI_MAX_SCO_SIZE, GFP_ATOMIC);
478                        if (!skb) {
479                                err = -ENOMEM;
480                                break;
481                        }
482
483                        bt_cb(skb)->pkt_type = HCI_SCODATA_PKT;
484                        bt_cb(skb)->expect = HCI_SCO_HDR_SIZE;
485                }
486
487                len = min_t(uint, bt_cb(skb)->expect, count);
488                memcpy(skb_put(skb, len), buffer, len);
489
490                count -= len;
491                buffer += len;
492                bt_cb(skb)->expect -= len;
493
494                if (skb->len == HCI_SCO_HDR_SIZE) {
495                        /* Complete SCO header */
496                        bt_cb(skb)->expect = hci_sco_hdr(skb)->dlen;
497
498                        if (skb_tailroom(skb) < bt_cb(skb)->expect) {
499                                kfree_skb(skb);
500                                skb = NULL;
501
502                                err = -EILSEQ;
503                                break;
504                        }
505                }
506
507                if (bt_cb(skb)->expect == 0) {
508                        /* Complete frame */
509                        hci_recv_frame(data->hdev, skb);
510                        skb = NULL;
511                }
512        }
513
514        data->sco_skb = skb;
515        spin_unlock(&data->rxlock);
516
517        return err;
518}
519
520static void btusb_intr_complete(struct urb *urb)
521{
522        struct hci_dev *hdev = urb->context;
523        struct btusb_data *data = hci_get_drvdata(hdev);
524        int err;
525
526        BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
527               urb->actual_length);
528
529        if (!test_bit(HCI_RUNNING, &hdev->flags))
530                return;
531
532        if (urb->status == 0) {
533                hdev->stat.byte_rx += urb->actual_length;
534
535                if (btusb_recv_intr(data, urb->transfer_buffer,
536                                    urb->actual_length) < 0) {
537                        BT_ERR("%s corrupted event packet", hdev->name);
538                        hdev->stat.err_rx++;
539                }
540        } else if (urb->status == -ENOENT) {
541                /* Avoid suspend failed when usb_kill_urb */
542                return;
543        }
544
545        if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
546                return;
547
548        usb_mark_last_busy(data->udev);
549        usb_anchor_urb(urb, &data->intr_anchor);
550
551        err = usb_submit_urb(urb, GFP_ATOMIC);
552        if (err < 0) {
553                /* -EPERM: urb is being killed;
554                 * -ENODEV: device got disconnected */
555                if (err != -EPERM && err != -ENODEV)
556                        BT_ERR("%s urb %p failed to resubmit (%d)",
557                               hdev->name, urb, -err);
558                usb_unanchor_urb(urb);
559        }
560}
561
562static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
563{
564        struct btusb_data *data = hci_get_drvdata(hdev);
565        struct urb *urb;
566        unsigned char *buf;
567        unsigned int pipe;
568        int err, size;
569
570        BT_DBG("%s", hdev->name);
571
572        if (!data->intr_ep)
573                return -ENODEV;
574
575        urb = usb_alloc_urb(0, mem_flags);
576        if (!urb)
577                return -ENOMEM;
578
579        size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
580
581        buf = kmalloc(size, mem_flags);
582        if (!buf) {
583                usb_free_urb(urb);
584                return -ENOMEM;
585        }
586
587        pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
588
589        usb_fill_int_urb(urb, data->udev, pipe, buf, size,
590                         btusb_intr_complete, hdev, data->intr_ep->bInterval);
591
592        urb->transfer_flags |= URB_FREE_BUFFER;
593
594        usb_anchor_urb(urb, &data->intr_anchor);
595
596        err = usb_submit_urb(urb, mem_flags);
597        if (err < 0) {
598                if (err != -EPERM && err != -ENODEV)
599                        BT_ERR("%s urb %p submission failed (%d)",
600                               hdev->name, urb, -err);
601                usb_unanchor_urb(urb);
602        }
603
604        usb_free_urb(urb);
605
606        return err;
607}
608
609static void btusb_bulk_complete(struct urb *urb)
610{
611        struct hci_dev *hdev = urb->context;
612        struct btusb_data *data = hci_get_drvdata(hdev);
613        int err;
614
615        BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
616               urb->actual_length);
617
618        if (!test_bit(HCI_RUNNING, &hdev->flags))
619                return;
620
621        if (urb->status == 0) {
622                hdev->stat.byte_rx += urb->actual_length;
623
624                if (btusb_recv_bulk(data, urb->transfer_buffer,
625                                    urb->actual_length) < 0) {
626                        BT_ERR("%s corrupted ACL packet", hdev->name);
627                        hdev->stat.err_rx++;
628                }
629        } else if (urb->status == -ENOENT) {
630                /* Avoid suspend failed when usb_kill_urb */
631                return;
632        }
633
634        if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
635                return;
636
637        usb_anchor_urb(urb, &data->bulk_anchor);
638        usb_mark_last_busy(data->udev);
639
640        err = usb_submit_urb(urb, GFP_ATOMIC);
641        if (err < 0) {
642                /* -EPERM: urb is being killed;
643                 * -ENODEV: device got disconnected */
644                if (err != -EPERM && err != -ENODEV)
645                        BT_ERR("%s urb %p failed to resubmit (%d)",
646                               hdev->name, urb, -err);
647                usb_unanchor_urb(urb);
648        }
649}
650
651static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
652{
653        struct btusb_data *data = hci_get_drvdata(hdev);
654        struct urb *urb;
655        unsigned char *buf;
656        unsigned int pipe;
657        int err, size = HCI_MAX_FRAME_SIZE;
658
659        BT_DBG("%s", hdev->name);
660
661        if (!data->bulk_rx_ep)
662                return -ENODEV;
663
664        urb = usb_alloc_urb(0, mem_flags);
665        if (!urb)
666                return -ENOMEM;
667
668        buf = kmalloc(size, mem_flags);
669        if (!buf) {
670                usb_free_urb(urb);
671                return -ENOMEM;
672        }
673
674        pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
675
676        usb_fill_bulk_urb(urb, data->udev, pipe, buf, size,
677                          btusb_bulk_complete, hdev);
678
679        urb->transfer_flags |= URB_FREE_BUFFER;
680
681        usb_mark_last_busy(data->udev);
682        usb_anchor_urb(urb, &data->bulk_anchor);
683
684        err = usb_submit_urb(urb, mem_flags);
685        if (err < 0) {
686                if (err != -EPERM && err != -ENODEV)
687                        BT_ERR("%s urb %p submission failed (%d)",
688                               hdev->name, urb, -err);
689                usb_unanchor_urb(urb);
690        }
691
692        usb_free_urb(urb);
693
694        return err;
695}
696
697static void btusb_isoc_complete(struct urb *urb)
698{
699        struct hci_dev *hdev = urb->context;
700        struct btusb_data *data = hci_get_drvdata(hdev);
701        int i, err;
702
703        BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
704               urb->actual_length);
705
706        if (!test_bit(HCI_RUNNING, &hdev->flags))
707                return;
708
709        if (urb->status == 0) {
710                for (i = 0; i < urb->number_of_packets; i++) {
711                        unsigned int offset = urb->iso_frame_desc[i].offset;
712                        unsigned int length = urb->iso_frame_desc[i].actual_length;
713
714                        if (urb->iso_frame_desc[i].status)
715                                continue;
716
717                        hdev->stat.byte_rx += length;
718
719                        if (btusb_recv_isoc(data, urb->transfer_buffer + offset,
720                                            length) < 0) {
721                                BT_ERR("%s corrupted SCO packet", hdev->name);
722                                hdev->stat.err_rx++;
723                        }
724                }
725        } else if (urb->status == -ENOENT) {
726                /* Avoid suspend failed when usb_kill_urb */
727                return;
728        }
729
730        if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
731                return;
732
733        usb_anchor_urb(urb, &data->isoc_anchor);
734
735        err = usb_submit_urb(urb, GFP_ATOMIC);
736        if (err < 0) {
737                /* -EPERM: urb is being killed;
738                 * -ENODEV: device got disconnected */
739                if (err != -EPERM && err != -ENODEV)
740                        BT_ERR("%s urb %p failed to resubmit (%d)",
741                               hdev->name, urb, -err);
742                usb_unanchor_urb(urb);
743        }
744}
745
746static inline void __fill_isoc_descriptor(struct urb *urb, int len, int mtu)
747{
748        int i, offset = 0;
749
750        BT_DBG("len %d mtu %d", len, mtu);
751
752        for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
753                                        i++, offset += mtu, len -= mtu) {
754                urb->iso_frame_desc[i].offset = offset;
755                urb->iso_frame_desc[i].length = mtu;
756        }
757
758        if (len && i < BTUSB_MAX_ISOC_FRAMES) {
759                urb->iso_frame_desc[i].offset = offset;
760                urb->iso_frame_desc[i].length = len;
761                i++;
762        }
763
764        urb->number_of_packets = i;
765}
766
767static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
768{
769        struct btusb_data *data = hci_get_drvdata(hdev);
770        struct urb *urb;
771        unsigned char *buf;
772        unsigned int pipe;
773        int err, size;
774
775        BT_DBG("%s", hdev->name);
776
777        if (!data->isoc_rx_ep)
778                return -ENODEV;
779
780        urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
781        if (!urb)
782                return -ENOMEM;
783
784        size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
785                                                BTUSB_MAX_ISOC_FRAMES;
786
787        buf = kmalloc(size, mem_flags);
788        if (!buf) {
789                usb_free_urb(urb);
790                return -ENOMEM;
791        }
792
793        pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
794
795        usb_fill_int_urb(urb, data->udev, pipe, buf, size, btusb_isoc_complete,
796                         hdev, data->isoc_rx_ep->bInterval);
797
798        urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;
799
800        __fill_isoc_descriptor(urb, size,
801                               le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
802
803        usb_anchor_urb(urb, &data->isoc_anchor);
804
805        err = usb_submit_urb(urb, mem_flags);
806        if (err < 0) {
807                if (err != -EPERM && err != -ENODEV)
808                        BT_ERR("%s urb %p submission failed (%d)",
809                               hdev->name, urb, -err);
810                usb_unanchor_urb(urb);
811        }
812
813        usb_free_urb(urb);
814
815        return err;
816}
817
818static void btusb_tx_complete(struct urb *urb)
819{
820        struct sk_buff *skb = urb->context;
821        struct hci_dev *hdev = (struct hci_dev *)skb->dev;
822        struct btusb_data *data = hci_get_drvdata(hdev);
823
824        BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
825               urb->actual_length);
826
827        if (!test_bit(HCI_RUNNING, &hdev->flags))
828                goto done;
829
830        if (!urb->status)
831                hdev->stat.byte_tx += urb->transfer_buffer_length;
832        else
833                hdev->stat.err_tx++;
834
835done:
836        spin_lock(&data->txlock);
837        data->tx_in_flight--;
838        spin_unlock(&data->txlock);
839
840        kfree(urb->setup_packet);
841
842        kfree_skb(skb);
843}
844
845static void btusb_isoc_tx_complete(struct urb *urb)
846{
847        struct sk_buff *skb = urb->context;
848        struct hci_dev *hdev = (struct hci_dev *)skb->dev;
849
850        BT_DBG("%s urb %p status %d count %d", hdev->name, urb, urb->status,
851               urb->actual_length);
852
853        if (!test_bit(HCI_RUNNING, &hdev->flags))
854                goto done;
855
856        if (!urb->status)
857                hdev->stat.byte_tx += urb->transfer_buffer_length;
858        else
859                hdev->stat.err_tx++;
860
861done:
862        kfree(urb->setup_packet);
863
864        kfree_skb(skb);
865}
866
867static int btusb_open(struct hci_dev *hdev)
868{
869        struct btusb_data *data = hci_get_drvdata(hdev);
870        int err;
871
872        BT_DBG("%s", hdev->name);
873
874        err = usb_autopm_get_interface(data->intf);
875        if (err < 0)
876                return err;
877
878        data->intf->needs_remote_wakeup = 1;
879
880        if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
881                goto done;
882
883        if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
884                goto done;
885
886        err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
887        if (err < 0)
888                goto failed;
889
890        err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
891        if (err < 0) {
892                usb_kill_anchored_urbs(&data->intr_anchor);
893                goto failed;
894        }
895
896        set_bit(BTUSB_BULK_RUNNING, &data->flags);
897        btusb_submit_bulk_urb(hdev, GFP_KERNEL);
898
899done:
900        usb_autopm_put_interface(data->intf);
901        return 0;
902
903failed:
904        clear_bit(BTUSB_INTR_RUNNING, &data->flags);
905        clear_bit(HCI_RUNNING, &hdev->flags);
906        usb_autopm_put_interface(data->intf);
907        return err;
908}
909
910static void btusb_stop_traffic(struct btusb_data *data)
911{
912        usb_kill_anchored_urbs(&data->intr_anchor);
913        usb_kill_anchored_urbs(&data->bulk_anchor);
914        usb_kill_anchored_urbs(&data->isoc_anchor);
915}
916
917static int btusb_close(struct hci_dev *hdev)
918{
919        struct btusb_data *data = hci_get_drvdata(hdev);
920        int err;
921
922        BT_DBG("%s", hdev->name);
923
924        if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
925                return 0;
926
927        cancel_work_sync(&data->work);
928        cancel_work_sync(&data->waker);
929
930        clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
931        clear_bit(BTUSB_BULK_RUNNING, &data->flags);
932        clear_bit(BTUSB_INTR_RUNNING, &data->flags);
933
934        btusb_stop_traffic(data);
935        btusb_free_frags(data);
936
937        err = usb_autopm_get_interface(data->intf);
938        if (err < 0)
939                goto failed;
940
941        data->intf->needs_remote_wakeup = 0;
942        usb_autopm_put_interface(data->intf);
943
944failed:
945        usb_scuttle_anchored_urbs(&data->deferred);
946        return 0;
947}
948
949static int btusb_flush(struct hci_dev *hdev)
950{
951        struct btusb_data *data = hci_get_drvdata(hdev);
952
953        BT_DBG("%s", hdev->name);
954
955        usb_kill_anchored_urbs(&data->tx_anchor);
956        btusb_free_frags(data);
957
958        return 0;
959}
960
961static struct urb *alloc_ctrl_urb(struct hci_dev *hdev, struct sk_buff *skb)
962{
963        struct btusb_data *data = hci_get_drvdata(hdev);
964        struct usb_ctrlrequest *dr;
965        struct urb *urb;
966        unsigned int pipe;
967
968        urb = usb_alloc_urb(0, GFP_KERNEL);
969        if (!urb)
970                return ERR_PTR(-ENOMEM);
971
972        dr = kmalloc(sizeof(*dr), GFP_KERNEL);
973        if (!dr) {
974                usb_free_urb(urb);
975                return ERR_PTR(-ENOMEM);
976        }
977
978        dr->bRequestType = data->cmdreq_type;
979        dr->bRequest     = 0;
980        dr->wIndex       = 0;
981        dr->wValue       = 0;
982        dr->wLength      = __cpu_to_le16(skb->len);
983
984        pipe = usb_sndctrlpipe(data->udev, 0x00);
985
986        usb_fill_control_urb(urb, data->udev, pipe, (void *)dr,
987                             skb->data, skb->len, btusb_tx_complete, skb);
988
989        skb->dev = (void *)hdev;
990
991        return urb;
992}
993
994static struct urb *alloc_bulk_urb(struct hci_dev *hdev, struct sk_buff *skb)
995{
996        struct btusb_data *data = hci_get_drvdata(hdev);
997        struct urb *urb;
998        unsigned int pipe;
999
1000        if (!data->bulk_tx_ep)
1001                return ERR_PTR(-ENODEV);
1002
1003        urb = usb_alloc_urb(0, GFP_KERNEL);
1004        if (!urb)
1005                return ERR_PTR(-ENOMEM);
1006
1007        pipe = usb_sndbulkpipe(data->udev, data->bulk_tx_ep->bEndpointAddress);
1008
1009        usb_fill_bulk_urb(urb, data->udev, pipe,
1010                          skb->data, skb->len, btusb_tx_complete, skb);
1011
1012        skb->dev = (void *)hdev;
1013
1014        return urb;
1015}
1016
1017static struct urb *alloc_isoc_urb(struct hci_dev *hdev, struct sk_buff *skb)
1018{
1019        struct btusb_data *data = hci_get_drvdata(hdev);
1020        struct urb *urb;
1021        unsigned int pipe;
1022
1023        if (!data->isoc_tx_ep)
1024                return ERR_PTR(-ENODEV);
1025
1026        urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_KERNEL);
1027        if (!urb)
1028                return ERR_PTR(-ENOMEM);
1029
1030        pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress);
1031
1032        usb_fill_int_urb(urb, data->udev, pipe,
1033                         skb->data, skb->len, btusb_isoc_tx_complete,
1034                         skb, data->isoc_tx_ep->bInterval);
1035
1036        urb->transfer_flags  = URB_ISO_ASAP;
1037
1038        __fill_isoc_descriptor(urb, skb->len,
1039                               le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
1040
1041        skb->dev = (void *)hdev;
1042
1043        return urb;
1044}
1045
1046static int submit_tx_urb(struct hci_dev *hdev, struct urb *urb)
1047{
1048        struct btusb_data *data = hci_get_drvdata(hdev);
1049        int err;
1050
1051        usb_anchor_urb(urb, &data->tx_anchor);
1052
1053        err = usb_submit_urb(urb, GFP_KERNEL);
1054        if (err < 0) {
1055                if (err != -EPERM && err != -ENODEV)
1056                        BT_ERR("%s urb %p submission failed (%d)",
1057                               hdev->name, urb, -err);
1058                kfree(urb->setup_packet);
1059                usb_unanchor_urb(urb);
1060        } else {
1061                usb_mark_last_busy(data->udev);
1062        }
1063
1064        usb_free_urb(urb);
1065        return err;
1066}
1067
1068static int submit_or_queue_tx_urb(struct hci_dev *hdev, struct urb *urb)
1069{
1070        struct btusb_data *data = hci_get_drvdata(hdev);
1071        unsigned long flags;
1072        bool suspending;
1073
1074        spin_lock_irqsave(&data->txlock, flags);
1075        suspending = test_bit(BTUSB_SUSPENDING, &data->flags);
1076        if (!suspending)
1077                data->tx_in_flight++;
1078        spin_unlock_irqrestore(&data->txlock, flags);
1079
1080        if (!suspending)
1081                return submit_tx_urb(hdev, urb);
1082
1083        usb_anchor_urb(urb, &data->deferred);
1084        schedule_work(&data->waker);
1085
1086        usb_free_urb(urb);
1087        return 0;
1088}
1089
1090static int btusb_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
1091{
1092        struct urb *urb;
1093
1094        BT_DBG("%s", hdev->name);
1095
1096        if (!test_bit(HCI_RUNNING, &hdev->flags))
1097                return -EBUSY;
1098
1099        switch (bt_cb(skb)->pkt_type) {
1100        case HCI_COMMAND_PKT:
1101                urb = alloc_ctrl_urb(hdev, skb);
1102                if (IS_ERR(urb))
1103                        return PTR_ERR(urb);
1104
1105                hdev->stat.cmd_tx++;
1106                return submit_or_queue_tx_urb(hdev, urb);
1107
1108        case HCI_ACLDATA_PKT:
1109                urb = alloc_bulk_urb(hdev, skb);
1110                if (IS_ERR(urb))
1111                        return PTR_ERR(urb);
1112
1113                hdev->stat.acl_tx++;
1114                return submit_or_queue_tx_urb(hdev, urb);
1115
1116        case HCI_SCODATA_PKT:
1117                if (hci_conn_num(hdev, SCO_LINK) < 1)
1118                        return -ENODEV;
1119
1120                urb = alloc_isoc_urb(hdev, skb);
1121                if (IS_ERR(urb))
1122                        return PTR_ERR(urb);
1123
1124                hdev->stat.sco_tx++;
1125                return submit_tx_urb(hdev, urb);
1126        }
1127
1128        return -EILSEQ;
1129}
1130
1131static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
1132{
1133        struct btusb_data *data = hci_get_drvdata(hdev);
1134
1135        BT_DBG("%s evt %d", hdev->name, evt);
1136
1137        if (hci_conn_num(hdev, SCO_LINK) != data->sco_num) {
1138                data->sco_num = hci_conn_num(hdev, SCO_LINK);
1139                schedule_work(&data->work);
1140        }
1141}
1142
1143static inline int __set_isoc_interface(struct hci_dev *hdev, int altsetting)
1144{
1145        struct btusb_data *data = hci_get_drvdata(hdev);
1146        struct usb_interface *intf = data->isoc;
1147        struct usb_endpoint_descriptor *ep_desc;
1148        int i, err;
1149
1150        if (!data->isoc)
1151                return -ENODEV;
1152
1153        err = usb_set_interface(data->udev, 1, altsetting);
1154        if (err < 0) {
1155                BT_ERR("%s setting interface failed (%d)", hdev->name, -err);
1156                return err;
1157        }
1158
1159        data->isoc_altsetting = altsetting;
1160
1161        data->isoc_tx_ep = NULL;
1162        data->isoc_rx_ep = NULL;
1163
1164        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
1165                ep_desc = &intf->cur_altsetting->endpoint[i].desc;
1166
1167                if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
1168                        data->isoc_tx_ep = ep_desc;
1169                        continue;
1170                }
1171
1172                if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
1173                        data->isoc_rx_ep = ep_desc;
1174                        continue;
1175                }
1176        }
1177
1178        if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
1179                BT_ERR("%s invalid SCO descriptors", hdev->name);
1180                return -ENODEV;
1181        }
1182
1183        return 0;
1184}
1185
1186static void btusb_work(struct work_struct *work)
1187{
1188        struct btusb_data *data = container_of(work, struct btusb_data, work);
1189        struct hci_dev *hdev = data->hdev;
1190        int new_alts;
1191        int err;
1192
1193        if (data->sco_num > 0) {
1194                if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
1195                        err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);
1196                        if (err < 0) {
1197                                clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1198                                usb_kill_anchored_urbs(&data->isoc_anchor);
1199                                return;
1200                        }
1201
1202                        set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
1203                }
1204
1205                if (hdev->voice_setting & 0x0020) {
1206                        static const int alts[3] = { 2, 4, 5 };
1207
1208                        new_alts = alts[data->sco_num - 1];
1209                } else {
1210                        new_alts = data->sco_num;
1211                }
1212
1213                if (data->isoc_altsetting != new_alts) {
1214                        clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1215                        usb_kill_anchored_urbs(&data->isoc_anchor);
1216
1217                        if (__set_isoc_interface(hdev, new_alts) < 0)
1218                                return;
1219                }
1220
1221                if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
1222                        if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)
1223                                clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1224                        else
1225                                btusb_submit_isoc_urb(hdev, GFP_KERNEL);
1226                }
1227        } else {
1228                clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
1229                usb_kill_anchored_urbs(&data->isoc_anchor);
1230
1231                __set_isoc_interface(hdev, 0);
1232                if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
1233                        usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);
1234        }
1235}
1236
1237static void btusb_waker(struct work_struct *work)
1238{
1239        struct btusb_data *data = container_of(work, struct btusb_data, waker);
1240        int err;
1241
1242        err = usb_autopm_get_interface(data->intf);
1243        if (err < 0)
1244                return;
1245
1246        usb_autopm_put_interface(data->intf);
1247}
1248
1249static int btusb_setup_bcm92035(struct hci_dev *hdev)
1250{
1251        struct sk_buff *skb;
1252        u8 val = 0x00;
1253
1254        BT_DBG("%s", hdev->name);
1255
1256        skb = __hci_cmd_sync(hdev, 0xfc3b, 1, &val, HCI_INIT_TIMEOUT);
1257        if (IS_ERR(skb))
1258                BT_ERR("BCM92035 command failed (%ld)", -PTR_ERR(skb));
1259        else
1260                kfree_skb(skb);
1261
1262        return 0;
1263}
1264
1265static int btusb_setup_csr(struct hci_dev *hdev)
1266{
1267        struct hci_rp_read_local_version *rp;
1268        struct sk_buff *skb;
1269        int ret;
1270
1271        BT_DBG("%s", hdev->name);
1272
1273        skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
1274                             HCI_INIT_TIMEOUT);
1275        if (IS_ERR(skb)) {
1276                BT_ERR("Reading local version failed (%ld)", -PTR_ERR(skb));
1277                return -PTR_ERR(skb);
1278        }
1279
1280        rp = (struct hci_rp_read_local_version *)skb->data;
1281
1282        if (!rp->status) {
1283                if (le16_to_cpu(rp->manufacturer) != 10) {
1284                        /* Clear the reset quirk since this is not an actual
1285                         * early Bluetooth 1.1 device from CSR.
1286                         */
1287                        clear_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
1288
1289                        /* These fake CSR controllers have all a broken
1290                         * stored link key handling and so just disable it.
1291                         */
1292                        set_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY,
1293                                &hdev->quirks);
1294                }
1295        }
1296
1297        ret = -bt_to_errno(rp->status);
1298
1299        kfree_skb(skb);
1300
1301        return ret;
1302}
1303
1304struct intel_version {
1305        u8 status;
1306        u8 hw_platform;
1307        u8 hw_variant;
1308        u8 hw_revision;
1309        u8 fw_variant;
1310        u8 fw_revision;
1311        u8 fw_build_num;
1312        u8 fw_build_ww;
1313        u8 fw_build_yy;
1314        u8 fw_patch_num;
1315} __packed;
1316
1317static const struct firmware *btusb_setup_intel_get_fw(struct hci_dev *hdev,
1318                                                       struct intel_version *ver)
1319{
1320        const struct firmware *fw;
1321        char fwname[64];
1322        int ret;
1323
1324        snprintf(fwname, sizeof(fwname),
1325                 "intel/ibt-hw-%x.%x.%x-fw-%x.%x.%x.%x.%x.bseq",
1326                 ver->hw_platform, ver->hw_variant, ver->hw_revision,
1327                 ver->fw_variant,  ver->fw_revision, ver->fw_build_num,
1328                 ver->fw_build_ww, ver->fw_build_yy);
1329
1330        ret = request_firmware(&fw, fwname, &hdev->dev);
1331        if (ret < 0) {
1332                if (ret == -EINVAL) {
1333                        BT_ERR("%s Intel firmware file request failed (%d)",
1334                               hdev->name, ret);
1335                        return NULL;
1336                }
1337
1338                BT_ERR("%s failed to open Intel firmware file: %s(%d)",
1339                       hdev->name, fwname, ret);
1340
1341                /* If the correct firmware patch file is not found, use the
1342                 * default firmware patch file instead
1343                 */
1344                snprintf(fwname, sizeof(fwname), "intel/ibt-hw-%x.%x.bseq",
1345                         ver->hw_platform, ver->hw_variant);
1346                if (request_firmware(&fw, fwname, &hdev->dev) < 0) {
1347                        BT_ERR("%s failed to open default Intel fw file: %s",
1348                               hdev->name, fwname);
1349                        return NULL;
1350                }
1351        }
1352
1353        BT_INFO("%s: Intel Bluetooth firmware file: %s", hdev->name, fwname);
1354
1355        return fw;
1356}
1357
1358static int btusb_setup_intel_patching(struct hci_dev *hdev,
1359                                      const struct firmware *fw,
1360                                      const u8 **fw_ptr, int *disable_patch)
1361{
1362        struct sk_buff *skb;
1363        struct hci_command_hdr *cmd;
1364        const u8 *cmd_param;
1365        struct hci_event_hdr *evt = NULL;
1366        const u8 *evt_param = NULL;
1367        int remain = fw->size - (*fw_ptr - fw->data);
1368
1369        /* The first byte indicates the types of the patch command or event.
1370         * 0x01 means HCI command and 0x02 is HCI event. If the first bytes
1371         * in the current firmware buffer doesn't start with 0x01 or
1372         * the size of remain buffer is smaller than HCI command header,
1373         * the firmware file is corrupted and it should stop the patching
1374         * process.
1375         */
1376        if (remain > HCI_COMMAND_HDR_SIZE && *fw_ptr[0] != 0x01) {
1377                BT_ERR("%s Intel fw corrupted: invalid cmd read", hdev->name);
1378                return -EINVAL;
1379        }
1380        (*fw_ptr)++;
1381        remain--;
1382
1383        cmd = (struct hci_command_hdr *)(*fw_ptr);
1384        *fw_ptr += sizeof(*cmd);
1385        remain -= sizeof(*cmd);
1386
1387        /* Ensure that the remain firmware data is long enough than the length
1388         * of command parameter. If not, the firmware file is corrupted.
1389         */
1390        if (remain < cmd->plen) {
1391                BT_ERR("%s Intel fw corrupted: invalid cmd len", hdev->name);
1392                return -EFAULT;
1393        }
1394
1395        /* If there is a command that loads a patch in the firmware
1396         * file, then enable the patch upon success, otherwise just
1397         * disable the manufacturer mode, for example patch activation
1398         * is not required when the default firmware patch file is used
1399         * because there are no patch data to load.
1400         */
1401        if (*disable_patch && le16_to_cpu(cmd->opcode) == 0xfc8e)
1402                *disable_patch = 0;
1403
1404        cmd_param = *fw_ptr;
1405        *fw_ptr += cmd->plen;
1406        remain -= cmd->plen;
1407
1408        /* This reads the expected events when the above command is sent to the
1409         * device. Some vendor commands expects more than one events, for
1410         * example command status event followed by vendor specific event.
1411         * For this case, it only keeps the last expected event. so the command
1412         * can be sent with __hci_cmd_sync_ev() which returns the sk_buff of
1413         * last expected event.
1414         */
1415        while (remain > HCI_EVENT_HDR_SIZE && *fw_ptr[0] == 0x02) {
1416                (*fw_ptr)++;
1417                remain--;
1418
1419                evt = (struct hci_event_hdr *)(*fw_ptr);
1420                *fw_ptr += sizeof(*evt);
1421                remain -= sizeof(*evt);
1422
1423                if (remain < evt->plen) {
1424                        BT_ERR("%s Intel fw corrupted: invalid evt len",
1425                               hdev->name);
1426                        return -EFAULT;
1427                }
1428
1429                evt_param = *fw_ptr;
1430                *fw_ptr += evt->plen;
1431                remain -= evt->plen;
1432        }
1433
1434        /* Every HCI commands in the firmware file has its correspond event.
1435         * If event is not found or remain is smaller than zero, the firmware
1436         * file is corrupted.
1437         */
1438        if (!evt || !evt_param || remain < 0) {
1439                BT_ERR("%s Intel fw corrupted: invalid evt read", hdev->name);
1440                return -EFAULT;
1441        }
1442
1443        skb = __hci_cmd_sync_ev(hdev, le16_to_cpu(cmd->opcode), cmd->plen,
1444                                cmd_param, evt->evt, HCI_INIT_TIMEOUT);
1445        if (IS_ERR(skb)) {
1446                BT_ERR("%s sending Intel patch command (0x%4.4x) failed (%ld)",
1447                       hdev->name, cmd->opcode, PTR_ERR(skb));
1448                return PTR_ERR(skb);
1449        }
1450
1451        /* It ensures that the returned event matches the event data read from
1452         * the firmware file. At fist, it checks the length and then
1453         * the contents of the event.
1454         */
1455        if (skb->len != evt->plen) {
1456                BT_ERR("%s mismatch event length (opcode 0x%4.4x)", hdev->name,
1457                       le16_to_cpu(cmd->opcode));
1458                kfree_skb(skb);
1459                return -EFAULT;
1460        }
1461
1462        if (memcmp(skb->data, evt_param, evt->plen)) {
1463                BT_ERR("%s mismatch event parameter (opcode 0x%4.4x)",
1464                       hdev->name, le16_to_cpu(cmd->opcode));
1465                kfree_skb(skb);
1466                return -EFAULT;
1467        }
1468        kfree_skb(skb);
1469
1470        return 0;
1471}
1472
1473#define BDADDR_INTEL (&(bdaddr_t) {{0x00, 0x8b, 0x9e, 0x19, 0x03, 0x00}})
1474
1475static int btusb_check_bdaddr_intel(struct hci_dev *hdev)
1476{
1477        struct sk_buff *skb;
1478        struct hci_rp_read_bd_addr *rp;
1479
1480        skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, 0, NULL,
1481                             HCI_INIT_TIMEOUT);
1482        if (IS_ERR(skb)) {
1483                BT_ERR("%s reading Intel device address failed (%ld)",
1484                       hdev->name, PTR_ERR(skb));
1485                return PTR_ERR(skb);
1486        }
1487
1488        if (skb->len != sizeof(*rp)) {
1489                BT_ERR("%s Intel device address length mismatch", hdev->name);
1490                kfree_skb(skb);
1491                return -EIO;
1492        }
1493
1494        rp = (struct hci_rp_read_bd_addr *)skb->data;
1495        if (rp->status) {
1496                BT_ERR("%s Intel device address result failed (%02x)",
1497                       hdev->name, rp->status);
1498                kfree_skb(skb);
1499                return -bt_to_errno(rp->status);
1500        }
1501
1502        /* For some Intel based controllers, the default Bluetooth device
1503         * address 00:03:19:9E:8B:00 can be found. These controllers are
1504         * fully operational, but have the danger of duplicate addresses
1505         * and that in turn can cause problems with Bluetooth operation.
1506         */
1507        if (!bacmp(&rp->bdaddr, BDADDR_INTEL)) {
1508                BT_ERR("%s found Intel default device address (%pMR)",
1509                       hdev->name, &rp->bdaddr);
1510                set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
1511        }
1512
1513        kfree_skb(skb);
1514
1515        return 0;
1516}
1517
1518static int btusb_setup_intel(struct hci_dev *hdev)
1519{
1520        struct sk_buff *skb;
1521        const struct firmware *fw;
1522        const u8 *fw_ptr;
1523        int disable_patch;
1524        struct intel_version *ver;
1525
1526        const u8 mfg_enable[] = { 0x01, 0x00 };
1527        const u8 mfg_disable[] = { 0x00, 0x00 };
1528        const u8 mfg_reset_deactivate[] = { 0x00, 0x01 };
1529        const u8 mfg_reset_activate[] = { 0x00, 0x02 };
1530
1531        BT_DBG("%s", hdev->name);
1532
1533        /* The controller has a bug with the first HCI command sent to it
1534         * returning number of completed commands as zero. This would stall the
1535         * command processing in the Bluetooth core.
1536         *
1537         * As a workaround, send HCI Reset command first which will reset the
1538         * number of completed commands and allow normal command processing
1539         * from now on.
1540         */
1541        skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
1542        if (IS_ERR(skb)) {
1543                BT_ERR("%s sending initial HCI reset command failed (%ld)",
1544                       hdev->name, PTR_ERR(skb));
1545                return PTR_ERR(skb);
1546        }
1547        kfree_skb(skb);
1548
1549        /* Read Intel specific controller version first to allow selection of
1550         * which firmware file to load.
1551         *
1552         * The returned information are hardware variant and revision plus
1553         * firmware variant, revision and build number.
1554         */
1555        skb = __hci_cmd_sync(hdev, 0xfc05, 0, NULL, HCI_INIT_TIMEOUT);
1556        if (IS_ERR(skb)) {
1557                BT_ERR("%s reading Intel fw version command failed (%ld)",
1558                       hdev->name, PTR_ERR(skb));
1559                return PTR_ERR(skb);
1560        }
1561
1562        if (skb->len != sizeof(*ver)) {
1563                BT_ERR("%s Intel version event length mismatch", hdev->name);
1564                kfree_skb(skb);
1565                return -EIO;
1566        }
1567
1568        ver = (struct intel_version *)skb->data;
1569        if (ver->status) {
1570                BT_ERR("%s Intel fw version event failed (%02x)", hdev->name,
1571                       ver->status);
1572                kfree_skb(skb);
1573                return -bt_to_errno(ver->status);
1574        }
1575
1576        BT_INFO("%s: read Intel version: %02x%02x%02x%02x%02x%02x%02x%02x%02x",
1577                hdev->name, ver->hw_platform, ver->hw_variant,
1578                ver->hw_revision, ver->fw_variant,  ver->fw_revision,
1579                ver->fw_build_num, ver->fw_build_ww, ver->fw_build_yy,
1580                ver->fw_patch_num);
1581
1582        /* fw_patch_num indicates the version of patch the device currently
1583         * have. If there is no patch data in the device, it is always 0x00.
1584         * So, if it is other than 0x00, no need to patch the deivce again.
1585         */
1586        if (ver->fw_patch_num) {
1587                BT_INFO("%s: Intel device is already patched. patch num: %02x",
1588                        hdev->name, ver->fw_patch_num);
1589                kfree_skb(skb);
1590                btusb_check_bdaddr_intel(hdev);
1591                return 0;
1592        }
1593
1594        /* Opens the firmware patch file based on the firmware version read
1595         * from the controller. If it fails to open the matching firmware
1596         * patch file, it tries to open the default firmware patch file.
1597         * If no patch file is found, allow the device to operate without
1598         * a patch.
1599         */
1600        fw = btusb_setup_intel_get_fw(hdev, ver);
1601        if (!fw) {
1602                kfree_skb(skb);
1603                btusb_check_bdaddr_intel(hdev);
1604                return 0;
1605        }
1606        fw_ptr = fw->data;
1607
1608        kfree_skb(skb);
1609
1610        /* This Intel specific command enables the manufacturer mode of the
1611         * controller.
1612         *
1613         * Only while this mode is enabled, the driver can download the
1614         * firmware patch data and configuration parameters.
1615         */
1616        skb = __hci_cmd_sync(hdev, 0xfc11, 2, mfg_enable, HCI_INIT_TIMEOUT);
1617        if (IS_ERR(skb)) {
1618                BT_ERR("%s entering Intel manufacturer mode failed (%ld)",
1619                       hdev->name, PTR_ERR(skb));
1620                release_firmware(fw);
1621                return PTR_ERR(skb);
1622        }
1623
1624        if (skb->data[0]) {
1625                u8 evt_status = skb->data[0];
1626
1627                BT_ERR("%s enable Intel manufacturer mode event failed (%02x)",
1628                       hdev->name, evt_status);
1629                kfree_skb(skb);
1630                release_firmware(fw);
1631                return -bt_to_errno(evt_status);
1632        }
1633        kfree_skb(skb);
1634
1635        disable_patch = 1;
1636
1637        /* The firmware data file consists of list of Intel specific HCI
1638         * commands and its expected events. The first byte indicates the
1639         * type of the message, either HCI command or HCI event.
1640         *
1641         * It reads the command and its expected event from the firmware file,
1642         * and send to the controller. Once __hci_cmd_sync_ev() returns,
1643         * the returned event is compared with the event read from the firmware
1644         * file and it will continue until all the messages are downloaded to
1645         * the controller.
1646         *
1647         * Once the firmware patching is completed successfully,
1648         * the manufacturer mode is disabled with reset and activating the
1649         * downloaded patch.
1650         *
1651         * If the firmware patching fails, the manufacturer mode is
1652         * disabled with reset and deactivating the patch.
1653         *
1654         * If the default patch file is used, no reset is done when disabling
1655         * the manufacturer.
1656         */
1657        while (fw->size > fw_ptr - fw->data) {
1658                int ret;
1659
1660                ret = btusb_setup_intel_patching(hdev, fw, &fw_ptr,
1661                                                 &disable_patch);
1662                if (ret < 0)
1663                        goto exit_mfg_deactivate;
1664        }
1665
1666        release_firmware(fw);
1667
1668        if (disable_patch)
1669                goto exit_mfg_disable;
1670
1671        /* Patching completed successfully and disable the manufacturer mode
1672         * with reset and activate the downloaded firmware patches.
1673         */
1674        skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_activate),
1675                             mfg_reset_activate, HCI_INIT_TIMEOUT);
1676        if (IS_ERR(skb)) {
1677                BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",
1678                       hdev->name, PTR_ERR(skb));
1679                return PTR_ERR(skb);
1680        }
1681        kfree_skb(skb);
1682
1683        BT_INFO("%s: Intel Bluetooth firmware patch completed and activated",
1684                hdev->name);
1685
1686        btusb_check_bdaddr_intel(hdev);
1687        return 0;
1688
1689exit_mfg_disable:
1690        /* Disable the manufacturer mode without reset */
1691        skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_disable), mfg_disable,
1692                             HCI_INIT_TIMEOUT);
1693        if (IS_ERR(skb)) {
1694                BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",
1695                       hdev->name, PTR_ERR(skb));
1696                return PTR_ERR(skb);
1697        }
1698        kfree_skb(skb);
1699
1700        BT_INFO("%s: Intel Bluetooth firmware patch completed", hdev->name);
1701
1702        btusb_check_bdaddr_intel(hdev);
1703        return 0;
1704
1705exit_mfg_deactivate:
1706        release_firmware(fw);
1707
1708        /* Patching failed. Disable the manufacturer mode with reset and
1709         * deactivate the downloaded firmware patches.
1710         */
1711        skb = __hci_cmd_sync(hdev, 0xfc11, sizeof(mfg_reset_deactivate),
1712                             mfg_reset_deactivate, HCI_INIT_TIMEOUT);
1713        if (IS_ERR(skb)) {
1714                BT_ERR("%s exiting Intel manufacturer mode failed (%ld)",
1715                       hdev->name, PTR_ERR(skb));
1716                return PTR_ERR(skb);
1717        }
1718        kfree_skb(skb);
1719
1720        BT_INFO("%s: Intel Bluetooth firmware patch completed and deactivated",
1721                hdev->name);
1722
1723        btusb_check_bdaddr_intel(hdev);
1724        return 0;
1725}
1726
1727static int btusb_set_bdaddr_intel(struct hci_dev *hdev, const bdaddr_t *bdaddr)
1728{
1729        struct sk_buff *skb;
1730        long ret;
1731
1732        skb = __hci_cmd_sync(hdev, 0xfc31, 6, bdaddr, HCI_INIT_TIMEOUT);
1733        if (IS_ERR(skb)) {
1734                ret = PTR_ERR(skb);
1735                BT_ERR("%s: changing Intel device address failed (%ld)",
1736                       hdev->name, ret);
1737                return ret;
1738        }
1739        kfree_skb(skb);
1740
1741        return 0;
1742}
1743
1744static int btusb_set_bdaddr_marvell(struct hci_dev *hdev,
1745                                    const bdaddr_t *bdaddr)
1746{
1747        struct sk_buff *skb;
1748        u8 buf[8];
1749        long ret;
1750
1751        buf[0] = 0xfe;
1752        buf[1] = sizeof(bdaddr_t);
1753        memcpy(buf + 2, bdaddr, sizeof(bdaddr_t));
1754
1755        skb = __hci_cmd_sync(hdev, 0xfc22, sizeof(buf), buf, HCI_INIT_TIMEOUT);
1756        if (IS_ERR(skb)) {
1757                ret = PTR_ERR(skb);
1758                BT_ERR("%s: changing Marvell device address failed (%ld)",
1759                       hdev->name, ret);
1760                return ret;
1761        }
1762        kfree_skb(skb);
1763
1764        return 0;
1765}
1766
1767#define BDADDR_BCM20702A0 (&(bdaddr_t) {{0x00, 0xa0, 0x02, 0x70, 0x20, 0x00}})
1768
1769static int btusb_setup_bcm_patchram(struct hci_dev *hdev)
1770{
1771        struct btusb_data *data = hci_get_drvdata(hdev);
1772        struct usb_device *udev = data->udev;
1773        char fw_name[64];
1774        const struct firmware *fw;
1775        const u8 *fw_ptr;
1776        size_t fw_size;
1777        const struct hci_command_hdr *cmd;
1778        const u8 *cmd_param;
1779        u16 opcode;
1780        struct sk_buff *skb;
1781        struct hci_rp_read_local_version *ver;
1782        struct hci_rp_read_bd_addr *bda;
1783        long ret;
1784
1785        snprintf(fw_name, sizeof(fw_name), "brcm/%s-%04x-%04x.hcd",
1786                 udev->product ? udev->product : "BCM",
1787                 le16_to_cpu(udev->descriptor.idVendor),
1788                 le16_to_cpu(udev->descriptor.idProduct));
1789
1790        ret = request_firmware(&fw, fw_name, &hdev->dev);
1791        if (ret < 0) {
1792                BT_INFO("%s: BCM: patch %s not found", hdev->name, fw_name);
1793                return 0;
1794        }
1795
1796        /* Reset */
1797        skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
1798        if (IS_ERR(skb)) {
1799                ret = PTR_ERR(skb);
1800                BT_ERR("%s: HCI_OP_RESET failed (%ld)", hdev->name, ret);
1801                goto done;
1802        }
1803        kfree_skb(skb);
1804
1805        /* Read Local Version Info */
1806        skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
1807                             HCI_INIT_TIMEOUT);
1808        if (IS_ERR(skb)) {
1809                ret = PTR_ERR(skb);
1810                BT_ERR("%s: HCI_OP_READ_LOCAL_VERSION failed (%ld)",
1811                       hdev->name, ret);
1812                goto done;
1813        }
1814
1815        if (skb->len != sizeof(*ver)) {
1816                BT_ERR("%s: HCI_OP_READ_LOCAL_VERSION event length mismatch",
1817                       hdev->name);
1818                kfree_skb(skb);
1819                ret = -EIO;
1820                goto done;
1821        }
1822
1823        ver = (struct hci_rp_read_local_version *)skb->data;
1824        BT_INFO("%s: BCM: patching hci_ver=%02x hci_rev=%04x lmp_ver=%02x "
1825                "lmp_subver=%04x", hdev->name, ver->hci_ver, ver->hci_rev,
1826                ver->lmp_ver, ver->lmp_subver);
1827        kfree_skb(skb);
1828
1829        /* Start Download */
1830        skb = __hci_cmd_sync(hdev, 0xfc2e, 0, NULL, HCI_INIT_TIMEOUT);
1831        if (IS_ERR(skb)) {
1832                ret = PTR_ERR(skb);
1833                BT_ERR("%s: BCM: Download Minidrv command failed (%ld)",
1834                       hdev->name, ret);
1835                goto reset_fw;
1836        }
1837        kfree_skb(skb);
1838
1839        /* 50 msec delay after Download Minidrv completes */
1840        msleep(50);
1841
1842        fw_ptr = fw->data;
1843        fw_size = fw->size;
1844
1845        while (fw_size >= sizeof(*cmd)) {
1846                cmd = (struct hci_command_hdr *)fw_ptr;
1847                fw_ptr += sizeof(*cmd);
1848                fw_size -= sizeof(*cmd);
1849
1850                if (fw_size < cmd->plen) {
1851                        BT_ERR("%s: BCM: patch %s is corrupted",
1852                               hdev->name, fw_name);
1853                        ret = -EINVAL;
1854                        goto reset_fw;
1855                }
1856
1857                cmd_param = fw_ptr;
1858                fw_ptr += cmd->plen;
1859                fw_size -= cmd->plen;
1860
1861                opcode = le16_to_cpu(cmd->opcode);
1862
1863                skb = __hci_cmd_sync(hdev, opcode, cmd->plen, cmd_param,
1864                                     HCI_INIT_TIMEOUT);
1865                if (IS_ERR(skb)) {
1866                        ret = PTR_ERR(skb);
1867                        BT_ERR("%s: BCM: patch command %04x failed (%ld)",
1868                               hdev->name, opcode, ret);
1869                        goto reset_fw;
1870                }
1871                kfree_skb(skb);
1872        }
1873
1874        /* 250 msec delay after Launch Ram completes */
1875        msleep(250);
1876
1877reset_fw:
1878        /* Reset */
1879        skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, HCI_INIT_TIMEOUT);
1880        if (IS_ERR(skb)) {
1881                ret = PTR_ERR(skb);
1882                BT_ERR("%s: HCI_OP_RESET failed (%ld)", hdev->name, ret);
1883                goto done;
1884        }
1885        kfree_skb(skb);
1886
1887        /* Read Local Version Info */
1888        skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL,
1889                             HCI_INIT_TIMEOUT);
1890        if (IS_ERR(skb)) {
1891                ret = PTR_ERR(skb);
1892                BT_ERR("%s: HCI_OP_READ_LOCAL_VERSION failed (%ld)",
1893                       hdev->name, ret);
1894                goto done;
1895        }
1896
1897        if (skb->len != sizeof(*ver)) {
1898                BT_ERR("%s: HCI_OP_READ_LOCAL_VERSION event length mismatch",
1899                       hdev->name);
1900                kfree_skb(skb);
1901                ret = -EIO;
1902                goto done;
1903        }
1904
1905        ver = (struct hci_rp_read_local_version *)skb->data;
1906        BT_INFO("%s: BCM: firmware hci_ver=%02x hci_rev=%04x lmp_ver=%02x "
1907                "lmp_subver=%04x", hdev->name, ver->hci_ver, ver->hci_rev,
1908                ver->lmp_ver, ver->lmp_subver);
1909        kfree_skb(skb);
1910
1911        /* Read BD Address */
1912        skb = __hci_cmd_sync(hdev, HCI_OP_READ_BD_ADDR, 0, NULL,
1913                             HCI_INIT_TIMEOUT);
1914        if (IS_ERR(skb)) {
1915                ret = PTR_ERR(skb);
1916                BT_ERR("%s: HCI_OP_READ_BD_ADDR failed (%ld)",
1917                       hdev->name, ret);
1918                goto done;
1919        }
1920
1921        if (skb->len != sizeof(*bda)) {
1922                BT_ERR("%s: HCI_OP_READ_BD_ADDR event length mismatch",
1923                       hdev->name);
1924                kfree_skb(skb);
1925                ret = -EIO;
1926                goto done;
1927        }
1928
1929        bda = (struct hci_rp_read_bd_addr *)skb->data;
1930        if (bda->status) {
1931                BT_ERR("%s: HCI_OP_READ_BD_ADDR error status (%02x)",
1932                       hdev->name, bda->status);
1933                kfree_skb(skb);
1934                ret = -bt_to_errno(bda->status);
1935                goto done;
1936        }
1937
1938        /* The address 00:20:70:02:A0:00 indicates a BCM20702A0 controller
1939         * with no configured address.
1940         */
1941        if (!bacmp(&bda->bdaddr, BDADDR_BCM20702A0)) {
1942                BT_INFO("%s: BCM: using default device address (%pMR)",
1943                        hdev->name, &bda->bdaddr);
1944                set_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks);
1945        }
1946
1947        kfree_skb(skb);
1948
1949done:
1950        release_firmware(fw);
1951
1952        return ret;
1953}
1954
1955static int btusb_set_bdaddr_bcm(struct hci_dev *hdev, const bdaddr_t *bdaddr)
1956{
1957        struct sk_buff *skb;
1958        long ret;
1959
1960        skb = __hci_cmd_sync(hdev, 0xfc01, 6, bdaddr, HCI_INIT_TIMEOUT);
1961        if (IS_ERR(skb)) {
1962                ret = PTR_ERR(skb);
1963                BT_ERR("%s: BCM: Change address command failed (%ld)",
1964                       hdev->name, ret);
1965                return ret;
1966        }
1967        kfree_skb(skb);
1968
1969        return 0;
1970}
1971
1972static int btusb_probe(struct usb_interface *intf,
1973                       const struct usb_device_id *id)
1974{
1975        struct usb_endpoint_descriptor *ep_desc;
1976        struct btusb_data *data;
1977        struct hci_dev *hdev;
1978        int i, err;
1979
1980        BT_DBG("intf %p id %p", intf, id);
1981
1982        /* interface numbers are hardcoded in the spec */
1983        if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
1984                return -ENODEV;
1985
1986        if (!id->driver_info) {
1987                const struct usb_device_id *match;
1988
1989                match = usb_match_id(intf, blacklist_table);
1990                if (match)
1991                        id = match;
1992        }
1993
1994        if (id->driver_info == BTUSB_IGNORE)
1995                return -ENODEV;
1996
1997        if (id->driver_info & BTUSB_ATH3012) {
1998                struct usb_device *udev = interface_to_usbdev(intf);
1999
2000                /* Old firmware would otherwise let ath3k driver load
2001                 * patch and sysconfig files */
2002                if (le16_to_cpu(udev->descriptor.bcdDevice) <= 0x0001)
2003                        return -ENODEV;
2004        }
2005
2006        data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
2007        if (!data)
2008                return -ENOMEM;
2009
2010        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
2011                ep_desc = &intf->cur_altsetting->endpoint[i].desc;
2012
2013                if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
2014                        data->intr_ep = ep_desc;
2015                        continue;
2016                }
2017
2018                if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
2019                        data->bulk_tx_ep = ep_desc;
2020                        continue;
2021                }
2022
2023                if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
2024                        data->bulk_rx_ep = ep_desc;
2025                        continue;
2026                }
2027        }
2028
2029        if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep)
2030                return -ENODEV;
2031
2032        data->cmdreq_type = USB_TYPE_CLASS;
2033
2034        data->udev = interface_to_usbdev(intf);
2035        data->intf = intf;
2036
2037        INIT_WORK(&data->work, btusb_work);
2038        INIT_WORK(&data->waker, btusb_waker);
2039        init_usb_anchor(&data->deferred);
2040        init_usb_anchor(&data->tx_anchor);
2041        spin_lock_init(&data->txlock);
2042
2043        init_usb_anchor(&data->intr_anchor);
2044        init_usb_anchor(&data->bulk_anchor);
2045        init_usb_anchor(&data->isoc_anchor);
2046        spin_lock_init(&data->rxlock);
2047
2048        hdev = hci_alloc_dev();
2049        if (!hdev)
2050                return -ENOMEM;
2051
2052        hdev->bus = HCI_USB;
2053        hci_set_drvdata(hdev, data);
2054
2055        data->hdev = hdev;
2056
2057        SET_HCIDEV_DEV(hdev, &intf->dev);
2058
2059        hdev->open   = btusb_open;
2060        hdev->close  = btusb_close;
2061        hdev->flush  = btusb_flush;
2062        hdev->send   = btusb_send_frame;
2063        hdev->notify = btusb_notify;
2064
2065        if (id->driver_info & BTUSB_BCM92035)
2066                hdev->setup = btusb_setup_bcm92035;
2067
2068        if (id->driver_info & BTUSB_BCM_PATCHRAM) {
2069                hdev->setup = btusb_setup_bcm_patchram;
2070                hdev->set_bdaddr = btusb_set_bdaddr_bcm;
2071        }
2072
2073        if (id->driver_info & BTUSB_INTEL) {
2074                hdev->setup = btusb_setup_intel;
2075                hdev->set_bdaddr = btusb_set_bdaddr_intel;
2076        }
2077
2078        if (id->driver_info & BTUSB_MARVELL)
2079                hdev->set_bdaddr = btusb_set_bdaddr_marvell;
2080
2081        if (id->driver_info & BTUSB_INTEL_BOOT)
2082                set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
2083
2084        /* Interface numbers are hardcoded in the specification */
2085        data->isoc = usb_ifnum_to_if(data->udev, 1);
2086
2087        if (!reset)
2088                set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
2089
2090        if (force_scofix || id->driver_info & BTUSB_WRONG_SCO_MTU) {
2091                if (!disable_scofix)
2092                        set_bit(HCI_QUIRK_FIXUP_BUFFER_SIZE, &hdev->quirks);
2093        }
2094
2095        if (id->driver_info & BTUSB_BROKEN_ISOC)
2096                data->isoc = NULL;
2097
2098        if (id->driver_info & BTUSB_DIGIANSWER) {
2099                data->cmdreq_type = USB_TYPE_VENDOR;
2100                set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
2101        }
2102
2103        if (id->driver_info & BTUSB_CSR) {
2104                struct usb_device *udev = data->udev;
2105                u16 bcdDevice = le16_to_cpu(udev->descriptor.bcdDevice);
2106
2107                /* Old firmware would otherwise execute USB reset */
2108                if (bcdDevice < 0x117)
2109                        set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks);
2110
2111                /* Fake CSR devices with broken commands */
2112                if (bcdDevice <= 0x100)
2113                        hdev->setup = btusb_setup_csr;
2114        }
2115
2116        if (id->driver_info & BTUSB_SNIFFER) {
2117                struct usb_device *udev = data->udev;
2118
2119                /* New sniffer firmware has crippled HCI interface */
2120                if (le16_to_cpu(udev->descriptor.bcdDevice) > 0x997)
2121                        set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks);
2122        }
2123
2124        if (id->driver_info & BTUSB_INTEL_BOOT) {
2125                /* A bug in the bootloader causes that interrupt interface is
2126                 * only enabled after receiving SetInterface(0, AltSetting=0).
2127                 */
2128                err = usb_set_interface(data->udev, 0, 0);
2129                if (err < 0) {
2130                        BT_ERR("failed to set interface 0, alt 0 %d", err);
2131                        hci_free_dev(hdev);
2132                        return err;
2133                }
2134        }
2135
2136        if (data->isoc) {
2137                err = usb_driver_claim_interface(&btusb_driver,
2138                                                 data->isoc, data);
2139                if (err < 0) {
2140                        hci_free_dev(hdev);
2141                        return err;
2142                }
2143        }
2144
2145        err = hci_register_dev(hdev);
2146        if (err < 0) {
2147                hci_free_dev(hdev);
2148                return err;
2149        }
2150
2151        usb_set_intfdata(intf, data);
2152
2153        return 0;
2154}
2155
2156static void btusb_disconnect(struct usb_interface *intf)
2157{
2158        struct btusb_data *data = usb_get_intfdata(intf);
2159        struct hci_dev *hdev;
2160
2161        BT_DBG("intf %p", intf);
2162
2163        if (!data)
2164                return;
2165
2166        hdev = data->hdev;
2167        usb_set_intfdata(data->intf, NULL);
2168
2169        if (data->isoc)
2170                usb_set_intfdata(data->isoc, NULL);
2171
2172        hci_unregister_dev(hdev);
2173
2174        if (intf == data->isoc)
2175                usb_driver_release_interface(&btusb_driver, data->intf);
2176        else if (data->isoc)
2177                usb_driver_release_interface(&btusb_driver, data->isoc);
2178
2179        btusb_free_frags(data);
2180        hci_free_dev(hdev);
2181}
2182
2183#ifdef CONFIG_PM
2184static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
2185{
2186        struct btusb_data *data = usb_get_intfdata(intf);
2187
2188        BT_DBG("intf %p", intf);
2189
2190        if (data->suspend_count++)
2191                return 0;
2192
2193        spin_lock_irq(&data->txlock);
2194        if (!(PMSG_IS_AUTO(message) && data->tx_in_flight)) {
2195                set_bit(BTUSB_SUSPENDING, &data->flags);
2196                spin_unlock_irq(&data->txlock);
2197        } else {
2198                spin_unlock_irq(&data->txlock);
2199                data->suspend_count--;
2200                return -EBUSY;
2201        }
2202
2203        cancel_work_sync(&data->work);
2204
2205        btusb_stop_traffic(data);
2206        usb_kill_anchored_urbs(&data->tx_anchor);
2207
2208        return 0;
2209}
2210
2211static void play_deferred(struct btusb_data *data)
2212{
2213        struct urb *urb;
2214        int err;
2215
2216        while ((urb = usb_get_from_anchor(&data->deferred))) {
2217                err = usb_submit_urb(urb, GFP_ATOMIC);
2218                if (err < 0)
2219                        break;
2220
2221                data->tx_in_flight++;
2222        }
2223        usb_scuttle_anchored_urbs(&data->deferred);
2224}
2225
2226static int btusb_resume(struct usb_interface *intf)
2227{
2228        struct btusb_data *data = usb_get_intfdata(intf);
2229        struct hci_dev *hdev = data->hdev;
2230        int err = 0;
2231
2232        BT_DBG("intf %p", intf);
2233
2234        if (--data->suspend_count)
2235                return 0;
2236
2237        if (!test_bit(HCI_RUNNING, &hdev->flags))
2238                goto done;
2239
2240        if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
2241                err = btusb_submit_intr_urb(hdev, GFP_NOIO);
2242                if (err < 0) {
2243                        clear_bit(BTUSB_INTR_RUNNING, &data->flags);
2244                        goto failed;
2245                }
2246        }
2247
2248        if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
2249                err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
2250                if (err < 0) {
2251                        clear_bit(BTUSB_BULK_RUNNING, &data->flags);
2252                        goto failed;
2253                }
2254
2255                btusb_submit_bulk_urb(hdev, GFP_NOIO);
2256        }
2257
2258        if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
2259                if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)
2260                        clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
2261                else
2262                        btusb_submit_isoc_urb(hdev, GFP_NOIO);
2263        }
2264
2265        spin_lock_irq(&data->txlock);
2266        play_deferred(data);
2267        clear_bit(BTUSB_SUSPENDING, &data->flags);
2268        spin_unlock_irq(&data->txlock);
2269        schedule_work(&data->work);
2270
2271        return 0;
2272
2273failed:
2274        usb_scuttle_anchored_urbs(&data->deferred);
2275done:
2276        spin_lock_irq(&data->txlock);
2277        clear_bit(BTUSB_SUSPENDING, &data->flags);
2278        spin_unlock_irq(&data->txlock);
2279
2280        return err;
2281}
2282#endif
2283
2284static struct usb_driver btusb_driver = {
2285        .name           = "btusb",
2286        .probe          = btusb_probe,
2287        .disconnect     = btusb_disconnect,
2288#ifdef CONFIG_PM
2289        .suspend        = btusb_suspend,
2290        .resume         = btusb_resume,
2291#endif
2292        .id_table       = btusb_table,
2293        .supports_autosuspend = 1,
2294        .disable_hub_initiated_lpm = 1,
2295};
2296
2297module_usb_driver(btusb_driver);
2298
2299module_param(disable_scofix, bool, 0644);
2300MODULE_PARM_DESC(disable_scofix, "Disable fixup of wrong SCO buffer size");
2301
2302module_param(force_scofix, bool, 0644);
2303MODULE_PARM_DESC(force_scofix, "Force fixup of wrong SCO buffers size");
2304
2305module_param(reset, bool, 0644);
2306MODULE_PARM_DESC(reset, "Send HCI reset command on initialization");
2307
2308MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
2309MODULE_DESCRIPTION("Generic Bluetooth USB driver ver " VERSION);
2310MODULE_VERSION(VERSION);
2311MODULE_LICENSE("GPL");
Note: See TracBrowser for help on using the repository browser.