blob: 40b9fb247010169d047f27b1532ef20e69ecab68 [file] [log] [blame]
Marcel Holtmanne9a2dd22015-04-04 16:13:03 -07001/*
2 *
3 * Bluetooth HCI UART driver for Broadcom devices
4 *
5 * Copyright (C) 2015 Intel Corporation
6 *
7 *
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.
12 *
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.
17 *
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
21 *
22 */
23
24#include <linux/kernel.h>
25#include <linux/errno.h>
26#include <linux/skbuff.h>
Frederic Danis18aeb442015-05-28 11:25:01 +020027#include <linux/firmware.h>
Frederic Danis0395ffc2015-08-11 16:35:35 +020028#include <linux/module.h>
29#include <linux/acpi.h>
Loic Poulain33cd1492017-08-17 19:59:51 +020030#include <linux/of.h>
31#include <linux/property.h>
Lukas Wunner4c331622018-01-10 16:32:10 +010032#include <linux/platform_data/x86/apple.h>
Frederic Danis0395ffc2015-08-11 16:35:35 +020033#include <linux/platform_device.h>
34#include <linux/clk.h>
35#include <linux/gpio/consumer.h>
36#include <linux/tty.h>
Frederic Danis6cc43962015-09-04 15:35:44 +020037#include <linux/interrupt.h>
Frederic Danis5cebdfe2015-09-23 18:18:08 +020038#include <linux/dmi.h>
Frederic Danise88ab302015-09-23 18:18:11 +020039#include <linux/pm_runtime.h>
Loic Poulain33cd1492017-08-17 19:59:51 +020040#include <linux/serdev.h>
Marcel Holtmanne9a2dd22015-04-04 16:13:03 -070041
42#include <net/bluetooth/bluetooth.h>
43#include <net/bluetooth/hci_core.h>
44
Marcel Holtmannbdd88182015-04-05 22:52:18 -070045#include "btbcm.h"
Marcel Holtmanne9a2dd22015-04-04 16:13:03 -070046#include "hci_uart.h"
Marcel Holtmannbdd88182015-04-05 22:52:18 -070047
Marcel Holtmann01d5e442017-08-17 21:41:09 +020048#define BCM_NULL_PKT 0x00
49#define BCM_NULL_SIZE 0
50
Marcel Holtmann94c58132015-10-07 19:12:54 +020051#define BCM_LM_DIAG_PKT 0x07
52#define BCM_LM_DIAG_SIZE 63
53
Frederic Danise88ab302015-09-23 18:18:11 +020054#define BCM_AUTOSUSPEND_DELAY 5000 /* default autosleep delay */
55
Lukas Wunnerb7c2aba2018-01-10 16:32:10 +010056/**
57 * struct bcm_device - device driver resources
58 * @serdev_hu: HCI UART controller struct
59 * @list: bcm_device_list node
60 * @dev: physical UART slave
61 * @name: device name logged by bt_dev_*() functions
62 * @device_wakeup: BT_WAKE pin,
63 * assert = Bluetooth device must wake up or remain awake,
64 * deassert = Bluetooth device may sleep when sleep criteria are met
65 * @shutdown: BT_REG_ON pin,
66 * power up or power down Bluetooth device internal regulators
Lukas Wunner8353b4a2018-01-10 16:32:10 +010067 * @set_device_wakeup: callback to toggle BT_WAKE pin
Lukas Wunner4c331622018-01-10 16:32:10 +010068 * either by accessing @device_wakeup or by calling @btlp
Lukas Wunner8353b4a2018-01-10 16:32:10 +010069 * @set_shutdown: callback to toggle BT_REG_ON pin
Lukas Wunner4c331622018-01-10 16:32:10 +010070 * either by accessing @shutdown or by calling @btpu/@btpd
71 * @btlp: Apple ACPI method to toggle BT_WAKE pin ("Bluetooth Low Power")
72 * @btpu: Apple ACPI method to drive BT_REG_ON pin high ("Bluetooth Power Up")
73 * @btpd: Apple ACPI method to drive BT_REG_ON pin low ("Bluetooth Power Down")
Lukas Wunnerb7c2aba2018-01-10 16:32:10 +010074 * @clk: clock used by Bluetooth device
75 * @clk_enabled: whether @clk is prepared and enabled
76 * @init_speed: default baudrate of Bluetooth device;
77 * the host UART is initially set to this baudrate so that
78 * it can configure the Bluetooth device for @oper_speed
79 * @oper_speed: preferred baudrate of Bluetooth device;
80 * set to 0 if @init_speed is already the preferred baudrate
81 * @irq: interrupt triggered by HOST_WAKE_BT pin
82 * @irq_active_low: whether @irq is active low
83 * @hu: pointer to HCI UART controller struct,
84 * used to disable flow control during runtime suspend and system sleep
85 * @is_suspended: whether flow control is currently disabled
86 */
Frederic Danis0395ffc2015-08-11 16:35:35 +020087struct bcm_device {
Hans de Goede8a920562017-10-04 20:43:43 +020088 /* Must be the first member, hci_serdev.c expects this. */
89 struct hci_uart serdev_hu;
Frederic Danis0395ffc2015-08-11 16:35:35 +020090 struct list_head list;
91
Hans de Goedec0d3ce52017-10-04 20:43:39 +020092 struct device *dev;
Frederic Danis0395ffc2015-08-11 16:35:35 +020093
94 const char *name;
95 struct gpio_desc *device_wakeup;
96 struct gpio_desc *shutdown;
Lukas Wunner8353b4a2018-01-10 16:32:10 +010097 int (*set_device_wakeup)(struct bcm_device *, bool);
98 int (*set_shutdown)(struct bcm_device *, bool);
Lukas Wunner4c331622018-01-10 16:32:10 +010099#ifdef CONFIG_ACPI
100 acpi_handle btlp, btpu, btpd;
101#endif
Frederic Danis0395ffc2015-08-11 16:35:35 +0200102
103 struct clk *clk;
104 bool clk_enabled;
Frederic Danisae056902015-08-11 16:35:37 +0200105
106 u32 init_speed;
Marcel Holtmann74183a12017-08-16 09:53:30 +0200107 u32 oper_speed;
Frederic Danis6cc43962015-09-04 15:35:44 +0200108 int irq;
Hans de Goede227630c2017-10-04 20:43:36 +0200109 bool irq_active_low;
Frederic Danis118612f2015-08-11 16:35:38 +0200110
Frederic Danisb7a622a2015-09-23 18:18:09 +0200111#ifdef CONFIG_PM
Frederic Danis118612f2015-08-11 16:35:38 +0200112 struct hci_uart *hu;
Lukas Wunnerb7c2aba2018-01-10 16:32:10 +0100113 bool is_suspended;
Frederic Danis118612f2015-08-11 16:35:38 +0200114#endif
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700115};
116
Loic Poulain33cd1492017-08-17 19:59:51 +0200117/* generic bcm uart resources */
Frederic Danis0395ffc2015-08-11 16:35:35 +0200118struct bcm_data {
119 struct sk_buff *rx_skb;
120 struct sk_buff_head txq;
121
122 struct bcm_device *dev;
123};
124
125/* List of BCM BT UART devices */
Frederic Danisbb3ea162015-09-01 12:13:35 +0200126static DEFINE_MUTEX(bcm_device_lock);
Frederic Danis0395ffc2015-08-11 16:35:35 +0200127static LIST_HEAD(bcm_device_list);
128
Loic Poulain33cd1492017-08-17 19:59:51 +0200129static inline void host_set_baudrate(struct hci_uart *hu, unsigned int speed)
130{
131 if (hu->serdev)
132 serdev_device_set_baudrate(hu->serdev, speed);
133 else
134 hci_uart_set_baudrate(hu, speed);
135}
136
Frederic Danis61b2fc22015-06-09 16:15:37 +0200137static int bcm_set_baudrate(struct hci_uart *hu, unsigned int speed)
138{
139 struct hci_dev *hdev = hu->hdev;
140 struct sk_buff *skb;
141 struct bcm_update_uart_baud_rate param;
142
143 if (speed > 3000000) {
144 struct bcm_write_uart_clock_setting clock;
145
146 clock.type = BCM_UART_CLOCK_48MHZ;
147
Frederic Danis65ad07c2015-09-01 12:13:36 +0200148 bt_dev_dbg(hdev, "Set Controller clock (%d)", clock.type);
Frederic Danis61b2fc22015-06-09 16:15:37 +0200149
150 /* This Broadcom specific command changes the UART's controller
151 * clock for baud rate > 3000000.
152 */
153 skb = __hci_cmd_sync(hdev, 0xfc45, 1, &clock, HCI_INIT_TIMEOUT);
154 if (IS_ERR(skb)) {
155 int err = PTR_ERR(skb);
Frederic Danis65ad07c2015-09-01 12:13:36 +0200156 bt_dev_err(hdev, "BCM: failed to write clock (%d)",
157 err);
Frederic Danis61b2fc22015-06-09 16:15:37 +0200158 return err;
159 }
160
161 kfree_skb(skb);
162 }
163
Frederic Danis65ad07c2015-09-01 12:13:36 +0200164 bt_dev_dbg(hdev, "Set Controller UART speed to %d bit/s", speed);
Frederic Danis61b2fc22015-06-09 16:15:37 +0200165
166 param.zero = cpu_to_le16(0);
167 param.baud_rate = cpu_to_le32(speed);
168
169 /* This Broadcom specific command changes the UART's controller baud
170 * rate.
171 */
172 skb = __hci_cmd_sync(hdev, 0xfc18, sizeof(param), &param,
173 HCI_INIT_TIMEOUT);
174 if (IS_ERR(skb)) {
175 int err = PTR_ERR(skb);
Frederic Danis65ad07c2015-09-01 12:13:36 +0200176 bt_dev_err(hdev, "BCM: failed to write update baudrate (%d)",
177 err);
Frederic Danis61b2fc22015-06-09 16:15:37 +0200178 return err;
179 }
180
181 kfree_skb(skb);
182
183 return 0;
184}
185
Frederic Danis917522a2015-08-28 15:44:00 +0200186/* bcm_device_exists should be protected by bcm_device_lock */
Frederic Danis0395ffc2015-08-11 16:35:35 +0200187static bool bcm_device_exists(struct bcm_device *device)
188{
189 struct list_head *p;
190
Arnd Bergmann81a19052017-10-11 15:46:21 +0200191#ifdef CONFIG_PM
Hans de Goede8a920562017-10-04 20:43:43 +0200192 /* Devices using serdev always exist */
193 if (device && device->hu && device->hu->serdev)
194 return true;
Arnd Bergmann81a19052017-10-11 15:46:21 +0200195#endif
Hans de Goede8a920562017-10-04 20:43:43 +0200196
Frederic Danis0395ffc2015-08-11 16:35:35 +0200197 list_for_each(p, &bcm_device_list) {
198 struct bcm_device *dev = list_entry(p, struct bcm_device, list);
199
200 if (device == dev)
201 return true;
202 }
203
204 return false;
205}
206
207static int bcm_gpio_set_power(struct bcm_device *dev, bool powered)
208{
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100209 int err;
Frederic Danis0395ffc2015-08-11 16:35:35 +0200210
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100211 if (powered && !IS_ERR(dev->clk) && !dev->clk_enabled) {
212 err = clk_prepare_enable(dev->clk);
213 if (err)
214 return err;
215 }
216
217 err = dev->set_shutdown(dev, powered);
218 if (err)
219 goto err_clk_disable;
220
221 err = dev->set_device_wakeup(dev, powered);
222 if (err)
223 goto err_revert_shutdown;
Frederic Danis0395ffc2015-08-11 16:35:35 +0200224
225 if (!powered && !IS_ERR(dev->clk) && dev->clk_enabled)
John Keeping730ce392017-03-15 12:20:05 +0000226 clk_disable_unprepare(dev->clk);
Frederic Danis0395ffc2015-08-11 16:35:35 +0200227
228 dev->clk_enabled = powered;
229
230 return 0;
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100231
232err_revert_shutdown:
233 dev->set_shutdown(dev, !powered);
234err_clk_disable:
235 if (powered && !IS_ERR(dev->clk) && !dev->clk_enabled)
236 clk_disable_unprepare(dev->clk);
237 return err;
Frederic Danis0395ffc2015-08-11 16:35:35 +0200238}
239
Frederic Danisb7a622a2015-09-23 18:18:09 +0200240#ifdef CONFIG_PM
Frederic Danis6cc43962015-09-04 15:35:44 +0200241static irqreturn_t bcm_host_wake(int irq, void *data)
242{
243 struct bcm_device *bdev = data;
244
245 bt_dev_dbg(bdev, "Host wake IRQ");
246
Hans de Goedeb09c6152018-03-14 23:06:02 +0100247 pm_runtime_get(bdev->dev);
248 pm_runtime_mark_last_busy(bdev->dev);
249 pm_runtime_put_autosuspend(bdev->dev);
Frederic Danise88ab302015-09-23 18:18:11 +0200250
Frederic Danis6cc43962015-09-04 15:35:44 +0200251 return IRQ_HANDLED;
252}
253
254static int bcm_request_irq(struct bcm_data *bcm)
255{
256 struct bcm_device *bdev = bcm->dev;
Loic Poulain98dc77d2017-07-04 12:57:56 +0200257 int err;
Frederic Danis6cc43962015-09-04 15:35:44 +0200258
Frederic Danis6cc43962015-09-04 15:35:44 +0200259 mutex_lock(&bcm_device_lock);
260 if (!bcm_device_exists(bdev)) {
261 err = -ENODEV;
262 goto unlock;
263 }
264
Loic Poulain98dc77d2017-07-04 12:57:56 +0200265 if (bdev->irq <= 0) {
266 err = -EOPNOTSUPP;
267 goto unlock;
Frederic Danis6cc43962015-09-04 15:35:44 +0200268 }
269
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200270 err = devm_request_irq(bdev->dev, bdev->irq, bcm_host_wake,
Hans de Goede227630c2017-10-04 20:43:36 +0200271 bdev->irq_active_low ? IRQF_TRIGGER_FALLING :
272 IRQF_TRIGGER_RISING,
273 "host_wake", bdev);
Lukas Wunner4dc27332018-01-10 16:32:10 +0100274 if (err) {
275 bdev->irq = err;
Loic Poulain98dc77d2017-07-04 12:57:56 +0200276 goto unlock;
Lukas Wunner4dc27332018-01-10 16:32:10 +0100277 }
Loic Poulain98dc77d2017-07-04 12:57:56 +0200278
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200279 device_init_wakeup(bdev->dev, true);
Loic Poulain98dc77d2017-07-04 12:57:56 +0200280
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200281 pm_runtime_set_autosuspend_delay(bdev->dev,
Loic Poulain98dc77d2017-07-04 12:57:56 +0200282 BCM_AUTOSUSPEND_DELAY);
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200283 pm_runtime_use_autosuspend(bdev->dev);
284 pm_runtime_set_active(bdev->dev);
285 pm_runtime_enable(bdev->dev);
Loic Poulain98dc77d2017-07-04 12:57:56 +0200286
Frederic Danis6cc43962015-09-04 15:35:44 +0200287unlock:
288 mutex_unlock(&bcm_device_lock);
289
290 return err;
291}
292
293static const struct bcm_set_sleep_mode default_sleep_params = {
294 .sleep_mode = 1, /* 0=Disabled, 1=UART, 2=Reserved, 3=USB */
295 .idle_host = 2, /* idle threshold HOST, in 300ms */
296 .idle_dev = 2, /* idle threshold device, in 300ms */
297 .bt_wake_active = 1, /* BT_WAKE active mode: 1 = high, 0 = low */
298 .host_wake_active = 0, /* HOST_WAKE active mode: 1 = high, 0 = low */
299 .allow_host_sleep = 1, /* Allow host sleep in SCO flag */
Frederic Danise88ab302015-09-23 18:18:11 +0200300 .combine_modes = 1, /* Combine sleep and LPM flag */
Frederic Danis6cc43962015-09-04 15:35:44 +0200301 .tristate_control = 0, /* Allow tri-state control of UART tx flag */
302 /* Irrelevant USB flags */
303 .usb_auto_sleep = 0,
304 .usb_resume_timeout = 0,
Lukas Wunnerff875962018-01-10 16:32:10 +0100305 .break_to_host = 0,
Hans de Goedee07c99b2018-03-14 23:06:03 +0100306 .pulsed_host_wake = 1,
Frederic Danis6cc43962015-09-04 15:35:44 +0200307};
308
309static int bcm_setup_sleep(struct hci_uart *hu)
310{
311 struct bcm_data *bcm = hu->priv;
312 struct sk_buff *skb;
313 struct bcm_set_sleep_mode sleep_params = default_sleep_params;
314
Hans de Goede227630c2017-10-04 20:43:36 +0200315 sleep_params.host_wake_active = !bcm->dev->irq_active_low;
Frederic Danis6cc43962015-09-04 15:35:44 +0200316
317 skb = __hci_cmd_sync(hu->hdev, 0xfc27, sizeof(sleep_params),
318 &sleep_params, HCI_INIT_TIMEOUT);
319 if (IS_ERR(skb)) {
320 int err = PTR_ERR(skb);
321 bt_dev_err(hu->hdev, "Sleep VSC failed (%d)", err);
322 return err;
323 }
324 kfree_skb(skb);
325
326 bt_dev_dbg(hu->hdev, "Set Sleep Parameters VSC succeeded");
327
328 return 0;
329}
330#else
331static inline int bcm_request_irq(struct bcm_data *bcm) { return 0; }
332static inline int bcm_setup_sleep(struct hci_uart *hu) { return 0; }
333#endif
334
Marcel Holtmann075e1f52015-10-07 20:08:26 +0200335static int bcm_set_diag(struct hci_dev *hdev, bool enable)
336{
337 struct hci_uart *hu = hci_get_drvdata(hdev);
338 struct bcm_data *bcm = hu->priv;
339 struct sk_buff *skb;
340
341 if (!test_bit(HCI_RUNNING, &hdev->flags))
342 return -ENETDOWN;
343
344 skb = bt_skb_alloc(3, GFP_KERNEL);
Dan Carpentera1857392015-10-22 12:06:09 +0300345 if (!skb)
346 return -ENOMEM;
Marcel Holtmann075e1f52015-10-07 20:08:26 +0200347
Johannes Berg634fef62017-06-16 14:29:24 +0200348 skb_put_u8(skb, BCM_LM_DIAG_PKT);
349 skb_put_u8(skb, 0xf0);
350 skb_put_u8(skb, enable);
Marcel Holtmann075e1f52015-10-07 20:08:26 +0200351
352 skb_queue_tail(&bcm->txq, skb);
353 hci_uart_tx_wakeup(hu);
354
355 return 0;
356}
357
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700358static int bcm_open(struct hci_uart *hu)
359{
360 struct bcm_data *bcm;
Frederic Danis0395ffc2015-08-11 16:35:35 +0200361 struct list_head *p;
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100362 int err;
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700363
Frederic Danis65ad07c2015-09-01 12:13:36 +0200364 bt_dev_dbg(hu->hdev, "hu %p", hu);
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700365
366 bcm = kzalloc(sizeof(*bcm), GFP_KERNEL);
367 if (!bcm)
368 return -ENOMEM;
369
370 skb_queue_head_init(&bcm->txq);
371
372 hu->priv = bcm;
Frederic Danis0395ffc2015-08-11 16:35:35 +0200373
Hans de Goede8a920562017-10-04 20:43:43 +0200374 mutex_lock(&bcm_device_lock);
375
Loic Poulain33cd1492017-08-17 19:59:51 +0200376 if (hu->serdev) {
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100377 err = serdev_device_open(hu->serdev);
378 if (err)
379 goto err_free;
380
Hans de Goede8a920562017-10-04 20:43:43 +0200381 bcm->dev = serdev_device_get_drvdata(hu->serdev);
Loic Poulain33cd1492017-08-17 19:59:51 +0200382 goto out;
383 }
384
Johan Hovold95065a62017-03-29 18:15:27 +0200385 if (!hu->tty->dev)
386 goto out;
387
Frederic Danis0395ffc2015-08-11 16:35:35 +0200388 list_for_each(p, &bcm_device_list) {
389 struct bcm_device *dev = list_entry(p, struct bcm_device, list);
390
391 /* Retrieve saved bcm_device based on parent of the
392 * platform device (saved during device probe) and
393 * parent of tty device used by hci_uart
394 */
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200395 if (hu->tty->dev->parent == dev->dev->parent) {
Frederic Danis0395ffc2015-08-11 16:35:35 +0200396 bcm->dev = dev;
Frederic Danisb7a622a2015-09-23 18:18:09 +0200397#ifdef CONFIG_PM
Frederic Danis118612f2015-08-11 16:35:38 +0200398 dev->hu = hu;
399#endif
Frederic Danis0395ffc2015-08-11 16:35:35 +0200400 break;
401 }
402 }
403
Johan Hovold95065a62017-03-29 18:15:27 +0200404out:
Hans de Goede8a920562017-10-04 20:43:43 +0200405 if (bcm->dev) {
406 hu->init_speed = bcm->dev->init_speed;
407 hu->oper_speed = bcm->dev->oper_speed;
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100408 err = bcm_gpio_set_power(bcm->dev, true);
409 if (err)
410 goto err_unset_hu;
Hans de Goede8a920562017-10-04 20:43:43 +0200411 }
412
413 mutex_unlock(&bcm_device_lock);
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700414 return 0;
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100415
416err_unset_hu:
Hans de Goede8c6b8ed2018-01-22 12:53:24 +0100417 if (hu->serdev)
418 serdev_device_close(hu->serdev);
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100419#ifdef CONFIG_PM
Hans de Goede8c6b8ed2018-01-22 12:53:24 +0100420 else
421 bcm->dev->hu = NULL;
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100422#endif
423err_free:
424 mutex_unlock(&bcm_device_lock);
425 hu->priv = NULL;
426 kfree(bcm);
427 return err;
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700428}
429
430static int bcm_close(struct hci_uart *hu)
431{
432 struct bcm_data *bcm = hu->priv;
Hans de Goede8a920562017-10-04 20:43:43 +0200433 struct bcm_device *bdev = NULL;
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100434 int err;
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700435
Frederic Danis65ad07c2015-09-01 12:13:36 +0200436 bt_dev_dbg(hu->hdev, "hu %p", hu);
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700437
Frederic Danis0395ffc2015-08-11 16:35:35 +0200438 /* Protect bcm->dev against removal of the device or driver */
Frederic Danisbb3ea162015-09-01 12:13:35 +0200439 mutex_lock(&bcm_device_lock);
Hans de Goede8a920562017-10-04 20:43:43 +0200440
441 if (hu->serdev) {
442 serdev_device_close(hu->serdev);
443 bdev = serdev_device_get_drvdata(hu->serdev);
444 } else if (bcm_device_exists(bcm->dev)) {
445 bdev = bcm->dev;
446#ifdef CONFIG_PM
447 bdev->hu = NULL;
448#endif
449 }
450
451 if (bdev) {
Lukas Wunner6d83f1e2018-01-10 16:32:10 +0100452 if (IS_ENABLED(CONFIG_PM) && bdev->irq > 0) {
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200453 devm_free_irq(bdev->dev, bdev->irq, bdev);
454 device_init_wakeup(bdev->dev, false);
Lukas Wunnerf4cf6b72018-01-10 16:32:10 +0100455 pm_runtime_disable(bdev->dev);
Frederic Danis6cc43962015-09-04 15:35:44 +0200456 }
Lukas Wunner54ba69f2018-01-10 16:32:10 +0100457
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100458 err = bcm_gpio_set_power(bdev, false);
459 if (err)
460 bt_dev_err(hu->hdev, "Failed to power down");
461 else
462 pm_runtime_set_suspended(bdev->dev);
Frederic Danis118612f2015-08-11 16:35:38 +0200463 }
Frederic Danisbb3ea162015-09-01 12:13:35 +0200464 mutex_unlock(&bcm_device_lock);
Frederic Danis0395ffc2015-08-11 16:35:35 +0200465
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700466 skb_queue_purge(&bcm->txq);
467 kfree_skb(bcm->rx_skb);
468 kfree(bcm);
469
470 hu->priv = NULL;
471 return 0;
472}
473
474static int bcm_flush(struct hci_uart *hu)
475{
476 struct bcm_data *bcm = hu->priv;
477
Frederic Danis65ad07c2015-09-01 12:13:36 +0200478 bt_dev_dbg(hu->hdev, "hu %p", hu);
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700479
480 skb_queue_purge(&bcm->txq);
481
482 return 0;
483}
484
485static int bcm_setup(struct hci_uart *hu)
486{
Frederic Danis6cc43962015-09-04 15:35:44 +0200487 struct bcm_data *bcm = hu->priv;
Frederic Danis6be09b42015-05-28 11:25:05 +0200488 char fw_name[64];
489 const struct firmware *fw;
Frederic Danis960ef1d2015-06-18 12:43:27 +0200490 unsigned int speed;
Frederic Danis6be09b42015-05-28 11:25:05 +0200491 int err;
492
Frederic Danis65ad07c2015-09-01 12:13:36 +0200493 bt_dev_dbg(hu->hdev, "hu %p", hu);
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700494
Marcel Holtmann075e1f52015-10-07 20:08:26 +0200495 hu->hdev->set_diag = bcm_set_diag;
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700496 hu->hdev->set_bdaddr = btbcm_set_bdaddr;
497
Frederic Danis6be09b42015-05-28 11:25:05 +0200498 err = btbcm_initialize(hu->hdev, fw_name, sizeof(fw_name));
499 if (err)
500 return err;
501
502 err = request_firmware(&fw, fw_name, &hu->hdev->dev);
503 if (err < 0) {
Frederic Danis65ad07c2015-09-01 12:13:36 +0200504 bt_dev_info(hu->hdev, "BCM: Patch %s not found", fw_name);
Frederic Danis6be09b42015-05-28 11:25:05 +0200505 return 0;
506 }
507
508 err = btbcm_patchram(hu->hdev, fw);
509 if (err) {
Frederic Danis65ad07c2015-09-01 12:13:36 +0200510 bt_dev_info(hu->hdev, "BCM: Patch failed (%d)", err);
Frederic Danis6be09b42015-05-28 11:25:05 +0200511 goto finalize;
512 }
513
Frederic Danis960ef1d2015-06-18 12:43:27 +0200514 /* Init speed if any */
515 if (hu->init_speed)
516 speed = hu->init_speed;
517 else if (hu->proto->init_speed)
518 speed = hu->proto->init_speed;
519 else
520 speed = 0;
Frederic Danis6be09b42015-05-28 11:25:05 +0200521
Frederic Danis960ef1d2015-06-18 12:43:27 +0200522 if (speed)
Loic Poulain33cd1492017-08-17 19:59:51 +0200523 host_set_baudrate(hu, speed);
Frederic Danis960ef1d2015-06-18 12:43:27 +0200524
525 /* Operational speed if any */
526 if (hu->oper_speed)
527 speed = hu->oper_speed;
528 else if (hu->proto->oper_speed)
529 speed = hu->proto->oper_speed;
530 else
531 speed = 0;
532
533 if (speed) {
534 err = bcm_set_baudrate(hu, speed);
Frederic Danis61b2fc22015-06-09 16:15:37 +0200535 if (!err)
Loic Poulain33cd1492017-08-17 19:59:51 +0200536 host_set_baudrate(hu, speed);
Frederic Danis61b2fc22015-06-09 16:15:37 +0200537 }
538
Frederic Danis6be09b42015-05-28 11:25:05 +0200539finalize:
540 release_firmware(fw);
541
542 err = btbcm_finalize(hu->hdev);
Frederic Danis6cc43962015-09-04 15:35:44 +0200543 if (err)
544 return err;
545
Loic Poulaincdd24a22017-06-27 19:15:07 +0200546 if (!bcm_request_irq(bcm))
Frederic Danis6cc43962015-09-04 15:35:44 +0200547 err = bcm_setup_sleep(hu);
Frederic Danis6be09b42015-05-28 11:25:05 +0200548
549 return err;
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700550}
551
Marcel Holtmann94c58132015-10-07 19:12:54 +0200552#define BCM_RECV_LM_DIAG \
553 .type = BCM_LM_DIAG_PKT, \
554 .hlen = BCM_LM_DIAG_SIZE, \
555 .loff = 0, \
556 .lsize = 0, \
557 .maxlen = BCM_LM_DIAG_SIZE
558
Marcel Holtmann01d5e442017-08-17 21:41:09 +0200559#define BCM_RECV_NULL \
560 .type = BCM_NULL_PKT, \
561 .hlen = BCM_NULL_SIZE, \
562 .loff = 0, \
563 .lsize = 0, \
564 .maxlen = BCM_NULL_SIZE
565
Marcel Holtmann79b8df92015-04-05 23:44:59 -0700566static const struct h4_recv_pkt bcm_recv_pkts[] = {
Marcel Holtmann94c58132015-10-07 19:12:54 +0200567 { H4_RECV_ACL, .recv = hci_recv_frame },
568 { H4_RECV_SCO, .recv = hci_recv_frame },
569 { H4_RECV_EVENT, .recv = hci_recv_frame },
570 { BCM_RECV_LM_DIAG, .recv = hci_recv_diag },
Marcel Holtmann01d5e442017-08-17 21:41:09 +0200571 { BCM_RECV_NULL, .recv = hci_recv_diag },
Marcel Holtmann79b8df92015-04-05 23:44:59 -0700572};
573
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700574static int bcm_recv(struct hci_uart *hu, const void *data, int count)
575{
576 struct bcm_data *bcm = hu->priv;
577
578 if (!test_bit(HCI_UART_REGISTERED, &hu->flags))
579 return -EUNATCH;
580
Marcel Holtmann79b8df92015-04-05 23:44:59 -0700581 bcm->rx_skb = h4_recv_buf(hu->hdev, bcm->rx_skb, data, count,
582 bcm_recv_pkts, ARRAY_SIZE(bcm_recv_pkts));
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700583 if (IS_ERR(bcm->rx_skb)) {
584 int err = PTR_ERR(bcm->rx_skb);
Frederic Danis65ad07c2015-09-01 12:13:36 +0200585 bt_dev_err(hu->hdev, "Frame reassembly failed (%d)", err);
Chan-yeol Park37134162015-06-17 21:10:39 +0900586 bcm->rx_skb = NULL;
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700587 return err;
Frederic Danise88ab302015-09-23 18:18:11 +0200588 } else if (!bcm->rx_skb) {
589 /* Delay auto-suspend when receiving completed packet */
590 mutex_lock(&bcm_device_lock);
Hans de Goedeb09c6152018-03-14 23:06:02 +0100591 if (bcm->dev && bcm_device_exists(bcm->dev)) {
592 pm_runtime_get(bcm->dev->dev);
593 pm_runtime_mark_last_busy(bcm->dev->dev);
594 pm_runtime_put_autosuspend(bcm->dev->dev);
595 }
Frederic Danise88ab302015-09-23 18:18:11 +0200596 mutex_unlock(&bcm_device_lock);
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700597 }
598
599 return count;
600}
601
602static int bcm_enqueue(struct hci_uart *hu, struct sk_buff *skb)
603{
604 struct bcm_data *bcm = hu->priv;
605
Frederic Danis65ad07c2015-09-01 12:13:36 +0200606 bt_dev_dbg(hu->hdev, "hu %p skb %p", hu, skb);
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700607
608 /* Prepend skb with frame type */
Marcel Holtmann618e8bc2015-11-05 07:33:56 +0100609 memcpy(skb_push(skb, 1), &hci_skb_pkt_type(skb), 1);
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700610 skb_queue_tail(&bcm->txq, skb);
611
612 return 0;
613}
614
615static struct sk_buff *bcm_dequeue(struct hci_uart *hu)
616{
617 struct bcm_data *bcm = hu->priv;
Frederic Danise88ab302015-09-23 18:18:11 +0200618 struct sk_buff *skb = NULL;
619 struct bcm_device *bdev = NULL;
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700620
Frederic Danise88ab302015-09-23 18:18:11 +0200621 mutex_lock(&bcm_device_lock);
622
623 if (bcm_device_exists(bcm->dev)) {
624 bdev = bcm->dev;
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200625 pm_runtime_get_sync(bdev->dev);
Frederic Danise88ab302015-09-23 18:18:11 +0200626 /* Shall be resumed here */
627 }
628
629 skb = skb_dequeue(&bcm->txq);
630
631 if (bdev) {
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200632 pm_runtime_mark_last_busy(bdev->dev);
633 pm_runtime_put_autosuspend(bdev->dev);
Frederic Danise88ab302015-09-23 18:18:11 +0200634 }
635
636 mutex_unlock(&bcm_device_lock);
637
638 return skb;
Marcel Holtmannbdd88182015-04-05 22:52:18 -0700639}
640
Frederic Danisb7a622a2015-09-23 18:18:09 +0200641#ifdef CONFIG_PM
642static int bcm_suspend_device(struct device *dev)
Frederic Danis118612f2015-08-11 16:35:38 +0200643{
Hans de Goede78277d72017-10-04 20:43:42 +0200644 struct bcm_device *bdev = dev_get_drvdata(dev);
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100645 int err;
Frederic Danis118612f2015-08-11 16:35:38 +0200646
Frederic Danisb7a622a2015-09-23 18:18:09 +0200647 bt_dev_dbg(bdev, "");
Frederic Danis118612f2015-08-11 16:35:38 +0200648
Frederic Danisb7a622a2015-09-23 18:18:09 +0200649 if (!bdev->is_suspended && bdev->hu) {
Frederic Danis118612f2015-08-11 16:35:38 +0200650 hci_uart_set_flow_control(bdev->hu, true);
651
Frederic Danisb7a622a2015-09-23 18:18:09 +0200652 /* Once this returns, driver suspends BT via GPIO */
Frederic Danis118612f2015-08-11 16:35:38 +0200653 bdev->is_suspended = true;
654 }
655
656 /* Suspend the device */
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100657 err = bdev->set_device_wakeup(bdev, false);
658 if (err) {
659 if (bdev->is_suspended && bdev->hu) {
660 bdev->is_suspended = false;
661 hci_uart_set_flow_control(bdev->hu, false);
662 }
663 return -EBUSY;
664 }
665
Lukas Wunner3e81a4c2018-01-10 16:32:10 +0100666 bt_dev_dbg(bdev, "suspend, delaying 15 ms");
Lukas Wunnere4b9e5b2018-01-10 16:32:10 +0100667 msleep(15);
Frederic Danis118612f2015-08-11 16:35:38 +0200668
Frederic Danisb7a622a2015-09-23 18:18:09 +0200669 return 0;
670}
671
672static int bcm_resume_device(struct device *dev)
673{
Hans de Goede78277d72017-10-04 20:43:42 +0200674 struct bcm_device *bdev = dev_get_drvdata(dev);
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100675 int err;
Frederic Danisb7a622a2015-09-23 18:18:09 +0200676
677 bt_dev_dbg(bdev, "");
678
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100679 err = bdev->set_device_wakeup(bdev, true);
680 if (err) {
681 dev_err(dev, "Failed to power up\n");
682 return err;
683 }
684
Lukas Wunner3e81a4c2018-01-10 16:32:10 +0100685 bt_dev_dbg(bdev, "resume, delaying 15 ms");
Lukas Wunnere4b9e5b2018-01-10 16:32:10 +0100686 msleep(15);
Frederic Danisb7a622a2015-09-23 18:18:09 +0200687
688 /* When this executes, the device has woken up already */
689 if (bdev->is_suspended && bdev->hu) {
690 bdev->is_suspended = false;
691
692 hci_uart_set_flow_control(bdev->hu, false);
693 }
694
695 return 0;
696}
697#endif
698
699#ifdef CONFIG_PM_SLEEP
Hans de Goede8a920562017-10-04 20:43:43 +0200700/* suspend callback */
Frederic Danisb7a622a2015-09-23 18:18:09 +0200701static int bcm_suspend(struct device *dev)
702{
Hans de Goede78277d72017-10-04 20:43:42 +0200703 struct bcm_device *bdev = dev_get_drvdata(dev);
Frederic Danisb7a622a2015-09-23 18:18:09 +0200704 int error;
705
706 bt_dev_dbg(bdev, "suspend: is_suspended %d", bdev->is_suspended);
707
Hans de Goede8a920562017-10-04 20:43:43 +0200708 /*
709 * When used with a device instantiated as platform_device, bcm_suspend
710 * can be called at any time as long as the platform device is bound,
711 * so it should use bcm_device_lock to protect access to hci_uart
Frederic Danisb7a622a2015-09-23 18:18:09 +0200712 * and device_wake-up GPIO.
713 */
714 mutex_lock(&bcm_device_lock);
715
716 if (!bdev->hu)
717 goto unlock;
718
Frederic Danise88ab302015-09-23 18:18:11 +0200719 if (pm_runtime_active(dev))
720 bcm_suspend_device(dev);
Frederic Danisb7a622a2015-09-23 18:18:09 +0200721
Ronald Tschalär4a59f1f2018-01-10 16:32:10 +0100722 if (device_may_wakeup(dev) && bdev->irq > 0) {
Frederic Danis6cc43962015-09-04 15:35:44 +0200723 error = enable_irq_wake(bdev->irq);
724 if (!error)
725 bt_dev_dbg(bdev, "BCM irq: enabled");
726 }
727
Frederic Danis917522a2015-08-28 15:44:00 +0200728unlock:
Frederic Danisbb3ea162015-09-01 12:13:35 +0200729 mutex_unlock(&bcm_device_lock);
Frederic Danis917522a2015-08-28 15:44:00 +0200730
Frederic Danis118612f2015-08-11 16:35:38 +0200731 return 0;
732}
733
Hans de Goede8a920562017-10-04 20:43:43 +0200734/* resume callback */
Frederic Danis118612f2015-08-11 16:35:38 +0200735static int bcm_resume(struct device *dev)
736{
Hans de Goede78277d72017-10-04 20:43:42 +0200737 struct bcm_device *bdev = dev_get_drvdata(dev);
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100738 int err = 0;
Frederic Danis118612f2015-08-11 16:35:38 +0200739
Frederic Danis65ad07c2015-09-01 12:13:36 +0200740 bt_dev_dbg(bdev, "resume: is_suspended %d", bdev->is_suspended);
Frederic Danis118612f2015-08-11 16:35:38 +0200741
Hans de Goede8a920562017-10-04 20:43:43 +0200742 /*
743 * When used with a device instantiated as platform_device, bcm_resume
744 * can be called at any time as long as platform device is bound,
745 * so it should use bcm_device_lock to protect access to hci_uart
Frederic Danisb7a622a2015-09-23 18:18:09 +0200746 * and device_wake-up GPIO.
747 */
Frederic Danisbb3ea162015-09-01 12:13:35 +0200748 mutex_lock(&bcm_device_lock);
Frederic Danis917522a2015-08-28 15:44:00 +0200749
750 if (!bdev->hu)
751 goto unlock;
752
Ronald Tschalär4a59f1f2018-01-10 16:32:10 +0100753 if (device_may_wakeup(dev) && bdev->irq > 0) {
Frederic Danis6cc43962015-09-04 15:35:44 +0200754 disable_irq_wake(bdev->irq);
755 bt_dev_dbg(bdev, "BCM irq: disabled");
756 }
757
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100758 err = bcm_resume_device(dev);
Frederic Danis118612f2015-08-11 16:35:38 +0200759
Frederic Danis917522a2015-08-28 15:44:00 +0200760unlock:
Frederic Danisbb3ea162015-09-01 12:13:35 +0200761 mutex_unlock(&bcm_device_lock);
Frederic Danis917522a2015-08-28 15:44:00 +0200762
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +0100763 if (!err) {
764 pm_runtime_disable(dev);
765 pm_runtime_set_active(dev);
766 pm_runtime_enable(dev);
767 }
Frederic Danise88ab302015-09-23 18:18:11 +0200768
Frederic Danis118612f2015-08-11 16:35:38 +0200769 return 0;
770}
771#endif
772
Daniel Drake89ab37b2017-01-05 11:10:54 -0600773static const struct acpi_gpio_params int_last_device_wakeup_gpios = { 0, 0, false };
774static const struct acpi_gpio_params int_last_shutdown_gpios = { 1, 0, false };
775static const struct acpi_gpio_params int_last_host_wakeup_gpios = { 2, 0, false };
Frederic Danis0395ffc2015-08-11 16:35:35 +0200776
Daniel Drake89ab37b2017-01-05 11:10:54 -0600777static const struct acpi_gpio_mapping acpi_bcm_int_last_gpios[] = {
778 { "device-wakeup-gpios", &int_last_device_wakeup_gpios, 1 },
779 { "shutdown-gpios", &int_last_shutdown_gpios, 1 },
780 { "host-wakeup-gpios", &int_last_host_wakeup_gpios, 1 },
781 { },
782};
783
784static const struct acpi_gpio_params int_first_host_wakeup_gpios = { 0, 0, false };
785static const struct acpi_gpio_params int_first_device_wakeup_gpios = { 1, 0, false };
786static const struct acpi_gpio_params int_first_shutdown_gpios = { 2, 0, false };
787
788static const struct acpi_gpio_mapping acpi_bcm_int_first_gpios[] = {
789 { "device-wakeup-gpios", &int_first_device_wakeup_gpios, 1 },
790 { "shutdown-gpios", &int_first_shutdown_gpios, 1 },
791 { "host-wakeup-gpios", &int_first_host_wakeup_gpios, 1 },
Frederic Danis0395ffc2015-08-11 16:35:35 +0200792 { },
793};
794
Frederic Danis50d78bc2015-08-12 12:46:01 +0200795#ifdef CONFIG_ACPI
Frederic Danis5cebdfe2015-09-23 18:18:08 +0200796/* IRQ polarity of some chipsets are not defined correctly in ACPI table. */
Hans de Goede227630c2017-10-04 20:43:36 +0200797static const struct dmi_system_id bcm_active_low_irq_dmi_table[] = {
Frederic Danis5cebdfe2015-09-23 18:18:08 +0200798 {
799 .ident = "Asus T100TA",
800 .matches = {
801 DMI_EXACT_MATCH(DMI_SYS_VENDOR,
802 "ASUSTeK COMPUTER INC."),
803 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100TA"),
804 },
Frederic Danis5cebdfe2015-09-23 18:18:08 +0200805 },
Hans de Goedec4c285d2017-06-29 14:21:32 +0200806 {
807 .ident = "Asus T100CHI",
808 .matches = {
809 DMI_EXACT_MATCH(DMI_SYS_VENDOR,
810 "ASUSTeK COMPUTER INC."),
811 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "T100CHI"),
812 },
Hans de Goedec4c285d2017-06-29 14:21:32 +0200813 },
Jérôme de Bretagne5e2bd932016-10-09 15:51:05 +0200814 { /* Handle ThinkPad 8 tablets with BCM2E55 chipset ACPI ID */
815 .ident = "Lenovo ThinkPad 8",
816 .matches = {
817 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "LENOVO"),
818 DMI_EXACT_MATCH(DMI_PRODUCT_VERSION, "ThinkPad 8"),
819 },
Jérôme de Bretagne5e2bd932016-10-09 15:51:05 +0200820 },
Ian W MORRISON1bdb68b2017-10-07 17:15:25 +1100821 {
822 .ident = "MINIX Z83-4",
823 .matches = {
824 DMI_EXACT_MATCH(DMI_SYS_VENDOR, "MINIX"),
825 DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"),
826 },
827 },
Frederic Danis5cebdfe2015-09-23 18:18:08 +0200828 { }
829};
830
Frederic Danisae056902015-08-11 16:35:37 +0200831static int bcm_resource(struct acpi_resource *ares, void *data)
832{
833 struct bcm_device *dev = data;
Frederic Danis6cc43962015-09-04 15:35:44 +0200834 struct acpi_resource_extended_irq *irq;
835 struct acpi_resource_gpio *gpio;
836 struct acpi_resource_uart_serialbus *sb;
Frederic Danisae056902015-08-11 16:35:37 +0200837
Frederic Danis6cc43962015-09-04 15:35:44 +0200838 switch (ares->type) {
839 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
840 irq = &ares->data.extended_irq;
Hans de Goede227630c2017-10-04 20:43:36 +0200841 dev->irq_active_low = irq->polarity == ACPI_ACTIVE_LOW;
Frederic Danis6cc43962015-09-04 15:35:44 +0200842 break;
Frederic Danisae056902015-08-11 16:35:37 +0200843
Frederic Danis6cc43962015-09-04 15:35:44 +0200844 case ACPI_RESOURCE_TYPE_GPIO:
845 gpio = &ares->data.gpio;
846 if (gpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT)
Hans de Goede227630c2017-10-04 20:43:36 +0200847 dev->irq_active_low = gpio->polarity == ACPI_ACTIVE_LOW;
Frederic Danis6cc43962015-09-04 15:35:44 +0200848 break;
849
850 case ACPI_RESOURCE_TYPE_SERIAL_BUS:
Frederic Danisae056902015-08-11 16:35:37 +0200851 sb = &ares->data.uart_serial_bus;
Marcel Holtmann74183a12017-08-16 09:53:30 +0200852 if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_UART) {
Frederic Danisae056902015-08-11 16:35:37 +0200853 dev->init_speed = sb->default_baud_rate;
Marcel Holtmann74183a12017-08-16 09:53:30 +0200854 dev->oper_speed = 4000000;
855 }
Frederic Danis6cc43962015-09-04 15:35:44 +0200856 break;
857
858 default:
859 break;
Frederic Danisae056902015-08-11 16:35:37 +0200860 }
861
Hans de Goede9d54fd62017-10-04 20:43:41 +0200862 return 0;
Frederic Danisae056902015-08-11 16:35:37 +0200863}
Lukas Wunner4c331622018-01-10 16:32:10 +0100864
865static int bcm_apple_set_device_wakeup(struct bcm_device *dev, bool awake)
866{
867 if (ACPI_FAILURE(acpi_execute_simple_method(dev->btlp, NULL, !awake)))
868 return -EIO;
869
870 return 0;
871}
872
873static int bcm_apple_set_shutdown(struct bcm_device *dev, bool powered)
874{
875 if (ACPI_FAILURE(acpi_evaluate_object(powered ? dev->btpu : dev->btpd,
876 NULL, NULL, NULL)))
877 return -EIO;
878
879 return 0;
880}
881
882static int bcm_apple_get_resources(struct bcm_device *dev)
883{
884 struct acpi_device *adev = ACPI_COMPANION(dev->dev);
885 const union acpi_object *obj;
886
887 if (!adev ||
888 ACPI_FAILURE(acpi_get_handle(adev->handle, "BTLP", &dev->btlp)) ||
889 ACPI_FAILURE(acpi_get_handle(adev->handle, "BTPU", &dev->btpu)) ||
890 ACPI_FAILURE(acpi_get_handle(adev->handle, "BTPD", &dev->btpd)))
891 return -ENODEV;
892
893 if (!acpi_dev_get_property(adev, "baud", ACPI_TYPE_BUFFER, &obj) &&
894 obj->buffer.length == 8)
895 dev->init_speed = *(u64 *)obj->buffer.pointer;
896
897 dev->set_device_wakeup = bcm_apple_set_device_wakeup;
898 dev->set_shutdown = bcm_apple_set_shutdown;
899
900 return 0;
901}
902#else
903static inline int bcm_apple_get_resources(struct bcm_device *dev)
904{
905 return -EOPNOTSUPP;
906}
Andy Shevchenko212d71832017-03-10 14:28:20 +0200907#endif /* CONFIG_ACPI */
Frederic Danisae056902015-08-11 16:35:37 +0200908
Lukas Wunner8353b4a2018-01-10 16:32:10 +0100909static int bcm_gpio_set_device_wakeup(struct bcm_device *dev, bool awake)
910{
911 gpiod_set_value(dev->device_wakeup, awake);
912 return 0;
913}
914
915static int bcm_gpio_set_shutdown(struct bcm_device *dev, bool powered)
916{
917 gpiod_set_value(dev->shutdown, powered);
918 return 0;
919}
920
Hans de Goede42ef18f2017-10-04 20:43:40 +0200921static int bcm_get_resources(struct bcm_device *dev)
Frederic Danis0395ffc2015-08-11 16:35:35 +0200922{
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200923 dev->name = dev_name(dev->dev);
Frederic Danis0395ffc2015-08-11 16:35:35 +0200924
Lukas Wunner4c331622018-01-10 16:32:10 +0100925 if (x86_apple_machine && !bcm_apple_get_resources(dev))
926 return 0;
927
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200928 dev->clk = devm_clk_get(dev->dev, NULL);
Daniel Drake89ab37b2017-01-05 11:10:54 -0600929
Stefan Wahrenab2f3362018-02-25 15:10:52 +0100930 dev->device_wakeup = devm_gpiod_get_optional(dev->dev, "device-wakeup",
931 GPIOD_OUT_LOW);
Uwe Kleine-König62aaefa2015-08-12 09:20:56 +0200932 if (IS_ERR(dev->device_wakeup))
933 return PTR_ERR(dev->device_wakeup);
Frederic Danis0395ffc2015-08-11 16:35:35 +0200934
Stefan Wahrenab2f3362018-02-25 15:10:52 +0100935 dev->shutdown = devm_gpiod_get_optional(dev->dev, "shutdown",
936 GPIOD_OUT_LOW);
Uwe Kleine-König62aaefa2015-08-12 09:20:56 +0200937 if (IS_ERR(dev->shutdown))
938 return PTR_ERR(dev->shutdown);
Frederic Danis0395ffc2015-08-11 16:35:35 +0200939
Lukas Wunner8353b4a2018-01-10 16:32:10 +0100940 dev->set_device_wakeup = bcm_gpio_set_device_wakeup;
941 dev->set_shutdown = bcm_gpio_set_shutdown;
942
Frederic Danis6cc43962015-09-04 15:35:44 +0200943 /* IRQ can be declared in ACPI table as Interrupt or GpioInt */
Frederic Danis6cc43962015-09-04 15:35:44 +0200944 if (dev->irq <= 0) {
945 struct gpio_desc *gpio;
946
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200947 gpio = devm_gpiod_get_optional(dev->dev, "host-wakeup",
Frederic Danis6cc43962015-09-04 15:35:44 +0200948 GPIOD_IN);
949 if (IS_ERR(gpio))
950 return PTR_ERR(gpio);
951
952 dev->irq = gpiod_to_irq(gpio);
953 }
954
Lukas Wunner5954cdf2018-01-10 16:32:10 +0100955 dev_dbg(dev->dev, "BCM irq: %d\n", dev->irq);
Andy Shevchenko212d71832017-03-10 14:28:20 +0200956 return 0;
957}
958
959#ifdef CONFIG_ACPI
960static int bcm_acpi_probe(struct bcm_device *dev)
961{
Andy Shevchenko212d71832017-03-10 14:28:20 +0200962 LIST_HEAD(resources);
963 const struct dmi_system_id *dmi_id;
964 const struct acpi_gpio_mapping *gpio_mapping = acpi_bcm_int_last_gpios;
965 const struct acpi_device_id *id;
Hans de Goede9d54fd62017-10-04 20:43:41 +0200966 struct resource_entry *entry;
Andy Shevchenko212d71832017-03-10 14:28:20 +0200967 int ret;
968
969 /* Retrieve GPIO data */
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200970 id = acpi_match_device(dev->dev->driver->acpi_match_table, dev->dev);
Andy Shevchenko212d71832017-03-10 14:28:20 +0200971 if (id)
972 gpio_mapping = (const struct acpi_gpio_mapping *) id->driver_data;
973
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200974 ret = devm_acpi_dev_add_driver_gpios(dev->dev, gpio_mapping);
Andy Shevchenko212d71832017-03-10 14:28:20 +0200975 if (ret)
976 return ret;
977
Frederic Danisae056902015-08-11 16:35:37 +0200978 /* Retrieve UART ACPI info */
Hans de Goedec0d3ce52017-10-04 20:43:39 +0200979 ret = acpi_dev_get_resources(ACPI_COMPANION(dev->dev),
Jarkko Nikulae98d6d62015-09-30 16:26:45 +0300980 &resources, bcm_resource, dev);
Jarkko Nikula5be00282015-09-30 16:26:42 +0300981 if (ret < 0)
982 return ret;
Hans de Goede9d54fd62017-10-04 20:43:41 +0200983
984 resource_list_for_each_entry(entry, &resources) {
985 if (resource_type(entry->res) == IORESOURCE_IRQ) {
986 dev->irq = entry->res->start;
987 break;
988 }
989 }
Jarkko Nikula09dbf1b2015-09-30 16:26:41 +0300990 acpi_dev_free_resource_list(&resources);
Frederic Danisae056902015-08-11 16:35:37 +0200991
Hans de Goede227630c2017-10-04 20:43:36 +0200992 dmi_id = dmi_first_match(bcm_active_low_irq_dmi_table);
Frederic Danis5cebdfe2015-09-23 18:18:08 +0200993 if (dmi_id) {
Ian W MORRISONe8bfe862017-10-07 17:16:08 +1100994 dev_warn(dev->dev, "%s: Overwriting IRQ polarity to active low",
Frederic Danis5cebdfe2015-09-23 18:18:08 +0200995 dmi_id->ident);
Hans de Goede227630c2017-10-04 20:43:36 +0200996 dev->irq_active_low = true;
Frederic Danis5cebdfe2015-09-23 18:18:08 +0200997 }
998
Frederic Danis0395ffc2015-08-11 16:35:35 +0200999 return 0;
1000}
Frederic Danis50d78bc2015-08-12 12:46:01 +02001001#else
1002static int bcm_acpi_probe(struct bcm_device *dev)
1003{
1004 return -EINVAL;
1005}
1006#endif /* CONFIG_ACPI */
Frederic Danis0395ffc2015-08-11 16:35:35 +02001007
Hans de Goede8a920562017-10-04 20:43:43 +02001008static int bcm_of_probe(struct bcm_device *bdev)
1009{
1010 device_property_read_u32(bdev->dev, "max-speed", &bdev->oper_speed);
1011 return 0;
1012}
1013
Frederic Danis0395ffc2015-08-11 16:35:35 +02001014static int bcm_probe(struct platform_device *pdev)
1015{
1016 struct bcm_device *dev;
Frederic Danis0395ffc2015-08-11 16:35:35 +02001017 int ret;
1018
1019 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
1020 if (!dev)
1021 return -ENOMEM;
1022
Hans de Goedec0d3ce52017-10-04 20:43:39 +02001023 dev->dev = &pdev->dev;
Hans de Goede4a56f892017-10-04 20:43:38 +02001024 dev->irq = platform_get_irq(pdev, 0);
Frederic Danis0395ffc2015-08-11 16:35:35 +02001025
Hans de Goede201762e2017-10-04 20:43:37 +02001026 if (has_acpi_companion(&pdev->dev)) {
Andy Shevchenko212d71832017-03-10 14:28:20 +02001027 ret = bcm_acpi_probe(dev);
Hans de Goede201762e2017-10-04 20:43:37 +02001028 if (ret)
1029 return ret;
1030 }
1031
Hans de Goede42ef18f2017-10-04 20:43:40 +02001032 ret = bcm_get_resources(dev);
Jarkko Nikula4d1c4552015-09-30 16:26:44 +03001033 if (ret)
1034 return ret;
Frederic Danis0395ffc2015-08-11 16:35:35 +02001035
1036 platform_set_drvdata(pdev, dev);
1037
1038 dev_info(&pdev->dev, "%s device registered.\n", dev->name);
1039
1040 /* Place this instance on the device list */
Frederic Danisbb3ea162015-09-01 12:13:35 +02001041 mutex_lock(&bcm_device_lock);
Frederic Danis0395ffc2015-08-11 16:35:35 +02001042 list_add_tail(&dev->list, &bcm_device_list);
Frederic Danisbb3ea162015-09-01 12:13:35 +02001043 mutex_unlock(&bcm_device_lock);
Frederic Danis0395ffc2015-08-11 16:35:35 +02001044
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +01001045 ret = bcm_gpio_set_power(dev, false);
1046 if (ret)
1047 dev_err(&pdev->dev, "Failed to power down\n");
Frederic Danis0395ffc2015-08-11 16:35:35 +02001048
1049 return 0;
1050}
1051
1052static int bcm_remove(struct platform_device *pdev)
1053{
1054 struct bcm_device *dev = platform_get_drvdata(pdev);
1055
Frederic Danisbb3ea162015-09-01 12:13:35 +02001056 mutex_lock(&bcm_device_lock);
Frederic Danis0395ffc2015-08-11 16:35:35 +02001057 list_del(&dev->list);
Frederic Danisbb3ea162015-09-01 12:13:35 +02001058 mutex_unlock(&bcm_device_lock);
Frederic Danis0395ffc2015-08-11 16:35:35 +02001059
Frederic Danis0395ffc2015-08-11 16:35:35 +02001060 dev_info(&pdev->dev, "%s device unregistered.\n", dev->name);
1061
1062 return 0;
1063}
1064
Marcel Holtmannbdd88182015-04-05 22:52:18 -07001065static const struct hci_uart_proto bcm_proto = {
1066 .id = HCI_UART_BCM,
Loic Poulain143f0a22016-09-19 12:05:12 +02001067 .name = "Broadcom",
Marcel Holtmannaee61f72015-10-20 21:30:45 +02001068 .manufacturer = 15,
Frederic Danis61b2fc22015-06-09 16:15:37 +02001069 .init_speed = 115200,
Marcel Holtmannbdd88182015-04-05 22:52:18 -07001070 .open = bcm_open,
1071 .close = bcm_close,
1072 .flush = bcm_flush,
1073 .setup = bcm_setup,
Frederic Danis61b2fc22015-06-09 16:15:37 +02001074 .set_baudrate = bcm_set_baudrate,
Marcel Holtmannbdd88182015-04-05 22:52:18 -07001075 .recv = bcm_recv,
1076 .enqueue = bcm_enqueue,
1077 .dequeue = bcm_dequeue,
1078};
1079
Frederic Danis0395ffc2015-08-11 16:35:35 +02001080#ifdef CONFIG_ACPI
1081static const struct acpi_device_id bcm_acpi_match[] = {
Daniel Drake89ab37b2017-01-05 11:10:54 -06001082 { "BCM2E1A", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1083 { "BCM2E39", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1084 { "BCM2E3A", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1085 { "BCM2E3D", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1086 { "BCM2E3F", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1087 { "BCM2E40", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1088 { "BCM2E54", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1089 { "BCM2E55", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1090 { "BCM2E64", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1091 { "BCM2E65", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1092 { "BCM2E67", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1093 { "BCM2E71", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
Hans de Goedec23fae12017-11-22 14:37:28 +01001094 { "BCM2E72", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
Daniel Drake89ab37b2017-01-05 11:10:54 -06001095 { "BCM2E7B", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
1096 { "BCM2E7C", (kernel_ulong_t)&acpi_bcm_int_last_gpios },
Hans de Goede61d220a2017-10-13 17:54:02 +02001097 { "BCM2E7E", (kernel_ulong_t)&acpi_bcm_int_first_gpios },
Daniel Drake89ab37b2017-01-05 11:10:54 -06001098 { "BCM2E95", (kernel_ulong_t)&acpi_bcm_int_first_gpios },
1099 { "BCM2E96", (kernel_ulong_t)&acpi_bcm_int_first_gpios },
Ian W MORRISON1bdb68b2017-10-07 17:15:25 +11001100 { "BCM2EA4", (kernel_ulong_t)&acpi_bcm_int_first_gpios },
Frederic Danis0395ffc2015-08-11 16:35:35 +02001101 { },
1102};
1103MODULE_DEVICE_TABLE(acpi, bcm_acpi_match);
1104#endif
1105
Hans de Goede8a920562017-10-04 20:43:43 +02001106/* suspend and resume callbacks */
Frederic Danise88ab302015-09-23 18:18:11 +02001107static const struct dev_pm_ops bcm_pm_ops = {
1108 SET_SYSTEM_SLEEP_PM_OPS(bcm_suspend, bcm_resume)
1109 SET_RUNTIME_PM_OPS(bcm_suspend_device, bcm_resume_device, NULL)
1110};
Frederic Danis118612f2015-08-11 16:35:38 +02001111
Frederic Danis0395ffc2015-08-11 16:35:35 +02001112static struct platform_driver bcm_driver = {
1113 .probe = bcm_probe,
1114 .remove = bcm_remove,
1115 .driver = {
1116 .name = "hci_bcm",
1117 .acpi_match_table = ACPI_PTR(bcm_acpi_match),
Frederic Danis118612f2015-08-11 16:35:38 +02001118 .pm = &bcm_pm_ops,
Frederic Danis0395ffc2015-08-11 16:35:35 +02001119 },
1120};
1121
Loic Poulain33cd1492017-08-17 19:59:51 +02001122static int bcm_serdev_probe(struct serdev_device *serdev)
1123{
Hans de Goede8a920562017-10-04 20:43:43 +02001124 struct bcm_device *bcmdev;
Loic Poulain33cd1492017-08-17 19:59:51 +02001125 int err;
1126
1127 bcmdev = devm_kzalloc(&serdev->dev, sizeof(*bcmdev), GFP_KERNEL);
1128 if (!bcmdev)
1129 return -ENOMEM;
1130
Hans de Goede8a920562017-10-04 20:43:43 +02001131 bcmdev->dev = &serdev->dev;
Arnd Bergmann81a19052017-10-11 15:46:21 +02001132#ifdef CONFIG_PM
Hans de Goede8a920562017-10-04 20:43:43 +02001133 bcmdev->hu = &bcmdev->serdev_hu;
Arnd Bergmann81a19052017-10-11 15:46:21 +02001134#endif
Hans de Goede8a920562017-10-04 20:43:43 +02001135 bcmdev->serdev_hu.serdev = serdev;
Loic Poulain33cd1492017-08-17 19:59:51 +02001136 serdev_device_set_drvdata(serdev, bcmdev);
1137
Hans de Goede8a920562017-10-04 20:43:43 +02001138 if (has_acpi_companion(&serdev->dev))
1139 err = bcm_acpi_probe(bcmdev);
1140 else
1141 err = bcm_of_probe(bcmdev);
1142 if (err)
1143 return err;
Loic Poulain33cd1492017-08-17 19:59:51 +02001144
Hans de Goede8a920562017-10-04 20:43:43 +02001145 err = bcm_get_resources(bcmdev);
1146 if (err)
1147 return err;
1148
Lukas Wunner8bfa7e1e2018-01-10 16:32:10 +01001149 err = bcm_gpio_set_power(bcmdev, false);
1150 if (err)
1151 dev_err(&serdev->dev, "Failed to power down\n");
Hans de Goede8a920562017-10-04 20:43:43 +02001152
1153 return hci_uart_register_device(&bcmdev->serdev_hu, &bcm_proto);
Loic Poulain33cd1492017-08-17 19:59:51 +02001154}
1155
1156static void bcm_serdev_remove(struct serdev_device *serdev)
1157{
Hans de Goede8a920562017-10-04 20:43:43 +02001158 struct bcm_device *bcmdev = serdev_device_get_drvdata(serdev);
Loic Poulain33cd1492017-08-17 19:59:51 +02001159
Hans de Goede8a920562017-10-04 20:43:43 +02001160 hci_uart_unregister_device(&bcmdev->serdev_hu);
Loic Poulain33cd1492017-08-17 19:59:51 +02001161}
1162
1163#ifdef CONFIG_OF
1164static const struct of_device_id bcm_bluetooth_of_match[] = {
1165 { .compatible = "brcm,bcm43438-bt" },
1166 { },
1167};
1168MODULE_DEVICE_TABLE(of, bcm_bluetooth_of_match);
1169#endif
1170
1171static struct serdev_device_driver bcm_serdev_driver = {
1172 .probe = bcm_serdev_probe,
1173 .remove = bcm_serdev_remove,
1174 .driver = {
1175 .name = "hci_uart_bcm",
1176 .of_match_table = of_match_ptr(bcm_bluetooth_of_match),
Hans de Goede8a920562017-10-04 20:43:43 +02001177 .acpi_match_table = ACPI_PTR(bcm_acpi_match),
1178 .pm = &bcm_pm_ops,
Loic Poulain33cd1492017-08-17 19:59:51 +02001179 },
1180};
1181
Marcel Holtmannbdd88182015-04-05 22:52:18 -07001182int __init bcm_init(void)
1183{
Loic Poulain33cd1492017-08-17 19:59:51 +02001184 /* For now, we need to keep both platform device
1185 * driver (ACPI generated) and serdev driver (DT).
1186 */
Frederic Danis0395ffc2015-08-11 16:35:35 +02001187 platform_driver_register(&bcm_driver);
Loic Poulain33cd1492017-08-17 19:59:51 +02001188 serdev_device_driver_register(&bcm_serdev_driver);
Frederic Danis0395ffc2015-08-11 16:35:35 +02001189
Marcel Holtmannbdd88182015-04-05 22:52:18 -07001190 return hci_uart_register_proto(&bcm_proto);
1191}
1192
1193int __exit bcm_deinit(void)
1194{
Frederic Danis0395ffc2015-08-11 16:35:35 +02001195 platform_driver_unregister(&bcm_driver);
Loic Poulain33cd1492017-08-17 19:59:51 +02001196 serdev_device_driver_unregister(&bcm_serdev_driver);
Frederic Danis0395ffc2015-08-11 16:35:35 +02001197
Marcel Holtmannbdd88182015-04-05 22:52:18 -07001198 return hci_uart_unregister_proto(&bcm_proto);
1199}