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