drivers/bluetooth/hci_nokia.c

   1 /*
   2  *  Bluetooth HCI UART H4 driver with Nokia Extensions AKA Nokia H4+
   3  *
   4  *  Copyright (C) 2015 Marcel Holtmann <marcel@holtmann.org>
   5  *  Copyright (C) 2015-2017 Sebastian Reichel <sre@kernel.org>
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  */
  17
  18 #include <linux/clk.h>
  19 #include <linux/errno.h>
  20 #include <linux/firmware.h>
  21 #include <linux/gpio/consumer.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/of.h>
  26 #include <linux/pm_runtime.h>
  27 #include <linux/serdev.h>
  28 #include <linux/skbuff.h>
  29 #include <linux/slab.h>
  30 #include <linux/string.h>
  31 #include <linux/types.h>
  32 #include <asm/unaligned.h>
  33 #include <net/bluetooth/bluetooth.h>
  34 #include <net/bluetooth/hci_core.h>
  35
  36 #include "hci_uart.h"
  37 #include "btbcm.h"
  38
  39 #define VERSION "0.1"
  40
  41 #define NOKIA_ID_BCM2048        0x04
  42 #define NOKIA_ID_TI1271         0x31
  43
  44 #define FIRMWARE_BCM2048        "nokia/bcmfw.bin"
  45 #define FIRMWARE_TI1271         "nokia/ti1273.bin"
  46
  47 #define HCI_NOKIA_NEG_PKT       0x06
  48 #define HCI_NOKIA_ALIVE_PKT     0x07
  49 #define HCI_NOKIA_RADIO_PKT     0x08
  50
  51 #define HCI_NOKIA_NEG_HDR_SIZE          1
  52 #define HCI_NOKIA_MAX_NEG_SIZE          255
  53 #define HCI_NOKIA_ALIVE_HDR_SIZE        1
  54 #define HCI_NOKIA_MAX_ALIVE_SIZE        255
  55 #define HCI_NOKIA_RADIO_HDR_SIZE        2
  56 #define HCI_NOKIA_MAX_RADIO_SIZE        255
  57
  58 #define NOKIA_PROTO_PKT         0x44
  59 #define NOKIA_PROTO_BYTE        0x4c
  60
  61 #define NOKIA_NEG_REQ           0x00
  62 #define NOKIA_NEG_ACK           0x20
  63 #define NOKIA_NEG_NAK           0x40
  64
  65 #define H4_TYPE_SIZE            1
  66
  67 #define NOKIA_RECV_ALIVE \
  68         .type = HCI_NOKIA_ALIVE_PKT, \
  69         .hlen = HCI_NOKIA_ALIVE_HDR_SIZE, \
  70         .loff = 0, \
  71         .lsize = 1, \
  72         .maxlen = HCI_NOKIA_MAX_ALIVE_SIZE \
  73
  74 #define NOKIA_RECV_NEG \
  75         .type = HCI_NOKIA_NEG_PKT, \
  76         .hlen = HCI_NOKIA_NEG_HDR_SIZE, \
  77         .loff = 0, \
  78         .lsize = 1, \
  79         .maxlen = HCI_NOKIA_MAX_NEG_SIZE \
  80
  81 #define NOKIA_RECV_RADIO \
  82         .type = HCI_NOKIA_RADIO_PKT, \
  83         .hlen = HCI_NOKIA_RADIO_HDR_SIZE, \
  84         .loff = 1, \
  85         .lsize = 1, \
  86         .maxlen = HCI_NOKIA_MAX_RADIO_SIZE \
  87
  88 struct hci_nokia_neg_hdr {
  89         u8      dlen;
  90 } __packed;
  91
  92 struct hci_nokia_neg_cmd {
  93         u8      ack;
  94         u16     baud;
  95         u16     unused1;
  96         u8      proto;
  97         u16     sys_clk;
  98         u16     unused2;
  99 } __packed;
 100
 101 #define NOKIA_ALIVE_REQ   0x55
 102 #define NOKIA_ALIVE_RESP  0xcc
 103
 104 struct hci_nokia_alive_hdr {
 105         u8      dlen;
 106 } __packed;
 107
 108 struct hci_nokia_alive_pkt {
 109         u8      mid;
 110         u8      unused;
 111 } __packed;
 112
 113 struct hci_nokia_neg_evt {
 114         u8      ack;
 115         u16     baud;
 116         u16     unused1;
 117         u8      proto;
 118         u16     sys_clk;
 119         u16     unused2;
 120         u8      man_id;
 121         u8      ver_id;
 122 } __packed;
 123
 124 #define MAX_BAUD_RATE           3692300
 125 #define SETUP_BAUD_RATE         921600
 126 #define INIT_BAUD_RATE          120000
 127
 128 struct hci_nokia_radio_hdr {
 129         u8      evt;
 130         u8      dlen;
 131 } __packed;
 132
 133 struct nokia_bt_dev {
 134         struct hci_uart hu;
 135         struct serdev_device *serdev;
 136
 137         struct gpio_desc *reset;
 138         struct gpio_desc *wakeup_host;
 139         struct gpio_desc *wakeup_bt;
 140         unsigned long sysclk_speed;
 141
 142         int wake_irq;
 143         struct sk_buff *rx_skb;
 144         struct sk_buff_head txq;
 145         bdaddr_t bdaddr;
 146
 147         int init_error;
 148         struct completion init_completion;
 149
 150         u8 man_id;
 151         u8 ver_id;
 152
 153         bool initialized;
 154         bool tx_enabled;
 155         bool rx_enabled;
 156 };
 157
 158 static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb);
 159
 160 static void nokia_flow_control(struct serdev_device *serdev, bool enable)
 161 {
 162         if (enable) {
 163                 serdev_device_set_rts(serdev, true);
 164                 serdev_device_set_flow_control(serdev, true);
 165         } else {
 166                 serdev_device_set_flow_control(serdev, false);
 167                 serdev_device_set_rts(serdev, false);
 168         }
 169 }
 170
 171 static irqreturn_t wakeup_handler(int irq, void *data)
 172 {
 173         struct nokia_bt_dev *btdev = data;
 174         struct device *dev = &btdev->serdev->dev;
 175         int wake_state = gpiod_get_value(btdev->wakeup_host);
 176
 177         if (btdev->rx_enabled == wake_state)
 178                 return IRQ_HANDLED;
 179
 180         if (wake_state)
 181                 pm_runtime_get(dev);
 182         else
 183                 pm_runtime_put(dev);
 184
 185         btdev->rx_enabled = wake_state;
 186
 187         return IRQ_HANDLED;
 188 }
 189
 190 static int nokia_reset(struct hci_uart *hu)
 191 {
 192         struct nokia_bt_dev *btdev = hu->priv;
 193         struct device *dev = &btdev->serdev->dev;
 194         int err;
 195
 196         /* reset routine */
 197         gpiod_set_value_cansleep(btdev->reset, 1);
 198         gpiod_set_value_cansleep(btdev->wakeup_bt, 1);
 199
 200         msleep(100);
 201
 202         /* safety check */
 203         err = gpiod_get_value_cansleep(btdev->wakeup_host);
 204         if (err == 1) {
 205                 dev_err(dev, "reset: host wakeup not low!");
 206                 return -EPROTO;
 207         }
 208
 209         /* flush queue */
 210         serdev_device_write_flush(btdev->serdev);
 211
 212         /* init uart */
 213         nokia_flow_control(btdev->serdev, false);
 214         serdev_device_set_baudrate(btdev->serdev, INIT_BAUD_RATE);
 215
 216         gpiod_set_value_cansleep(btdev->reset, 0);
 217
 218         /* wait for cts */
 219         err = serdev_device_wait_for_cts(btdev->serdev, true, 200);
 220         if (err < 0) {
 221                 dev_err(dev, "CTS not received: %d", err);
 222                 return err;
 223         }
 224
 225         nokia_flow_control(btdev->serdev, true);
 226
 227         return 0;
 228 }
 229
 230 static int nokia_send_alive_packet(struct hci_uart *hu)
 231 {
 232         struct nokia_bt_dev *btdev = hu->priv;
 233         struct device *dev = &btdev->serdev->dev;
 234         struct hci_nokia_alive_hdr *hdr;
 235         struct hci_nokia_alive_pkt *pkt;
 236         struct sk_buff *skb;
 237         int len;
 238
 239         init_completion(&btdev->init_completion);
 240
 241         len = H4_TYPE_SIZE + sizeof(*hdr) + sizeof(*pkt);
 242         skb = bt_skb_alloc(len, GFP_KERNEL);
 243         if (!skb)
 244                 return -ENOMEM;
 245
 246         hci_skb_pkt_type(skb) = HCI_NOKIA_ALIVE_PKT;
 247         memset(skb->data, 0x00, len);
 248
 249         hdr = skb_put(skb, sizeof(*hdr));
 250         hdr->dlen = sizeof(*pkt);
 251         pkt = skb_put(skb, sizeof(*pkt));
 252         pkt->mid = NOKIA_ALIVE_REQ;
 253
 254         nokia_enqueue(hu, skb);
 255         hci_uart_tx_wakeup(hu);
 256
 257         dev_dbg(dev, "Alive sent");
 258
 259         if (!wait_for_completion_interruptible_timeout(&btdev->init_completion,
 260                 msecs_to_jiffies(1000))) {
 261                 return -ETIMEDOUT;
 262         }
 263
 264         if (btdev->init_error < 0)
 265                 return btdev->init_error;
 266
 267         return 0;
 268 }
 269
 270 static int nokia_send_negotiation(struct hci_uart *hu)
 271 {
 272         struct nokia_bt_dev *btdev = hu->priv;
 273         struct device *dev = &btdev->serdev->dev;
 274         struct hci_nokia_neg_cmd *neg_cmd;
 275         struct hci_nokia_neg_hdr *neg_hdr;
 276         struct sk_buff *skb;
 277         int len, err;
 278         u16 baud = DIV_ROUND_CLOSEST(btdev->sysclk_speed * 10, SETUP_BAUD_RATE);
 279         int sysclk = btdev->sysclk_speed / 1000;
 280
 281         len = H4_TYPE_SIZE + sizeof(*neg_hdr) + sizeof(*neg_cmd);
 282         skb = bt_skb_alloc(len, GFP_KERNEL);
 283         if (!skb)
 284                 return -ENOMEM;
 285
 286         hci_skb_pkt_type(skb) = HCI_NOKIA_NEG_PKT;
 287
 288         neg_hdr = skb_put(skb, sizeof(*neg_hdr));
 289         neg_hdr->dlen = sizeof(*neg_cmd);
 290
 291         neg_cmd = skb_put(skb, sizeof(*neg_cmd));
 292         neg_cmd->ack = NOKIA_NEG_REQ;
 293         neg_cmd->baud = cpu_to_le16(baud);
 294         neg_cmd->unused1 = 0x0000;
 295         neg_cmd->proto = NOKIA_PROTO_BYTE;
 296         neg_cmd->sys_clk = cpu_to_le16(sysclk);
 297         neg_cmd->unused2 = 0x0000;
 298
 299         btdev->init_error = 0;
 300         init_completion(&btdev->init_completion);
 301
 302         nokia_enqueue(hu, skb);
 303         hci_uart_tx_wakeup(hu);
 304
 305         dev_dbg(dev, "Negotiation sent");
 306
 307         if (!wait_for_completion_interruptible_timeout(&btdev->init_completion,
 308                 msecs_to_jiffies(10000))) {
 309                 return -ETIMEDOUT;
 310         }
 311
 312         if (btdev->init_error < 0)
 313                 return btdev->init_error;
 314
 315         /* Change to previously negotiated speed. Flow Control
 316          * is disabled until bluetooth adapter is ready to avoid
 317          * broken bytes being received.
 318          */
 319         nokia_flow_control(btdev->serdev, false);
 320         serdev_device_set_baudrate(btdev->serdev, SETUP_BAUD_RATE);
 321         err = serdev_device_wait_for_cts(btdev->serdev, true, 200);
 322         if (err < 0) {
 323                 dev_err(dev, "CTS not received: %d", err);
 324                 return err;
 325         }
 326         nokia_flow_control(btdev->serdev, true);
 327
 328         dev_dbg(dev, "Negotiation successful");
 329
 330         return 0;
 331 }
 332
 333 static int nokia_setup_fw(struct hci_uart *hu)
 334 {
 335         struct nokia_bt_dev *btdev = hu->priv;
 336         struct device *dev = &btdev->serdev->dev;
 337         const char *fwname;
 338         const struct firmware *fw;
 339         const u8 *fw_ptr;
 340         size_t fw_size;
 341         int err;
 342
 343         dev_dbg(dev, "setup firmware");
 344
 345         if (btdev->man_id == NOKIA_ID_BCM2048) {
 346                 fwname = FIRMWARE_BCM2048;
 347         } else if (btdev->man_id == NOKIA_ID_TI1271) {
 348                 fwname = FIRMWARE_TI1271;
 349         } else {
 350                 dev_err(dev, "Unsupported bluetooth device!");
 351                 return -ENODEV;
 352         }
 353
 354         err = request_firmware(&fw, fwname, dev);
 355         if (err < 0) {
 356                 dev_err(dev, "%s: Failed to load Nokia firmware file (%d)",
 357                         hu->hdev->name, err);
 358                 return err;
 359         }
 360
 361         fw_ptr = fw->data;
 362         fw_size = fw->size;
 363
 364         while (fw_size >= 4) {
 365                 u16 pkt_size = get_unaligned_le16(fw_ptr);
 366                 u8 pkt_type = fw_ptr[2];
 367                 const struct hci_command_hdr *cmd;
 368                 u16 opcode;
 369                 struct sk_buff *skb;
 370
 371                 switch (pkt_type) {
 372                 case HCI_COMMAND_PKT:
 373                         cmd = (struct hci_command_hdr *)(fw_ptr + 3);
 374                         opcode = le16_to_cpu(cmd->opcode);
 375
 376                         skb = __hci_cmd_sync(hu->hdev, opcode, cmd->plen,
 377                                              fw_ptr + 3 + HCI_COMMAND_HDR_SIZE,
 378                                              HCI_INIT_TIMEOUT);
 379                         if (IS_ERR(skb)) {
 380                                 err = PTR_ERR(skb);
 381                                 dev_err(dev, "%s: FW command %04x failed (%d)",
 382                                        hu->hdev->name, opcode, err);
 383                                 goto done;
 384                         }
 385                         kfree_skb(skb);
 386                         break;
 387                 case HCI_NOKIA_RADIO_PKT:
 388                 case HCI_NOKIA_NEG_PKT:
 389                 case HCI_NOKIA_ALIVE_PKT:
 390                         break;
 391                 }
 392
 393                 fw_ptr += pkt_size + 2;
 394                 fw_size -= pkt_size + 2;
 395         }
 396
 397 done:
 398         release_firmware(fw);
 399         return err;
 400 }
 401
 402 static int nokia_setup(struct hci_uart *hu)
 403 {
 404         struct nokia_bt_dev *btdev = hu->priv;
 405         struct device *dev = &btdev->serdev->dev;
 406         int err;
 407
 408         btdev->initialized = false;
 409
 410         nokia_flow_control(btdev->serdev, false);
 411
 412         pm_runtime_get_sync(dev);
 413
 414         if (btdev->tx_enabled) {
 415                 gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
 416                 pm_runtime_put(&btdev->serdev->dev);
 417                 btdev->tx_enabled = false;
 418         }
 419
 420         dev_dbg(dev, "protocol setup");
 421
 422         /* 0. reset connection */
 423         err = nokia_reset(hu);
 424         if (err < 0) {
 425                 dev_err(dev, "Reset failed: %d", err);
 426                 goto out;
 427         }
 428
 429         /* 1. negotiate speed etc */
 430         err = nokia_send_negotiation(hu);
 431         if (err < 0) {
 432                 dev_err(dev, "Negotiation failed: %d", err);
 433                 goto out;
 434         }
 435
 436         /* 2. verify correct setup using alive packet */
 437         err = nokia_send_alive_packet(hu);
 438         if (err < 0) {
 439                 dev_err(dev, "Alive check failed: %d", err);
 440                 goto out;
 441         }
 442
 443         /* 3. send firmware */
 444         err = nokia_setup_fw(hu);
 445         if (err < 0) {
 446                 dev_err(dev, "Could not setup FW: %d", err);
 447                 goto out;
 448         }
 449
 450         nokia_flow_control(btdev->serdev, false);
 451         serdev_device_set_baudrate(btdev->serdev, MAX_BAUD_RATE);
 452         nokia_flow_control(btdev->serdev, true);
 453
 454         if (btdev->man_id == NOKIA_ID_BCM2048) {
 455                 hu->hdev->set_bdaddr = btbcm_set_bdaddr;
 456                 set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks);
 457                 dev_dbg(dev, "bcm2048 has invalid bluetooth address!");
 458         }
 459
 460         dev_dbg(dev, "protocol setup done!");
 461
 462         gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
 463         pm_runtime_put(dev);
 464         btdev->tx_enabled = false;
 465         btdev->initialized = true;
 466
 467         return 0;
 468 out:
 469         pm_runtime_put(dev);
 470
 471         return err;
 472 }
 473
 474 static int nokia_open(struct hci_uart *hu)
 475 {
 476         struct device *dev = &hu->serdev->dev;
 477
 478         dev_dbg(dev, "protocol open");
 479
 480         pm_runtime_enable(dev);
 481
 482         return 0;
 483 }
 484
 485 static int nokia_flush(struct hci_uart *hu)
 486 {
 487         struct nokia_bt_dev *btdev = hu->priv;
 488
 489         dev_dbg(&btdev->serdev->dev, "flush device");
 490
 491         skb_queue_purge(&btdev->txq);
 492
 493         return 0;
 494 }
 495
 496 static int nokia_close(struct hci_uart *hu)
 497 {
 498         struct nokia_bt_dev *btdev = hu->priv;
 499         struct device *dev = &btdev->serdev->dev;
 500
 501         dev_dbg(dev, "close device");
 502
 503         btdev->initialized = false;
 504
 505         skb_queue_purge(&btdev->txq);
 506
 507         kfree_skb(btdev->rx_skb);
 508
 509         /* disable module */
 510         gpiod_set_value(btdev->reset, 1);
 511         gpiod_set_value(btdev->wakeup_bt, 0);
 512
 513         pm_runtime_disable(&btdev->serdev->dev);
 514
 515         return 0;
 516 }
 517
 518 /* Enqueue frame for transmittion (padding, crc, etc) */
 519 static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb)
 520 {
 521         struct nokia_bt_dev *btdev = hu->priv;
 522         int err;
 523
 524         /* Prepend skb with frame type */
 525         memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
 526
 527         /* Packets must be word aligned */
 528         if (skb->len % 2) {
 529                 err = skb_pad(skb, 1);
 530                 if (err)
 531                         return err;
 532                 skb_put_u8(skb, 0x00);
 533         }
 534
 535         skb_queue_tail(&btdev->txq, skb);
 536
 537         return 0;
 538 }
 539
 540 static int nokia_recv_negotiation_packet(struct hci_dev *hdev,
 541                                          struct sk_buff *skb)
 542 {
 543         struct hci_uart *hu = hci_get_drvdata(hdev);
 544         struct nokia_bt_dev *btdev = hu->priv;
 545         struct device *dev = &btdev->serdev->dev;
 546         struct hci_nokia_neg_hdr *hdr;
 547         struct hci_nokia_neg_evt *evt;
 548         int ret = 0;
 549
 550         hdr = (struct hci_nokia_neg_hdr *)skb->data;
 551         if (hdr->dlen != sizeof(*evt)) {
 552                 btdev->init_error = -EIO;
 553                 ret = -EIO;
 554                 goto finish_neg;
 555         }
 556
 557         evt = skb_pull(skb, sizeof(*hdr));
 558
 559         if (evt->ack != NOKIA_NEG_ACK) {
 560                 dev_err(dev, "Negotiation received: wrong reply");
 561                 btdev->init_error = -EINVAL;
 562                 ret = -EINVAL;
 563                 goto finish_neg;
 564         }
 565
 566         btdev->man_id = evt->man_id;
 567         btdev->ver_id = evt->ver_id;
 568
 569         dev_dbg(dev, "Negotiation received: baud=%u:clk=%u:manu=%u:vers=%u",
 570                 evt->baud, evt->sys_clk, evt->man_id, evt->ver_id);
 571
 572 finish_neg:
 573         complete(&btdev->init_completion);
 574         kfree_skb(skb);
 575         return ret;
 576 }
 577
 578 static int nokia_recv_alive_packet(struct hci_dev *hdev, struct sk_buff *skb)
 579 {
 580         struct hci_uart *hu = hci_get_drvdata(hdev);
 581         struct nokia_bt_dev *btdev = hu->priv;
 582         struct device *dev = &btdev->serdev->dev;
 583         struct hci_nokia_alive_hdr *hdr;
 584         struct hci_nokia_alive_pkt *pkt;
 585         int ret = 0;
 586
 587         hdr = (struct hci_nokia_alive_hdr *)skb->data;
 588         if (hdr->dlen != sizeof(*pkt)) {
 589                 dev_err(dev, "Corrupted alive message");
 590                 btdev->init_error = -EIO;
 591                 ret = -EIO;
 592                 goto finish_alive;
 593         }
 594
 595         pkt = skb_pull(skb, sizeof(*hdr));
 596
 597         if (pkt->mid != NOKIA_ALIVE_RESP) {
 598                 dev_err(dev, "Alive received: invalid response: 0x%02x!",
 599                         pkt->mid);
 600                 btdev->init_error = -EINVAL;
 601                 ret = -EINVAL;
 602                 goto finish_alive;
 603         }
 604
 605         dev_dbg(dev, "Alive received");
 606
 607 finish_alive:
 608         complete(&btdev->init_completion);
 609         kfree_skb(skb);
 610         return ret;
 611 }
 612
 613 static int nokia_recv_radio(struct hci_dev *hdev, struct sk_buff *skb)
 614 {
 615         /* Packets received on the dedicated radio channel are
 616          * HCI events and so feed them back into the core.
 617          */
 618         hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
 619         return hci_recv_frame(hdev, skb);
 620 }
 621
 622 /* Recv data */
 623 static const struct h4_recv_pkt nokia_recv_pkts[] = {
 624         { H4_RECV_ACL,          .recv = hci_recv_frame },
 625         { H4_RECV_SCO,          .recv = hci_recv_frame },
 626         { H4_RECV_EVENT,        .recv = hci_recv_frame },
 627         { NOKIA_RECV_ALIVE,     .recv = nokia_recv_alive_packet },
 628         { NOKIA_RECV_NEG,       .recv = nokia_recv_negotiation_packet },
 629         { NOKIA_RECV_RADIO,     .recv = nokia_recv_radio },
 630 };
 631
 632 static int nokia_recv(struct hci_uart *hu, const void *data, int count)
 633 {
 634         struct nokia_bt_dev *btdev = hu->priv;
 635         struct device *dev = &btdev->serdev->dev;
 636         int err;
 637
 638         if (!test_bit(HCI_UART_REGISTERED, &hu->flags))
 639                 return -EUNATCH;
 640
 641         btdev->rx_skb = h4_recv_buf(hu->hdev, btdev->rx_skb, data, count,
 642                                   nokia_recv_pkts, ARRAY_SIZE(nokia_recv_pkts));
 643         if (IS_ERR(btdev->rx_skb)) {
 644                 err = PTR_ERR(btdev->rx_skb);
 645                 dev_err(dev, "Frame reassembly failed (%d)", err);
 646                 btdev->rx_skb = NULL;
 647                 return err;
 648         }
 649
 650         return count;
 651 }
 652
 653 static struct sk_buff *nokia_dequeue(struct hci_uart *hu)
 654 {
 655         struct nokia_bt_dev *btdev = hu->priv;
 656         struct device *dev = &btdev->serdev->dev;
 657         struct sk_buff *result = skb_dequeue(&btdev->txq);
 658
 659         if (!btdev->initialized)
 660                 return result;
 661
 662         if (btdev->tx_enabled == !!result)
 663                 return result;
 664
 665         if (result) {
 666                 pm_runtime_get_sync(dev);
 667                 gpiod_set_value_cansleep(btdev->wakeup_bt, 1);
 668         } else {
 669                 serdev_device_wait_until_sent(btdev->serdev, 0);
 670                 gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
 671                 pm_runtime_put(dev);
 672         }
 673
 674         btdev->tx_enabled = !!result;
 675
 676         return result;
 677 }
 678
 679 static const struct hci_uart_proto nokia_proto = {
 680         .id             = HCI_UART_NOKIA,
 681         .name           = "Nokia",
 682         .open           = nokia_open,
 683         .close          = nokia_close,
 684         .recv           = nokia_recv,
 685         .enqueue        = nokia_enqueue,
 686         .dequeue        = nokia_dequeue,
 687         .flush          = nokia_flush,
 688         .setup          = nokia_setup,
 689         .manufacturer   = 1,
 690 };
 691
 692 static int nokia_bluetooth_serdev_probe(struct serdev_device *serdev)
 693 {
 694         struct device *dev = &serdev->dev;
 695         struct nokia_bt_dev *btdev;
 696         struct clk *sysclk;
 697         int err = 0;
 698
 699         btdev = devm_kzalloc(dev, sizeof(*btdev), GFP_KERNEL);
 700         if (!btdev)
 701                 return -ENOMEM;
 702
 703         btdev->hu.serdev = btdev->serdev = serdev;
 704         serdev_device_set_drvdata(serdev, btdev);
 705
 706         btdev->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
 707         if (IS_ERR(btdev->reset)) {
 708                 err = PTR_ERR(btdev->reset);
 709                 dev_err(dev, "could not get reset gpio: %d", err);
 710                 return err;
 711         }
 712
 713         btdev->wakeup_host = devm_gpiod_get(dev, "host-wakeup", GPIOD_IN);
 714         if (IS_ERR(btdev->wakeup_host)) {
 715                 err = PTR_ERR(btdev->wakeup_host);
 716                 dev_err(dev, "could not get host wakeup gpio: %d", err);
 717                 return err;
 718         }
 719
 720         btdev->wake_irq = gpiod_to_irq(btdev->wakeup_host);
 721
 722         err = devm_request_threaded_irq(dev, btdev->wake_irq, NULL,
 723                 wakeup_handler,
 724                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 725                 "wakeup", btdev);
 726         if (err) {
 727                 dev_err(dev, "could request wakeup irq: %d", err);
 728                 return err;
 729         }
 730
 731         btdev->wakeup_bt = devm_gpiod_get(dev, "bluetooth-wakeup",
 732                                            GPIOD_OUT_LOW);
 733         if (IS_ERR(btdev->wakeup_bt)) {
 734                 err = PTR_ERR(btdev->wakeup_bt);
 735                 dev_err(dev, "could not get BT wakeup gpio: %d", err);
 736                 return err;
 737         }
 738
 739         sysclk = devm_clk_get(dev, "sysclk");
 740         if (IS_ERR(sysclk)) {
 741                 err = PTR_ERR(sysclk);
 742                 dev_err(dev, "could not get sysclk: %d", err);
 743                 return err;
 744         }
 745
 746         clk_prepare_enable(sysclk);
 747         btdev->sysclk_speed = clk_get_rate(sysclk);
 748         clk_disable_unprepare(sysclk);
 749
 750         skb_queue_head_init(&btdev->txq);
 751
 752         btdev->hu.priv = btdev;
 753         btdev->hu.alignment = 2; /* Nokia H4+ is word aligned */
 754
 755         err = hci_uart_register_device(&btdev->hu, &nokia_proto);
 756         if (err) {
 757                 dev_err(dev, "could not register bluetooth uart: %d", err);
 758                 return err;
 759         }
 760
 761         return 0;
 762 }
 763
 764 static void nokia_bluetooth_serdev_remove(struct serdev_device *serdev)
 765 {
 766         struct nokia_bt_dev *btdev = serdev_device_get_drvdata(serdev);
 767
 768         hci_uart_unregister_device(&btdev->hu);
 769 }
 770
 771 static int nokia_bluetooth_runtime_suspend(struct device *dev)
 772 {
 773         struct serdev_device *serdev = to_serdev_device(dev);
 774
 775         nokia_flow_control(serdev, false);
 776         return 0;
 777 }
 778
 779 static int nokia_bluetooth_runtime_resume(struct device *dev)
 780 {
 781         struct serdev_device *serdev = to_serdev_device(dev);
 782
 783         nokia_flow_control(serdev, true);
 784         return 0;
 785 }
 786
 787 static const struct dev_pm_ops nokia_bluetooth_pm_ops = {
 788         SET_RUNTIME_PM_OPS(nokia_bluetooth_runtime_suspend,
 789                            nokia_bluetooth_runtime_resume,
 790                            NULL)
 791 };
 792
 793 #ifdef CONFIG_OF
 794 static const struct of_device_id nokia_bluetooth_of_match[] = {
 795         { .compatible = "nokia,h4p-bluetooth", },
 796         {},
 797 };
 798 MODULE_DEVICE_TABLE(of, nokia_bluetooth_of_match);
 799 #endif
 800
 801 static struct serdev_device_driver nokia_bluetooth_serdev_driver = {
 802         .probe = nokia_bluetooth_serdev_probe,
 803         .remove = nokia_bluetooth_serdev_remove,
 804         .driver = {
 805                 .name = "nokia-bluetooth",
 806                 .pm = &nokia_bluetooth_pm_ops,
 807                 .of_match_table = of_match_ptr(nokia_bluetooth_of_match),
 808         },
 809 };
 810
 811 module_serdev_device_driver(nokia_bluetooth_serdev_driver);
 812
 813 MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>");
 814 MODULE_DESCRIPTION("Bluetooth HCI UART Nokia H4+ driver ver " VERSION);
 815 MODULE_VERSION(VERSION);
 816 MODULE_LICENSE("GPL");