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 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 144 static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb); 145 146 static 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 157 static 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 else 169 pm_runtime_put(dev); 170 171 btdev->rx_enabled = wake_state; 172 173 return IRQ_HANDLED; 174 } 175 176 static 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 216 static 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 256 static 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 Control 302 * is disabled until bluetooth adapter is ready to avoid 303 * 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 319 static 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 383 done: 384 release_firmware(fw); 385 return err; 386 } 387 388 static 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; 454 out: 455 pm_runtime_put(dev); 456 457 return err; 458 } 459 460 static 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 471 static 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 482 static 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) */ 505 static 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 526 static 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 558 finish_neg: 559 complete(&btdev->init_completion); 560 kfree_skb(skb); 561 return ret; 562 } 563 564 static 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 593 finish_alive: 594 complete(&btdev->init_completion); 595 kfree_skb(skb); 596 return ret; 597 } 598 599 static int nokia_recv_radio(struct hci_dev *hdev, struct sk_buff *skb) 600 { 601 /* Packets received on the dedicated radio channel are 602 * 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 */ 609 static 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 618 static 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 639 static 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 665 static 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 678 static 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 754 static 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 761 static 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 769 static 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 777 static 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_OF 784 static const struct of_device_id nokia_bluetooth_of_match[] = { 785 { .compatible = "nokia,h4p-bluetooth", }, 786 {}, 787 }; 788 MODULE_DEVICE_TABLE(of, nokia_bluetooth_of_match); 789 #endif 790 791 static 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 801 module_serdev_device_driver(nokia_bluetooth_serdev_driver); 802 803 MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>"); 804 MODULE_DESCRIPTION("Bluetooth HCI UART Nokia H4+ driver ver " VERSION); 805 MODULE_VERSION(VERSION); 806 MODULE_LICENSE("GPL"); 807