1 /* 2 * 3 * Bluetooth HCI UART driver for Broadcom devices 4 * 5 * Copyright (C) 2015 Intel Corporation 6 * 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 24 #include <linux/kernel.h> 25 #include <linux/errno.h> 26 #include <linux/skbuff.h> 27 #include <linux/firmware.h> 28 #include <linux/module.h> 29 #include <linux/acpi.h> 30 #include <linux/of.h> 31 #include <linux/property.h> 32 #include <linux/platform_data/x86/apple.h> 33 #include <linux/platform_device.h> 34 #include <linux/clk.h> 35 #include <linux/gpio/consumer.h> 36 #include <linux/tty.h> 37 #include <linux/interrupt.h> 38 #include <linux/dmi.h> 39 #include <linux/pm_runtime.h> 40 #include <linux/serdev.h> 41 42 #include <net/bluetooth/bluetooth.h> 43 #include <net/bluetooth/hci_core.h> 44 45 #include "btbcm.h" 46 #include "hci_uart.h" 47 48 #define BCM_NULL_PKT 0x00 49 #define BCM_NULL_SIZE 0 50 51 #define BCM_LM_DIAG_PKT 0x07 52 #define BCM_LM_DIAG_SIZE 63 53 54 #define BCM_AUTOSUSPEND_DELAY 5000 /* default autosleep delay */ 55 56 /** 57 * struct bcm_device - device driver resources 58 * @serdev_hu: HCI UART controller struct 59 * @list: bcm_device_list node 60 * @dev: physical UART slave 61 * @name: device name logged by bt_dev_*() functions 62 * @device_wakeup: BT_WAKE pin, 63 * assert = Bluetooth device must wake up or remain awake, 64 * deassert = Bluetooth device may sleep when sleep criteria are met 65 * @shutdown: BT_REG_ON pin, 66 * power up or power down Bluetooth device internal regulators 67 * @set_device_wakeup: callback to toggle BT_WAKE pin 68 * either by accessing @device_wakeup or by calling @btlp 69 * @set_shutdown: callback to toggle BT_REG_ON pin 70 * either by accessing @shutdown or by calling @btpu/@btpd 71 * @btlp: Apple ACPI method to toggle BT_WAKE pin ("Bluetooth Low Power") 72 * @btpu: Apple ACPI method to drive BT_REG_ON pin high ("Bluetooth Power Up") 73 * @btpd: Apple ACPI method to drive BT_REG_ON pin low ("Bluetooth Power Down") 74 * @clk: clock used by Bluetooth device 75 * @clk_enabled: whether @clk is prepared and enabled 76 * @init_speed: default baudrate of Bluetooth device; 77 * the host UART is initially set to this baudrate so that 78 * it can configure the Bluetooth device for @oper_speed 79 * @oper_speed: preferred baudrate of Bluetooth device; 80 * set to 0 if @init_speed is already the preferred baudrate 81 * @irq: interrupt triggered by HOST_WAKE_BT pin 82 * @irq_active_low: whether @irq is active low 83 * @hu: pointer to HCI UART controller struct, 84 * used to disable flow control during runtime suspend and system sleep 85 * @is_suspended: whether flow control is currently disabled 86 */ 87 struct bcm_device { 88 /* Must be the first member, hci_serdev.c expects this. */ 89 struct hci_uart serdev_hu; 90 struct list_head list; 91 92 struct device *dev; 93 94 const char *name; 95 struct gpio_desc *device_wakeup; 96 struct gpio_desc *shutdown; 97 int (*set_device_wakeup)(struct bcm_device *, bool); 98 int (*set_shutdown)(struct bcm_device *, bool); 99 #ifdef CONFIG_ACPI 100 acpi_handle btlp, btpu, btpd; 101 #endif 102 103 struct clk *clk; 104 bool clk_enabled; 105 106 u32 init_speed; 107 u32 oper_speed; 108 int irq; 109 bool irq_active_low; 110 111 #ifdef CONFIG_PM 112 struct hci_uart *hu; 113 bool is_suspended; 114 #endif 115 }; 116 117 /* generic bcm uart resources */ 118 struct bcm_data { 119 struct sk_buff *rx_skb; 120 struct sk_buff_head txq; 121 122 struct bcm_device *dev; 123 }; 124 125 /* List of BCM BT UART devices */ 126 static DEFINE_MUTEX(bcm_device_lock); 127 static LIST_HEAD(bcm_device_list); 128 129 static inline void host_set_baudrate(struct hci_uart *hu, unsigned int speed) 130 { 131 if (hu->serdev) 132 serdev_device_set_baudrate(hu->serdev, speed); 133 else 134 hci_uart_set_baudrate(hu, speed); 135 } 136 137 static int bcm_set_baudrate(struct hci_uart *hu, unsigned int speed) 138 { 139 struct hci_dev *hdev = hu->hdev; 140 struct sk_buff *skb; 141 struct bcm_update_uart_baud_rate param; 142 143 if (speed > 3000000) { 144 struct bcm_write_uart_clock_setting clock; 145 146 clock.type = BCM_UART_CLOCK_48MHZ; 147 148 bt_dev_dbg(hdev, "Set Controller clock (%d)", clock.type); 149 150 /* This Broadcom specific command changes the UART's controller 151 * clock for baud rate > 3000000. 152 */ 153 skb = __hci_cmd_sync(hdev, 0xfc45, 1, &clock, HCI_INIT_TIMEOUT); 154 if (IS_ERR(skb)) { 155 int err = PTR_ERR(skb); 156 bt_dev_err(hdev, "BCM: failed to write clock (%d)", 157 err); 158 return err; 159 } 160 161 kfree_skb(skb); 162 } 163 164 bt_dev_dbg(hdev, "Set Controller UART speed to %d bit/s", speed); 165 166 param.zero = cpu_to_le16(0); 167 param.baud_rate = cpu_to_le32(speed); 168 169 /* This Broadcom specific command changes the UART's controller baud 170 * rate. 171 */ 172 skb = __hci_cmd_sync(hdev, 0xfc18, sizeof(param), ¶m, 173 HCI_INIT_TIMEOUT); 174 if (IS_ERR(skb)) { 175 int err = PTR_ERR(skb); 176 bt_dev_err(hdev, "BCM: failed to write update baudrate (%d)", 177 err); 178 return err; 179 } 180 181 kfree_skb(skb); 182 183 return 0; 184 } 185 186 /* bcm_device_exists should be protected by bcm_device_lock */ 187 static bool bcm_device_exists(struct bcm_device *device) 188 { 189 struct list_head *p; 190 191 #ifdef CONFIG_PM 192 /* Devices using serdev always exist */ 193 if (device && device->hu && device->hu->serdev) 194 return true; 195 #endif 196 197 list_for_each(p, &bcm_device_list) { 198 struct bcm_device *dev = list_entry(p, struct bcm_device, list); 199 200 if (device == dev) 201 return true; 202 } 203 204 return false; 205 } 206 207 static int bcm_gpio_set_power(struct bcm_device *dev, bool powered) 208 { 209 int err; 210 211 if (powered && !IS_ERR(dev->clk) && !dev->clk_enabled) { 212 err = clk_prepare_enable(dev->clk); 213 if (err) 214 return err; 215 } 216 217 err = dev->set_shutdown(dev, powered); 218 if (err) 219 goto err_clk_disable; 220 221 err = dev->set_device_wakeup(dev, powered); 222 if (err) 223 goto err_revert_shutdown; 224 225 if (!powered && !IS_ERR(dev->clk) && dev->clk_enabled) 226 clk_disable_unprepare(dev->clk); 227 228 dev->clk_enabled = powered; 229 230 return 0; 231 232 err_revert_shutdown: 233 dev->set_shutdown(dev, !powered); 234 err_clk_disable: 235 if (powered && !IS_ERR(dev->clk) && !dev->clk_enabled) 236 clk_disable_unprepare(dev->clk); 237 return err; 238 } 239 240 #ifdef CONFIG_PM 241 static irqreturn_t bcm_host_wake(int irq, void *data) 242 { 243 struct bcm_device *bdev = data; 244 245 bt_dev_dbg(bdev, "Host wake IRQ"); 246 247 pm_runtime_get(bdev->dev); 248 pm_runtime_mark_last_busy(bdev->dev); 249 pm_runtime_put_autosuspend(bdev->dev); 250 251 return IRQ_HANDLED; 252 } 253 254 static int bcm_request_irq(struct bcm_data *bcm) 255 { 256 struct bcm_device *bdev = bcm->dev; 257 int err; 258 259 mutex_lock(&bcm_device_lock); 260 if (!bcm_device_exists(bdev)) { 261 err = -ENODEV; 262 goto unlock; 263 } 264 265 if (bdev->irq <= 0) { 266 err = -EOPNOTSUPP; 267 goto unlock; 268 } 269 270 err = devm_request_irq(bdev->dev, bdev->irq, bcm_host_wake, 271 bdev->irq_active_low ? IRQF_TRIGGER_FALLING : 272 IRQF_TRIGGER_RISING, 273 "host_wake", bdev); 274 if (err) { 275 bdev->irq = err; 276 goto unlock; 277 } 278 279 device_init_wakeup(bdev->dev, true); 280 281 pm_runtime_set_autosuspend_delay(bdev->dev, 282 BCM_AUTOSUSPEND_DELAY); 283 pm_runtime_use_autosuspend(bdev->dev); 284 pm_runtime_set_active(bdev->dev); 285 pm_runtime_enable(bdev->dev); 286 287 unlock: 288 mutex_unlock(&bcm_device_lock); 289 290 return err; 291 } 292 293 static const struct bcm_set_sleep_mode default_sleep_params = { 294 .sleep_mode = 1, /* 0=Disabled, 1=UART, 2=Reserved, 3=USB */ 295 .idle_host = 2, /* idle threshold HOST, in 300ms */ 296 .idle_dev = 2, /* idle threshold device, in 300ms */ 297 .bt_wake_active = 1, /* BT_WAKE active mode: 1 = high, 0 = low */ 298 .host_wake_active = 0, /* HOST_WAKE active mode: 1 = high, 0 = low */ 299 .allow_host_sleep = 1, /* Allow host sleep in SCO flag */ 300 .combine_modes = 1, /* Combine sleep and LPM flag */ 301 .tristate_control = 0, /* Allow tri-state control of UART tx flag */ 302 /* Irrelevant USB flags */ 303 .usb_auto_sleep = 0, 304 .usb_resume_timeout = 0, 305 .break_to_host = 0, 306 .pulsed_host_wake = 1, 307 }; 308 309 static int bcm_setup_sleep(struct hci_uart *hu) 310 { 311 struct bcm_data *bcm = hu->priv; 312 struct sk_buff *skb; 313 struct bcm_set_sleep_mode sleep_params = default_sleep_params; 314 315 sleep_params.host_wake_active = !bcm->dev->irq_active_low; 316 317 skb = __hci_cmd_sync(hu->hdev, 0xfc27, sizeof(sleep_params), 318 &sleep_params, HCI_INIT_TIMEOUT); 319 if (IS_ERR(skb)) { 320 int err = PTR_ERR(skb); 321 bt_dev_err(hu->hdev, "Sleep VSC failed (%d)", err); 322 return err; 323 } 324 kfree_skb(skb); 325 326 bt_dev_dbg(hu->hdev, "Set Sleep Parameters VSC succeeded"); 327 328 return 0; 329 } 330 #else 331 static inline int bcm_request_irq(struct bcm_data *bcm) { return 0; } 332 static inline int bcm_setup_sleep(struct hci_uart *hu) { return 0; } 333 #endif 334 335 static int bcm_set_diag(struct hci_dev *hdev, bool enable) 336 { 337 struct hci_uart *hu = hci_get_drvdata(hdev); 338 struct bcm_data *bcm = hu->priv; 339 struct sk_buff *skb; 340 341 if (!test_bit(HCI_RUNNING, &hdev->flags)) 342 return -ENETDOWN; 343 344 skb = bt_skb_alloc(3, GFP_KERNEL); 345 if (!skb) 346 return -ENOMEM; 347 348 skb_put_u8(skb, BCM_LM_DIAG_PKT); 349 skb_put_u8(skb, 0xf0); 350 skb_put_u8(skb, enable); 351 352 skb_queue_tail(&bcm->txq, skb); 353 hci_uart_tx_wakeup(hu); 354 355 return 0; 356 } 357 358 static int bcm_open(struct hci_uart *hu) 359 { 360 struct bcm_data *bcm; 361 struct list_head *p; 362 int err; 363 364 bt_dev_dbg(hu->hdev, "hu %p", hu); 365 366 bcm = kzalloc(sizeof(*bcm), GFP_KERNEL); 367 if (!bcm) 368 return -ENOMEM; 369 370 skb_queue_head_init(&bcm->txq); 371 372 hu->priv = bcm; 373 374 mutex_lock(&bcm_device_lock); 375 376 if (hu->serdev) { 377 err = serdev_device_open(hu->serdev); 378 if (err) 379 goto err_free; 380 381 bcm->dev = serdev_device_get_drvdata(hu->serdev); 382 goto out; 383 } 384 385 if (!hu->tty->dev) 386 goto out; 387 388 list_for_each(p, &bcm_device_list) { 389 struct bcm_device *dev = list_entry(p, struct bcm_device, list); 390 391 /* Retrieve saved bcm_device based on parent of the 392 * platform device (saved during device probe) and 393 * parent of tty device used by hci_uart 394 */ 395 if (hu->tty->dev->parent == dev->dev->parent) { 396 bcm->dev = dev; 397 #ifdef CONFIG_PM 398 dev->hu = hu; 399 #endif 400 break; 401 } 402 } 403 404 out: 405 if (bcm->dev) { 406 hu->init_speed = bcm->dev->init_speed; 407 hu->oper_speed = bcm->dev->oper_speed; 408 err = bcm_gpio_set_power(bcm->dev, true); 409 if (err) 410 goto err_unset_hu; 411 } 412 413 mutex_unlock(&bcm_device_lock); 414 return 0; 415 416 err_unset_hu: 417 if (hu->serdev) 418 serdev_device_close(hu->serdev); 419 #ifdef CONFIG_PM 420 else 421 bcm->dev->hu = NULL; 422 #endif 423 err_free: 424 mutex_unlock(&bcm_device_lock); 425 hu->priv = NULL; 426 kfree(bcm); 427 return err; 428 } 429 430 static int bcm_close(struct hci_uart *hu) 431 { 432 struct bcm_data *bcm = hu->priv; 433 struct bcm_device *bdev = NULL; 434 int err; 435 436 bt_dev_dbg(hu->hdev, "hu %p", hu); 437 438 /* Protect bcm->dev against removal of the device or driver */ 439 mutex_lock(&bcm_device_lock); 440 441 if (hu->serdev) { 442 serdev_device_close(hu->serdev); 443 bdev = serdev_device_get_drvdata(hu->serdev); 444 } else if (bcm_device_exists(bcm->dev)) { 445 bdev = bcm->dev; 446 #ifdef CONFIG_PM 447 bdev->hu = NULL; 448 #endif 449 } 450 451 if (bdev) { 452 if (IS_ENABLED(CONFIG_PM) && bdev->irq > 0) { 453 devm_free_irq(bdev->dev, bdev->irq, bdev); 454 device_init_wakeup(bdev->dev, false); 455 pm_runtime_disable(bdev->dev); 456 } 457 458 err = bcm_gpio_set_power(bdev, false); 459 if (err) 460 bt_dev_err(hu->hdev, "Failed to power down"); 461 else 462 pm_runtime_set_suspended(bdev->dev); 463 } 464 mutex_unlock(&bcm_device_lock); 465 466 skb_queue_purge(&bcm->txq); 467 kfree_skb(bcm->rx_skb); 468 kfree(bcm); 469 470 hu->priv = NULL; 471 return 0; 472 } 473 474 static int bcm_flush(struct hci_uart *hu) 475 { 476 struct bcm_data *bcm = hu->priv; 477 478 bt_dev_dbg(hu->hdev, "hu %p", hu); 479 480 skb_queue_purge(&bcm->txq); 481 482 return 0; 483 } 484 485 static int bcm_setup(struct hci_uart *hu) 486 { 487 struct bcm_data *bcm = hu->priv; 488 char fw_name[64]; 489 const struct firmware *fw; 490 unsigned int speed; 491 int err; 492 493 bt_dev_dbg(hu->hdev, "hu %p", hu); 494 495 hu->hdev->set_diag = bcm_set_diag; 496 hu->hdev->set_bdaddr = btbcm_set_bdaddr; 497 498 err = btbcm_initialize(hu->hdev, fw_name, sizeof(fw_name)); 499 if (err) 500 return err; 501 502 err = request_firmware(&fw, fw_name, &hu->hdev->dev); 503 if (err < 0) { 504 bt_dev_info(hu->hdev, "BCM: Patch %s not found", fw_name); 505 return 0; 506 } 507 508 err = btbcm_patchram(hu->hdev, fw); 509 if (err) { 510 bt_dev_info(hu->hdev, "BCM: Patch failed (%d)", err); 511 goto finalize; 512 } 513 514 /* Init speed if any */ 515 if (hu->init_speed) 516 speed = hu->init_speed; 517 else if (hu->proto->init_speed) 518 speed = hu->proto->init_speed; 519 else 520 speed = 0; 521 522 if (speed) 523 host_set_baudrate(hu, speed); 524 525 /* Operational speed if any */ 526 if (hu->oper_speed) 527 speed = hu->oper_speed; 528 else if (hu->proto->oper_speed) 529 speed = hu->proto->oper_speed; 530 else 531 speed = 0; 532 533 if (speed) { 534 err = bcm_set_baudrate(hu, speed); 535 if (!err) 536 host_set_baudrate(hu, speed); 537 } 538 539 finalize: 540 release_firmware(fw); 541 542 err = btbcm_finalize(hu->hdev); 543 if (err) 544 return err; 545 546 if (!bcm_request_irq(bcm)) 547 err = bcm_setup_sleep(hu); 548 549 return err; 550 } 551 552 #define BCM_RECV_LM_DIAG \ 553 .type = BCM_LM_DIAG_PKT, \ 554 .hlen = BCM_LM_DIAG_SIZE, \ 555 .loff = 0, \ 556 .lsize = 0, \ 557 .maxlen = BCM_LM_DIAG_SIZE 558 559 #define BCM_RECV_NULL \ 560 .type = BCM_NULL_PKT, \ 561 .hlen = BCM_NULL_SIZE, \ 562 .loff = 0, \ 563 .lsize = 0, \ 564 .maxlen = BCM_NULL_SIZE 565 566 static const struct h4_recv_pkt bcm_recv_pkts[] = { 567 { H4_RECV_ACL, .recv = hci_recv_frame }, 568 { H4_RECV_SCO, .recv = hci_recv_frame }, 569 { H4_RECV_EVENT, .recv = hci_recv_frame }, 570 { BCM_RECV_LM_DIAG, .recv = hci_recv_diag }, 571 { BCM_RECV_NULL, .recv = hci_recv_diag }, 572 }; 573 574 static int bcm_recv(struct hci_uart *hu, const void *data, int count) 575 { 576 struct bcm_data *bcm = hu->priv; 577 578 if (!test_bit(HCI_UART_REGISTERED, &hu->flags)) 579 return -EUNATCH; 580 581 bcm->rx_skb = h4_recv_buf(hu->hdev, bcm->rx_skb, data, count, 582 bcm_recv_pkts, ARRAY_SIZE(bcm_recv_pkts)); 583 if (IS_ERR(bcm->rx_skb)) { 584 int err = PTR_ERR(bcm->rx_skb); 585 bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err); 586 bcm->rx_skb = NULL; 587 return err; 588 } else if (!bcm->rx_skb) { 589 /* Delay auto-suspend when receiving completed packet */ 590 mutex_lock(&bcm_device_lock); 591 if (bcm->dev && bcm_device_exists(bcm->dev)) { 592 pm_runtime_get(bcm->dev->dev); 593 pm_runtime_mark_last_busy(bcm->dev->dev); 594 pm_runtime_put_autosuspend(bcm->dev->dev); 595 } 596 mutex_unlock(&bcm_device_lock); 597 } 598 599 return count; 600 } 601 602 static int bcm_enqueue(struct hci_uart *hu, struct sk_buff *skb) 603 { 604 struct bcm_data *bcm = hu->priv; 605 606 bt_dev_dbg(hu->hdev, "hu %p skb %p", hu, skb); 607 608 /* Prepend skb with frame type */ 609 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1); 610 skb_queue_tail(&bcm->txq, skb); 611 612 return 0; 613 } 614 615 static struct sk_buff *bcm_dequeue(struct hci_uart *hu) 616 { 617 struct bcm_data *bcm = hu->priv; 618 struct sk_buff *skb = NULL; 619 struct bcm_device *bdev = NULL; 620 621 mutex_lock(&bcm_device_lock); 622 623 if (bcm_device_exists(bcm->dev)) { 624 bdev = bcm->dev; 625 pm_runtime_get_sync(bdev->dev); 626 /* Shall be resumed here */ 627 } 628 629 skb = skb_dequeue(&bcm->txq); 630 631 if (bdev) { 632 pm_runtime_mark_last_busy(bdev->dev); 633 pm_runtime_put_autosuspend(bdev->dev); 634 } 635 636 mutex_unlock(&bcm_device_lock); 637 638 return skb; 639 } 640 641 #ifdef CONFIG_PM 642 static int bcm_suspend_device(struct device *dev) 643 { 644 struct bcm_device *bdev = dev_get_drvdata(dev); 645 int err; 646 647 bt_dev_dbg(bdev, ""); 648 649 if (!bdev->is_suspended && bdev->hu) { 650 hci_uart_set_flow_control(bdev->hu, true); 651 652 /* Once this returns, driver suspends BT via GPIO */ 653 bdev->is_suspended = true; 654 } 655 656 /* Suspend the device */ 657 err = bdev->set_device_wakeup(bdev, false); 658 if (err) { 659 if (bdev->is_suspended && bdev->hu) { 660 bdev->is_suspended = false; 661 hci_uart_set_flow_control(bdev->hu, false); 662 } 663 return -EBUSY; 664 } 665 666 bt_dev_dbg(bdev, "suspend, delaying 15 ms"); 667 msleep(15); 668 669 return 0; 670 } 671 672 static int bcm_resume_device(struct device *dev) 673 { 674 struct bcm_device *bdev = dev_get_drvdata(dev); 675 int err; 676 677 bt_dev_dbg(bdev, ""); 678 679 err = bdev->set_device_wakeup(bdev, true); 680 if (err) { 681 dev_err(dev, "Failed to power up\n"); 682 return err; 683 } 684 685 bt_dev_dbg(bdev, "resume, delaying 15 ms"); 686 msleep(15); 687 688 /* When this executes, the device has woken up already */ 689 if (bdev->is_suspended && bdev->hu) { 690 bdev->is_suspended = false; 691 692 hci_uart_set_flow_control(bdev->hu, false); 693 } 694 695 return 0; 696 } 697 #endif 698 699 #ifdef CONFIG_PM_SLEEP 700 /* suspend callback */ 701 static int bcm_suspend(struct device *dev) 702 { 703 struct bcm_device *bdev = dev_get_drvdata(dev); 704 int error; 705 706 bt_dev_dbg(bdev, "suspend: is_suspended %d", bdev->is_suspended); 707 708 /* 709 * When used with a device instantiated as platform_device, bcm_suspend 710 * can be called at any time as long as the platform device is bound, 711 * so it should use bcm_device_lock to protect access to hci_uart 712 * and device_wake-up GPIO. 713 */ 714 mutex_lock(&bcm_device_lock); 715 716 if (!bdev->hu) 717 goto unlock; 718 719 if (pm_runtime_active(dev)) 720 bcm_suspend_device(dev); 721 722 if (device_may_wakeup(dev) && bdev->irq > 0) { 723 error = enable_irq_wake(bdev->irq); 724 if (!error) 725 bt_dev_dbg(bdev, "BCM irq: enabled"); 726 } 727 728 unlock: 729 mutex_unlock(&bcm_device_lock); 730 731 return 0; 732 } 733 734 /* resume callback */ 735 static int bcm_resume(struct device *dev) 736 { 737 struct bcm_device *bdev = dev_get_drvdata(dev); 738 int err = 0; 739 740 bt_dev_dbg(bdev, "resume: is_suspended %d", bdev->is_suspended); 741 742 /* 743 * When used with a device instantiated as platform_device, bcm_resume 744 * can be called at any time as long as platform device is bound, 745 * so it should use bcm_device_lock to protect access to hci_uart 746 * and device_wake-up GPIO. 747 */ 748 mutex_lock(&bcm_device_lock); 749 750 if (!bdev->hu) 751 goto unlock; 752 753 if (device_may_wakeup(dev) && bdev->irq > 0) { 754 disable_irq_wake(bdev->irq); 755 bt_dev_dbg(bdev, "BCM irq: disabled"); 756 } 757 758 err = bcm_resume_device(dev); 759 760 unlock: 761 mutex_unlock(&bcm_device_lock); 762 763 if (!err) { 764 pm_runtime_disable(dev); 765 pm_runtime_set_active(dev); 766 pm_runtime_enable(dev); 767 } 768 769 return 0; 770 } 771 #endif 772 773 static const struct acpi_gpio_params int_last_device_wakeup_gpios = { 0, 0, false }; 774 static const struct acpi_gpio_params int_last_shutdown_gpios = { 1, 0, false }; 775 static const struct acpi_gpio_params int_last_host_wakeup_gpios = { 2, 0, false }; 776 777 static const struct acpi_gpio_mapping acpi_bcm_int_last_gpios[] = { 778 { "device-wakeup-gpios", &int_last_device_wakeup_gpios, 1 }, 779 { "shutdown-gpios", &int_last_shutdown_gpios, 1 }, 780 { "host-wakeup-gpios", &int_last_host_wakeup_gpios, 1 }, 781 { }, 782 }; 783 784 static const struct acpi_gpio_params int_first_host_wakeup_gpios = { 0, 0, false }; 785 static const struct acpi_gpio_params int_first_device_wakeup_gpios = { 1, 0, false }; 786 static const struct acpi_gpio_params int_first_shutdown_gpios = { 2, 0, false }; 787 788 static const struct acpi_gpio_mapping acpi_bcm_int_first_gpios[] = { 789 { "device-wakeup-gpios", &int_first_device_wakeup_gpios, 1 }, 790 { "shutdown-gpios", &int_first_shutdown_gpios, 1 }, 791 { "host-wakeup-gpios", &int_first_host_wakeup_gpios, 1 }, 792 { }, 793 }; 794 795 #ifdef CONFIG_ACPI 796 /* IRQ polarity of some chipsets are not defined correctly in ACPI table. */ 797 static const struct dmi_system_id bcm_active_low_irq_dmi_table[] = { 798 { 799 .ident = "Asus T100TA", 800 .matches = { 801 DMI_EXACT_MATCH(DMI_SYS_VENDOR, 802 "ASUSTeK COMPUTER INC."), 803 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100TA"), 804 }, 805 }, 806 { 807 .ident = "Asus T100CHI", 808 .matches = { 809 DMI_EXACT_MATCH(DMI_SYS_VENDOR, 810 "ASUSTeK COMPUTER INC."), 811 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100CHI"), 812 }, 813 }, 814 { /* Handle ThinkPad 8 tablets with BCM2E55 chipset ACPI ID */ 815 .ident = "Lenovo ThinkPad 8", 816 .matches = { 817 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"), 818 DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "ThinkPad 8"), 819 }, 820 }, 821 { 822 .ident = "MINIX Z83-4", 823 .matches = { 824 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "MINIX"), 825 DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"), 826 }, 827 }, 828 { } 829 }; 830 831 static int bcm_resource(struct acpi_resource *ares, void *data) 832 { 833 struct bcm_device *dev = data; 834 struct acpi_resource_extended_irq *irq; 835 struct acpi_resource_gpio *gpio; 836 struct acpi_resource_uart_serialbus *sb; 837 838 switch (ares->type) { 839 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 840 irq = &ares->data.extended_irq; 841 dev->irq_active_low = irq->polarity == ACPI_ACTIVE_LOW; 842 break; 843 844 case ACPI_RESOURCE_TYPE_GPIO: 845 gpio = &ares->data.gpio; 846 if (gpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT) 847 dev->irq_active_low = gpio->polarity == ACPI_ACTIVE_LOW; 848 break; 849 850 case ACPI_RESOURCE_TYPE_SERIAL_BUS: 851 sb = &ares->data.uart_serial_bus; 852 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_UART) { 853 dev->init_speed = sb->default_baud_rate; 854 dev->oper_speed = 4000000; 855 } 856 break; 857 858 default: 859 break; 860 } 861 862 return 0; 863 } 864 865 static int bcm_apple_set_device_wakeup(struct bcm_device *dev, bool awake) 866 { 867 if (ACPI_FAILURE(acpi_execute_simple_method(dev->btlp, NULL, !awake))) 868 return -EIO; 869 870 return 0; 871 } 872 873 static int bcm_apple_set_shutdown(struct bcm_device *dev, bool powered) 874 { 875 if (ACPI_FAILURE(acpi_evaluate_object(powered ? dev->btpu : dev->btpd, 876 NULL, NULL, NULL))) 877 return -EIO; 878 879 return 0; 880 } 881 882 static int bcm_apple_get_resources(struct bcm_device *dev) 883 { 884 struct acpi_device *adev = ACPI_COMPANION(dev->dev); 885 const union acpi_object *obj; 886 887 if (!adev || 888 ACPI_FAILURE(acpi_get_handle(adev->handle, "BTLP", &dev->btlp)) || 889 ACPI_FAILURE(acpi_get_handle(adev->handle, "BTPU", &dev->btpu)) || 890 ACPI_FAILURE(acpi_get_handle(adev->handle, "BTPD", &dev->btpd))) 891 return -ENODEV; 892 893 if (!acpi_dev_get_property(adev, "baud", ACPI_TYPE_BUFFER, &obj) && 894 obj->buffer.length == 8) 895 dev->init_speed = *(u64 *)obj->buffer.pointer; 896 897 dev->set_device_wakeup = bcm_apple_set_device_wakeup; 898 dev->set_shutdown = bcm_apple_set_shutdown; 899 900 return 0; 901 } 902 #else 903 static inline int bcm_apple_get_resources(struct bcm_device *dev) 904 { 905 return -EOPNOTSUPP; 906 } 907 #endif /* CONFIG_ACPI */ 908 909 static int bcm_gpio_set_device_wakeup(struct bcm_device *dev, bool awake) 910 { 911 gpiod_set_value(dev->device_wakeup, awake); 912 return 0; 913 } 914 915 static int bcm_gpio_set_shutdown(struct bcm_device *dev, bool powered) 916 { 917 gpiod_set_value(dev->shutdown, powered); 918 return 0; 919 } 920 921 static int bcm_get_resources(struct bcm_device *dev) 922 { 923 dev->name = dev_name(dev->dev); 924 925 if (x86_apple_machine && !bcm_apple_get_resources(dev)) 926 return 0; 927 928 dev->clk = devm_clk_get(dev->dev, NULL); 929 930 dev->device_wakeup = devm_gpiod_get_optional(dev->dev, "device-wakeup", 931 GPIOD_OUT_LOW); 932 if (IS_ERR(dev->device_wakeup)) 933 return PTR_ERR(dev->device_wakeup); 934 935 dev->shutdown = devm_gpiod_get_optional(dev->dev, "shutdown", 936 GPIOD_OUT_LOW); 937 if (IS_ERR(dev->shutdown)) 938 return PTR_ERR(dev->shutdown); 939 940 dev->set_device_wakeup = bcm_gpio_set_device_wakeup; 941 dev->set_shutdown = bcm_gpio_set_shutdown; 942 943 /* IRQ can be declared in ACPI table as Interrupt or GpioInt */ 944 if (dev->irq <= 0) { 945 struct gpio_desc *gpio; 946 947 gpio = devm_gpiod_get_optional(dev->dev, "host-wakeup", 948 GPIOD_IN); 949 if (IS_ERR(gpio)) 950 return PTR_ERR(gpio); 951 952 dev->irq = gpiod_to_irq(gpio); 953 } 954 955 dev_dbg(dev->dev, "BCM irq: %d\n", dev->irq); 956 return 0; 957 } 958 959 #ifdef CONFIG_ACPI 960 static int bcm_acpi_probe(struct bcm_device *dev) 961 { 962 LIST_HEAD(resources); 963 const struct dmi_system_id *dmi_id; 964 const struct acpi_gpio_mapping *gpio_mapping = acpi_bcm_int_last_gpios; 965 const struct acpi_device_id *id; 966 struct resource_entry *entry; 967 int ret; 968 969 /* Retrieve GPIO data */ 970 id = acpi_match_device(dev->dev->driver->acpi_match_table, dev->dev); 971 if (id) 972 gpio_mapping = (const struct acpi_gpio_mapping *) id->driver_data; 973 974 ret = devm_acpi_dev_add_driver_gpios(dev->dev, gpio_mapping); 975 if (ret) 976 return ret; 977 978 /* Retrieve UART ACPI info */ 979 ret = acpi_dev_get_resources(ACPI_COMPANION(dev->dev), 980 &resources, bcm_resource, dev); 981 if (ret < 0) 982 return ret; 983 984 resource_list_for_each_entry(entry, &resources) { 985 if (resource_type(entry->res) == IORESOURCE_IRQ) { 986 dev->irq = entry->res->start; 987 break; 988 } 989 } 990 acpi_dev_free_resource_list(&resources); 991 992 dmi_id = dmi_first_match(bcm_active_low_irq_dmi_table); 993 if (dmi_id) { 994 dev_warn(dev->dev, "%s: Overwriting IRQ polarity to active low", 995 dmi_id->ident); 996 dev->irq_active_low = true; 997 } 998 999 return 0; 1000 } 1001 #else 1002 static int bcm_acpi_probe(struct bcm_device *dev) 1003 { 1004 return -EINVAL; 1005 } 1006 #endif /* CONFIG_ACPI */ 1007 1008 static int bcm_of_probe(struct bcm_device *bdev) 1009 { 1010 device_property_read_u32(bdev->dev, "max-speed", &bdev->oper_speed); 1011 return 0; 1012 } 1013 1014 static int bcm_probe(struct platform_device *pdev) 1015 { 1016 struct bcm_device *dev; 1017 int ret; 1018 1019 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL); 1020 if (!dev) 1021 return -ENOMEM; 1022 1023 dev->dev = &pdev->dev; 1024 dev->irq = platform_get_irq(pdev, 0); 1025 1026 if (has_acpi_companion(&pdev->dev)) { 1027 ret = bcm_acpi_probe(dev); 1028 if (ret) 1029 return ret; 1030 } 1031 1032 ret = bcm_get_resources(dev); 1033 if (ret) 1034 return ret; 1035 1036 platform_set_drvdata(pdev, dev); 1037 1038 dev_info(&pdev->dev, "%s device registered.\n", dev->name); 1039 1040 /* Place this instance on the device list */ 1041 mutex_lock(&bcm_device_lock); 1042 list_add_tail(&dev->list, &bcm_device_list); 1043 mutex_unlock(&bcm_device_lock); 1044 1045 ret = bcm_gpio_set_power(dev, false); 1046 if (ret) 1047 dev_err(&pdev->dev, "Failed to power down\n"); 1048 1049 return 0; 1050 } 1051 1052 static int bcm_remove(struct platform_device *pdev) 1053 { 1054 struct bcm_device *dev = platform_get_drvdata(pdev); 1055 1056 mutex_lock(&bcm_device_lock); 1057 list_del(&dev->list); 1058 mutex_unlock(&bcm_device_lock); 1059 1060 dev_info(&pdev->dev, "%s device unregistered.\n", dev->name); 1061 1062 return 0; 1063 } 1064 1065 static const struct hci_uart_proto bcm_proto = { 1066 .id = HCI_UART_BCM, 1067 .name = "Broadcom", 1068 .manufacturer = 15, 1069 .init_speed = 115200, 1070 .open = bcm_open, 1071 .close = bcm_close, 1072 .flush = bcm_flush, 1073 .setup = bcm_setup, 1074 .set_baudrate = bcm_set_baudrate, 1075 .recv = bcm_recv, 1076 .enqueue = bcm_enqueue, 1077 .dequeue = bcm_dequeue, 1078 }; 1079 1080 #ifdef CONFIG_ACPI 1081 static const struct acpi_device_id bcm_acpi_match[] = { 1082 { "BCM2E1A", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1083 { "BCM2E39", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1084 { "BCM2E3A", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1085 { "BCM2E3D", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1086 { "BCM2E3F", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1087 { "BCM2E40", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1088 { "BCM2E54", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1089 { "BCM2E55", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1090 { "BCM2E64", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1091 { "BCM2E65", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1092 { "BCM2E67", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1093 { "BCM2E71", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1094 { "BCM2E72", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1095 { "BCM2E7B", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1096 { "BCM2E7C", (kernel_ulong_t)&acpi_bcm_int_last_gpios }, 1097 { "BCM2E7E", (kernel_ulong_t)&acpi_bcm_int_first_gpios }, 1098 { "BCM2E95", (kernel_ulong_t)&acpi_bcm_int_first_gpios }, 1099 { "BCM2E96", (kernel_ulong_t)&acpi_bcm_int_first_gpios }, 1100 { "BCM2EA4", (kernel_ulong_t)&acpi_bcm_int_first_gpios }, 1101 { }, 1102 }; 1103 MODULE_DEVICE_TABLE(acpi, bcm_acpi_match); 1104 #endif 1105 1106 /* suspend and resume callbacks */ 1107 static const struct dev_pm_ops bcm_pm_ops = { 1108 SET_SYSTEM_SLEEP_PM_OPS(bcm_suspend, bcm_resume) 1109 SET_RUNTIME_PM_OPS(bcm_suspend_device, bcm_resume_device, NULL) 1110 }; 1111 1112 static struct platform_driver bcm_driver = { 1113 .probe = bcm_probe, 1114 .remove = bcm_remove, 1115 .driver = { 1116 .name = "hci_bcm", 1117 .acpi_match_table = ACPI_PTR(bcm_acpi_match), 1118 .pm = &bcm_pm_ops, 1119 }, 1120 }; 1121 1122 static int bcm_serdev_probe(struct serdev_device *serdev) 1123 { 1124 struct bcm_device *bcmdev; 1125 int err; 1126 1127 bcmdev = devm_kzalloc(&serdev->dev, sizeof(*bcmdev), GFP_KERNEL); 1128 if (!bcmdev) 1129 return -ENOMEM; 1130 1131 bcmdev->dev = &serdev->dev; 1132 #ifdef CONFIG_PM 1133 bcmdev->hu = &bcmdev->serdev_hu; 1134 #endif 1135 bcmdev->serdev_hu.serdev = serdev; 1136 serdev_device_set_drvdata(serdev, bcmdev); 1137 1138 if (has_acpi_companion(&serdev->dev)) 1139 err = bcm_acpi_probe(bcmdev); 1140 else 1141 err = bcm_of_probe(bcmdev); 1142 if (err) 1143 return err; 1144 1145 err = bcm_get_resources(bcmdev); 1146 if (err) 1147 return err; 1148 1149 err = bcm_gpio_set_power(bcmdev, false); 1150 if (err) 1151 dev_err(&serdev->dev, "Failed to power down\n"); 1152 1153 return hci_uart_register_device(&bcmdev->serdev_hu, &bcm_proto); 1154 } 1155 1156 static void bcm_serdev_remove(struct serdev_device *serdev) 1157 { 1158 struct bcm_device *bcmdev = serdev_device_get_drvdata(serdev); 1159 1160 hci_uart_unregister_device(&bcmdev->serdev_hu); 1161 } 1162 1163 #ifdef CONFIG_OF 1164 static const struct of_device_id bcm_bluetooth_of_match[] = { 1165 { .compatible = "brcm,bcm43438-bt" }, 1166 { }, 1167 }; 1168 MODULE_DEVICE_TABLE(of, bcm_bluetooth_of_match); 1169 #endif 1170 1171 static struct serdev_device_driver bcm_serdev_driver = { 1172 .probe = bcm_serdev_probe, 1173 .remove = bcm_serdev_remove, 1174 .driver = { 1175 .name = "hci_uart_bcm", 1176 .of_match_table = of_match_ptr(bcm_bluetooth_of_match), 1177 .acpi_match_table = ACPI_PTR(bcm_acpi_match), 1178 .pm = &bcm_pm_ops, 1179 }, 1180 }; 1181 1182 int __init bcm_init(void) 1183 { 1184 /* For now, we need to keep both platform device 1185 * driver (ACPI generated) and serdev driver (DT). 1186 */ 1187 platform_driver_register(&bcm_driver); 1188 serdev_device_driver_register(&bcm_serdev_driver); 1189 1190 return hci_uart_register_proto(&bcm_proto); 1191 } 1192 1193 int __exit bcm_deinit(void) 1194 { 1195 platform_driver_unregister(&bcm_driver); 1196 serdev_device_driver_unregister(&bcm_serdev_driver); 1197 1198 return hci_uart_unregister_proto(&bcm_proto); 1199 } 1200