1 /*
2 *
3 * Realtek Bluetooth USB driver
4 *
5 *
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.
10 *
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.
15 *
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 *
20 */
21
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/types.h>
27 #include <linux/sched.h>
28 #include <linux/errno.h>
29 #include <linux/skbuff.h>
30 #include <linux/usb.h>
31
32 #include <linux/ioctl.h>
33 #include <linux/io.h>
34 #include <linux/firmware.h>
35 #include <linux/vmalloc.h>
36 #include <linux/fs.h>
37 #include <linux/uaccess.h>
38 #include <linux/reboot.h>
39
40 #include "rtk_btusb.h"
41
42 #define RTKBT_RELEASE_NAME "20180702_BT_ANDROID_8.1"
43 #define VERSION "4.1.5"
44
45 #define SUSPNED_DW_FW 0
46 #define SET_WAKEUP_DEVICE 0
47
48
49 static spinlock_t queue_lock;
50 static spinlock_t dlfw_lock;
51 static volatile uint16_t dlfw_dis_state = 0;
52
53 #if SUSPNED_DW_FW
54 static firmware_info *fw_info_4_suspend = NULL;
55 #endif
56
57 static uint32_t usb_info;
58
59 static patch_info fw_patch_table[] = {
60 /* { vid, pid, lmp_sub_default, lmp_sub, everion, mp_fw_name, fw_name, config_name, fw_cache, fw_len, mac_offset } */
61 { 0x0BDA, 0x1724, 0x1200, 0, 0, "mp_rtl8723a_fw", "rtl8723a_fw", "rtl8723a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723A */
62 { 0x0BDA, 0x8723, 0x1200, 0, 0, "mp_rtl8723a_fw", "rtl8723a_fw", "rtl8723a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* 8723AE */
63 { 0x0BDA, 0xA723, 0x1200, 0, 0, "mp_rtl8723a_fw", "rtl8723a_fw", "rtl8723a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* 8723AE for LI */
64 { 0x0BDA, 0x0723, 0x1200, 0, 0, "mp_rtl8723a_fw", "rtl8723a_fw", "rtl8723a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* 8723AE */
65 { 0x13D3, 0x3394, 0x1200, 0, 0, "mp_rtl8723a_fw", "rtl8723a_fw", "rtl8723a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* 8723AE for Azurewave*/
66
67 { 0x0BDA, 0x0724, 0x1200, 0, 0, "mp_rtl8723a_fw", "rtl8723a_fw", "rtl8723a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* 8723AU */
68 { 0x0BDA, 0x8725, 0x1200, 0, 0, "mp_rtl8723a_fw", "rtl8723a_fw", "rtl8723a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* 8723AU */
69 { 0x0BDA, 0x872A, 0x1200, 0, 0, "mp_rtl8723a_fw", "rtl8723a_fw", "rtl8723a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* 8723AU */
70 { 0x0BDA, 0x872B, 0x1200, 0, 0, "mp_rtl8723a_fw", "rtl8723a_fw", "rtl8723a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* 8723AU */
71
72 { 0x0BDA, 0xb720, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723bu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BU */
73 { 0x0BDA, 0xb72A, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723bu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BU */
74 { 0x0BDA, 0xb728, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE for LC */
75 { 0x0BDA, 0xb723, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE */
76 { 0x0BDA, 0xb72B, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE */
77 { 0x0BDA, 0xb001, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE for HP */
78 { 0x0BDA, 0xb002, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE */
79 { 0x0BDA, 0xb003, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE */
80 { 0x0BDA, 0xb004, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE */
81 { 0x0BDA, 0xb005, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE */
82
83 { 0x13D3, 0x3410, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE for Azurewave */
84 { 0x13D3, 0x3416, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE for Azurewave */
85 { 0x13D3, 0x3459, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE for Azurewave */
86 { 0x0489, 0xE085, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE for Foxconn */
87 { 0x0489, 0xE08B, 0x8723, 0, 0, "mp_rtl8723b_fw", "rtl8723b_fw", "rtl8723b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8723BE for Foxconn */
88
89 { 0x0BDA, 0x2850, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761au_fw", "rtl8761a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AU */
90 { 0x0BDA, 0xA761, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761au_fw", "rtl8761a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AU only */
91 { 0x0BDA, 0x818B, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761aw8192eu_fw", "rtl8761aw8192eu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AW + 8192EU */
92 { 0x0BDA, 0x818C, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761aw8192eu_fw", "rtl8761aw8192eu_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AW + 8192EU */
93 { 0x0BDA, 0x8760, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761au8192ee_fw", "rtl8761a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AU + 8192EE */
94 { 0x0BDA, 0xB761, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761au_fw", "rtl8761a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AUV only */
95 { 0x0BDA, 0x8761, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761au8192ee_fw", "rtl8761a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AU + 8192EE for LI */
96 { 0x0BDA, 0x8A60, 0x8761, 0, 0, "mp_rtl8761a_fw", "rtl8761au8812ae_fw", "rtl8761a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8761AU + 8812AE */
97
98 { 0x0BDA, 0x8821, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */
99 { 0x0BDA, 0x0821, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */
100 { 0x0BDA, 0x0823, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AU */
101 { 0x13D3, 0x3414, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */
102 { 0x13D3, 0x3458, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */
103 { 0x13D3, 0x3461, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */
104 { 0x13D3, 0x3462, 0x8821, 0, 0, "mp_rtl8821a_fw", "rtl8821a_fw", "rtl8821a_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_1_2, MAX_PATCH_SIZE_24K}, /* RTL8821AE */
105
106 { 0x0BDA, 0xB822, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_24K}, /* RTL8822BE */
107 { 0x0BDA, 0xB82C, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_24K}, /* RTL8822BU */
108 { 0x0BDA, 0xB023, 0x8822, 0, 0, "mp_rtl8822b_fw", "rtl8822b_fw", "rtl8822b_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_24K}, /* RTL8822BE */
109 { 0x0BDA, 0xB703, 0x8703, 0, 0, "mp_rtl8723c_fw", "rtl8723c_fw", "rtl8723c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_24K}, /* RTL8723CU */
110 /* todo: RTL8703BU */
111
112 { 0x0BDA, 0xD723, 0x8723, 0, 0, "mp_rtl8723d_fw", "rtl8723d_fw", "rtl8723d_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8723DU */
113 { 0x0BDA, 0xD720, 0x8723, 0, 0, "mp_rtl8723d_fw", "rtl8723d_fw", "rtl8723d_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8723DE */
114 { 0x0BDA, 0xB820, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CU */
115 { 0x0BDA, 0xC820, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CU */
116 { 0x0BDA, 0xC821, 0x8821, 0, 0, "mp_rtl8821c_fw", "rtl8821c_fw", "rtl8821c_config", NULL, 0 ,CONFIG_MAC_OFFSET_GEN_3PLUS, MAX_PATCH_SIZE_40K}, /* RTL8821CE */
117 /* todo: RTL8703CU */
118
119 /* NOTE: must append patch entries above the null entry */
120 { 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, 0, 0 }
121 };
122
123 struct btusb_data {
124 struct hci_dev *hdev;
125 struct usb_device *udev;
126 struct usb_interface *intf;
127 struct usb_interface *isoc;
128
129 spinlock_t lock;
130
131 unsigned long flags;
132
133 struct work_struct work;
134 struct work_struct waker;
135
136 struct usb_anchor tx_anchor;
137 struct usb_anchor intr_anchor;
138 struct usb_anchor bulk_anchor;
139 struct usb_anchor isoc_anchor;
140 struct usb_anchor deferred;
141 int tx_in_flight;
142 spinlock_t txlock;
143
144 struct usb_endpoint_descriptor *intr_ep;
145 struct usb_endpoint_descriptor *bulk_tx_ep;
146 struct usb_endpoint_descriptor *bulk_rx_ep;
147 struct usb_endpoint_descriptor *isoc_tx_ep;
148 struct usb_endpoint_descriptor *isoc_rx_ep;
149
150 __u8 cmdreq_type;
151
152 unsigned int sco_num;
153 int isoc_altsetting;
154 int suspend_count;
155 uint16_t sco_handle;
156 //#ifdef CONFIG_HAS_EARLYSUSPEND
157 #if 0
158 struct early_suspend early_suspend;
159 #else
160 struct notifier_block pm_notifier;
161 struct notifier_block reboot_notifier;
162 #endif
163 firmware_info *fw_info;
164
165 #ifdef CONFIG_SCO_OVER_HCI
166 RTK_sco_card_t *pSCOSnd;
167 #endif
168 };
169 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 1)
170 static bool reset_on_close = 0;
171 #endif
172
173 int download_patch(firmware_info *fw_info, int cached);
174 int reset_controller(firmware_info* fw_info);
175
check_set_dlfw_state_value(uint16_t change_value)176 static inline int check_set_dlfw_state_value(uint16_t change_value)
177 {
178 int state;
179 spin_lock(&dlfw_lock);
180 if(!dlfw_dis_state) {
181 dlfw_dis_state = change_value;
182 }
183 state = dlfw_dis_state;
184 spin_unlock(&dlfw_lock);
185 return state;
186 }
187
set_dlfw_state_value(uint16_t change_value)188 static inline void set_dlfw_state_value(uint16_t change_value)
189 {
190 spin_lock(&dlfw_lock);
191 dlfw_dis_state = change_value;
192 spin_unlock(&dlfw_lock);
193 }
194
195 #if SUSPNED_DW_FW
196 static int download_suspend_patch(firmware_info *fw_info, int cached);
197 #endif
198 #if SET_WAKEUP_DEVICE
199 static void set_wakeup_device_from_conf(firmware_info *fw_info);
200 int set_wakeup_device(firmware_info* fw_info, uint8_t* wakeup_bdaddr);
201 #endif
202
rtk_free(struct btusb_data * data)203 static void rtk_free( struct btusb_data *data)
204 {
205 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 1)
206 kfree(data);
207 #endif
208 return;
209 }
210
rtk_alloc(struct usb_interface * intf)211 static struct btusb_data *rtk_alloc(struct usb_interface *intf)
212 {
213 struct btusb_data *data;
214 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 1)
215 data = kzalloc(sizeof(*data), GFP_KERNEL);
216 #else
217 data = devm_kzalloc(&intf->dev, sizeof(*data), GFP_KERNEL);
218 #endif
219 return data;
220 }
221
print_acl(struct sk_buff * skb,int direction)222 static void print_acl(struct sk_buff *skb, int direction)
223 {
224 #if PRINT_ACL_DATA
225 uint wlength = skb->len;
226 u16 *handle = (u16 *)(skb->data);
227 u16 len = *(handle+1);
228 u8 *acl_data = (u8 *)(skb->data);
229
230 RTK_INFO("%s: direction %d, handle %04x, len %d",
231 __func__, direction, *handle, len);
232 #endif
233 }
234
print_sco(struct sk_buff * skb,int direction)235 static void print_sco(struct sk_buff *skb, int direction)
236 {
237 #if PRINT_SCO_DATA
238 uint wlength = skb->len;
239 u16 *handle = (u16 *)(skb->data);
240 u8 len = *(u8 *)(handle+1);
241 u8 *sco_data =(u8 *)(skb->data);
242
243 RTKBT_INFO("%s: direction %d, handle %04x, len %d",
244 __func__, direction, *handle, len);
245 #endif
246 }
247
print_error_command(struct sk_buff * skb)248 static void print_error_command(struct sk_buff *skb)
249 {
250 uint wlength = skb->len;
251 uint icount = 0;
252 u16 *opcode = (u16*)(skb->data);
253 u8 *cmd_data = (u8*)(skb->data);
254 u8 len = *(cmd_data+2);
255
256 switch (*opcode) {
257 case HCI_OP_INQUIRY:
258 printk("HCI_OP_INQUIRY");
259 break;
260 case HCI_OP_INQUIRY_CANCEL:
261 printk("HCI_OP_INQUIRY_CANCEL");
262 break;
263 case HCI_OP_EXIT_PERIODIC_INQ:
264 printk("HCI_OP_EXIT_PERIODIC_INQ");
265 break;
266 case HCI_OP_CREATE_CONN:
267 printk("HCI_OP_CREATE_CONN");
268 break;
269 case HCI_OP_DISCONNECT:
270 printk("HCI_OP_DISCONNECT");
271 break;
272 case HCI_OP_CREATE_CONN_CANCEL:
273 printk("HCI_OP_CREATE_CONN_CANCEL");
274 break;
275 case HCI_OP_ACCEPT_CONN_REQ:
276 printk("HCI_OP_ACCEPT_CONN_REQ");
277 break;
278 case HCI_OP_REJECT_CONN_REQ:
279 printk("HCI_OP_REJECT_CONN_REQ");
280 break;
281 case HCI_OP_AUTH_REQUESTED:
282 printk("HCI_OP_AUTH_REQUESTED");
283 break;
284 case HCI_OP_SET_CONN_ENCRYPT:
285 printk("HCI_OP_SET_CONN_ENCRYPT");
286 break;
287 case HCI_OP_REMOTE_NAME_REQ:
288 printk("HCI_OP_REMOTE_NAME_REQ");
289 break;
290 case HCI_OP_READ_REMOTE_FEATURES:
291 printk("HCI_OP_READ_REMOTE_FEATURES");
292 break;
293 case HCI_OP_SNIFF_MODE:
294 printk("HCI_OP_SNIFF_MODE");
295 break;
296 case HCI_OP_EXIT_SNIFF_MODE:
297 printk("HCI_OP_EXIT_SNIFF_MODE");
298 break;
299 case HCI_OP_SWITCH_ROLE:
300 printk("HCI_OP_SWITCH_ROLE");
301 break;
302 case HCI_OP_SNIFF_SUBRATE:
303 printk("HCI_OP_SNIFF_SUBRATE");
304 break;
305 case HCI_OP_RESET:
306 printk("HCI_OP_RESET");
307 break;
308 case HCI_OP_Write_Extended_Inquiry_Response:
309 printk("HCI_Write_Extended_Inquiry_Response");
310 break;
311
312 default:
313 printk("CMD");
314 break;
315 }
316 printk(":%04x,len:%d,", *opcode,len);
317 for (icount = 3; (icount < wlength) && (icount < 24); icount++)
318 printk("%02x ", *(cmd_data+icount));
319 printk("\n");
320 }
321
print_command(struct sk_buff * skb)322 static void print_command(struct sk_buff *skb)
323 {
324 #if PRINT_CMD_EVENT
325 print_error_command(skb);
326 #endif
327 }
328
329 #if CONFIG_BLUEDROID
330 /* Global parameters for bt usb char driver */
331 #define BT_CHAR_DEVICE_NAME "rtkbt_dev"
332 struct mutex btchr_mutex;
333 static struct sk_buff_head btchr_readq;
334 static wait_queue_head_t btchr_read_wait;
335 static wait_queue_head_t bt_dlfw_wait;
336 static bool bt_char_dev_registered;
337 static dev_t bt_devid; /* bt char device number */
338 static struct cdev bt_char_dev; /* bt character device structure */
339 static struct class *bt_char_class; /* device class for usb char driver */
340 static int bt_reset = 0;
341 /* HCI device & lock */
342 DEFINE_RWLOCK(hci_dev_lock);
343 struct hci_dev *ghdev = NULL;
344
print_event(struct sk_buff * skb)345 static void print_event(struct sk_buff *skb)
346 {
347 #if PRINT_CMD_EVENT
348 uint wlength = skb->len;
349 uint icount = 0;
350 u8 *opcode = (u8*)(skb->data);
351 u8 len = *(opcode+1);
352
353 switch (*opcode) {
354 case HCI_EV_INQUIRY_COMPLETE:
355 printk("HCI_EV_INQUIRY_COMPLETE");
356 break;
357 case HCI_EV_INQUIRY_RESULT:
358 printk("HCI_EV_INQUIRY_RESULT");
359 break;
360 case HCI_EV_CONN_COMPLETE:
361 printk("HCI_EV_CONN_COMPLETE");
362 break;
363 case HCI_EV_CONN_REQUEST:
364 printk("HCI_EV_CONN_REQUEST");
365 break;
366 case HCI_EV_DISCONN_COMPLETE:
367 printk("HCI_EV_DISCONN_COMPLETE");
368 break;
369 case HCI_EV_AUTH_COMPLETE:
370 printk("HCI_EV_AUTH_COMPLETE");
371 break;
372 case HCI_EV_REMOTE_NAME:
373 printk("HCI_EV_REMOTE_NAME");
374 break;
375 case HCI_EV_ENCRYPT_CHANGE:
376 printk("HCI_EV_ENCRYPT_CHANGE");
377 break;
378 case HCI_EV_CHANGE_LINK_KEY_COMPLETE:
379 printk("HCI_EV_CHANGE_LINK_KEY_COMPLETE");
380 break;
381 case HCI_EV_REMOTE_FEATURES:
382 printk("HCI_EV_REMOTE_FEATURES");
383 break;
384 case HCI_EV_REMOTE_VERSION:
385 printk("HCI_EV_REMOTE_VERSION");
386 break;
387 case HCI_EV_QOS_SETUP_COMPLETE:
388 printk("HCI_EV_QOS_SETUP_COMPLETE");
389 break;
390 case HCI_EV_CMD_COMPLETE:
391 printk("HCI_EV_CMD_COMPLETE");
392 break;
393 case HCI_EV_CMD_STATUS:
394 printk("HCI_EV_CMD_STATUS");
395 break;
396 case HCI_EV_ROLE_CHANGE:
397 printk("HCI_EV_ROLE_CHANGE");
398 break;
399 case HCI_EV_NUM_COMP_PKTS:
400 printk("HCI_EV_NUM_COMP_PKTS");
401 break;
402 case HCI_EV_MODE_CHANGE:
403 printk("HCI_EV_MODE_CHANGE");
404 break;
405 case HCI_EV_PIN_CODE_REQ:
406 printk("HCI_EV_PIN_CODE_REQ");
407 break;
408 case HCI_EV_LINK_KEY_REQ:
409 printk("HCI_EV_LINK_KEY_REQ");
410 break;
411 case HCI_EV_LINK_KEY_NOTIFY:
412 printk("HCI_EV_LINK_KEY_NOTIFY");
413 break;
414 case HCI_EV_CLOCK_OFFSET:
415 printk("HCI_EV_CLOCK_OFFSET");
416 break;
417 case HCI_EV_PKT_TYPE_CHANGE:
418 printk("HCI_EV_PKT_TYPE_CHANGE");
419 break;
420 case HCI_EV_PSCAN_REP_MODE:
421 printk("HCI_EV_PSCAN_REP_MODE");
422 break;
423 case HCI_EV_INQUIRY_RESULT_WITH_RSSI:
424 printk("HCI_EV_INQUIRY_RESULT_WITH_RSSI");
425 break;
426 case HCI_EV_REMOTE_EXT_FEATURES:
427 printk("HCI_EV_REMOTE_EXT_FEATURES");
428 break;
429 case HCI_EV_SYNC_CONN_COMPLETE:
430 printk("HCI_EV_SYNC_CONN_COMPLETE");
431 break;
432 case HCI_EV_SYNC_CONN_CHANGED:
433 printk("HCI_EV_SYNC_CONN_CHANGED");
434 break;
435 case HCI_EV_SNIFF_SUBRATE:
436 printk("HCI_EV_SNIFF_SUBRATE");
437 break;
438 case HCI_EV_EXTENDED_INQUIRY_RESULT:
439 printk("HCI_EV_EXTENDED_INQUIRY_RESULT");
440 break;
441 case HCI_EV_IO_CAPA_REQUEST:
442 printk("HCI_EV_IO_CAPA_REQUEST");
443 break;
444 case HCI_EV_SIMPLE_PAIR_COMPLETE:
445 printk("HCI_EV_SIMPLE_PAIR_COMPLETE");
446 break;
447 case HCI_EV_REMOTE_HOST_FEATURES:
448 printk("HCI_EV_REMOTE_HOST_FEATURES");
449 break;
450 default:
451 printk("event");
452 break;
453 }
454 printk(":%02x,len:%d,", *opcode,len);
455 for (icount = 2; (icount < wlength) && (icount < 24); icount++)
456 printk("%02x ", *(opcode+icount));
457 printk("\n");
458 #endif
459 }
460
usb_put_user(struct sk_buff * skb,char __user * buf,int count)461 static inline ssize_t usb_put_user(struct sk_buff *skb,
462 char __user *buf, int count)
463 {
464 char __user *ptr = buf;
465 int len = min_t(unsigned int, skb->len, count);
466
467 if (copy_to_user(ptr, skb->data, len))
468 return -EFAULT;
469
470 return len;
471 }
472
473 static struct sk_buff *rtk_skb_queue[QUEUE_SIZE];
474 static int rtk_skb_queue_front = 0;
475 static int rtk_skb_queue_rear = 0;
476
rtk_enqueue(struct sk_buff * skb)477 static void rtk_enqueue(struct sk_buff *skb)
478 {
479 spin_lock(&queue_lock);
480 if (rtk_skb_queue_front == (rtk_skb_queue_rear + 1) % QUEUE_SIZE) {
481 /*
482 * If queue is full, current solution is to drop
483 * the following entries.
484 */
485 RTKBT_WARN("%s: Queue is full, entry will be dropped", __func__);
486 } else {
487 rtk_skb_queue[rtk_skb_queue_rear] = skb;
488
489 rtk_skb_queue_rear++;
490 rtk_skb_queue_rear %= QUEUE_SIZE;
491
492 }
493 spin_unlock(&queue_lock);
494 }
495
rtk_dequeue_try(unsigned int deq_len)496 static struct sk_buff *rtk_dequeue_try(unsigned int deq_len)
497 {
498 struct sk_buff *skb;
499 struct sk_buff *skb_copy;
500
501 if (rtk_skb_queue_front == rtk_skb_queue_rear) {
502 RTKBT_WARN("%s: Queue is empty", __func__);
503 return NULL;
504 }
505
506 skb = rtk_skb_queue[rtk_skb_queue_front];
507 if (deq_len >= skb->len) {
508 rtk_skb_queue[rtk_skb_queue_front] = NULL;
509 rtk_skb_queue_front++;
510 rtk_skb_queue_front %= QUEUE_SIZE;
511
512 /*
513 * Return skb addr to be dequeued, and the caller
514 * should free the skb eventually.
515 */
516 return skb;
517 } else {
518 skb_copy = pskb_copy(skb, GFP_ATOMIC);
519 skb_pull(skb, deq_len);
520 /* Return its copy to be freed */
521 return skb_copy;
522 }
523 }
524
is_queue_empty(void)525 static inline int is_queue_empty(void)
526 {
527 return (rtk_skb_queue_front == rtk_skb_queue_rear) ? 1 : 0;
528 }
529
rtk_clear_queue(void)530 static void rtk_clear_queue(void)
531 {
532 struct sk_buff *skb;
533 spin_lock(&queue_lock);
534 while(!is_queue_empty()) {
535 skb = rtk_skb_queue[rtk_skb_queue_front];
536 rtk_skb_queue[rtk_skb_queue_front] = NULL;
537 rtk_skb_queue_front++;
538 rtk_skb_queue_front %= QUEUE_SIZE;
539 if (skb) {
540 kfree_skb(skb);
541 }
542 }
543 spin_unlock(&queue_lock);
544 }
545
546 /*
547 * Realtek - Integrate from hci_core.c
548 */
549
550 /* Get HCI device by index.
551 * Device is held on return. */
hci_dev_get(int index)552 static struct hci_dev *hci_dev_get(int index)
553 {
554 if (index != 0)
555 return NULL;
556
557 return ghdev;
558 }
559
560 /* ---- HCI ioctl helpers ---- */
hci_dev_open(__u16 dev)561 static int hci_dev_open(__u16 dev)
562 {
563 struct hci_dev *hdev;
564 int ret = 0;
565
566 RTKBT_DBG("%s: dev %d", __func__, dev);
567
568 hdev = hci_dev_get(dev);
569 if (!hdev) {
570 RTKBT_ERR("%s: Failed to get hci dev[Null]", __func__);
571 return -ENODEV;
572 }
573
574 if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) {
575 ret = -ENODEV;
576 goto done;
577 }
578
579 if (test_bit(HCI_UP, &hdev->flags)) {
580 ret = -EALREADY;
581 goto done;
582 }
583 /*
584 ret = hdev->open(hdev);
585 if(ret < 0){
586 RTKBT_ERR("%s:Failed in hdev->open(hdev):%d",__func__,ret);
587 goto done;
588 }
589 set_bit(HCI_UP, &hdev->flags);
590 */
591
592 done:
593 return ret;
594 }
595
hci_dev_do_close(struct hci_dev * hdev)596 static int hci_dev_do_close(struct hci_dev *hdev)
597 {
598 if (hdev->flush)
599 hdev->flush(hdev);
600 /* After this point our queues are empty
601 * and no tasks are scheduled. */
602 hdev->close(hdev);
603 /* Clear flags */
604 hdev->flags = 0;
605 return 0;
606 }
607
hci_dev_close(__u16 dev)608 static int hci_dev_close(__u16 dev)
609 {
610 struct hci_dev *hdev;
611 int err;
612 hdev = hci_dev_get(dev);
613 if (!hdev) {
614 RTKBT_ERR("%s: failed to get hci dev[Null]", __func__);
615 return -ENODEV;
616 }
617
618 err = hci_dev_do_close(hdev);
619
620 return err;
621 }
622
hci_alloc_dev(void)623 static struct hci_dev *hci_alloc_dev(void)
624 {
625 struct hci_dev *hdev;
626
627 hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL);
628 if (!hdev)
629 return NULL;
630
631 return hdev;
632 }
633
634 /* Free HCI device */
hci_free_dev(struct hci_dev * hdev)635 static void hci_free_dev(struct hci_dev *hdev)
636 {
637 kfree(hdev);
638 }
639
640 /* Register HCI device */
hci_register_dev(struct hci_dev * hdev)641 static int hci_register_dev(struct hci_dev *hdev)
642 {
643 int i, id;
644
645 RTKBT_DBG("%s: %p name %s bus %d", __func__, hdev, hdev->name, hdev->bus);
646 /* Do not allow HCI_AMP devices to register at index 0,
647 * so the index can be used as the AMP controller ID.
648 */
649 id = (hdev->dev_type == HCI_BREDR) ? 0 : 1;
650
651 write_lock(&hci_dev_lock);
652
653 sprintf(hdev->name, "hci%d", id);
654 hdev->id = id;
655 hdev->flags = 0;
656 hdev->dev_flags = 0;
657 mutex_init(&hdev->lock);
658
659 RTKBT_DBG("%s: id %d, name %s", __func__, hdev->id, hdev->name);
660
661
662 for (i = 0; i < NUM_REASSEMBLY; i++)
663 hdev->reassembly[i] = NULL;
664
665 memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
666 atomic_set(&hdev->promisc, 0);
667
668 if (ghdev) {
669 write_unlock(&hci_dev_lock);
670 RTKBT_ERR("%s: Hci device has been registered already", __func__);
671 return -1;
672 } else
673 ghdev = hdev;
674
675 write_unlock(&hci_dev_lock);
676
677 return id;
678 }
679
680 /* Unregister HCI device */
hci_unregister_dev(struct hci_dev * hdev)681 static void hci_unregister_dev(struct hci_dev *hdev)
682 {
683 int i;
684
685 RTKBT_DBG("%s: hdev %p name %s bus %d", __func__, hdev, hdev->name, hdev->bus);
686 set_bit(HCI_UNREGISTER, &hdev->dev_flags);
687
688 write_lock(&hci_dev_lock);
689 ghdev = NULL;
690 write_unlock(&hci_dev_lock);
691
692 hci_dev_do_close(hdev);
693 for (i = 0; i < NUM_REASSEMBLY; i++)
694 kfree_skb(hdev->reassembly[i]);
695 }
696
697
698 #ifdef CONFIG_SCO_OVER_HCI
699 /* copy data from the URB buffer into the ALSA ring buffer */
rtk_copy_capture_data_to_alsa(struct btusb_data * data,uint8_t * p_data,unsigned int frames)700 static bool rtk_copy_capture_data_to_alsa(struct btusb_data *data, uint8_t* p_data, unsigned int frames)
701 {
702 struct snd_pcm_runtime *runtime;
703 unsigned int frame_bytes, frames1;
704 u8 *dest;
705 RTK_sco_card_t *pSCOSnd = data->pSCOSnd;
706
707 runtime = pSCOSnd->capture.substream->runtime;
708 frame_bytes = 2;
709
710 dest = runtime->dma_area + pSCOSnd->capture.buffer_pos * frame_bytes;
711 if (pSCOSnd->capture.buffer_pos + frames <= runtime->buffer_size) {
712 memcpy(dest, p_data, frames * frame_bytes);
713 } else {
714 /* wrap around at end of ring buffer */
715 frames1 = runtime->buffer_size - pSCOSnd->capture.buffer_pos;
716 memcpy(dest, p_data, frames1 * frame_bytes);
717 memcpy(runtime->dma_area,
718 p_data + frames1 * frame_bytes,
719 (frames - frames1) * frame_bytes);
720 }
721
722 pSCOSnd->capture.buffer_pos += frames;
723 if (pSCOSnd->capture.buffer_pos >= runtime->buffer_size) {
724 pSCOSnd->capture.buffer_pos -= runtime->buffer_size;
725 }
726
727 if((pSCOSnd->capture.buffer_pos%runtime->period_size) == 0) {
728 snd_pcm_period_elapsed(pSCOSnd->capture.substream);
729 }
730
731 return false;
732 }
733
734
hci_send_to_alsa_ringbuffer(struct hci_dev * hdev,struct sk_buff * skb)735 static void hci_send_to_alsa_ringbuffer(struct hci_dev *hdev, struct sk_buff *skb)
736 {
737 struct btusb_data *data = GET_DRV_DATA(hdev);
738 RTK_sco_card_t *pSCOSnd = data->pSCOSnd;
739 uint8_t* p_data;
740 int sco_length = skb->len - HCI_SCO_HDR_SIZE;
741
742 RTKBT_DBG("%s", __func__);
743
744 if (!hdev) {
745 RTKBT_ERR("%s: Frame for unknown HCI device", __func__);
746 return;
747 }
748
749 if (!test_bit(ALSA_CAPTURE_RUNNING, &pSCOSnd->states)) {
750 //RTKBT_WARN("%s: ALSA is not running", __func__);
751 return;
752 }
753
754 p_data = (uint8_t *)skb->data + HCI_SCO_HDR_SIZE;
755 rtk_copy_capture_data_to_alsa(data, p_data, sco_length/2);
756 }
757
758 #endif
759
hci_send_to_stack(struct hci_dev * hdev,struct sk_buff * skb)760 static void hci_send_to_stack(struct hci_dev *hdev, struct sk_buff *skb)
761 {
762 struct sk_buff *rtk_skb_copy = NULL;
763
764 RTKBT_DBG("%s", __func__);
765
766 if (!hdev) {
767 RTKBT_ERR("%s: Frame for unknown HCI device", __func__);
768 return;
769 }
770
771 if (!test_bit(HCI_RUNNING, &hdev->flags)) {
772 RTKBT_ERR("%s: HCI not running", __func__);
773 return;
774 }
775
776 rtk_skb_copy = pskb_copy(skb, GFP_ATOMIC);
777 if (!rtk_skb_copy) {
778 RTKBT_ERR("%s: Copy skb error", __func__);
779 return;
780 }
781
782 memcpy(skb_push(rtk_skb_copy, 1), &bt_cb(skb)->pkt_type, 1);
783 rtk_enqueue(rtk_skb_copy);
784
785 /* Make sure bt char device existing before wakeup read queue */
786 hdev = hci_dev_get(0);
787 if (hdev) {
788 RTKBT_DBG("%s: Try to wakeup read queue", __func__);
789 wake_up_interruptible(&btchr_read_wait);
790 }
791
792 return;
793 }
794
795 /* Receive frame from HCI drivers */
hci_recv_frame(struct sk_buff * skb)796 static int hci_recv_frame(struct sk_buff *skb)
797 {
798 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
799
800 if (!hdev ||
801 (!test_bit(HCI_UP, &hdev->flags) && !test_bit(HCI_INIT, &hdev->flags))) {
802 kfree_skb(skb);
803 return -ENXIO;
804 }
805
806 /* Incomming skb */
807 bt_cb(skb)->incoming = 1;
808
809 /* Time stamp */
810 __net_timestamp(skb);
811
812 if (atomic_read(&hdev->promisc)) {
813 #ifdef CONFIG_SCO_OVER_HCI
814 if(bt_cb(skb)->pkt_type == HCI_SCODATA_PKT)
815 hci_send_to_alsa_ringbuffer(hdev, skb);
816 #endif
817 /* Send copy to the sockets */
818 hci_send_to_stack(hdev, skb);
819 }
820
821 kfree_skb(skb);
822 return 0;
823 }
824
hci_reassembly(struct hci_dev * hdev,int type,void * data,int count,__u8 index)825 static int hci_reassembly(struct hci_dev *hdev, int type, void *data,
826 int count, __u8 index)
827 {
828 int len = 0;
829 int hlen = 0;
830 int remain = count;
831 struct sk_buff *skb;
832 struct bt_skb_cb *scb;
833
834 RTKBT_DBG("%s", __func__);
835
836 if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) ||
837 index >= NUM_REASSEMBLY)
838 return -EILSEQ;
839
840 skb = hdev->reassembly[index];
841
842 if (!skb) {
843 switch (type) {
844 case HCI_ACLDATA_PKT:
845 len = HCI_MAX_FRAME_SIZE;
846 hlen = HCI_ACL_HDR_SIZE;
847 break;
848 case HCI_EVENT_PKT:
849 len = HCI_MAX_EVENT_SIZE;
850 hlen = HCI_EVENT_HDR_SIZE;
851 break;
852 case HCI_SCODATA_PKT:
853 len = HCI_MAX_SCO_SIZE;
854 hlen = HCI_SCO_HDR_SIZE;
855 break;
856 }
857
858 skb = bt_skb_alloc(len, GFP_ATOMIC);
859 if (!skb)
860 return -ENOMEM;
861
862 scb = (void *) skb->cb;
863 scb->expect = hlen;
864 scb->pkt_type = type;
865
866 skb->dev = (void *) hdev;
867 hdev->reassembly[index] = skb;
868 }
869
870 while (count) {
871 scb = (void *) skb->cb;
872 len = min_t(uint, scb->expect, count);
873
874 memcpy(skb_put(skb, len), data, len);
875
876 count -= len;
877 data += len;
878 scb->expect -= len;
879 remain = count;
880
881 switch (type) {
882 case HCI_EVENT_PKT:
883 if (skb->len == HCI_EVENT_HDR_SIZE) {
884 struct hci_event_hdr *h = hci_event_hdr(skb);
885 scb->expect = h->plen;
886
887 if (skb_tailroom(skb) < scb->expect) {
888 kfree_skb(skb);
889 hdev->reassembly[index] = NULL;
890 return -ENOMEM;
891 }
892 }
893 break;
894
895 case HCI_ACLDATA_PKT:
896 if (skb->len == HCI_ACL_HDR_SIZE) {
897 struct hci_acl_hdr *h = hci_acl_hdr(skb);
898 scb->expect = __le16_to_cpu(h->dlen);
899
900 if (skb_tailroom(skb) < scb->expect) {
901 kfree_skb(skb);
902 hdev->reassembly[index] = NULL;
903 return -ENOMEM;
904 }
905 }
906 break;
907
908 case HCI_SCODATA_PKT:
909 if (skb->len == HCI_SCO_HDR_SIZE) {
910 struct hci_sco_hdr *h = hci_sco_hdr(skb);
911 scb->expect = h->dlen;
912
913 if (skb_tailroom(skb) < scb->expect) {
914 kfree_skb(skb);
915 hdev->reassembly[index] = NULL;
916 return -ENOMEM;
917 }
918 }
919 break;
920 }
921
922 if (scb->expect == 0) {
923 /* Complete frame */
924 if(HCI_ACLDATA_PKT == type)
925 print_acl(skb,0);
926 if(HCI_SCODATA_PKT == type)
927 print_sco(skb,0);
928 if(HCI_EVENT_PKT == type)
929 print_event(skb);
930
931 bt_cb(skb)->pkt_type = type;
932 hci_recv_frame(skb);
933
934 hdev->reassembly[index] = NULL;
935 return remain;
936 }
937 }
938
939 return remain;
940 }
941
hci_recv_fragment(struct hci_dev * hdev,int type,void * data,int count)942 static int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count)
943 {
944 int rem = 0;
945
946 if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT)
947 return -EILSEQ;
948
949 while (count) {
950 rem = hci_reassembly(hdev, type, data, count, type - 1);
951 if (rem < 0)
952 return rem;
953
954 data += (count - rem);
955 count = rem;
956 }
957
958 return rem;
959 }
960
hci_hardware_error(void)961 void hci_hardware_error(void)
962 {
963 struct sk_buff *rtk_skb_copy = NULL;
964 int len = 3;
965 uint8_t hardware_err_pkt[4] = {HCI_EVENT_PKT, 0x10, 0x01, HCI_VENDOR_USB_DISC_HARDWARE_ERROR};
966
967 rtk_skb_copy = alloc_skb(len, GFP_ATOMIC);
968 if (!rtk_skb_copy) {
969 RTKBT_ERR("%s: Failed to allocate mem", __func__);
970 return;
971 }
972
973 memcpy(skb_put(rtk_skb_copy, len), hardware_err_pkt, len);
974 rtk_enqueue(rtk_skb_copy);
975
976 wake_up_interruptible(&btchr_read_wait);
977 }
978
btchr_open(struct inode * inode_p,struct file * file_p)979 static int btchr_open(struct inode *inode_p, struct file *file_p)
980 {
981 struct btusb_data *data;
982 struct hci_dev *hdev;
983
984 RTKBT_INFO("%s: BT usb char device is opening", __func__);
985 /* Not open unless wanna tracing log */
986 /* trace_printk("%s: open....\n", __func__); */
987
988 hdev = hci_dev_get(0);
989 if (!hdev) {
990 RTKBT_ERR("%s: Failed to get hci dev[NULL]", __func__);
991 return -ENODEV;
992 }
993 data = GET_DRV_DATA(hdev);
994
995 atomic_inc(&hdev->promisc);
996 /*
997 * As bt device is not re-opened when hotplugged out, we cannot
998 * trust on file's private data(may be null) when other file ops
999 * are invoked.
1000 */
1001 file_p->private_data = data;
1002
1003 mutex_lock(&btchr_mutex);
1004 hci_dev_open(0);
1005 mutex_unlock(&btchr_mutex);
1006
1007 rtk_clear_queue();
1008 return nonseekable_open(inode_p, file_p);
1009 }
1010
btchr_close(struct inode * inode_p,struct file * file_p)1011 static int btchr_close(struct inode *inode_p, struct file *file_p)
1012 {
1013 struct btusb_data *data;
1014 struct hci_dev *hdev;
1015
1016 RTKBT_INFO("%s: BT usb char device is closing", __func__);
1017 /* Not open unless wanna tracing log */
1018 /* trace_printk("%s: close....\n", __func__); */
1019
1020 data = file_p->private_data;
1021 file_p->private_data = NULL;
1022
1023 #if CONFIG_BLUEDROID
1024 /*
1025 * If the upper layer closes bt char interfaces, no reset
1026 * action required even bt device hotplugged out.
1027 */
1028 bt_reset = 0;
1029 #endif
1030
1031 hdev = hci_dev_get(0);
1032 if (hdev) {
1033 atomic_set(&hdev->promisc, 0);
1034 mutex_lock(&btchr_mutex);
1035 hci_dev_close(0);
1036 mutex_unlock(&btchr_mutex);
1037 }
1038
1039 return 0;
1040 }
1041
btchr_read(struct file * file_p,char __user * buf_p,size_t count,loff_t * pos_p)1042 static ssize_t btchr_read(struct file *file_p,
1043 char __user *buf_p,
1044 size_t count,
1045 loff_t *pos_p)
1046 {
1047 struct hci_dev *hdev;
1048 struct sk_buff *skb;
1049 ssize_t ret = 0;
1050
1051 RTKBT_DBG("%s: BT usb char device is reading", __func__);
1052
1053 while (count) {
1054 hdev = hci_dev_get(0);
1055 if (!hdev) {
1056 /*
1057 * Note: Only when BT device hotplugged out, we wil get
1058 * into such situation. In order to keep the upper layer
1059 * stack alive (blocking the read), we should never return
1060 * EFAULT or break the loop.
1061 */
1062 RTKBT_ERR("%s: Failed to get hci dev[Null]", __func__);
1063 }
1064
1065 ret = wait_event_interruptible(btchr_read_wait, !is_queue_empty());
1066 if (ret < 0) {
1067 RTKBT_ERR("%s: wait event is signaled %d", __func__, (int)ret);
1068 break;
1069 }
1070
1071 skb = rtk_dequeue_try(count);
1072 if (skb) {
1073 ret = usb_put_user(skb, buf_p, count);
1074 if (ret < 0)
1075 RTKBT_ERR("%s: Failed to put data to user space", __func__);
1076 kfree_skb(skb);
1077 break;
1078 }
1079 }
1080
1081 return ret;
1082 }
1083
btchr_write(struct file * file_p,const char __user * buf_p,size_t count,loff_t * pos_p)1084 static ssize_t btchr_write(struct file *file_p,
1085 const char __user *buf_p,
1086 size_t count,
1087 loff_t *pos_p)
1088 {
1089 struct btusb_data *data = file_p->private_data;
1090 struct hci_dev *hdev;
1091 struct sk_buff *skb;
1092
1093 RTKBT_DBG("%s: BT usb char device is writing", __func__);
1094
1095 hdev = hci_dev_get(0);
1096 if (!hdev) {
1097 RTKBT_WARN("%s: Failed to get hci dev[Null]", __func__);
1098 /*
1099 * Note: we bypass the data from the upper layer if bt device
1100 * is hotplugged out. Fortunatelly, H4 or H5 HCI stack does
1101 * NOT check btchr_write's return value. However, returning
1102 * count instead of EFAULT is preferable.
1103 */
1104 /* return -EFAULT; */
1105 return count;
1106 }
1107
1108 /* Never trust on btusb_data, as bt device may be hotplugged out */
1109 data = GET_DRV_DATA(hdev);
1110 if (!data) {
1111 RTKBT_WARN("%s: Failed to get bt usb driver data[Null]", __func__);
1112 return count;
1113 }
1114
1115 if (count > HCI_MAX_FRAME_SIZE)
1116 return -EINVAL;
1117
1118 skb = bt_skb_alloc(count, GFP_ATOMIC);
1119 if (!skb)
1120 return -ENOMEM;
1121 skb_reserve(skb, -1); // Add this line
1122
1123 if (copy_from_user(skb_put(skb, count), buf_p, count)) {
1124 RTKBT_ERR("%s: Failed to get data from user space", __func__);
1125 kfree_skb(skb);
1126 return -EFAULT;
1127 }
1128
1129 skb->dev = (void *)hdev;
1130 bt_cb(skb)->pkt_type = *((__u8 *)skb->data);
1131 skb_pull(skb, 1);
1132 data->hdev->send(skb);
1133
1134 return count;
1135 }
1136
btchr_poll(struct file * file_p,poll_table * wait)1137 static unsigned int btchr_poll(struct file *file_p, poll_table *wait)
1138 {
1139 struct btusb_data *data = file_p->private_data;
1140 struct hci_dev *hdev;
1141
1142 RTKBT_DBG("%s: BT usb char device is polling", __func__);
1143
1144 if(!bt_char_dev_registered) {
1145 RTKBT_ERR("%s: char device has not registered!", __func__);
1146 return POLLERR | POLLHUP;
1147 }
1148
1149 poll_wait(file_p, &btchr_read_wait, wait);
1150
1151 hdev = hci_dev_get(0);
1152 if (!hdev) {
1153 RTKBT_ERR("%s: Failed to get hci dev[Null]", __func__);
1154 mdelay(URB_CANCELING_DELAY_MS);
1155 return POLLOUT | POLLWRNORM;
1156 }
1157
1158 /* Never trust on btusb_data, as bt device may be hotplugged out */
1159 data = GET_DRV_DATA(hdev);
1160 if (!data) {
1161 /*
1162 * When bt device is hotplugged out, btusb_data will
1163 * be freed in disconnect.
1164 */
1165 RTKBT_ERR("%s: Failed to get bt usb driver data[Null]", __func__);
1166 mdelay(URB_CANCELING_DELAY_MS);
1167 return POLLOUT | POLLWRNORM;
1168 }
1169
1170 if (!is_queue_empty())
1171 return POLLIN | POLLRDNORM;
1172
1173 return POLLOUT | POLLWRNORM;
1174 }
btchr_ioctl(struct file * file_p,unsigned int cmd,unsigned long arg)1175 static long btchr_ioctl(struct file *file_p, unsigned int cmd, unsigned long arg){
1176 int ret = 0;
1177 struct hci_dev *hdev;
1178 struct btusb_data *data;
1179 firmware_info *fw_info;
1180
1181 if(!bt_char_dev_registered) {
1182 return -ENODEV;
1183 }
1184
1185 if(check_set_dlfw_state_value(1) != 1) {
1186 RTKBT_ERR("%s bt controller is disconnecting!", __func__);
1187 return 0;
1188 }
1189
1190 hdev = hci_dev_get(0);
1191 if(!hdev) {
1192 RTKBT_ERR("%s device is NULL!", __func__);
1193 set_dlfw_state_value(0);
1194 return 0;
1195 }
1196 data = GET_DRV_DATA(hdev);
1197 fw_info = data->fw_info;
1198
1199 RTKBT_INFO(" btchr_ioctl DOWN_FW_CFG with Cmd:%d",cmd);
1200 switch (cmd) {
1201 case DOWN_FW_CFG:
1202 ret = usb_autopm_get_interface(data->intf);
1203 if (ret < 0){
1204 goto failed;
1205 }
1206
1207 ret = download_patch(fw_info,1);
1208 usb_autopm_put_interface(data->intf);
1209 if(ret < 0){
1210 RTKBT_ERR("%s:Failed in download_patch with ret:%d",__func__,ret);
1211 goto failed;
1212 }
1213
1214 ret = hdev->open(hdev);
1215 if(ret < 0){
1216 RTKBT_ERR("%s:Failed in hdev->open(hdev):%d",__func__,ret);
1217 goto failed;
1218 }
1219 set_bit(HCI_UP, &hdev->flags);
1220 set_dlfw_state_value(0);
1221 wake_up_interruptible(&bt_dlfw_wait);
1222 return 1;
1223 case GET_USB_INFO:
1224 ret = hdev->open(hdev);
1225 if(ret < 0){
1226 RTKBT_ERR("%s:Failed in hdev->open(hdev):%d",__func__,ret);
1227 //goto done;
1228 }
1229 set_bit(HCI_UP, &hdev->flags);
1230 return usb_info;
1231 case RESET_CONTROLLER:
1232 reset_controller(fw_info);
1233 return 1;
1234
1235 #ifdef CONFIG_SCO_OVER_HCI
1236 case SET_ISO_CFG:
1237 hdev->voice_setting = *(__u16 *)arg;
1238 RTKBT_INFO(" voice settings = 0x%04x", hdev->voice_setting);
1239 return 1;
1240 #endif
1241 default:
1242 RTKBT_ERR("%s:Failed with wrong Cmd:%d",__func__,cmd);
1243 goto failed;
1244 }
1245 failed:
1246 set_dlfw_state_value(0);
1247 wake_up_interruptible(&bt_dlfw_wait);
1248 return ret;
1249
1250 }
1251
1252
1253
1254 static struct file_operations bt_chrdev_ops = {
1255 open : btchr_open,
1256 release : btchr_close,
1257 read : btchr_read,
1258 write : btchr_write,
1259 poll : btchr_poll,
1260 unlocked_ioctl : btchr_ioctl,
1261 };
1262
btchr_init(void)1263 static int btchr_init(void)
1264 {
1265 int res = 0;
1266 struct device *dev;
1267
1268 RTKBT_INFO("Register usb char device interface for BT driver");
1269 /*
1270 * btchr mutex is used to sync between
1271 * 1) downloading patch and opening bt char driver
1272 * 2) the file operations of bt char driver
1273 */
1274 mutex_init(&btchr_mutex);
1275
1276 skb_queue_head_init(&btchr_readq);
1277 init_waitqueue_head(&btchr_read_wait);
1278 init_waitqueue_head(&bt_dlfw_wait);
1279
1280 bt_char_class = class_create(THIS_MODULE, BT_CHAR_DEVICE_NAME);
1281 if (IS_ERR(bt_char_class)) {
1282 RTKBT_ERR("Failed to create bt char class");
1283 return PTR_ERR(bt_char_class);
1284 }
1285
1286 res = alloc_chrdev_region(&bt_devid, 0, 1, BT_CHAR_DEVICE_NAME);
1287 if (res < 0) {
1288 RTKBT_ERR("Failed to allocate bt char device");
1289 goto err_alloc;
1290 }
1291
1292 dev = device_create(bt_char_class, NULL, bt_devid, NULL, BT_CHAR_DEVICE_NAME);
1293 if (IS_ERR(dev)) {
1294 RTKBT_ERR("Failed to create bt char device");
1295 res = PTR_ERR(dev);
1296 goto err_create;
1297 }
1298
1299 cdev_init(&bt_char_dev, &bt_chrdev_ops);
1300 res = cdev_add(&bt_char_dev, bt_devid, 1);
1301 if (res < 0) {
1302 RTKBT_ERR("Failed to add bt char device");
1303 goto err_add;
1304 }
1305
1306 return 0;
1307
1308 err_add:
1309 device_destroy(bt_char_class, bt_devid);
1310 err_create:
1311 unregister_chrdev_region(bt_devid, 1);
1312 err_alloc:
1313 class_destroy(bt_char_class);
1314 return res;
1315 }
1316
btchr_exit(void)1317 static void btchr_exit(void)
1318 {
1319 RTKBT_INFO("Unregister usb char device interface for BT driver");
1320
1321 device_destroy(bt_char_class, bt_devid);
1322 cdev_del(&bt_char_dev);
1323 unregister_chrdev_region(bt_devid, 1);
1324 class_destroy(bt_char_class);
1325
1326 return;
1327 }
1328 #endif
1329
send_hci_cmd(firmware_info * fw_info)1330 int send_hci_cmd(firmware_info *fw_info)
1331 {
1332 int i = 0;
1333 int ret_val = -1;
1334 while((ret_val<0)&&(i++<10))
1335 {
1336 ret_val = usb_control_msg(
1337 fw_info->udev, fw_info->pipe_out,
1338 0, USB_TYPE_CLASS, 0, 0,
1339 (void *)(fw_info->send_pkt),
1340 fw_info->pkt_len, MSG_TO);
1341 }
1342 return ret_val;
1343 }
1344
rcv_hci_evt(firmware_info * fw_info)1345 int rcv_hci_evt(firmware_info *fw_info)
1346 {
1347 int ret_len = 0, ret_val = 0;
1348 int i;
1349
1350 while (1) {
1351 for(i = 0; i < 5; i++) {
1352 ret_val = usb_interrupt_msg(
1353 fw_info->udev, fw_info->pipe_in,
1354 (void *)(fw_info->rcv_pkt), PKT_LEN,
1355 &ret_len, MSG_TO);
1356 if (ret_val >= 0)
1357 break;
1358 }
1359
1360 if (ret_val < 0)
1361 return ret_val;
1362
1363 if (CMD_CMP_EVT == fw_info->evt_hdr->evt) {
1364 if (fw_info->cmd_hdr->opcode == fw_info->cmd_cmp->opcode)
1365 return ret_len;
1366 }
1367 }
1368 }
1369
set_bt_onoff(firmware_info * fw_info,uint8_t onoff)1370 int set_bt_onoff(firmware_info *fw_info, uint8_t onoff)
1371 {
1372 patch_info *patch_entry;
1373 int ret_val;
1374
1375 RTKBT_INFO("%s: %s", __func__, onoff != 0 ? "on" : "off");
1376
1377 patch_entry = fw_info->patch_entry;
1378 if (!patch_entry)
1379 return -1;
1380
1381 fw_info->cmd_hdr->opcode = cpu_to_le16(BTOFF_OPCODE);
1382 fw_info->cmd_hdr->plen = 1;
1383 fw_info->pkt_len = CMD_HDR_LEN + 1;
1384 fw_info->send_pkt[CMD_HDR_LEN] = onoff;
1385
1386 ret_val = send_hci_cmd(fw_info);
1387 if (ret_val < 0) {
1388 RTKBT_ERR("%s: Failed to send bt %s cmd, errno %d",
1389 __func__, onoff != 0 ? "on" : "off", ret_val);
1390 return ret_val;
1391 }
1392
1393 ret_val = rcv_hci_evt(fw_info);
1394 if (ret_val < 0) {
1395 RTKBT_ERR("%s: Failed to receive bt %s event, errno %d",
1396 __func__, onoff != 0 ? "on" : "off", ret_val);
1397 return ret_val;
1398 }
1399
1400 return ret_val;
1401 }
1402
get_fw_table_entry(struct usb_device * udev)1403 static patch_info *get_fw_table_entry(struct usb_device* udev)
1404 {
1405 patch_info *patch_entry = fw_patch_table;
1406 uint16_t vid = le16_to_cpu(udev->descriptor.idVendor);
1407 uint16_t pid = le16_to_cpu(udev->descriptor.idProduct);
1408 uint32_t entry_size = sizeof(fw_patch_table) / sizeof(fw_patch_table[0]);
1409 uint32_t i;
1410
1411 RTKBT_INFO("%s: Product id = 0x%04x, fw table entry size %d", __func__, pid, entry_size);
1412 usb_info = (uint32_t)(vid<<16) | pid;
1413
1414 for (i = 0; i < entry_size; i++, patch_entry++) {
1415 if ((vid == patch_entry->vid)&&(pid == patch_entry->pid))
1416 break;
1417 }
1418
1419 if (i == entry_size) {
1420 RTKBT_ERR("%s: No fw table entry found", __func__);
1421 return NULL;
1422 }
1423
1424 return patch_entry;
1425 }
1426
1427 #if SUSPNED_DW_FW
get_suspend_fw_table_entry(struct usb_device * udev)1428 static patch_info *get_suspend_fw_table_entry(struct usb_device* udev)
1429 {
1430 patch_info *patch_entry = fw_patch_table;
1431 uint16_t vid = le16_to_cpu(udev->descriptor.idVendor);
1432 uint16_t pid = le16_to_cpu(udev->descriptor.idProduct);
1433 uint32_t entry_size = sizeof(fw_patch_table) / sizeof(fw_patch_table[0]);
1434 uint32_t i;
1435
1436 RTKBT_INFO("%s: Product id = 0x%04x, fw table entry size %d", __func__, pid, entry_size);
1437
1438 for (i = 0; i < entry_size; i++, patch_entry++) {
1439 if ((vid == patch_entry->vid)&&(pid == patch_entry->pid))
1440 break;
1441 }
1442
1443 if (i == entry_size) {
1444 RTKBT_ERR("%s: No fw table entry found", __func__);
1445 return NULL;
1446 }
1447
1448 return patch_entry;
1449 }
1450 #endif
1451
get_fw_patch_entry(struct rtk_epatch * epatch_info,uint16_t eco_ver)1452 static struct rtk_epatch_entry *get_fw_patch_entry(struct rtk_epatch *epatch_info, uint16_t eco_ver)
1453 {
1454 int patch_num = epatch_info->number_of_total_patch;
1455 uint8_t *epatch_buf = (uint8_t *)epatch_info;
1456 struct rtk_epatch_entry *p_entry = NULL;
1457 int coex_date;
1458 int coex_ver;
1459 int i;
1460
1461 for (i = 0; i < patch_num; i++) {
1462 if (*(uint16_t *)(epatch_buf + 14 + 2*i) == eco_ver + 1) {
1463 p_entry = kzalloc(sizeof(*p_entry), GFP_KERNEL);
1464 if (!p_entry) {
1465 RTKBT_ERR("%s: Failed to allocate mem for patch entry", __func__);
1466 return NULL;
1467 }
1468 p_entry->chip_id = eco_ver + 1;
1469 p_entry->patch_length = *(uint16_t*)(epatch_buf + 14 + 2*patch_num + 2*i);
1470 p_entry->start_offset = *(uint32_t*)(epatch_buf + 14 + 4*patch_num + 4*i);
1471 p_entry->coex_version = *(uint32_t*)(epatch_buf + p_entry->start_offset + p_entry->patch_length - 12);
1472 p_entry->svn_version = *(uint32_t*)(epatch_buf + p_entry->start_offset + p_entry->patch_length - 8);
1473 p_entry->fw_version = *(uint32_t*)(epatch_buf + p_entry->start_offset + p_entry->patch_length - 4);
1474
1475 coex_date = ((p_entry->coex_version >> 16) & 0x7ff) + ((p_entry->coex_version >> 27) * 10000);
1476 coex_ver = p_entry->coex_version & 0xffff;
1477
1478 RTKBT_INFO("BTCOEX:20%06d-0x%04x svn version:0x%08x fw version:0x%08x rtk_btusb version:%s Cut:%d, patch length:0x%04x, patch offset:0x%08x\n", \
1479 coex_date, coex_ver, p_entry->svn_version, p_entry->fw_version, VERSION, p_entry->chip_id, p_entry->patch_length, p_entry->start_offset);
1480 break;
1481 }
1482 }
1483
1484 return p_entry;
1485 }
1486
1487 /*reset_controller is aimed to reset_bt_fw before updata Fw patch*/
reset_controller(firmware_info * fw_info)1488 int reset_controller(firmware_info* fw_info)
1489 {
1490 int ret_val;
1491 RTKBT_ERR("reset_controller");
1492
1493 if (!fw_info)
1494 return -ENODEV;
1495
1496 fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VENDOR_FORCE_RESET_AND_PATCHABLE);
1497 fw_info->cmd_hdr->plen = 0;
1498 fw_info->pkt_len = CMD_HDR_LEN;
1499 ret_val = send_hci_cmd(fw_info);
1500
1501 if (ret_val < 0) {
1502 RTKBT_ERR("%s: Failed to send hci cmd 0x%04x, errno %d",
1503 __func__, fw_info->cmd_hdr->opcode, ret_val);
1504 return ret_val;
1505 }
1506
1507 //sleep 1s for firmware reset.
1508 msleep(1000);
1509 RTKBT_INFO("%s: Wait fw reset for 1000ms",__func__);
1510
1511 return ret_val;
1512 }
1513 /*reset_controller is aimed to reset_bt_fw before updata Fw patch*/
1514
1515 /*
1516 * check the return value
1517 * 1: need to download fw patch
1518 * 0: no need to download fw patch
1519 * <0: failed to check lmp version
1520 */
check_fw_version(firmware_info * fw_info)1521 int check_fw_version(firmware_info* fw_info)
1522 {
1523 struct hci_rp_read_local_version *read_ver_rsp;
1524 patch_info *patch_entry = NULL;
1525 int ret_val = -1;
1526
1527 fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_OP_READ_LOCAL_VERSION);
1528 fw_info->cmd_hdr->plen = 0;
1529 fw_info->pkt_len = CMD_HDR_LEN;
1530
1531 ret_val = send_hci_cmd(fw_info);
1532 if (ret_val < 0) {
1533 RTKBT_ERR("%s: Failed to send hci cmd 0x%04x, errno %d",
1534 __func__, fw_info->cmd_hdr->opcode, ret_val);
1535 return ret_val;
1536 }
1537
1538 ret_val = rcv_hci_evt(fw_info);
1539 if (ret_val < 0) {
1540 RTKBT_ERR("%s: Failed to receive hci event, errno %d",
1541 __func__, ret_val);
1542 return ret_val;
1543 }
1544
1545 patch_entry = fw_info->patch_entry;
1546 read_ver_rsp = (struct hci_rp_read_local_version *)(fw_info->rsp_para);
1547
1548 RTKBT_INFO("%s: Controller lmp = 0x%04x, patch lmp = 0x%04x, default patch lmp = 0x%04x",
1549 __func__, read_ver_rsp->lmp_subver, patch_entry->lmp_sub, patch_entry->lmp_sub_default);
1550
1551 if (read_ver_rsp->lmp_subver == patch_entry->lmp_sub_default) {
1552 RTKBT_INFO("%s: Cold BT controller startup", __func__);
1553
1554 return 2;
1555
1556 } else if (read_ver_rsp->lmp_subver != patch_entry->lmp_sub) {
1557 RTKBT_INFO("%s: Warm BT controller startup with updated lmp", __func__);
1558 return 1;
1559 } else {
1560 RTKBT_INFO("%s: Warm BT controller startup with same lmp", __func__);
1561 return 0;
1562 }
1563 }
1564
1565 #if SET_WAKEUP_DEVICE
set_wakeup_device(firmware_info * fw_info,uint8_t * wakeup_bdaddr)1566 int set_wakeup_device(firmware_info* fw_info, uint8_t* wakeup_bdaddr)
1567 {
1568 struct rtk_eversion_evt *ever_evt;
1569 int ret_val;
1570
1571 if (!fw_info)
1572 return -ENODEV;
1573
1574 fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VENDOR_ADD_WAKE_UP_DEVICE);
1575 fw_info->cmd_hdr->plen = 7;
1576 memcpy(fw_info->req_para, wakeup_bdaddr, 7);
1577 fw_info->pkt_len = CMD_HDR_LEN + 7;
1578
1579 ret_val = send_hci_cmd(fw_info);
1580 if (ret_val < 0) {
1581 RTKBT_ERR("%s: Failed to send hci cmd 0x%04x, errno %d\n",
1582 __func__, fw_info->cmd_hdr->opcode, ret_val);
1583 return ret_val;
1584 }
1585
1586 ret_val = rcv_hci_evt(fw_info);
1587 if (ret_val < 0) {
1588 RTKBT_ERR("%s: Failed to receive hci event, errno %d\n",__func__, ret_val);
1589 return ret_val;
1590 }
1591
1592 ever_evt = (struct rtk_eversion_evt *)(fw_info->rsp_para);
1593
1594 RTKBT_DBG("%s: status %d, eversion %d", __func__, ever_evt->status, ever_evt->version);
1595 return ret_val;
1596 }
1597 #endif
1598
1599 /*reset_channel to recover the communication between wifi 8192eu with 8761 bt controller in case of geteversion error*/
1600
reset_channel(firmware_info * fw_info)1601 int reset_channel(firmware_info* fw_info)
1602 {
1603 struct rtk_reset_evt *ever_evt;
1604 int ret_val;
1605
1606 if (!fw_info)
1607 return -ENODEV;
1608
1609 fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VENDOR_RESET);
1610 fw_info->cmd_hdr->plen = 0;
1611 fw_info->pkt_len = CMD_HDR_LEN;
1612
1613 ret_val = send_hci_cmd(fw_info);
1614 if (ret_val < 0) {
1615 RTKBT_ERR("%s: Failed to send hci cmd 0x%04x, errno %d",
1616 __func__, fw_info->cmd_hdr->opcode, ret_val);
1617 return ret_val;
1618 }
1619
1620 ret_val = rcv_hci_evt(fw_info);
1621 if (ret_val < 0) {
1622 RTKBT_ERR("%s: Failed to receive hci event, errno %d",
1623 __func__, ret_val);
1624 return ret_val;
1625 }
1626
1627 ever_evt = (struct rtk_reset_evt *)(fw_info->rsp_para);
1628
1629 RTKBT_INFO("%s: status %d ", __func__, ever_evt->status);
1630
1631 //sleep 300ms for channel reset.
1632 msleep(300);
1633 RTKBT_INFO("%s: Wait channel reset for 300ms",__func__);
1634
1635 return ret_val;
1636 }
1637
read_localversion(firmware_info * fw_info)1638 int read_localversion(firmware_info* fw_info)
1639 {
1640 struct rtk_localversion_evt *ever_evt;
1641 int ret_val;
1642
1643 if (!fw_info)
1644 return -ENODEV;
1645
1646 fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VENDOR_READ_LMP_VERISION);
1647 fw_info->cmd_hdr->plen = 0;
1648 fw_info->pkt_len = CMD_HDR_LEN;
1649
1650 ret_val = send_hci_cmd(fw_info);
1651 if (ret_val < 0) {
1652 RTKBT_ERR("%s: Failed to send hci cmd 0x%04x, errno %d",
1653 __func__, fw_info->cmd_hdr->opcode, ret_val);
1654 return ret_val;
1655 }
1656
1657 ret_val = rcv_hci_evt(fw_info);
1658 if (ret_val < 0) {
1659 RTKBT_ERR("%s: Failed to receive hci event, errno %d",
1660 __func__, ret_val);
1661 return ret_val;
1662 }
1663
1664 ever_evt = (struct rtk_localversion_evt *)(fw_info->rsp_para);
1665
1666 RTKBT_INFO("%s: status %d ", __func__, ever_evt->status);
1667 RTKBT_INFO("%s: hci_version %d ", __func__, ever_evt->hci_version);
1668 RTKBT_INFO("%s: hci_revision %d ", __func__, ever_evt->hci_revision);
1669 RTKBT_INFO("%s: lmp_version %d ", __func__, ever_evt->lmp_version);
1670 RTKBT_INFO("%s: lmp_subversion %d ", __func__, ever_evt->lmp_subversion);
1671 RTKBT_INFO("%s: lmp_manufacture %d ", __func__, ever_evt->lmp_manufacture);
1672 //sleep 300ms for channel reset.
1673 msleep(300);
1674 RTKBT_INFO("%s: Wait channel reset for 300ms",__func__);
1675
1676 return ret_val;
1677 }
1678
get_eversion(firmware_info * fw_info)1679 int get_eversion(firmware_info* fw_info)
1680 {
1681 struct rtk_eversion_evt *ever_evt;
1682 int ret_val;
1683
1684 if (!fw_info)
1685 return -ENODEV;
1686
1687 fw_info->cmd_hdr->opcode = cpu_to_le16(HCI_VENDOR_READ_RTK_ROM_VERISION);
1688 fw_info->cmd_hdr->plen = 0;
1689 fw_info->pkt_len = CMD_HDR_LEN;
1690
1691 ret_val = send_hci_cmd(fw_info);
1692 if (ret_val < 0) {
1693 RTKBT_ERR("%s: Failed to send hci cmd 0x%04x, errno %d",
1694 __func__, fw_info->cmd_hdr->opcode, ret_val);
1695 return ret_val;
1696 }
1697
1698 ret_val = rcv_hci_evt(fw_info);
1699 if (ret_val < 0) {
1700 RTKBT_ERR("%s: Failed to receive hci event, errno %d",
1701 __func__, ret_val);
1702 return ret_val;
1703 }
1704
1705 ever_evt = (struct rtk_eversion_evt *)(fw_info->rsp_para);
1706
1707 RTKBT_INFO("%s: status %d, eversion %d", __func__, ever_evt->status, ever_evt->version);
1708
1709 if (ever_evt->status)
1710 fw_info->patch_entry->eversion = 0;
1711 else
1712 fw_info->patch_entry->eversion = ever_evt->version;
1713
1714 return ret_val;
1715 }
1716
rtk_update_altsettings(patch_info * patch_entry,const unsigned char * org_config_buf,int org_config_len,unsigned char ** new_config_buf_ptr,int * new_config_len_ptr)1717 void rtk_update_altsettings(patch_info *patch_entry, const unsigned char* org_config_buf, int org_config_len, unsigned char ** new_config_buf_ptr, int *new_config_len_ptr)
1718 {
1719 static unsigned char config_buf[1024];
1720 unsigned short offset[256];
1721 unsigned char val[256];
1722
1723 struct rtk_bt_vendor_config* config = (struct rtk_bt_vendor_config*) config_buf;
1724 struct rtk_bt_vendor_config_entry* entry = config->entry;
1725
1726 int count = 0,temp = 0, i = 0, j;
1727
1728 memset(config_buf, 0, sizeof(config_buf));
1729 memset(offset, 0, sizeof(offset));
1730 memset(val, 0, sizeof(val));
1731
1732 memcpy(config_buf, org_config_buf, org_config_len);
1733 *new_config_buf_ptr = config_buf;
1734 *new_config_len_ptr = org_config_len;
1735
1736 count = getAltSettings(patch_entry, offset, sizeof(offset)/sizeof(unsigned short));
1737 if(count <= 0){
1738 RTKBT_INFO("rtk_update_altsettings: No AltSettings");
1739 return;
1740 }else{
1741 RTKBT_INFO("rtk_update_altsettings: %d AltSettings", count);
1742 }
1743
1744 RTKBT_INFO("ORG Config len=%08x:\n", org_config_len);
1745 for(i=0;i<=org_config_len;i+=0x10)
1746 {
1747 RTKBT_INFO("%08x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", i, \
1748 config_buf[i], config_buf[i+1], config_buf[i+2], config_buf[i+3], config_buf[i+4], config_buf[i+5], config_buf[i+6], config_buf[i+7], \
1749 config_buf[i+8], config_buf[i+9], config_buf[i+10], config_buf[i+11], config_buf[i+12], config_buf[i+13], config_buf[i+14], config_buf[i+15]);
1750 }
1751
1752 if (config->data_len != org_config_len - sizeof(struct rtk_bt_vendor_config))
1753 {
1754 RTKBT_ERR("rtk_update_altsettings: config len(%x) is not right(%x)", config->data_len, org_config_len-(int)sizeof(struct rtk_bt_vendor_config));
1755 return;
1756 }
1757
1758 for (i=0; i<config->data_len;)
1759 {
1760 for(j = 0; j < count;j++)
1761 {
1762 if(entry->offset == offset[j])
1763 offset[j] = 0;
1764 }
1765 if(getAltSettingVal(patch_entry, entry->offset, val) == entry->entry_len){
1766 RTKBT_INFO("rtk_update_altsettings: replace %04x[%02x]", entry->offset, entry->entry_len);
1767 memcpy(entry->entry_data, val, entry->entry_len);
1768 }
1769 temp = entry->entry_len + sizeof(struct rtk_bt_vendor_config_entry);
1770 i += temp;
1771 entry = (struct rtk_bt_vendor_config_entry*)((uint8_t*)entry + temp);
1772 }
1773 for(j = 0; j < count;j++){
1774 if(offset[j] == 0)
1775 continue;
1776 entry->entry_len = getAltSettingVal(patch_entry, offset[j], val);
1777 if(entry->entry_len <= 0)
1778 continue;
1779 entry->offset = offset[j];
1780 memcpy(entry->entry_data, val, entry->entry_len);
1781 RTKBT_INFO("rtk_update_altsettings: add %04x[%02x]", entry->offset, entry->entry_len);
1782 temp = entry->entry_len + sizeof(struct rtk_bt_vendor_config_entry);
1783 i += temp;
1784 entry = (struct rtk_bt_vendor_config_entry*)((uint8_t*)entry + temp);
1785 }
1786 config->data_len = i;
1787 *new_config_buf_ptr = config_buf;
1788 *new_config_len_ptr = config->data_len+sizeof(struct rtk_bt_vendor_config);
1789
1790 return;
1791 }
1792
load_firmware(firmware_info * fw_info,uint8_t ** buff)1793 int load_firmware(firmware_info *fw_info, uint8_t **buff)
1794 {
1795 const struct firmware *fw, *cfg;
1796 struct usb_device *udev;
1797 patch_info *patch_entry;
1798 char *config_name, *fw_name;
1799 int fw_len = 0;
1800 int ret_val;
1801
1802 int config_len = 0, buf_len = -1;
1803 uint8_t *buf = *buff, *config_file_buf = NULL;
1804 uint8_t *epatch_buf = NULL;
1805
1806 struct rtk_epatch *epatch_info = NULL;
1807 uint8_t need_download_fw = 1;
1808 struct rtk_extension_entry patch_lmp = {0};
1809 struct rtk_epatch_entry *p_epatch_entry = NULL;
1810 uint16_t lmp_version;
1811 //uint8_t use_mp_fw = 0;
1812 RTKBT_DBG("%s: start", __func__);
1813
1814 udev = fw_info->udev;
1815 patch_entry = fw_info->patch_entry;
1816 lmp_version = patch_entry->lmp_sub_default;
1817 config_name = patch_entry->config_name;
1818 /* 1 Mptool Fw; 0 Normal Fw */
1819 if(DRV_MP_MODE == mp_drv_mode){
1820 fw_name = patch_entry->mp_patch_name;
1821 }else{
1822 fw_name = patch_entry->patch_name;
1823 }
1824
1825 RTKBT_INFO("%s: Default lmp version = 0x%04x, config file name[%s], "
1826 "fw file name[%s]", __func__, lmp_version,config_name, fw_name);
1827
1828 ret_val = request_firmware(&cfg, config_name, &udev->dev);
1829 if (ret_val < 0)
1830 config_len = 0;
1831 else {
1832 int i;
1833 rtk_update_altsettings(patch_entry, cfg->data, cfg->size, &config_file_buf, &config_len);
1834
1835 RTKBT_INFO("Final Config len=%08x:\n", config_len);
1836 for(i=0;i<=config_len;i+=0x10)
1837 {
1838 RTKBT_INFO("%08x: %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", i, \
1839 config_file_buf[i], config_file_buf[i+1], config_file_buf[i+2], config_file_buf[i+3], config_file_buf[i+4], config_file_buf[i+5], config_file_buf[i+6], config_file_buf[i+7], \
1840 config_file_buf[i+8], config_file_buf[i+9], config_file_buf[i+10], config_file_buf[i+11], config_file_buf[i+12], config_file_buf[i+13], config_file_buf[i+14], config_file_buf[i+15]);
1841 }
1842
1843 release_firmware(cfg);
1844 }
1845
1846 ret_val = request_firmware(&fw, fw_name, &udev->dev);
1847 if (ret_val < 0)
1848 goto fw_fail;
1849 else {
1850 epatch_buf = vmalloc(fw->size);
1851 RTKBT_INFO("%s: epatch_buf = vmalloc(fw->size, GFP_KERNEL)", __func__);
1852 if (!epatch_buf) {
1853 release_firmware(fw);
1854 goto fw_fail;
1855 }
1856 memcpy(epatch_buf, fw->data, fw->size);
1857 fw_len = fw->size;
1858 buf_len = fw_len + config_len;
1859 release_firmware(fw);
1860 }
1861
1862 if (lmp_version == ROM_LMP_8723a) {
1863 RTKBT_DBG("%s: 8723a -> use old style patch", __func__);
1864 if (!memcmp(epatch_buf, RTK_EPATCH_SIGNATURE, 8)) {
1865 RTKBT_ERR("%s: 8723a check signature error", __func__);
1866 need_download_fw = 0;
1867 } else {
1868 if (!(buf = kzalloc(buf_len, GFP_KERNEL))) {
1869 RTKBT_ERR("%s: Failed to allocate mem for fw&config", __func__);
1870 buf_len = -1;
1871 } else {
1872 RTKBT_DBG("%s: 8723a -> fw copy directly", __func__);
1873 memcpy(buf, epatch_buf, buf_len);
1874 patch_entry->lmp_sub = *(uint16_t *)(buf + buf_len - config_len - 4);
1875 RTKBT_DBG("%s: Config lmp version = 0x%04x", __func__,
1876 patch_entry->lmp_sub);
1877 vfree(epatch_buf);
1878 RTKBT_INFO("%s:ROM_LMP_8723a vfree(epatch_buf)", __func__);
1879 epatch_buf = NULL;
1880 if (config_len)
1881 memcpy(buf + buf_len - config_len, config_file_buf, config_len);
1882 }
1883 }
1884 } else {
1885 RTKBT_DBG("%s: Not 8723a -> use new style patch", __func__);
1886
1887 RTKBT_DBG("%s: reset_channel before get_eversion from bt controller", __func__);
1888 ret_val = reset_channel(fw_info);
1889 if (ret_val < 0) {
1890 RTKBT_ERR("%s: Failed to reset_channel, errno %d", __func__, ret_val);
1891 goto fw_fail;
1892 }
1893 // read_localversion(fw_info);
1894 RTKBT_DBG("%s: get_eversion from bt controller", __func__);
1895
1896 ret_val = get_eversion(fw_info);
1897 if (ret_val < 0) {
1898 RTKBT_ERR("%s: Failed to get eversion, errno %d", __func__, ret_val);
1899 goto fw_fail;
1900 }
1901 RTKBT_DBG("%s: Get eversion =%d", __func__, patch_entry->eversion);
1902 if (memcmp(epatch_buf + buf_len - config_len - 4 , EXTENSION_SECTION_SIGNATURE, 4)) {
1903 RTKBT_ERR("%s: Failed to check extension section signature", __func__);
1904 need_download_fw = 0;
1905 } else {
1906 uint8_t *temp;
1907 temp = epatch_buf+buf_len-config_len - 5;
1908 do {
1909 if (*temp == 0x00) {
1910 patch_lmp.opcode = *temp;
1911 patch_lmp.length = *(temp-1);
1912 if ((patch_lmp.data = kzalloc(patch_lmp.length, GFP_KERNEL))) {
1913 int k;
1914 for (k = 0; k < patch_lmp.length; k++) {
1915 *(patch_lmp.data+k) = *(temp-2-k);
1916 RTKBT_DBG("data = 0x%x", *(patch_lmp.data+k));
1917 }
1918 }
1919 RTKBT_DBG("%s: opcode = 0x%x, length = 0x%x, data = 0x%x", __func__,
1920 patch_lmp.opcode, patch_lmp.length, *(patch_lmp.data));
1921 break;
1922 }
1923 temp -= *(temp-1) + 2;
1924 } while (*temp != 0xFF);
1925
1926 if (lmp_version != project_id[*(patch_lmp.data)]) {
1927 RTKBT_ERR("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x "
1928 "-> not match", __func__, lmp_version, *(patch_lmp.data),project_id[*(patch_lmp.data)]);
1929 if (patch_lmp.data)
1930 kfree(patch_lmp.data);
1931 need_download_fw = 0;
1932 } else {
1933 RTKBT_INFO("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x "
1934 "-> match", __func__, lmp_version, *(patch_lmp.data), project_id[*(patch_lmp.data)]);
1935 if (patch_lmp.data)
1936 kfree(patch_lmp.data);
1937 if (memcmp(epatch_buf, RTK_EPATCH_SIGNATURE, 8)) {
1938 RTKBT_ERR("%s: Check signature error", __func__);
1939 need_download_fw = 0;
1940 } else {
1941 epatch_info = (struct rtk_epatch*)epatch_buf;
1942 patch_entry->lmp_sub = (uint16_t)epatch_info->fw_version;
1943
1944 RTKBT_DBG("%s: lmp version 0x%04x, fw_version 0x%x, "
1945 "number_of_total_patch %d", __func__,
1946 patch_entry->lmp_sub, epatch_info->fw_version,
1947 epatch_info->number_of_total_patch);
1948
1949 /* Get right epatch entry */
1950 p_epatch_entry = get_fw_patch_entry(epatch_info, patch_entry->eversion);
1951 if (p_epatch_entry == NULL) {
1952 RTKBT_WARN("%s: Failed to get fw patch entry", __func__);
1953 ret_val = -1;
1954 goto fw_fail ;
1955 }
1956
1957 buf_len = p_epatch_entry->patch_length + config_len;
1958 RTKBT_DBG("buf_len = 0x%x", buf_len);
1959
1960 if (!(buf = kzalloc(buf_len, GFP_KERNEL))) {
1961 RTKBT_ERR("%s: Can't alloc memory for fw&config", __func__);
1962 buf_len = -1;
1963 } else {
1964 memcpy(buf, &epatch_buf[p_epatch_entry->start_offset], p_epatch_entry->patch_length);
1965 memcpy(&buf[p_epatch_entry->patch_length-4], &epatch_info->fw_version, 4);
1966 kfree(p_epatch_entry);
1967 }
1968 vfree(epatch_buf);
1969 RTKBT_INFO("%s: vfree(epatch_buf)", __func__);
1970 epatch_buf = NULL;
1971
1972 if (config_len)
1973 memcpy(&buf[buf_len - config_len], config_file_buf, config_len);
1974 }
1975 }
1976 }
1977 }
1978
1979 RTKBT_INFO("%s: fw%s exists, config file%s exists", __func__,
1980 (buf_len > 0) ? "" : " not", (config_len > 0) ? "":" not");
1981
1982 if (buf && buf_len > 0 && need_download_fw)
1983 *buff = buf;
1984
1985 RTKBT_DBG("%s: done", __func__);
1986
1987 return buf_len;
1988
1989 fw_fail:
1990 return ret_val;
1991 }
1992
1993 #if SUSPNED_DW_FW
load_suspend_firmware(firmware_info * fw_info,uint8_t ** buff)1994 static int load_suspend_firmware(firmware_info *fw_info, uint8_t **buff)
1995 {
1996 const struct firmware *fw, *cfg;
1997 struct usb_device *udev;
1998 patch_info *patch_entry;
1999 char config_name[100] = {0};
2000 char fw_name[100] = {0};
2001 int fw_len = 0;
2002 int ret_val;
2003
2004 int config_len = 0, buf_len = -1;
2005 uint8_t *buf = *buff, *config_file_buf = NULL;
2006 uint8_t *epatch_buf = NULL;
2007
2008 struct rtk_epatch *epatch_info = NULL;
2009 uint8_t need_download_fw = 1;
2010 struct rtk_extension_entry patch_lmp = {0};
2011 struct rtk_epatch_entry *p_epatch_entry = NULL;
2012 uint16_t lmp_version;
2013 RTKBT_DBG("%s: start", __func__);
2014
2015 udev = fw_info->udev;
2016 patch_entry = fw_info->patch_entry;
2017 lmp_version = patch_entry->lmp_sub_default;
2018 sprintf(config_name, "%s_suspend", patch_entry->config_name);
2019 sprintf(fw_name, "%s_suspend", patch_entry->patch_name);
2020
2021 RTKBT_INFO("%s: Default lmp version = 0x%04x, config file name[%s], "
2022 "fw file name[%s]", __func__, lmp_version,config_name, fw_name);
2023
2024 ret_val = request_firmware(&cfg, config_name, &udev->dev);
2025 if (ret_val < 0)
2026 config_len = 0;
2027 else {
2028 config_file_buf = vmalloc(cfg->size);
2029 RTKBT_INFO("%s: epatch_buf = vmalloc(cfg->size)", __func__);
2030 if (!config_file_buf)
2031 return -ENOMEM;
2032 memcpy(config_file_buf, cfg->data, cfg->size);
2033 config_len = cfg->size;
2034 release_firmware(cfg);
2035 }
2036
2037 ret_val = request_firmware(&fw, fw_name, &udev->dev);
2038 if (ret_val < 0)
2039 goto fw_fail;
2040 else {
2041 epatch_buf = vmalloc(fw->size);
2042 RTKBT_INFO("%s: epatch_buf = vmalloc(fw->size, GFP_KERNEL)", __func__);
2043 if (!epatch_buf) {
2044 release_firmware(fw);
2045 goto fw_fail;
2046 }
2047 memcpy(epatch_buf, fw->data, fw->size);
2048 fw_len = fw->size;
2049 buf_len = fw_len + config_len;
2050 release_firmware(fw);
2051 }
2052
2053 RTKBT_DBG("%s: Not 8723a -> use new style patch", __func__);
2054
2055 RTKBT_DBG("%s: get_eversion from bt controller", __func__);
2056
2057 ret_val = get_eversion(fw_info);
2058 if (ret_val < 0) {
2059 RTKBT_ERR("%s: Failed to get eversion, errno %d", __func__, ret_val);
2060 goto fw_fail;
2061 }
2062 RTKBT_DBG("%s: Get eversion =%d", __func__, patch_entry->eversion);
2063 if (memcmp(epatch_buf + buf_len - config_len - 4 , EXTENSION_SECTION_SIGNATURE, 4)) {
2064 RTKBT_ERR("%s: Failed to check extension section signature", __func__);
2065 need_download_fw = 0;
2066 } else {
2067 uint8_t *temp;
2068 temp = epatch_buf+buf_len-config_len - 5;
2069 do {
2070 if (*temp == 0x00) {
2071 patch_lmp.opcode = *temp;
2072 patch_lmp.length = *(temp-1);
2073 if ((patch_lmp.data = kzalloc(patch_lmp.length, GFP_KERNEL))) {
2074 int k;
2075 for (k = 0; k < patch_lmp.length; k++) {
2076 *(patch_lmp.data+k) = *(temp-2-k);
2077 RTKBT_DBG("data = 0x%x", *(patch_lmp.data+k));
2078 }
2079 }
2080 RTKBT_DBG("%s: opcode = 0x%x, length = 0x%x, data = 0x%x", __func__,
2081 patch_lmp.opcode, patch_lmp.length, *(patch_lmp.data));
2082 break;
2083 }
2084 temp -= *(temp-1) + 2;
2085 } while (*temp != 0xFF);
2086
2087 if (lmp_version != project_id[*(patch_lmp.data)]) {
2088 RTKBT_ERR("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x "
2089 "-> not match", __func__, lmp_version, *(patch_lmp.data),project_id[*(patch_lmp.data)]);
2090 if (patch_lmp.data)
2091 kfree(patch_lmp.data);
2092 need_download_fw = 0;
2093 } else {
2094 RTKBT_INFO("%s: Default lmp_version 0x%04x, project_id[%d] 0x%04x "
2095 "-> match", __func__, lmp_version, *(patch_lmp.data), project_id[*(patch_lmp.data)]);
2096 if (patch_lmp.data)
2097 kfree(patch_lmp.data);
2098 if (memcmp(epatch_buf, RTK_EPATCH_SIGNATURE, 8)) {
2099 RTKBT_ERR("%s: Check signature error", __func__);
2100 need_download_fw = 0;
2101 } else {
2102 epatch_info = (struct rtk_epatch*)epatch_buf;
2103 patch_entry->lmp_sub = (uint16_t)epatch_info->fw_version;
2104
2105 RTKBT_DBG("%s: lmp version 0x%04x, fw_version 0x%x, "
2106 "number_of_total_patch %d", __func__,
2107 patch_entry->lmp_sub, epatch_info->fw_version,
2108 epatch_info->number_of_total_patch);
2109
2110 /* Get right epatch entry */
2111 p_epatch_entry = get_fw_patch_entry(epatch_info, patch_entry->eversion);
2112 if (p_epatch_entry == NULL) {
2113 RTKBT_WARN("%s: Failed to get fw patch entry", __func__);
2114 ret_val = -1;
2115 goto fw_fail ;
2116 }
2117
2118 buf_len = p_epatch_entry->patch_length + config_len;
2119 RTKBT_DBG("buf_len = 0x%x", buf_len);
2120
2121 if (!(buf = kzalloc(buf_len, GFP_KERNEL))) {
2122 RTKBT_ERR("%s: Can't alloc memory for fw&config", __func__);
2123 buf_len = -1;
2124 } else {
2125 memcpy(buf, &epatch_buf[p_epatch_entry->start_offset], p_epatch_entry->patch_length);
2126 memcpy(&buf[p_epatch_entry->patch_length-4], &epatch_info->fw_version, 4);
2127 kfree(p_epatch_entry);
2128 }
2129 vfree(epatch_buf);
2130 RTKBT_INFO("%s: vfree(epatch_buf)", __func__);
2131 epatch_buf = NULL;
2132
2133 if (config_len)
2134 memcpy(&buf[buf_len - config_len], config_file_buf, config_len);
2135 }
2136 }
2137 }
2138
2139 if (config_file_buf){
2140 vfree(config_file_buf);
2141 config_file_buf = NULL;
2142 RTKBT_INFO("%s: vfree(config_file_buf)", __func__);
2143 }
2144
2145 RTKBT_INFO("%s: fw%s exists, config file%s exists", __func__,
2146 (buf_len > 0) ? "" : " not", (config_len > 0) ? "":" not");
2147
2148 if (buf && buf_len > 0 && need_download_fw)
2149 *buff = buf;
2150
2151 RTKBT_DBG("%s: done", __func__);
2152
2153 return buf_len;
2154
2155 fw_fail:
2156 if (config_file_buf){
2157 vfree(config_file_buf);
2158 config_file_buf = NULL;
2159 }
2160 RTKBT_INFO("%s: fw_fail vfree(config_file_buf)", __func__);
2161 return ret_val;
2162 }
2163 #endif
2164
get_firmware(firmware_info * fw_info,int cached)2165 int get_firmware(firmware_info *fw_info, int cached)
2166 {
2167 patch_info *patch_entry = fw_info->patch_entry;
2168
2169 RTKBT_INFO("%s: start, cached %d,patch_entry->fw_len= %d", __func__, cached,patch_entry->fw_len);
2170
2171 if (cached > 0) {
2172 if (patch_entry->fw_len > 0) {
2173 fw_info->fw_data = kzalloc(patch_entry->fw_len, GFP_KERNEL);
2174 if (!fw_info->fw_data)
2175 return -ENOMEM;
2176 memcpy(fw_info->fw_data, patch_entry->fw_cache, patch_entry->fw_len);
2177 fw_info->fw_len = patch_entry->fw_len;
2178 } else {
2179 fw_info->fw_len = load_firmware(fw_info, &fw_info->fw_data);
2180 if (fw_info->fw_len <= 0)
2181 return -1;
2182 }
2183 } else {
2184 fw_info->fw_len = load_firmware(fw_info, &fw_info->fw_data);
2185 if (fw_info->fw_len <= 0)
2186 return -1;
2187 }
2188
2189 return 0;
2190 }
2191
2192 #if SUSPNED_DW_FW
get_suspend_firmware(firmware_info * fw_info,int cached)2193 static int get_suspend_firmware(firmware_info *fw_info, int cached)
2194 {
2195 patch_info *patch_entry = fw_info->patch_entry;
2196
2197 RTKBT_INFO("%s: start, cached %d,patch_entry->fw_len= %d", __func__, cached,patch_entry->fw_len);
2198
2199 if (cached > 0) {
2200 if (patch_entry->fw_len > 0) {
2201 fw_info->fw_data = kzalloc(patch_entry->fw_len, GFP_KERNEL);
2202 if (!fw_info->fw_data)
2203 return -ENOMEM;
2204 memcpy(fw_info->fw_data, patch_entry->fw_cache, patch_entry->fw_len);
2205 fw_info->fw_len = patch_entry->fw_len;
2206 } else {
2207 fw_info->fw_len = load_suspend_firmware(fw_info, &fw_info->fw_data);
2208 if (fw_info->fw_len <= 0)
2209 return -1;
2210 }
2211 } else {
2212 fw_info->fw_len = load_suspend_firmware(fw_info, &fw_info->fw_data);
2213 if (fw_info->fw_len <= 0)
2214 return -1;
2215 }
2216
2217 return 0;
2218 }
2219 #endif
2220
2221 /*
2222 * Open the log message only if in debugging,
2223 * or it will decelerate download procedure.
2224 */
download_data(firmware_info * fw_info)2225 int download_data(firmware_info *fw_info)
2226 {
2227 download_cp *cmd_para;
2228 download_rp *evt_para;
2229 uint8_t *pcur;
2230 int pkt_len, frag_num, frag_len;
2231 int i, ret_val;
2232 int ncmd = 1, step = 1;
2233
2234 RTKBT_DBG("%s: start", __func__);
2235
2236 cmd_para = (download_cp *)fw_info->req_para;
2237 evt_para = (download_rp *)fw_info->rsp_para;
2238 pcur = fw_info->fw_data;
2239 pkt_len = CMD_HDR_LEN + sizeof(download_cp);
2240 frag_num = fw_info->fw_len / PATCH_SEG_MAX + 1;
2241 frag_len = PATCH_SEG_MAX;
2242
2243 for (i = 0; i < frag_num; i++) {
2244 cmd_para->index = i?((i-1)%0x7f+1):0;
2245 if (i == (frag_num - 1)) {
2246 cmd_para->index |= DATA_END;
2247 frag_len = fw_info->fw_len % PATCH_SEG_MAX;
2248 pkt_len -= (PATCH_SEG_MAX - frag_len);
2249 }
2250 fw_info->cmd_hdr->opcode = cpu_to_le16(DOWNLOAD_OPCODE);
2251 fw_info->cmd_hdr->plen = sizeof(uint8_t) + frag_len;
2252 fw_info->pkt_len = pkt_len;
2253 memcpy(cmd_para->data, pcur, frag_len);
2254
2255 if (step > 0) {
2256 ret_val = send_hci_cmd(fw_info);
2257 if (ret_val < 0) {
2258 RTKBT_DBG("%s: Failed to send frag num %d", __func__, cmd_para->index);
2259 return ret_val;
2260 } else
2261 RTKBT_DBG("%s: Send frag num %d", __func__, cmd_para->index);
2262
2263 if (--step > 0 && i < frag_num - 1) {
2264 RTKBT_DBG("%s: Continue to send frag num %d", __func__, cmd_para->index + 1);
2265 pcur += PATCH_SEG_MAX;
2266 continue;
2267 }
2268 }
2269
2270 while (ncmd > 0) {
2271 ret_val = rcv_hci_evt(fw_info);
2272 if (ret_val < 0) {
2273 RTKBT_ERR("%s: rcv_hci_evt err %d", __func__, ret_val);
2274 return ret_val;
2275 } else {
2276 RTKBT_DBG("%s: Receive acked frag num %d", __func__, evt_para->index);
2277 ncmd--;
2278 }
2279
2280 if (0 != evt_para->status) {
2281 RTKBT_ERR("%s: Receive acked frag num %d, err status %d",
2282 __func__, ret_val, evt_para->status);
2283 return -1;
2284 }
2285
2286 if ((evt_para->index & DATA_END) || (evt_para->index == frag_num - 1)) {
2287 RTKBT_DBG("%s: Receive last acked index %d", __func__, evt_para->index);
2288 goto end;
2289 }
2290 }
2291
2292 ncmd = step = fw_info->cmd_cmp->ncmd;
2293 pcur += PATCH_SEG_MAX;
2294 RTKBT_DBG("%s: HCI command packet num %d", __func__, ncmd);
2295 }
2296
2297 /*
2298 * It is tricky that Host cannot receive DATA_END index from BT
2299 * controller, at least for 8723au. We are doomed if failed.
2300 */
2301 #if 0
2302 /* Continue to receive the responsed events until last index occurs */
2303 if (i == frag_num) {
2304 RTKBT_DBG("%s: total frag count %d", __func__, frag_num);
2305 while (!(evt_para->index & DATA_END)) {
2306 ret_val = rcv_hci_evt(fw_info);
2307 if (ret_val < 0) {
2308 RTKBT_ERR("%s: rcv_hci_evt err %d", __func__, ret_val);
2309 return ret_val;
2310 }
2311 if (0 != evt_para->status)
2312 return -1;
2313 RTKBT_DBG("%s: continue to receive acked frag num %d", __func__, evt_para->index);
2314 }
2315 }
2316 #endif
2317 end:
2318 RTKBT_INFO("%s: done, sent %d frag pkts, received %d frag events",
2319 __func__, cmd_para->index, evt_para->index);
2320 return fw_info->fw_len;
2321 }
2322
download_patch(firmware_info * fw_info,int cached)2323 int download_patch(firmware_info *fw_info, int cached)
2324 {
2325 int ret_val = 0;
2326
2327 RTKBT_DBG("%s: Download fw patch start, cached %d", __func__, cached);
2328
2329 if (!fw_info || !fw_info->patch_entry) {
2330 RTKBT_ERR("%s: No patch entry exists(fw_info %p)", __func__, fw_info);
2331 ret_val = -1;
2332 goto end;
2333 }
2334
2335 /*
2336 * step1: get local firmware if existed
2337 * step2: check firmware version
2338 * step3: download firmware if updated
2339 */
2340 ret_val = get_firmware(fw_info, cached);
2341 if (ret_val < 0) {
2342 RTKBT_ERR("%s: Failed to get firmware", __func__);
2343 goto end;
2344 }
2345
2346 #if SUSPNED_DW_FW
2347 if(fw_info_4_suspend) {
2348 RTKBT_DBG("%s: get suspend fw first cached %d", __func__, cached);
2349 ret_val = get_suspend_firmware(fw_info_4_suspend, cached);
2350 if (ret_val < 0) {
2351 RTKBT_ERR("%s: Failed to get suspend firmware", __func__);
2352 goto end;
2353 }
2354 }
2355 #endif
2356
2357 /*check the length of fw to be download*/
2358 RTKBT_DBG("%s: Check fw_info->fw_len:%d max_patch_size %d", __func__, fw_info->fw_len, fw_info->patch_entry->max_patch_size);
2359 if (fw_info->fw_len > fw_info->patch_entry->max_patch_size) {
2360 RTKBT_ERR("%s: Total length of fw&config(%08x) larger than max_patch_size 0x%08x", __func__, fw_info->fw_len, fw_info->patch_entry->max_patch_size);
2361 ret_val = -1;
2362 goto free;
2363 }
2364
2365 ret_val = check_fw_version(fw_info);
2366
2367 if (2 == ret_val) {
2368 RTKBT_ERR("%s: Cold reset bt chip only download", __func__);
2369 ret_val = download_data(fw_info);
2370 if (ret_val > 0)
2371 RTKBT_ERR("%s: Download fw patch done, fw len %d", __func__, ret_val);
2372 } else if(1 == ret_val){
2373 // reset bt chip to update Fw patch
2374 ret_val = reset_controller(fw_info);
2375 RTKBT_ERR("%s: reset bt chip to update Fw patch, fw len %d", __func__, ret_val);
2376 ret_val = download_data(fw_info);
2377 if (ret_val > 0)
2378 RTKBT_ERR("%s: Download fw patch done, fw len %d", __func__, ret_val);
2379 }
2380
2381
2382 free:
2383 /* Free fw data after download finished */
2384 kfree(fw_info->fw_data);
2385 fw_info->fw_data = NULL;
2386
2387 end:
2388 return ret_val;
2389 }
2390
2391 #if SUSPNED_DW_FW
download_suspend_patch(firmware_info * fw_info,int cached)2392 static int download_suspend_patch(firmware_info *fw_info, int cached)
2393 {
2394 int ret_val = 0;
2395
2396 RTKBT_DBG("%s: Download fw patch start, cached %d", __func__, cached);
2397
2398 if (!fw_info || !fw_info->patch_entry) {
2399 RTKBT_ERR("%s: No patch entry exists(fw_info %p)", __func__, fw_info);
2400 ret_val = -1;
2401 goto end;
2402 }
2403
2404 /*check the length of fw to be download*/
2405 RTKBT_DBG("%s:Check RTK_PATCH_LENGTH fw_info->fw_len:%d", __func__,fw_info->fw_len);
2406 if (fw_info->fw_len > RTK_PATCH_LENGTH_MAX || fw_info->fw_len == 0) {
2407 RTKBT_ERR("%s: Total length of fw&config larger than allowed 24K or no fw len:%d", __func__, fw_info->fw_len);
2408 ret_val = -1;
2409 goto free;
2410 }
2411
2412 ret_val = check_fw_version(fw_info);
2413
2414 if (2 == ret_val) {
2415 RTKBT_ERR("%s: Cold reset bt chip only download", __func__);
2416 ret_val = download_data(fw_info);
2417 if (ret_val > 0)
2418 RTKBT_ERR("%s: Download fw patch done, fw len %d", __func__, ret_val);
2419 } else if(1 == ret_val){
2420 // reset bt chip to update Fw patch
2421 ret_val = reset_controller(fw_info);
2422 RTKBT_ERR("%s: reset bt chip to update Fw patch, fw len %d", __func__, ret_val);
2423 ret_val = download_data(fw_info);
2424 if (ret_val > 0)
2425 RTKBT_ERR("%s: Download fw patch done, fw len %d", __func__, ret_val);
2426 }
2427
2428
2429 free:
2430 /* Free fw data after download finished */
2431 kfree(fw_info->fw_data);
2432 fw_info->fw_data = NULL;
2433
2434 end:
2435 return ret_val;
2436 }
2437
suspend_firmware_info_init(firmware_info * fw_info)2438 static void suspend_firmware_info_init(firmware_info *fw_info)
2439 {
2440 RTKBT_DBG("%s: start", __func__);
2441 if(!fw_info)
2442 return;
2443
2444 fw_info_4_suspend= kzalloc(sizeof(*fw_info), GFP_KERNEL);
2445 if (!fw_info_4_suspend)
2446 goto error;
2447
2448 fw_info_4_suspend->send_pkt = kzalloc(PKT_LEN, GFP_KERNEL);
2449 if (!fw_info_4_suspend->send_pkt) {
2450 kfree(fw_info_4_suspend);
2451 goto error;
2452 }
2453
2454 fw_info_4_suspend->rcv_pkt = kzalloc(PKT_LEN, GFP_KERNEL);
2455 if (!fw_info_4_suspend->rcv_pkt) {
2456 kfree(fw_info_4_suspend->send_pkt);
2457 kfree(fw_info_4_suspend);
2458 goto error;
2459 }
2460
2461 fw_info_4_suspend->patch_entry = get_suspend_fw_table_entry(fw_info->udev);
2462 if (!fw_info_4_suspend->patch_entry) {
2463 kfree(fw_info_4_suspend->rcv_pkt);
2464 kfree(fw_info_4_suspend->send_pkt);
2465 kfree(fw_info_4_suspend);
2466 goto error;
2467 }
2468
2469 fw_info_4_suspend->intf = fw_info->intf;
2470 fw_info_4_suspend->udev = fw_info->udev;
2471 fw_info_4_suspend->cmd_hdr = (struct hci_command_hdr *)(fw_info_4_suspend->send_pkt);
2472 fw_info_4_suspend->evt_hdr = (struct hci_event_hdr *)(fw_info_4_suspend->rcv_pkt);
2473 fw_info_4_suspend->cmd_cmp = (struct hci_ev_cmd_complete *)(fw_info_4_suspend->rcv_pkt + EVT_HDR_LEN);
2474 fw_info_4_suspend->req_para = fw_info_4_suspend->send_pkt + CMD_HDR_LEN;
2475 fw_info_4_suspend->rsp_para = fw_info_4_suspend->rcv_pkt + EVT_HDR_LEN + CMD_CMP_LEN;
2476 fw_info_4_suspend->pipe_in = fw_info->pipe_in;
2477 fw_info_4_suspend->pipe_out = fw_info->pipe_out;
2478
2479 return;
2480 error:
2481 RTKBT_DBG("%s: fail !", __func__);
2482 fw_info_4_suspend = NULL;
2483 return;
2484 }
2485 #endif
2486
2487 #if SET_WAKEUP_DEVICE
set_wakeup_device_from_conf(firmware_info * fw_info)2488 static void set_wakeup_device_from_conf(firmware_info *fw_info)
2489 {
2490 uint8_t paired_wakeup_bdaddr[7];
2491 uint8_t num = 0;
2492 int i;
2493 struct file *fp;
2494 mm_segment_t fs;
2495 loff_t pos;
2496
2497 memset(paired_wakeup_bdaddr, 0, 7);
2498 fp = filp_open(SET_WAKEUP_DEVICE_CONF, O_RDWR, 0);
2499 if (!IS_ERR(fp)) {
2500 fs = get_fs();
2501 set_fs(KERNEL_DS);
2502 pos = 0;
2503 //read number
2504 vfs_read(fp, &num, 1, &pos);
2505 RTKBT_DBG("read number = %d", num);
2506 if(num) {
2507 for(i = 0; i < num; i++) {
2508 vfs_read(fp, paired_wakeup_bdaddr, 7, &pos);
2509 RTKBT_DBG("paired_wakeup_bdaddr: 0x%02x:0x%02x:0x%02x:0x%02x:0x%02x:0x%02x",
2510 paired_wakeup_bdaddr[1],paired_wakeup_bdaddr[2],paired_wakeup_bdaddr[3],
2511 paired_wakeup_bdaddr[4],paired_wakeup_bdaddr[5],paired_wakeup_bdaddr[6]);
2512 set_wakeup_device(fw_info, paired_wakeup_bdaddr);
2513 }
2514 }
2515 filp_close(fp, NULL);
2516 set_fs(fs);
2517 }
2518 else {
2519 RTKBT_ERR("open wakeup config file fail! errno = %ld", PTR_ERR(fp));
2520 }
2521 }
2522 #endif
2523
firmware_info_init(struct usb_interface * intf)2524 firmware_info *firmware_info_init(struct usb_interface *intf)
2525 {
2526 struct usb_device *udev = interface_to_usbdev(intf);
2527 firmware_info *fw_info;
2528
2529 RTKBT_DBG("%s: start", __func__);
2530
2531 fw_info = kzalloc(sizeof(*fw_info), GFP_KERNEL);
2532 if (!fw_info)
2533 return NULL;
2534
2535 fw_info->send_pkt = kzalloc(PKT_LEN, GFP_KERNEL);
2536 if (!fw_info->send_pkt) {
2537 kfree(fw_info);
2538 return NULL;
2539 }
2540
2541 fw_info->rcv_pkt = kzalloc(PKT_LEN, GFP_KERNEL);
2542 if (!fw_info->rcv_pkt) {
2543 kfree(fw_info->send_pkt);
2544 kfree(fw_info);
2545 return NULL;
2546 }
2547
2548 fw_info->patch_entry = get_fw_table_entry(udev);
2549 if (!fw_info->patch_entry) {
2550 kfree(fw_info->rcv_pkt);
2551 kfree(fw_info->send_pkt);
2552 kfree(fw_info);
2553 return NULL;
2554 }
2555
2556 fw_info->intf = intf;
2557 fw_info->udev = udev;
2558 fw_info->pipe_in = usb_rcvintpipe(fw_info->udev, INTR_EP);
2559 fw_info->pipe_out = usb_sndctrlpipe(fw_info->udev, CTRL_EP);
2560 fw_info->cmd_hdr = (struct hci_command_hdr *)(fw_info->send_pkt);
2561 fw_info->evt_hdr = (struct hci_event_hdr *)(fw_info->rcv_pkt);
2562 fw_info->cmd_cmp = (struct hci_ev_cmd_complete *)(fw_info->rcv_pkt + EVT_HDR_LEN);
2563 fw_info->req_para = fw_info->send_pkt + CMD_HDR_LEN;
2564 fw_info->rsp_para = fw_info->rcv_pkt + EVT_HDR_LEN + CMD_CMP_LEN;
2565
2566 #if SUSPNED_DW_FW
2567 suspend_firmware_info_init(fw_info);
2568 #endif
2569
2570 #if BTUSB_RPM
2571 RTKBT_INFO("%s: Auto suspend is enabled", __func__);
2572 usb_enable_autosuspend(udev);
2573 pm_runtime_set_autosuspend_delay(&(udev->dev), 2000);
2574 #else
2575 RTKBT_INFO("%s: Auto suspend is disabled", __func__);
2576 usb_disable_autosuspend(udev);
2577 #endif
2578
2579 #if BTUSB_WAKEUP_HOST
2580 device_wakeup_enable(&udev->dev);
2581 #endif
2582
2583 return fw_info;
2584 }
2585
firmware_info_destroy(struct usb_interface * intf)2586 void firmware_info_destroy(struct usb_interface *intf)
2587 {
2588 firmware_info *fw_info;
2589 struct usb_device *udev;
2590 struct btusb_data *data;
2591
2592 udev = interface_to_usbdev(intf);
2593 data = usb_get_intfdata(intf);
2594
2595 fw_info = data->fw_info;
2596 if (!fw_info)
2597 return;
2598
2599 #if BTUSB_RPM
2600 usb_disable_autosuspend(udev);
2601 #endif
2602
2603 /*
2604 * In order to reclaim fw data mem, we free fw_data immediately
2605 * after download patch finished instead of here.
2606 */
2607 kfree(fw_info->rcv_pkt);
2608 kfree(fw_info->send_pkt);
2609 kfree(fw_info);
2610
2611 #if SUSPNED_DW_FW
2612 if (!fw_info_4_suspend)
2613 return;
2614
2615 kfree(fw_info_4_suspend->rcv_pkt);
2616 kfree(fw_info_4_suspend->send_pkt);
2617 kfree(fw_info_4_suspend);
2618 fw_info_4_suspend = NULL;
2619 #endif
2620 }
2621
2622 static struct usb_driver btusb_driver;
2623
2624 static struct usb_device_id btusb_table[] = {
2625 { .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2626 USB_DEVICE_ID_MATCH_INT_INFO,
2627 .idVendor = 0x0bda,
2628 .bInterfaceClass = 0xe0,
2629 .bInterfaceSubClass = 0x01,
2630 .bInterfaceProtocol = 0x01 },
2631
2632 { .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2633 USB_DEVICE_ID_MATCH_INT_INFO,
2634 .idVendor = 0x13d3,
2635 .bInterfaceClass = 0xe0,
2636 .bInterfaceSubClass = 0x01,
2637 .bInterfaceProtocol = 0x01 },
2638
2639 { }
2640 };
2641
2642 MODULE_DEVICE_TABLE(usb, btusb_table);
2643
inc_tx(struct btusb_data * data)2644 static int inc_tx(struct btusb_data *data)
2645 {
2646 unsigned long flags;
2647 int rv;
2648
2649 spin_lock_irqsave(&data->txlock, flags);
2650 rv = test_bit(BTUSB_SUSPENDING, &data->flags);
2651 if (!rv)
2652 data->tx_in_flight++;
2653 spin_unlock_irqrestore(&data->txlock, flags);
2654
2655 return rv;
2656 }
2657
check_sco_event(struct urb * urb)2658 void check_sco_event(struct urb *urb)
2659 {
2660 u8* opcode = (u8*)(urb->transfer_buffer);
2661 u8 status;
2662 uint16_t handle;
2663 struct hci_dev *hdev = urb->context;
2664 struct btusb_data *data = GET_DRV_DATA(hdev);
2665
2666 switch (*opcode) {
2667 case HCI_EV_SYNC_CONN_COMPLETE:
2668 RTKBT_INFO("%s: HCI_EV_SYNC_CONN_COMPLETE(0x%02x)", __func__, *opcode);
2669 status = *(opcode + 2);
2670 data->sco_handle = *(opcode + 3) | *(opcode + 4) << 8;
2671 //hdev->voice_setting = *(uint16_t*)&opcode[15];
2672 if (status == 0) {
2673 hdev->conn_hash.sco_num++;
2674 hdev->notify(hdev, 0);
2675 }
2676 break;
2677 case HCI_EV_DISCONN_COMPLETE:
2678 status = *(opcode + 2);
2679 handle = *(opcode + 3) | *(opcode + 4) << 8;
2680 if (status == 0 && data->sco_handle == handle) {
2681 RTKBT_INFO("%s: SCO HCI_EV_DISCONN_COMPLETE(0x%02x)", __func__, *opcode);
2682 hdev->conn_hash.sco_num--;
2683 hdev->notify(hdev, 0);
2684 data->sco_handle = 0;
2685 }
2686 break;
2687 default:
2688 RTKBT_DBG("%s: event 0x%02x", __func__, *opcode);
2689 break;
2690 }
2691 }
2692
btusb_intr_complete(struct urb * urb)2693 static void btusb_intr_complete(struct urb *urb)
2694 {
2695 struct hci_dev *hdev = urb->context;
2696 struct btusb_data *data = GET_DRV_DATA(hdev);
2697 int err;
2698
2699 RTKBT_DBG("%s: urb %p status %d count %d ", __func__,
2700 urb, urb->status, urb->actual_length);
2701
2702 #ifdef CONFIG_SCO_OVER_HCI
2703 check_sco_event(urb);
2704 #endif
2705
2706 if (!test_bit(HCI_RUNNING, &hdev->flags))
2707 return;
2708
2709
2710 if (urb->status == 0) {
2711 hdev->stat.byte_rx += urb->actual_length;
2712
2713 if (hci_recv_fragment(hdev, HCI_EVENT_PKT,
2714 urb->transfer_buffer,
2715 urb->actual_length) < 0) {
2716 RTKBT_ERR("%s: Corrupted event packet", __func__);
2717 hdev->stat.err_rx++;
2718 }
2719 }
2720 /* Avoid suspend failed when usb_kill_urb */
2721 else if(urb->status == -ENOENT) {
2722 return;
2723 }
2724
2725
2726 if (!test_bit(BTUSB_INTR_RUNNING, &data->flags))
2727 return;
2728
2729 usb_mark_last_busy(data->udev);
2730 usb_anchor_urb(urb, &data->intr_anchor);
2731
2732 err = usb_submit_urb(urb, GFP_ATOMIC);
2733 if (err < 0) {
2734 /* EPERM: urb is being killed;
2735 * ENODEV: device got disconnected */
2736 if (err != -EPERM && err != -ENODEV)
2737 RTKBT_ERR("%s: Failed to re-submit urb %p, err %d",
2738 __func__, urb, err);
2739 usb_unanchor_urb(urb);
2740 }
2741 }
2742
btusb_submit_intr_urb(struct hci_dev * hdev,gfp_t mem_flags)2743 static int btusb_submit_intr_urb(struct hci_dev *hdev, gfp_t mem_flags)
2744 {
2745 struct btusb_data *data = GET_DRV_DATA(hdev);
2746 struct urb *urb;
2747 unsigned char *buf;
2748 unsigned int pipe;
2749 int err, size;
2750
2751 if (!data->intr_ep)
2752 return -ENODEV;
2753
2754 urb = usb_alloc_urb(0, mem_flags);
2755 if (!urb)
2756 return -ENOMEM;
2757
2758 size = le16_to_cpu(data->intr_ep->wMaxPacketSize);
2759
2760 buf = kmalloc(size, mem_flags);
2761 if (!buf) {
2762 usb_free_urb(urb);
2763 return -ENOMEM;
2764 }
2765
2766 RTKBT_DBG("%s: mMaxPacketSize %d, bEndpointAddress 0x%02x",
2767 __func__, size, data->intr_ep->bEndpointAddress);
2768
2769 pipe = usb_rcvintpipe(data->udev, data->intr_ep->bEndpointAddress);
2770
2771 usb_fill_int_urb(urb, data->udev, pipe, buf, size,
2772 btusb_intr_complete, hdev,
2773 data->intr_ep->bInterval);
2774
2775 urb->transfer_flags |= URB_FREE_BUFFER;
2776
2777 usb_anchor_urb(urb, &data->intr_anchor);
2778
2779 err = usb_submit_urb(urb, mem_flags);
2780 if (err < 0) {
2781 RTKBT_ERR("%s: Failed to submit urb %p, err %d",
2782 __func__, urb, err);
2783 usb_unanchor_urb(urb);
2784 }
2785
2786 usb_free_urb(urb);
2787
2788 return err;
2789 }
2790
btusb_bulk_complete(struct urb * urb)2791 static void btusb_bulk_complete(struct urb *urb)
2792 {
2793 struct hci_dev *hdev = urb->context;
2794 struct btusb_data *data = GET_DRV_DATA(hdev);
2795 int err;
2796
2797 RTKBT_DBG("%s: urb %p status %d count %d",
2798 __func__, urb, urb->status, urb->actual_length);
2799
2800 if (!test_bit(HCI_RUNNING, &hdev->flags))
2801 return;
2802
2803 if (urb->status == 0) {
2804 hdev->stat.byte_rx += urb->actual_length;
2805
2806 if (hci_recv_fragment(hdev, HCI_ACLDATA_PKT,
2807 urb->transfer_buffer,
2808 urb->actual_length) < 0) {
2809 RTKBT_ERR("%s: Corrupted ACL packet", __func__);
2810 hdev->stat.err_rx++;
2811 }
2812 }
2813 /* Avoid suspend failed when usb_kill_urb */
2814 else if(urb->status == -ENOENT) {
2815 return;
2816 }
2817
2818
2819 if (!test_bit(BTUSB_BULK_RUNNING, &data->flags))
2820 return;
2821
2822 usb_anchor_urb(urb, &data->bulk_anchor);
2823 usb_mark_last_busy(data->udev);
2824
2825 err = usb_submit_urb(urb, GFP_ATOMIC);
2826 if (err < 0) {
2827 /* -EPERM: urb is being killed;
2828 * -ENODEV: device got disconnected */
2829 if (err != -EPERM && err != -ENODEV)
2830 RTKBT_ERR("btusb_bulk_complete %s urb %p failed to resubmit (%d)",
2831 hdev->name, urb, -err);
2832 usb_unanchor_urb(urb);
2833 }
2834 }
2835
btusb_submit_bulk_urb(struct hci_dev * hdev,gfp_t mem_flags)2836 static int btusb_submit_bulk_urb(struct hci_dev *hdev, gfp_t mem_flags)
2837 {
2838 struct btusb_data *data = GET_DRV_DATA(hdev);
2839 struct urb *urb;
2840 unsigned char *buf;
2841 unsigned int pipe;
2842 int err, size = HCI_MAX_FRAME_SIZE;
2843
2844 RTKBT_DBG("%s: hdev name %s", __func__, hdev->name);
2845
2846 if (!data->bulk_rx_ep)
2847 return -ENODEV;
2848
2849 urb = usb_alloc_urb(0, mem_flags);
2850 if (!urb)
2851 return -ENOMEM;
2852
2853 buf = kmalloc(size, mem_flags);
2854 if (!buf) {
2855 usb_free_urb(urb);
2856 return -ENOMEM;
2857 }
2858
2859 pipe = usb_rcvbulkpipe(data->udev, data->bulk_rx_ep->bEndpointAddress);
2860
2861 usb_fill_bulk_urb(urb, data->udev, pipe,
2862 buf, size, btusb_bulk_complete, hdev);
2863
2864 urb->transfer_flags |= URB_FREE_BUFFER;
2865
2866 usb_mark_last_busy(data->udev);
2867 usb_anchor_urb(urb, &data->bulk_anchor);
2868
2869 err = usb_submit_urb(urb, mem_flags);
2870 if (err < 0) {
2871 RTKBT_ERR("%s: Failed to submit urb %p, err %d", __func__, urb, err);
2872 usb_unanchor_urb(urb);
2873 }
2874
2875 usb_free_urb(urb);
2876
2877 return err;
2878 }
2879
btusb_isoc_complete(struct urb * urb)2880 static void btusb_isoc_complete(struct urb *urb)
2881 {
2882 struct hci_dev *hdev = urb->context;
2883 struct btusb_data *data = GET_DRV_DATA(hdev);
2884 int i, err;
2885
2886
2887 RTKBT_DBG("%s: urb %p status %d count %d",
2888 __func__, urb, urb->status, urb->actual_length);
2889
2890 if (!test_bit(HCI_RUNNING, &hdev->flags))
2891 return;
2892
2893 if (urb->status == 0) {
2894 for (i = 0; i < urb->number_of_packets; i++) {
2895 unsigned int offset = urb->iso_frame_desc[i].offset;
2896 unsigned int length = urb->iso_frame_desc[i].actual_length;
2897
2898 if (urb->iso_frame_desc[i].status)
2899 continue;
2900
2901 hdev->stat.byte_rx += length;
2902
2903 if (hci_recv_fragment(hdev, HCI_SCODATA_PKT,
2904 urb->transfer_buffer + offset,
2905 length) < 0) {
2906 RTKBT_ERR("%s: Corrupted SCO packet", __func__);
2907 hdev->stat.err_rx++;
2908 }
2909 }
2910 }
2911 /* Avoid suspend failed when usb_kill_urb */
2912 else if(urb->status == -ENOENT) {
2913 return;
2914 }
2915
2916
2917 if (!test_bit(BTUSB_ISOC_RUNNING, &data->flags))
2918 return;
2919
2920 usb_anchor_urb(urb, &data->isoc_anchor);
2921 i = 0;
2922 retry:
2923 err = usb_submit_urb(urb, GFP_ATOMIC);
2924 if (err < 0) {
2925 /* -EPERM: urb is being killed;
2926 * -ENODEV: device got disconnected */
2927 if (err != -EPERM && err != -ENODEV)
2928 RTKBT_ERR("%s: Failed to re-sumbit urb %p, retry %d, err %d",
2929 __func__, urb, i, err);
2930 if (i < 10) {
2931 i++;
2932 mdelay(1);
2933 goto retry;
2934 }
2935
2936 usb_unanchor_urb(urb);
2937 }
2938 }
2939
fill_isoc_descriptor(struct urb * urb,int len,int mtu)2940 static inline void fill_isoc_descriptor(struct urb *urb, int len, int mtu)
2941 {
2942 int i, offset = 0;
2943
2944 RTKBT_DBG("%s: len %d mtu %d", __func__, len, mtu);
2945
2946 for (i = 0; i < BTUSB_MAX_ISOC_FRAMES && len >= mtu;
2947 i++, offset += mtu, len -= mtu) {
2948 urb->iso_frame_desc[i].offset = offset;
2949 urb->iso_frame_desc[i].length = mtu;
2950 }
2951
2952 if (len && i < BTUSB_MAX_ISOC_FRAMES) {
2953 urb->iso_frame_desc[i].offset = offset;
2954 urb->iso_frame_desc[i].length = len;
2955 i++;
2956 }
2957
2958 urb->number_of_packets = i;
2959 }
2960
btusb_submit_isoc_urb(struct hci_dev * hdev,gfp_t mem_flags)2961 static int btusb_submit_isoc_urb(struct hci_dev *hdev, gfp_t mem_flags)
2962 {
2963 struct btusb_data *data = GET_DRV_DATA(hdev);
2964 struct urb *urb;
2965 unsigned char *buf;
2966 unsigned int pipe;
2967 int err, size;
2968
2969 if (!data->isoc_rx_ep)
2970 return -ENODEV;
2971
2972 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, mem_flags);
2973 if (!urb)
2974 return -ENOMEM;
2975
2976 size = le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize) *
2977 BTUSB_MAX_ISOC_FRAMES;
2978
2979 buf = kmalloc(size, mem_flags);
2980 if (!buf) {
2981 usb_free_urb(urb);
2982 return -ENOMEM;
2983 }
2984
2985 pipe = usb_rcvisocpipe(data->udev, data->isoc_rx_ep->bEndpointAddress);
2986
2987 urb->dev = data->udev;
2988 urb->pipe = pipe;
2989 urb->context = hdev;
2990 urb->complete = btusb_isoc_complete;
2991 urb->interval = data->isoc_rx_ep->bInterval;
2992
2993 urb->transfer_flags = URB_FREE_BUFFER | URB_ISO_ASAP;
2994 urb->transfer_buffer = buf;
2995 urb->transfer_buffer_length = size;
2996
2997 fill_isoc_descriptor(urb, size,
2998 le16_to_cpu(data->isoc_rx_ep->wMaxPacketSize));
2999
3000 usb_anchor_urb(urb, &data->isoc_anchor);
3001
3002 err = usb_submit_urb(urb, mem_flags);
3003 if (err < 0) {
3004 RTKBT_ERR("%s: Failed to submit urb %p, err %d", __func__, urb, err);
3005 usb_unanchor_urb(urb);
3006 }
3007
3008 usb_free_urb(urb);
3009
3010 return err;
3011 }
3012
btusb_tx_complete(struct urb * urb)3013 static void btusb_tx_complete(struct urb *urb)
3014 {
3015 struct sk_buff *skb = urb->context;
3016 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
3017 struct btusb_data *data = GET_DRV_DATA(hdev);
3018
3019 if (!test_bit(HCI_RUNNING, &hdev->flags))
3020 goto done;
3021
3022 if (!urb->status)
3023 hdev->stat.byte_tx += urb->transfer_buffer_length;
3024 else
3025 hdev->stat.err_tx++;
3026
3027 done:
3028 spin_lock(&data->txlock);
3029 data->tx_in_flight--;
3030 spin_unlock(&data->txlock);
3031
3032 kfree(urb->setup_packet);
3033
3034 kfree_skb(skb);
3035 }
3036
btusb_isoc_tx_complete(struct urb * urb)3037 static void btusb_isoc_tx_complete(struct urb *urb)
3038 {
3039 struct sk_buff *skb = urb->context;
3040 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
3041
3042 RTKBT_DBG("%s: urb %p status %d count %d",
3043 __func__, urb, urb->status, urb->actual_length);
3044
3045 if (skb && hdev) {
3046 if (!test_bit(HCI_RUNNING, &hdev->flags))
3047 goto done;
3048
3049 if (!urb->status)
3050 hdev->stat.byte_tx += urb->transfer_buffer_length;
3051 else
3052 hdev->stat.err_tx++;
3053 } else
3054 RTKBT_ERR("%s: skb 0x%p hdev 0x%p", __func__, skb, hdev);
3055
3056 done:
3057 kfree(urb->setup_packet);
3058
3059 kfree_skb(skb);
3060 }
3061
btusb_open(struct hci_dev * hdev)3062 static int btusb_open(struct hci_dev *hdev)
3063 {
3064 struct btusb_data *data = GET_DRV_DATA(hdev);
3065 int err = 0;
3066
3067 RTKBT_INFO("%s: Start, PM usage count %d", __func__,
3068 atomic_read(&(data->intf->pm_usage_cnt)));
3069
3070 err = usb_autopm_get_interface(data->intf);
3071 if (err < 0)
3072 return err;
3073
3074 data->intf->needs_remote_wakeup = 1;
3075
3076 if (test_and_set_bit(HCI_RUNNING, &hdev->flags))
3077 goto done;
3078
3079 if (test_and_set_bit(BTUSB_INTR_RUNNING, &data->flags))
3080 goto done;
3081
3082 err = btusb_submit_intr_urb(hdev, GFP_KERNEL);
3083 if (err < 0)
3084 goto failed;
3085
3086 err = btusb_submit_bulk_urb(hdev, GFP_KERNEL);
3087 if (err < 0) {
3088 mdelay(URB_CANCELING_DELAY_MS);
3089 usb_kill_anchored_urbs(&data->intr_anchor);
3090 goto failed;
3091 }
3092
3093 set_bit(BTUSB_BULK_RUNNING, &data->flags);
3094 btusb_submit_bulk_urb(hdev, GFP_KERNEL);
3095
3096 done:
3097 usb_autopm_put_interface(data->intf);
3098 RTKBT_INFO("%s: End, PM usage count %d", __func__,
3099 atomic_read(&(data->intf->pm_usage_cnt)));
3100 return 0;
3101
3102 failed:
3103 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
3104 clear_bit(HCI_RUNNING, &hdev->flags);
3105 usb_autopm_put_interface(data->intf);
3106 RTKBT_ERR("%s: Failed, PM usage count %d", __func__,
3107 atomic_read(&(data->intf->pm_usage_cnt)));
3108 return err;
3109 }
3110
btusb_stop_traffic(struct btusb_data * data)3111 static void btusb_stop_traffic(struct btusb_data *data)
3112 {
3113 mdelay(URB_CANCELING_DELAY_MS);
3114 usb_kill_anchored_urbs(&data->intr_anchor);
3115 usb_kill_anchored_urbs(&data->bulk_anchor);
3116 usb_kill_anchored_urbs(&data->isoc_anchor);
3117 }
3118
btusb_close(struct hci_dev * hdev)3119 static int btusb_close(struct hci_dev *hdev)
3120 {
3121 struct btusb_data *data = GET_DRV_DATA(hdev);
3122 int i, err;
3123
3124 RTKBT_INFO("%s: hci running %lu", __func__, hdev->flags & HCI_RUNNING);
3125
3126 if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
3127 return 0;
3128
3129 for (i = 0; i < NUM_REASSEMBLY; i++) {
3130 if (hdev->reassembly[i]) {
3131 RTKBT_DBG("%s: free ressembly[%d]", __func__, i);
3132 kfree_skb(hdev->reassembly[i]);
3133 hdev->reassembly[i] = NULL;
3134 }
3135 }
3136
3137 cancel_work_sync(&data->work);
3138 cancel_work_sync(&data->waker);
3139
3140 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
3141 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
3142 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
3143
3144 btusb_stop_traffic(data);
3145 err = usb_autopm_get_interface(data->intf);
3146 if (err < 0)
3147 goto failed;
3148
3149 data->intf->needs_remote_wakeup = 0;
3150 usb_autopm_put_interface(data->intf);
3151
3152 failed:
3153 mdelay(URB_CANCELING_DELAY_MS);
3154 usb_scuttle_anchored_urbs(&data->deferred);
3155 return 0;
3156 }
3157
btusb_flush(struct hci_dev * hdev)3158 static int btusb_flush(struct hci_dev *hdev)
3159 {
3160 struct btusb_data *data = GET_DRV_DATA(hdev);
3161
3162 RTKBT_DBG("%s", __func__);
3163
3164 mdelay(URB_CANCELING_DELAY_MS);
3165 usb_kill_anchored_urbs(&data->tx_anchor);
3166
3167 return 0;
3168 }
3169
3170 #ifdef CONFIG_SCO_OVER_HCI
3171 static void btusb_isoc_snd_tx_complete(struct urb *urb);
3172
snd_send_sco_frame(struct sk_buff * skb)3173 static int snd_send_sco_frame(struct sk_buff *skb)
3174 {
3175 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
3176
3177 struct btusb_data *data = GET_DRV_DATA(hdev);
3178 //struct usb_ctrlrequest *dr;
3179 struct urb *urb;
3180 unsigned int pipe;
3181 int err;
3182
3183 RTKBT_DBG("%s:pkt type %d, packet_len : %d",
3184 __func__,bt_cb(skb)->pkt_type, skb->len);
3185
3186 if (!hdev && !test_bit(HCI_RUNNING, &hdev->flags))
3187 return -EBUSY;
3188
3189 if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1) {
3190 kfree(skb);
3191 return -ENODEV;
3192 }
3193
3194 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);
3195 if (!urb) {
3196 RTKBT_ERR("%s: Failed to allocate mem for sco pkts", __func__);
3197 kfree(skb);
3198 return -ENOMEM;
3199 }
3200
3201 pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress);
3202
3203 usb_fill_int_urb(urb, data->udev, pipe,
3204 skb->data, skb->len, btusb_isoc_snd_tx_complete,
3205 skb, data->isoc_tx_ep->bInterval);
3206
3207 urb->transfer_flags = URB_ISO_ASAP;
3208
3209 fill_isoc_descriptor(urb, skb->len,
3210 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
3211
3212 hdev->stat.sco_tx++;
3213
3214 usb_anchor_urb(urb, &data->tx_anchor);
3215
3216 err = usb_submit_urb(urb, GFP_ATOMIC);
3217 if (err < 0) {
3218 RTKBT_ERR("%s: Failed to submit urb %p, pkt type %d, err %d",
3219 __func__, urb, bt_cb(skb)->pkt_type, err);
3220 kfree(urb->setup_packet);
3221 usb_unanchor_urb(urb);
3222 } else
3223 usb_mark_last_busy(data->udev);
3224 usb_free_urb(urb);
3225
3226 return err;
3227
3228 }
3229
snd_copy_send_sco_data(RTK_sco_card_t * pSCOSnd)3230 static bool snd_copy_send_sco_data( RTK_sco_card_t *pSCOSnd)
3231 {
3232 struct snd_pcm_runtime *runtime = pSCOSnd->playback.substream->runtime;
3233 unsigned int frame_bytes = 2, frames1;
3234 const u8 *source;
3235
3236 snd_pcm_uframes_t period_size = runtime->period_size;
3237 int i, count;
3238 u8 buffer[period_size * 3];
3239 int sco_packet_bytes = pSCOSnd->playback.sco_packet_bytes;
3240 struct sk_buff *skb;
3241
3242 count = frames_to_bytes(runtime, period_size)/sco_packet_bytes;
3243 skb = bt_skb_alloc(((sco_packet_bytes + HCI_SCO_HDR_SIZE) * count), GFP_ATOMIC);
3244 skb->dev = (void *)hci_dev_get(0);
3245 bt_cb(skb)->pkt_type = HCI_SCODATA_PKT;
3246 skb_put(skb, ((sco_packet_bytes + HCI_SCO_HDR_SIZE) * count));
3247 if(!skb)
3248 return false;
3249
3250 RTKBT_DBG("%s, buffer_pos: %d", __FUNCTION__, pSCOSnd->playback.buffer_pos);
3251
3252 source = runtime->dma_area + pSCOSnd->playback.buffer_pos * frame_bytes;
3253
3254 if (pSCOSnd->playback.buffer_pos + period_size <= runtime->buffer_size) {
3255 memcpy(buffer, source, period_size * frame_bytes);
3256 } else {
3257 /* wrap around at end of ring buffer */
3258 frames1 = runtime->buffer_size - pSCOSnd->playback.buffer_pos;
3259 memcpy(buffer, source, frames1 * frame_bytes);
3260 memcpy(&buffer[frames1 * frame_bytes],
3261 runtime->dma_area, (period_size - frames1) * frame_bytes);
3262 }
3263
3264 pSCOSnd->playback.buffer_pos += period_size;
3265 if ( pSCOSnd->playback.buffer_pos >= runtime->buffer_size)
3266 pSCOSnd->playback.buffer_pos -= runtime->buffer_size;
3267
3268 for(i = 0; i < count; i++) {
3269 *((__u16 *)(skb->data + i * (sco_packet_bytes + HCI_SCO_HDR_SIZE))) = pSCOSnd->usb_data->sco_handle;
3270 *((__u8 *)(skb->data + i*(sco_packet_bytes + HCI_SCO_HDR_SIZE) + 2)) = sco_packet_bytes;
3271 memcpy((skb->data + i * (sco_packet_bytes + HCI_SCO_HDR_SIZE) + HCI_SCO_HDR_SIZE),
3272 &buffer[sco_packet_bytes * i], sco_packet_bytes);
3273 }
3274
3275 if(test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)) {
3276 snd_pcm_period_elapsed(pSCOSnd->playback.substream);
3277 }
3278 snd_send_sco_frame(skb);
3279 return true;
3280 }
3281
btusb_isoc_snd_tx_complete(struct urb * urb)3282 static void btusb_isoc_snd_tx_complete(struct urb *urb)
3283 {
3284 struct sk_buff *skb = urb->context;
3285 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
3286 struct btusb_data *data = GET_DRV_DATA(hdev);
3287 RTK_sco_card_t *pSCOSnd = data->pSCOSnd;
3288
3289 RTKBT_DBG("%s: status %d count %d",
3290 __func__,urb->status, urb->actual_length);
3291
3292 if (skb && hdev) {
3293 if (!test_bit(HCI_RUNNING, &hdev->flags))
3294 goto done;
3295
3296 if (!urb->status)
3297 hdev->stat.byte_tx += urb->transfer_buffer_length;
3298 else
3299 hdev->stat.err_tx++;
3300 } else
3301 RTKBT_ERR("%s: skb 0x%p hdev 0x%p", __func__, skb, hdev);
3302
3303 done:
3304 kfree(urb->setup_packet);
3305 kfree_skb(skb);
3306 if(test_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states)){
3307 snd_copy_send_sco_data(pSCOSnd);
3308 //schedule_work(&pSCOSnd->send_sco_work);
3309 }
3310 }
3311
playback_work(struct work_struct * work)3312 static void playback_work(struct work_struct *work)
3313 {
3314 RTK_sco_card_t *pSCOSnd = container_of(work, RTK_sco_card_t, send_sco_work);
3315
3316 snd_copy_send_sco_data(pSCOSnd);
3317 }
3318
3319 #endif
3320
btusb_send_frame(struct sk_buff * skb)3321 static int btusb_send_frame(struct sk_buff *skb)
3322 {
3323 struct hci_dev *hdev = (struct hci_dev *) skb->dev;
3324
3325 struct btusb_data *data = GET_DRV_DATA(hdev);
3326 struct usb_ctrlrequest *dr;
3327 struct urb *urb;
3328 unsigned int pipe;
3329 int err;
3330 int retries = 0;
3331
3332 RTKBT_DBG("%s: hdev %p, btusb data %p, pkt type %d",
3333 __func__, hdev, data, bt_cb(skb)->pkt_type);
3334
3335 if (!test_bit(HCI_RUNNING, &hdev->flags))
3336 return -EBUSY;
3337
3338
3339
3340 switch (bt_cb(skb)->pkt_type) {
3341 case HCI_COMMAND_PKT:
3342 print_command(skb);
3343 urb = usb_alloc_urb(0, GFP_ATOMIC);
3344 if (!urb)
3345 return -ENOMEM;
3346
3347 dr = kmalloc(sizeof(*dr), GFP_ATOMIC);
3348 if (!dr) {
3349 usb_free_urb(urb);
3350 return -ENOMEM;
3351 }
3352
3353 dr->bRequestType = data->cmdreq_type;
3354 dr->bRequest = 0;
3355 dr->wIndex = 0;
3356 dr->wValue = 0;
3357 dr->wLength = __cpu_to_le16(skb->len);
3358
3359 pipe = usb_sndctrlpipe(data->udev, 0x00);
3360
3361 usb_fill_control_urb(urb, data->udev, pipe, (void *) dr,
3362 skb->data, skb->len, btusb_tx_complete, skb);
3363
3364 hdev->stat.cmd_tx++;
3365 break;
3366
3367 case HCI_ACLDATA_PKT:
3368 print_acl(skb, 1);
3369 if (!data->bulk_tx_ep)
3370 return -ENODEV;
3371
3372 urb = usb_alloc_urb(0, GFP_ATOMIC);
3373 if (!urb)
3374 return -ENOMEM;
3375
3376 pipe = usb_sndbulkpipe(data->udev,
3377 data->bulk_tx_ep->bEndpointAddress);
3378
3379 usb_fill_bulk_urb(urb, data->udev, pipe,
3380 skb->data, skb->len, btusb_tx_complete, skb);
3381
3382 hdev->stat.acl_tx++;
3383 break;
3384
3385 case HCI_SCODATA_PKT:
3386 print_sco(skb, 1);
3387 if (!data->isoc_tx_ep || hdev->conn_hash.sco_num < 1) {
3388 kfree(skb);
3389 return -ENODEV;
3390 }
3391
3392 urb = usb_alloc_urb(BTUSB_MAX_ISOC_FRAMES, GFP_ATOMIC);
3393 if (!urb) {
3394 RTKBT_ERR("%s: Failed to allocate mem for sco pkts", __func__);
3395 kfree(skb);
3396 return -ENOMEM;
3397 }
3398
3399 pipe = usb_sndisocpipe(data->udev, data->isoc_tx_ep->bEndpointAddress);
3400
3401 usb_fill_int_urb(urb, data->udev, pipe,
3402 skb->data, skb->len, btusb_isoc_tx_complete,
3403 skb, data->isoc_tx_ep->bInterval);
3404
3405 urb->transfer_flags = URB_ISO_ASAP;
3406
3407 fill_isoc_descriptor(urb, skb->len,
3408 le16_to_cpu(data->isoc_tx_ep->wMaxPacketSize));
3409
3410 hdev->stat.sco_tx++;
3411 goto skip_waking;
3412
3413 default:
3414 return -EILSEQ;
3415 }
3416
3417 err = inc_tx(data);
3418 if (err) {
3419 usb_anchor_urb(urb, &data->deferred);
3420 schedule_work(&data->waker);
3421 err = 0;
3422 goto done;
3423 }
3424
3425 skip_waking:
3426 usb_anchor_urb(urb, &data->tx_anchor);
3427 retry:
3428 err = usb_submit_urb(urb, GFP_ATOMIC);
3429 if (err < 0) {
3430 RTKBT_ERR("%s: Failed to submit urb %p, pkt type %d, err %d, retries %d",
3431 __func__, urb, bt_cb(skb)->pkt_type, err, retries);
3432 if ((bt_cb(skb)->pkt_type != HCI_SCODATA_PKT) && (retries < 10)) {
3433 mdelay(1);
3434
3435 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT)
3436 print_error_command(skb);
3437 retries++;
3438 goto retry;
3439 }
3440 kfree(urb->setup_packet);
3441 usb_unanchor_urb(urb);
3442 } else
3443 usb_mark_last_busy(data->udev);
3444 usb_free_urb(urb);
3445
3446 done:
3447 return err;
3448 }
3449
3450 #if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 4, 0)
btusb_destruct(struct hci_dev * hdev)3451 static void btusb_destruct(struct hci_dev *hdev)
3452 {
3453 struct btusb_data *data = GET_DRV_DATA(hdev);
3454
3455 RTKBT_DBG("%s: name %s", __func__, hdev->name);
3456
3457 kfree(data);
3458 }
3459 #endif
3460
btusb_notify(struct hci_dev * hdev,unsigned int evt)3461 static void btusb_notify(struct hci_dev *hdev, unsigned int evt)
3462 {
3463 struct btusb_data *data = GET_DRV_DATA(hdev);
3464
3465 RTKBT_DBG("%s: name %s, evt %d", __func__, hdev->name, evt);
3466
3467 RTKBT_INFO("%s: hdev->conn_hash.sco_num= %d, data->sco_num = %d", __func__, hdev->conn_hash.sco_num,
3468 data->sco_num);
3469 if (hdev->conn_hash.sco_num != data->sco_num) {
3470 data->sco_num = hdev->conn_hash.sco_num;
3471 schedule_work(&data->work);
3472 }
3473 }
3474
set_isoc_interface(struct hci_dev * hdev,int altsetting)3475 static inline int set_isoc_interface(struct hci_dev *hdev, int altsetting)
3476 {
3477 struct btusb_data *data = GET_DRV_DATA(hdev);
3478 struct usb_interface *intf = data->isoc;
3479 struct usb_endpoint_descriptor *ep_desc;
3480 int i, err;
3481
3482 if (!data->isoc)
3483 return -ENODEV;
3484
3485 err = usb_set_interface(data->udev, 1, altsetting);
3486 if (err < 0) {
3487 RTKBT_ERR("%s: Failed to set interface, altsetting %d, err %d",
3488 __func__, altsetting, err);
3489 return err;
3490 }
3491
3492 data->isoc_altsetting = altsetting;
3493
3494 data->isoc_tx_ep = NULL;
3495 data->isoc_rx_ep = NULL;
3496
3497 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
3498 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
3499
3500 if (!data->isoc_tx_ep && usb_endpoint_is_isoc_out(ep_desc)) {
3501 data->isoc_tx_ep = ep_desc;
3502 continue;
3503 }
3504
3505 if (!data->isoc_rx_ep && usb_endpoint_is_isoc_in(ep_desc)) {
3506 data->isoc_rx_ep = ep_desc;
3507 continue;
3508 }
3509 }
3510
3511 if (!data->isoc_tx_ep || !data->isoc_rx_ep) {
3512 RTKBT_ERR("%s: Invalid SCO descriptors", __func__);
3513 return -ENODEV;
3514 }
3515
3516 return 0;
3517 }
3518
check_controller_support_msbc(struct usb_device * udev)3519 static int check_controller_support_msbc( struct usb_device *udev)
3520 {
3521 //fix this in the future,when new card support msbc decode and encode
3522 RTKBT_INFO("%s:pid = 0x%02x, vid = 0x%02x",__func__,udev->descriptor.idProduct, udev->descriptor.idVendor);
3523 switch (udev->descriptor.idProduct) {
3524
3525 default:
3526 return 0;
3527 }
3528 return 0;
3529 }
3530
btusb_work(struct work_struct * work)3531 static void btusb_work(struct work_struct *work)
3532 {
3533 struct btusb_data *data = container_of(work, struct btusb_data, work);
3534 struct hci_dev *hdev = data->hdev;
3535
3536 int err;
3537 int new_alts;
3538 if (data->sco_num > 0) {
3539 if (!test_bit(BTUSB_DID_ISO_RESUME, &data->flags)) {
3540 err = usb_autopm_get_interface(data->isoc ? data->isoc : data->intf);
3541 if (err < 0) {
3542 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
3543 mdelay(URB_CANCELING_DELAY_MS);
3544 usb_kill_anchored_urbs(&data->isoc_anchor);
3545 return;
3546 }
3547
3548 set_bit(BTUSB_DID_ISO_RESUME, &data->flags);
3549 }
3550
3551 RTKBT_INFO("%s voice settings = 0x%04x", __func__, hdev->voice_setting);
3552 if (!(hdev->voice_setting & 0x0003)) {
3553 if(data->sco_num == 1)
3554 new_alts = 2;
3555 else {
3556 RTKBT_ERR("%s: we don't support mutiple sco link for cvsd", __func__);
3557 return;
3558 }
3559 } else{
3560 if(check_controller_support_msbc(data->udev)) {
3561 if(data->sco_num == 1)
3562 new_alts = 4;
3563 else {
3564 RTKBT_ERR("%s: we don't support mutiple sco link for msbc", __func__);
3565 return;
3566 }
3567 } else {
3568 new_alts = 2;
3569 }
3570 }
3571 if (data->isoc_altsetting != new_alts) {
3572
3573 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
3574 mdelay(URB_CANCELING_DELAY_MS);
3575 usb_kill_anchored_urbs(&data->isoc_anchor);
3576
3577 if (set_isoc_interface(hdev, new_alts) < 0)
3578 return;
3579 }
3580
3581 if (!test_and_set_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
3582 if (btusb_submit_isoc_urb(hdev, GFP_KERNEL) < 0)
3583 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
3584 else
3585 btusb_submit_isoc_urb(hdev, GFP_KERNEL);
3586 }
3587 #ifdef CONFIG_SCO_OVER_HCI
3588 if(test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
3589 set_bit(USB_CAPTURE_RUNNING, &data->pSCOSnd->states);
3590 set_bit(USB_PLAYBACK_RUNNING, &data->pSCOSnd->states);
3591 }
3592 #endif
3593 } else {
3594 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
3595 #ifdef CONFIG_SCO_OVER_HCI
3596 clear_bit(USB_CAPTURE_RUNNING, &data->pSCOSnd->states);
3597 clear_bit(USB_PLAYBACK_RUNNING, &data->pSCOSnd->states);
3598 #endif
3599 mdelay(URB_CANCELING_DELAY_MS);
3600 usb_kill_anchored_urbs(&data->isoc_anchor);
3601
3602 set_isoc_interface(hdev, 0);
3603 if (test_and_clear_bit(BTUSB_DID_ISO_RESUME, &data->flags))
3604 usb_autopm_put_interface(data->isoc ? data->isoc : data->intf);
3605 }
3606 }
3607
btusb_waker(struct work_struct * work)3608 static void btusb_waker(struct work_struct *work)
3609 {
3610 struct btusb_data *data = container_of(work, struct btusb_data, waker);
3611 int err;
3612
3613 RTKBT_DBG("%s: PM usage count %d", __func__,
3614 atomic_read(&data->intf->pm_usage_cnt));
3615
3616 err = usb_autopm_get_interface(data->intf);
3617 if (err < 0)
3618 return;
3619
3620 usb_autopm_put_interface(data->intf);
3621 }
3622
3623
3624 //#ifdef CONFIG_HAS_EARLYSUSPEND
3625 #if 0
3626 static void btusb_early_suspend(struct early_suspend *h)
3627 {
3628 struct btusb_data *data;
3629 firmware_info *fw_info;
3630 patch_info *patch_entry;
3631
3632 RTKBT_INFO("%s", __func__);
3633
3634 data = container_of(h, struct btusb_data, early_suspend);
3635 fw_info = data->fw_info;
3636 patch_entry = fw_info->patch_entry;
3637
3638 patch_entry->fw_len = load_firmware(fw_info, &patch_entry->fw_cache);
3639 if (patch_entry->fw_len <= 0) {
3640 /* We may encount failure in loading firmware, just give a warning */
3641 RTKBT_WARN("%s: Failed to load firmware", __func__);
3642 }
3643 }
3644
3645 static void btusb_late_resume(struct early_suspend *h)
3646 {
3647 struct btusb_data *data;
3648 firmware_info *fw_info;
3649 patch_info *patch_entry;
3650
3651 RTKBT_INFO("%s", __func__);
3652
3653 data = container_of(h, struct btusb_data, early_suspend);
3654 fw_info = data->fw_info;
3655 patch_entry = fw_info->patch_entry;
3656
3657 /* Reclaim fw buffer when bt usb resumed */
3658 if (patch_entry->fw_len > 0) {
3659 kfree(patch_entry->fw_cache);
3660 patch_entry->fw_cache = NULL;
3661 patch_entry->fw_len = 0;
3662 }
3663 }
3664 #else
bt_pm_notify(struct notifier_block * notifier,ulong pm_event,void * unused)3665 int bt_pm_notify(struct notifier_block *notifier, ulong pm_event, void *unused)
3666 {
3667 struct btusb_data *data;
3668 firmware_info *fw_info;
3669 patch_info *patch_entry;
3670 struct usb_device *udev;
3671
3672 RTKBT_INFO("%s: pm event %ld", __func__, pm_event);
3673
3674 data = container_of(notifier, struct btusb_data, pm_notifier);
3675 fw_info = data->fw_info;
3676 patch_entry = fw_info->patch_entry;
3677 udev = fw_info->udev;
3678
3679 switch (pm_event) {
3680 case PM_SUSPEND_PREPARE:
3681 case PM_HIBERNATION_PREPARE:
3682 #if 0
3683 patch_entry->fw_len = load_firmware(fw_info, &patch_entry->fw_cache);
3684 if (patch_entry->fw_len <= 0) {
3685 /* We may encount failure in loading firmware, just give a warning */
3686 RTKBT_WARN("%s: Failed to load firmware", __func__);
3687 }
3688 #endif
3689 if (!device_may_wakeup(&udev->dev)) {
3690 #if (CONFIG_RESET_RESUME || CONFIG_BLUEDROID)
3691 RTKBT_INFO("%s:remote wakeup not supported, reset resume supported", __func__);
3692 #else
3693 fw_info->intf->needs_binding = 1;
3694 RTKBT_INFO("%s:remote wakeup not supported, binding needed", __func__);
3695 #endif
3696 }
3697 break;
3698
3699 case PM_POST_SUSPEND:
3700 case PM_POST_HIBERNATION:
3701 case PM_POST_RESTORE:
3702 #if 0
3703 /* Reclaim fw buffer when bt usb resumed */
3704 if (patch_entry->fw_len > 0) {
3705 kfree(patch_entry->fw_cache);
3706 patch_entry->fw_cache = NULL;
3707 patch_entry->fw_len = 0;
3708 }
3709 #endif
3710
3711 #if BTUSB_RPM
3712 usb_disable_autosuspend(udev);
3713 usb_enable_autosuspend(udev);
3714 pm_runtime_set_autosuspend_delay(&(udev->dev), 2000);
3715 #endif
3716 break;
3717
3718 default:
3719 break;
3720 }
3721
3722 return NOTIFY_DONE;
3723 }
3724
bt_reboot_notify(struct notifier_block * notifier,ulong pm_event,void * unused)3725 int bt_reboot_notify(struct notifier_block *notifier, ulong pm_event, void *unused)
3726 {
3727 struct btusb_data *data;
3728 firmware_info *fw_info;
3729 patch_info *patch_entry;
3730 struct usb_device *udev;
3731
3732 RTKBT_INFO("%s: pm event %ld", __func__, pm_event);
3733
3734 data = container_of(notifier, struct btusb_data, reboot_notifier);
3735 fw_info = data->fw_info;
3736 patch_entry = fw_info->patch_entry;
3737 udev = fw_info->udev;
3738
3739 switch (pm_event) {
3740 case SYS_DOWN:
3741 RTKBT_DBG("%s:system down or restart", __func__);
3742 break;
3743
3744 case SYS_HALT:
3745 case SYS_POWER_OFF:
3746 #if SUSPNED_DW_FW
3747 cancel_work_sync(&data->work);
3748
3749 btusb_stop_traffic(data);
3750 mdelay(URB_CANCELING_DELAY_MS);
3751 usb_kill_anchored_urbs(&data->tx_anchor);
3752
3753
3754 if(fw_info_4_suspend) {
3755 download_suspend_patch(fw_info_4_suspend,1);
3756 }
3757 else
3758 RTKBT_ERR("%s: Failed to download suspend fw", __func__);
3759 #endif
3760
3761 #if SET_WAKEUP_DEVICE
3762 set_wakeup_device_from_conf(fw_info_4_suspend);
3763 #endif
3764 RTKBT_DBG("%s:system halt or power off", __func__);
3765 break;
3766
3767 default:
3768 break;
3769 }
3770
3771 return NOTIFY_DONE;
3772 }
3773
3774 #endif
3775
3776 #ifdef CONFIG_SCO_OVER_HCI
3777 static const struct snd_pcm_hardware snd_card_sco_capture_default =
3778 {
3779 .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_NONINTERLEAVED |
3780 SNDRV_PCM_ACCESS_RW_INTERLEAVED | SNDRV_PCM_INFO_FIFO_IN_FRAMES),
3781 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8,
3782 .rates = (SNDRV_PCM_RATE_8000),
3783 .rate_min = 8000,
3784 .rate_max = 8000,
3785 .channels_min = 1,
3786 .channels_max = 1,
3787 .buffer_bytes_max = 8 * 768,
3788 .period_bytes_min = 48,
3789 .period_bytes_max = 768,
3790 .periods_min = 1,
3791 .periods_max = 8,
3792 .fifo_size = 8,
3793
3794 };
3795
snd_sco_capture_pcm_open(struct snd_pcm_substream * substream)3796 static int snd_sco_capture_pcm_open(struct snd_pcm_substream * substream)
3797 {
3798 RTK_sco_card_t *pSCOSnd = substream->private_data;
3799
3800 RTKBT_INFO("%s", __FUNCTION__);
3801 pSCOSnd->capture.substream = substream;
3802
3803 memcpy(&substream->runtime->hw, &snd_card_sco_capture_default, sizeof(struct snd_pcm_hardware));
3804
3805 if(check_controller_support_msbc(pSCOSnd->dev)) {
3806 substream->runtime->hw.rates |= SNDRV_PCM_RATE_16000;
3807 substream->runtime->hw.rate_max = 16000;
3808 substream->runtime->hw.period_bytes_min = 96;
3809 substream->runtime->hw.period_bytes_max = 16 * 96;
3810 substream->runtime->hw.buffer_bytes_max = 8 * 16 * 96;
3811 }
3812 set_bit(ALSA_CAPTURE_OPEN, &pSCOSnd->states);
3813 return 0;
3814 }
3815
snd_sco_capture_pcm_close(struct snd_pcm_substream * substream)3816 static int snd_sco_capture_pcm_close(struct snd_pcm_substream *substream)
3817 {
3818 RTK_sco_card_t *pSCOSnd = substream->private_data;
3819
3820 clear_bit(ALSA_CAPTURE_OPEN, &pSCOSnd->states);
3821 return 0;
3822 }
3823
snd_sco_capture_ioctl(struct snd_pcm_substream * substream,unsigned int cmd,void * arg)3824 static int snd_sco_capture_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg)
3825 {
3826 RTKBT_DBG("%s, cmd = %d", __FUNCTION__, cmd);
3827 switch (cmd)
3828 {
3829 default:
3830 return snd_pcm_lib_ioctl(substream, cmd, arg);
3831 }
3832 return 0;
3833 }
3834
snd_sco_capture_pcm_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * hw_params)3835 static int snd_sco_capture_pcm_hw_params(struct snd_pcm_substream * substream, struct snd_pcm_hw_params * hw_params)
3836 {
3837
3838 int err;
3839 struct snd_pcm_runtime *runtime = substream->runtime;
3840 err = snd_pcm_lib_alloc_vmalloc_buffer(substream, params_buffer_bytes(hw_params));
3841 RTKBT_INFO("%s,err : %d, runtime state : %d", __FUNCTION__, err, runtime->status->state);
3842 return err;
3843 }
3844
snd_sco_capture_pcm_hw_free(struct snd_pcm_substream * substream)3845 static int snd_sco_capture_pcm_hw_free(struct snd_pcm_substream * substream)
3846 {
3847 RTKBT_DBG("%s", __FUNCTION__);
3848 return snd_pcm_lib_free_vmalloc_buffer(substream);;
3849 }
3850
snd_sco_capture_pcm_prepare(struct snd_pcm_substream * substream)3851 static int snd_sco_capture_pcm_prepare(struct snd_pcm_substream *substream)
3852 {
3853 RTK_sco_card_t *pSCOSnd = substream->private_data;
3854 struct snd_pcm_runtime *runtime = substream->runtime;
3855
3856 RTKBT_INFO("%s", __FUNCTION__);
3857 if (test_bit(DISCONNECTED, &pSCOSnd->states))
3858 return -ENODEV;
3859 if (!test_bit(USB_CAPTURE_RUNNING, &pSCOSnd->states))
3860 return -EIO;
3861
3862 if(runtime->rate == 8000) {
3863 if(pSCOSnd->usb_data->isoc_altsetting != 2)
3864 return -ENOEXEC;
3865 pSCOSnd->capture.sco_packet_bytes = 48;
3866 }
3867 else if(runtime->rate == 16000 && check_controller_support_msbc(pSCOSnd->dev)) {
3868 if(pSCOSnd->usb_data->isoc_altsetting != 4)
3869 return -ENOEXEC;
3870 pSCOSnd->capture.sco_packet_bytes = 96;
3871 }
3872 else if(pSCOSnd->usb_data->isoc_altsetting == 2) {
3873 pSCOSnd->capture.sco_packet_bytes = 48;
3874 }
3875 else if(pSCOSnd->usb_data->isoc_altsetting == 1) {
3876 pSCOSnd->capture.sco_packet_bytes = 24;
3877 }
3878 return 0;
3879 }
3880
snd_sco_capture_pcm_trigger(struct snd_pcm_substream * substream,int cmd)3881 static int snd_sco_capture_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
3882 {
3883 RTK_sco_card_t *pSCOSnd = substream->private_data;
3884 RTKBT_INFO("%s, cmd : %d", __FUNCTION__, cmd);
3885
3886 switch (cmd) {
3887 case SNDRV_PCM_TRIGGER_START:
3888 if (!test_bit(USB_CAPTURE_RUNNING, &pSCOSnd->states))
3889 return -EIO;
3890 set_bit(ALSA_CAPTURE_RUNNING, &pSCOSnd->states);
3891 return 0;
3892 case SNDRV_PCM_TRIGGER_STOP:
3893 clear_bit(ALSA_CAPTURE_RUNNING, &pSCOSnd->states);
3894 return 0;
3895 default:
3896 return -EINVAL;
3897 }
3898 }
3899
snd_sco_capture_pcm_pointer(struct snd_pcm_substream * substream)3900 static snd_pcm_uframes_t snd_sco_capture_pcm_pointer(struct snd_pcm_substream *substream)
3901 {
3902 RTK_sco_card_t *pSCOSnd = substream->private_data;
3903
3904 return pSCOSnd->capture.buffer_pos;
3905 }
3906
3907
3908 static struct snd_pcm_ops snd_sco_capture_pcm_ops = {
3909 .open = snd_sco_capture_pcm_open,
3910 .close = snd_sco_capture_pcm_close,
3911 .ioctl = snd_sco_capture_ioctl,
3912 .hw_params = snd_sco_capture_pcm_hw_params,
3913 .hw_free = snd_sco_capture_pcm_hw_free,
3914 .prepare = snd_sco_capture_pcm_prepare,
3915 .trigger = snd_sco_capture_pcm_trigger,
3916 .pointer = snd_sco_capture_pcm_pointer,
3917 };
3918
3919
3920 static const struct snd_pcm_hardware snd_card_sco_playback_default =
3921 {
3922 .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_NONINTERLEAVED |
3923 SNDRV_PCM_ACCESS_RW_INTERLEAVED | SNDRV_PCM_INFO_FIFO_IN_FRAMES),
3924 .formats = SNDRV_PCM_FMTBIT_S16_LE,
3925 .rates = (SNDRV_PCM_RATE_8000),
3926 .rate_min = 8000,
3927 .rate_max = 8000,
3928 .channels_min = 1,
3929 .channels_max = 1,
3930 .buffer_bytes_max = 8 * 768,
3931 .period_bytes_min = 48,
3932 .period_bytes_max = 768,
3933 .periods_min = 1,
3934 .periods_max = 8,
3935 .fifo_size = 8,
3936 };
3937
snd_sco_playback_pcm_open(struct snd_pcm_substream * substream)3938 static int snd_sco_playback_pcm_open(struct snd_pcm_substream * substream)
3939 {
3940 RTK_sco_card_t *pSCOSnd = substream->private_data;
3941 int err = 0;
3942
3943 RTKBT_INFO("%s, rate : %d", __FUNCTION__, substream->runtime->rate);
3944 memcpy(&substream->runtime->hw, &snd_card_sco_playback_default, sizeof(struct snd_pcm_hardware));
3945 if(check_controller_support_msbc(pSCOSnd->dev)) {
3946 substream->runtime->hw.rates |= SNDRV_PCM_RATE_16000;
3947 substream->runtime->hw.rate_max = 16000;
3948 substream->runtime->hw.period_bytes_min = 96;
3949 substream->runtime->hw.period_bytes_max = 16 * 96;
3950 substream->runtime->hw.buffer_bytes_max = 8 * 16 * 96;
3951 }
3952 pSCOSnd->playback.substream = substream;
3953 set_bit(ALSA_PLAYBACK_OPEN, &pSCOSnd->states);
3954
3955 return err;
3956 }
3957
snd_sco_playback_pcm_close(struct snd_pcm_substream * substream)3958 static int snd_sco_playback_pcm_close(struct snd_pcm_substream *substream)
3959 {
3960 RTK_sco_card_t *pSCOSnd = substream->private_data;
3961
3962 clear_bit(ALSA_PLAYBACK_OPEN, &pSCOSnd->states);
3963 cancel_work_sync(&pSCOSnd->send_sco_work);
3964 return 0;
3965 }
3966
snd_sco_playback_ioctl(struct snd_pcm_substream * substream,unsigned int cmd,void * arg)3967 static int snd_sco_playback_ioctl(struct snd_pcm_substream *substream, unsigned int cmd, void *arg)
3968 {
3969 RTKBT_DBG("%s, cmd : %d", __FUNCTION__, cmd);
3970 switch (cmd)
3971 {
3972 default:
3973 return snd_pcm_lib_ioctl(substream, cmd, arg);
3974 break;
3975 }
3976 return 0;
3977 }
3978
snd_sco_playback_pcm_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * hw_params)3979 static int snd_sco_playback_pcm_hw_params(struct snd_pcm_substream * substream, struct snd_pcm_hw_params * hw_params)
3980 {
3981 int err;
3982 err = snd_pcm_lib_alloc_vmalloc_buffer(substream, params_buffer_bytes(hw_params));
3983 return err;
3984 }
3985
snd_sco_palyback_pcm_hw_free(struct snd_pcm_substream * substream)3986 static int snd_sco_palyback_pcm_hw_free(struct snd_pcm_substream * substream)
3987 {
3988 RTKBT_DBG("%s", __FUNCTION__);
3989 return snd_pcm_lib_free_vmalloc_buffer(substream);
3990 }
3991
snd_sco_playback_pcm_prepare(struct snd_pcm_substream * substream)3992 static int snd_sco_playback_pcm_prepare(struct snd_pcm_substream *substream)
3993 {
3994 RTK_sco_card_t *pSCOSnd = substream->private_data;
3995 struct snd_pcm_runtime *runtime = substream->runtime;
3996
3997 RTKBT_INFO("%s, bound_rate = %d", __FUNCTION__, runtime->rate);
3998
3999 if (test_bit(DISCONNECTED, &pSCOSnd->states))
4000 return -ENODEV;
4001 if (!test_bit(USB_PLAYBACK_RUNNING, &pSCOSnd->states))
4002 return -EIO;
4003
4004 if(runtime->rate == 8000) {
4005 if(pSCOSnd->usb_data->isoc_altsetting != 2)
4006 return -ENOEXEC;
4007 pSCOSnd->playback.sco_packet_bytes = 48;
4008 }
4009 else if(runtime->rate == 16000) {
4010 if(pSCOSnd->usb_data->isoc_altsetting != 4)
4011 return -ENOEXEC;
4012 pSCOSnd->playback.sco_packet_bytes = 96;
4013 }
4014
4015 return 0;
4016 }
4017
snd_sco_playback_pcm_trigger(struct snd_pcm_substream * substream,int cmd)4018 static int snd_sco_playback_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
4019 {
4020 RTK_sco_card_t *pSCOSnd = substream->private_data;
4021
4022 RTKBT_INFO("%s, cmd = %d", __FUNCTION__, cmd);
4023 switch (cmd) {
4024 case SNDRV_PCM_TRIGGER_START:
4025 if (!test_bit(USB_PLAYBACK_RUNNING, &pSCOSnd->states))
4026 return -EIO;
4027 set_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states);
4028 schedule_work(&pSCOSnd->send_sco_work);
4029 return 0;
4030 case SNDRV_PCM_TRIGGER_STOP:
4031 clear_bit(ALSA_PLAYBACK_RUNNING, &pSCOSnd->states);
4032 return 0;
4033 default:
4034 return -EINVAL;
4035 }
4036 }
4037
snd_sco_playback_pcm_pointer(struct snd_pcm_substream * substream)4038 static snd_pcm_uframes_t snd_sco_playback_pcm_pointer(struct snd_pcm_substream *substream)
4039 {
4040 RTK_sco_card_t *pSCOSnd = substream->private_data;
4041
4042 return pSCOSnd->playback.buffer_pos;
4043 }
4044
4045
4046 static struct snd_pcm_ops snd_sco_playback_pcm_ops = {
4047 .open = snd_sco_playback_pcm_open,
4048 .close = snd_sco_playback_pcm_close,
4049 .ioctl = snd_sco_playback_ioctl,
4050 .hw_params = snd_sco_playback_pcm_hw_params,
4051 .hw_free = snd_sco_palyback_pcm_hw_free,
4052 .prepare = snd_sco_playback_pcm_prepare,
4053 .trigger = snd_sco_playback_pcm_trigger,
4054 .pointer = snd_sco_playback_pcm_pointer,
4055 };
4056
4057
btusb_snd_init(struct usb_interface * intf,const struct usb_device_id * id,struct btusb_data * data)4058 static RTK_sco_card_t* btusb_snd_init(struct usb_interface *intf, const struct usb_device_id *id, struct btusb_data *data)
4059 {
4060 struct snd_card *card;
4061 RTK_sco_card_t *pSCOSnd;
4062 int err=0;
4063 RTKBT_INFO("%s", __func__);
4064 err = snd_card_new(&intf->dev,
4065 -1, RTK_SCO_ID, THIS_MODULE,
4066 sizeof(RTK_sco_card_t), &card);
4067 if (err < 0) {
4068 RTKBT_ERR("%s: sco snd card create fail", __func__);
4069 return NULL;
4070 }
4071 // private data
4072 pSCOSnd = (RTK_sco_card_t *)card->private_data;
4073 pSCOSnd->card = card;
4074 pSCOSnd->dev = interface_to_usbdev(intf);
4075 pSCOSnd->usb_data = data;
4076
4077 strcpy(card->driver, RTK_SCO_ID);
4078 strcpy(card->shortname, "Realtek sco snd");
4079 sprintf(card->longname, "Realtek sco over hci: VID:0x%04x, PID:0x%04x",
4080 id->idVendor, pSCOSnd->dev->descriptor.idProduct);
4081
4082 err = snd_pcm_new(card, RTK_SCO_ID, 0, 1, 1, &pSCOSnd->pcm);
4083 if (err < 0) {
4084 RTKBT_ERR("%s: sco snd card new pcm fail", __func__);
4085 return NULL;
4086 }
4087 pSCOSnd->pcm->private_data = pSCOSnd;
4088 sprintf(pSCOSnd->pcm->name, "sco_pcm:VID:0x%04x, PID:0x%04x",
4089 id->idVendor, pSCOSnd->dev->descriptor.idProduct);
4090
4091 snd_pcm_set_ops(pSCOSnd->pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_sco_playback_pcm_ops);
4092 snd_pcm_set_ops(pSCOSnd->pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_sco_capture_pcm_ops);
4093
4094 err = snd_card_register(card);
4095 if (err < 0) {
4096 RTKBT_ERR("%s: sco snd card register card fail", __func__);
4097 return NULL;
4098 }
4099
4100 spin_lock_init(&pSCOSnd->capture_lock);
4101 spin_lock_init(&pSCOSnd->playback_lock);
4102 INIT_WORK(&pSCOSnd->send_sco_work, playback_work);
4103 return pSCOSnd;
4104 }
4105 #endif
4106
btusb_probe(struct usb_interface * intf,const struct usb_device_id * id)4107 static int btusb_probe(struct usb_interface *intf, const struct usb_device_id *id)
4108 {
4109 struct usb_device *udev = interface_to_usbdev(intf);
4110 struct usb_endpoint_descriptor *ep_desc;
4111 struct btusb_data *data;
4112 struct hci_dev *hdev;
4113 firmware_info *fw_info;
4114 int i, err=0;
4115
4116 RTKBT_INFO("%s: usb_interface %p, bInterfaceNumber %d, idVendor 0x%04x, "
4117 "idProduct 0x%04x", __func__, intf,
4118 intf->cur_altsetting->desc.bInterfaceNumber,
4119 id->idVendor, id->idProduct);
4120
4121 /* interface numbers are hardcoded in the spec */
4122 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
4123 return -ENODEV;
4124
4125 RTKBT_DBG("%s: can wakeup = %x, may wakeup = %x", __func__,
4126 device_can_wakeup(&udev->dev), device_may_wakeup(&udev->dev));
4127
4128 data = rtk_alloc(intf);
4129 if (!data)
4130 return -ENOMEM;
4131
4132 for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
4133 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
4134
4135 if (!data->intr_ep && usb_endpoint_is_int_in(ep_desc)) {
4136 data->intr_ep = ep_desc;
4137 continue;
4138 }
4139
4140 if (!data->bulk_tx_ep && usb_endpoint_is_bulk_out(ep_desc)) {
4141 data->bulk_tx_ep = ep_desc;
4142 continue;
4143 }
4144
4145 if (!data->bulk_rx_ep && usb_endpoint_is_bulk_in(ep_desc)) {
4146 data->bulk_rx_ep = ep_desc;
4147 continue;
4148 }
4149 }
4150
4151 if (!data->intr_ep || !data->bulk_tx_ep || !data->bulk_rx_ep) {
4152 rtk_free(data);
4153 return -ENODEV;
4154 }
4155
4156 data->cmdreq_type = USB_TYPE_CLASS;
4157
4158 data->udev = udev;
4159 data->intf = intf;
4160
4161 dlfw_dis_state = 0;
4162 spin_lock_init(&queue_lock);
4163 spin_lock_init(&dlfw_lock);
4164 spin_lock_init(&data->lock);
4165
4166 INIT_WORK(&data->work, btusb_work);
4167 INIT_WORK(&data->waker, btusb_waker);
4168 spin_lock_init(&data->txlock);
4169
4170 init_usb_anchor(&data->tx_anchor);
4171 init_usb_anchor(&data->intr_anchor);
4172 init_usb_anchor(&data->bulk_anchor);
4173 init_usb_anchor(&data->isoc_anchor);
4174 init_usb_anchor(&data->deferred);
4175
4176 fw_info = firmware_info_init(intf);
4177 if (fw_info)
4178 data->fw_info = fw_info;
4179 else {
4180 RTKBT_WARN("%s: Failed to initialize fw info", __func__);
4181 /* Skip download patch */
4182 goto end;
4183 }
4184
4185 hdev = hci_alloc_dev();
4186 if (!hdev) {
4187 rtk_free(data);
4188 data = NULL;
4189 return -ENOMEM;
4190 }
4191
4192 HDEV_BUS = HCI_USB;
4193
4194 data->hdev = hdev;
4195
4196 SET_HCIDEV_DEV(hdev, &intf->dev);
4197
4198 hdev->open = btusb_open;
4199 hdev->close = btusb_close;
4200 hdev->flush = btusb_flush;
4201 hdev->send = btusb_send_frame;
4202 hdev->notify = btusb_notify;
4203
4204 #if LINUX_VERSION_CODE > KERNEL_VERSION(3, 4, 0)
4205 hci_set_drvdata(hdev, data);
4206 #else
4207 hdev->driver_data = data;
4208 hdev->destruct = btusb_destruct;
4209 hdev->owner = THIS_MODULE;
4210 #endif
4211
4212 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 1)
4213 if (!reset_on_close){
4214 /* set_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks); */
4215 RTKBT_DBG("%s: Set HCI_QUIRK_RESET_ON_CLOSE", __func__);
4216 }
4217 #endif
4218
4219 /* Interface numbers are hardcoded in the specification */
4220 data->isoc = usb_ifnum_to_if(data->udev, 1);
4221 if (data->isoc) {
4222 err = usb_driver_claim_interface(&btusb_driver,
4223 data->isoc, data);
4224 if (err < 0) {
4225 hci_free_dev(hdev);
4226 hdev = NULL;
4227 rtk_free(data);
4228 data = NULL;
4229 return err;
4230 }
4231 #ifdef CONFIG_SCO_OVER_HCI
4232 data->pSCOSnd = btusb_snd_init(intf, id, data);
4233 #endif
4234 }
4235
4236 err = hci_register_dev(hdev);
4237 if (err < 0) {
4238 hci_free_dev(hdev);
4239 hdev = NULL;
4240 rtk_free(data);
4241 data = NULL;
4242 return err;
4243 }
4244
4245 usb_set_intfdata(intf, data);
4246
4247 //#ifdef CONFIG_HAS_EARLYSUSPEND
4248 #if 0
4249 data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
4250 data->early_suspend.suspend = btusb_early_suspend;
4251 data->early_suspend.resume = btusb_late_resume;
4252 register_early_suspend(&data->early_suspend);
4253 #else
4254 data->pm_notifier.notifier_call = bt_pm_notify;
4255 data->reboot_notifier.notifier_call = bt_reboot_notify;
4256 register_pm_notifier(&data->pm_notifier);
4257 register_reboot_notifier(&data->reboot_notifier);
4258 #endif
4259
4260 #if CONFIG_BLUEDROID
4261 RTKBT_INFO("%s: Check bt reset flag %d", __func__, bt_reset);
4262 /* Report hci hardware error after everthing is ready,
4263 * especially hci register is completed. Or, btchr_poll
4264 * will get null hci dev when hotplug in.
4265 */
4266 if (bt_reset == 1) {
4267 hci_hardware_error();
4268 bt_reset = 0;
4269 } else
4270 bt_reset = 0; /* Clear and reset it anyway */
4271 #endif
4272
4273 end:
4274 return 0;
4275 }
4276
btusb_disconnect(struct usb_interface * intf)4277 static void btusb_disconnect(struct usb_interface *intf)
4278 {
4279 struct btusb_data *data;
4280 struct hci_dev *hdev = NULL;
4281
4282 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
4283 return;
4284
4285 wait_event_interruptible(bt_dlfw_wait, (check_set_dlfw_state_value(2) == 2));
4286
4287 RTKBT_INFO("%s: usb_interface %p, bInterfaceNumber %d",
4288 __func__, intf, intf->cur_altsetting->desc.bInterfaceNumber);
4289
4290 data = usb_get_intfdata(intf);
4291
4292 if (data)
4293 hdev = data->hdev;
4294 else {
4295 RTKBT_WARN("%s: Failed to get bt usb data[Null]", __func__);
4296 return;
4297 }
4298
4299 #ifdef CONFIG_SCO_OVER_HCI
4300 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
4301 RTK_sco_card_t *pSCOSnd = data->pSCOSnd;
4302 if(!pSCOSnd) {
4303 RTKBT_ERR("%s: sco private data is null", __func__);
4304 return;
4305 }
4306 set_bit(DISCONNECTED, &pSCOSnd->states);
4307 snd_card_disconnect(pSCOSnd->card);
4308 snd_card_free_when_closed(pSCOSnd->card);
4309 }
4310 #endif
4311
4312 //#ifdef CONFIG_HAS_EARLYSUSPEND
4313 #if 0
4314 unregister_early_suspend(&data->early_suspend);
4315 #else
4316 unregister_pm_notifier(&data->pm_notifier);
4317 unregister_reboot_notifier(&data->reboot_notifier);
4318 #endif
4319
4320 firmware_info_destroy(intf);
4321
4322 #if CONFIG_BLUEDROID
4323 if (test_bit(HCI_RUNNING, &hdev->flags)) {
4324 RTKBT_INFO("%s: Set BT reset flag", __func__);
4325 bt_reset = 1;
4326 }
4327 #endif
4328
4329 usb_set_intfdata(data->intf, NULL);
4330
4331 if (data->isoc)
4332 usb_set_intfdata(data->isoc, NULL);
4333
4334 hci_unregister_dev(hdev);
4335
4336 if (intf == data->isoc)
4337 usb_driver_release_interface(&btusb_driver, data->intf);
4338 else if (data->isoc)
4339 usb_driver_release_interface(&btusb_driver, data->isoc);
4340
4341 #if !CONFIG_BLUEDROID
4342 #if LINUX_VERSION_CODE <= KERNEL_VERSION(3, 4, 0)
4343 __hci_dev_put(hdev);
4344 #endif
4345 #endif
4346
4347 hci_free_dev(hdev);
4348 rtk_free(data);
4349 data = NULL;
4350 set_dlfw_state_value(0);
4351 }
4352
4353 #ifdef CONFIG_PM
btusb_suspend(struct usb_interface * intf,pm_message_t message)4354 static int btusb_suspend(struct usb_interface *intf, pm_message_t message)
4355 {
4356 struct btusb_data *data = usb_get_intfdata(intf);
4357 firmware_info *fw_info = data->fw_info;
4358
4359 RTKBT_INFO("%s: event 0x%x, suspend count %d", __func__,
4360 message.event, data->suspend_count);
4361
4362 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
4363 return 0;
4364
4365 if (!test_bit(HCI_RUNNING, &data->hdev->flags))
4366 set_bt_onoff(fw_info, 1);
4367
4368 if (data->suspend_count++)
4369 return 0;
4370
4371 spin_lock_irq(&data->txlock);
4372 if (!((message.event & PM_EVENT_AUTO) && data->tx_in_flight)) {
4373 set_bit(BTUSB_SUSPENDING, &data->flags);
4374 spin_unlock_irq(&data->txlock);
4375 } else {
4376 spin_unlock_irq(&data->txlock);
4377 data->suspend_count--;
4378 RTKBT_ERR("%s: Failed to enter suspend", __func__);
4379 return -EBUSY;
4380 }
4381
4382 cancel_work_sync(&data->work);
4383
4384 btusb_stop_traffic(data);
4385 mdelay(URB_CANCELING_DELAY_MS);
4386 usb_kill_anchored_urbs(&data->tx_anchor);
4387
4388 #if SUSPNED_DW_FW
4389 if(fw_info_4_suspend) {
4390 download_suspend_patch(fw_info_4_suspend,1);
4391 }
4392 else
4393 RTKBT_ERR("%s: Failed to download suspend fw", __func__);
4394 #endif
4395
4396 #if SET_WAKEUP_DEVICE
4397 set_wakeup_device_from_conf(fw_info_4_suspend);
4398 #endif
4399
4400 return 0;
4401 }
4402
play_deferred(struct btusb_data * data)4403 static void play_deferred(struct btusb_data *data)
4404 {
4405 struct urb *urb;
4406 int err;
4407
4408 while ((urb = usb_get_from_anchor(&data->deferred))) {
4409 usb_anchor_urb(urb, &data->tx_anchor);
4410 err = usb_submit_urb(urb, GFP_ATOMIC);
4411 if (err < 0) {
4412 RTKBT_ERR("%s: Failed to submit urb %p, err %d",
4413 __func__, urb, err);
4414 kfree(urb->setup_packet);
4415 usb_unanchor_urb(urb);
4416 } else {
4417 usb_mark_last_busy(data->udev);
4418 }
4419 usb_free_urb(urb);
4420
4421 data->tx_in_flight++;
4422 }
4423 mdelay(URB_CANCELING_DELAY_MS);
4424 usb_scuttle_anchored_urbs(&data->deferred);
4425 }
4426
btusb_resume(struct usb_interface * intf)4427 static int btusb_resume(struct usb_interface *intf)
4428 {
4429 struct btusb_data *data = usb_get_intfdata(intf);
4430 struct hci_dev *hdev = data->hdev;
4431 firmware_info *fw_info = data->fw_info;
4432 int err = 0;
4433
4434 RTKBT_INFO("%s: Suspend count %d", __func__, data->suspend_count);
4435
4436 if (intf->cur_altsetting->desc.bInterfaceNumber != 0)
4437 return 0;
4438
4439 if (--data->suspend_count)
4440 return 0;
4441
4442 /*check_fw_version to check the status of the BT Controller after USB Resume*/
4443 err = check_fw_version(fw_info);
4444 if (err !=0)
4445 {
4446 RTKBT_INFO("%s: BT Controller Power OFF And Return hci_hardware_error:%d", __func__, err);
4447 hci_hardware_error();
4448 }
4449
4450
4451 if (test_bit(BTUSB_INTR_RUNNING, &data->flags)) {
4452 err = btusb_submit_intr_urb(hdev, GFP_NOIO);
4453 if (err < 0) {
4454 clear_bit(BTUSB_INTR_RUNNING, &data->flags);
4455 goto failed;
4456 }
4457 }
4458
4459 if (test_bit(BTUSB_BULK_RUNNING, &data->flags)) {
4460 err = btusb_submit_bulk_urb(hdev, GFP_NOIO);
4461 if (err < 0) {
4462 clear_bit(BTUSB_BULK_RUNNING, &data->flags);
4463 goto failed;
4464 }
4465
4466 btusb_submit_bulk_urb(hdev, GFP_NOIO);
4467 }
4468
4469 if (test_bit(BTUSB_ISOC_RUNNING, &data->flags)) {
4470 if (btusb_submit_isoc_urb(hdev, GFP_NOIO) < 0)
4471 clear_bit(BTUSB_ISOC_RUNNING, &data->flags);
4472 else
4473 btusb_submit_isoc_urb(hdev, GFP_NOIO);
4474 }
4475
4476 spin_lock_irq(&data->txlock);
4477 play_deferred(data);
4478 clear_bit(BTUSB_SUSPENDING, &data->flags);
4479 spin_unlock_irq(&data->txlock);
4480 schedule_work(&data->work);
4481
4482 return 0;
4483
4484 failed:
4485 mdelay(URB_CANCELING_DELAY_MS);
4486 usb_scuttle_anchored_urbs(&data->deferred);
4487 spin_lock_irq(&data->txlock);
4488 clear_bit(BTUSB_SUSPENDING, &data->flags);
4489 spin_unlock_irq(&data->txlock);
4490
4491 return err;
4492 }
4493 #endif
4494
4495 static struct usb_driver btusb_driver = {
4496 .name = "rtk_btusb",
4497 .probe = btusb_probe,
4498 .disconnect = btusb_disconnect,
4499 #ifdef CONFIG_PM
4500 .suspend = btusb_suspend,
4501 .resume = btusb_resume,
4502 #endif
4503 #if CONFIG_RESET_RESUME
4504 .reset_resume = btusb_resume,
4505 #endif
4506 .id_table = btusb_table,
4507 .supports_autosuspend = 1,
4508 #if LINUX_VERSION_CODE > KERNEL_VERSION(3, 7, 1)
4509 .disable_hub_initiated_lpm = 1,
4510 #endif
4511 };
4512
btusb_init(void)4513 static int __init btusb_init(void)
4514 {
4515 int err;
4516
4517 RTKBT_INFO("RTKBT_RELEASE_NAME: %s",RTKBT_RELEASE_NAME);
4518 RTKBT_INFO("Realtek Bluetooth USB driver module init, version %s", VERSION);
4519 #if CONFIG_BLUEDROID
4520 err = btchr_init();
4521 if (err < 0) {
4522 /* usb register will go on, even bt char register failed */
4523 RTKBT_ERR("Failed to register usb char device interfaces");
4524 } else
4525 bt_char_dev_registered = true;
4526 #endif
4527 err = usb_register(&btusb_driver);
4528 if (err < 0)
4529 RTKBT_ERR("Failed to register RTK bluetooth USB driver");
4530 return err;
4531 }
4532
btusb_exit(void)4533 static void __exit btusb_exit(void)
4534 {
4535 struct hci_dev *hdev;
4536 RTKBT_INFO("Realtek Bluetooth USB driver module exit");
4537 #if CONFIG_BLUEDROID
4538 hdev = hci_dev_get(0);
4539 if (bt_char_dev_registered) {
4540 bt_char_dev_registered = false;
4541 while(hdev && atomic_read(&hdev->promisc)) {
4542 RTKBT_ERR("%s: rtkbt driver is being removed, but application is still running!", __func__);
4543 RTKBT_ERR("%s: wait bt application to stop, or the driver can't be removed", __func__);
4544 mdelay(100);
4545 }
4546 btchr_exit();
4547 }
4548 #endif
4549 usb_deregister(&btusb_driver);
4550 }
4551
4552 module_init(btusb_init);
4553 module_exit(btusb_exit);
4554
4555
4556 module_param(mp_drv_mode, int, 0644);
4557 MODULE_PARM_DESC(mp_drv_mode, "0: NORMAL; 1: MP MODE");
4558
4559
4560 MODULE_AUTHOR("Realtek Corporation");
4561 MODULE_DESCRIPTION("Realtek Bluetooth USB driver version");
4562 MODULE_VERSION(VERSION);
4563 MODULE_LICENSE("GPL");
4564