drivers/bluetooth/btnxpuart.c

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