drivers/bluetooth/hci_bcm.c

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