Bluetooth: add nokia driver

This adds a driver for the Nokia H4+ protocol, which is used
at least on the Nokia N9, N900 & N950.

Signed-off-by: Sebastian Reichel <sre@kernel.org>
Signed-off-by: Marcel Holtmann <marcel@holtmann.org>

3 files changed, 834 insertions, 0 deletions

diff --git a/drivers/bluetooth/Kconfig b/drivers/bluetooth/Kconfig
index a6a9dd4d0eef..8aafbed9e160 100644
--- a/drivers/bluetooth/Kconfig
+++ b/drivers/bluetooth/Kconfig
@@ -86,6 +86,18 @@ config BT_HCIUART_H4
 
           Say Y here to compile support for HCI UART (H4) protocol.
 
+config BT_HCIUART_NOKIA
+        tristate "UART Nokia H4+ protocol support"
+        depends on BT_HCIUART
+        depends on SERIAL_DEV_BUS
+        depends on PM
+        help
+          Nokia H4+ is serial protocol for communication between Bluetooth
+          device and host. This protocol is required for Bluetooth devices
+          with UART interface in Nokia devices.
+
+          Say Y here to compile support for Nokia's H4+ protocol.
+
 config BT_HCIUART_BCSP
         bool "BCSP protocol support"
         depends on BT_HCIUART
diff --git a/drivers/bluetooth/Makefile b/drivers/bluetooth/Makefile
index fd571689eed6..a7f237320f4b 100644
--- a/drivers/bluetooth/Makefile
+++ b/drivers/bluetooth/Makefile
@@ -25,6 +25,8 @@ obj-$(CONFIG_BT_BCM)		+= btbcm.o
 obj-$(CONFIG_BT_RTL)            += btrtl.o
 obj-$(CONFIG_BT_QCA)            += btqca.o
 
+obj-$(CONFIG_BT_HCIUART_NOKIA)  += hci_nokia.o
+
 btmrvl-y                        := btmrvl_main.o
 btmrvl-$(CONFIG_DEBUG_FS)       += btmrvl_debugfs.o
 
