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 <linux/unaligned/le_struct.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 = (struct hci_nokia_alive_hdr *)skb_put(skb, sizeof(*hdr)); 250 hdr->dlen = sizeof(*pkt); 251 pkt = (struct hci_nokia_alive_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 = (struct hci_nokia_neg_hdr *)skb_put(skb, sizeof(*neg_hdr)); 289 neg_hdr->dlen = sizeof(*neg_cmd); 290 291 neg_cmd = (struct hci_nokia_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 serdev_device_open(hu->serdev); 481 482 pm_runtime_enable(dev); 483 484 return 0; 485 } 486 487 static int nokia_flush(struct hci_uart *hu) 488 { 489 struct nokia_bt_dev *btdev = hu->priv; 490 491 dev_dbg(&btdev->serdev->dev, "flush device"); 492 493 skb_queue_purge(&btdev->txq); 494 495 return 0; 496 } 497 498 static int nokia_close(struct hci_uart *hu) 499 { 500 struct nokia_bt_dev *btdev = hu->priv; 501 struct device *dev = &btdev->serdev->dev; 502 503 dev_dbg(dev, "close device"); 504 505 btdev->initialized = false; 506 507 skb_queue_purge(&btdev->txq); 508 509 kfree_skb(btdev->rx_skb); 510 511 /* disable module */ 512 gpiod_set_value(btdev->reset, 1); 513 gpiod_set_value(btdev->wakeup_bt, 0); 514 515 pm_runtime_disable(&btdev->serdev->dev); 516 serdev_device_close(btdev->serdev); 517 518 return 0; 519 } 520 521 /* Enqueue frame for transmittion (padding, crc, etc) */ 522 static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb) 523 { 524 struct nokia_bt_dev *btdev = hu->priv; 525 int err; 526 527 /* Prepend skb with frame type */ 528 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1); 529 530 /* Packets must be word aligned */ 531 if (skb->len % 2) { 532 err = skb_pad(skb, 1); 533 if (err) 534 return err; 535 *skb_put(skb, 1) = 0x00; 536 } 537 538 skb_queue_tail(&btdev->txq, skb); 539 540 return 0; 541 } 542 543 static int nokia_recv_negotiation_packet(struct hci_dev *hdev, 544 struct sk_buff *skb) 545 { 546 struct hci_uart *hu = hci_get_drvdata(hdev); 547 struct nokia_bt_dev *btdev = hu->priv; 548 struct device *dev = &btdev->serdev->dev; 549 struct hci_nokia_neg_hdr *hdr; 550 struct hci_nokia_neg_evt *evt; 551 int ret = 0; 552 553 hdr = (struct hci_nokia_neg_hdr *)skb->data; 554 if (hdr->dlen != sizeof(*evt)) { 555 btdev->init_error = -EIO; 556 ret = -EIO; 557 goto finish_neg; 558 } 559 560 evt = (struct hci_nokia_neg_evt *)skb_pull(skb, sizeof(*hdr)); 561 562 if (evt->ack != NOKIA_NEG_ACK) { 563 dev_err(dev, "Negotiation received: wrong reply"); 564 btdev->init_error = -EINVAL; 565 ret = -EINVAL; 566 goto finish_neg; 567 } 568 569 btdev->man_id = evt->man_id; 570 btdev->ver_id = evt->ver_id; 571 572 dev_dbg(dev, "Negotiation received: baud=%u:clk=%u:manu=%u:vers=%u", 573 evt->baud, evt->sys_clk, evt->man_id, evt->ver_id); 574 575 finish_neg: 576 complete(&btdev->init_completion); 577 kfree_skb(skb); 578 return ret; 579 } 580 581 static int nokia_recv_alive_packet(struct hci_dev *hdev, struct sk_buff *skb) 582 { 583 struct hci_uart *hu = hci_get_drvdata(hdev); 584 struct nokia_bt_dev *btdev = hu->priv; 585 struct device *dev = &btdev->serdev->dev; 586 struct hci_nokia_alive_hdr *hdr; 587 struct hci_nokia_alive_pkt *pkt; 588 int ret = 0; 589 590 hdr = (struct hci_nokia_alive_hdr *)skb->data; 591 if (hdr->dlen != sizeof(*pkt)) { 592 dev_err(dev, "Corrupted alive message"); 593 btdev->init_error = -EIO; 594 ret = -EIO; 595 goto finish_alive; 596 } 597 598 pkt = (struct hci_nokia_alive_pkt *)skb_pull(skb, sizeof(*hdr)); 599 600 if (pkt->mid != NOKIA_ALIVE_RESP) { 601 dev_err(dev, "Alive received: invalid response: 0x%02x!", 602 pkt->mid); 603 btdev->init_error = -EINVAL; 604 ret = -EINVAL; 605 goto finish_alive; 606 } 607 608 dev_dbg(dev, "Alive received"); 609 610 finish_alive: 611 complete(&btdev->init_completion); 612 kfree_skb(skb); 613 return ret; 614 } 615 616 static int nokia_recv_radio(struct hci_dev *hdev, struct sk_buff *skb) 617 { 618 /* Packets received on the dedicated radio channel are 619 * HCI events and so feed them back into the core. 620 */ 621 hci_skb_pkt_type(skb) = HCI_EVENT_PKT; 622 return hci_recv_frame(hdev, skb); 623 } 624 625 /* Recv data */ 626 static const struct h4_recv_pkt nokia_recv_pkts[] = { 627 { H4_RECV_ACL, .recv = hci_recv_frame }, 628 { H4_RECV_SCO, .recv = hci_recv_frame }, 629 { H4_RECV_EVENT, .recv = hci_recv_frame }, 630 { NOKIA_RECV_ALIVE, .recv = nokia_recv_alive_packet }, 631 { NOKIA_RECV_NEG, .recv = nokia_recv_negotiation_packet }, 632 { NOKIA_RECV_RADIO, .recv = nokia_recv_radio }, 633 }; 634 635 static int nokia_recv(struct hci_uart *hu, const void *data, int count) 636 { 637 struct nokia_bt_dev *btdev = hu->priv; 638 struct device *dev = &btdev->serdev->dev; 639 int err; 640 641 if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) 642 return -EUNATCH; 643 644 btdev->rx_skb = h4_recv_buf(hu->hdev, btdev->rx_skb, data, count, 645 nokia_recv_pkts, ARRAY_SIZE(nokia_recv_pkts)); 646 if (IS_ERR(btdev->rx_skb)) { 647 err = PTR_ERR(btdev->rx_skb); 648 dev_err(dev, "Frame reassembly failed (%d)", err); 649 btdev->rx_skb = NULL; 650 return err; 651 } 652 653 return count; 654 } 655 656 static struct sk_buff *nokia_dequeue(struct hci_uart *hu) 657 { 658 struct nokia_bt_dev *btdev = hu->priv; 659 struct device *dev = &btdev->serdev->dev; 660 struct sk_buff *result = skb_dequeue(&btdev->txq); 661 662 if (!btdev->initialized) 663 return result; 664 665 if (btdev->tx_enabled == !!result) 666 return result; 667 668 if (result) { 669 pm_runtime_get_sync(dev); 670 gpiod_set_value_cansleep(btdev->wakeup_bt, 1); 671 } else { 672 serdev_device_wait_until_sent(btdev->serdev, 0); 673 gpiod_set_value_cansleep(btdev->wakeup_bt, 0); 674 pm_runtime_put(dev); 675 } 676 677 btdev->tx_enabled = !!result; 678 679 return result; 680 } 681 682 static const struct hci_uart_proto nokia_proto = { 683 .id = HCI_UART_NOKIA, 684 .name = "Nokia", 685 .open = nokia_open, 686 .close = nokia_close, 687 .recv = nokia_recv, 688 .enqueue = nokia_enqueue, 689 .dequeue = nokia_dequeue, 690 .flush = nokia_flush, 691 .setup = nokia_setup, 692 .manufacturer = 1, 693 }; 694 695 static int nokia_bluetooth_serdev_probe(struct serdev_device *serdev) 696 { 697 struct device *dev = &serdev->dev; 698 struct nokia_bt_dev *btdev; 699 struct clk *sysclk; 700 int err = 0; 701 702 btdev = devm_kzalloc(dev, sizeof(*btdev), GFP_KERNEL); 703 if (!btdev) 704 return -ENOMEM; 705 706 btdev->hu.serdev = btdev->serdev = serdev; 707 serdev_device_set_drvdata(serdev, btdev); 708 709 btdev->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); 710 if (IS_ERR(btdev->reset)) { 711 err = PTR_ERR(btdev->reset); 712 dev_err(dev, "could not get reset gpio: %d", err); 713 return err; 714 } 715 716 btdev->wakeup_host = devm_gpiod_get(dev, "host-wakeup", GPIOD_IN); 717 if (IS_ERR(btdev->wakeup_host)) { 718 err = PTR_ERR(btdev->wakeup_host); 719 dev_err(dev, "could not get host wakeup gpio: %d", err); 720 return err; 721 } 722 723 btdev->wake_irq = gpiod_to_irq(btdev->wakeup_host); 724 725 err = devm_request_threaded_irq(dev, btdev->wake_irq, NULL, 726 wakeup_handler, 727 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 728 "wakeup", btdev); 729 if (err) { 730 dev_err(dev, "could request wakeup irq: %d", err); 731 return err; 732 } 733 734 btdev->wakeup_bt = devm_gpiod_get(dev, "bluetooth-wakeup", 735 GPIOD_OUT_LOW); 736 if (IS_ERR(btdev->wakeup_bt)) { 737 err = PTR_ERR(btdev->wakeup_bt); 738 dev_err(dev, "could not get BT wakeup gpio: %d", err); 739 return err; 740 } 741 742 sysclk = devm_clk_get(dev, "sysclk"); 743 if (IS_ERR(sysclk)) { 744 err = PTR_ERR(sysclk); 745 dev_err(dev, "could not get sysclk: %d", err); 746 return err; 747 } 748 749 clk_prepare_enable(sysclk); 750 btdev->sysclk_speed = clk_get_rate(sysclk); 751 clk_disable_unprepare(sysclk); 752 753 skb_queue_head_init(&btdev->txq); 754 755 btdev->hu.priv = btdev; 756 btdev->hu.alignment = 2; /* Nokia H4+ is word aligned */ 757 758 err = hci_uart_register_device(&btdev->hu, &nokia_proto); 759 if (err) { 760 dev_err(dev, "could not register bluetooth uart: %d", err); 761 return err; 762 } 763 764 return 0; 765 } 766 767 static void nokia_bluetooth_serdev_remove(struct serdev_device *serdev) 768 { 769 struct nokia_bt_dev *btdev = serdev_device_get_drvdata(serdev); 770 struct hci_uart *hu = &btdev->hu; 771 struct hci_dev *hdev = hu->hdev; 772 773 cancel_work_sync(&hu->write_work); 774 775 hci_unregister_dev(hdev); 776 hci_free_dev(hdev); 777 hu->proto->close(hu); 778 779 pm_runtime_disable(&btdev->serdev->dev); 780 } 781 782 static int nokia_bluetooth_runtime_suspend(struct device *dev) 783 { 784 struct serdev_device *serdev = to_serdev_device(dev); 785 786 nokia_flow_control(serdev, false); 787 return 0; 788 } 789 790 static int nokia_bluetooth_runtime_resume(struct device *dev) 791 { 792 struct serdev_device *serdev = to_serdev_device(dev); 793 794 nokia_flow_control(serdev, true); 795 return 0; 796 } 797 798 static const struct dev_pm_ops nokia_bluetooth_pm_ops = { 799 SET_RUNTIME_PM_OPS(nokia_bluetooth_runtime_suspend, 800 nokia_bluetooth_runtime_resume, 801 NULL) 802 }; 803 804 #ifdef CONFIG_OF 805 static const struct of_device_id nokia_bluetooth_of_match[] = { 806 { .compatible = "nokia,h4p-bluetooth", }, 807 {}, 808 }; 809 MODULE_DEVICE_TABLE(of, nokia_bluetooth_of_match); 810 #endif 811 812 static struct serdev_device_driver nokia_bluetooth_serdev_driver = { 813 .probe = nokia_bluetooth_serdev_probe, 814 .remove = nokia_bluetooth_serdev_remove, 815 .driver = { 816 .name = "nokia-bluetooth", 817 .pm = &nokia_bluetooth_pm_ops, 818 .of_match_table = of_match_ptr(nokia_bluetooth_of_match), 819 }, 820 }; 821 822 module_serdev_device_driver(nokia_bluetooth_serdev_driver); 823 824 MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>"); 825 MODULE_DESCRIPTION("Bluetooth HCI UART Nokia H4+ driver ver " VERSION); 826 MODULE_VERSION(VERSION); 827 MODULE_LICENSE("GPL"); 828