1644 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 *4 * Bluetooth HCI UART driver for Broadcom devices5 *6 * Copyright (C) 2015 Intel Corporation7 */8 9#include <linux/kernel.h>10#include <linux/errno.h>11#include <linux/skbuff.h>12#include <linux/firmware.h>13#include <linux/module.h>14#include <linux/acpi.h>15#include <linux/of.h>16#include <linux/of_irq.h>17#include <linux/property.h>18#include <linux/platform_data/x86/apple.h>19#include <linux/platform_device.h>20#include <linux/regulator/consumer.h>21#include <linux/clk.h>22#include <linux/gpio/consumer.h>23#include <linux/gpio/machine.h>24#include <linux/tty.h>25#include <linux/interrupt.h>26#include <linux/dmi.h>27#include <linux/pm_runtime.h>28#include <linux/serdev.h>29 30#include <net/bluetooth/bluetooth.h>31#include <net/bluetooth/hci_core.h>32 33#include "btbcm.h"34#include "hci_uart.h"35 36#define BCM_NULL_PKT 0x0037#define BCM_NULL_SIZE 038 39#define BCM_LM_DIAG_PKT 0x0740#define BCM_LM_DIAG_SIZE 6341 42#define BCM_TYPE49_PKT 0x3143#define BCM_TYPE49_SIZE 044 45#define BCM_TYPE52_PKT 0x3446#define BCM_TYPE52_SIZE 047 48#define BCM_AUTOSUSPEND_DELAY 5000 /* default autosleep delay */49 50#define BCM_NUM_SUPPLIES 251 52/**53 * struct bcm_device_data - device specific data54 * @no_early_set_baudrate: Disallow set baudrate before driver setup()55 * @drive_rts_on_open: drive RTS signal on ->open() when platform requires it56 * @no_uart_clock_set: UART clock set command for >3Mbps mode is unavailable57 * @max_autobaud_speed: max baudrate supported by device in autobaud mode58 * @max_speed: max baudrate supported59 */60struct bcm_device_data {61 bool no_early_set_baudrate;62 bool drive_rts_on_open;63 bool no_uart_clock_set;64 u32 max_autobaud_speed;65 u32 max_speed;66};67 68/**69 * struct bcm_device - device driver resources70 * @serdev_hu: HCI UART controller struct71 * @list: bcm_device_list node72 * @dev: physical UART slave73 * @name: device name logged by bt_dev_*() functions74 * @device_wakeup: BT_WAKE pin,75 * assert = Bluetooth device must wake up or remain awake,76 * deassert = Bluetooth device may sleep when sleep criteria are met77 * @shutdown: BT_REG_ON pin,78 * power up or power down Bluetooth device internal regulators79 * @reset: BT_RST_N pin,80 * active low resets the Bluetooth logic core81 * @set_device_wakeup: callback to toggle BT_WAKE pin82 * either by accessing @device_wakeup or by calling @btlp83 * @set_shutdown: callback to toggle BT_REG_ON pin84 * either by accessing @shutdown or by calling @btpu/@btpd85 * @btlp: Apple ACPI method to toggle BT_WAKE pin ("Bluetooth Low Power")86 * @btpu: Apple ACPI method to drive BT_REG_ON pin high ("Bluetooth Power Up")87 * @btpd: Apple ACPI method to drive BT_REG_ON pin low ("Bluetooth Power Down")88 * @gpio_count: internal counter for GPIO resources associated with ACPI device89 * @gpio_int_idx: index in _CRS for GpioInt() resource90 * @txco_clk: external reference frequency clock used by Bluetooth device91 * @lpo_clk: external LPO clock used by Bluetooth device92 * @supplies: VBAT and VDDIO supplies used by Bluetooth device93 * @res_enabled: whether clocks and supplies are prepared and enabled94 * @init_speed: default baudrate of Bluetooth device;95 * the host UART is initially set to this baudrate so that96 * it can configure the Bluetooth device for @oper_speed97 * @oper_speed: preferred baudrate of Bluetooth device;98 * set to 0 if @init_speed is already the preferred baudrate99 * @irq: interrupt triggered by HOST_WAKE_BT pin100 * @irq_active_low: whether @irq is active low101 * @irq_acquired: flag to show if IRQ handler has been assigned102 * @hu: pointer to HCI UART controller struct,103 * used to disable flow control during runtime suspend and system sleep104 * @is_suspended: whether flow control is currently disabled105 * @no_early_set_baudrate: don't set_baudrate before setup()106 * @drive_rts_on_open: drive RTS signal on ->open() when platform requires it107 * @no_uart_clock_set: UART clock set command for >3Mbps mode is unavailable108 * @pcm_int_params: keep the initial PCM configuration109 * @use_autobaud_mode: start Bluetooth device in autobaud mode110 * @max_autobaud_speed: max baudrate supported by device in autobaud mode111 */112struct bcm_device {113 /* Must be the first member, hci_serdev.c expects this. */114 struct hci_uart serdev_hu;115 struct list_head list;116 117 struct device *dev;118 119 const char *name;120 struct gpio_desc *device_wakeup;121 struct gpio_desc *shutdown;122 struct gpio_desc *reset;123 int (*set_device_wakeup)(struct bcm_device *, bool);124 int (*set_shutdown)(struct bcm_device *, bool);125#ifdef CONFIG_ACPI126 acpi_handle btlp, btpu, btpd;127 int gpio_count;128 int gpio_int_idx;129#endif130 131 struct clk *txco_clk;132 struct clk *lpo_clk;133 struct regulator_bulk_data supplies[BCM_NUM_SUPPLIES];134 bool res_enabled;135 136 u32 init_speed;137 u32 oper_speed;138 int irq;139 bool irq_active_low;140 bool irq_acquired;141 142#ifdef CONFIG_PM143 struct hci_uart *hu;144 bool is_suspended;145#endif146 bool no_early_set_baudrate;147 bool drive_rts_on_open;148 bool no_uart_clock_set;149 bool use_autobaud_mode;150 u8 pcm_int_params[5];151 u32 max_autobaud_speed;152};153 154/* generic bcm uart resources */155struct bcm_data {156 struct sk_buff *rx_skb;157 struct sk_buff_head txq;158 159 struct bcm_device *dev;160};161 162/* List of BCM BT UART devices */163static DEFINE_MUTEX(bcm_device_lock);164static LIST_HEAD(bcm_device_list);165 166static int irq_polarity = -1;167module_param(irq_polarity, int, 0444);168MODULE_PARM_DESC(irq_polarity, "IRQ polarity 0: active-high 1: active-low");169 170static inline void host_set_baudrate(struct hci_uart *hu, unsigned int speed)171{172 if (hu->serdev)173 serdev_device_set_baudrate(hu->serdev, speed);174 else175 hci_uart_set_baudrate(hu, speed);176}177 178static int bcm_set_baudrate(struct hci_uart *hu, unsigned int speed)179{180 struct hci_dev *hdev = hu->hdev;181 struct bcm_data *bcm = hu->priv;182 struct sk_buff *skb;183 struct bcm_update_uart_baud_rate param;184 185 if (speed > 3000000 && !bcm->dev->no_uart_clock_set) {186 struct bcm_write_uart_clock_setting clock;187 188 clock.type = BCM_UART_CLOCK_48MHZ;189 190 bt_dev_dbg(hdev, "Set Controller clock (%d)", clock.type);191 192 /* This Broadcom specific command changes the UART's controller193 * clock for baud rate > 3000000.194 */195 skb = __hci_cmd_sync(hdev, 0xfc45, 1, &clock, HCI_INIT_TIMEOUT);196 if (IS_ERR(skb)) {197 int err = PTR_ERR(skb);198 bt_dev_err(hdev, "BCM: failed to write clock (%d)",199 err);200 return err;201 }202 203 kfree_skb(skb);204 }205 206 bt_dev_dbg(hdev, "Set Controller UART speed to %d bit/s", speed);207 208 param.zero = cpu_to_le16(0);209 param.baud_rate = cpu_to_le32(speed);210 211 /* This Broadcom specific command changes the UART's controller baud212 * rate.213 */214 skb = __hci_cmd_sync(hdev, 0xfc18, sizeof(param), ¶m,215 HCI_INIT_TIMEOUT);216 if (IS_ERR(skb)) {217 int err = PTR_ERR(skb);218 bt_dev_err(hdev, "BCM: failed to write update baudrate (%d)",219 err);220 return err;221 }222 223 kfree_skb(skb);224 225 return 0;226}227 228/* bcm_device_exists should be protected by bcm_device_lock */229static bool bcm_device_exists(struct bcm_device *device)230{231 struct list_head *p;232 233#ifdef CONFIG_PM234 /* Devices using serdev always exist */235 if (device && device->hu && device->hu->serdev)236 return true;237#endif238 239 list_for_each(p, &bcm_device_list) {240 struct bcm_device *dev = list_entry(p, struct bcm_device, list);241 242 if (device == dev)243 return true;244 }245 246 return false;247}248 249static int bcm_gpio_set_power(struct bcm_device *dev, bool powered)250{251 int err;252 253 if (powered && !dev->res_enabled) {254 /* Intel Macs use bcm_apple_get_resources() and don't255 * have regulator supplies configured.256 */257 if (dev->supplies[0].supply) {258 err = regulator_bulk_enable(BCM_NUM_SUPPLIES,259 dev->supplies);260 if (err)261 return err;262 }263 264 /* LPO clock needs to be 32.768 kHz */265 err = clk_set_rate(dev->lpo_clk, 32768);266 if (err) {267 dev_err(dev->dev, "Could not set LPO clock rate\n");268 goto err_regulator_disable;269 }270 271 err = clk_prepare_enable(dev->lpo_clk);272 if (err)273 goto err_regulator_disable;274 275 err = clk_prepare_enable(dev->txco_clk);276 if (err)277 goto err_lpo_clk_disable;278 }279 280 err = dev->set_shutdown(dev, powered);281 if (err)282 goto err_txco_clk_disable;283 284 err = dev->set_device_wakeup(dev, powered);285 if (err)286 goto err_revert_shutdown;287 288 if (!powered && dev->res_enabled) {289 clk_disable_unprepare(dev->txco_clk);290 clk_disable_unprepare(dev->lpo_clk);291 292 /* Intel Macs use bcm_apple_get_resources() and don't293 * have regulator supplies configured.294 */295 if (dev->supplies[0].supply)296 regulator_bulk_disable(BCM_NUM_SUPPLIES,297 dev->supplies);298 }299 300 /* wait for device to power on and come out of reset */301 usleep_range(100000, 120000);302 303 dev->res_enabled = powered;304 305 return 0;306 307err_revert_shutdown:308 dev->set_shutdown(dev, !powered);309err_txco_clk_disable:310 if (powered && !dev->res_enabled)311 clk_disable_unprepare(dev->txco_clk);312err_lpo_clk_disable:313 if (powered && !dev->res_enabled)314 clk_disable_unprepare(dev->lpo_clk);315err_regulator_disable:316 if (powered && !dev->res_enabled)317 regulator_bulk_disable(BCM_NUM_SUPPLIES, dev->supplies);318 return err;319}320 321#ifdef CONFIG_PM322static irqreturn_t bcm_host_wake(int irq, void *data)323{324 struct bcm_device *bdev = data;325 326 bt_dev_dbg(bdev, "Host wake IRQ");327 328 pm_runtime_get(bdev->dev);329 pm_runtime_mark_last_busy(bdev->dev);330 pm_runtime_put_autosuspend(bdev->dev);331 332 return IRQ_HANDLED;333}334 335static int bcm_request_irq(struct bcm_data *bcm)336{337 struct bcm_device *bdev = bcm->dev;338 int err;339 340 mutex_lock(&bcm_device_lock);341 if (!bcm_device_exists(bdev)) {342 err = -ENODEV;343 goto unlock;344 }345 346 if (bdev->irq <= 0) {347 err = -EOPNOTSUPP;348 goto unlock;349 }350 351 err = devm_request_irq(bdev->dev, bdev->irq, bcm_host_wake,352 bdev->irq_active_low ? IRQF_TRIGGER_FALLING :353 IRQF_TRIGGER_RISING,354 "host_wake", bdev);355 if (err) {356 bdev->irq = err;357 goto unlock;358 }359 360 bdev->irq_acquired = true;361 362 device_init_wakeup(bdev->dev, true);363 364 pm_runtime_set_autosuspend_delay(bdev->dev,365 BCM_AUTOSUSPEND_DELAY);366 pm_runtime_use_autosuspend(bdev->dev);367 pm_runtime_set_active(bdev->dev);368 pm_runtime_enable(bdev->dev);369 370unlock:371 mutex_unlock(&bcm_device_lock);372 373 return err;374}375 376static const struct bcm_set_sleep_mode default_sleep_params = {377 .sleep_mode = 1, /* 0=Disabled, 1=UART, 2=Reserved, 3=USB */378 .idle_host = 2, /* idle threshold HOST, in 300ms */379 .idle_dev = 2, /* idle threshold device, in 300ms */380 .bt_wake_active = 1, /* BT_WAKE active mode: 1 = high, 0 = low */381 .host_wake_active = 0, /* HOST_WAKE active mode: 1 = high, 0 = low */382 .allow_host_sleep = 1, /* Allow host sleep in SCO flag */383 .combine_modes = 1, /* Combine sleep and LPM flag */384 .tristate_control = 0, /* Allow tri-state control of UART tx flag */385 /* Irrelevant USB flags */386 .usb_auto_sleep = 0,387 .usb_resume_timeout = 0,388 .break_to_host = 0,389 .pulsed_host_wake = 1,390};391 392static int bcm_setup_sleep(struct hci_uart *hu)393{394 struct bcm_data *bcm = hu->priv;395 struct sk_buff *skb;396 struct bcm_set_sleep_mode sleep_params = default_sleep_params;397 398 sleep_params.host_wake_active = !bcm->dev->irq_active_low;399 400 skb = __hci_cmd_sync(hu->hdev, 0xfc27, sizeof(sleep_params),401 &sleep_params, HCI_INIT_TIMEOUT);402 if (IS_ERR(skb)) {403 int err = PTR_ERR(skb);404 bt_dev_err(hu->hdev, "Sleep VSC failed (%d)", err);405 return err;406 }407 kfree_skb(skb);408 409 bt_dev_dbg(hu->hdev, "Set Sleep Parameters VSC succeeded");410 411 return 0;412}413#else414static inline int bcm_request_irq(struct bcm_data *bcm) { return 0; }415static inline int bcm_setup_sleep(struct hci_uart *hu) { return 0; }416#endif417 418static int bcm_set_diag(struct hci_dev *hdev, bool enable)419{420 struct hci_uart *hu = hci_get_drvdata(hdev);421 struct bcm_data *bcm = hu->priv;422 struct sk_buff *skb;423 424 if (!test_bit(HCI_RUNNING, &hdev->flags))425 return -ENETDOWN;426 427 skb = bt_skb_alloc(3, GFP_KERNEL);428 if (!skb)429 return -ENOMEM;430 431 skb_put_u8(skb, BCM_LM_DIAG_PKT);432 skb_put_u8(skb, 0xf0);433 skb_put_u8(skb, enable);434 435 skb_queue_tail(&bcm->txq, skb);436 hci_uart_tx_wakeup(hu);437 438 return 0;439}440 441static int bcm_open(struct hci_uart *hu)442{443 struct bcm_data *bcm;444 struct list_head *p;445 int err;446 447 bt_dev_dbg(hu->hdev, "hu %p", hu);448 449 if (!hci_uart_has_flow_control(hu))450 return -EOPNOTSUPP;451 452 bcm = kzalloc(sizeof(*bcm), GFP_KERNEL);453 if (!bcm)454 return -ENOMEM;455 456 skb_queue_head_init(&bcm->txq);457 458 hu->priv = bcm;459 460 mutex_lock(&bcm_device_lock);461 462 if (hu->serdev) {463 bcm->dev = serdev_device_get_drvdata(hu->serdev);464 goto out;465 }466 467 if (!hu->tty->dev)468 goto out;469 470 list_for_each(p, &bcm_device_list) {471 struct bcm_device *dev = list_entry(p, struct bcm_device, list);472 473 /* Retrieve saved bcm_device based on parent of the474 * platform device (saved during device probe) and475 * parent of tty device used by hci_uart476 */477 if (hu->tty->dev->parent == dev->dev->parent) {478 bcm->dev = dev;479#ifdef CONFIG_PM480 dev->hu = hu;481#endif482 break;483 }484 }485 486out:487 if (bcm->dev) {488 if (bcm->dev->use_autobaud_mode)489 hci_uart_set_flow_control(hu, false); /* Assert BT_UART_CTS_N */490 else if (bcm->dev->drive_rts_on_open)491 hci_uart_set_flow_control(hu, true);492 493 if (bcm->dev->use_autobaud_mode && bcm->dev->max_autobaud_speed)494 hu->init_speed = min(bcm->dev->oper_speed, bcm->dev->max_autobaud_speed);495 else496 hu->init_speed = bcm->dev->init_speed;497 498 /* If oper_speed is set, ldisc/serdev will set the baudrate499 * before calling setup()500 */501 if (!bcm->dev->no_early_set_baudrate && !bcm->dev->use_autobaud_mode)502 hu->oper_speed = bcm->dev->oper_speed;503 504 err = bcm_gpio_set_power(bcm->dev, true);505 506 if (bcm->dev->drive_rts_on_open)507 hci_uart_set_flow_control(hu, false);508 509 if (err)510 goto err_unset_hu;511 }512 513 mutex_unlock(&bcm_device_lock);514 return 0;515 516err_unset_hu:517#ifdef CONFIG_PM518 if (!hu->serdev)519 bcm->dev->hu = NULL;520#endif521 mutex_unlock(&bcm_device_lock);522 hu->priv = NULL;523 kfree(bcm);524 return err;525}526 527static int bcm_close(struct hci_uart *hu)528{529 struct bcm_data *bcm = hu->priv;530 struct bcm_device *bdev = NULL;531 int err;532 533 bt_dev_dbg(hu->hdev, "hu %p", hu);534 535 /* Protect bcm->dev against removal of the device or driver */536 mutex_lock(&bcm_device_lock);537 538 if (hu->serdev) {539 bdev = serdev_device_get_drvdata(hu->serdev);540 } else if (bcm_device_exists(bcm->dev)) {541 bdev = bcm->dev;542#ifdef CONFIG_PM543 bdev->hu = NULL;544#endif545 }546 547 if (bdev) {548 if (IS_ENABLED(CONFIG_PM) && bdev->irq_acquired) {549 devm_free_irq(bdev->dev, bdev->irq, bdev);550 device_init_wakeup(bdev->dev, false);551 pm_runtime_disable(bdev->dev);552 }553 554 err = bcm_gpio_set_power(bdev, false);555 if (err)556 bt_dev_err(hu->hdev, "Failed to power down");557 else558 pm_runtime_set_suspended(bdev->dev);559 }560 mutex_unlock(&bcm_device_lock);561 562 skb_queue_purge(&bcm->txq);563 kfree_skb(bcm->rx_skb);564 kfree(bcm);565 566 hu->priv = NULL;567 return 0;568}569 570static int bcm_flush(struct hci_uart *hu)571{572 struct bcm_data *bcm = hu->priv;573 574 bt_dev_dbg(hu->hdev, "hu %p", hu);575 576 skb_queue_purge(&bcm->txq);577 578 return 0;579}580 581static int bcm_setup(struct hci_uart *hu)582{583 struct bcm_data *bcm = hu->priv;584 bool fw_load_done = false;585 bool use_autobaud_mode = (bcm->dev ? bcm->dev->use_autobaud_mode : 0);586 unsigned int speed;587 int err;588 589 bt_dev_dbg(hu->hdev, "hu %p", hu);590 591 hu->hdev->set_diag = bcm_set_diag;592 hu->hdev->set_bdaddr = btbcm_set_bdaddr;593 594 err = btbcm_initialize(hu->hdev, &fw_load_done, use_autobaud_mode);595 if (err)596 return err;597 598 if (!fw_load_done)599 return 0;600 601 /* Init speed if any */602 if (bcm->dev && bcm->dev->init_speed)603 speed = bcm->dev->init_speed;604 else if (hu->proto->init_speed)605 speed = hu->proto->init_speed;606 else607 speed = 0;608 609 if (speed)610 host_set_baudrate(hu, speed);611 612 /* Operational speed if any */613 if (hu->oper_speed)614 speed = hu->oper_speed;615 else if (bcm->dev && bcm->dev->oper_speed)616 speed = bcm->dev->oper_speed;617 else if (hu->proto->oper_speed)618 speed = hu->proto->oper_speed;619 else620 speed = 0;621 622 if (speed) {623 err = bcm_set_baudrate(hu, speed);624 if (!err)625 host_set_baudrate(hu, speed);626 }627 628 /* PCM parameters if provided */629 if (bcm->dev && bcm->dev->pcm_int_params[0] != 0xff) {630 struct bcm_set_pcm_int_params params;631 632 btbcm_read_pcm_int_params(hu->hdev, ¶ms);633 634 memcpy(¶ms, bcm->dev->pcm_int_params, 5);635 btbcm_write_pcm_int_params(hu->hdev, ¶ms);636 }637 638 err = btbcm_finalize(hu->hdev, &fw_load_done, use_autobaud_mode);639 if (err)640 return err;641 642 /* Some devices ship with the controller default address.643 * Allow the bootloader to set a valid address through the644 * device tree.645 */646 if (test_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks))647 set_bit(HCI_QUIRK_USE_BDADDR_PROPERTY, &hu->hdev->quirks);648 649 if (!bcm_request_irq(bcm))650 err = bcm_setup_sleep(hu);651 652 return err;653}654 655#define BCM_RECV_LM_DIAG \656 .type = BCM_LM_DIAG_PKT, \657 .hlen = BCM_LM_DIAG_SIZE, \658 .loff = 0, \659 .lsize = 0, \660 .maxlen = BCM_LM_DIAG_SIZE661 662#define BCM_RECV_NULL \663 .type = BCM_NULL_PKT, \664 .hlen = BCM_NULL_SIZE, \665 .loff = 0, \666 .lsize = 0, \667 .maxlen = BCM_NULL_SIZE668 669#define BCM_RECV_TYPE49 \670 .type = BCM_TYPE49_PKT, \671 .hlen = BCM_TYPE49_SIZE, \672 .loff = 0, \673 .lsize = 0, \674 .maxlen = BCM_TYPE49_SIZE675 676#define BCM_RECV_TYPE52 \677 .type = BCM_TYPE52_PKT, \678 .hlen = BCM_TYPE52_SIZE, \679 .loff = 0, \680 .lsize = 0, \681 .maxlen = BCM_TYPE52_SIZE682 683static const struct h4_recv_pkt bcm_recv_pkts[] = {684 { H4_RECV_ACL, .recv = hci_recv_frame },685 { H4_RECV_SCO, .recv = hci_recv_frame },686 { H4_RECV_EVENT, .recv = hci_recv_frame },687 { H4_RECV_ISO, .recv = hci_recv_frame },688 { BCM_RECV_LM_DIAG, .recv = hci_recv_diag },689 { BCM_RECV_NULL, .recv = hci_recv_diag },690 { BCM_RECV_TYPE49, .recv = hci_recv_diag },691 { BCM_RECV_TYPE52, .recv = hci_recv_diag },692};693 694static int bcm_recv(struct hci_uart *hu, const void *data, int count)695{696 struct bcm_data *bcm = hu->priv;697 698 if (!test_bit(HCI_UART_REGISTERED, &hu->flags))699 return -EUNATCH;700 701 bcm->rx_skb = h4_recv_buf(hu->hdev, bcm->rx_skb, data, count,702 bcm_recv_pkts, ARRAY_SIZE(bcm_recv_pkts));703 if (IS_ERR(bcm->rx_skb)) {704 int err = PTR_ERR(bcm->rx_skb);705 bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err);706 bcm->rx_skb = NULL;707 return err;708 } else if (!bcm->rx_skb) {709 /* Delay auto-suspend when receiving completed packet */710 mutex_lock(&bcm_device_lock);711 if (bcm->dev && bcm_device_exists(bcm->dev)) {712 pm_runtime_get(bcm->dev->dev);713 pm_runtime_mark_last_busy(bcm->dev->dev);714 pm_runtime_put_autosuspend(bcm->dev->dev);715 }716 mutex_unlock(&bcm_device_lock);717 }718 719 return count;720}721 722static int bcm_enqueue(struct hci_uart *hu, struct sk_buff *skb)723{724 struct bcm_data *bcm = hu->priv;725 726 bt_dev_dbg(hu->hdev, "hu %p skb %p", hu, skb);727 728 /* Prepend skb with frame type */729 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);730 skb_queue_tail(&bcm->txq, skb);731 732 return 0;733}734 735static struct sk_buff *bcm_dequeue(struct hci_uart *hu)736{737 struct bcm_data *bcm = hu->priv;738 struct sk_buff *skb = NULL;739 struct bcm_device *bdev = NULL;740 741 mutex_lock(&bcm_device_lock);742 743 if (bcm_device_exists(bcm->dev)) {744 bdev = bcm->dev;745 pm_runtime_get_sync(bdev->dev);746 /* Shall be resumed here */747 }748 749 skb = skb_dequeue(&bcm->txq);750 751 if (bdev) {752 pm_runtime_mark_last_busy(bdev->dev);753 pm_runtime_put_autosuspend(bdev->dev);754 }755 756 mutex_unlock(&bcm_device_lock);757 758 return skb;759}760 761#ifdef CONFIG_PM762static int bcm_suspend_device(struct device *dev)763{764 struct bcm_device *bdev = dev_get_drvdata(dev);765 int err;766 767 bt_dev_dbg(bdev, "");768 769 if (!bdev->is_suspended && bdev->hu) {770 hci_uart_set_flow_control(bdev->hu, true);771 772 /* Once this returns, driver suspends BT via GPIO */773 bdev->is_suspended = true;774 }775 776 /* Suspend the device */777 err = bdev->set_device_wakeup(bdev, false);778 if (err) {779 if (bdev->is_suspended && bdev->hu) {780 bdev->is_suspended = false;781 hci_uart_set_flow_control(bdev->hu, false);782 }783 return -EBUSY;784 }785 786 bt_dev_dbg(bdev, "suspend, delaying 15 ms");787 msleep(15);788 789 return 0;790}791 792static int bcm_resume_device(struct device *dev)793{794 struct bcm_device *bdev = dev_get_drvdata(dev);795 int err;796 797 bt_dev_dbg(bdev, "");798 799 err = bdev->set_device_wakeup(bdev, true);800 if (err) {801 dev_err(dev, "Failed to power up\n");802 return err;803 }804 805 bt_dev_dbg(bdev, "resume, delaying 15 ms");806 msleep(15);807 808 /* When this executes, the device has woken up already */809 if (bdev->is_suspended && bdev->hu) {810 bdev->is_suspended = false;811 812 hci_uart_set_flow_control(bdev->hu, false);813 }814 815 return 0;816}817#endif818 819#ifdef CONFIG_PM_SLEEP820/* suspend callback */821static int bcm_suspend(struct device *dev)822{823 struct bcm_device *bdev = dev_get_drvdata(dev);824 int error;825 826 bt_dev_dbg(bdev, "suspend: is_suspended %d", bdev->is_suspended);827 828 /*829 * When used with a device instantiated as platform_device, bcm_suspend830 * can be called at any time as long as the platform device is bound,831 * so it should use bcm_device_lock to protect access to hci_uart832 * and device_wake-up GPIO.833 */834 mutex_lock(&bcm_device_lock);835 836 if (!bdev->hu)837 goto unlock;838 839 if (pm_runtime_active(dev))840 bcm_suspend_device(dev);841 842 if (device_may_wakeup(dev) && bdev->irq > 0) {843 error = enable_irq_wake(bdev->irq);844 if (!error)845 bt_dev_dbg(bdev, "BCM irq: enabled");846 }847 848unlock:849 mutex_unlock(&bcm_device_lock);850 851 return 0;852}853 854/* resume callback */855static int bcm_resume(struct device *dev)856{857 struct bcm_device *bdev = dev_get_drvdata(dev);858 int err = 0;859 860 bt_dev_dbg(bdev, "resume: is_suspended %d", bdev->is_suspended);861 862 /*863 * When used with a device instantiated as platform_device, bcm_resume864 * can be called at any time as long as platform device is bound,865 * so it should use bcm_device_lock to protect access to hci_uart866 * and device_wake-up GPIO.867 */868 mutex_lock(&bcm_device_lock);869 870 if (!bdev->hu)871 goto unlock;872 873 if (device_may_wakeup(dev) && bdev->irq > 0) {874 disable_irq_wake(bdev->irq);875 bt_dev_dbg(bdev, "BCM irq: disabled");876 }877 878 err = bcm_resume_device(dev);879 880unlock:881 mutex_unlock(&bcm_device_lock);882 883 if (!err) {884 pm_runtime_disable(dev);885 pm_runtime_set_active(dev);886 pm_runtime_enable(dev);887 }888 889 return 0;890}891#endif892 893/* Some firmware reports an IRQ which does not work (wrong pin in fw table?) */894static struct gpiod_lookup_table irq_on_int33fc02_pin17_gpios = {895 .dev_id = "serial0-0",896 .table = {897 GPIO_LOOKUP("INT33FC:02", 17, "host-wakeup-alt", GPIO_ACTIVE_HIGH),898 { }899 },900};901 902static const struct dmi_system_id bcm_broken_irq_dmi_table[] = {903 {904 .ident = "Acer Iconia One 7 B1-750",905 .matches = {906 DMI_MATCH(DMI_SYS_VENDOR, "Insyde"),907 DMI_MATCH(DMI_PRODUCT_NAME, "VESPA2"),908 },909 .driver_data = &irq_on_int33fc02_pin17_gpios,910 },911 {912 .ident = "Asus TF103C",913 .matches = {914 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),915 DMI_MATCH(DMI_PRODUCT_NAME, "TF103C"),916 },917 .driver_data = &irq_on_int33fc02_pin17_gpios,918 },919 {920 .ident = "Lenovo Yoga Tablet 2 830F/L / 1050F/L",921 .matches = {922 DMI_MATCH(DMI_SYS_VENDOR, "Intel Corp."),923 DMI_MATCH(DMI_PRODUCT_NAME, "VALLEYVIEW C0 PLATFORM"),924 DMI_MATCH(DMI_BOARD_NAME, "BYT-T FFD8"),925 /* Partial match on beginning of BIOS version */926 DMI_MATCH(DMI_BIOS_VERSION, "BLADE_21"),927 },928 .driver_data = &irq_on_int33fc02_pin17_gpios,929 },930 {931 .ident = "Meegopad T08",932 .matches = {933 DMI_EXACT_MATCH(DMI_BOARD_VENDOR,934 "To be filled by OEM."),935 DMI_EXACT_MATCH(DMI_BOARD_NAME, "T3 MRD"),936 DMI_EXACT_MATCH(DMI_BOARD_VERSION, "V1.1"),937 },938 },939 { }940};941 942#ifdef CONFIG_ACPI943static const struct acpi_gpio_params first_gpio = { 0, 0, false };944static const struct acpi_gpio_params second_gpio = { 1, 0, false };945static const struct acpi_gpio_params third_gpio = { 2, 0, false };946 947static const struct acpi_gpio_mapping acpi_bcm_int_last_gpios[] = {948 { "device-wakeup-gpios", &first_gpio, 1 },949 { "shutdown-gpios", &second_gpio, 1 },950 { "host-wakeup-gpios", &third_gpio, 1 },951 { },952};953 954static const struct acpi_gpio_mapping acpi_bcm_int_first_gpios[] = {955 { "host-wakeup-gpios", &first_gpio, 1 },956 { "device-wakeup-gpios", &second_gpio, 1 },957 { "shutdown-gpios", &third_gpio, 1 },958 { },959};960 961static int bcm_resource(struct acpi_resource *ares, void *data)962{963 struct bcm_device *dev = data;964 struct acpi_resource_extended_irq *irq;965 struct acpi_resource_gpio *gpio;966 struct acpi_resource_uart_serialbus *sb;967 968 switch (ares->type) {969 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:970 irq = &ares->data.extended_irq;971 if (irq->polarity != ACPI_ACTIVE_LOW)972 dev_info(dev->dev, "ACPI Interrupt resource is active-high, this is usually wrong, treating the IRQ as active-low\n");973 dev->irq_active_low = true;974 break;975 976 case ACPI_RESOURCE_TYPE_GPIO:977 gpio = &ares->data.gpio;978 if (gpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT) {979 dev->gpio_int_idx = dev->gpio_count;980 dev->irq_active_low = gpio->polarity == ACPI_ACTIVE_LOW;981 }982 dev->gpio_count++;983 break;984 985 case ACPI_RESOURCE_TYPE_SERIAL_BUS:986 sb = &ares->data.uart_serial_bus;987 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_UART) {988 dev->init_speed = sb->default_baud_rate;989 dev->oper_speed = 4000000;990 }991 break;992 993 default:994 break;995 }996 997 return 0;998}999 1000static int bcm_apple_set_device_wakeup(struct bcm_device *dev, bool awake)1001{1002 if (ACPI_FAILURE(acpi_execute_simple_method(dev->btlp, NULL, !awake)))1003 return -EIO;1004 1005 return 0;1006}1007 1008static int bcm_apple_set_shutdown(struct bcm_device *dev, bool powered)1009{1010 if (ACPI_FAILURE(acpi_evaluate_object(powered ? dev->btpu : dev->btpd,1011 NULL, NULL, NULL)))1012 return -EIO;1013 1014 return 0;1015}1016 1017static int bcm_apple_get_resources(struct bcm_device *dev)1018{1019 struct acpi_device *adev = ACPI_COMPANION(dev->dev);1020 const union acpi_object *obj;1021 1022 if (!adev ||1023 ACPI_FAILURE(acpi_get_handle(adev->handle, "BTLP", &dev->btlp)) ||1024 ACPI_FAILURE(acpi_get_handle(adev->handle, "BTPU", &dev->btpu)) ||1025 ACPI_FAILURE(acpi_get_handle(adev->handle, "BTPD", &dev->btpd)))1026 return -ENODEV;1027 1028 if (!acpi_dev_get_property(adev, "baud", ACPI_TYPE_BUFFER, &obj) &&1029 obj->buffer.length == 8)1030 dev->init_speed = *(u64 *)obj->buffer.pointer;1031 1032 dev->set_device_wakeup = bcm_apple_set_device_wakeup;1033 dev->set_shutdown = bcm_apple_set_shutdown;1034 1035 return 0;1036}1037#else1038static inline int bcm_apple_get_resources(struct bcm_device *dev)1039{1040 return -EOPNOTSUPP;1041}1042#endif /* CONFIG_ACPI */1043 1044static int bcm_gpio_set_device_wakeup(struct bcm_device *dev, bool awake)1045{1046 gpiod_set_value_cansleep(dev->device_wakeup, awake);1047 return 0;1048}1049 1050static int bcm_gpio_set_shutdown(struct bcm_device *dev, bool powered)1051{1052 gpiod_set_value_cansleep(dev->shutdown, powered);1053 if (dev->reset)1054 /*1055 * The reset line is asserted on powerdown and deasserted1056 * on poweron so the inverse of powered is used. Notice1057 * that the GPIO line BT_RST_N needs to be specified as1058 * active low in the device tree or similar system1059 * description.1060 */1061 gpiod_set_value_cansleep(dev->reset, !powered);1062 return 0;1063}1064 1065/* Try a bunch of names for TXCO */1066static struct clk *bcm_get_txco(struct device *dev)1067{1068 struct clk *clk;1069 1070 /* New explicit name */1071 clk = devm_clk_get(dev, "txco");1072 if (!IS_ERR(clk) || PTR_ERR(clk) == -EPROBE_DEFER)1073 return clk;1074 1075 /* Deprecated name */1076 clk = devm_clk_get(dev, "extclk");1077 if (!IS_ERR(clk) || PTR_ERR(clk) == -EPROBE_DEFER)1078 return clk;1079 1080 /* Original code used no name at all */1081 return devm_clk_get(dev, NULL);1082}1083 1084static int bcm_get_resources(struct bcm_device *dev)1085{1086 const struct dmi_system_id *broken_irq_dmi_id;1087 const char *irq_con_id = "host-wakeup";1088 int err;1089 1090 dev->name = dev_name(dev->dev);1091 1092 if (x86_apple_machine && !bcm_apple_get_resources(dev))1093 return 0;1094 1095 dev->txco_clk = bcm_get_txco(dev->dev);1096 1097 /* Handle deferred probing */1098 if (dev->txco_clk == ERR_PTR(-EPROBE_DEFER))1099 return PTR_ERR(dev->txco_clk);1100 1101 /* Ignore all other errors as before */1102 if (IS_ERR(dev->txco_clk))1103 dev->txco_clk = NULL;1104 1105 dev->lpo_clk = devm_clk_get(dev->dev, "lpo");1106 if (dev->lpo_clk == ERR_PTR(-EPROBE_DEFER))1107 return PTR_ERR(dev->lpo_clk);1108 1109 if (IS_ERR(dev->lpo_clk))1110 dev->lpo_clk = NULL;1111 1112 /* Check if we accidentally fetched the lpo clock twice */1113 if (dev->lpo_clk && clk_is_match(dev->lpo_clk, dev->txco_clk)) {1114 devm_clk_put(dev->dev, dev->txco_clk);1115 dev->txco_clk = NULL;1116 }1117 1118 dev->device_wakeup = devm_gpiod_get_optional(dev->dev, "device-wakeup",1119 GPIOD_OUT_LOW);1120 if (IS_ERR(dev->device_wakeup))1121 return PTR_ERR(dev->device_wakeup);1122 1123 dev->shutdown = devm_gpiod_get_optional(dev->dev, "shutdown",1124 GPIOD_OUT_LOW);1125 if (IS_ERR(dev->shutdown))1126 return PTR_ERR(dev->shutdown);1127 1128 dev->reset = devm_gpiod_get_optional(dev->dev, "reset",1129 GPIOD_OUT_LOW);1130 if (IS_ERR(dev->reset))1131 return PTR_ERR(dev->reset);1132 1133 dev->set_device_wakeup = bcm_gpio_set_device_wakeup;1134 dev->set_shutdown = bcm_gpio_set_shutdown;1135 1136 dev->supplies[0].supply = "vbat";1137 dev->supplies[1].supply = "vddio";1138 err = devm_regulator_bulk_get(dev->dev, BCM_NUM_SUPPLIES,1139 dev->supplies);1140 if (err)1141 return err;1142 1143 broken_irq_dmi_id = dmi_first_match(bcm_broken_irq_dmi_table);1144 if (broken_irq_dmi_id && broken_irq_dmi_id->driver_data) {1145 gpiod_add_lookup_table(broken_irq_dmi_id->driver_data);1146 irq_con_id = "host-wakeup-alt";1147 dev->irq_active_low = false;1148 dev->irq = 0;1149 }1150 1151 /* IRQ can be declared in ACPI table as Interrupt or GpioInt */1152 if (dev->irq <= 0) {1153 struct gpio_desc *gpio;1154 1155 gpio = devm_gpiod_get_optional(dev->dev, irq_con_id, GPIOD_IN);1156 if (IS_ERR(gpio))1157 return PTR_ERR(gpio);1158 1159 dev->irq = gpiod_to_irq(gpio);1160 }1161 1162 if (broken_irq_dmi_id) {1163 if (broken_irq_dmi_id->driver_data) {1164 gpiod_remove_lookup_table(broken_irq_dmi_id->driver_data);1165 } else {1166 dev_info(dev->dev, "%s: Has a broken IRQ config, disabling IRQ support / runtime-pm\n",1167 broken_irq_dmi_id->ident);1168 dev->irq = 0;1169 }1170 }1171 1172 dev_dbg(dev->dev, "BCM irq: %d\n", dev->irq);1173 return 0;1174}1175 1176#ifdef CONFIG_ACPI1177static int bcm_acpi_probe(struct bcm_device *dev)1178{1179 LIST_HEAD(resources);1180 const struct acpi_gpio_mapping *gpio_mapping = acpi_bcm_int_last_gpios;1181 struct resource_entry *entry;1182 int ret;1183 1184 /* Retrieve UART ACPI info */1185 dev->gpio_int_idx = -1;1186 ret = acpi_dev_get_resources(ACPI_COMPANION(dev->dev),1187 &resources, bcm_resource, dev);1188 if (ret < 0)1189 return ret;1190 1191 resource_list_for_each_entry(entry, &resources) {1192 if (resource_type(entry->res) == IORESOURCE_IRQ) {1193 dev->irq = entry->res->start;1194 break;1195 }1196 }1197 acpi_dev_free_resource_list(&resources);1198 1199 /* If the DSDT uses an Interrupt resource for the IRQ, then there are1200 * only 2 GPIO resources, we use the irq-last mapping for this, since1201 * we already have an irq the 3th / last mapping will not be used.1202 */1203 if (dev->irq)1204 gpio_mapping = acpi_bcm_int_last_gpios;1205 else if (dev->gpio_int_idx == 0)1206 gpio_mapping = acpi_bcm_int_first_gpios;1207 else if (dev->gpio_int_idx == 2)1208 gpio_mapping = acpi_bcm_int_last_gpios;1209 else1210 dev_warn(dev->dev, "Unexpected ACPI gpio_int_idx: %d\n",1211 dev->gpio_int_idx);1212 1213 /* Warn if our expectations are not met. */1214 if (dev->gpio_count != (dev->irq ? 2 : 3))1215 dev_warn(dev->dev, "Unexpected number of ACPI GPIOs: %d\n",1216 dev->gpio_count);1217 1218 ret = devm_acpi_dev_add_driver_gpios(dev->dev, gpio_mapping);1219 if (ret)1220 return ret;1221 1222 if (irq_polarity != -1) {1223 dev->irq_active_low = irq_polarity;1224 dev_warn(dev->dev, "Overwriting IRQ polarity to active %s by module-param\n",1225 dev->irq_active_low ? "low" : "high");1226 }1227 1228 return 0;1229}1230#else1231static int bcm_acpi_probe(struct bcm_device *dev)1232{1233 return -EINVAL;1234}1235#endif /* CONFIG_ACPI */1236 1237static int bcm_of_probe(struct bcm_device *bdev)1238{1239 bdev->use_autobaud_mode = device_property_read_bool(bdev->dev,1240 "brcm,requires-autobaud-mode");1241 device_property_read_u32(bdev->dev, "max-speed", &bdev->oper_speed);1242 device_property_read_u8_array(bdev->dev, "brcm,bt-pcm-int-params",1243 bdev->pcm_int_params, 5);1244 bdev->irq = of_irq_get_byname(bdev->dev->of_node, "host-wakeup");1245 bdev->irq_active_low = irq_get_trigger_type(bdev->irq)1246 & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_LEVEL_LOW);1247 return 0;1248}1249 1250static int bcm_probe(struct platform_device *pdev)1251{1252 struct bcm_device *dev;1253 int ret;1254 1255 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);1256 if (!dev)1257 return -ENOMEM;1258 1259 dev->dev = &pdev->dev;1260 1261 ret = platform_get_irq(pdev, 0);1262 if (ret < 0)1263 return ret;1264 1265 dev->irq = ret;1266 1267 /* Initialize routing field to an unused value */1268 dev->pcm_int_params[0] = 0xff;1269 1270 if (has_acpi_companion(&pdev->dev)) {1271 ret = bcm_acpi_probe(dev);1272 if (ret)1273 return ret;1274 }1275 1276 ret = bcm_get_resources(dev);1277 if (ret)1278 return ret;1279 1280 platform_set_drvdata(pdev, dev);1281 1282 dev_info(&pdev->dev, "%s device registered.\n", dev->name);1283 1284 /* Place this instance on the device list */1285 mutex_lock(&bcm_device_lock);1286 list_add_tail(&dev->list, &bcm_device_list);1287 mutex_unlock(&bcm_device_lock);1288 1289 ret = bcm_gpio_set_power(dev, false);1290 if (ret)1291 dev_err(&pdev->dev, "Failed to power down\n");1292 1293 return 0;1294}1295 1296static void bcm_remove(struct platform_device *pdev)1297{1298 struct bcm_device *dev = platform_get_drvdata(pdev);1299 1300 mutex_lock(&bcm_device_lock);1301 list_del(&dev->list);1302 mutex_unlock(&bcm_device_lock);1303 1304 dev_info(&pdev->dev, "%s device unregistered.\n", dev->name);1305}1306 1307static const struct hci_uart_proto bcm_proto = {1308 .id = HCI_UART_BCM,1309 .name = "Broadcom",1310 .manufacturer = 15,1311 .init_speed = 115200,1312 .open = bcm_open,1313 .close = bcm_close,1314 .flush = bcm_flush,1315 .setup = bcm_setup,1316 .set_baudrate = bcm_set_baudrate,1317 .recv = bcm_recv,1318 .enqueue = bcm_enqueue,1319 .dequeue = bcm_dequeue,1320};1321 1322#ifdef CONFIG_ACPI1323 1324/* bcm43430a0/a1 BT does not support 48MHz UART clock, limit to 2000000 baud */1325static struct bcm_device_data bcm43430_device_data = {1326 .max_speed = 2000000,1327};1328 1329static const struct acpi_device_id bcm_acpi_match[] = {1330 { "BCM2E00" },1331 { "BCM2E01" },1332 { "BCM2E02" },1333 { "BCM2E03" },1334 { "BCM2E04" },1335 { "BCM2E05" },1336 { "BCM2E06" },1337 { "BCM2E07" },1338 { "BCM2E08" },1339 { "BCM2E09" },1340 { "BCM2E0A" },1341 { "BCM2E0B" },1342 { "BCM2E0C" },1343 { "BCM2E0D" },1344 { "BCM2E0E" },1345 { "BCM2E0F" },1346 { "BCM2E10" },1347 { "BCM2E11" },1348 { "BCM2E12" },1349 { "BCM2E13" },1350 { "BCM2E14" },1351 { "BCM2E15" },1352 { "BCM2E16" },1353 { "BCM2E17" },1354 { "BCM2E18" },1355 { "BCM2E19" },1356 { "BCM2E1A" },1357 { "BCM2E1B" },1358 { "BCM2E1C" },1359 { "BCM2E1D" },1360 { "BCM2E1F" },1361 { "BCM2E20" },1362 { "BCM2E21" },1363 { "BCM2E22" },1364 { "BCM2E23" },1365 { "BCM2E24" },1366 { "BCM2E25" },1367 { "BCM2E26" },1368 { "BCM2E27" },1369 { "BCM2E28" },1370 { "BCM2E29" },1371 { "BCM2E2A" },1372 { "BCM2E2B" },1373 { "BCM2E2C" },1374 { "BCM2E2D" },1375 { "BCM2E2E" },1376 { "BCM2E2F" },1377 { "BCM2E30" },1378 { "BCM2E31" },1379 { "BCM2E32" },1380 { "BCM2E33" },1381 { "BCM2E34" },1382 { "BCM2E35" },1383 { "BCM2E36" },1384 { "BCM2E37" },1385 { "BCM2E38" },1386 { "BCM2E39" },1387 { "BCM2E3A" },1388 { "BCM2E3B" },1389 { "BCM2E3C" },1390 { "BCM2E3D" },1391 { "BCM2E3E" },1392 { "BCM2E3F" },1393 { "BCM2E40" },1394 { "BCM2E41" },1395 { "BCM2E42" },1396 { "BCM2E43" },1397 { "BCM2E44" },1398 { "BCM2E45" },1399 { "BCM2E46" },1400 { "BCM2E47" },1401 { "BCM2E48" },1402 { "BCM2E49" },1403 { "BCM2E4A" },1404 { "BCM2E4B" },1405 { "BCM2E4C" },1406 { "BCM2E4D" },1407 { "BCM2E4E" },1408 { "BCM2E4F" },1409 { "BCM2E50" },1410 { "BCM2E51" },1411 { "BCM2E52" },1412 { "BCM2E53" },1413 { "BCM2E54" },1414 { "BCM2E55" },1415 { "BCM2E56" },1416 { "BCM2E57" },1417 { "BCM2E58" },1418 { "BCM2E59" },1419 { "BCM2E5A" },1420 { "BCM2E5B" },1421 { "BCM2E5C" },1422 { "BCM2E5D" },1423 { "BCM2E5E" },1424 { "BCM2E5F" },1425 { "BCM2E60" },1426 { "BCM2E61" },1427 { "BCM2E62" },1428 { "BCM2E63" },1429 { "BCM2E64" },1430 { "BCM2E65" },1431 { "BCM2E66" },1432 { "BCM2E67" },1433 { "BCM2E68" },1434 { "BCM2E69" },1435 { "BCM2E6B" },1436 { "BCM2E6D" },1437 { "BCM2E6E" },1438 { "BCM2E6F" },1439 { "BCM2E70" },1440 { "BCM2E71" },1441 { "BCM2E72" },1442 { "BCM2E73" },1443 { "BCM2E74", (long)&bcm43430_device_data },1444 { "BCM2E75", (long)&bcm43430_device_data },1445 { "BCM2E76" },1446 { "BCM2E77" },1447 { "BCM2E78" },1448 { "BCM2E79" },1449 { "BCM2E7A" },1450 { "BCM2E7B", (long)&bcm43430_device_data },1451 { "BCM2E7C" },1452 { "BCM2E7D" },1453 { "BCM2E7E" },1454 { "BCM2E7F" },1455 { "BCM2E80", (long)&bcm43430_device_data },1456 { "BCM2E81" },1457 { "BCM2E82" },1458 { "BCM2E83" },1459 { "BCM2E84" },1460 { "BCM2E85" },1461 { "BCM2E86" },1462 { "BCM2E87" },1463 { "BCM2E88" },1464 { "BCM2E89", (long)&bcm43430_device_data },1465 { "BCM2E8A" },1466 { "BCM2E8B" },1467 { "BCM2E8C" },1468 { "BCM2E8D" },1469 { "BCM2E8E" },1470 { "BCM2E90" },1471 { "BCM2E92" },1472 { "BCM2E93" },1473 { "BCM2E94", (long)&bcm43430_device_data },1474 { "BCM2E95" },1475 { "BCM2E96" },1476 { "BCM2E97" },1477 { "BCM2E98" },1478 { "BCM2E99", (long)&bcm43430_device_data },1479 { "BCM2E9A" },1480 { "BCM2E9B", (long)&bcm43430_device_data },1481 { "BCM2E9C" },1482 { "BCM2E9D" },1483 { "BCM2E9F", (long)&bcm43430_device_data },1484 { "BCM2EA0" },1485 { "BCM2EA1" },1486 { "BCM2EA2", (long)&bcm43430_device_data },1487 { "BCM2EA3", (long)&bcm43430_device_data },1488 { "BCM2EA4", (long)&bcm43430_device_data }, /* bcm43455 */1489 { "BCM2EA5" },1490 { "BCM2EA6" },1491 { "BCM2EA7" },1492 { "BCM2EA8" },1493 { "BCM2EA9" },1494 { "BCM2EAA", (long)&bcm43430_device_data },1495 { "BCM2EAB", (long)&bcm43430_device_data },1496 { "BCM2EAC", (long)&bcm43430_device_data },1497 { },1498};1499MODULE_DEVICE_TABLE(acpi, bcm_acpi_match);1500#endif1501 1502/* suspend and resume callbacks */1503static const struct dev_pm_ops bcm_pm_ops = {1504 SET_SYSTEM_SLEEP_PM_OPS(bcm_suspend, bcm_resume)1505 SET_RUNTIME_PM_OPS(bcm_suspend_device, bcm_resume_device, NULL)1506};1507 1508static struct platform_driver bcm_driver = {1509 .probe = bcm_probe,1510 .remove_new = bcm_remove,1511 .driver = {1512 .name = "hci_bcm",1513 .acpi_match_table = ACPI_PTR(bcm_acpi_match),1514 .pm = &bcm_pm_ops,1515 },1516};1517 1518static int bcm_serdev_probe(struct serdev_device *serdev)1519{1520 struct bcm_device *bcmdev;1521 const struct bcm_device_data *data;1522 int err;1523 1524 bcmdev = devm_kzalloc(&serdev->dev, sizeof(*bcmdev), GFP_KERNEL);1525 if (!bcmdev)1526 return -ENOMEM;1527 1528 bcmdev->dev = &serdev->dev;1529#ifdef CONFIG_PM1530 bcmdev->hu = &bcmdev->serdev_hu;1531#endif1532 bcmdev->serdev_hu.serdev = serdev;1533 serdev_device_set_drvdata(serdev, bcmdev);1534 1535 /* Initialize routing field to an unused value */1536 bcmdev->pcm_int_params[0] = 0xff;1537 1538 if (has_acpi_companion(&serdev->dev))1539 err = bcm_acpi_probe(bcmdev);1540 else1541 err = bcm_of_probe(bcmdev);1542 if (err)1543 return err;1544 1545 err = bcm_get_resources(bcmdev);1546 if (err)1547 return err;1548 1549 if (!bcmdev->shutdown) {1550 dev_warn(&serdev->dev,1551 "No reset resource, using default baud rate\n");1552 bcmdev->oper_speed = bcmdev->init_speed;1553 }1554 1555 err = bcm_gpio_set_power(bcmdev, false);1556 if (err)1557 dev_err(&serdev->dev, "Failed to power down\n");1558 1559 data = device_get_match_data(bcmdev->dev);1560 if (data) {1561 bcmdev->max_autobaud_speed = data->max_autobaud_speed;1562 bcmdev->no_early_set_baudrate = data->no_early_set_baudrate;1563 bcmdev->drive_rts_on_open = data->drive_rts_on_open;1564 bcmdev->no_uart_clock_set = data->no_uart_clock_set;1565 if (data->max_speed && bcmdev->oper_speed > data->max_speed)1566 bcmdev->oper_speed = data->max_speed;1567 }1568 1569 return hci_uart_register_device(&bcmdev->serdev_hu, &bcm_proto);1570}1571 1572static void bcm_serdev_remove(struct serdev_device *serdev)1573{1574 struct bcm_device *bcmdev = serdev_device_get_drvdata(serdev);1575 1576 hci_uart_unregister_device(&bcmdev->serdev_hu);1577}1578 1579#ifdef CONFIG_OF1580static struct bcm_device_data bcm4354_device_data = {1581 .no_early_set_baudrate = true,1582};1583 1584static struct bcm_device_data bcm43438_device_data = {1585 .drive_rts_on_open = true,1586};1587 1588static struct bcm_device_data cyw4373a0_device_data = {1589 .no_uart_clock_set = true,1590};1591 1592static struct bcm_device_data cyw55572_device_data = {1593 .max_autobaud_speed = 921600,1594};1595 1596static const struct of_device_id bcm_bluetooth_of_match[] = {1597 { .compatible = "brcm,bcm20702a1" },1598 { .compatible = "brcm,bcm4329-bt" },1599 { .compatible = "brcm,bcm4330-bt" },1600 { .compatible = "brcm,bcm4334-bt" },1601 { .compatible = "brcm,bcm4345c5" },1602 { .compatible = "brcm,bcm43430a0-bt" },1603 { .compatible = "brcm,bcm43430a1-bt" },1604 { .compatible = "brcm,bcm43438-bt", .data = &bcm43438_device_data },1605 { .compatible = "brcm,bcm4349-bt", .data = &bcm43438_device_data },1606 { .compatible = "brcm,bcm43540-bt", .data = &bcm4354_device_data },1607 { .compatible = "brcm,bcm4335a0" },1608 { .compatible = "cypress,cyw4373a0-bt", .data = &cyw4373a0_device_data },1609 { .compatible = "infineon,cyw55572-bt", .data = &cyw55572_device_data },1610 { },1611};1612MODULE_DEVICE_TABLE(of, bcm_bluetooth_of_match);1613#endif1614 1615static struct serdev_device_driver bcm_serdev_driver = {1616 .probe = bcm_serdev_probe,1617 .remove = bcm_serdev_remove,1618 .driver = {1619 .name = "hci_uart_bcm",1620 .of_match_table = of_match_ptr(bcm_bluetooth_of_match),1621 .acpi_match_table = ACPI_PTR(bcm_acpi_match),1622 .pm = &bcm_pm_ops,1623 },1624};1625 1626int __init bcm_init(void)1627{1628 /* For now, we need to keep both platform device1629 * driver (ACPI generated) and serdev driver (DT).1630 */1631 platform_driver_register(&bcm_driver);1632 serdev_device_driver_register(&bcm_serdev_driver);1633 1634 return hci_uart_register_proto(&bcm_proto);1635}1636 1637int __exit bcm_deinit(void)1638{1639 platform_driver_unregister(&bcm_driver);1640 serdev_device_driver_unregister(&bcm_serdev_driver);1641 1642 return hci_uart_unregister_proto(&bcm_proto);1643}1644