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