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