diff --git a/drivers/bluetooth/hci_nokia.c b/drivers/bluetooth/hci_nokia.c
new file mode 100644
index 000000000000..4038daf78d24
--- /dev/null
+++ b/drivers/bluetooth/hci_nokia.c
@@ -0,0 +1,820 @@
+/*
+ *  Bluetooth HCI UART H4 driver with Nokia Extensions AKA Nokia H4+
+ *
+ *  Copyright (C) 2015 Marcel Holtmann <marcel@holtmann.org>
+ *  Copyright (C) 2015-2017 Sebastian Reichel <sre@kernel.org>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ */
+
+#include <linux/clk.h>
+#include <linux/errno.h>
+#include <linux/firmware.h>
+#include <linux/gpio/consumer.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/pm_runtime.h>
+#include <linux/serdev.h>
+#include <linux/skbuff.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/unaligned/le_struct.h>
+#include <net/bluetooth/bluetooth.h>
+#include <net/bluetooth/hci_core.h>
+
+#include "hci_uart.h"
+#include "btbcm.h"
+
+#define NOKIA_ID_BCM2048        0x04
+#define NOKIA_ID_TI1271         0x31
+
+#define FIRMWARE_BCM2048        "nokia/bcmfw.bin"
+#define FIRMWARE_TI1271         "nokia/ti1273.bin"
+
+#define HCI_NOKIA_NEG_PKT       0x06
+#define HCI_NOKIA_ALIVE_PKT     0x07
+#define HCI_NOKIA_RADIO_PKT     0x08
+
+#define HCI_NOKIA_NEG_HDR_SIZE          1
+#define HCI_NOKIA_MAX_NEG_SIZE          255
+#define HCI_NOKIA_ALIVE_HDR_SIZE        1
+#define HCI_NOKIA_MAX_ALIVE_SIZE        255
+#define HCI_NOKIA_RADIO_HDR_SIZE        2
+#define HCI_NOKIA_MAX_RADIO_SIZE        255
+
+#define NOKIA_PROTO_PKT         0x44
+#define NOKIA_PROTO_BYTE        0x4c
+
+#define NOKIA_NEG_REQ           0x00
+#define NOKIA_NEG_ACK           0x20
+#define NOKIA_NEG_NAK           0x40
+
+#define H4_TYPE_SIZE            1
+
+#define NOKIA_RECV_ALIVE \
+        .type = HCI_NOKIA_ALIVE_PKT, \
+        .hlen = HCI_NOKIA_ALIVE_HDR_SIZE, \
+        .loff = 0, \
+        .lsize = 1, \
+        .maxlen = HCI_NOKIA_MAX_ALIVE_SIZE \
+
+#define NOKIA_RECV_NEG \
+        .type = HCI_NOKIA_NEG_PKT, \
+        .hlen = HCI_NOKIA_NEG_HDR_SIZE, \
+        .loff = 0, \
+        .lsize = 1, \
+        .maxlen = HCI_NOKIA_MAX_NEG_SIZE \
+
+#define NOKIA_RECV_RADIO \
+        .type = HCI_NOKIA_RADIO_PKT, \
+        .hlen = HCI_NOKIA_RADIO_HDR_SIZE, \
+        .loff = 1, \
+        .lsize = 1, \
+        .maxlen = HCI_NOKIA_MAX_RADIO_SIZE \
+
+struct hci_nokia_neg_hdr {
+        u8      dlen;
+} __packed;
+
+struct hci_nokia_neg_cmd {
+        u8      ack;
+        u16     baud;
+        u16     unused1;
+        u8      proto;
+        u16     sys_clk;
+        u16     unused2;
+} __packed;
+
+#define NOKIA_ALIVE_REQ   0x55
+#define NOKIA_ALIVE_RESP  0xcc
+
+struct hci_nokia_alive_hdr {
+        u8      dlen;
+} __packed;
+
+struct hci_nokia_alive_pkt {
+        u8      mid;
+        u8      unused;
+} __packed;
+
+struct hci_nokia_neg_evt {
+        u8      ack;
+        u16     baud;
+        u16     unused1;
+        u8      proto;
+        u16     sys_clk;
+        u16     unused2;
+        u8      man_id;
+        u8      ver_id;
+} __packed;
+
+#define MAX_BAUD_RATE           3692300
+#define SETUP_BAUD_RATE         921600
+#define INIT_BAUD_RATE          120000
+
+struct hci_nokia_radio_hdr {
+        u8      evt;
+        u8      dlen;
+} __packed;
+
+struct nokia_bt_dev {
+        struct hci_uart hu;
+        struct serdev_device *serdev;
+
+        struct gpio_desc *reset;
+        struct gpio_desc *wakeup_host;
+        struct gpio_desc *wakeup_bt;
+        unsigned long sysclk_speed;
+
+        int wake_irq;
+        struct sk_buff *rx_skb;
+        struct sk_buff_head txq;
+        bdaddr_t bdaddr;
+
+        int init_error;
+        struct completion init_completion;
+
+        u8 man_id;
+        u8 ver_id;
+
+        bool initialized;
+        bool tx_enabled;
+        bool rx_enabled;
+};
+
+static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb);
+
+static void nokia_flow_control(struct serdev_device *serdev, bool enable)
+{
+        if (enable) {
+                serdev_device_set_rts(serdev, true);
+                serdev_device_set_flow_control(serdev, true);
+        } else {
+                serdev_device_set_flow_control(serdev, false);
+                serdev_device_set_rts(serdev, false);
+        }
+}
+
+static irqreturn_t wakeup_handler(int irq, void *data)
+{
+        struct nokia_bt_dev *btdev = data;
+        struct device *dev = &btdev->serdev->dev;
+        int wake_state = gpiod_get_value(btdev->wakeup_host);
+
+        if (btdev->rx_enabled == wake_state)
+                return IRQ_HANDLED;
+
+        if (wake_state)
+                pm_runtime_get(dev);
+        else
+                pm_runtime_put(dev);
+
+        btdev->rx_enabled = wake_state;
+
+        return IRQ_HANDLED;
+}
+
+static int nokia_reset(struct hci_uart *hu)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+        int err;
+
+        /* reset routine */
+        gpiod_set_value_cansleep(btdev->reset, 1);
+        gpiod_set_value_cansleep(btdev->wakeup_bt, 1);
+
+        msleep(100);
+
+        /* safety check */
+        err = gpiod_get_value_cansleep(btdev->wakeup_host);
+        if (err == 1) {
+                dev_err(dev, "reset: host wakeup not low!");
+                return -EPROTO;
+        }
+
+        /* flush queue */
+        serdev_device_write_flush(btdev->serdev);
+
+        /* init uart */
+        nokia_flow_control(btdev->serdev, false);
+        serdev_device_set_baudrate(btdev->serdev, INIT_BAUD_RATE);
+
+        gpiod_set_value_cansleep(btdev->reset, 0);
+
+        /* wait for cts */
+        err = serdev_device_wait_for_cts(btdev->serdev, true, 200);
+        if (err < 0) {
+                dev_err(dev, "CTS not received: %d", err);
+                return err;
+        }
+
+        nokia_flow_control(btdev->serdev, true);
+
+        return 0;
+}
+
+static int nokia_send_alive_packet(struct hci_uart *hu)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+        struct hci_nokia_alive_hdr *hdr;
+        struct hci_nokia_alive_pkt *pkt;
+        struct sk_buff *skb;
+        int len;
+
+        init_completion(&btdev->init_completion);
+
+        len = H4_TYPE_SIZE + sizeof(*hdr) + sizeof(*pkt);
+        skb = bt_skb_alloc(len, GFP_KERNEL);
+        if (!skb)
+                return -ENOMEM;
+
+        hci_skb_pkt_type(skb) = HCI_NOKIA_ALIVE_PKT;
+        memset(skb->data, 0x00, len);
+
+        hdr = (struct hci_nokia_alive_hdr *)skb_put(skb, sizeof(*hdr));
+        hdr->dlen = sizeof(*pkt);
+        pkt = (struct hci_nokia_alive_pkt *)skb_put(skb, sizeof(*pkt));
+        pkt->mid = NOKIA_ALIVE_REQ;
+
+        nokia_enqueue(hu, skb);
+        hci_uart_tx_wakeup(hu);
+
+        dev_dbg(dev, "Alive sent");
+
+        if (!wait_for_completion_interruptible_timeout(&btdev->init_completion,
+                msecs_to_jiffies(1000))) {
+                return -ETIMEDOUT;
+        }
+
+        if (btdev->init_error < 0)
+                return btdev->init_error;
+
+        return 0;
+}
+
+static int nokia_send_negotiation(struct hci_uart *hu)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+        struct hci_nokia_neg_cmd *neg_cmd;
+        struct hci_nokia_neg_hdr *neg_hdr;
+        struct sk_buff *skb;
+        int len, err;
+        u16 baud = DIV_ROUND_CLOSEST(btdev->sysclk_speed * 10, SETUP_BAUD_RATE);
+        int sysclk = btdev->sysclk_speed / 1000;
+
+        len = H4_TYPE_SIZE + sizeof(*neg_hdr) + sizeof(*neg_cmd);
+        skb = bt_skb_alloc(len, GFP_KERNEL);
+        if (!skb)
+                return -ENOMEM;
+
+        hci_skb_pkt_type(skb) = HCI_NOKIA_NEG_PKT;
+
+        neg_hdr = (struct hci_nokia_neg_hdr *)skb_put(skb, sizeof(*neg_hdr));
+        neg_hdr->dlen = sizeof(*neg_cmd);
+
+        neg_cmd = (struct hci_nokia_neg_cmd *)skb_put(skb, sizeof(*neg_cmd));
+        neg_cmd->ack = NOKIA_NEG_REQ;
+        neg_cmd->baud = cpu_to_le16(baud);
+        neg_cmd->unused1 = 0x0000;
+        neg_cmd->proto = NOKIA_PROTO_BYTE;
+        neg_cmd->sys_clk = cpu_to_le16(sysclk);
+        neg_cmd->unused2 = 0x0000;
+
+        btdev->init_error = 0;
+        init_completion(&btdev->init_completion);
+
+        nokia_enqueue(hu, skb);
+        hci_uart_tx_wakeup(hu);
+
+        dev_dbg(dev, "Negotiation sent");
+
+        if (!wait_for_completion_interruptible_timeout(&btdev->init_completion,
+                msecs_to_jiffies(10000))) {
+                return -ETIMEDOUT;
+        }
+
+        if (btdev->init_error < 0)
+                return btdev->init_error;
+
+        /* Change to previously negotiated speed. Flow Control
+         * is disabled until bluetooth adapter is ready to avoid
+         * broken bytes being received.
+         */
+        nokia_flow_control(btdev->serdev, false);
+        serdev_device_set_baudrate(btdev->serdev, SETUP_BAUD_RATE);
+        err = serdev_device_wait_for_cts(btdev->serdev, true, 200);
+        if (err < 0) {
+                dev_err(dev, "CTS not received: %d", err);
+                return err;
+        }
+        nokia_flow_control(btdev->serdev, true);
+
+        dev_dbg(dev, "Negotiation successful");
+
+        return 0;
+}
+
+static int nokia_setup_fw(struct hci_uart *hu)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+        const char *fwname;
+        const struct firmware *fw;
+        const u8 *fw_ptr;
+        size_t fw_size;
+        int err;
+
+        dev_dbg(dev, "setup firmware");
+
+        if (btdev->man_id == NOKIA_ID_BCM2048) {
+                fwname = FIRMWARE_BCM2048;
+        } else if (btdev->man_id == NOKIA_ID_TI1271) {
+                fwname = FIRMWARE_TI1271;
+        } else {
+                dev_err(dev, "Unsupported bluetooth device!");
+                return -ENODEV;
+        }
+
+        err = request_firmware(&fw, fwname, dev);
+        if (err < 0) {
+                dev_err(dev, "%s: Failed to load Nokia firmware file (%d)",
+                        hu->hdev->name, err);
+                return err;
+        }
+
+        fw_ptr = fw->data;
+        fw_size = fw->size;
+
+        while (fw_size >= 4) {
+                u16 pkt_size = get_unaligned_le16(fw_ptr);
+                u8 pkt_type = fw_ptr[2];
+                const struct hci_command_hdr *cmd;
+                u16 opcode;
+                struct sk_buff *skb;
+
+                switch (pkt_type) {
+                case HCI_COMMAND_PKT:
+                        cmd = (struct hci_command_hdr *)(fw_ptr + 3);
+                        opcode = le16_to_cpu(cmd->opcode);
+
+                        skb = __hci_cmd_sync(hu->hdev, opcode, cmd->plen,
+                                             fw_ptr + 3 + HCI_COMMAND_HDR_SIZE,
+                                             HCI_INIT_TIMEOUT);
+                        if (IS_ERR(skb)) {
+                                err = PTR_ERR(skb);
+                                dev_err(dev, "%s: FW command %04x failed (%d)",
+                                       hu->hdev->name, opcode, err);
+                                goto done;
+                        }
+                        kfree_skb(skb);
+                        break;
+                case HCI_NOKIA_RADIO_PKT:
+                case HCI_NOKIA_NEG_PKT:
+                case HCI_NOKIA_ALIVE_PKT:
+                        break;
+                }
+
+                fw_ptr += pkt_size + 2;
+                fw_size -= pkt_size + 2;
+        }
+
+done:
+        release_firmware(fw);
+        return err;
+}
+
+static int nokia_setup(struct hci_uart *hu)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+        int err;
+
+        btdev->initialized = false;
+
+        nokia_flow_control(btdev->serdev, false);
+
+        pm_runtime_get_sync(dev);
+
+        if (btdev->tx_enabled) {
+                gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
+                pm_runtime_put(&btdev->serdev->dev);
+                btdev->tx_enabled = false;
+        }
+
+        dev_dbg(dev, "protocol setup");
+
+        /* 0. reset connection */
+        err = nokia_reset(hu);
+        if (err < 0) {
+                dev_err(dev, "Reset failed: %d", err);
+                goto out;
+        }
+
+        /* 1. negotiate speed etc */
+        err = nokia_send_negotiation(hu);
+        if (err < 0) {
+                dev_err(dev, "Negotiation failed: %d", err);
+                goto out;
+        }
+
+        /* 2. verify correct setup using alive packet */
+        err = nokia_send_alive_packet(hu);
+        if (err < 0) {
+                dev_err(dev, "Alive check failed: %d", err);
+                goto out;
+        }
+
+        /* 3. send firmware */
+        err = nokia_setup_fw(hu);
+        if (err < 0) {
+                dev_err(dev, "Could not setup FW: %d", err);
+                goto out;
+        }
+
+        nokia_flow_control(btdev->serdev, false);
+        serdev_device_set_baudrate(btdev->serdev, MAX_BAUD_RATE);
+        nokia_flow_control(btdev->serdev, true);
+
+        if (btdev->man_id == NOKIA_ID_BCM2048) {
+                hu->hdev->set_bdaddr = btbcm_set_bdaddr;
+                set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks);
+                dev_dbg(dev, "bcm2048 has invalid bluetooth address!");
+        }
+
+        dev_dbg(dev, "protocol setup done!");
+
+        gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
+        pm_runtime_put(dev);
+        btdev->tx_enabled = false;
+        btdev->initialized = true;
+
+        return 0;
+out:
+        pm_runtime_put(dev);
+
+        return err;
+}
+
+static int nokia_open(struct hci_uart *hu)
+{
+        struct device *dev = &hu->serdev->dev;
+
+        dev_dbg(dev, "protocol open");
+
+        serdev_device_open(hu->serdev);
+
+        pm_runtime_enable(dev);
+
+        return 0;
+}
+
+static int nokia_flush(struct hci_uart *hu)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+
+        dev_dbg(&btdev->serdev->dev, "flush device");
+
+        skb_queue_purge(&btdev->txq);
+
+        return 0;
+}
+
+static int nokia_close(struct hci_uart *hu)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+
+        dev_dbg(dev, "close device");
+
+        btdev->initialized = false;
+
+        skb_queue_purge(&btdev->txq);
+
+        kfree_skb(btdev->rx_skb);
+
+        /* disable module */
+        gpiod_set_value(btdev->reset, 1);
+        gpiod_set_value(btdev->wakeup_bt, 0);
+
+        pm_runtime_disable(&btdev->serdev->dev);
+        serdev_device_close(btdev->serdev);
+
+        return 0;
+}
+
+/* Enqueue frame for transmittion (padding, crc, etc) */
+static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+        int err;
+
+        /* Prepend skb with frame type */
+        memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
+
+        /* Packets must be word aligned */
+        if (skb->len % 2) {
+                err = skb_pad(skb, 1);
+                if (err)
+                        return err;
+                *skb_put(skb, 1) = 0x00;
+        }
+
+        skb_queue_tail(&btdev->txq, skb);
+
+        return 0;
+}
+
+static int nokia_recv_negotiation_packet(struct hci_dev *hdev,
+                                         struct sk_buff *skb)
+{
+        struct hci_uart *hu = hci_get_drvdata(hdev);
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+        struct hci_nokia_neg_hdr *hdr;
+        struct hci_nokia_neg_evt *evt;
+        int ret = 0;
+
+        hdr = (struct hci_nokia_neg_hdr *)skb->data;
+        if (hdr->dlen != sizeof(*evt)) {
+                btdev->init_error = -EIO;
+                ret = -EIO;
+                goto finish_neg;
+        }
+
+        evt = (struct hci_nokia_neg_evt *)skb_pull(skb, sizeof(*hdr));
+
+        if (evt->ack != NOKIA_NEG_ACK) {
+                dev_err(dev, "Negotiation received: wrong reply");
+                btdev->init_error = -EINVAL;
+                ret = -EINVAL;
+                goto finish_neg;
+        }
+
+        btdev->man_id = evt->man_id;
+        btdev->ver_id = evt->ver_id;
+
+        dev_dbg(dev, "Negotiation received: baud=%u:clk=%u:manu=%u:vers=%u",
+                evt->baud, evt->sys_clk, evt->man_id, evt->ver_id);
+
+finish_neg:
+        complete(&btdev->init_completion);
+        kfree_skb(skb);
+        return ret;
+}
+
+static int nokia_recv_alive_packet(struct hci_dev *hdev, struct sk_buff *skb)
+{
+        struct hci_uart *hu = hci_get_drvdata(hdev);
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+        struct hci_nokia_alive_hdr *hdr;
+        struct hci_nokia_alive_pkt *pkt;
+        int ret = 0;
+
+        hdr = (struct hci_nokia_alive_hdr *)skb->data;
+        if (hdr->dlen != sizeof(*pkt)) {
+                dev_err(dev, "Corrupted alive message");
+                btdev->init_error = -EIO;
+                ret = -EIO;
+                goto finish_alive;
+        }
+
+        pkt = (struct hci_nokia_alive_pkt *)skb_pull(skb, sizeof(*hdr));
+
+        if (pkt->mid != NOKIA_ALIVE_RESP) {
+                dev_err(dev, "Alive received: invalid response: 0x%02x!",
+                        pkt->mid);
+                btdev->init_error = -EINVAL;
+                ret = -EINVAL;
+                goto finish_alive;
+        }
+
+        dev_dbg(dev, "Alive received");
+
+finish_alive:
+        complete(&btdev->init_completion);
+        kfree_skb(skb);
+        return ret;
+}
+
+static int nokia_recv_radio(struct hci_dev *hdev, struct sk_buff *skb)
+{
+        /* Packets received on the dedicated radio channel are
+         * HCI events and so feed them back into the core.
+         */
+        hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
+        return hci_recv_frame(hdev, skb);
+}
+
+/* Recv data */
+static const struct h4_recv_pkt nokia_recv_pkts[] = {
+        { H4_RECV_ACL,          .recv = hci_recv_frame },
+        { H4_RECV_SCO,          .recv = hci_recv_frame },
+        { H4_RECV_EVENT,        .recv = hci_recv_frame },
+        { NOKIA_RECV_ALIVE,     .recv = nokia_recv_alive_packet },
+        { NOKIA_RECV_NEG,       .recv = nokia_recv_negotiation_packet },
+        { NOKIA_RECV_RADIO,     .recv = nokia_recv_radio },
+};
+
+static int nokia_recv(struct hci_uart *hu, const void *data, int count)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+        int err;
+
+        if (!test_bit(HCI_UART_REGISTERED, &hu->flags))
+                return -EUNATCH;
+
+        btdev->rx_skb = h4_recv_buf(hu->hdev, btdev->rx_skb, data, count,
+                                  nokia_recv_pkts, ARRAY_SIZE(nokia_recv_pkts));
+        if (IS_ERR(btdev->rx_skb)) {
+                err = PTR_ERR(btdev->rx_skb);
+                dev_err(dev, "Frame reassembly failed (%d)", err);
+                btdev->rx_skb = NULL;
+                return err;
+        }
+
+        return count;
+}
+
+static struct sk_buff *nokia_dequeue(struct hci_uart *hu)
+{
+        struct nokia_bt_dev *btdev = hu->priv;
+        struct device *dev = &btdev->serdev->dev;
+        struct sk_buff *result = skb_dequeue(&btdev->txq);
+
+        if (!btdev->initialized)
+                return result;
+
+        if (btdev->tx_enabled == !!result)
+                return result;
+
+        if (result) {
+                pm_runtime_get_sync(dev);
+                gpiod_set_value_cansleep(btdev->wakeup_bt, 1);
+        } else {
+                serdev_device_wait_until_sent(btdev->serdev, 0);
+                gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
+                pm_runtime_put(dev);
+        }
+
+        btdev->tx_enabled = !!result;
+
+        return result;
+}
+
+static const struct hci_uart_proto nokia_proto = {
+        .id             = HCI_UART_NOKIA,
+        .name           = "Nokia",
+        .open           = nokia_open,
+        .close          = nokia_close,
+        .recv           = nokia_recv,
+        .enqueue        = nokia_enqueue,
+        .dequeue        = nokia_dequeue,
+        .flush          = nokia_flush,
+        .setup          = nokia_setup,
+        .manufacturer   = 1,
+};
+
+static int nokia_bluetooth_serdev_probe(struct serdev_device *serdev)
+{
+        struct device *dev = &serdev->dev;
+        struct nokia_bt_dev *btdev;
+        struct clk *sysclk;
+        int err = 0;
+
+        btdev = devm_kzalloc(dev, sizeof(*btdev), GFP_KERNEL);
+        if (!btdev)
+                return -ENOMEM;
+
+        btdev->hu.serdev = btdev->serdev = serdev;
+        serdev_device_set_drvdata(serdev, btdev);
+
+        btdev->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
+        if (IS_ERR(btdev->reset)) {
+                err = PTR_ERR(btdev->reset);
+                dev_err(dev, "could not get reset gpio: %d", err);
+                return err;
+        }
+
+        btdev->wakeup_host = devm_gpiod_get(dev, "host-wakeup", GPIOD_IN);
+        if (IS_ERR(btdev->wakeup_host)) {
+                err = PTR_ERR(btdev->wakeup_host);
+                dev_err(dev, "could not get host wakeup gpio: %d", err);
+                return err;
+        }
+
+        btdev->wake_irq = gpiod_to_irq(btdev->wakeup_host);
+
+        err = devm_request_threaded_irq(dev, btdev->wake_irq, NULL,
+                wakeup_handler,
+                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                "wakeup", btdev);
+        if (err) {
+                dev_err(dev, "could request wakeup irq: %d", err);
+                return err;
+        }
+
+        btdev->wakeup_bt = devm_gpiod_get(dev, "bluetooth-wakeup",
+                                           GPIOD_OUT_LOW);
+        if (IS_ERR(btdev->wakeup_bt)) {
+                err = PTR_ERR(btdev->wakeup_bt);
+                dev_err(dev, "could not get BT wakeup gpio: %d", err);
+                return err;
+        }
+
+        sysclk = devm_clk_get(dev, "sysclk");
+        if (IS_ERR(sysclk)) {
+                err = PTR_ERR(sysclk);
+                dev_err(dev, "could not get sysclk: %d", err);
+                return err;
+        }
+
+        clk_prepare_enable(sysclk);
+        btdev->sysclk_speed = clk_get_rate(sysclk);
+        clk_disable_unprepare(sysclk);
+
+        skb_queue_head_init(&btdev->txq);
+
+        btdev->hu.priv = btdev;
+        btdev->hu.alignment = 2; /* Nokia H4+ is word aligned */
+
+        err = hci_uart_register_device(&btdev->hu, &nokia_proto);
+        if (err) {
+                dev_err(dev, "could not register bluetooth uart: %d", err);
+                return err;
+        }
+
+        return 0;
+}
+
+static void nokia_bluetooth_serdev_remove(struct serdev_device *serdev)
+{
+        struct nokia_bt_dev *btdev = serdev_device_get_drvdata(serdev);
+        struct hci_uart *hu = &btdev->hu;
+        struct hci_dev *hdev = hu->hdev;
+
+        cancel_work_sync(&hu->write_work);
+
+        hci_unregister_dev(hdev);
+        hci_free_dev(hdev);
+        hu->proto->close(hu);
+
+        pm_runtime_disable(&btdev->serdev->dev);
+}
+
+static int nokia_bluetooth_runtime_suspend(struct device *dev)
+{
+        struct serdev_device *serdev = to_serdev_device(dev);
+
+        nokia_flow_control(serdev, false);
+        return 0;
+}
+
+static int nokia_bluetooth_runtime_resume(struct device *dev)
+{
+        struct serdev_device *serdev = to_serdev_device(dev);
+
+        nokia_flow_control(serdev, true);
+        return 0;
+}
+
+static const struct dev_pm_ops nokia_bluetooth_pm_ops = {
+        SET_RUNTIME_PM_OPS(nokia_bluetooth_runtime_suspend,
+                           nokia_bluetooth_runtime_resume,
+                           NULL)
+};
+
+#ifdef CONFIG_OF
+static const struct of_device_id nokia_bluetooth_of_match[] = {
+        { .compatible = "nokia,h4p-bluetooth", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, nokia_bluetooth_of_match);
+#endif
+
+static struct serdev_device_driver nokia_bluetooth_serdev_driver = {
+        .probe = nokia_bluetooth_serdev_probe,
+        .remove = nokia_bluetooth_serdev_remove,
+        .driver = {
+                .name = "nokia-bluetooth",
+                .pm = &nokia_bluetooth_pm_ops,
+                .of_match_table = of_match_ptr(nokia_bluetooth_of_match),
+        },
+};
+
+module_serdev_device_driver(nokia_bluetooth_serdev_driver);