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