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>
30 #include <linux/platform_device.h>
31 #include <linux/clk.h>
32 #include <linux/gpio/consumer.h>
33 #include <linux/tty.h>
34 #include <linux/interrupt.h>
35 #include <linux/dmi.h>
36 #include <linux/pm_runtime.h>
38 #include <net/bluetooth/bluetooth.h>
39 #include <net/bluetooth/hci_core.h>
44 #define BCM_LM_DIAG_PKT 0x07
45 #define BCM_LM_DIAG_SIZE 63
47 #define BCM_AUTOSUSPEND_DELAY 5000 /* default autosleep delay */
50 struct list_head list
;
52 struct platform_device
*pdev
;
55 struct gpio_desc
*device_wakeup
;
56 struct gpio_desc
*shutdown
;
67 bool is_suspended
; /* suspend/resume flag */
72 struct sk_buff
*rx_skb
;
73 struct sk_buff_head txq
;
75 struct bcm_device
*dev
;
78 /* List of BCM BT UART devices */
79 static DEFINE_MUTEX(bcm_device_lock
);
80 static LIST_HEAD(bcm_device_list
);
82 static int bcm_set_baudrate(struct hci_uart
*hu
, unsigned int speed
)
84 struct hci_dev
*hdev
= hu
->hdev
;
86 struct bcm_update_uart_baud_rate param
;
88 if (speed
> 3000000) {
89 struct bcm_write_uart_clock_setting clock
;
91 clock
.type
= BCM_UART_CLOCK_48MHZ
;
93 bt_dev_dbg(hdev
, "Set Controller clock (%d)", clock
.type
);
95 /* This Broadcom specific command changes the UART's controller
96 * clock for baud rate > 3000000.
98 skb
= __hci_cmd_sync(hdev
, 0xfc45, 1, &clock
, HCI_INIT_TIMEOUT
);
100 int err
= PTR_ERR(skb
);
101 bt_dev_err(hdev
, "BCM: failed to write clock (%d)",
109 bt_dev_dbg(hdev
, "Set Controller UART speed to %d bit/s", speed
);
111 param
.zero
= cpu_to_le16(0);
112 param
.baud_rate
= cpu_to_le32(speed
);
114 /* This Broadcom specific command changes the UART's controller baud
117 skb
= __hci_cmd_sync(hdev
, 0xfc18, sizeof(param
), ¶m
,
120 int err
= PTR_ERR(skb
);
121 bt_dev_err(hdev
, "BCM: failed to write update baudrate (%d)",
131 /* bcm_device_exists should be protected by bcm_device_lock */
132 static bool bcm_device_exists(struct bcm_device
*device
)
136 list_for_each(p
, &bcm_device_list
) {
137 struct bcm_device
*dev
= list_entry(p
, struct bcm_device
, list
);
146 static int bcm_gpio_set_power(struct bcm_device
*dev
, bool powered
)
148 if (powered
&& !IS_ERR(dev
->clk
) && !dev
->clk_enabled
)
149 clk_prepare_enable(dev
->clk
);
151 gpiod_set_value(dev
->shutdown
, powered
);
152 gpiod_set_value(dev
->device_wakeup
, powered
);
154 if (!powered
&& !IS_ERR(dev
->clk
) && dev
->clk_enabled
)
155 clk_disable_unprepare(dev
->clk
);
157 dev
->clk_enabled
= powered
;
163 static irqreturn_t
bcm_host_wake(int irq
, void *data
)
165 struct bcm_device
*bdev
= data
;
167 bt_dev_dbg(bdev
, "Host wake IRQ");
169 pm_runtime_get(&bdev
->pdev
->dev
);
170 pm_runtime_mark_last_busy(&bdev
->pdev
->dev
);
171 pm_runtime_put_autosuspend(&bdev
->pdev
->dev
);
176 static int bcm_request_irq(struct bcm_data
*bcm
)
178 struct bcm_device
*bdev
= bcm
->dev
;
181 /* If this is not a platform device, do not enable PM functionalities */
182 mutex_lock(&bcm_device_lock
);
183 if (!bcm_device_exists(bdev
)) {
188 if (bdev
->irq
<= 0) {
193 err
= devm_request_irq(&bdev
->pdev
->dev
, bdev
->irq
, bcm_host_wake
,
194 IRQF_TRIGGER_RISING
, "host_wake", bdev
);
198 device_init_wakeup(&bdev
->pdev
->dev
, true);
200 pm_runtime_set_autosuspend_delay(&bdev
->pdev
->dev
,
201 BCM_AUTOSUSPEND_DELAY
);
202 pm_runtime_use_autosuspend(&bdev
->pdev
->dev
);
203 pm_runtime_set_active(&bdev
->pdev
->dev
);
204 pm_runtime_enable(&bdev
->pdev
->dev
);
207 mutex_unlock(&bcm_device_lock
);
212 static const struct bcm_set_sleep_mode default_sleep_params
= {
213 .sleep_mode
= 1, /* 0=Disabled, 1=UART, 2=Reserved, 3=USB */
214 .idle_host
= 2, /* idle threshold HOST, in 300ms */
215 .idle_dev
= 2, /* idle threshold device, in 300ms */
216 .bt_wake_active
= 1, /* BT_WAKE active mode: 1 = high, 0 = low */
217 .host_wake_active
= 0, /* HOST_WAKE active mode: 1 = high, 0 = low */
218 .allow_host_sleep
= 1, /* Allow host sleep in SCO flag */
219 .combine_modes
= 1, /* Combine sleep and LPM flag */
220 .tristate_control
= 0, /* Allow tri-state control of UART tx flag */
221 /* Irrelevant USB flags */
223 .usb_resume_timeout
= 0,
224 .pulsed_host_wake
= 0,
228 static int bcm_setup_sleep(struct hci_uart
*hu
)
230 struct bcm_data
*bcm
= hu
->priv
;
232 struct bcm_set_sleep_mode sleep_params
= default_sleep_params
;
234 sleep_params
.host_wake_active
= !bcm
->dev
->irq_polarity
;
236 skb
= __hci_cmd_sync(hu
->hdev
, 0xfc27, sizeof(sleep_params
),
237 &sleep_params
, HCI_INIT_TIMEOUT
);
239 int err
= PTR_ERR(skb
);
240 bt_dev_err(hu
->hdev
, "Sleep VSC failed (%d)", err
);
245 bt_dev_dbg(hu
->hdev
, "Set Sleep Parameters VSC succeeded");
250 static inline int bcm_request_irq(struct bcm_data
*bcm
) { return 0; }
251 static inline int bcm_setup_sleep(struct hci_uart
*hu
) { return 0; }
254 static int bcm_set_diag(struct hci_dev
*hdev
, bool enable
)
256 struct hci_uart
*hu
= hci_get_drvdata(hdev
);
257 struct bcm_data
*bcm
= hu
->priv
;
260 if (!test_bit(HCI_RUNNING
, &hdev
->flags
))
263 skb
= bt_skb_alloc(3, GFP_KERNEL
);
267 skb_put_u8(skb
, BCM_LM_DIAG_PKT
);
268 skb_put_u8(skb
, 0xf0);
269 skb_put_u8(skb
, enable
);
271 skb_queue_tail(&bcm
->txq
, skb
);
272 hci_uart_tx_wakeup(hu
);
277 static int bcm_open(struct hci_uart
*hu
)
279 struct bcm_data
*bcm
;
282 bt_dev_dbg(hu
->hdev
, "hu %p", hu
);
284 bcm
= kzalloc(sizeof(*bcm
), GFP_KERNEL
);
288 skb_queue_head_init(&bcm
->txq
);
295 mutex_lock(&bcm_device_lock
);
296 list_for_each(p
, &bcm_device_list
) {
297 struct bcm_device
*dev
= list_entry(p
, struct bcm_device
, list
);
299 /* Retrieve saved bcm_device based on parent of the
300 * platform device (saved during device probe) and
301 * parent of tty device used by hci_uart
303 if (hu
->tty
->dev
->parent
== dev
->pdev
->dev
.parent
) {
305 hu
->init_speed
= dev
->init_speed
;
309 bcm_gpio_set_power(bcm
->dev
, true);
314 mutex_unlock(&bcm_device_lock
);
319 static int bcm_close(struct hci_uart
*hu
)
321 struct bcm_data
*bcm
= hu
->priv
;
322 struct bcm_device
*bdev
= bcm
->dev
;
324 bt_dev_dbg(hu
->hdev
, "hu %p", hu
);
326 /* Protect bcm->dev against removal of the device or driver */
327 mutex_lock(&bcm_device_lock
);
328 if (bcm_device_exists(bdev
)) {
329 bcm_gpio_set_power(bdev
, false);
331 pm_runtime_disable(&bdev
->pdev
->dev
);
332 pm_runtime_set_suspended(&bdev
->pdev
->dev
);
334 if (device_can_wakeup(&bdev
->pdev
->dev
)) {
335 devm_free_irq(&bdev
->pdev
->dev
, bdev
->irq
, bdev
);
336 device_init_wakeup(&bdev
->pdev
->dev
, false);
342 mutex_unlock(&bcm_device_lock
);
344 skb_queue_purge(&bcm
->txq
);
345 kfree_skb(bcm
->rx_skb
);
352 static int bcm_flush(struct hci_uart
*hu
)
354 struct bcm_data
*bcm
= hu
->priv
;
356 bt_dev_dbg(hu
->hdev
, "hu %p", hu
);
358 skb_queue_purge(&bcm
->txq
);
363 static int bcm_setup(struct hci_uart
*hu
)
365 struct bcm_data
*bcm
= hu
->priv
;
367 const struct firmware
*fw
;
371 bt_dev_dbg(hu
->hdev
, "hu %p", hu
);
373 hu
->hdev
->set_diag
= bcm_set_diag
;
374 hu
->hdev
->set_bdaddr
= btbcm_set_bdaddr
;
376 err
= btbcm_initialize(hu
->hdev
, fw_name
, sizeof(fw_name
));
380 err
= request_firmware(&fw
, fw_name
, &hu
->hdev
->dev
);
382 bt_dev_info(hu
->hdev
, "BCM: Patch %s not found", fw_name
);
386 err
= btbcm_patchram(hu
->hdev
, fw
);
388 bt_dev_info(hu
->hdev
, "BCM: Patch failed (%d)", err
);
392 /* Init speed if any */
394 speed
= hu
->init_speed
;
395 else if (hu
->proto
->init_speed
)
396 speed
= hu
->proto
->init_speed
;
401 hci_uart_set_baudrate(hu
, speed
);
403 /* Operational speed if any */
405 speed
= hu
->oper_speed
;
406 else if (hu
->proto
->oper_speed
)
407 speed
= hu
->proto
->oper_speed
;
412 err
= bcm_set_baudrate(hu
, speed
);
414 hci_uart_set_baudrate(hu
, speed
);
418 release_firmware(fw
);
420 err
= btbcm_finalize(hu
->hdev
);
424 if (!bcm_request_irq(bcm
))
425 err
= bcm_setup_sleep(hu
);
430 #define BCM_RECV_LM_DIAG \
431 .type = BCM_LM_DIAG_PKT, \
432 .hlen = BCM_LM_DIAG_SIZE, \
435 .maxlen = BCM_LM_DIAG_SIZE
437 static const struct h4_recv_pkt bcm_recv_pkts
[] = {
438 { H4_RECV_ACL
, .recv
= hci_recv_frame
},
439 { H4_RECV_SCO
, .recv
= hci_recv_frame
},
440 { H4_RECV_EVENT
, .recv
= hci_recv_frame
},
441 { BCM_RECV_LM_DIAG
, .recv
= hci_recv_diag
},
444 static int bcm_recv(struct hci_uart
*hu
, const void *data
, int count
)
446 struct bcm_data
*bcm
= hu
->priv
;
448 if (!test_bit(HCI_UART_REGISTERED
, &hu
->flags
))
451 bcm
->rx_skb
= h4_recv_buf(hu
->hdev
, bcm
->rx_skb
, data
, count
,
452 bcm_recv_pkts
, ARRAY_SIZE(bcm_recv_pkts
));
453 if (IS_ERR(bcm
->rx_skb
)) {
454 int err
= PTR_ERR(bcm
->rx_skb
);
455 bt_dev_err(hu
->hdev
, "Frame reassembly failed (%d)", err
);
458 } else if (!bcm
->rx_skb
) {
459 /* Delay auto-suspend when receiving completed packet */
460 mutex_lock(&bcm_device_lock
);
461 if (bcm
->dev
&& bcm_device_exists(bcm
->dev
)) {
462 pm_runtime_get(&bcm
->dev
->pdev
->dev
);
463 pm_runtime_mark_last_busy(&bcm
->dev
->pdev
->dev
);
464 pm_runtime_put_autosuspend(&bcm
->dev
->pdev
->dev
);
466 mutex_unlock(&bcm_device_lock
);
472 static int bcm_enqueue(struct hci_uart
*hu
, struct sk_buff
*skb
)
474 struct bcm_data
*bcm
= hu
->priv
;
476 bt_dev_dbg(hu
->hdev
, "hu %p skb %p", hu
, skb
);
478 /* Prepend skb with frame type */
479 memcpy(skb_push(skb
, 1), &hci_skb_pkt_type(skb
), 1);
480 skb_queue_tail(&bcm
->txq
, skb
);
485 static struct sk_buff
*bcm_dequeue(struct hci_uart
*hu
)
487 struct bcm_data
*bcm
= hu
->priv
;
488 struct sk_buff
*skb
= NULL
;
489 struct bcm_device
*bdev
= NULL
;
491 mutex_lock(&bcm_device_lock
);
493 if (bcm_device_exists(bcm
->dev
)) {
495 pm_runtime_get_sync(&bdev
->pdev
->dev
);
496 /* Shall be resumed here */
499 skb
= skb_dequeue(&bcm
->txq
);
502 pm_runtime_mark_last_busy(&bdev
->pdev
->dev
);
503 pm_runtime_put_autosuspend(&bdev
->pdev
->dev
);
506 mutex_unlock(&bcm_device_lock
);
512 static int bcm_suspend_device(struct device
*dev
)
514 struct bcm_device
*bdev
= platform_get_drvdata(to_platform_device(dev
));
516 bt_dev_dbg(bdev
, "");
518 if (!bdev
->is_suspended
&& bdev
->hu
) {
519 hci_uart_set_flow_control(bdev
->hu
, true);
521 /* Once this returns, driver suspends BT via GPIO */
522 bdev
->is_suspended
= true;
525 /* Suspend the device */
526 if (bdev
->device_wakeup
) {
527 gpiod_set_value(bdev
->device_wakeup
, false);
528 bt_dev_dbg(bdev
, "suspend, delaying 15 ms");
535 static int bcm_resume_device(struct device
*dev
)
537 struct bcm_device
*bdev
= platform_get_drvdata(to_platform_device(dev
));
539 bt_dev_dbg(bdev
, "");
541 if (bdev
->device_wakeup
) {
542 gpiod_set_value(bdev
->device_wakeup
, true);
543 bt_dev_dbg(bdev
, "resume, delaying 15 ms");
547 /* When this executes, the device has woken up already */
548 if (bdev
->is_suspended
&& bdev
->hu
) {
549 bdev
->is_suspended
= false;
551 hci_uart_set_flow_control(bdev
->hu
, false);
558 #ifdef CONFIG_PM_SLEEP
559 /* Platform suspend callback */
560 static int bcm_suspend(struct device
*dev
)
562 struct bcm_device
*bdev
= platform_get_drvdata(to_platform_device(dev
));
565 bt_dev_dbg(bdev
, "suspend: is_suspended %d", bdev
->is_suspended
);
567 /* bcm_suspend can be called at any time as long as platform device is
568 * bound, so it should use bcm_device_lock to protect access to hci_uart
569 * and device_wake-up GPIO.
571 mutex_lock(&bcm_device_lock
);
576 if (pm_runtime_active(dev
))
577 bcm_suspend_device(dev
);
579 if (device_may_wakeup(&bdev
->pdev
->dev
)) {
580 error
= enable_irq_wake(bdev
->irq
);
582 bt_dev_dbg(bdev
, "BCM irq: enabled");
586 mutex_unlock(&bcm_device_lock
);
591 /* Platform resume callback */
592 static int bcm_resume(struct device
*dev
)
594 struct bcm_device
*bdev
= platform_get_drvdata(to_platform_device(dev
));
596 bt_dev_dbg(bdev
, "resume: is_suspended %d", bdev
->is_suspended
);
598 /* bcm_resume can be called at any time as long as platform device is
599 * bound, so it should use bcm_device_lock to protect access to hci_uart
600 * and device_wake-up GPIO.
602 mutex_lock(&bcm_device_lock
);
607 if (device_may_wakeup(&bdev
->pdev
->dev
)) {
608 disable_irq_wake(bdev
->irq
);
609 bt_dev_dbg(bdev
, "BCM irq: disabled");
612 bcm_resume_device(dev
);
615 mutex_unlock(&bcm_device_lock
);
617 pm_runtime_disable(dev
);
618 pm_runtime_set_active(dev
);
619 pm_runtime_enable(dev
);
625 static const struct acpi_gpio_params int_last_device_wakeup_gpios
= { 0, 0, false };
626 static const struct acpi_gpio_params int_last_shutdown_gpios
= { 1, 0, false };
627 static const struct acpi_gpio_params int_last_host_wakeup_gpios
= { 2, 0, false };
629 static const struct acpi_gpio_mapping acpi_bcm_int_last_gpios
[] = {
630 { "device-wakeup-gpios", &int_last_device_wakeup_gpios
, 1 },
631 { "shutdown-gpios", &int_last_shutdown_gpios
, 1 },
632 { "host-wakeup-gpios", &int_last_host_wakeup_gpios
, 1 },
636 static const struct acpi_gpio_params int_first_host_wakeup_gpios
= { 0, 0, false };
637 static const struct acpi_gpio_params int_first_device_wakeup_gpios
= { 1, 0, false };
638 static const struct acpi_gpio_params int_first_shutdown_gpios
= { 2, 0, false };
640 static const struct acpi_gpio_mapping acpi_bcm_int_first_gpios
[] = {
641 { "device-wakeup-gpios", &int_first_device_wakeup_gpios
, 1 },
642 { "shutdown-gpios", &int_first_shutdown_gpios
, 1 },
643 { "host-wakeup-gpios", &int_first_host_wakeup_gpios
, 1 },
648 static u8 acpi_active_low
= ACPI_ACTIVE_LOW
;
650 /* IRQ polarity of some chipsets are not defined correctly in ACPI table. */
651 static const struct dmi_system_id bcm_wrong_irq_dmi_table
[] = {
653 .ident
= "Asus T100TA",
655 DMI_EXACT_MATCH(DMI_SYS_VENDOR
,
656 "ASUSTeK COMPUTER INC."),
657 DMI_EXACT_MATCH(DMI_PRODUCT_NAME
, "T100TA"),
659 .driver_data
= &acpi_active_low
,
662 .ident
= "Asus T100CHI",
664 DMI_EXACT_MATCH(DMI_SYS_VENDOR
,
665 "ASUSTeK COMPUTER INC."),
666 DMI_EXACT_MATCH(DMI_PRODUCT_NAME
, "T100CHI"),
668 .driver_data
= &acpi_active_low
,
670 { /* Handle ThinkPad 8 tablets with BCM2E55 chipset ACPI ID */
671 .ident
= "Lenovo ThinkPad 8",
673 DMI_EXACT_MATCH(DMI_SYS_VENDOR
, "LENOVO"),
674 DMI_EXACT_MATCH(DMI_PRODUCT_VERSION
, "ThinkPad 8"),
676 .driver_data
= &acpi_active_low
,
681 static int bcm_resource(struct acpi_resource
*ares
, void *data
)
683 struct bcm_device
*dev
= data
;
684 struct acpi_resource_extended_irq
*irq
;
685 struct acpi_resource_gpio
*gpio
;
686 struct acpi_resource_uart_serialbus
*sb
;
688 switch (ares
->type
) {
689 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ
:
690 irq
= &ares
->data
.extended_irq
;
691 dev
->irq_polarity
= irq
->polarity
;
694 case ACPI_RESOURCE_TYPE_GPIO
:
695 gpio
= &ares
->data
.gpio
;
696 if (gpio
->connection_type
== ACPI_RESOURCE_GPIO_TYPE_INT
)
697 dev
->irq_polarity
= gpio
->polarity
;
700 case ACPI_RESOURCE_TYPE_SERIAL_BUS
:
701 sb
= &ares
->data
.uart_serial_bus
;
702 if (sb
->type
== ACPI_RESOURCE_SERIAL_TYPE_UART
)
703 dev
->init_speed
= sb
->default_baud_rate
;
710 /* Always tell the ACPI core to skip this resource */
713 #endif /* CONFIG_ACPI */
715 static int bcm_platform_probe(struct bcm_device
*dev
)
717 struct platform_device
*pdev
= dev
->pdev
;
719 dev
->name
= dev_name(&pdev
->dev
);
721 dev
->clk
= devm_clk_get(&pdev
->dev
, NULL
);
723 dev
->device_wakeup
= devm_gpiod_get_optional(&pdev
->dev
,
726 if (IS_ERR(dev
->device_wakeup
))
727 return PTR_ERR(dev
->device_wakeup
);
729 dev
->shutdown
= devm_gpiod_get_optional(&pdev
->dev
, "shutdown",
731 if (IS_ERR(dev
->shutdown
))
732 return PTR_ERR(dev
->shutdown
);
734 /* IRQ can be declared in ACPI table as Interrupt or GpioInt */
735 dev
->irq
= platform_get_irq(pdev
, 0);
737 struct gpio_desc
*gpio
;
739 gpio
= devm_gpiod_get_optional(&pdev
->dev
, "host-wakeup",
742 return PTR_ERR(gpio
);
744 dev
->irq
= gpiod_to_irq(gpio
);
747 dev_info(&pdev
->dev
, "BCM irq: %d\n", dev
->irq
);
749 /* Make sure at-least one of the GPIO is defined and that
750 * a name is specified for this instance
752 if ((!dev
->device_wakeup
&& !dev
->shutdown
) || !dev
->name
) {
753 dev_err(&pdev
->dev
, "invalid platform data\n");
761 static int bcm_acpi_probe(struct bcm_device
*dev
)
763 struct platform_device
*pdev
= dev
->pdev
;
764 LIST_HEAD(resources
);
765 const struct dmi_system_id
*dmi_id
;
766 const struct acpi_gpio_mapping
*gpio_mapping
= acpi_bcm_int_last_gpios
;
767 const struct acpi_device_id
*id
;
770 /* Retrieve GPIO data */
771 id
= acpi_match_device(pdev
->dev
.driver
->acpi_match_table
, &pdev
->dev
);
773 gpio_mapping
= (const struct acpi_gpio_mapping
*) id
->driver_data
;
775 ret
= devm_acpi_dev_add_driver_gpios(&pdev
->dev
, gpio_mapping
);
779 ret
= bcm_platform_probe(dev
);
783 /* Retrieve UART ACPI info */
784 ret
= acpi_dev_get_resources(ACPI_COMPANION(&dev
->pdev
->dev
),
785 &resources
, bcm_resource
, dev
);
788 acpi_dev_free_resource_list(&resources
);
790 dmi_id
= dmi_first_match(bcm_wrong_irq_dmi_table
);
792 bt_dev_warn(dev
, "%s: Overwriting IRQ polarity to active low",
794 dev
->irq_polarity
= *(u8
*)dmi_id
->driver_data
;
800 static int bcm_acpi_probe(struct bcm_device
*dev
)
804 #endif /* CONFIG_ACPI */
806 static int bcm_probe(struct platform_device
*pdev
)
808 struct bcm_device
*dev
;
811 dev
= devm_kzalloc(&pdev
->dev
, sizeof(*dev
), GFP_KERNEL
);
817 if (has_acpi_companion(&pdev
->dev
))
818 ret
= bcm_acpi_probe(dev
);
820 ret
= bcm_platform_probe(dev
);
824 platform_set_drvdata(pdev
, dev
);
826 dev_info(&pdev
->dev
, "%s device registered.\n", dev
->name
);
828 /* Place this instance on the device list */
829 mutex_lock(&bcm_device_lock
);
830 list_add_tail(&dev
->list
, &bcm_device_list
);
831 mutex_unlock(&bcm_device_lock
);
833 bcm_gpio_set_power(dev
, false);
838 static int bcm_remove(struct platform_device
*pdev
)
840 struct bcm_device
*dev
= platform_get_drvdata(pdev
);
842 mutex_lock(&bcm_device_lock
);
843 list_del(&dev
->list
);
844 mutex_unlock(&bcm_device_lock
);
846 dev_info(&pdev
->dev
, "%s device unregistered.\n", dev
->name
);
851 static const struct hci_uart_proto bcm_proto
= {
855 .init_speed
= 115200,
856 .oper_speed
= 4000000,
861 .set_baudrate
= bcm_set_baudrate
,
863 .enqueue
= bcm_enqueue
,
864 .dequeue
= bcm_dequeue
,
868 static const struct acpi_device_id bcm_acpi_match
[] = {
869 { "BCM2E1A", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
870 { "BCM2E39", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
871 { "BCM2E3A", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
872 { "BCM2E3D", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
873 { "BCM2E3F", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
874 { "BCM2E40", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
875 { "BCM2E54", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
876 { "BCM2E55", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
877 { "BCM2E64", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
878 { "BCM2E65", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
879 { "BCM2E67", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
880 { "BCM2E71", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
881 { "BCM2E7B", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
882 { "BCM2E7C", (kernel_ulong_t
)&acpi_bcm_int_last_gpios
},
883 { "BCM2E95", (kernel_ulong_t
)&acpi_bcm_int_first_gpios
},
884 { "BCM2E96", (kernel_ulong_t
)&acpi_bcm_int_first_gpios
},
887 MODULE_DEVICE_TABLE(acpi
, bcm_acpi_match
);
890 /* Platform suspend and resume callbacks */
891 static const struct dev_pm_ops bcm_pm_ops
= {
892 SET_SYSTEM_SLEEP_PM_OPS(bcm_suspend
, bcm_resume
)
893 SET_RUNTIME_PM_OPS(bcm_suspend_device
, bcm_resume_device
, NULL
)
896 static struct platform_driver bcm_driver
= {
898 .remove
= bcm_remove
,
901 .acpi_match_table
= ACPI_PTR(bcm_acpi_match
),
906 int __init
bcm_init(void)
908 platform_driver_register(&bcm_driver
);
910 return hci_uart_register_proto(&bcm_proto
);
913 int __exit
bcm_deinit(void)
915 platform_driver_unregister(&bcm_driver
);
917 return hci_uart_unregister_proto(&bcm_proto
);