2 * MediaTek Bluetooth USB Driver
4 * Copyright (C) 2013, MediaTek co.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * or on the worldwide web at
20 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
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 #include <linux/completion.h>
33 #include <linux/firmware.h>
34 #include <linux/usb.h>
35 #include <net/bluetooth/bluetooth.h>
36 #include <net/bluetooth/hci_core.h>
38 #include "btmtk_usb.h"
40 #define VERSION "1.0.4"
41 #define MT7650_FIRMWARE "mt7650.bin"
42 #define MT7662_FIRMWARE "mt7662.bin"
44 static struct usb_driver btmtk_usb_driver
;
47 static int btmtk_usb_load_rom_patch(struct btmtk_usb_data
*);
48 static int btmtk_usb_load_fw(struct btmtk_usb_data
*);
50 static void hex_dump(char *str
, u8
*src_buf
, u32 src_buf_len
)
57 BT_DBG("%s: %p, len = %d\n", str
, src_buf
, src_buf_len
);
59 for (x
= 0; x
< src_buf_len
; x
++) {
61 BT_DBG("0x%04x : ", x
);
62 BT_DBG("%02x ", ((unsigned char)pt
[x
]));
70 static int btmtk_usb_reset(struct usb_device
*udev
)
74 BT_DBG("%s\n", __func__
);
76 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x01,
77 DEVICE_VENDOR_REQUEST_OUT
, 0x01, 0x00,
78 NULL
, 0x00, CONTROL_TIMEOUT_JIFFIES
);
81 BT_ERR("%s error(%d)\n", __func__
, ret
);
91 static int btmtk_usb_io_read32(struct btmtk_usb_data
*data
, u32 reg
, u32
*val
)
93 u8 request
= data
->r_request
;
94 struct usb_device
*udev
= data
->udev
;
97 ret
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0), request
,
98 DEVICE_VENDOR_REQUEST_IN
, 0x0, reg
, data
->io_buf
,
99 4, CONTROL_TIMEOUT_JIFFIES
);
103 BT_ERR("%s error(%d), reg=%x, value=%x\n",
104 __func__
, ret
, reg
, *val
);
108 memmove(val
, data
->io_buf
, 4);
110 *val
= le32_to_cpu(*val
);
118 static int btmtk_usb_io_write32(struct btmtk_usb_data
*data
, u32 reg
, u32 val
)
121 u8 request
= data
->w_request
;
122 struct usb_device
*udev
= data
->udev
;
126 value
= val
& 0x0000ffff;
128 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), request
,
129 DEVICE_VENDOR_REQUEST_OUT
, value
, index
,
130 NULL
, 0, CONTROL_TIMEOUT_JIFFIES
);
133 BT_ERR("%s error(%d), reg=%x, value=%x\n",
134 __func__
, ret
, reg
, val
);
138 index
= (u16
)(reg
+ 2);
139 value
= (val
& 0xffff0000) >> 16;
141 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0),
142 request
, DEVICE_VENDOR_REQUEST_OUT
,
143 value
, index
, NULL
, 0, CONTROL_TIMEOUT_JIFFIES
);
146 BT_ERR("%s error(%d), reg=%x, value=%x\n",
147 __func__
, ret
, reg
, val
);
157 static int btmtk_usb_switch_iobase(struct btmtk_usb_data
*data
, int base
)
163 data
->w_request
= 0x42;
164 data
->r_request
= 0x47;
167 data
->w_request
= 0x02;
168 data
->r_request
= 0x07;
178 static void btmtk_usb_cap_init(struct btmtk_usb_data
*data
)
180 const struct firmware
*firmware
;
181 struct usb_device
*udev
= data
->udev
;
184 btmtk_usb_io_read32(data
, 0x00, &data
->chip_id
);
186 BT_DBG("chip id = %x\n", data
->chip_id
);
188 if (is_mt7630(data
) || is_mt7650(data
)) {
189 data
->need_load_fw
= 1;
190 data
->need_load_rom_patch
= 0;
191 ret
= request_firmware(&firmware
, MT7650_FIRMWARE
, &udev
->dev
);
193 if (ret
== -ENOENT
) {
194 BT_ERR("Firmware file \"%s\" not found\n",
197 BT_ERR("Firmware file \"%s\" request failed (err=%d)\n",
198 MT7650_FIRMWARE
, ret
);
201 BT_DBG("Firmware file \"%s\" Found\n",
203 /* load firmware here */
204 data
->firmware
= firmware
;
205 btmtk_usb_load_fw(data
);
207 release_firmware(firmware
);
208 } else if (is_mt7632(data
) || is_mt7662(data
)) {
209 data
->need_load_fw
= 0;
210 data
->need_load_rom_patch
= 1;
211 data
->rom_patch_offset
= 0x90000;
212 ret
= request_firmware(&firmware
, MT7662_FIRMWARE
, &udev
->dev
);
214 if (ret
== -ENOENT
) {
215 BT_ERR("Firmware file \"%s\" not found\n",
218 BT_ERR("Firmware file \"%s\" request failed (err=%d)\n",
219 MT7662_FIRMWARE
, ret
);
222 BT_DBG("Firmware file \"%s\" Found\n", MT7662_FIRMWARE
);
223 /* load rom patch here */
224 data
->firmware
= firmware
;
225 data
->rom_patch_len
= firmware
->size
;
226 btmtk_usb_load_rom_patch(data
);
228 release_firmware(firmware
);
230 BT_ERR("unknow chip(%x)\n", data
->chip_id
);
234 static u16
checksume16(u8
*pData
, int len
)
239 sum
+= *((u16
*)pData
);
243 if (sum
& 0x80000000)
244 sum
= (sum
& 0xFFFF) + (sum
>> 16);
250 sum
+= *((u8
*)pData
);
253 sum
= (sum
& 0xFFFF) + (sum
>> 16);
258 static int btmtk_usb_chk_crc(struct btmtk_usb_data
*data
, u32 checksum_len
)
261 struct usb_device
*udev
= data
->udev
;
263 BT_DBG("%s\n", __func__
);
265 memmove(data
->io_buf
, &data
->rom_patch_offset
, 4);
266 memmove(&data
->io_buf
[4], &checksum_len
, 4);
268 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x1,
269 DEVICE_VENDOR_REQUEST_IN
, 0x20, 0x00, data
->io_buf
,
270 8, CONTROL_TIMEOUT_JIFFIES
);
273 BT_ERR("%s error(%d)\n", __func__
, ret
);
278 static u16
btmtk_usb_get_crc(struct btmtk_usb_data
*data
)
281 struct usb_device
*udev
= data
->udev
;
284 BT_DBG("%s\n", __func__
);
287 ret
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0),
288 0x01, DEVICE_VENDOR_REQUEST_IN
,
289 0x21, 0x00, data
->io_buf
, 2,
290 CONTROL_TIMEOUT_JIFFIES
);
294 BT_ERR("%s error(%d)\n", __func__
, ret
);
297 memmove(&crc
, data
->io_buf
, 2);
299 crc
= le16_to_cpu(crc
);
307 BT_ERR("Query CRC over %d times\n", count
);
315 static int btmtk_usb_reset_wmt(struct btmtk_usb_data
*data
)
320 u8 cmd
[8] = {0x6F, 0xFC, 0x05, 0x01, 0x07, 0x01, 0x00, 0x04};
322 memmove(data
->io_buf
, cmd
, 8);
324 BT_DBG("%s\n", __func__
);
326 ret
= usb_control_msg(data
->udev
, usb_sndctrlpipe(data
->udev
, 0), 0x01,
327 DEVICE_CLASS_REQUEST_OUT
, 0x12, 0x00,
328 data
->io_buf
, 8, CONTROL_TIMEOUT_JIFFIES
);
331 BT_ERR("%s:(%d)\n", __func__
, ret
);
336 static void load_rom_patch_complete(struct urb
*urb
)
339 struct completion
*sent_to_mcu_done
= (struct completion
*)urb
->context
;
341 complete(sent_to_mcu_done
);
344 static int btmtk_usb_load_rom_patch(struct btmtk_usb_data
*data
)
349 int ret
= 0, total_checksum
= 0;
354 struct completion sent_to_mcu_done
;
360 pipe
= usb_sndbulkpipe(data
->udev
, data
->bulk_tx_ep
->bEndpointAddress
);
362 if (!data
->firmware
) {
363 BT_ERR("%s:please assign a rom patch\n", __func__
);
368 btmtk_usb_switch_iobase(data
, WLAN
);
369 btmtk_usb_io_read32(data
, SEMAPHORE_03
, &value
);
372 if (((value
& 0x01) == 0x00) && (loop
< 600)) {
374 goto load_patch_protect
;
377 btmtk_usb_io_write32(data
, 0x1004, 0x2c);
379 btmtk_usb_switch_iobase(data
, SYSCTL
);
381 btmtk_usb_io_write32(data
, 0x1c, 0x30);
383 /* Enable USB_DMA_CFG */
384 btmtk_usb_io_write32(data
, 0x9018, 0x00c00020);
386 btmtk_usb_switch_iobase(data
, WLAN
);
388 /* check ROM patch if upgrade */
389 btmtk_usb_io_read32(data
, COM_REG0
, &value
);
391 if ((value
& 0x02) == 0x02)
394 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
401 buf
= usb_alloc_coherent(data
->udev
, UPLOAD_PATCH_UNIT
,
402 GFP_ATOMIC
, &data_dma
);
410 BT_DBG("loading rom patch");
412 init_completion(&sent_to_mcu_done
);
415 patch_len
= data
->rom_patch_len
- PATCH_INFO_SIZE
;
417 /* loading rom patch */
419 s32 sent_len_max
= UPLOAD_PATCH_UNIT
- PATCH_HEADER_SIZE
;
420 sent_len
= (patch_len
- cur_len
) >= sent_len_max
?
421 sent_len_max
: (patch_len
- cur_len
);
423 BT_DBG("patch_len = %d\n", patch_len
);
424 BT_DBG("cur_len = %d\n", cur_len
);
425 BT_DBG("sent_len = %d\n", sent_len
);
430 if (first_block
== 1) {
431 if (sent_len
< sent_len_max
)
432 phase
= PATCH_PHASE3
;
434 phase
= PATCH_PHASE1
;
436 } else if (sent_len
== sent_len_max
) {
437 phase
= PATCH_PHASE2
;
439 phase
= PATCH_PHASE3
;
442 /* prepare HCI header */
445 pos
[2] = (sent_len
+ 5) & 0xFF;
446 pos
[3] = ((sent_len
+ 5) >> 8) & 0xFF;
448 /* prepare WMT header */
451 pos
[6] = (sent_len
+ 1) & 0xFF;
452 pos
[7] = ((sent_len
+ 1) >> 8) & 0xFF;
457 data
->firmware
->data
+ PATCH_INFO_SIZE
+ cur_len
,
460 BT_DBG("sent_len + PATCH_HEADER_SIZE = %d, phase = %d\n",
461 sent_len
+ PATCH_HEADER_SIZE
, phase
);
463 usb_fill_bulk_urb(urb
,
467 sent_len
+ PATCH_HEADER_SIZE
,
468 load_rom_patch_complete
,
471 urb
->transfer_dma
= data_dma
;
472 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
474 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
479 if (!wait_for_completion_timeout(&sent_to_mcu_done
,
480 msecs_to_jiffies(1000))) {
482 BT_ERR("upload rom_patch timeout\n");
494 total_checksum
= checksume16(
495 (u8
*)data
->firmware
->data
+ PATCH_INFO_SIZE
,
498 BT_DBG("Send checksum req..\n");
500 btmtk_usb_chk_crc(data
, patch_len
);
504 if (total_checksum
!= btmtk_usb_get_crc(data
)) {
505 BT_ERR("checksum fail!, local(0x%x) <> fw(0x%x)\n",
506 total_checksum
, btmtk_usb_get_crc(data
));
513 ret
= btmtk_usb_reset_wmt(data
);
518 usb_free_coherent(data
->udev
, UPLOAD_PATCH_UNIT
, buf
, data_dma
);
522 btmtk_usb_io_write32(data
, SEMAPHORE_03
, 0x1);
527 static int load_fw_iv(struct btmtk_usb_data
*data
)
530 struct usb_device
*udev
= data
->udev
;
531 char *buf
= kmalloc(64, GFP_ATOMIC
);
533 memmove(buf
, data
->firmware
->data
+ 32, 64);
535 ret
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x01,
536 DEVICE_VENDOR_REQUEST_OUT
, 0x12, 0x0, buf
, 64,
537 CONTROL_TIMEOUT_JIFFIES
);
540 BT_ERR("%s error(%d) step4\n", __func__
, ret
);
553 static void load_fw_complete(struct urb
*urb
)
556 struct completion
*sent_to_mcu_done
= (struct completion
*)urb
->context
;
558 complete(sent_to_mcu_done
);
561 static int btmtk_usb_load_fw(struct btmtk_usb_data
*data
)
563 struct usb_device
*udev
= data
->udev
;
567 u32 packet_header
= 0;
569 u32 ilm_len
= 0, dlm_len
= 0;
570 u16 fw_ver
, build_ver
;
573 int ret
= 0, sent_len
;
574 struct completion sent_to_mcu_done
;
576 pipe
= usb_sndbulkpipe(data
->udev
, data
->bulk_tx_ep
->bEndpointAddress
);
578 if (!data
->firmware
) {
579 BT_ERR("%s:please assign a fw\n", __func__
);
583 BT_DBG("bulk_tx_ep = %x\n", data
->bulk_tx_ep
->bEndpointAddress
);
586 btmtk_usb_switch_iobase(data
, WLAN
);
587 btmtk_usb_io_read32(data
, SEMAPHORE_00
, &value
);
590 if (((value
& 0x1) == 0) && (loop
< 10000))
593 /* check MCU if ready */
594 btmtk_usb_io_read32(data
, COM_REG0
, &value
);
596 if ((value
& 0x01) == 0x01)
599 /* Enable MPDMA TX and EP2 load FW mode */
600 btmtk_usb_io_write32(data
, 0x238, 0x1c000000);
602 btmtk_usb_reset(udev
);
605 ilm_len
= (*(data
->firmware
->data
+ 3) << 24)
606 | (*(data
->firmware
->data
+ 2) << 16)
607 | (*(data
->firmware
->data
+ 1) << 8)
608 | (*data
->firmware
->data
);
610 dlm_len
= (*(data
->firmware
->data
+ 7) << 24)
611 | (*(data
->firmware
->data
+ 6) << 16)
612 | (*(data
->firmware
->data
+ 5) << 8)
613 | (*(data
->firmware
->data
+ 4));
615 fw_ver
= (*(data
->firmware
->data
+ 11) << 8) |
616 (*(data
->firmware
->data
+ 10));
618 build_ver
= (*(data
->firmware
->data
+ 9) << 8) |
619 (*(data
->firmware
->data
+ 8));
621 BT_DBG("fw version:%d.%d.%02d ",
622 (fw_ver
& 0xf000) >> 8,
623 (fw_ver
& 0x0f00) >> 8,
626 BT_DBG("build:%x\n", build_ver
);
628 BT_DBG("build Time =");
630 for (loop
= 0; loop
< 16; loop
++)
631 BT_DBG("%c", *(data
->firmware
->data
+ 16 + loop
));
635 BT_DBG("ILM length = %d(bytes)\n", ilm_len
);
636 BT_DBG("DLM length = %d(bytes)\n", dlm_len
);
638 btmtk_usb_switch_iobase(data
, SYSCTL
);
640 /* U2M_PDMA rx_ring_base_ptr */
641 btmtk_usb_io_write32(data
, 0x790, 0x400230);
643 /* U2M_PDMA rx_ring_max_cnt */
644 btmtk_usb_io_write32(data
, 0x794, 0x1);
646 /* U2M_PDMA cpu_idx */
647 btmtk_usb_io_write32(data
, 0x798, 0x1);
649 /* U2M_PDMA enable */
650 btmtk_usb_io_write32(data
, 0x704, 0x44);
652 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
659 buf
= usb_alloc_coherent(udev
, 14592, GFP_ATOMIC
, &data_dma
);
666 BT_DBG("loading fw");
668 init_completion(&sent_to_mcu_done
);
670 btmtk_usb_switch_iobase(data
, SYSCTL
);
676 sent_len
= (ilm_len
- cur_len
) >= 14336 ? 14336 :
680 packet_header
&= ~(0xffffffff);
681 packet_header
|= (sent_len
<< 16);
682 packet_header
= cpu_to_le32(packet_header
);
684 memmove(buf
, &packet_header
, 4);
685 memmove(buf
+ 4, data
->firmware
->data
+ 32 + cur_len
,
688 /* U2M_PDMA descriptor */
689 btmtk_usb_io_write32(data
, 0x230, cur_len
);
691 while ((sent_len
% 4) != 0)
694 /* U2M_PDMA length */
695 btmtk_usb_io_write32(data
, 0x234, sent_len
<< 16);
697 usb_fill_bulk_urb(urb
,
705 urb
->transfer_dma
= data_dma
;
706 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
708 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
713 if (!wait_for_completion_timeout(&sent_to_mcu_done
,
714 msecs_to_jiffies(1000))) {
716 BT_ERR("upload ilm fw timeout\n");
730 init_completion(&sent_to_mcu_done
);
735 sent_len
= (dlm_len
- cur_len
) >= 14336 ? 14336 :
741 packet_header
&= ~(0xffffffff);
742 packet_header
|= (sent_len
<< 16);
743 packet_header
= cpu_to_le32(packet_header
);
745 memmove(buf
, &packet_header
, 4);
747 data
->firmware
->data
+ 32 + ilm_len
+ cur_len
,
750 /* U2M_PDMA descriptor */
751 btmtk_usb_io_write32(data
, 0x230, 0x80000 + cur_len
);
753 while ((sent_len
% 4) != 0) {
754 BT_DBG("sent_len is not divided by 4\n");
758 /* U2M_PDMA length */
759 btmtk_usb_io_write32(data
, 0x234, sent_len
<< 16);
761 usb_fill_bulk_urb(urb
,
769 urb
->transfer_dma
= data_dma
;
770 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
772 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
777 if (!wait_for_completion_timeout(&sent_to_mcu_done
,
778 msecs_to_jiffies(1000))) {
780 BT_ERR("upload dlm fw timeout\n");
792 /* upload 64bytes interrupt vector */
793 ret
= load_fw_iv(data
);
796 btmtk_usb_switch_iobase(data
, WLAN
);
798 /* check MCU if ready */
802 btmtk_usb_io_read32(data
, COM_REG0
, &value
);
809 } while (loop
<= 100);
812 BT_ERR("wait for 100 times\n");
817 usb_free_coherent(udev
, 14592, buf
, data_dma
);
821 /* Disbale load fw mode */
822 btmtk_usb_io_read32(data
, 0x238, &value
);
823 value
= value
& ~(0x10000000);
824 btmtk_usb_io_write32(data
, 0x238, value
);
826 btmtk_usb_io_write32(data
, SEMAPHORE_00
, 0x1);
830 static int inc_tx(struct btmtk_usb_data
*data
)
835 spin_lock_irqsave(&data
->txlock
, flags
);
836 rv
= test_bit(BTUSB_SUSPENDING
, &data
->flags
);
838 data
->tx_in_flight
++;
839 spin_unlock_irqrestore(&data
->txlock
, flags
);
844 static void btmtk_usb_intr_complete(struct urb
*urb
)
846 struct hci_dev
*hdev
= urb
->context
;
847 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
850 BT_DBG("%s: %s urb %p status %d count %d\n", __func__
, hdev
->name
,
851 urb
, urb
->status
, urb
->actual_length
);
853 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
856 if (urb
->status
== 0) {
857 hdev
->stat
.byte_rx
+= urb
->actual_length
;
859 hex_dump("hci event", urb
->transfer_buffer
, urb
->actual_length
);
861 if (hci_recv_fragment(hdev
, HCI_EVENT_PKT
,
862 urb
->transfer_buffer
,
863 urb
->actual_length
) < 0) {
864 BT_ERR("%s corrupted event packet", hdev
->name
);
869 if (!test_bit(BTUSB_INTR_RUNNING
, &data
->flags
))
872 usb_mark_last_busy(data
->udev
);
873 usb_anchor_urb(urb
, &data
->intr_anchor
);
875 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
878 /* -EPERM: urb is being killed;
879 * -ENODEV: device got disconnected */
880 if (err
!= -EPERM
&& err
!= -ENODEV
)
881 BT_ERR("%s urb %p failed to resubmit (%d)",
882 hdev
->name
, urb
, -err
);
883 usb_unanchor_urb(urb
);
887 static int btmtk_usb_submit_intr_urb(struct hci_dev
*hdev
, gfp_t mem_flags
)
889 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
895 BT_DBG("%s\n", __func__
);
900 urb
= usb_alloc_urb(0, mem_flags
);
904 size
= le16_to_cpu(data
->intr_ep
->wMaxPacketSize
);
906 buf
= kmalloc(size
, mem_flags
);
912 pipe
= usb_rcvintpipe(data
->udev
, data
->intr_ep
->bEndpointAddress
);
914 usb_fill_int_urb(urb
, data
->udev
, pipe
, buf
, size
,
915 btmtk_usb_intr_complete
, hdev
,
916 data
->intr_ep
->bInterval
);
918 urb
->transfer_flags
|= URB_FREE_BUFFER
;
920 usb_anchor_urb(urb
, &data
->intr_anchor
);
922 err
= usb_submit_urb(urb
, mem_flags
);
924 if (err
!= -EPERM
&& err
!= -ENODEV
)
925 BT_ERR("%s urb %p submission failed (%d)",
926 hdev
->name
, urb
, -err
);
927 usb_unanchor_urb(urb
);
936 static void btmtk_usb_bulk_in_complete(struct urb
*urb
)
938 struct hci_dev
*hdev
= urb
->context
;
939 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
942 BT_DBG("%s:%s urb %p status %d count %d", __func__
, hdev
->name
,
943 urb
, urb
->status
, urb
->actual_length
);
945 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
948 if (urb
->status
== 0) {
949 hdev
->stat
.byte_rx
+= urb
->actual_length
;
951 if (hci_recv_fragment(hdev
, HCI_ACLDATA_PKT
,
952 urb
->transfer_buffer
,
953 urb
->actual_length
) < 0) {
954 BT_ERR("%s corrupted ACL packet", hdev
->name
);
959 if (!test_bit(BTUSB_BULK_RUNNING
, &data
->flags
))
962 usb_anchor_urb(urb
, &data
->bulk_anchor
);
963 usb_mark_last_busy(data
->udev
);
965 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
967 /* -EPERM: urb is being killed;
968 * -ENODEV: device got disconnected */
969 if (err
!= -EPERM
&& err
!= -ENODEV
)
970 BT_ERR("%s urb %p failed to resubmit (%d)",
971 hdev
->name
, urb
, -err
);
972 usb_unanchor_urb(urb
);
976 static int btmtk_usb_submit_bulk_in_urb(struct hci_dev
*hdev
, gfp_t mem_flags
)
978 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
982 int err
, size
= HCI_MAX_FRAME_SIZE
;
984 BT_DBG("%s:%s\n", __func__
, hdev
->name
);
986 if (!data
->bulk_rx_ep
)
989 urb
= usb_alloc_urb(0, mem_flags
);
993 buf
= kmalloc(size
, mem_flags
);
999 pipe
= usb_rcvbulkpipe(data
->udev
, data
->bulk_rx_ep
->bEndpointAddress
);
1001 usb_fill_bulk_urb(urb
, data
->udev
, pipe
, buf
, size
,
1002 btmtk_usb_bulk_in_complete
, hdev
);
1004 urb
->transfer_flags
|= URB_FREE_BUFFER
;
1006 usb_mark_last_busy(data
->udev
);
1007 usb_anchor_urb(urb
, &data
->bulk_anchor
);
1009 err
= usb_submit_urb(urb
, mem_flags
);
1011 if (err
!= -EPERM
&& err
!= -ENODEV
)
1012 BT_ERR("%s urb %p submission failed (%d)",
1013 hdev
->name
, urb
, -err
);
1014 usb_unanchor_urb(urb
);
1022 static void btmtk_usb_isoc_in_complete(struct urb
*urb
)
1025 struct hci_dev
*hdev
= urb
->context
;
1026 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
1029 BT_DBG("%s: %s urb %p status %d count %d", __func__
, hdev
->name
,
1030 urb
, urb
->status
, urb
->actual_length
);
1032 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
1035 if (urb
->status
== 0) {
1036 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
1037 unsigned int offset
= urb
->iso_frame_desc
[i
].offset
;
1038 unsigned int length
;
1039 length
= urb
->iso_frame_desc
[i
].actual_length
;
1041 if (urb
->iso_frame_desc
[i
].status
)
1044 hdev
->stat
.byte_rx
+= length
;
1046 if (hci_recv_fragment(hdev
, HCI_SCODATA_PKT
,
1047 urb
->transfer_buffer
+ offset
,
1049 BT_ERR("%s corrupted SCO packet", hdev
->name
);
1050 hdev
->stat
.err_rx
++;
1055 if (!test_bit(BTUSB_ISOC_RUNNING
, &data
->flags
))
1058 usb_anchor_urb(urb
, &data
->isoc_anchor
);
1060 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1062 /* -EPERM: urb is being killed;
1063 * -ENODEV: device got disconnected */
1064 if (err
!= -EPERM
&& err
!= -ENODEV
)
1065 BT_ERR("%s urb %p failed to resubmit (%d)",
1066 hdev
->name
, urb
, -err
);
1067 usb_unanchor_urb(urb
);
1071 static inline void __fill_isoc_descriptor(struct urb
*urb
, int len
, int mtu
)
1075 BT_DBG("len %d mtu %d", len
, mtu
);
1077 for (i
= 0; i
< BTUSB_MAX_ISOC_FRAMES
&& len
>= mtu
;
1078 i
++, offset
+= mtu
, len
-= mtu
) {
1079 urb
->iso_frame_desc
[i
].offset
= offset
;
1080 urb
->iso_frame_desc
[i
].length
= mtu
;
1083 if (len
&& i
< BTUSB_MAX_ISOC_FRAMES
) {
1084 urb
->iso_frame_desc
[i
].offset
= offset
;
1085 urb
->iso_frame_desc
[i
].length
= len
;
1089 urb
->number_of_packets
= i
;
1092 static int btmtk_usb_submit_isoc_in_urb(struct hci_dev
*hdev
, gfp_t mem_flags
)
1094 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
1100 BT_DBG("%s\n", __func__
);
1102 if (!data
->isoc_rx_ep
)
1105 urb
= usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES
, mem_flags
);
1109 size
= le16_to_cpu(data
->isoc_rx_ep
->wMaxPacketSize
) *
1110 BTUSB_MAX_ISOC_FRAMES
;
1112 buf
= kmalloc(size
, mem_flags
);
1118 pipe
= usb_rcvisocpipe(data
->udev
, data
->isoc_rx_ep
->bEndpointAddress
);
1120 usb_fill_int_urb(urb
, data
->udev
, pipe
, buf
, size
,
1121 btmtk_usb_isoc_in_complete
, hdev
,
1122 data
->isoc_rx_ep
->bInterval
);
1124 urb
->transfer_flags
= URB_FREE_BUFFER
| URB_ISO_ASAP
;
1126 __fill_isoc_descriptor(urb
, size
,
1127 le16_to_cpu(data
->isoc_rx_ep
->wMaxPacketSize
));
1129 usb_anchor_urb(urb
, &data
->isoc_anchor
);
1131 err
= usb_submit_urb(urb
, mem_flags
);
1133 if (err
!= -EPERM
&& err
!= -ENODEV
)
1134 BT_ERR("%s urb %p submission failed (%d)",
1135 hdev
->name
, urb
, -err
);
1136 usb_unanchor_urb(urb
);
1144 static int btmtk_usb_open(struct hci_dev
*hdev
)
1146 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
1149 BT_DBG("%s\n", __func__
);
1151 err
= usb_autopm_get_interface(data
->intf
);
1155 data
->intf
->needs_remote_wakeup
= 1;
1157 if (test_and_set_bit(HCI_RUNNING
, &hdev
->flags
))
1160 if (test_and_set_bit(BTUSB_INTR_RUNNING
, &data
->flags
))
1163 err
= btmtk_usb_submit_intr_urb(hdev
, GFP_KERNEL
);
1167 err
= btmtk_usb_submit_bulk_in_urb(hdev
, GFP_KERNEL
);
1169 usb_kill_anchored_urbs(&data
->intr_anchor
);
1173 set_bit(BTUSB_BULK_RUNNING
, &data
->flags
);
1174 btmtk_usb_submit_bulk_in_urb(hdev
, GFP_KERNEL
);
1177 usb_autopm_put_interface(data
->intf
);
1181 clear_bit(BTUSB_INTR_RUNNING
, &data
->flags
);
1182 clear_bit(HCI_RUNNING
, &hdev
->flags
);
1183 usb_autopm_put_interface(data
->intf
);
1187 static void btmtk_usb_stop_traffic(struct btmtk_usb_data
*data
)
1189 BT_DBG("%s\n", __func__
);
1191 usb_kill_anchored_urbs(&data
->intr_anchor
);
1192 usb_kill_anchored_urbs(&data
->bulk_anchor
);
1193 usb_kill_anchored_urbs(&data
->isoc_anchor
);
1196 static int btmtk_usb_close(struct hci_dev
*hdev
)
1198 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
1201 BT_DBG("%s\n", __func__
);
1203 if (!test_and_clear_bit(HCI_RUNNING
, &hdev
->flags
))
1206 cancel_work_sync(&data
->work
);
1207 cancel_work_sync(&data
->waker
);
1209 clear_bit(BTUSB_ISOC_RUNNING
, &data
->flags
);
1210 clear_bit(BTUSB_BULK_RUNNING
, &data
->flags
);
1211 clear_bit(BTUSB_INTR_RUNNING
, &data
->flags
);
1213 btmtk_usb_stop_traffic(data
);
1215 err
= usb_autopm_get_interface(data
->intf
);
1219 data
->intf
->needs_remote_wakeup
= 0;
1220 usb_autopm_put_interface(data
->intf
);
1223 usb_scuttle_anchored_urbs(&data
->deferred
);
1227 static int btmtk_usb_flush(struct hci_dev
*hdev
)
1229 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
1231 BT_DBG("%s\n", __func__
);
1233 usb_kill_anchored_urbs(&data
->tx_anchor
);
1238 static void btmtk_usb_tx_complete(struct urb
*urb
)
1240 struct sk_buff
*skb
= urb
->context
;
1241 struct hci_dev
*hdev
= (struct hci_dev
*)skb
->dev
;
1242 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
1244 BT_DBG("%s: %s urb %p status %d count %d\n", __func__
, hdev
->name
,
1245 urb
, urb
->status
, urb
->actual_length
);
1247 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
1251 hdev
->stat
.byte_tx
+= urb
->transfer_buffer_length
;
1253 hdev
->stat
.err_tx
++;
1256 spin_lock(&data
->txlock
);
1257 data
->tx_in_flight
--;
1258 spin_unlock(&data
->txlock
);
1260 kfree(urb
->setup_packet
);
1265 static void btmtk_usb_isoc_tx_complete(struct urb
*urb
)
1267 struct sk_buff
*skb
= urb
->context
;
1268 struct hci_dev
*hdev
= (struct hci_dev
*) skb
->dev
;
1270 BT_DBG("%s: %s urb %p status %d count %d", __func__
, hdev
->name
,
1271 urb
, urb
->status
, urb
->actual_length
);
1273 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
1277 hdev
->stat
.byte_tx
+= urb
->transfer_buffer_length
;
1279 hdev
->stat
.err_tx
++;
1282 kfree(urb
->setup_packet
);
1287 static int btmtk_usb_send_frame(struct sk_buff
*skb
)
1289 struct hci_dev
*hdev
= (struct hci_dev
*)skb
->dev
;
1290 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
1291 struct usb_ctrlrequest
*dr
;
1296 BT_DBG("%s\n", __func__
);
1298 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
1301 switch (bt_cb(skb
)->pkt_type
) {
1302 case HCI_COMMAND_PKT
:
1303 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
1307 dr
= kmalloc(sizeof(*dr
), GFP_ATOMIC
);
1313 dr
->bRequestType
= data
->cmdreq_type
;
1317 dr
->wLength
= __cpu_to_le16(skb
->len
);
1319 pipe
= usb_sndctrlpipe(data
->udev
, 0x00);
1321 if (test_bit(HCI_RUNNING
, &hdev
->flags
)) {
1323 memcpy(&op_code
, skb
->data
, 2);
1324 BT_DBG("ogf = %x\n", (op_code
& 0xfc00) >> 10);
1325 BT_DBG("ocf = %x\n", op_code
& 0x03ff);
1326 hex_dump("hci command", skb
->data
, skb
->len
);
1330 usb_fill_control_urb(urb
, data
->udev
, pipe
, (void *) dr
,
1331 skb
->data
, skb
->len
,
1332 btmtk_usb_tx_complete
, skb
);
1334 hdev
->stat
.cmd_tx
++;
1337 case HCI_ACLDATA_PKT
:
1338 if (!data
->bulk_tx_ep
)
1341 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
1345 pipe
= usb_sndbulkpipe(data
->udev
,
1346 data
->bulk_tx_ep
->bEndpointAddress
);
1348 usb_fill_bulk_urb(urb
, data
->udev
, pipe
, skb
->data
,
1349 skb
->len
, btmtk_usb_tx_complete
, skb
);
1351 hdev
->stat
.acl_tx
++;
1352 BT_DBG("HCI_ACLDATA_PKT:\n");
1355 case HCI_SCODATA_PKT
:
1356 if (!data
->isoc_tx_ep
|| hdev
->conn_hash
.sco_num
< 1)
1359 urb
= usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES
, GFP_ATOMIC
);
1363 pipe
= usb_sndisocpipe(data
->udev
,
1364 data
->isoc_tx_ep
->bEndpointAddress
);
1366 usb_fill_int_urb(urb
, data
->udev
, pipe
,
1367 skb
->data
, skb
->len
, btmtk_usb_isoc_tx_complete
,
1368 skb
, data
->isoc_tx_ep
->bInterval
);
1370 urb
->transfer_flags
= URB_ISO_ASAP
;
1372 __fill_isoc_descriptor(urb
, skb
->len
,
1373 le16_to_cpu(data
->isoc_tx_ep
->wMaxPacketSize
));
1375 hdev
->stat
.sco_tx
++;
1376 BT_DBG("HCI_SCODATA_PKT:\n");
1386 usb_anchor_urb(urb
, &data
->deferred
);
1387 schedule_work(&data
->waker
);
1393 usb_anchor_urb(urb
, &data
->tx_anchor
);
1395 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1397 if (err
!= -EPERM
&& err
!= -ENODEV
)
1398 BT_ERR("%s urb %p submission failed (%d)",
1399 hdev
->name
, urb
, -err
);
1400 kfree(urb
->setup_packet
);
1401 usb_unanchor_urb(urb
);
1403 usb_mark_last_busy(data
->udev
);
1411 static void btmtk_usb_notify(struct hci_dev
*hdev
, unsigned int evt
)
1413 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
1415 BT_DBG("%s evt %d", hdev
->name
, evt
);
1417 if (hdev
->conn_hash
.sco_num
!= data
->sco_num
) {
1418 data
->sco_num
= hdev
->conn_hash
.sco_num
;
1419 schedule_work(&data
->work
);
1423 static inline int __set_isoc_interface(struct hci_dev
*hdev
, int altsetting
)
1425 struct btmtk_usb_data
*data
= hci_get_drvdata(hdev
);
1426 struct usb_interface
*intf
= data
->isoc
;
1427 struct usb_endpoint_descriptor
*ep_desc
;
1433 err
= usb_set_interface(data
->udev
, 1, altsetting
);
1435 BT_ERR("%s setting interface failed (%d)", hdev
->name
, -err
);
1439 data
->isoc_altsetting
= altsetting
;
1441 data
->isoc_tx_ep
= NULL
;
1442 data
->isoc_rx_ep
= NULL
;
1444 for (i
= 0; i
< intf
->cur_altsetting
->desc
.bNumEndpoints
; i
++) {
1445 ep_desc
= &intf
->cur_altsetting
->endpoint
[i
].desc
;
1447 if (!data
->isoc_tx_ep
&& usb_endpoint_is_isoc_out(ep_desc
)) {
1448 data
->isoc_tx_ep
= ep_desc
;
1452 if (!data
->isoc_rx_ep
&& usb_endpoint_is_isoc_in(ep_desc
)) {
1453 data
->isoc_rx_ep
= ep_desc
;
1458 if (!data
->isoc_tx_ep
|| !data
->isoc_rx_ep
) {
1459 BT_ERR("%s invalid SCO descriptors", hdev
->name
);
1466 static void btmtk_usb_work(struct work_struct
*work
)
1468 struct btmtk_usb_data
*data
= container_of(work
, struct btmtk_usb_data
,
1470 struct hci_dev
*hdev
= data
->hdev
;
1474 BT_DBG("%s\n", __func__
);
1476 if (hdev
->conn_hash
.sco_num
> 0) {
1477 if (!test_bit(BTUSB_DID_ISO_RESUME
, &data
->flags
)) {
1478 err
= usb_autopm_get_interface(data
->isoc
?
1479 data
->isoc
: data
->intf
);
1481 clear_bit(BTUSB_ISOC_RUNNING
, &data
->flags
);
1482 usb_kill_anchored_urbs(&data
->isoc_anchor
);
1486 set_bit(BTUSB_DID_ISO_RESUME
, &data
->flags
);
1489 if (hdev
->voice_setting
& 0x0020) {
1490 static const int alts
[3] = { 2, 4, 5 };
1491 new_alts
= alts
[hdev
->conn_hash
.sco_num
- 1];
1493 new_alts
= hdev
->conn_hash
.sco_num
;
1496 if (data
->isoc_altsetting
!= new_alts
) {
1497 clear_bit(BTUSB_ISOC_RUNNING
, &data
->flags
);
1498 usb_kill_anchored_urbs(&data
->isoc_anchor
);
1500 if (__set_isoc_interface(hdev
, new_alts
) < 0)
1504 if (!test_and_set_bit(BTUSB_ISOC_RUNNING
, &data
->flags
)) {
1505 if (btmtk_usb_submit_isoc_in_urb(hdev
, GFP_KERNEL
) < 0)
1506 clear_bit(BTUSB_ISOC_RUNNING
, &data
->flags
);
1508 btmtk_usb_submit_isoc_in_urb(hdev
, GFP_KERNEL
);
1511 clear_bit(BTUSB_ISOC_RUNNING
, &data
->flags
);
1512 usb_kill_anchored_urbs(&data
->isoc_anchor
);
1514 __set_isoc_interface(hdev
, 0);
1516 if (test_and_clear_bit(BTUSB_DID_ISO_RESUME
, &data
->flags
))
1517 usb_autopm_put_interface(data
->isoc
?
1518 data
->isoc
: data
->intf
);
1522 static void btmtk_usb_waker(struct work_struct
*work
)
1524 struct btmtk_usb_data
*data
= container_of(work
, struct btmtk_usb_data
,
1528 err
= usb_autopm_get_interface(data
->intf
);
1533 usb_autopm_put_interface(data
->intf
);
1536 static int btmtk_usb_probe(struct usb_interface
*intf
,
1537 const struct usb_device_id
*id
)
1539 struct btmtk_usb_data
*data
;
1540 struct usb_endpoint_descriptor
*ep_desc
;
1542 struct hci_dev
*hdev
;
1544 /* interface numbers are hardcoded in the spec */
1545 if (intf
->cur_altsetting
->desc
.bInterfaceNumber
!= 0)
1548 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
1553 for (i
= 0; i
< intf
->cur_altsetting
->desc
.bNumEndpoints
; i
++) {
1554 ep_desc
= &intf
->cur_altsetting
->endpoint
[i
].desc
;
1556 if (!data
->intr_ep
&& usb_endpoint_is_int_in(ep_desc
)) {
1557 data
->intr_ep
= ep_desc
;
1561 if (!data
->bulk_tx_ep
&& usb_endpoint_is_bulk_out(ep_desc
)) {
1562 data
->bulk_tx_ep
= ep_desc
;
1566 if (!data
->bulk_rx_ep
&& usb_endpoint_is_bulk_in(ep_desc
)) {
1567 data
->bulk_rx_ep
= ep_desc
;
1572 if (!data
->intr_ep
|| !data
->bulk_tx_ep
|| !data
->bulk_rx_ep
) {
1577 data
->cmdreq_type
= USB_TYPE_CLASS
;
1579 data
->udev
= interface_to_usbdev(intf
);
1582 spin_lock_init(&data
->lock
);
1583 INIT_WORK(&data
->work
, btmtk_usb_work
);
1584 INIT_WORK(&data
->waker
, btmtk_usb_waker
);
1585 spin_lock_init(&data
->txlock
);
1587 init_usb_anchor(&data
->tx_anchor
);
1588 init_usb_anchor(&data
->intr_anchor
);
1589 init_usb_anchor(&data
->bulk_anchor
);
1590 init_usb_anchor(&data
->isoc_anchor
);
1591 init_usb_anchor(&data
->deferred
);
1593 hdev
= hci_alloc_dev();
1599 hdev
->bus
= HCI_USB
;
1601 hci_set_drvdata(hdev
, data
);
1605 SET_HCIDEV_DEV(hdev
, &intf
->dev
);
1607 hdev
->open
= btmtk_usb_open
;
1608 hdev
->close
= btmtk_usb_close
;
1609 hdev
->flush
= btmtk_usb_flush
;
1610 hdev
->send
= btmtk_usb_send_frame
;
1611 hdev
->notify
= btmtk_usb_notify
;
1613 /* Interface numbers are hardcoded in the specification */
1614 data
->isoc
= usb_ifnum_to_if(data
->udev
, 1);
1617 err
= usb_driver_claim_interface(&btmtk_usb_driver
,
1626 data
->io_buf
= kmalloc(256, GFP_KERNEL
);
1627 if (!data
->io_buf
) {
1633 btmtk_usb_switch_iobase(data
, WLAN
);
1635 btmtk_usb_cap_init(data
);
1637 err
= hci_register_dev(hdev
);
1644 usb_set_intfdata(intf
, data
);
1649 static void btmtk_usb_disconnect(struct usb_interface
*intf
)
1651 struct btmtk_usb_data
*data
= usb_get_intfdata(intf
);
1652 struct hci_dev
*hdev
;
1654 BT_DBG("%s\n", __func__
);
1660 usb_set_intfdata(data
->intf
, NULL
);
1663 usb_set_intfdata(data
->isoc
, NULL
);
1665 hci_unregister_dev(hdev
);
1667 if (intf
== data
->isoc
)
1668 usb_driver_release_interface(&btmtk_usb_driver
, data
->intf
);
1669 else if (data
->isoc
)
1670 usb_driver_release_interface(&btmtk_usb_driver
, data
->isoc
);
1674 kfree(data
->io_buf
);
1680 static int btmtk_usb_suspend(struct usb_interface
*intf
, pm_message_t message
)
1682 struct btmtk_usb_data
*data
= usb_get_intfdata(intf
);
1684 BT_DBG("%s\n", __func__
);
1686 if (data
->suspend_count
++)
1689 spin_lock_irq(&data
->txlock
);
1690 if (!(PMSG_IS_AUTO(message
) && data
->tx_in_flight
)) {
1691 set_bit(BTUSB_SUSPENDING
, &data
->flags
);
1692 spin_unlock_irq(&data
->txlock
);
1694 spin_unlock_irq(&data
->txlock
);
1695 data
->suspend_count
--;
1699 cancel_work_sync(&data
->work
);
1701 btmtk_usb_stop_traffic(data
);
1702 usb_kill_anchored_urbs(&data
->tx_anchor
);
1707 static void play_deferred(struct btmtk_usb_data
*data
)
1712 while ((urb
= usb_get_from_anchor(&data
->deferred
))) {
1713 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
1717 data
->tx_in_flight
++;
1720 usb_scuttle_anchored_urbs(&data
->deferred
);
1723 static int btmtk_usb_resume(struct usb_interface
*intf
)
1725 struct btmtk_usb_data
*data
= usb_get_intfdata(intf
);
1726 struct hci_dev
*hdev
= data
->hdev
;
1729 BT_DBG("%s\n", __func__
);
1731 if (--data
->suspend_count
)
1734 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
1737 if (test_bit(BTUSB_INTR_RUNNING
, &data
->flags
)) {
1738 err
= btmtk_usb_submit_intr_urb(hdev
, GFP_NOIO
);
1740 clear_bit(BTUSB_INTR_RUNNING
, &data
->flags
);
1745 if (test_bit(BTUSB_BULK_RUNNING
, &data
->flags
)) {
1746 err
= btmtk_usb_submit_bulk_in_urb(hdev
, GFP_NOIO
);
1748 clear_bit(BTUSB_BULK_RUNNING
, &data
->flags
);
1752 btmtk_usb_submit_bulk_in_urb(hdev
, GFP_NOIO
);
1755 if (test_bit(BTUSB_ISOC_RUNNING
, &data
->flags
)) {
1756 if (btmtk_usb_submit_isoc_in_urb(hdev
, GFP_NOIO
) < 0)
1757 clear_bit(BTUSB_ISOC_RUNNING
, &data
->flags
);
1759 btmtk_usb_submit_isoc_in_urb(hdev
, GFP_NOIO
);
1762 spin_lock_irq(&data
->txlock
);
1763 play_deferred(data
);
1764 clear_bit(BTUSB_SUSPENDING
, &data
->flags
);
1765 spin_unlock_irq(&data
->txlock
);
1766 schedule_work(&data
->work
);
1771 usb_scuttle_anchored_urbs(&data
->deferred
);
1773 spin_lock_irq(&data
->txlock
);
1774 clear_bit(BTUSB_SUSPENDING
, &data
->flags
);
1775 spin_unlock_irq(&data
->txlock
);
1781 static struct usb_device_id btmtk_usb_table
[] = {
1782 /* Mediatek MT7650 */
1783 { USB_DEVICE(0x0e8d, 0x7650) },
1784 { USB_DEVICE(0x0e8d, 0x7630) },
1785 { USB_DEVICE(0x0e8d, 0x763e) },
1786 /* Mediatek MT662 */
1787 { USB_DEVICE(0x0e8d, 0x7662) },
1788 { USB_DEVICE(0x0e8d, 0x7632) },
1789 { } /* Terminating entry */
1792 static struct usb_driver btmtk_usb_driver
= {
1793 .name
= "btmtk_usb",
1794 .probe
= btmtk_usb_probe
,
1795 .disconnect
= btmtk_usb_disconnect
,
1797 .suspend
= btmtk_usb_suspend
,
1798 .resume
= btmtk_usb_resume
,
1800 .id_table
= btmtk_usb_table
,
1801 .supports_autosuspend
= 1,
1802 .disable_hub_initiated_lpm
= 1,
1805 module_usb_driver(btmtk_usb_driver
);
1807 MODULE_DESCRIPTION("Mediatek Bluetooth USB driver ver " VERSION
);
1808 MODULE_VERSION(VERSION
);
1809 MODULE_LICENSE("GPL");
1810 MODULE_FIRMWARE(MT7650_FIRMWARE
);
1811 MODULE_FIRMWARE(MT7662_FIRMWARE
);