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