1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * NXP Bluetooth driver |
4 | * Copyright 2023 NXP |
5 | */ |
6 | |
7 | #include <linux/module.h> |
8 | #include <linux/kernel.h> |
9 | |
10 | #include <linux/serdev.h> |
11 | #include <linux/of.h> |
12 | #include <linux/skbuff.h> |
13 | #include <asm/unaligned.h> |
14 | #include <linux/firmware.h> |
15 | #include <linux/string.h> |
16 | #include <linux/crc8.h> |
17 | #include <linux/crc32.h> |
18 | #include <linux/string_helpers.h> |
19 | |
20 | #include <net/bluetooth/bluetooth.h> |
21 | #include <net/bluetooth/hci_core.h> |
22 | |
23 | #include "h4_recv.h" |
24 | |
25 | #define MANUFACTURER_NXP 37 |
26 | |
27 | #define BTNXPUART_TX_STATE_ACTIVE 1 |
28 | #define BTNXPUART_FW_DOWNLOADING 2 |
29 | #define BTNXPUART_CHECK_BOOT_SIGNATURE 3 |
30 | #define BTNXPUART_SERDEV_OPEN 4 |
31 | #define BTNXPUART_IR_IN_PROGRESS 5 |
32 | |
33 | /* NXP HW err codes */ |
34 | #define BTNXPUART_IR_HW_ERR 0xb0 |
35 | |
36 | #define FIRMWARE_W8987 "nxp/uartuart8987_bt.bin" |
37 | #define FIRMWARE_W8997 "nxp/uartuart8997_bt_v4.bin" |
38 | #define FIRMWARE_W9098 "nxp/uartuart9098_bt_v1.bin" |
39 | #define FIRMWARE_IW416 "nxp/uartiw416_bt_v0.bin" |
40 | #define FIRMWARE_IW612 "nxp/uartspi_n61x_v1.bin.se" |
41 | #define FIRMWARE_IW624 "nxp/uartiw624_bt.bin" |
42 | #define FIRMWARE_SECURE_IW624 "nxp/uartiw624_bt.bin.se" |
43 | #define FIRMWARE_AW693 "nxp/uartaw693_bt.bin" |
44 | #define FIRMWARE_SECURE_AW693 "nxp/uartaw693_bt.bin.se" |
45 | #define FIRMWARE_HELPER "nxp/helper_uart_3000000.bin" |
46 | |
47 | #define CHIP_ID_W9098 0x5c03 |
48 | #define CHIP_ID_IW416 0x7201 |
49 | #define CHIP_ID_IW612 0x7601 |
50 | #define CHIP_ID_IW624a 0x8000 |
51 | #define CHIP_ID_IW624c 0x8001 |
52 | #define CHIP_ID_AW693 0x8200 |
53 | |
54 | #define FW_SECURE_MASK 0xc0 |
55 | #define FW_OPEN 0x00 |
56 | #define FW_AUTH_ILLEGAL 0x40 |
57 | #define FW_AUTH_PLAIN 0x80 |
58 | #define FW_AUTH_ENC 0xc0 |
59 | |
60 | #define HCI_NXP_PRI_BAUDRATE 115200 |
61 | #define HCI_NXP_SEC_BAUDRATE 3000000 |
62 | |
63 | #define MAX_FW_FILE_NAME_LEN 50 |
64 | |
65 | /* Default ps timeout period in milliseconds */ |
66 | #define PS_DEFAULT_TIMEOUT_PERIOD_MS 2000 |
67 | |
68 | /* wakeup methods */ |
69 | #define WAKEUP_METHOD_DTR 0 |
70 | #define WAKEUP_METHOD_BREAK 1 |
71 | #define WAKEUP_METHOD_EXT_BREAK 2 |
72 | #define WAKEUP_METHOD_RTS 3 |
73 | #define WAKEUP_METHOD_INVALID 0xff |
74 | |
75 | /* power save mode status */ |
76 | #define PS_MODE_DISABLE 0 |
77 | #define PS_MODE_ENABLE 1 |
78 | |
79 | /* Power Save Commands to ps_work_func */ |
80 | #define PS_CMD_EXIT_PS 1 |
81 | #define PS_CMD_ENTER_PS 2 |
82 | |
83 | /* power save state */ |
84 | #define PS_STATE_AWAKE 0 |
85 | #define PS_STATE_SLEEP 1 |
86 | |
87 | /* Bluetooth vendor command : Sleep mode */ |
88 | #define HCI_NXP_AUTO_SLEEP_MODE 0xfc23 |
89 | /* Bluetooth vendor command : Wakeup method */ |
90 | #define HCI_NXP_WAKEUP_METHOD 0xfc53 |
91 | /* Bluetooth vendor command : Set operational baudrate */ |
92 | #define HCI_NXP_SET_OPER_SPEED 0xfc09 |
93 | /* Bluetooth vendor command: Independent Reset */ |
94 | #define HCI_NXP_IND_RESET 0xfcfc |
95 | |
96 | /* Bluetooth Power State : Vendor cmd params */ |
97 | #define BT_PS_ENABLE 0x02 |
98 | #define BT_PS_DISABLE 0x03 |
99 | |
100 | /* Bluetooth Host Wakeup Methods */ |
101 | #define BT_HOST_WAKEUP_METHOD_NONE 0x00 |
102 | #define BT_HOST_WAKEUP_METHOD_DTR 0x01 |
103 | #define BT_HOST_WAKEUP_METHOD_BREAK 0x02 |
104 | #define BT_HOST_WAKEUP_METHOD_GPIO 0x03 |
105 | |
106 | /* Bluetooth Chip Wakeup Methods */ |
107 | #define BT_CTRL_WAKEUP_METHOD_DSR 0x00 |
108 | #define BT_CTRL_WAKEUP_METHOD_BREAK 0x01 |
109 | #define BT_CTRL_WAKEUP_METHOD_GPIO 0x02 |
110 | #define BT_CTRL_WAKEUP_METHOD_EXT_BREAK 0x04 |
111 | #define BT_CTRL_WAKEUP_METHOD_RTS 0x05 |
112 | |
113 | struct ps_data { |
114 | u8 target_ps_mode; /* ps mode to be set */ |
115 | u8 cur_psmode; /* current ps_mode */ |
116 | u8 ps_state; /* controller's power save state */ |
117 | u8 ps_cmd; |
118 | u8 h2c_wakeupmode; |
119 | u8 cur_h2c_wakeupmode; |
120 | u8 c2h_wakeupmode; |
121 | u8 c2h_wakeup_gpio; |
122 | u8 h2c_wakeup_gpio; |
123 | bool driver_sent_cmd; |
124 | u16 h2c_ps_interval; |
125 | u16 c2h_ps_interval; |
126 | struct hci_dev *hdev; |
127 | struct work_struct work; |
128 | struct timer_list ps_timer; |
129 | }; |
130 | |
131 | struct wakeup_cmd_payload { |
132 | u8 c2h_wakeupmode; |
133 | u8 c2h_wakeup_gpio; |
134 | u8 h2c_wakeupmode; |
135 | u8 h2c_wakeup_gpio; |
136 | } __packed; |
137 | |
138 | struct psmode_cmd_payload { |
139 | u8 ps_cmd; |
140 | __le16 c2h_ps_interval; |
141 | } __packed; |
142 | |
143 | struct btnxpuart_data { |
144 | const char *helper_fw_name; |
145 | const char *fw_name; |
146 | }; |
147 | |
148 | struct btnxpuart_dev { |
149 | struct hci_dev *hdev; |
150 | struct serdev_device *serdev; |
151 | |
152 | struct work_struct tx_work; |
153 | unsigned long tx_state; |
154 | struct sk_buff_head txq; |
155 | struct sk_buff *rx_skb; |
156 | |
157 | const struct firmware *fw; |
158 | u8 fw_name[MAX_FW_FILE_NAME_LEN]; |
159 | u32 fw_dnld_v1_offset; |
160 | u32 fw_v1_sent_bytes; |
161 | u32 fw_v3_offset_correction; |
162 | u32 fw_v1_expected_len; |
163 | u32 boot_reg_offset; |
164 | wait_queue_head_t fw_dnld_done_wait_q; |
165 | wait_queue_head_t check_boot_sign_wait_q; |
166 | |
167 | u32 new_baudrate; |
168 | u32 current_baudrate; |
169 | u32 fw_init_baudrate; |
170 | bool timeout_changed; |
171 | bool baudrate_changed; |
172 | bool helper_downloaded; |
173 | |
174 | struct ps_data psdata; |
175 | struct btnxpuart_data *nxp_data; |
176 | }; |
177 | |
178 | #define NXP_V1_FW_REQ_PKT 0xa5 |
179 | #define NXP_V1_CHIP_VER_PKT 0xaa |
180 | #define NXP_V3_FW_REQ_PKT 0xa7 |
181 | #define NXP_V3_CHIP_VER_PKT 0xab |
182 | |
183 | #define NXP_ACK_V1 0x5a |
184 | #define NXP_NAK_V1 0xbf |
185 | #define NXP_ACK_V3 0x7a |
186 | #define NXP_NAK_V3 0x7b |
187 | #define NXP_CRC_ERROR_V3 0x7c |
188 | |
189 | #define HDR_LEN 16 |
190 | |
191 | #define NXP_RECV_CHIP_VER_V1 \ |
192 | .type = NXP_V1_CHIP_VER_PKT, \ |
193 | .hlen = 4, \ |
194 | .loff = 0, \ |
195 | .lsize = 0, \ |
196 | .maxlen = 4 |
197 | |
198 | #define NXP_RECV_FW_REQ_V1 \ |
199 | .type = NXP_V1_FW_REQ_PKT, \ |
200 | .hlen = 4, \ |
201 | .loff = 0, \ |
202 | .lsize = 0, \ |
203 | .maxlen = 4 |
204 | |
205 | #define NXP_RECV_CHIP_VER_V3 \ |
206 | .type = NXP_V3_CHIP_VER_PKT, \ |
207 | .hlen = 4, \ |
208 | .loff = 0, \ |
209 | .lsize = 0, \ |
210 | .maxlen = 4 |
211 | |
212 | #define NXP_RECV_FW_REQ_V3 \ |
213 | .type = NXP_V3_FW_REQ_PKT, \ |
214 | .hlen = 9, \ |
215 | .loff = 0, \ |
216 | .lsize = 0, \ |
217 | .maxlen = 9 |
218 | |
219 | struct v1_data_req { |
220 | __le16 len; |
221 | __le16 len_comp; |
222 | } __packed; |
223 | |
224 | struct v1_start_ind { |
225 | __le16 chip_id; |
226 | __le16 chip_id_comp; |
227 | } __packed; |
228 | |
229 | struct v3_data_req { |
230 | __le16 len; |
231 | __le32 offset; |
232 | __le16 error; |
233 | u8 crc; |
234 | } __packed; |
235 | |
236 | struct v3_start_ind { |
237 | __le16 chip_id; |
238 | u8 loader_ver; |
239 | u8 crc; |
240 | } __packed; |
241 | |
242 | /* UART register addresses of BT chip */ |
243 | #define CLKDIVADDR 0x7f00008f |
244 | #define UARTDIVADDR 0x7f000090 |
245 | #define UARTMCRADDR 0x7f000091 |
246 | #define UARTREINITADDR 0x7f000092 |
247 | #define UARTICRADDR 0x7f000093 |
248 | #define UARTFCRADDR 0x7f000094 |
249 | |
250 | #define MCR 0x00000022 |
251 | #define INIT 0x00000001 |
252 | #define ICR 0x000000c7 |
253 | #define FCR 0x000000c7 |
254 | |
255 | #define POLYNOMIAL8 0x07 |
256 | |
257 | struct uart_reg { |
258 | __le32 address; |
259 | __le32 value; |
260 | } __packed; |
261 | |
262 | struct uart_config { |
263 | struct uart_reg clkdiv; |
264 | struct uart_reg uartdiv; |
265 | struct uart_reg mcr; |
266 | struct uart_reg re_init; |
267 | struct uart_reg icr; |
268 | struct uart_reg fcr; |
269 | __be32 crc; |
270 | } __packed; |
271 | |
272 | struct nxp_bootloader_cmd { |
273 | __le32 ; |
274 | __le32 arg; |
275 | __le32 payload_len; |
276 | __be32 crc; |
277 | } __packed; |
278 | |
279 | static u8 crc8_table[CRC8_TABLE_SIZE]; |
280 | |
281 | /* Default configurations */ |
282 | #define DEFAULT_H2C_WAKEUP_MODE WAKEUP_METHOD_BREAK |
283 | #define DEFAULT_PS_MODE PS_MODE_DISABLE |
284 | #define FW_INIT_BAUDRATE HCI_NXP_PRI_BAUDRATE |
285 | |
286 | static struct sk_buff *nxp_drv_send_cmd(struct hci_dev *hdev, u16 opcode, |
287 | u32 plen, |
288 | void *param) |
289 | { |
290 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
291 | struct ps_data *psdata = &nxpdev->psdata; |
292 | struct sk_buff *skb; |
293 | |
294 | /* set flag to prevent nxp_enqueue from parsing values from this command and |
295 | * calling hci_cmd_sync_queue() again. |
296 | */ |
297 | psdata->driver_sent_cmd = true; |
298 | skb = __hci_cmd_sync(hdev, opcode, plen, param, HCI_CMD_TIMEOUT); |
299 | psdata->driver_sent_cmd = false; |
300 | |
301 | return skb; |
302 | } |
303 | |
304 | static void btnxpuart_tx_wakeup(struct btnxpuart_dev *nxpdev) |
305 | { |
306 | if (schedule_work(work: &nxpdev->tx_work)) |
307 | set_bit(BTNXPUART_TX_STATE_ACTIVE, addr: &nxpdev->tx_state); |
308 | } |
309 | |
310 | /* NXP Power Save Feature */ |
311 | static void ps_start_timer(struct btnxpuart_dev *nxpdev) |
312 | { |
313 | struct ps_data *psdata = &nxpdev->psdata; |
314 | |
315 | if (!psdata) |
316 | return; |
317 | |
318 | if (psdata->cur_psmode == PS_MODE_ENABLE) |
319 | mod_timer(timer: &psdata->ps_timer, expires: jiffies + msecs_to_jiffies(m: psdata->h2c_ps_interval)); |
320 | } |
321 | |
322 | static void ps_cancel_timer(struct btnxpuart_dev *nxpdev) |
323 | { |
324 | struct ps_data *psdata = &nxpdev->psdata; |
325 | |
326 | flush_work(work: &psdata->work); |
327 | del_timer_sync(timer: &psdata->ps_timer); |
328 | } |
329 | |
330 | static void ps_control(struct hci_dev *hdev, u8 ps_state) |
331 | { |
332 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
333 | struct ps_data *psdata = &nxpdev->psdata; |
334 | int status; |
335 | |
336 | if (psdata->ps_state == ps_state || |
337 | !test_bit(BTNXPUART_SERDEV_OPEN, &nxpdev->tx_state)) |
338 | return; |
339 | |
340 | switch (psdata->cur_h2c_wakeupmode) { |
341 | case WAKEUP_METHOD_DTR: |
342 | if (ps_state == PS_STATE_AWAKE) |
343 | status = serdev_device_set_tiocm(nxpdev->serdev, TIOCM_DTR, 0); |
344 | else |
345 | status = serdev_device_set_tiocm(nxpdev->serdev, 0, TIOCM_DTR); |
346 | break; |
347 | case WAKEUP_METHOD_BREAK: |
348 | default: |
349 | if (ps_state == PS_STATE_AWAKE) |
350 | status = serdev_device_break_ctl(serdev: nxpdev->serdev, break_state: 0); |
351 | else |
352 | status = serdev_device_break_ctl(serdev: nxpdev->serdev, break_state: -1); |
353 | bt_dev_dbg(hdev, "Set UART break: %s, status=%d" , |
354 | str_on_off(ps_state == PS_STATE_SLEEP), status); |
355 | break; |
356 | } |
357 | if (!status) |
358 | psdata->ps_state = ps_state; |
359 | if (ps_state == PS_STATE_AWAKE) |
360 | btnxpuart_tx_wakeup(nxpdev); |
361 | } |
362 | |
363 | static void ps_work_func(struct work_struct *work) |
364 | { |
365 | struct ps_data *data = container_of(work, struct ps_data, work); |
366 | |
367 | if (data->ps_cmd == PS_CMD_ENTER_PS && data->cur_psmode == PS_MODE_ENABLE) |
368 | ps_control(hdev: data->hdev, PS_STATE_SLEEP); |
369 | else if (data->ps_cmd == PS_CMD_EXIT_PS) |
370 | ps_control(hdev: data->hdev, PS_STATE_AWAKE); |
371 | } |
372 | |
373 | static void ps_timeout_func(struct timer_list *t) |
374 | { |
375 | struct ps_data *data = from_timer(data, t, ps_timer); |
376 | struct hci_dev *hdev = data->hdev; |
377 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
378 | |
379 | if (test_bit(BTNXPUART_TX_STATE_ACTIVE, &nxpdev->tx_state)) { |
380 | ps_start_timer(nxpdev); |
381 | } else { |
382 | data->ps_cmd = PS_CMD_ENTER_PS; |
383 | schedule_work(work: &data->work); |
384 | } |
385 | } |
386 | |
387 | static void ps_setup(struct hci_dev *hdev) |
388 | { |
389 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
390 | struct ps_data *psdata = &nxpdev->psdata; |
391 | |
392 | psdata->hdev = hdev; |
393 | INIT_WORK(&psdata->work, ps_work_func); |
394 | timer_setup(&psdata->ps_timer, ps_timeout_func, 0); |
395 | } |
396 | |
397 | static void ps_wakeup(struct btnxpuart_dev *nxpdev) |
398 | { |
399 | struct ps_data *psdata = &nxpdev->psdata; |
400 | |
401 | if (psdata->ps_state != PS_STATE_AWAKE) { |
402 | psdata->ps_cmd = PS_CMD_EXIT_PS; |
403 | schedule_work(work: &psdata->work); |
404 | } |
405 | } |
406 | |
407 | static int send_ps_cmd(struct hci_dev *hdev, void *data) |
408 | { |
409 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
410 | struct ps_data *psdata = &nxpdev->psdata; |
411 | struct psmode_cmd_payload pcmd; |
412 | struct sk_buff *skb; |
413 | u8 *status; |
414 | |
415 | if (psdata->target_ps_mode == PS_MODE_ENABLE) |
416 | pcmd.ps_cmd = BT_PS_ENABLE; |
417 | else |
418 | pcmd.ps_cmd = BT_PS_DISABLE; |
419 | pcmd.c2h_ps_interval = __cpu_to_le16(psdata->c2h_ps_interval); |
420 | |
421 | skb = nxp_drv_send_cmd(hdev, HCI_NXP_AUTO_SLEEP_MODE, plen: sizeof(pcmd), param: &pcmd); |
422 | if (IS_ERR(ptr: skb)) { |
423 | bt_dev_err(hdev, "Setting Power Save mode failed (%ld)" , PTR_ERR(skb)); |
424 | return PTR_ERR(ptr: skb); |
425 | } |
426 | |
427 | status = skb_pull_data(skb, len: 1); |
428 | if (status) { |
429 | if (!*status) |
430 | psdata->cur_psmode = psdata->target_ps_mode; |
431 | else |
432 | psdata->target_ps_mode = psdata->cur_psmode; |
433 | if (psdata->cur_psmode == PS_MODE_ENABLE) |
434 | ps_start_timer(nxpdev); |
435 | else |
436 | ps_wakeup(nxpdev); |
437 | bt_dev_dbg(hdev, "Power Save mode response: status=%d, ps_mode=%d" , |
438 | *status, psdata->cur_psmode); |
439 | } |
440 | kfree_skb(skb); |
441 | |
442 | return 0; |
443 | } |
444 | |
445 | static int send_wakeup_method_cmd(struct hci_dev *hdev, void *data) |
446 | { |
447 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
448 | struct ps_data *psdata = &nxpdev->psdata; |
449 | struct wakeup_cmd_payload pcmd; |
450 | struct sk_buff *skb; |
451 | u8 *status; |
452 | |
453 | pcmd.c2h_wakeupmode = psdata->c2h_wakeupmode; |
454 | pcmd.c2h_wakeup_gpio = psdata->c2h_wakeup_gpio; |
455 | switch (psdata->h2c_wakeupmode) { |
456 | case WAKEUP_METHOD_DTR: |
457 | pcmd.h2c_wakeupmode = BT_CTRL_WAKEUP_METHOD_DSR; |
458 | break; |
459 | case WAKEUP_METHOD_BREAK: |
460 | default: |
461 | pcmd.h2c_wakeupmode = BT_CTRL_WAKEUP_METHOD_BREAK; |
462 | break; |
463 | } |
464 | pcmd.h2c_wakeup_gpio = 0xff; |
465 | |
466 | skb = nxp_drv_send_cmd(hdev, HCI_NXP_WAKEUP_METHOD, plen: sizeof(pcmd), param: &pcmd); |
467 | if (IS_ERR(ptr: skb)) { |
468 | bt_dev_err(hdev, "Setting wake-up method failed (%ld)" , PTR_ERR(skb)); |
469 | return PTR_ERR(ptr: skb); |
470 | } |
471 | |
472 | status = skb_pull_data(skb, len: 1); |
473 | if (status) { |
474 | if (*status == 0) |
475 | psdata->cur_h2c_wakeupmode = psdata->h2c_wakeupmode; |
476 | else |
477 | psdata->h2c_wakeupmode = psdata->cur_h2c_wakeupmode; |
478 | bt_dev_dbg(hdev, "Set Wakeup Method response: status=%d, h2c_wakeupmode=%d" , |
479 | *status, psdata->cur_h2c_wakeupmode); |
480 | } |
481 | kfree_skb(skb); |
482 | |
483 | return 0; |
484 | } |
485 | |
486 | static void ps_init(struct hci_dev *hdev) |
487 | { |
488 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
489 | struct ps_data *psdata = &nxpdev->psdata; |
490 | |
491 | serdev_device_set_tiocm(nxpdev->serdev, 0, TIOCM_RTS); |
492 | usleep_range(min: 5000, max: 10000); |
493 | serdev_device_set_tiocm(nxpdev->serdev, TIOCM_RTS, 0); |
494 | usleep_range(min: 5000, max: 10000); |
495 | |
496 | psdata->ps_state = PS_STATE_AWAKE; |
497 | psdata->c2h_wakeupmode = BT_HOST_WAKEUP_METHOD_NONE; |
498 | psdata->c2h_wakeup_gpio = 0xff; |
499 | |
500 | psdata->cur_h2c_wakeupmode = WAKEUP_METHOD_INVALID; |
501 | psdata->h2c_ps_interval = PS_DEFAULT_TIMEOUT_PERIOD_MS; |
502 | switch (DEFAULT_H2C_WAKEUP_MODE) { |
503 | case WAKEUP_METHOD_DTR: |
504 | psdata->h2c_wakeupmode = WAKEUP_METHOD_DTR; |
505 | serdev_device_set_tiocm(nxpdev->serdev, 0, TIOCM_DTR); |
506 | serdev_device_set_tiocm(nxpdev->serdev, TIOCM_DTR, 0); |
507 | break; |
508 | case WAKEUP_METHOD_BREAK: |
509 | default: |
510 | psdata->h2c_wakeupmode = WAKEUP_METHOD_BREAK; |
511 | serdev_device_break_ctl(serdev: nxpdev->serdev, break_state: -1); |
512 | usleep_range(min: 5000, max: 10000); |
513 | serdev_device_break_ctl(serdev: nxpdev->serdev, break_state: 0); |
514 | usleep_range(min: 5000, max: 10000); |
515 | break; |
516 | } |
517 | |
518 | psdata->cur_psmode = PS_MODE_DISABLE; |
519 | psdata->target_ps_mode = DEFAULT_PS_MODE; |
520 | |
521 | if (psdata->cur_h2c_wakeupmode != psdata->h2c_wakeupmode) |
522 | hci_cmd_sync_queue(hdev, func: send_wakeup_method_cmd, NULL, NULL); |
523 | if (psdata->cur_psmode != psdata->target_ps_mode) |
524 | hci_cmd_sync_queue(hdev, func: send_ps_cmd, NULL, NULL); |
525 | } |
526 | |
527 | /* NXP Firmware Download Feature */ |
528 | static int nxp_download_firmware(struct hci_dev *hdev) |
529 | { |
530 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
531 | int err = 0; |
532 | |
533 | nxpdev->fw_dnld_v1_offset = 0; |
534 | nxpdev->fw_v1_sent_bytes = 0; |
535 | nxpdev->fw_v1_expected_len = HDR_LEN; |
536 | nxpdev->boot_reg_offset = 0; |
537 | nxpdev->fw_v3_offset_correction = 0; |
538 | nxpdev->baudrate_changed = false; |
539 | nxpdev->timeout_changed = false; |
540 | nxpdev->helper_downloaded = false; |
541 | |
542 | serdev_device_set_baudrate(nxpdev->serdev, HCI_NXP_PRI_BAUDRATE); |
543 | serdev_device_set_flow_control(nxpdev->serdev, false); |
544 | nxpdev->current_baudrate = HCI_NXP_PRI_BAUDRATE; |
545 | |
546 | /* Wait till FW is downloaded */ |
547 | err = wait_event_interruptible_timeout(nxpdev->fw_dnld_done_wait_q, |
548 | !test_bit(BTNXPUART_FW_DOWNLOADING, |
549 | &nxpdev->tx_state), |
550 | msecs_to_jiffies(60000)); |
551 | if (err == 0) { |
552 | bt_dev_err(hdev, "FW Download Timeout." ); |
553 | return -ETIMEDOUT; |
554 | } |
555 | |
556 | serdev_device_set_flow_control(nxpdev->serdev, true); |
557 | release_firmware(fw: nxpdev->fw); |
558 | memset(nxpdev->fw_name, 0, sizeof(nxpdev->fw_name)); |
559 | |
560 | /* Allow the downloaded FW to initialize */ |
561 | msleep(msecs: 1200); |
562 | |
563 | return 0; |
564 | } |
565 | |
566 | static void nxp_send_ack(u8 ack, struct hci_dev *hdev) |
567 | { |
568 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
569 | u8 ack_nak[2]; |
570 | int len = 1; |
571 | |
572 | ack_nak[0] = ack; |
573 | if (ack == NXP_ACK_V3) { |
574 | ack_nak[1] = crc8(table: crc8_table, pdata: ack_nak, nbytes: 1, crc: 0xff); |
575 | len = 2; |
576 | } |
577 | serdev_device_write_buf(nxpdev->serdev, ack_nak, len); |
578 | } |
579 | |
580 | static bool nxp_fw_change_baudrate(struct hci_dev *hdev, u16 req_len) |
581 | { |
582 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
583 | struct nxp_bootloader_cmd nxp_cmd5; |
584 | struct uart_config uart_config; |
585 | u32 clkdivaddr = CLKDIVADDR - nxpdev->boot_reg_offset; |
586 | u32 uartdivaddr = UARTDIVADDR - nxpdev->boot_reg_offset; |
587 | u32 uartmcraddr = UARTMCRADDR - nxpdev->boot_reg_offset; |
588 | u32 uartreinitaddr = UARTREINITADDR - nxpdev->boot_reg_offset; |
589 | u32 uarticraddr = UARTICRADDR - nxpdev->boot_reg_offset; |
590 | u32 uartfcraddr = UARTFCRADDR - nxpdev->boot_reg_offset; |
591 | |
592 | if (req_len == sizeof(nxp_cmd5)) { |
593 | nxp_cmd5.header = __cpu_to_le32(5); |
594 | nxp_cmd5.arg = 0; |
595 | nxp_cmd5.payload_len = __cpu_to_le32(sizeof(uart_config)); |
596 | /* FW expects swapped CRC bytes */ |
597 | nxp_cmd5.crc = __cpu_to_be32(crc32_be(0UL, (char *)&nxp_cmd5, |
598 | sizeof(nxp_cmd5) - 4)); |
599 | |
600 | serdev_device_write_buf(nxpdev->serdev, (u8 *)&nxp_cmd5, sizeof(nxp_cmd5)); |
601 | nxpdev->fw_v3_offset_correction += req_len; |
602 | } else if (req_len == sizeof(uart_config)) { |
603 | uart_config.clkdiv.address = __cpu_to_le32(clkdivaddr); |
604 | uart_config.clkdiv.value = __cpu_to_le32(0x00c00000); |
605 | uart_config.uartdiv.address = __cpu_to_le32(uartdivaddr); |
606 | uart_config.uartdiv.value = __cpu_to_le32(1); |
607 | uart_config.mcr.address = __cpu_to_le32(uartmcraddr); |
608 | uart_config.mcr.value = __cpu_to_le32(MCR); |
609 | uart_config.re_init.address = __cpu_to_le32(uartreinitaddr); |
610 | uart_config.re_init.value = __cpu_to_le32(INIT); |
611 | uart_config.icr.address = __cpu_to_le32(uarticraddr); |
612 | uart_config.icr.value = __cpu_to_le32(ICR); |
613 | uart_config.fcr.address = __cpu_to_le32(uartfcraddr); |
614 | uart_config.fcr.value = __cpu_to_le32(FCR); |
615 | /* FW expects swapped CRC bytes */ |
616 | uart_config.crc = __cpu_to_be32(crc32_be(0UL, (char *)&uart_config, |
617 | sizeof(uart_config) - 4)); |
618 | |
619 | serdev_device_write_buf(nxpdev->serdev, (u8 *)&uart_config, sizeof(uart_config)); |
620 | serdev_device_wait_until_sent(nxpdev->serdev, 0); |
621 | nxpdev->fw_v3_offset_correction += req_len; |
622 | return true; |
623 | } |
624 | return false; |
625 | } |
626 | |
627 | static bool nxp_fw_change_timeout(struct hci_dev *hdev, u16 req_len) |
628 | { |
629 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
630 | struct nxp_bootloader_cmd nxp_cmd7; |
631 | |
632 | if (req_len != sizeof(nxp_cmd7)) |
633 | return false; |
634 | |
635 | nxp_cmd7.header = __cpu_to_le32(7); |
636 | nxp_cmd7.arg = __cpu_to_le32(0x70); |
637 | nxp_cmd7.payload_len = 0; |
638 | /* FW expects swapped CRC bytes */ |
639 | nxp_cmd7.crc = __cpu_to_be32(crc32_be(0UL, (char *)&nxp_cmd7, |
640 | sizeof(nxp_cmd7) - 4)); |
641 | serdev_device_write_buf(nxpdev->serdev, (u8 *)&nxp_cmd7, sizeof(nxp_cmd7)); |
642 | serdev_device_wait_until_sent(nxpdev->serdev, 0); |
643 | nxpdev->fw_v3_offset_correction += req_len; |
644 | return true; |
645 | } |
646 | |
647 | static u32 nxp_get_data_len(const u8 *buf) |
648 | { |
649 | struct nxp_bootloader_cmd *hdr = (struct nxp_bootloader_cmd *)buf; |
650 | |
651 | return __le32_to_cpu(hdr->payload_len); |
652 | } |
653 | |
654 | static bool is_fw_downloading(struct btnxpuart_dev *nxpdev) |
655 | { |
656 | return test_bit(BTNXPUART_FW_DOWNLOADING, &nxpdev->tx_state); |
657 | } |
658 | |
659 | static bool process_boot_signature(struct btnxpuart_dev *nxpdev) |
660 | { |
661 | if (test_bit(BTNXPUART_CHECK_BOOT_SIGNATURE, &nxpdev->tx_state)) { |
662 | clear_bit(BTNXPUART_CHECK_BOOT_SIGNATURE, addr: &nxpdev->tx_state); |
663 | wake_up_interruptible(&nxpdev->check_boot_sign_wait_q); |
664 | return false; |
665 | } |
666 | return is_fw_downloading(nxpdev); |
667 | } |
668 | |
669 | static int nxp_request_firmware(struct hci_dev *hdev, const char *fw_name) |
670 | { |
671 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
672 | int err = 0; |
673 | |
674 | if (!fw_name) |
675 | return -ENOENT; |
676 | |
677 | if (!strlen(nxpdev->fw_name)) { |
678 | snprintf(buf: nxpdev->fw_name, MAX_FW_FILE_NAME_LEN, fmt: "%s" , fw_name); |
679 | |
680 | bt_dev_dbg(hdev, "Request Firmware: %s" , nxpdev->fw_name); |
681 | err = request_firmware(fw: &nxpdev->fw, name: nxpdev->fw_name, device: &hdev->dev); |
682 | if (err < 0) { |
683 | bt_dev_err(hdev, "Firmware file %s not found" , nxpdev->fw_name); |
684 | clear_bit(BTNXPUART_FW_DOWNLOADING, addr: &nxpdev->tx_state); |
685 | } |
686 | } |
687 | return err; |
688 | } |
689 | |
690 | /* for legacy chipsets with V1 bootloader */ |
691 | static int nxp_recv_chip_ver_v1(struct hci_dev *hdev, struct sk_buff *skb) |
692 | { |
693 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
694 | struct v1_start_ind *req; |
695 | __u16 chip_id; |
696 | |
697 | req = skb_pull_data(skb, len: sizeof(*req)); |
698 | if (!req) |
699 | goto free_skb; |
700 | |
701 | chip_id = le16_to_cpu(req->chip_id ^ req->chip_id_comp); |
702 | if (chip_id == 0xffff && nxpdev->fw_dnld_v1_offset) { |
703 | nxpdev->fw_dnld_v1_offset = 0; |
704 | nxpdev->fw_v1_sent_bytes = 0; |
705 | nxpdev->fw_v1_expected_len = HDR_LEN; |
706 | release_firmware(fw: nxpdev->fw); |
707 | memset(nxpdev->fw_name, 0, sizeof(nxpdev->fw_name)); |
708 | nxp_send_ack(NXP_ACK_V1, hdev); |
709 | } |
710 | |
711 | free_skb: |
712 | kfree_skb(skb); |
713 | return 0; |
714 | } |
715 | |
716 | static int nxp_recv_fw_req_v1(struct hci_dev *hdev, struct sk_buff *skb) |
717 | { |
718 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
719 | struct btnxpuart_data *nxp_data = nxpdev->nxp_data; |
720 | struct v1_data_req *req; |
721 | __u16 len; |
722 | |
723 | if (!process_boot_signature(nxpdev)) |
724 | goto free_skb; |
725 | |
726 | req = skb_pull_data(skb, len: sizeof(*req)); |
727 | if (!req) |
728 | goto free_skb; |
729 | |
730 | len = __le16_to_cpu(req->len ^ req->len_comp); |
731 | if (len != 0xffff) { |
732 | bt_dev_dbg(hdev, "ERR: Send NAK" ); |
733 | nxp_send_ack(NXP_NAK_V1, hdev); |
734 | goto free_skb; |
735 | } |
736 | nxp_send_ack(NXP_ACK_V1, hdev); |
737 | |
738 | len = __le16_to_cpu(req->len); |
739 | |
740 | if (!nxp_data->helper_fw_name) { |
741 | if (!nxpdev->timeout_changed) { |
742 | nxpdev->timeout_changed = nxp_fw_change_timeout(hdev, |
743 | req_len: len); |
744 | goto free_skb; |
745 | } |
746 | if (!nxpdev->baudrate_changed) { |
747 | nxpdev->baudrate_changed = nxp_fw_change_baudrate(hdev, |
748 | req_len: len); |
749 | if (nxpdev->baudrate_changed) { |
750 | serdev_device_set_baudrate(nxpdev->serdev, |
751 | HCI_NXP_SEC_BAUDRATE); |
752 | serdev_device_set_flow_control(nxpdev->serdev, true); |
753 | nxpdev->current_baudrate = HCI_NXP_SEC_BAUDRATE; |
754 | } |
755 | goto free_skb; |
756 | } |
757 | } |
758 | |
759 | if (!nxp_data->helper_fw_name || nxpdev->helper_downloaded) { |
760 | if (nxp_request_firmware(hdev, fw_name: nxp_data->fw_name)) |
761 | goto free_skb; |
762 | } else if (nxp_data->helper_fw_name && !nxpdev->helper_downloaded) { |
763 | if (nxp_request_firmware(hdev, fw_name: nxp_data->helper_fw_name)) |
764 | goto free_skb; |
765 | } |
766 | |
767 | if (!len) { |
768 | bt_dev_dbg(hdev, "FW Downloaded Successfully: %zu bytes" , |
769 | nxpdev->fw->size); |
770 | if (nxp_data->helper_fw_name && !nxpdev->helper_downloaded) { |
771 | nxpdev->helper_downloaded = true; |
772 | serdev_device_wait_until_sent(nxpdev->serdev, 0); |
773 | serdev_device_set_baudrate(nxpdev->serdev, |
774 | HCI_NXP_SEC_BAUDRATE); |
775 | serdev_device_set_flow_control(nxpdev->serdev, true); |
776 | } else { |
777 | clear_bit(BTNXPUART_FW_DOWNLOADING, addr: &nxpdev->tx_state); |
778 | wake_up_interruptible(&nxpdev->fw_dnld_done_wait_q); |
779 | } |
780 | goto free_skb; |
781 | } |
782 | if (len & 0x01) { |
783 | /* The CRC did not match at the other end. |
784 | * Simply send the same bytes again. |
785 | */ |
786 | len = nxpdev->fw_v1_sent_bytes; |
787 | bt_dev_dbg(hdev, "CRC error. Resend %d bytes of FW." , len); |
788 | } else { |
789 | nxpdev->fw_dnld_v1_offset += nxpdev->fw_v1_sent_bytes; |
790 | |
791 | /* The FW bin file is made up of many blocks of |
792 | * 16 byte header and payload data chunks. If the |
793 | * FW has requested a header, read the payload length |
794 | * info from the header, before sending the header. |
795 | * In the next iteration, the FW should request the |
796 | * payload data chunk, which should be equal to the |
797 | * payload length read from header. If there is a |
798 | * mismatch, clearly the driver and FW are out of sync, |
799 | * and we need to re-send the previous header again. |
800 | */ |
801 | if (len == nxpdev->fw_v1_expected_len) { |
802 | if (len == HDR_LEN) |
803 | nxpdev->fw_v1_expected_len = nxp_get_data_len(buf: nxpdev->fw->data + |
804 | nxpdev->fw_dnld_v1_offset); |
805 | else |
806 | nxpdev->fw_v1_expected_len = HDR_LEN; |
807 | } else if (len == HDR_LEN) { |
808 | /* FW download out of sync. Send previous chunk again */ |
809 | nxpdev->fw_dnld_v1_offset -= nxpdev->fw_v1_sent_bytes; |
810 | nxpdev->fw_v1_expected_len = HDR_LEN; |
811 | } |
812 | } |
813 | |
814 | if (nxpdev->fw_dnld_v1_offset + len <= nxpdev->fw->size) |
815 | serdev_device_write_buf(nxpdev->serdev, nxpdev->fw->data + |
816 | nxpdev->fw_dnld_v1_offset, len); |
817 | nxpdev->fw_v1_sent_bytes = len; |
818 | |
819 | free_skb: |
820 | kfree_skb(skb); |
821 | return 0; |
822 | } |
823 | |
824 | static char *nxp_get_fw_name_from_chipid(struct hci_dev *hdev, u16 chipid, |
825 | u8 loader_ver) |
826 | { |
827 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
828 | char *fw_name = NULL; |
829 | |
830 | switch (chipid) { |
831 | case CHIP_ID_W9098: |
832 | fw_name = FIRMWARE_W9098; |
833 | break; |
834 | case CHIP_ID_IW416: |
835 | fw_name = FIRMWARE_IW416; |
836 | break; |
837 | case CHIP_ID_IW612: |
838 | fw_name = FIRMWARE_IW612; |
839 | break; |
840 | case CHIP_ID_IW624a: |
841 | case CHIP_ID_IW624c: |
842 | nxpdev->boot_reg_offset = 1; |
843 | if ((loader_ver & FW_SECURE_MASK) == FW_OPEN) |
844 | fw_name = FIRMWARE_IW624; |
845 | else if ((loader_ver & FW_SECURE_MASK) != FW_AUTH_ILLEGAL) |
846 | fw_name = FIRMWARE_SECURE_IW624; |
847 | else |
848 | bt_dev_err(hdev, "Illegal loader version %02x" , loader_ver); |
849 | break; |
850 | case CHIP_ID_AW693: |
851 | if ((loader_ver & FW_SECURE_MASK) == FW_OPEN) |
852 | fw_name = FIRMWARE_AW693; |
853 | else if ((loader_ver & FW_SECURE_MASK) != FW_AUTH_ILLEGAL) |
854 | fw_name = FIRMWARE_SECURE_AW693; |
855 | else |
856 | bt_dev_err(hdev, "Illegal loader version %02x" , loader_ver); |
857 | break; |
858 | default: |
859 | bt_dev_err(hdev, "Unknown chip signature %04x" , chipid); |
860 | break; |
861 | } |
862 | return fw_name; |
863 | } |
864 | |
865 | static int nxp_recv_chip_ver_v3(struct hci_dev *hdev, struct sk_buff *skb) |
866 | { |
867 | struct v3_start_ind *req = skb_pull_data(skb, len: sizeof(*req)); |
868 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
869 | u16 chip_id; |
870 | u8 loader_ver; |
871 | |
872 | if (!process_boot_signature(nxpdev)) |
873 | goto free_skb; |
874 | |
875 | chip_id = le16_to_cpu(req->chip_id); |
876 | loader_ver = req->loader_ver; |
877 | if (!nxp_request_firmware(hdev, fw_name: nxp_get_fw_name_from_chipid(hdev, |
878 | chipid: chip_id, loader_ver))) |
879 | nxp_send_ack(NXP_ACK_V3, hdev); |
880 | |
881 | free_skb: |
882 | kfree_skb(skb); |
883 | return 0; |
884 | } |
885 | |
886 | static int nxp_recv_fw_req_v3(struct hci_dev *hdev, struct sk_buff *skb) |
887 | { |
888 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
889 | struct v3_data_req *req; |
890 | __u16 len; |
891 | __u32 offset; |
892 | |
893 | if (!process_boot_signature(nxpdev)) |
894 | goto free_skb; |
895 | |
896 | req = skb_pull_data(skb, len: sizeof(*req)); |
897 | if (!req || !nxpdev->fw) |
898 | goto free_skb; |
899 | |
900 | nxp_send_ack(NXP_ACK_V3, hdev); |
901 | |
902 | len = __le16_to_cpu(req->len); |
903 | |
904 | if (!nxpdev->timeout_changed) { |
905 | nxpdev->timeout_changed = nxp_fw_change_timeout(hdev, req_len: len); |
906 | goto free_skb; |
907 | } |
908 | |
909 | if (!nxpdev->baudrate_changed) { |
910 | nxpdev->baudrate_changed = nxp_fw_change_baudrate(hdev, req_len: len); |
911 | if (nxpdev->baudrate_changed) { |
912 | serdev_device_set_baudrate(nxpdev->serdev, |
913 | HCI_NXP_SEC_BAUDRATE); |
914 | serdev_device_set_flow_control(nxpdev->serdev, true); |
915 | nxpdev->current_baudrate = HCI_NXP_SEC_BAUDRATE; |
916 | } |
917 | goto free_skb; |
918 | } |
919 | |
920 | if (req->len == 0) { |
921 | bt_dev_dbg(hdev, "FW Downloaded Successfully: %zu bytes" , |
922 | nxpdev->fw->size); |
923 | clear_bit(BTNXPUART_FW_DOWNLOADING, addr: &nxpdev->tx_state); |
924 | wake_up_interruptible(&nxpdev->fw_dnld_done_wait_q); |
925 | goto free_skb; |
926 | } |
927 | if (req->error) |
928 | bt_dev_dbg(hdev, "FW Download received err 0x%02x from chip" , |
929 | req->error); |
930 | |
931 | offset = __le32_to_cpu(req->offset); |
932 | if (offset < nxpdev->fw_v3_offset_correction) { |
933 | /* This scenario should ideally never occur. But if it ever does, |
934 | * FW is out of sync and needs a power cycle. |
935 | */ |
936 | bt_dev_err(hdev, "Something went wrong during FW download" ); |
937 | bt_dev_err(hdev, "Please power cycle and try again" ); |
938 | goto free_skb; |
939 | } |
940 | |
941 | serdev_device_write_buf(nxpdev->serdev, nxpdev->fw->data + offset - |
942 | nxpdev->fw_v3_offset_correction, len); |
943 | |
944 | free_skb: |
945 | kfree_skb(skb); |
946 | return 0; |
947 | } |
948 | |
949 | static int nxp_set_baudrate_cmd(struct hci_dev *hdev, void *data) |
950 | { |
951 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
952 | __le32 new_baudrate = __cpu_to_le32(nxpdev->new_baudrate); |
953 | struct ps_data *psdata = &nxpdev->psdata; |
954 | struct sk_buff *skb; |
955 | u8 *status; |
956 | |
957 | if (!psdata) |
958 | return 0; |
959 | |
960 | skb = nxp_drv_send_cmd(hdev, HCI_NXP_SET_OPER_SPEED, plen: 4, param: (u8 *)&new_baudrate); |
961 | if (IS_ERR(ptr: skb)) { |
962 | bt_dev_err(hdev, "Setting baudrate failed (%ld)" , PTR_ERR(skb)); |
963 | return PTR_ERR(ptr: skb); |
964 | } |
965 | |
966 | status = (u8 *)skb_pull_data(skb, len: 1); |
967 | if (status) { |
968 | if (*status == 0) { |
969 | serdev_device_set_baudrate(nxpdev->serdev, nxpdev->new_baudrate); |
970 | nxpdev->current_baudrate = nxpdev->new_baudrate; |
971 | } |
972 | bt_dev_dbg(hdev, "Set baudrate response: status=%d, baudrate=%d" , |
973 | *status, nxpdev->new_baudrate); |
974 | } |
975 | kfree_skb(skb); |
976 | |
977 | return 0; |
978 | } |
979 | |
980 | static int nxp_check_boot_sign(struct btnxpuart_dev *nxpdev) |
981 | { |
982 | serdev_device_set_baudrate(nxpdev->serdev, HCI_NXP_PRI_BAUDRATE); |
983 | if (test_bit(BTNXPUART_IR_IN_PROGRESS, &nxpdev->tx_state)) |
984 | serdev_device_set_flow_control(nxpdev->serdev, false); |
985 | else |
986 | serdev_device_set_flow_control(nxpdev->serdev, true); |
987 | set_bit(BTNXPUART_CHECK_BOOT_SIGNATURE, addr: &nxpdev->tx_state); |
988 | |
989 | return wait_event_interruptible_timeout(nxpdev->check_boot_sign_wait_q, |
990 | !test_bit(BTNXPUART_CHECK_BOOT_SIGNATURE, |
991 | &nxpdev->tx_state), |
992 | msecs_to_jiffies(1000)); |
993 | } |
994 | |
995 | static int nxp_set_ind_reset(struct hci_dev *hdev, void *data) |
996 | { |
997 | static const u8 ir_hw_err[] = { HCI_EV_HARDWARE_ERROR, |
998 | 0x01, BTNXPUART_IR_HW_ERR }; |
999 | struct sk_buff *skb; |
1000 | |
1001 | skb = bt_skb_alloc(len: 3, GFP_ATOMIC); |
1002 | if (!skb) |
1003 | return -ENOMEM; |
1004 | |
1005 | hci_skb_pkt_type(skb) = HCI_EVENT_PKT; |
1006 | skb_put_data(skb, data: ir_hw_err, len: 3); |
1007 | |
1008 | /* Inject Hardware Error to upper stack */ |
1009 | return hci_recv_frame(hdev, skb); |
1010 | } |
1011 | |
1012 | /* NXP protocol */ |
1013 | static int nxp_setup(struct hci_dev *hdev) |
1014 | { |
1015 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
1016 | int err = 0; |
1017 | |
1018 | if (nxp_check_boot_sign(nxpdev)) { |
1019 | bt_dev_dbg(hdev, "Need FW Download." ); |
1020 | err = nxp_download_firmware(hdev); |
1021 | if (err < 0) |
1022 | return err; |
1023 | } else { |
1024 | bt_dev_dbg(hdev, "FW already running." ); |
1025 | clear_bit(BTNXPUART_FW_DOWNLOADING, addr: &nxpdev->tx_state); |
1026 | } |
1027 | |
1028 | serdev_device_set_baudrate(nxpdev->serdev, nxpdev->fw_init_baudrate); |
1029 | nxpdev->current_baudrate = nxpdev->fw_init_baudrate; |
1030 | |
1031 | if (nxpdev->current_baudrate != HCI_NXP_SEC_BAUDRATE) { |
1032 | nxpdev->new_baudrate = HCI_NXP_SEC_BAUDRATE; |
1033 | hci_cmd_sync_queue(hdev, func: nxp_set_baudrate_cmd, NULL, NULL); |
1034 | } |
1035 | |
1036 | ps_init(hdev); |
1037 | |
1038 | if (test_and_clear_bit(BTNXPUART_IR_IN_PROGRESS, addr: &nxpdev->tx_state)) |
1039 | hci_dev_clear_flag(hdev, HCI_SETUP); |
1040 | |
1041 | return 0; |
1042 | } |
1043 | |
1044 | static void nxp_hw_err(struct hci_dev *hdev, u8 code) |
1045 | { |
1046 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
1047 | |
1048 | switch (code) { |
1049 | case BTNXPUART_IR_HW_ERR: |
1050 | set_bit(BTNXPUART_IR_IN_PROGRESS, addr: &nxpdev->tx_state); |
1051 | hci_dev_set_flag(hdev, HCI_SETUP); |
1052 | break; |
1053 | default: |
1054 | break; |
1055 | } |
1056 | } |
1057 | |
1058 | static int nxp_shutdown(struct hci_dev *hdev) |
1059 | { |
1060 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
1061 | struct sk_buff *skb; |
1062 | u8 *status; |
1063 | u8 pcmd = 0; |
1064 | |
1065 | if (test_bit(BTNXPUART_IR_IN_PROGRESS, &nxpdev->tx_state)) { |
1066 | skb = nxp_drv_send_cmd(hdev, HCI_NXP_IND_RESET, plen: 1, param: &pcmd); |
1067 | if (IS_ERR(ptr: skb)) |
1068 | return PTR_ERR(ptr: skb); |
1069 | |
1070 | status = skb_pull_data(skb, len: 1); |
1071 | if (status) { |
1072 | serdev_device_set_flow_control(nxpdev->serdev, false); |
1073 | set_bit(BTNXPUART_FW_DOWNLOADING, addr: &nxpdev->tx_state); |
1074 | } |
1075 | kfree_skb(skb); |
1076 | } |
1077 | |
1078 | return 0; |
1079 | } |
1080 | |
1081 | static int btnxpuart_queue_skb(struct hci_dev *hdev, struct sk_buff *skb) |
1082 | { |
1083 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
1084 | |
1085 | /* Prepend skb with frame type */ |
1086 | memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); |
1087 | skb_queue_tail(list: &nxpdev->txq, newsk: skb); |
1088 | btnxpuart_tx_wakeup(nxpdev); |
1089 | return 0; |
1090 | } |
1091 | |
1092 | static int nxp_enqueue(struct hci_dev *hdev, struct sk_buff *skb) |
1093 | { |
1094 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
1095 | struct ps_data *psdata = &nxpdev->psdata; |
1096 | struct hci_command_hdr *hdr; |
1097 | struct psmode_cmd_payload ps_parm; |
1098 | struct wakeup_cmd_payload wakeup_parm; |
1099 | __le32 baudrate_parm; |
1100 | |
1101 | /* if vendor commands are received from user space (e.g. hcitool), update |
1102 | * driver flags accordingly and ask driver to re-send the command to FW. |
1103 | * In case the payload for any command does not match expected payload |
1104 | * length, let the firmware and user space program handle it, or throw |
1105 | * an error. |
1106 | */ |
1107 | if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT && !psdata->driver_sent_cmd) { |
1108 | hdr = (struct hci_command_hdr *)skb->data; |
1109 | if (hdr->plen != (skb->len - HCI_COMMAND_HDR_SIZE)) |
1110 | return btnxpuart_queue_skb(hdev, skb); |
1111 | |
1112 | switch (__le16_to_cpu(hdr->opcode)) { |
1113 | case HCI_NXP_AUTO_SLEEP_MODE: |
1114 | if (hdr->plen == sizeof(ps_parm)) { |
1115 | memcpy(&ps_parm, skb->data + HCI_COMMAND_HDR_SIZE, hdr->plen); |
1116 | if (ps_parm.ps_cmd == BT_PS_ENABLE) |
1117 | psdata->target_ps_mode = PS_MODE_ENABLE; |
1118 | else if (ps_parm.ps_cmd == BT_PS_DISABLE) |
1119 | psdata->target_ps_mode = PS_MODE_DISABLE; |
1120 | psdata->c2h_ps_interval = __le16_to_cpu(ps_parm.c2h_ps_interval); |
1121 | hci_cmd_sync_queue(hdev, func: send_ps_cmd, NULL, NULL); |
1122 | goto free_skb; |
1123 | } |
1124 | break; |
1125 | case HCI_NXP_WAKEUP_METHOD: |
1126 | if (hdr->plen == sizeof(wakeup_parm)) { |
1127 | memcpy(&wakeup_parm, skb->data + HCI_COMMAND_HDR_SIZE, hdr->plen); |
1128 | psdata->c2h_wakeupmode = wakeup_parm.c2h_wakeupmode; |
1129 | psdata->c2h_wakeup_gpio = wakeup_parm.c2h_wakeup_gpio; |
1130 | psdata->h2c_wakeup_gpio = wakeup_parm.h2c_wakeup_gpio; |
1131 | switch (wakeup_parm.h2c_wakeupmode) { |
1132 | case BT_CTRL_WAKEUP_METHOD_DSR: |
1133 | psdata->h2c_wakeupmode = WAKEUP_METHOD_DTR; |
1134 | break; |
1135 | case BT_CTRL_WAKEUP_METHOD_BREAK: |
1136 | default: |
1137 | psdata->h2c_wakeupmode = WAKEUP_METHOD_BREAK; |
1138 | break; |
1139 | } |
1140 | hci_cmd_sync_queue(hdev, func: send_wakeup_method_cmd, NULL, NULL); |
1141 | goto free_skb; |
1142 | } |
1143 | break; |
1144 | case HCI_NXP_SET_OPER_SPEED: |
1145 | if (hdr->plen == sizeof(baudrate_parm)) { |
1146 | memcpy(&baudrate_parm, skb->data + HCI_COMMAND_HDR_SIZE, hdr->plen); |
1147 | nxpdev->new_baudrate = __le32_to_cpu(baudrate_parm); |
1148 | hci_cmd_sync_queue(hdev, func: nxp_set_baudrate_cmd, NULL, NULL); |
1149 | goto free_skb; |
1150 | } |
1151 | break; |
1152 | case HCI_NXP_IND_RESET: |
1153 | if (hdr->plen == 1) { |
1154 | hci_cmd_sync_queue(hdev, func: nxp_set_ind_reset, NULL, NULL); |
1155 | goto free_skb; |
1156 | } |
1157 | break; |
1158 | default: |
1159 | break; |
1160 | } |
1161 | } |
1162 | |
1163 | return btnxpuart_queue_skb(hdev, skb); |
1164 | |
1165 | free_skb: |
1166 | kfree_skb(skb); |
1167 | return 0; |
1168 | } |
1169 | |
1170 | static struct sk_buff *nxp_dequeue(void *data) |
1171 | { |
1172 | struct btnxpuart_dev *nxpdev = (struct btnxpuart_dev *)data; |
1173 | |
1174 | ps_wakeup(nxpdev); |
1175 | ps_start_timer(nxpdev); |
1176 | return skb_dequeue(list: &nxpdev->txq); |
1177 | } |
1178 | |
1179 | /* btnxpuart based on serdev */ |
1180 | static void btnxpuart_tx_work(struct work_struct *work) |
1181 | { |
1182 | struct btnxpuart_dev *nxpdev = container_of(work, struct btnxpuart_dev, |
1183 | tx_work); |
1184 | struct serdev_device *serdev = nxpdev->serdev; |
1185 | struct hci_dev *hdev = nxpdev->hdev; |
1186 | struct sk_buff *skb; |
1187 | int len; |
1188 | |
1189 | while ((skb = nxp_dequeue(data: nxpdev))) { |
1190 | len = serdev_device_write_buf(serdev, skb->data, skb->len); |
1191 | hdev->stat.byte_tx += len; |
1192 | |
1193 | skb_pull(skb, len); |
1194 | if (skb->len > 0) { |
1195 | skb_queue_head(list: &nxpdev->txq, newsk: skb); |
1196 | break; |
1197 | } |
1198 | |
1199 | switch (hci_skb_pkt_type(skb)) { |
1200 | case HCI_COMMAND_PKT: |
1201 | hdev->stat.cmd_tx++; |
1202 | break; |
1203 | case HCI_ACLDATA_PKT: |
1204 | hdev->stat.acl_tx++; |
1205 | break; |
1206 | case HCI_SCODATA_PKT: |
1207 | hdev->stat.sco_tx++; |
1208 | break; |
1209 | } |
1210 | |
1211 | kfree_skb(skb); |
1212 | } |
1213 | clear_bit(BTNXPUART_TX_STATE_ACTIVE, addr: &nxpdev->tx_state); |
1214 | } |
1215 | |
1216 | static int btnxpuart_open(struct hci_dev *hdev) |
1217 | { |
1218 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
1219 | int err = 0; |
1220 | |
1221 | err = serdev_device_open(nxpdev->serdev); |
1222 | if (err) { |
1223 | bt_dev_err(hdev, "Unable to open UART device %s" , |
1224 | dev_name(&nxpdev->serdev->dev)); |
1225 | } else { |
1226 | set_bit(BTNXPUART_SERDEV_OPEN, addr: &nxpdev->tx_state); |
1227 | } |
1228 | return err; |
1229 | } |
1230 | |
1231 | static int btnxpuart_close(struct hci_dev *hdev) |
1232 | { |
1233 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
1234 | |
1235 | ps_wakeup(nxpdev); |
1236 | serdev_device_close(nxpdev->serdev); |
1237 | clear_bit(BTNXPUART_SERDEV_OPEN, addr: &nxpdev->tx_state); |
1238 | return 0; |
1239 | } |
1240 | |
1241 | static int btnxpuart_flush(struct hci_dev *hdev) |
1242 | { |
1243 | struct btnxpuart_dev *nxpdev = hci_get_drvdata(hdev); |
1244 | |
1245 | /* Flush any pending characters */ |
1246 | serdev_device_write_flush(nxpdev->serdev); |
1247 | skb_queue_purge(list: &nxpdev->txq); |
1248 | |
1249 | cancel_work_sync(work: &nxpdev->tx_work); |
1250 | |
1251 | kfree_skb(skb: nxpdev->rx_skb); |
1252 | nxpdev->rx_skb = NULL; |
1253 | |
1254 | return 0; |
1255 | } |
1256 | |
1257 | static const struct h4_recv_pkt nxp_recv_pkts[] = { |
1258 | { H4_RECV_ACL, .recv = hci_recv_frame }, |
1259 | { H4_RECV_SCO, .recv = hci_recv_frame }, |
1260 | { H4_RECV_EVENT, .recv = hci_recv_frame }, |
1261 | { NXP_RECV_CHIP_VER_V1, .recv = nxp_recv_chip_ver_v1 }, |
1262 | { NXP_RECV_FW_REQ_V1, .recv = nxp_recv_fw_req_v1 }, |
1263 | { NXP_RECV_CHIP_VER_V3, .recv = nxp_recv_chip_ver_v3 }, |
1264 | { NXP_RECV_FW_REQ_V3, .recv = nxp_recv_fw_req_v3 }, |
1265 | }; |
1266 | |
1267 | static int btnxpuart_receive_buf(struct serdev_device *serdev, const u8 *data, |
1268 | size_t count) |
1269 | { |
1270 | struct btnxpuart_dev *nxpdev = serdev_device_get_drvdata(serdev); |
1271 | |
1272 | ps_start_timer(nxpdev); |
1273 | |
1274 | nxpdev->rx_skb = h4_recv_buf(hdev: nxpdev->hdev, skb: nxpdev->rx_skb, buffer: data, count, |
1275 | pkts: nxp_recv_pkts, ARRAY_SIZE(nxp_recv_pkts)); |
1276 | if (IS_ERR(ptr: nxpdev->rx_skb)) { |
1277 | int err = PTR_ERR(ptr: nxpdev->rx_skb); |
1278 | /* Safe to ignore out-of-sync bootloader signatures */ |
1279 | if (is_fw_downloading(nxpdev)) |
1280 | return count; |
1281 | bt_dev_err(nxpdev->hdev, "Frame reassembly failed (%d)" , err); |
1282 | nxpdev->rx_skb = NULL; |
1283 | return err; |
1284 | } |
1285 | if (!is_fw_downloading(nxpdev)) |
1286 | nxpdev->hdev->stat.byte_rx += count; |
1287 | return count; |
1288 | } |
1289 | |
1290 | static void btnxpuart_write_wakeup(struct serdev_device *serdev) |
1291 | { |
1292 | serdev_device_write_wakeup(serdev); |
1293 | } |
1294 | |
1295 | static const struct serdev_device_ops btnxpuart_client_ops = { |
1296 | .receive_buf = btnxpuart_receive_buf, |
1297 | .write_wakeup = btnxpuart_write_wakeup, |
1298 | }; |
1299 | |
1300 | static int nxp_serdev_probe(struct serdev_device *serdev) |
1301 | { |
1302 | struct hci_dev *hdev; |
1303 | struct btnxpuart_dev *nxpdev; |
1304 | |
1305 | nxpdev = devm_kzalloc(dev: &serdev->dev, size: sizeof(*nxpdev), GFP_KERNEL); |
1306 | if (!nxpdev) |
1307 | return -ENOMEM; |
1308 | |
1309 | nxpdev->nxp_data = (struct btnxpuart_data *)device_get_match_data(dev: &serdev->dev); |
1310 | |
1311 | nxpdev->serdev = serdev; |
1312 | serdev_device_set_drvdata(serdev, data: nxpdev); |
1313 | |
1314 | serdev_device_set_client_ops(serdev, ops: &btnxpuart_client_ops); |
1315 | |
1316 | INIT_WORK(&nxpdev->tx_work, btnxpuart_tx_work); |
1317 | skb_queue_head_init(list: &nxpdev->txq); |
1318 | |
1319 | init_waitqueue_head(&nxpdev->fw_dnld_done_wait_q); |
1320 | init_waitqueue_head(&nxpdev->check_boot_sign_wait_q); |
1321 | |
1322 | device_property_read_u32(dev: &nxpdev->serdev->dev, propname: "fw-init-baudrate" , |
1323 | val: &nxpdev->fw_init_baudrate); |
1324 | if (!nxpdev->fw_init_baudrate) |
1325 | nxpdev->fw_init_baudrate = FW_INIT_BAUDRATE; |
1326 | |
1327 | set_bit(BTNXPUART_FW_DOWNLOADING, addr: &nxpdev->tx_state); |
1328 | |
1329 | crc8_populate_msb(table: crc8_table, POLYNOMIAL8); |
1330 | |
1331 | /* Initialize and register HCI device */ |
1332 | hdev = hci_alloc_dev(); |
1333 | if (!hdev) { |
1334 | dev_err(&serdev->dev, "Can't allocate HCI device\n" ); |
1335 | return -ENOMEM; |
1336 | } |
1337 | |
1338 | nxpdev->hdev = hdev; |
1339 | |
1340 | hdev->bus = HCI_UART; |
1341 | hci_set_drvdata(hdev, data: nxpdev); |
1342 | |
1343 | hdev->manufacturer = MANUFACTURER_NXP; |
1344 | hdev->open = btnxpuart_open; |
1345 | hdev->close = btnxpuart_close; |
1346 | hdev->flush = btnxpuart_flush; |
1347 | hdev->setup = nxp_setup; |
1348 | hdev->send = nxp_enqueue; |
1349 | hdev->hw_error = nxp_hw_err; |
1350 | hdev->shutdown = nxp_shutdown; |
1351 | SET_HCIDEV_DEV(hdev, &serdev->dev); |
1352 | |
1353 | if (hci_register_dev(hdev) < 0) { |
1354 | dev_err(&serdev->dev, "Can't register HCI device\n" ); |
1355 | hci_free_dev(hdev); |
1356 | return -ENODEV; |
1357 | } |
1358 | |
1359 | ps_setup(hdev); |
1360 | |
1361 | return 0; |
1362 | } |
1363 | |
1364 | static void nxp_serdev_remove(struct serdev_device *serdev) |
1365 | { |
1366 | struct btnxpuart_dev *nxpdev = serdev_device_get_drvdata(serdev); |
1367 | struct hci_dev *hdev = nxpdev->hdev; |
1368 | |
1369 | /* Restore FW baudrate to fw_init_baudrate if changed. |
1370 | * This will ensure FW baudrate is in sync with |
1371 | * driver baudrate in case this driver is re-inserted. |
1372 | */ |
1373 | if (nxpdev->current_baudrate != nxpdev->fw_init_baudrate) { |
1374 | nxpdev->new_baudrate = nxpdev->fw_init_baudrate; |
1375 | nxp_set_baudrate_cmd(hdev, NULL); |
1376 | } |
1377 | |
1378 | ps_cancel_timer(nxpdev); |
1379 | hci_unregister_dev(hdev); |
1380 | hci_free_dev(hdev); |
1381 | } |
1382 | |
1383 | static struct btnxpuart_data w8987_data __maybe_unused = { |
1384 | .helper_fw_name = NULL, |
1385 | .fw_name = FIRMWARE_W8987, |
1386 | }; |
1387 | |
1388 | static struct btnxpuart_data w8997_data __maybe_unused = { |
1389 | .helper_fw_name = FIRMWARE_HELPER, |
1390 | .fw_name = FIRMWARE_W8997, |
1391 | }; |
1392 | |
1393 | static const struct of_device_id nxpuart_of_match_table[] __maybe_unused = { |
1394 | { .compatible = "nxp,88w8987-bt" , .data = &w8987_data }, |
1395 | { .compatible = "nxp,88w8997-bt" , .data = &w8997_data }, |
1396 | { } |
1397 | }; |
1398 | MODULE_DEVICE_TABLE(of, nxpuart_of_match_table); |
1399 | |
1400 | static struct serdev_device_driver nxp_serdev_driver = { |
1401 | .probe = nxp_serdev_probe, |
1402 | .remove = nxp_serdev_remove, |
1403 | .driver = { |
1404 | .name = "btnxpuart" , |
1405 | .of_match_table = of_match_ptr(nxpuart_of_match_table), |
1406 | }, |
1407 | }; |
1408 | |
1409 | module_serdev_device_driver(nxp_serdev_driver); |
1410 | |
1411 | MODULE_AUTHOR("Neeraj Sanjay Kale <neeraj.sanjaykale@nxp.com>" ); |
1412 | MODULE_DESCRIPTION("NXP Bluetooth Serial driver" ); |
1413 | MODULE_LICENSE("GPL" ); |
1414 | |