3 * Bluetooth HCI UART driver for Broadcom devices
5 * Copyright (C) 2015 Intel Corporation
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/kernel.h>
25 #include <linux/errno.h>
26 #include <linux/skbuff.h>
27 #include <linux/firmware.h>
28 #include <linux/module.h>
29 #include <linux/acpi.h>
31 #include <linux/property.h>
32 #include <linux/platform_device.h>
33 #include <linux/clk.h>
34 #include <linux/gpio/consumer.h>
35 #include <linux/tty.h>
36 #include <linux/interrupt.h>
37 #include <linux/dmi.h>
38 #include <linux/pm_runtime.h>
39 #include <linux/serdev.h>
41 #include <net/bluetooth/bluetooth.h>
42 #include <net/bluetooth/hci_core.h>
47 #define BCM_NULL_PKT 0x00
48 #define BCM_NULL_SIZE 0
50 #define BCM_LM_DIAG_PKT 0x07
51 #define BCM_LM_DIAG_SIZE 63
53 #define BCM_AUTOSUSPEND_DELAY 5000 /* default autosleep delay */
55 /* platform device driver resources */
57 struct list_head list
;
59 struct platform_device
*pdev
;
62 struct gpio_desc
*device_wakeup
;
63 struct gpio_desc
*shutdown
;
75 bool is_suspended
; /* suspend/resume flag */
79 /* serdev driver resources */
84 /* generic bcm uart resources */
86 struct sk_buff
*rx_skb
;
87 struct sk_buff_head txq
;
89 struct bcm_device
*dev
;
92 /* List of BCM BT UART devices */
93 static DEFINE_MUTEX(bcm_device_lock
);
94 static LIST_HEAD(bcm_device_list
);
96 static inline void host_set_baudrate(struct hci_uart
*hu
, unsigned int speed
)
99 serdev_device_set_baudrate(hu
->serdev
, speed
);
101 hci_uart_set_baudrate(hu
, speed
);
104 static int bcm_set_baudrate(struct hci_uart
*hu
, unsigned int speed
)
106 struct hci_dev
*hdev
= hu
->hdev
;
108 struct bcm_update_uart_baud_rate param
;
110 if (speed
> 3000000) {
111 struct bcm_write_uart_clock_setting clock
;
113 clock
.type
= BCM_UART_CLOCK_48MHZ
;
115 bt_dev_dbg(hdev
, "Set Controller clock (%d)", clock
.type
);
117 /* This Broadcom specific command changes the UART's controller
118 * clock for baud rate > 3000000.
120 skb
= __hci_cmd_sync(hdev
, 0xfc45, 1, &clock
, HCI_INIT_TIMEOUT
);
122 int err
= PTR_ERR(skb
);
123 bt_dev_err(hdev
, "BCM: failed to write clock (%d)",
131 bt_dev_dbg(hdev
, "Set Controller UART speed to %d bit/s", speed
);
133 param
.zero
= cpu_to_le16(0);
134 param
.baud_rate
= cpu_to_le32(speed
);
136 /* This Broadcom specific command changes the UART's controller baud
139 skb
= __hci_cmd_sync(hdev
, 0xfc18, sizeof(param
), ¶m
,
142 int err
= PTR_ERR(skb
);
143 bt_dev_err(hdev
, "BCM: failed to write update baudrate (%d)",
153 /* bcm_device_exists should be protected by bcm_device_lock */
154 static bool bcm_device_exists(struct bcm_device
*device
)
158 list_for_each(p
, &bcm_device_list
) {
159 struct bcm_device
*dev
= list_entry(p
, struct bcm_device
, list
);
168 static int bcm_gpio_set_power(struct bcm_device
*dev
, bool powered
)
170 if (powered
&& !IS_ERR(dev
->clk
) && !dev
->clk_enabled
)
171 clk_prepare_enable(dev
->clk
);
173 gpiod_set_value(dev
->shutdown
, powered
);
174 gpiod_set_value(dev
->device_wakeup
, powered
);
176 if (!powered
&& !IS_ERR(dev
->clk
) && dev
->clk_enabled
)
177 clk_disable_unprepare(dev
->clk
);
179 dev
->clk_enabled
= powered
;
185 static irqreturn_t
bcm_host_wake(int irq
, void *data
)
187 struct bcm_device
*bdev
= data
;
189 bt_dev_dbg(bdev
, "Host wake IRQ");
191 pm_runtime_get(&bdev
->pdev
->dev
);
192 pm_runtime_mark_last_busy(&bdev
->pdev
->dev
);
193 pm_runtime_put_autosuspend(&bdev
->pdev
->dev
);
198 static int bcm_request_irq(struct bcm_data
*bcm
)
200 struct bcm_device
*bdev
= bcm
->dev
;
203 /* If this is not a platform device, do not enable PM functionalities */
204 mutex_lock(&bcm_device_lock
);
205 if (!bcm_device_exists(bdev
)) {
210 if (bdev
->irq
<= 0) {
215 err
= devm_request_irq(&bdev
->pdev
->dev
, bdev
->irq
, bcm_host_wake
,
216 IRQF_TRIGGER_RISING
, "host_wake", bdev
);
220 device_init_wakeup(&bdev
->pdev
->dev
, true);
222 pm_runtime_set_autosuspend_delay(&bdev
->pdev
->dev
,
223 BCM_AUTOSUSPEND_DELAY
);
224 pm_runtime_use_autosuspend(&bdev
->pdev
->dev
);
225 pm_runtime_set_active(&bdev
->pdev
->dev
);
226 pm_runtime_enable(&bdev
->pdev
->dev
);
229 mutex_unlock(&bcm_device_lock
);
234 static const struct bcm_set_sleep_mode default_sleep_params
= {
235 .sleep_mode
= 1, /* 0=Disabled, 1=UART, 2=Reserved, 3=USB */
236 .idle_host
= 2, /* idle threshold HOST, in 300ms */
237 .idle_dev
= 2, /* idle threshold device, in 300ms */
238 .bt_wake_active
= 1, /* BT_WAKE active mode: 1 = high, 0 = low */
239 .host_wake_active
= 0, /* HOST_WAKE active mode: 1 = high, 0 = low */
240 .allow_host_sleep
= 1, /* Allow host sleep in SCO flag */
241 .combine_modes
= 1, /* Combine sleep and LPM flag */
242 .tristate_control
= 0, /* Allow tri-state control of UART tx flag */
243 /* Irrelevant USB flags */
245 .usb_resume_timeout
= 0,
246 .pulsed_host_wake
= 0,
250 static int bcm_setup_sleep(struct hci_uart
*hu
)
252 struct bcm_data
*bcm
= hu
->priv
;
254 struct bcm_set_sleep_mode sleep_params
= default_sleep_params
;
256 sleep_params
.host_wake_active
= !bcm
->dev
->irq_polarity
;
258 skb
= __hci_cmd_sync(hu
->hdev
, 0xfc27, sizeof(sleep_params
),
259 &sleep_params
, HCI_INIT_TIMEOUT
);
261 int err
= PTR_ERR(skb
);
262 bt_dev_err(hu
->hdev
, "Sleep VSC failed (%d)", err
);
267 bt_dev_dbg(hu
->hdev
, "Set Sleep Parameters VSC succeeded");
272 static inline int bcm_request_irq(struct bcm_data
*bcm
) { return 0; }
273 static inline int bcm_setup_sleep(struct hci_uart
*hu
) { return 0; }
276 static int bcm_set_diag(struct hci_dev
*hdev
, bool enable
)
278 struct hci_uart
*hu
= hci_get_drvdata(hdev
);
279 struct bcm_data
*bcm
= hu
->priv
;
282 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
285 skb
= bt_skb_alloc(3, GFP_KERNEL
);
289 skb_put_u8(skb
, BCM_LM_DIAG_PKT
);
290 skb_put_u8(skb
, 0xf0);
291 skb_put_u8(skb
, enable
);
293 skb_queue_tail(&bcm
->txq
, skb
);
294 hci_uart_tx_wakeup(hu
);
299 static int bcm_open(struct hci_uart
*hu
)
301 struct bcm_data
*bcm
;
304 bt_dev_dbg(hu
->hdev
, "hu %p", hu
);
306 bcm
= kzalloc(sizeof(*bcm
), GFP_KERNEL
);
310 skb_queue_head_init(&bcm
->txq
);
314 /* If this is a serdev defined device, then only use
315 * serdev open primitive and skip the rest.
318 serdev_device_open(hu
->serdev
);
325 mutex_lock(&bcm_device_lock
);
326 list_for_each(p
, &bcm_device_list
) {
327 struct bcm_device
*dev
= list_entry(p
, struct bcm_device
, list
);
329 /* Retrieve saved bcm_device based on parent of the
330 * platform device (saved during device probe) and
331 * parent of tty device used by hci_uart
333 if (hu
->tty
->dev
->parent
== dev
->pdev
->dev
.parent
) {
335 hu
->init_speed
= dev
->init_speed
;
336 hu
->oper_speed
= dev
->oper_speed
;
340 bcm_gpio_set_power(bcm
->dev
, true);
345 mutex_unlock(&bcm_device_lock
);
350 static int bcm_close(struct hci_uart
*hu
)
352 struct bcm_data
*bcm
= hu
->priv
;
353 struct bcm_device
*bdev
= bcm
->dev
;
355 bt_dev_dbg(hu
->hdev
, "hu %p", hu
);
357 /* If this is a serdev defined device, only use serdev
358 * close primitive and then continue as usual.
361 serdev_device_close(hu
->serdev
);
363 /* Protect bcm->dev against removal of the device or driver */
364 mutex_lock(&bcm_device_lock
);
365 if (bcm_device_exists(bdev
)) {
366 bcm_gpio_set_power(bdev
, false);
368 pm_runtime_disable(&bdev
->pdev
->dev
);
369 pm_runtime_set_suspended(&bdev
->pdev
->dev
);
371 if (device_can_wakeup(&bdev
->pdev
->dev
)) {
372 devm_free_irq(&bdev
->pdev
->dev
, bdev
->irq
, bdev
);
373 device_init_wakeup(&bdev
->pdev
->dev
, false);
379 mutex_unlock(&bcm_device_lock
);
381 skb_queue_purge(&bcm
->txq
);
382 kfree_skb(bcm
->rx_skb
);
389 static int bcm_flush(struct hci_uart
*hu
)
391 struct bcm_data
*bcm
= hu
->priv
;
393 bt_dev_dbg(hu
->hdev
, "hu %p", hu
);
395 skb_queue_purge(&bcm
->txq
);
400 static int bcm_setup(struct hci_uart
*hu
)
402 struct bcm_data
*bcm
= hu
->priv
;
404 const struct firmware
*fw
;
408 bt_dev_dbg(hu
->hdev
, "hu %p", hu
);
410 hu
->hdev
->set_diag
= bcm_set_diag
;
411 hu
->hdev
->set_bdaddr
= btbcm_set_bdaddr
;
413 err
= btbcm_initialize(hu
->hdev
, fw_name
, sizeof(fw_name
));
417 err
= request_firmware(&fw
, fw_name
, &hu
->hdev
->dev
);
419 bt_dev_info(hu
->hdev
, "BCM: Patch %s not found", fw_name
);
423 err
= btbcm_patchram(hu
->hdev
, fw
);
425 bt_dev_info(hu
->hdev
, "BCM: Patch failed (%d)", err
);
429 /* Init speed if any */
431 speed
= hu
->init_speed
;
432 else if (hu
->proto
->init_speed
)
433 speed
= hu
->proto
->init_speed
;
438 host_set_baudrate(hu
, speed
);
440 /* Operational speed if any */
442 speed
= hu
->oper_speed
;
443 else if (hu
->proto
->oper_speed
)
444 speed
= hu
->proto
->oper_speed
;
449 err
= bcm_set_baudrate(hu
, speed
);
451 host_set_baudrate(hu
, speed
);
455 release_firmware(fw
);
457 err
= btbcm_finalize(hu
->hdev
);
461 if (!bcm_request_irq(bcm
))
462 err
= bcm_setup_sleep(hu
);
467 #define BCM_RECV_LM_DIAG \
468 .type = BCM_LM_DIAG_PKT, \
469 .hlen = BCM_LM_DIAG_SIZE, \
472 .maxlen = BCM_LM_DIAG_SIZE
474 #define BCM_RECV_NULL \
475 .type = BCM_NULL_PKT, \
476 .hlen = BCM_NULL_SIZE, \
479 .maxlen = BCM_NULL_SIZE
481 static const struct h4_recv_pkt bcm_recv_pkts
[] = {
482 { H4_RECV_ACL
, .recv
= hci_recv_frame
},
483 { H4_RECV_SCO
, .recv
= hci_recv_frame
},
484 { H4_RECV_EVENT
, .recv
= hci_recv_frame
},
485 { BCM_RECV_LM_DIAG
, .recv
= hci_recv_diag
},
486 { BCM_RECV_NULL
, .recv
= hci_recv_diag
},
489 static int bcm_recv(struct hci_uart
*hu
, const void *data
, int count
)
491 struct bcm_data
*bcm
= hu
->priv
;
493 if (!test_bit(HCI_UART_REGISTERED
, &hu
->flags
))
496 bcm
->rx_skb
= h4_recv_buf(hu
->hdev
, bcm
->rx_skb
, data
, count
,
497 bcm_recv_pkts
, ARRAY_SIZE(bcm_recv_pkts
));
498 if (IS_ERR(bcm
->rx_skb
)) {
499 int err
= PTR_ERR(bcm
->rx_skb
);
500 bt_dev_err(hu
->hdev
, "Frame reassembly failed (%d)", err
);
503 } else if (!bcm
->rx_skb
) {
504 /* Delay auto-suspend when receiving completed packet */
505 mutex_lock(&bcm_device_lock
);
506 if (bcm
->dev
&& bcm_device_exists(bcm
->dev
)) {
507 pm_runtime_get(&bcm
->dev
->pdev
->dev
);
508 pm_runtime_mark_last_busy(&bcm
->dev
->pdev
->dev
);
509 pm_runtime_put_autosuspend(&bcm
->dev
->pdev
->dev
);
511 mutex_unlock(&bcm_device_lock
);
517 static int bcm_enqueue(struct hci_uart
*hu
, struct sk_buff
*skb
)
519 struct bcm_data
*bcm
= hu
->priv
;
521 bt_dev_dbg(hu
->hdev
, "hu %p skb %p", hu
, skb
);
523 /* Prepend skb with frame type */
524 memcpy(skb_push(skb
, 1), &hci_skb_pkt_type(skb
), 1);
525 skb_queue_tail(&bcm
->txq
, skb
);
530 static struct sk_buff
*bcm_dequeue(struct hci_uart
*hu
)
532 struct bcm_data
*bcm
= hu
->priv
;
533 struct sk_buff
*skb
= NULL
;
534 struct bcm_device
*bdev
= NULL
;
536 mutex_lock(&bcm_device_lock
);
538 if (bcm_device_exists(bcm
->dev
)) {
540 pm_runtime_get_sync(&bdev
->pdev
->dev
);
541 /* Shall be resumed here */
544 skb
= skb_dequeue(&bcm
->txq
);
547 pm_runtime_mark_last_busy(&bdev
->pdev
->dev
);
548 pm_runtime_put_autosuspend(&bdev
->pdev
->dev
);
551 mutex_unlock(&bcm_device_lock
);
557 static int bcm_suspend_device(struct device
*dev
)
559 struct bcm_device
*bdev
= platform_get_drvdata(to_platform_device(dev
));
561 bt_dev_dbg(bdev
, "");
563 if (!bdev
->is_suspended
&& bdev
->hu
) {
564 hci_uart_set_flow_control(bdev
->hu
, true);
566 /* Once this returns, driver suspends BT via GPIO */
567 bdev
->is_suspended
= true;
570 /* Suspend the device */
571 if (bdev
->device_wakeup
) {
572 gpiod_set_value(bdev
->device_wakeup
, false);
573 bt_dev_dbg(bdev
, "suspend, delaying 15 ms");
580 static int bcm_resume_device(struct device
*dev
)
582 struct bcm_device
*bdev
= platform_get_drvdata(to_platform_device(dev
));
584 bt_dev_dbg(bdev
, "");
586 if (bdev
->device_wakeup
) {
587 gpiod_set_value(bdev
->device_wakeup
, true);
588 bt_dev_dbg(bdev
, "resume, delaying 15 ms");
592 /* When this executes, the device has woken up already */
593 if (bdev
->is_suspended
&& bdev
->hu
) {
594 bdev
->is_suspended
= false;
596 hci_uart_set_flow_control(bdev
->hu
, false);
603 #ifdef CONFIG_PM_SLEEP
604 /* Platform suspend callback */
605 static int bcm_suspend(struct device
*dev
)
607 struct bcm_device
*bdev
= platform_get_drvdata(to_platform_device(dev
));
610 bt_dev_dbg(bdev
, "suspend: is_suspended %d", bdev
->is_suspended
);
612 /* bcm_suspend can be called at any time as long as platform device is
613 * bound, so it should use bcm_device_lock to protect access to hci_uart
614 * and device_wake-up GPIO.
616 mutex_lock(&bcm_device_lock
);
621 if (pm_runtime_active(dev
))
622 bcm_suspend_device(dev
);
624 if (device_may_wakeup(&bdev
->pdev
->dev
)) {
625 error
= enable_irq_wake(bdev
->irq
);
627 bt_dev_dbg(bdev
, "BCM irq: enabled");
631 mutex_unlock(&bcm_device_lock
);
636 /* Platform resume callback */
637 static int bcm_resume(struct device
*dev
)
639 struct bcm_device
*bdev
= platform_get_drvdata(to_platform_device(dev
));
641 bt_dev_dbg(bdev
, "resume: is_suspended %d", bdev
->is_suspended
);
643 /* bcm_resume can be called at any time as long as platform device is
644 * bound, so it should use bcm_device_lock to protect access to hci_uart
645 * and device_wake-up GPIO.
647 mutex_lock(&bcm_device_lock
);
652 if (device_may_wakeup(&bdev
->pdev
->dev
)) {
653 disable_irq_wake(bdev
->irq
);
654 bt_dev_dbg(bdev
, "BCM irq: disabled");
657 bcm_resume_device(dev
);
660 mutex_unlock(&bcm_device_lock
);
662 pm_runtime_disable(dev
);
663 pm_runtime_set_active(dev
);
664 pm_runtime_enable(dev
);
670 static const struct acpi_gpio_params int_last_device_wakeup_gpios
= { 0, 0, false };
671 static const struct acpi_gpio_params int_last_shutdown_gpios
= { 1, 0, false };
672 static const struct acpi_gpio_params int_last_host_wakeup_gpios
= { 2, 0, false };
674 static const struct acpi_gpio_mapping acpi_bcm_int_last_gpios
[] = {
675 { "device-wakeup-gpios", &int_last_device_wakeup_gpios
, 1 },
676 { "shutdown-gpios", &int_last_shutdown_gpios
, 1 },
677 { "host-wakeup-gpios", &int_last_host_wakeup_gpios
, 1 },
681 static const struct acpi_gpio_params int_first_host_wakeup_gpios
= { 0, 0, false };
682 static const struct acpi_gpio_params int_first_device_wakeup_gpios
= { 1, 0, false };
683 static const struct acpi_gpio_params int_first_shutdown_gpios
= { 2, 0, false };
685 static const struct acpi_gpio_mapping acpi_bcm_int_first_gpios
[] = {
686 { "device-wakeup-gpios", &int_first_device_wakeup_gpios
, 1 },
687 { "shutdown-gpios", &int_first_shutdown_gpios
, 1 },
688 { "host-wakeup-gpios", &int_first_host_wakeup_gpios
, 1 },
693 static u8 acpi_active_low
= ACPI_ACTIVE_LOW
;
695 /* IRQ polarity of some chipsets are not defined correctly in ACPI table. */
696 static const struct dmi_system_id bcm_wrong_irq_dmi_table
[] = {
698 .ident
= "Asus T100TA",
700 DMI_EXACT_MATCH(DMI_SYS_VENDOR
,
701 "ASUSTeK COMPUTER INC."),
702 DMI_EXACT_MATCH(DMI_PRODUCT_NAME
, "T100TA"),
704 .driver_data
= &acpi_active_low
,
707 .ident
= "Asus T100CHI",
709 DMI_EXACT_MATCH(DMI_SYS_VENDOR
,
710 "ASUSTeK COMPUTER INC."),
711 DMI_EXACT_MATCH(DMI_PRODUCT_NAME
, "T100CHI"),
713 .driver_data
= &acpi_active_low
,
715 { /* Handle ThinkPad 8 tablets with BCM2E55 chipset ACPI ID */
716 .ident
= "Lenovo ThinkPad 8",
718 DMI_EXACT_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
719 DMI_EXACT_MATCH(DMI_PRODUCT_VERSION
, "ThinkPad 8"),
721 .driver_data
= &acpi_active_low
,
726 static int bcm_resource(struct acpi_resource
*ares
, void *data
)
728 struct bcm_device
*dev
= data
;
729 struct acpi_resource_extended_irq
*irq
;
730 struct acpi_resource_gpio
*gpio
;
731 struct acpi_resource_uart_serialbus
*sb
;
733 switch (ares
->type
) {
734 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
735 irq
= &ares
->data
.extended_irq
;
736 dev
->irq_polarity
= irq
->polarity
;
739 case ACPI_RESOURCE_TYPE_GPIO
:
740 gpio
= &ares
->data
.gpio
;
741 if (gpio
->connection_type
== ACPI_RESOURCE_GPIO_TYPE_INT
)
742 dev
->irq_polarity
= gpio
->polarity
;
745 case ACPI_RESOURCE_TYPE_SERIAL_BUS
:
746 sb
= &ares
->data
.uart_serial_bus
;
747 if (sb
->type
== ACPI_RESOURCE_SERIAL_TYPE_UART
) {
748 dev
->init_speed
= sb
->default_baud_rate
;
749 dev
->oper_speed
= 4000000;
757 /* Always tell the ACPI core to skip this resource */
760 #endif /* CONFIG_ACPI */
762 static int bcm_platform_probe(struct bcm_device
*dev
)
764 struct platform_device
*pdev
= dev
->pdev
;
766 dev
->name
= dev_name(&pdev
->dev
);
768 dev
->clk
= devm_clk_get(&pdev
->dev
, NULL
);
770 dev
->device_wakeup
= devm_gpiod_get_optional(&pdev
->dev
,
773 if (IS_ERR(dev
->device_wakeup
))
774 return PTR_ERR(dev
->device_wakeup
);
776 dev
->shutdown
= devm_gpiod_get_optional(&pdev
->dev
, "shutdown",
778 if (IS_ERR(dev
->shutdown
))
779 return PTR_ERR(dev
->shutdown
);
781 /* IRQ can be declared in ACPI table as Interrupt or GpioInt */
782 dev
->irq
= platform_get_irq(pdev
, 0);
784 struct gpio_desc
*gpio
;
786 gpio
= devm_gpiod_get_optional(&pdev
->dev
, "host-wakeup",
789 return PTR_ERR(gpio
);
791 dev
->irq
= gpiod_to_irq(gpio
);
794 dev_info(&pdev
->dev
, "BCM irq: %d\n", dev
->irq
);
796 /* Make sure at-least one of the GPIO is defined and that
797 * a name is specified for this instance
799 if ((!dev
->device_wakeup
&& !dev
->shutdown
) || !dev
->name
) {
800 dev_err(&pdev
->dev
, "invalid platform data\n");
808 static int bcm_acpi_probe(struct bcm_device
*dev
)
810 struct platform_device
*pdev
= dev
->pdev
;
811 LIST_HEAD(resources
);
812 const struct dmi_system_id
*dmi_id
;
813 const struct acpi_gpio_mapping
*gpio_mapping
= acpi_bcm_int_last_gpios
;
814 const struct acpi_device_id
*id
;
817 /* Retrieve GPIO data */
818 id
= acpi_match_device(pdev
->dev
.driver
->acpi_match_table
, &pdev
->dev
);
820 gpio_mapping
= (const struct acpi_gpio_mapping
*) id
->driver_data
;
822 ret
= devm_acpi_dev_add_driver_gpios(&pdev
->dev
, gpio_mapping
);
826 ret
= bcm_platform_probe(dev
);
830 /* Retrieve UART ACPI info */
831 ret
= acpi_dev_get_resources(ACPI_COMPANION(&dev
->pdev
->dev
),
832 &resources
, bcm_resource
, dev
);
835 acpi_dev_free_resource_list(&resources
);
837 dmi_id
= dmi_first_match(bcm_wrong_irq_dmi_table
);
839 bt_dev_warn(dev
, "%s: Overwriting IRQ polarity to active low",
841 dev
->irq_polarity
= *(u8
*)dmi_id
->driver_data
;
847 static int bcm_acpi_probe(struct bcm_device
*dev
)
851 #endif /* CONFIG_ACPI */
853 static int bcm_probe(struct platform_device
*pdev
)
855 struct bcm_device
*dev
;
858 dev
= devm_kzalloc(&pdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
864 if (has_acpi_companion(&pdev
->dev
))
865 ret
= bcm_acpi_probe(dev
);
867 ret
= bcm_platform_probe(dev
);
871 platform_set_drvdata(pdev
, dev
);
873 dev_info(&pdev
->dev
, "%s device registered.\n", dev
->name
);
875 /* Place this instance on the device list */
876 mutex_lock(&bcm_device_lock
);
877 list_add_tail(&dev
->list
, &bcm_device_list
);
878 mutex_unlock(&bcm_device_lock
);
880 bcm_gpio_set_power(dev
, false);
885 static int bcm_remove(struct platform_device
*pdev
)
887 struct bcm_device
*dev
= platform_get_drvdata(pdev
);
889 mutex_lock(&bcm_device_lock
);
890 list_del(&dev
->list
);
891 mutex_unlock(&bcm_device_lock
);
893 dev_info(&pdev
->dev
, "%s device unregistered.\n", dev
->name
);
898 static const struct hci_uart_proto bcm_proto
= {
902 .init_speed
= 115200,
907 .set_baudrate
= bcm_set_baudrate
,
909 .enqueue
= bcm_enqueue
,
910 .dequeue
= bcm_dequeue
,
914 static const struct acpi_device_id bcm_acpi_match
[] = {
915 { "BCM2E1A", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
916 { "BCM2E39", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
917 { "BCM2E3A", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
918 { "BCM2E3D", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
919 { "BCM2E3F", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
920 { "BCM2E40", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
921 { "BCM2E54", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
922 { "BCM2E55", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
923 { "BCM2E64", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
924 { "BCM2E65", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
925 { "BCM2E67", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
926 { "BCM2E71", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
927 { "BCM2E7B", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
928 { "BCM2E7C", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
929 { "BCM2E95", (kernel_ulong_t
)&acpi_bcm_int_first_gpios
},
930 { "BCM2E96", (kernel_ulong_t
)&acpi_bcm_int_first_gpios
},
933 MODULE_DEVICE_TABLE(acpi
, bcm_acpi_match
);
936 /* Platform suspend and resume callbacks */
937 static const struct dev_pm_ops bcm_pm_ops
= {
938 SET_SYSTEM_SLEEP_PM_OPS(bcm_suspend
, bcm_resume
)
939 SET_RUNTIME_PM_OPS(bcm_suspend_device
, bcm_resume_device
, NULL
)
942 static struct platform_driver bcm_driver
= {
944 .remove
= bcm_remove
,
947 .acpi_match_table
= ACPI_PTR(bcm_acpi_match
),
952 static int bcm_serdev_probe(struct serdev_device
*serdev
)
954 struct bcm_serdev
*bcmdev
;
958 bcmdev
= devm_kzalloc(&serdev
->dev
, sizeof(*bcmdev
), GFP_KERNEL
);
962 bcmdev
->hu
.serdev
= serdev
;
963 serdev_device_set_drvdata(serdev
, bcmdev
);
965 err
= device_property_read_u32(&serdev
->dev
, "max-speed", &speed
);
967 bcmdev
->hu
.oper_speed
= speed
;
969 return hci_uart_register_device(&bcmdev
->hu
, &bcm_proto
);
972 static void bcm_serdev_remove(struct serdev_device
*serdev
)
974 struct bcm_serdev
*bcmdev
= serdev_device_get_drvdata(serdev
);
976 hci_uart_unregister_device(&bcmdev
->hu
);
980 static const struct of_device_id bcm_bluetooth_of_match
[] = {
981 { .compatible
= "brcm,bcm43438-bt" },
984 MODULE_DEVICE_TABLE(of
, bcm_bluetooth_of_match
);
987 static struct serdev_device_driver bcm_serdev_driver
= {
988 .probe
= bcm_serdev_probe
,
989 .remove
= bcm_serdev_remove
,
991 .name
= "hci_uart_bcm",
992 .of_match_table
= of_match_ptr(bcm_bluetooth_of_match
),
996 int __init
bcm_init(void)
998 /* For now, we need to keep both platform device
999 * driver (ACPI generated) and serdev driver (DT).
1001 platform_driver_register(&bcm_driver
);
1002 serdev_device_driver_register(&bcm_serdev_driver
);
1004 return hci_uart_register_proto(&bcm_proto
);
1007 int __exit
bcm_deinit(void)
1009 platform_driver_unregister(&bcm_driver
);
1010 serdev_device_driver_unregister(&bcm_serdev_driver
);
1012 return hci_uart_unregister_proto(&bcm_proto
);