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