1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2019 MediaTek Inc.
3
4 /*
5 * Bluetooth support for MediaTek SDIO devices
6 *
7 * This file is written based on btsdio.c and btmtkuart.c.
8 *
9 * Author: Sean Wang <sean.wang@mediatek.com>
10 *
11 */
12
13 #include <linux/unaligned.h>
14 #include <linux/atomic.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/init.h>
17 #include <linux/iopoll.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/of.h>
21 #include <linux/pm_runtime.h>
22 #include <linux/skbuff.h>
23 #include <linux/usb.h>
24
25 #include <linux/mmc/host.h>
26 #include <linux/mmc/sdio_ids.h>
27 #include <linux/mmc/sdio_func.h>
28
29 #include <net/bluetooth/bluetooth.h>
30 #include <net/bluetooth/hci_core.h>
31
32 #include "hci_uart.h"
33 #include "btmtk.h"
34
35 #define VERSION "0.1"
36
37 #define MTKBTSDIO_AUTOSUSPEND_DELAY 1000
38
39 static bool enable_autosuspend = true;
40
41 struct btmtksdio_data {
42 const char *fwname;
43 u16 chipid;
44 bool lp_mbox_supported;
45 };
46
47 static const struct btmtksdio_data mt7663_data = {
48 .fwname = FIRMWARE_MT7663,
49 .chipid = 0x7663,
50 .lp_mbox_supported = false,
51 };
52
53 static const struct btmtksdio_data mt7668_data = {
54 .fwname = FIRMWARE_MT7668,
55 .chipid = 0x7668,
56 .lp_mbox_supported = false,
57 };
58
59 static const struct btmtksdio_data mt7921_data = {
60 .fwname = FIRMWARE_MT7961,
61 .chipid = 0x7921,
62 .lp_mbox_supported = true,
63 };
64
65 static const struct sdio_device_id btmtksdio_table[] = {
66 {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7663),
67 .driver_data = (kernel_ulong_t)&mt7663_data },
68 {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7668),
69 .driver_data = (kernel_ulong_t)&mt7668_data },
70 {SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7961),
71 .driver_data = (kernel_ulong_t)&mt7921_data },
72 { } /* Terminating entry */
73 };
74 MODULE_DEVICE_TABLE(sdio, btmtksdio_table);
75
76 #define MTK_REG_CHLPCR 0x4 /* W1S */
77 #define C_INT_EN_SET BIT(0)
78 #define C_INT_EN_CLR BIT(1)
79 #define C_FW_OWN_REQ_SET BIT(8) /* For write */
80 #define C_COM_DRV_OWN BIT(8) /* For read */
81 #define C_FW_OWN_REQ_CLR BIT(9)
82
83 #define MTK_REG_CSDIOCSR 0x8
84 #define SDIO_RE_INIT_EN BIT(0)
85 #define SDIO_INT_CTL BIT(2)
86
87 #define MTK_REG_CHCR 0xc
88 #define C_INT_CLR_CTRL BIT(1)
89 #define BT_RST_DONE BIT(8)
90
91 /* CHISR have the same bits field definition with CHIER */
92 #define MTK_REG_CHISR 0x10
93 #define MTK_REG_CHIER 0x14
94 #define FW_OWN_BACK_INT BIT(0)
95 #define RX_DONE_INT BIT(1)
96 #define TX_EMPTY BIT(2)
97 #define TX_FIFO_OVERFLOW BIT(8)
98 #define FW_MAILBOX_INT BIT(15)
99 #define INT_MASK GENMASK(15, 0)
100 #define RX_PKT_LEN GENMASK(31, 16)
101
102 #define MTK_REG_CSICR 0xc0
103 #define CSICR_CLR_MBOX_ACK BIT(0)
104 #define MTK_REG_PH2DSM0R 0xc4
105 #define PH2DSM0R_DRIVER_OWN BIT(0)
106 #define MTK_REG_PD2HRM0R 0xdc
107 #define PD2HRM0R_DRV_OWN BIT(0)
108
109 #define MTK_REG_CTDR 0x18
110
111 #define MTK_REG_CRDR 0x1c
112
113 #define MTK_REG_CRPLR 0x24
114
115 #define MTK_SDIO_BLOCK_SIZE 256
116
117 #define BTMTKSDIO_TX_WAIT_VND_EVT 1
118 #define BTMTKSDIO_HW_TX_READY 2
119 #define BTMTKSDIO_FUNC_ENABLED 3
120 #define BTMTKSDIO_PATCH_ENABLED 4
121 #define BTMTKSDIO_HW_RESET_ACTIVE 5
122 #define BTMTKSDIO_BT_WAKE_ENABLED 6
123
124 struct mtkbtsdio_hdr {
125 __le16 len;
126 __le16 reserved;
127 u8 bt_type;
128 } __packed;
129
130 struct btmtksdio_dev {
131 struct hci_dev *hdev;
132 struct sdio_func *func;
133 struct device *dev;
134
135 struct work_struct txrx_work;
136 unsigned long tx_state;
137 struct sk_buff_head txq;
138
139 struct sk_buff *evt_skb;
140
141 const struct btmtksdio_data *data;
142
143 struct gpio_desc *reset;
144 };
145
mtk_hci_wmt_sync(struct hci_dev * hdev,struct btmtk_hci_wmt_params * wmt_params)146 static int mtk_hci_wmt_sync(struct hci_dev *hdev,
147 struct btmtk_hci_wmt_params *wmt_params)
148 {
149 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
150 struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
151 struct btmtk_hci_wmt_evt_reg *wmt_evt_reg;
152 u32 hlen, status = BTMTK_WMT_INVALID;
153 struct btmtk_hci_wmt_evt *wmt_evt;
154 struct btmtk_hci_wmt_cmd *wc;
155 struct btmtk_wmt_hdr *hdr;
156 int err;
157
158 /* Send the WMT command and wait until the WMT event returns */
159 hlen = sizeof(*hdr) + wmt_params->dlen;
160 if (hlen > 255)
161 return -EINVAL;
162
163 wc = kzalloc(hlen, GFP_KERNEL);
164 if (!wc)
165 return -ENOMEM;
166
167 hdr = &wc->hdr;
168 hdr->dir = 1;
169 hdr->op = wmt_params->op;
170 hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
171 hdr->flag = wmt_params->flag;
172 memcpy(wc->data, wmt_params->data, wmt_params->dlen);
173
174 set_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
175
176 err = __hci_cmd_send(hdev, 0xfc6f, hlen, wc);
177 if (err < 0) {
178 clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
179 goto err_free_wc;
180 }
181
182 /* The vendor specific WMT commands are all answered by a vendor
183 * specific event and will not have the Command Status or Command
184 * Complete as with usual HCI command flow control.
185 *
186 * After sending the command, wait for BTMTKSDIO_TX_WAIT_VND_EVT
187 * state to be cleared. The driver specific event receive routine
188 * will clear that state and with that indicate completion of the
189 * WMT command.
190 */
191 err = wait_on_bit_timeout(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT,
192 TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
193 if (err == -EINTR) {
194 bt_dev_err(hdev, "Execution of wmt command interrupted");
195 clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
196 goto err_free_wc;
197 }
198
199 if (err) {
200 bt_dev_err(hdev, "Execution of wmt command timed out");
201 clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
202 err = -ETIMEDOUT;
203 goto err_free_wc;
204 }
205
206 /* Parse and handle the return WMT event */
207 wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data;
208 if (wmt_evt->whdr.op != hdr->op) {
209 bt_dev_err(hdev, "Wrong op received %d expected %d",
210 wmt_evt->whdr.op, hdr->op);
211 err = -EIO;
212 goto err_free_skb;
213 }
214
215 switch (wmt_evt->whdr.op) {
216 case BTMTK_WMT_SEMAPHORE:
217 if (wmt_evt->whdr.flag == 2)
218 status = BTMTK_WMT_PATCH_UNDONE;
219 else
220 status = BTMTK_WMT_PATCH_DONE;
221 break;
222 case BTMTK_WMT_FUNC_CTRL:
223 wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
224 if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
225 status = BTMTK_WMT_ON_DONE;
226 else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
227 status = BTMTK_WMT_ON_PROGRESS;
228 else
229 status = BTMTK_WMT_ON_UNDONE;
230 break;
231 case BTMTK_WMT_PATCH_DWNLD:
232 if (wmt_evt->whdr.flag == 2)
233 status = BTMTK_WMT_PATCH_DONE;
234 else if (wmt_evt->whdr.flag == 1)
235 status = BTMTK_WMT_PATCH_PROGRESS;
236 else
237 status = BTMTK_WMT_PATCH_UNDONE;
238 break;
239 case BTMTK_WMT_REGISTER:
240 wmt_evt_reg = (struct btmtk_hci_wmt_evt_reg *)wmt_evt;
241 if (le16_to_cpu(wmt_evt->whdr.dlen) == 12)
242 status = le32_to_cpu(wmt_evt_reg->val);
243 break;
244 }
245
246 if (wmt_params->status)
247 *wmt_params->status = status;
248
249 err_free_skb:
250 kfree_skb(bdev->evt_skb);
251 bdev->evt_skb = NULL;
252 err_free_wc:
253 kfree(wc);
254
255 return err;
256 }
257
btmtksdio_tx_packet(struct btmtksdio_dev * bdev,struct sk_buff * skb)258 static int btmtksdio_tx_packet(struct btmtksdio_dev *bdev,
259 struct sk_buff *skb)
260 {
261 struct mtkbtsdio_hdr *sdio_hdr;
262 int err;
263
264 /* Make sure that there are enough rooms for SDIO header */
265 if (unlikely(skb_headroom(skb) < sizeof(*sdio_hdr))) {
266 err = pskb_expand_head(skb, sizeof(*sdio_hdr), 0,
267 GFP_ATOMIC);
268 if (err < 0)
269 return err;
270 }
271
272 /* Prepend MediaTek SDIO Specific Header */
273 skb_push(skb, sizeof(*sdio_hdr));
274
275 sdio_hdr = (void *)skb->data;
276 sdio_hdr->len = cpu_to_le16(skb->len);
277 sdio_hdr->reserved = cpu_to_le16(0);
278 sdio_hdr->bt_type = hci_skb_pkt_type(skb);
279
280 clear_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
281 err = sdio_writesb(bdev->func, MTK_REG_CTDR, skb->data,
282 round_up(skb->len, MTK_SDIO_BLOCK_SIZE));
283 if (err < 0)
284 goto err_skb_pull;
285
286 bdev->hdev->stat.byte_tx += skb->len;
287
288 kfree_skb(skb);
289
290 return 0;
291
292 err_skb_pull:
293 skb_pull(skb, sizeof(*sdio_hdr));
294
295 return err;
296 }
297
btmtksdio_drv_own_query(struct btmtksdio_dev * bdev)298 static u32 btmtksdio_drv_own_query(struct btmtksdio_dev *bdev)
299 {
300 return sdio_readl(bdev->func, MTK_REG_CHLPCR, NULL);
301 }
302
btmtksdio_drv_own_query_79xx(struct btmtksdio_dev * bdev)303 static u32 btmtksdio_drv_own_query_79xx(struct btmtksdio_dev *bdev)
304 {
305 return sdio_readl(bdev->func, MTK_REG_PD2HRM0R, NULL);
306 }
307
btmtksdio_chcr_query(struct btmtksdio_dev * bdev)308 static u32 btmtksdio_chcr_query(struct btmtksdio_dev *bdev)
309 {
310 return sdio_readl(bdev->func, MTK_REG_CHCR, NULL);
311 }
312
btmtksdio_fw_pmctrl(struct btmtksdio_dev * bdev)313 static int btmtksdio_fw_pmctrl(struct btmtksdio_dev *bdev)
314 {
315 u32 status;
316 int err;
317
318 sdio_claim_host(bdev->func);
319
320 if (bdev->data->lp_mbox_supported &&
321 test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state)) {
322 sdio_writel(bdev->func, CSICR_CLR_MBOX_ACK, MTK_REG_CSICR,
323 &err);
324 err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev,
325 status, !(status & PD2HRM0R_DRV_OWN),
326 2000, 1000000);
327 if (err < 0) {
328 bt_dev_err(bdev->hdev, "mailbox ACK not cleared");
329 goto out;
330 }
331 }
332
333 /* Return ownership to the device */
334 sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, &err);
335 if (err < 0)
336 goto out;
337
338 err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
339 !(status & C_COM_DRV_OWN), 2000, 1000000);
340
341 out:
342 sdio_release_host(bdev->func);
343
344 if (err < 0)
345 bt_dev_err(bdev->hdev, "Cannot return ownership to device");
346
347 return err;
348 }
349
btmtksdio_drv_pmctrl(struct btmtksdio_dev * bdev)350 static int btmtksdio_drv_pmctrl(struct btmtksdio_dev *bdev)
351 {
352 u32 status;
353 int err;
354
355 sdio_claim_host(bdev->func);
356
357 /* Get ownership from the device */
358 sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err);
359 if (err < 0)
360 goto out;
361
362 err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
363 status & C_COM_DRV_OWN, 2000, 1000000);
364
365 if (!err && bdev->data->lp_mbox_supported &&
366 test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state))
367 err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev,
368 status, status & PD2HRM0R_DRV_OWN,
369 2000, 1000000);
370
371 out:
372 sdio_release_host(bdev->func);
373
374 if (err < 0)
375 bt_dev_err(bdev->hdev, "Cannot get ownership from device");
376
377 return err;
378 }
379
btmtksdio_recv_event(struct hci_dev * hdev,struct sk_buff * skb)380 static int btmtksdio_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
381 {
382 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
383 struct hci_event_hdr *hdr = (void *)skb->data;
384 u8 evt = hdr->evt;
385 int err;
386
387 /* When someone waits for the WMT event, the skb is being cloned
388 * and being processed the events from there then.
389 */
390 if (test_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state)) {
391 bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
392 if (!bdev->evt_skb) {
393 err = -ENOMEM;
394 goto err_out;
395 }
396 }
397
398 err = hci_recv_frame(hdev, skb);
399 if (err < 0)
400 goto err_free_skb;
401
402 if (evt == HCI_EV_WMT) {
403 if (test_and_clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT,
404 &bdev->tx_state)) {
405 /* Barrier to sync with other CPUs */
406 smp_mb__after_atomic();
407 wake_up_bit(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT);
408 }
409 }
410
411 return 0;
412
413 err_free_skb:
414 kfree_skb(bdev->evt_skb);
415 bdev->evt_skb = NULL;
416
417 err_out:
418 return err;
419 }
420
btmtksdio_recv_acl(struct hci_dev * hdev,struct sk_buff * skb)421 static int btmtksdio_recv_acl(struct hci_dev *hdev, struct sk_buff *skb)
422 {
423 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
424 u16 handle = le16_to_cpu(hci_acl_hdr(skb)->handle);
425
426 switch (handle) {
427 case 0xfc6f:
428 /* Firmware dump from device: when the firmware hangs, the
429 * device can no longer suspend and thus disable auto-suspend.
430 */
431 pm_runtime_forbid(bdev->dev);
432 fallthrough;
433 case 0x05ff:
434 case 0x05fe:
435 /* Firmware debug logging */
436 return hci_recv_diag(hdev, skb);
437 }
438
439 return hci_recv_frame(hdev, skb);
440 }
441
442 static const struct h4_recv_pkt mtk_recv_pkts[] = {
443 { H4_RECV_ACL, .recv = btmtksdio_recv_acl },
444 { H4_RECV_SCO, .recv = hci_recv_frame },
445 { H4_RECV_EVENT, .recv = btmtksdio_recv_event },
446 };
447
btmtksdio_rx_packet(struct btmtksdio_dev * bdev,u16 rx_size)448 static int btmtksdio_rx_packet(struct btmtksdio_dev *bdev, u16 rx_size)
449 {
450 const struct h4_recv_pkt *pkts = mtk_recv_pkts;
451 int pkts_count = ARRAY_SIZE(mtk_recv_pkts);
452 struct mtkbtsdio_hdr *sdio_hdr;
453 int err, i, pad_size;
454 struct sk_buff *skb;
455 u16 dlen;
456
457 if (rx_size < sizeof(*sdio_hdr))
458 return -EILSEQ;
459
460 /* A SDIO packet is exactly containing a Bluetooth packet */
461 skb = bt_skb_alloc(rx_size, GFP_KERNEL);
462 if (!skb)
463 return -ENOMEM;
464
465 skb_put(skb, rx_size);
466
467 err = sdio_readsb(bdev->func, skb->data, MTK_REG_CRDR, rx_size);
468 if (err < 0)
469 goto err_kfree_skb;
470
471 sdio_hdr = (void *)skb->data;
472
473 /* We assume the default error as -EILSEQ simply to make the error path
474 * be cleaner.
475 */
476 err = -EILSEQ;
477
478 if (rx_size != le16_to_cpu(sdio_hdr->len)) {
479 bt_dev_err(bdev->hdev, "Rx size in sdio header is mismatched ");
480 goto err_kfree_skb;
481 }
482
483 hci_skb_pkt_type(skb) = sdio_hdr->bt_type;
484
485 /* Remove MediaTek SDIO header */
486 skb_pull(skb, sizeof(*sdio_hdr));
487
488 /* We have to dig into the packet to get payload size and then know how
489 * many padding bytes at the tail, these padding bytes should be removed
490 * before the packet is indicated to the core layer.
491 */
492 for (i = 0; i < pkts_count; i++) {
493 if (sdio_hdr->bt_type == (&pkts[i])->type)
494 break;
495 }
496
497 if (i >= pkts_count) {
498 bt_dev_err(bdev->hdev, "Invalid bt type 0x%02x",
499 sdio_hdr->bt_type);
500 goto err_kfree_skb;
501 }
502
503 /* Remaining bytes cannot hold a header*/
504 if (skb->len < (&pkts[i])->hlen) {
505 bt_dev_err(bdev->hdev, "The size of bt header is mismatched");
506 goto err_kfree_skb;
507 }
508
509 switch ((&pkts[i])->lsize) {
510 case 1:
511 dlen = skb->data[(&pkts[i])->loff];
512 break;
513 case 2:
514 dlen = get_unaligned_le16(skb->data +
515 (&pkts[i])->loff);
516 break;
517 default:
518 goto err_kfree_skb;
519 }
520
521 pad_size = skb->len - (&pkts[i])->hlen - dlen;
522
523 /* Remaining bytes cannot hold a payload */
524 if (pad_size < 0) {
525 bt_dev_err(bdev->hdev, "The size of bt payload is mismatched");
526 goto err_kfree_skb;
527 }
528
529 /* Remove padding bytes */
530 skb_trim(skb, skb->len - pad_size);
531
532 /* Complete frame */
533 (&pkts[i])->recv(bdev->hdev, skb);
534
535 bdev->hdev->stat.byte_rx += rx_size;
536
537 return 0;
538
539 err_kfree_skb:
540 kfree_skb(skb);
541
542 return err;
543 }
544
btmtksdio_txrx_work(struct work_struct * work)545 static void btmtksdio_txrx_work(struct work_struct *work)
546 {
547 struct btmtksdio_dev *bdev = container_of(work, struct btmtksdio_dev,
548 txrx_work);
549 unsigned long txrx_timeout;
550 u32 int_status, rx_size;
551 struct sk_buff *skb;
552 int err;
553
554 pm_runtime_get_sync(bdev->dev);
555
556 sdio_claim_host(bdev->func);
557
558 /* Disable interrupt */
559 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
560
561 txrx_timeout = jiffies + 5 * HZ;
562
563 do {
564 int_status = sdio_readl(bdev->func, MTK_REG_CHISR, NULL);
565
566 /* Ack an interrupt as soon as possible before any operation on
567 * hardware.
568 *
569 * Note that we don't ack any status during operations to avoid race
570 * condition between the host and the device such as it's possible to
571 * mistakenly ack RX_DONE for the next packet and then cause interrupts
572 * not be raised again but there is still pending data in the hardware
573 * FIFO.
574 */
575 sdio_writel(bdev->func, int_status, MTK_REG_CHISR, NULL);
576 int_status &= INT_MASK;
577
578 if ((int_status & FW_MAILBOX_INT) &&
579 bdev->data->chipid == 0x7921) {
580 sdio_writel(bdev->func, PH2DSM0R_DRIVER_OWN,
581 MTK_REG_PH2DSM0R, NULL);
582 }
583
584 if (int_status & FW_OWN_BACK_INT)
585 bt_dev_dbg(bdev->hdev, "Get fw own back");
586
587 if (int_status & TX_EMPTY)
588 set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
589
590 else if (unlikely(int_status & TX_FIFO_OVERFLOW))
591 bt_dev_warn(bdev->hdev, "Tx fifo overflow");
592
593 if (test_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state)) {
594 skb = skb_dequeue(&bdev->txq);
595 if (skb) {
596 err = btmtksdio_tx_packet(bdev, skb);
597 if (err < 0) {
598 bdev->hdev->stat.err_tx++;
599 skb_queue_head(&bdev->txq, skb);
600 }
601 }
602 }
603
604 if (int_status & RX_DONE_INT) {
605 rx_size = sdio_readl(bdev->func, MTK_REG_CRPLR, NULL);
606 rx_size = (rx_size & RX_PKT_LEN) >> 16;
607 if (btmtksdio_rx_packet(bdev, rx_size) < 0)
608 bdev->hdev->stat.err_rx++;
609 }
610 } while (int_status || time_is_before_jiffies(txrx_timeout));
611
612 /* Enable interrupt */
613 if (bdev->func->irq_handler)
614 sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, NULL);
615
616 sdio_release_host(bdev->func);
617
618 pm_runtime_put_autosuspend(bdev->dev);
619 }
620
btmtksdio_interrupt(struct sdio_func * func)621 static void btmtksdio_interrupt(struct sdio_func *func)
622 {
623 struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
624
625 if (test_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state)) {
626 if (bdev->hdev->suspended)
627 pm_wakeup_event(bdev->dev, 0);
628 clear_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state);
629 }
630
631 /* Disable interrupt */
632 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
633
634 schedule_work(&bdev->txrx_work);
635 }
636
btmtksdio_open(struct hci_dev * hdev)637 static int btmtksdio_open(struct hci_dev *hdev)
638 {
639 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
640 u32 val;
641 int err;
642
643 sdio_claim_host(bdev->func);
644
645 err = sdio_enable_func(bdev->func);
646 if (err < 0)
647 goto err_release_host;
648
649 set_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state);
650
651 err = btmtksdio_drv_pmctrl(bdev);
652 if (err < 0)
653 goto err_disable_func;
654
655 /* Disable interrupt & mask out all interrupt sources */
656 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, &err);
657 if (err < 0)
658 goto err_disable_func;
659
660 sdio_writel(bdev->func, 0, MTK_REG_CHIER, &err);
661 if (err < 0)
662 goto err_disable_func;
663
664 err = sdio_claim_irq(bdev->func, btmtksdio_interrupt);
665 if (err < 0)
666 goto err_disable_func;
667
668 err = sdio_set_block_size(bdev->func, MTK_SDIO_BLOCK_SIZE);
669 if (err < 0)
670 goto err_release_irq;
671
672 /* SDIO CMD 5 allows the SDIO device back to idle state an
673 * synchronous interrupt is supported in SDIO 4-bit mode
674 */
675 val = sdio_readl(bdev->func, MTK_REG_CSDIOCSR, &err);
676 if (err < 0)
677 goto err_release_irq;
678
679 val |= SDIO_INT_CTL;
680 sdio_writel(bdev->func, val, MTK_REG_CSDIOCSR, &err);
681 if (err < 0)
682 goto err_release_irq;
683
684 /* Explicitly set write-1-clear method */
685 val = sdio_readl(bdev->func, MTK_REG_CHCR, &err);
686 if (err < 0)
687 goto err_release_irq;
688
689 val |= C_INT_CLR_CTRL;
690 sdio_writel(bdev->func, val, MTK_REG_CHCR, &err);
691 if (err < 0)
692 goto err_release_irq;
693
694 /* Setup interrupt sources */
695 sdio_writel(bdev->func, RX_DONE_INT | TX_EMPTY | TX_FIFO_OVERFLOW,
696 MTK_REG_CHIER, &err);
697 if (err < 0)
698 goto err_release_irq;
699
700 /* Enable interrupt */
701 sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, &err);
702 if (err < 0)
703 goto err_release_irq;
704
705 sdio_release_host(bdev->func);
706
707 return 0;
708
709 err_release_irq:
710 sdio_release_irq(bdev->func);
711
712 err_disable_func:
713 sdio_disable_func(bdev->func);
714
715 err_release_host:
716 sdio_release_host(bdev->func);
717
718 return err;
719 }
720
btmtksdio_close(struct hci_dev * hdev)721 static int btmtksdio_close(struct hci_dev *hdev)
722 {
723 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
724
725 /* Skip btmtksdio_close if BTMTKSDIO_FUNC_ENABLED isn't set */
726 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
727 return 0;
728
729 sdio_claim_host(bdev->func);
730
731 /* Disable interrupt */
732 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
733
734 sdio_release_irq(bdev->func);
735
736 cancel_work_sync(&bdev->txrx_work);
737
738 btmtksdio_fw_pmctrl(bdev);
739
740 clear_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state);
741 sdio_disable_func(bdev->func);
742
743 sdio_release_host(bdev->func);
744
745 return 0;
746 }
747
btmtksdio_flush(struct hci_dev * hdev)748 static int btmtksdio_flush(struct hci_dev *hdev)
749 {
750 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
751
752 skb_queue_purge(&bdev->txq);
753
754 cancel_work_sync(&bdev->txrx_work);
755
756 return 0;
757 }
758
btmtksdio_func_query(struct hci_dev * hdev)759 static int btmtksdio_func_query(struct hci_dev *hdev)
760 {
761 struct btmtk_hci_wmt_params wmt_params;
762 int status, err;
763 u8 param = 0;
764
765 /* Query whether the function is enabled */
766 wmt_params.op = BTMTK_WMT_FUNC_CTRL;
767 wmt_params.flag = 4;
768 wmt_params.dlen = sizeof(param);
769 wmt_params.data = ¶m;
770 wmt_params.status = &status;
771
772 err = mtk_hci_wmt_sync(hdev, &wmt_params);
773 if (err < 0) {
774 bt_dev_err(hdev, "Failed to query function status (%d)", err);
775 return err;
776 }
777
778 return status;
779 }
780
mt76xx_setup(struct hci_dev * hdev,const char * fwname)781 static int mt76xx_setup(struct hci_dev *hdev, const char *fwname)
782 {
783 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
784 struct btmtk_hci_wmt_params wmt_params;
785 struct btmtk_tci_sleep tci_sleep;
786 struct sk_buff *skb;
787 int err, status;
788 u8 param = 0x1;
789
790 /* Query whether the firmware is already download */
791 wmt_params.op = BTMTK_WMT_SEMAPHORE;
792 wmt_params.flag = 1;
793 wmt_params.dlen = 0;
794 wmt_params.data = NULL;
795 wmt_params.status = &status;
796
797 err = mtk_hci_wmt_sync(hdev, &wmt_params);
798 if (err < 0) {
799 bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
800 return err;
801 }
802
803 if (status == BTMTK_WMT_PATCH_DONE) {
804 bt_dev_info(hdev, "Firmware already downloaded");
805 goto ignore_setup_fw;
806 }
807
808 /* Setup a firmware which the device definitely requires */
809 err = btmtk_setup_firmware(hdev, fwname, mtk_hci_wmt_sync);
810 if (err < 0)
811 return err;
812
813 ignore_setup_fw:
814 /* Query whether the device is already enabled */
815 err = readx_poll_timeout(btmtksdio_func_query, hdev, status,
816 status < 0 || status != BTMTK_WMT_ON_PROGRESS,
817 2000, 5000000);
818 /* -ETIMEDOUT happens */
819 if (err < 0)
820 return err;
821
822 /* The other errors happen in btusb_mtk_func_query */
823 if (status < 0)
824 return status;
825
826 if (status == BTMTK_WMT_ON_DONE) {
827 bt_dev_info(hdev, "function already on");
828 goto ignore_func_on;
829 }
830
831 /* Enable Bluetooth protocol */
832 wmt_params.op = BTMTK_WMT_FUNC_CTRL;
833 wmt_params.flag = 0;
834 wmt_params.dlen = sizeof(param);
835 wmt_params.data = ¶m;
836 wmt_params.status = NULL;
837
838 err = mtk_hci_wmt_sync(hdev, &wmt_params);
839 if (err < 0) {
840 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
841 return err;
842 }
843
844 set_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state);
845
846 ignore_func_on:
847 /* Apply the low power environment setup */
848 tci_sleep.mode = 0x5;
849 tci_sleep.duration = cpu_to_le16(0x640);
850 tci_sleep.host_duration = cpu_to_le16(0x640);
851 tci_sleep.host_wakeup_pin = 0;
852 tci_sleep.time_compensation = 0;
853
854 skb = __hci_cmd_sync(hdev, 0xfc7a, sizeof(tci_sleep), &tci_sleep,
855 HCI_INIT_TIMEOUT);
856 if (IS_ERR(skb)) {
857 err = PTR_ERR(skb);
858 bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
859 return err;
860 }
861 kfree_skb(skb);
862
863 return 0;
864 }
865
mt79xx_setup(struct hci_dev * hdev,const char * fwname)866 static int mt79xx_setup(struct hci_dev *hdev, const char *fwname)
867 {
868 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
869 struct btmtk_hci_wmt_params wmt_params;
870 u8 param = 0x1;
871 int err;
872
873 err = btmtk_setup_firmware_79xx(hdev, fwname, mtk_hci_wmt_sync);
874 if (err < 0) {
875 bt_dev_err(hdev, "Failed to setup 79xx firmware (%d)", err);
876 return err;
877 }
878
879 err = btmtksdio_fw_pmctrl(bdev);
880 if (err < 0)
881 return err;
882
883 err = btmtksdio_drv_pmctrl(bdev);
884 if (err < 0)
885 return err;
886
887 /* Enable Bluetooth protocol */
888 wmt_params.op = BTMTK_WMT_FUNC_CTRL;
889 wmt_params.flag = 0;
890 wmt_params.dlen = sizeof(param);
891 wmt_params.data = ¶m;
892 wmt_params.status = NULL;
893
894 err = mtk_hci_wmt_sync(hdev, &wmt_params);
895 if (err < 0) {
896 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
897 return err;
898 }
899
900 hci_set_msft_opcode(hdev, 0xFD30);
901 hci_set_aosp_capable(hdev);
902 set_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state);
903
904 return err;
905 }
906
btmtksdio_mtk_reg_read(struct hci_dev * hdev,u32 reg,u32 * val)907 static int btmtksdio_mtk_reg_read(struct hci_dev *hdev, u32 reg, u32 *val)
908 {
909 struct btmtk_hci_wmt_params wmt_params;
910 struct reg_read_cmd reg_read = {
911 .type = 1,
912 .num = 1,
913 };
914 u32 status;
915 int err;
916
917 reg_read.addr = cpu_to_le32(reg);
918 wmt_params.op = BTMTK_WMT_REGISTER;
919 wmt_params.flag = BTMTK_WMT_REG_READ;
920 wmt_params.dlen = sizeof(reg_read);
921 wmt_params.data = ®_read;
922 wmt_params.status = &status;
923
924 err = mtk_hci_wmt_sync(hdev, &wmt_params);
925 if (err < 0) {
926 bt_dev_err(hdev, "Failed to read reg (%d)", err);
927 return err;
928 }
929
930 *val = status;
931
932 return err;
933 }
934
btmtksdio_mtk_reg_write(struct hci_dev * hdev,u32 reg,u32 val,u32 mask)935 static int btmtksdio_mtk_reg_write(struct hci_dev *hdev, u32 reg, u32 val, u32 mask)
936 {
937 struct btmtk_hci_wmt_params wmt_params;
938 const struct reg_write_cmd reg_write = {
939 .type = 1,
940 .num = 1,
941 .addr = cpu_to_le32(reg),
942 .data = cpu_to_le32(val),
943 .mask = cpu_to_le32(mask),
944 };
945 int err, status;
946
947 wmt_params.op = BTMTK_WMT_REGISTER;
948 wmt_params.flag = BTMTK_WMT_REG_WRITE;
949 wmt_params.dlen = sizeof(reg_write);
950 wmt_params.data = ®_write;
951 wmt_params.status = &status;
952
953 err = mtk_hci_wmt_sync(hdev, &wmt_params);
954 if (err < 0)
955 bt_dev_err(hdev, "Failed to write reg (%d)", err);
956
957 return err;
958 }
959
btmtksdio_get_data_path_id(struct hci_dev * hdev,__u8 * data_path_id)960 static int btmtksdio_get_data_path_id(struct hci_dev *hdev, __u8 *data_path_id)
961 {
962 /* uses 1 as data path id for all the usecases */
963 *data_path_id = 1;
964 return 0;
965 }
966
btmtksdio_get_codec_config_data(struct hci_dev * hdev,__u8 link,struct bt_codec * codec,__u8 * ven_len,__u8 ** ven_data)967 static int btmtksdio_get_codec_config_data(struct hci_dev *hdev,
968 __u8 link, struct bt_codec *codec,
969 __u8 *ven_len, __u8 **ven_data)
970 {
971 int err = 0;
972
973 if (!ven_data || !ven_len)
974 return -EINVAL;
975
976 *ven_len = 0;
977 *ven_data = NULL;
978
979 if (link != ESCO_LINK) {
980 bt_dev_err(hdev, "Invalid link type(%u)", link);
981 return -EINVAL;
982 }
983
984 *ven_data = kmalloc(sizeof(__u8), GFP_KERNEL);
985 if (!*ven_data) {
986 err = -ENOMEM;
987 goto error;
988 }
989
990 /* supports only CVSD and mSBC offload codecs */
991 switch (codec->id) {
992 case 0x02:
993 **ven_data = 0x00;
994 break;
995 case 0x05:
996 **ven_data = 0x01;
997 break;
998 default:
999 err = -EINVAL;
1000 bt_dev_err(hdev, "Invalid codec id(%u)", codec->id);
1001 goto error;
1002 }
1003 /* codec and its capabilities are pre-defined to ids
1004 * preset id = 0x00 represents CVSD codec with sampling rate 8K
1005 * preset id = 0x01 represents mSBC codec with sampling rate 16K
1006 */
1007 *ven_len = sizeof(__u8);
1008 return err;
1009
1010 error:
1011 kfree(*ven_data);
1012 *ven_data = NULL;
1013 return err;
1014 }
1015
btmtksdio_sco_setting(struct hci_dev * hdev)1016 static int btmtksdio_sco_setting(struct hci_dev *hdev)
1017 {
1018 const struct btmtk_sco sco_setting = {
1019 .clock_config = 0x49,
1020 .channel_format_config = 0x80,
1021 };
1022 struct sk_buff *skb;
1023 u32 val;
1024 int err;
1025
1026 /* Enable SCO over I2S/PCM for MediaTek chipset */
1027 skb = __hci_cmd_sync(hdev, 0xfc72, sizeof(sco_setting),
1028 &sco_setting, HCI_CMD_TIMEOUT);
1029 if (IS_ERR(skb))
1030 return PTR_ERR(skb);
1031
1032 kfree_skb(skb);
1033
1034 err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_0, &val);
1035 if (err < 0)
1036 return err;
1037
1038 val |= 0x11000000;
1039 err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_0, val, ~0);
1040 if (err < 0)
1041 return err;
1042
1043 err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, &val);
1044 if (err < 0)
1045 return err;
1046
1047 val |= 0x00000101;
1048 err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, ~0);
1049 if (err < 0)
1050 return err;
1051
1052 hdev->get_data_path_id = btmtksdio_get_data_path_id;
1053 hdev->get_codec_config_data = btmtksdio_get_codec_config_data;
1054
1055 return err;
1056 }
1057
btmtksdio_reset_setting(struct hci_dev * hdev)1058 static int btmtksdio_reset_setting(struct hci_dev *hdev)
1059 {
1060 int err;
1061 u32 val;
1062
1063 err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, &val);
1064 if (err < 0)
1065 return err;
1066
1067 val |= 0x20; /* set the pin (bit field 11:8) work as GPIO mode */
1068 err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, ~0);
1069 if (err < 0)
1070 return err;
1071
1072 err = btmtksdio_mtk_reg_read(hdev, MT7921_BTSYS_RST, &val);
1073 if (err < 0)
1074 return err;
1075
1076 val |= MT7921_BTSYS_RST_WITH_GPIO;
1077 return btmtksdio_mtk_reg_write(hdev, MT7921_BTSYS_RST, val, ~0);
1078 }
1079
btmtksdio_setup(struct hci_dev * hdev)1080 static int btmtksdio_setup(struct hci_dev *hdev)
1081 {
1082 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1083 ktime_t calltime, delta, rettime;
1084 unsigned long long duration;
1085 char fwname[64];
1086 int err, dev_id;
1087 u32 fw_version = 0, val;
1088
1089 calltime = ktime_get();
1090 set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
1091
1092 switch (bdev->data->chipid) {
1093 case 0x7921:
1094 if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state)) {
1095 err = btmtksdio_mtk_reg_read(hdev, MT7921_DLSTATUS,
1096 &val);
1097 if (err < 0)
1098 return err;
1099
1100 val &= ~BT_DL_STATE;
1101 err = btmtksdio_mtk_reg_write(hdev, MT7921_DLSTATUS,
1102 val, ~0);
1103 if (err < 0)
1104 return err;
1105
1106 btmtksdio_fw_pmctrl(bdev);
1107 msleep(20);
1108 btmtksdio_drv_pmctrl(bdev);
1109
1110 clear_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state);
1111 }
1112
1113 err = btmtksdio_mtk_reg_read(hdev, 0x70010200, &dev_id);
1114 if (err < 0) {
1115 bt_dev_err(hdev, "Failed to get device id (%d)", err);
1116 return err;
1117 }
1118
1119 err = btmtksdio_mtk_reg_read(hdev, 0x80021004, &fw_version);
1120 if (err < 0) {
1121 bt_dev_err(hdev, "Failed to get fw version (%d)", err);
1122 return err;
1123 }
1124
1125 btmtk_fw_get_filename(fwname, sizeof(fwname), dev_id,
1126 fw_version, 0);
1127
1128 snprintf(fwname, sizeof(fwname),
1129 "mediatek/BT_RAM_CODE_MT%04x_1_%x_hdr.bin",
1130 dev_id & 0xffff, (fw_version & 0xff) + 1);
1131 err = mt79xx_setup(hdev, fwname);
1132 if (err < 0)
1133 return err;
1134
1135 /* Enable SCO over I2S/PCM */
1136 err = btmtksdio_sco_setting(hdev);
1137 if (err < 0) {
1138 bt_dev_err(hdev, "Failed to enable SCO setting (%d)", err);
1139 return err;
1140 }
1141
1142 /* Enable WBS with mSBC codec */
1143 hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
1144
1145 /* Enable GPIO reset mechanism */
1146 if (bdev->reset) {
1147 err = btmtksdio_reset_setting(hdev);
1148 if (err < 0) {
1149 bt_dev_err(hdev, "Failed to enable Reset setting (%d)", err);
1150 devm_gpiod_put(bdev->dev, bdev->reset);
1151 bdev->reset = NULL;
1152 }
1153 }
1154
1155 break;
1156 case 0x7663:
1157 case 0x7668:
1158 err = mt76xx_setup(hdev, bdev->data->fwname);
1159 if (err < 0)
1160 return err;
1161 break;
1162 default:
1163 return -ENODEV;
1164 }
1165
1166 rettime = ktime_get();
1167 delta = ktime_sub(rettime, calltime);
1168 duration = (unsigned long long)ktime_to_ns(delta) >> 10;
1169
1170 pm_runtime_set_autosuspend_delay(bdev->dev,
1171 MTKBTSDIO_AUTOSUSPEND_DELAY);
1172 pm_runtime_use_autosuspend(bdev->dev);
1173
1174 err = pm_runtime_set_active(bdev->dev);
1175 if (err < 0)
1176 return err;
1177
1178 /* Default forbid runtime auto suspend, that can be allowed by
1179 * enable_autosuspend flag or the PM runtime entry under sysfs.
1180 */
1181 pm_runtime_forbid(bdev->dev);
1182 pm_runtime_enable(bdev->dev);
1183
1184 if (enable_autosuspend)
1185 pm_runtime_allow(bdev->dev);
1186
1187 bt_dev_info(hdev, "Device setup in %llu usecs", duration);
1188
1189 return 0;
1190 }
1191
btmtksdio_shutdown(struct hci_dev * hdev)1192 static int btmtksdio_shutdown(struct hci_dev *hdev)
1193 {
1194 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1195 struct btmtk_hci_wmt_params wmt_params;
1196 u8 param = 0x0;
1197 int err;
1198
1199 /* Get back the state to be consistent with the state
1200 * in btmtksdio_setup.
1201 */
1202 pm_runtime_get_sync(bdev->dev);
1203
1204 /* wmt command only works until the reset is complete */
1205 if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state))
1206 goto ignore_wmt_cmd;
1207
1208 /* Disable the device */
1209 wmt_params.op = BTMTK_WMT_FUNC_CTRL;
1210 wmt_params.flag = 0;
1211 wmt_params.dlen = sizeof(param);
1212 wmt_params.data = ¶m;
1213 wmt_params.status = NULL;
1214
1215 err = mtk_hci_wmt_sync(hdev, &wmt_params);
1216 if (err < 0) {
1217 bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
1218 return err;
1219 }
1220
1221 ignore_wmt_cmd:
1222 pm_runtime_put_noidle(bdev->dev);
1223 pm_runtime_disable(bdev->dev);
1224
1225 return 0;
1226 }
1227
btmtksdio_send_frame(struct hci_dev * hdev,struct sk_buff * skb)1228 static int btmtksdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
1229 {
1230 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1231
1232 switch (hci_skb_pkt_type(skb)) {
1233 case HCI_COMMAND_PKT:
1234 hdev->stat.cmd_tx++;
1235 break;
1236
1237 case HCI_ACLDATA_PKT:
1238 hdev->stat.acl_tx++;
1239 break;
1240
1241 case HCI_SCODATA_PKT:
1242 hdev->stat.sco_tx++;
1243 break;
1244
1245 default:
1246 return -EILSEQ;
1247 }
1248
1249 skb_queue_tail(&bdev->txq, skb);
1250
1251 schedule_work(&bdev->txrx_work);
1252
1253 return 0;
1254 }
1255
btmtksdio_reset(struct hci_dev * hdev)1256 static void btmtksdio_reset(struct hci_dev *hdev)
1257 {
1258 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1259 u32 status;
1260 int err;
1261
1262 if (!bdev->reset || bdev->data->chipid != 0x7921)
1263 return;
1264
1265 pm_runtime_get_sync(bdev->dev);
1266
1267 if (test_and_set_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state))
1268 return;
1269
1270 sdio_claim_host(bdev->func);
1271
1272 /* set drv_pmctrl if BT is closed before doing reset */
1273 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) {
1274 sdio_enable_func(bdev->func);
1275 btmtksdio_drv_pmctrl(bdev);
1276 }
1277
1278 sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
1279 skb_queue_purge(&bdev->txq);
1280 cancel_work_sync(&bdev->txrx_work);
1281
1282 gpiod_set_value_cansleep(bdev->reset, 1);
1283 msleep(100);
1284 gpiod_set_value_cansleep(bdev->reset, 0);
1285
1286 err = readx_poll_timeout(btmtksdio_chcr_query, bdev, status,
1287 status & BT_RST_DONE, 100000, 2000000);
1288 if (err < 0) {
1289 bt_dev_err(hdev, "Failed to reset (%d)", err);
1290 goto err;
1291 }
1292
1293 /* set fw_pmctrl back if BT is closed after doing reset */
1294 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) {
1295 btmtksdio_fw_pmctrl(bdev);
1296 sdio_disable_func(bdev->func);
1297 }
1298
1299 clear_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state);
1300 err:
1301 sdio_release_host(bdev->func);
1302
1303 pm_runtime_put_noidle(bdev->dev);
1304 pm_runtime_disable(bdev->dev);
1305
1306 hci_reset_dev(hdev);
1307 }
1308
btmtksdio_sdio_inband_wakeup(struct hci_dev * hdev)1309 static bool btmtksdio_sdio_inband_wakeup(struct hci_dev *hdev)
1310 {
1311 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1312
1313 return device_may_wakeup(bdev->dev);
1314 }
1315
btmtksdio_sdio_wakeup(struct hci_dev * hdev)1316 static bool btmtksdio_sdio_wakeup(struct hci_dev *hdev)
1317 {
1318 struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1319 bool may_wakeup = device_may_wakeup(bdev->dev);
1320 const struct btmtk_wakeon bt_awake = {
1321 .mode = 0x1,
1322 .gpo = 0,
1323 .active_high = 0x1,
1324 .enable_delay = cpu_to_le16(0xc80),
1325 .wakeup_delay = cpu_to_le16(0x20),
1326 };
1327
1328 if (may_wakeup && bdev->data->chipid == 0x7921) {
1329 struct sk_buff *skb;
1330
1331 skb = __hci_cmd_sync(hdev, 0xfc27, sizeof(bt_awake),
1332 &bt_awake, HCI_CMD_TIMEOUT);
1333 if (IS_ERR(skb))
1334 may_wakeup = false;
1335 else
1336 kfree_skb(skb);
1337 }
1338
1339 return may_wakeup;
1340 }
1341
btmtksdio_probe(struct sdio_func * func,const struct sdio_device_id * id)1342 static int btmtksdio_probe(struct sdio_func *func,
1343 const struct sdio_device_id *id)
1344 {
1345 struct btmtksdio_dev *bdev;
1346 struct hci_dev *hdev;
1347 struct device_node *old_node;
1348 bool restore_node;
1349 int err;
1350
1351 bdev = devm_kzalloc(&func->dev, sizeof(*bdev), GFP_KERNEL);
1352 if (!bdev)
1353 return -ENOMEM;
1354
1355 bdev->data = (void *)id->driver_data;
1356 if (!bdev->data)
1357 return -ENODEV;
1358
1359 bdev->dev = &func->dev;
1360 bdev->func = func;
1361
1362 INIT_WORK(&bdev->txrx_work, btmtksdio_txrx_work);
1363 skb_queue_head_init(&bdev->txq);
1364
1365 /* Initialize and register HCI device */
1366 hdev = hci_alloc_dev();
1367 if (!hdev) {
1368 dev_err(&func->dev, "Can't allocate HCI device\n");
1369 return -ENOMEM;
1370 }
1371
1372 bdev->hdev = hdev;
1373
1374 hdev->bus = HCI_SDIO;
1375 hci_set_drvdata(hdev, bdev);
1376
1377 hdev->open = btmtksdio_open;
1378 hdev->close = btmtksdio_close;
1379 hdev->reset = btmtksdio_reset;
1380 hdev->flush = btmtksdio_flush;
1381 hdev->setup = btmtksdio_setup;
1382 hdev->shutdown = btmtksdio_shutdown;
1383 hdev->send = btmtksdio_send_frame;
1384 hdev->wakeup = btmtksdio_sdio_wakeup;
1385 /*
1386 * If SDIO controller supports wake on Bluetooth, sending a wakeon
1387 * command is not necessary.
1388 */
1389 if (device_can_wakeup(func->card->host->parent))
1390 hdev->wakeup = btmtksdio_sdio_inband_wakeup;
1391 else
1392 hdev->wakeup = btmtksdio_sdio_wakeup;
1393 hdev->set_bdaddr = btmtk_set_bdaddr;
1394
1395 SET_HCIDEV_DEV(hdev, &func->dev);
1396
1397 hdev->manufacturer = 70;
1398 hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP);
1399
1400 sdio_set_drvdata(func, bdev);
1401
1402 err = hci_register_dev(hdev);
1403 if (err < 0) {
1404 dev_err(&func->dev, "Can't register HCI device\n");
1405 hci_free_dev(hdev);
1406 return err;
1407 }
1408
1409 /* pm_runtime_enable would be done after the firmware is being
1410 * downloaded because the core layer probably already enables
1411 * runtime PM for this func such as the case host->caps &
1412 * MMC_CAP_POWER_OFF_CARD.
1413 */
1414 if (pm_runtime_enabled(bdev->dev))
1415 pm_runtime_disable(bdev->dev);
1416
1417 /* As explanation in drivers/mmc/core/sdio_bus.c tells us:
1418 * Unbound SDIO functions are always suspended.
1419 * During probe, the function is set active and the usage count
1420 * is incremented. If the driver supports runtime PM,
1421 * it should call pm_runtime_put_noidle() in its probe routine and
1422 * pm_runtime_get_noresume() in its remove routine.
1423 *
1424 * So, put a pm_runtime_put_noidle here !
1425 */
1426 pm_runtime_put_noidle(bdev->dev);
1427
1428 err = devm_device_init_wakeup(bdev->dev);
1429 if (err)
1430 bt_dev_err(hdev, "failed to initialize device wakeup");
1431
1432 restore_node = false;
1433 if (!of_device_is_compatible(bdev->dev->of_node, "mediatek,mt7921s-bluetooth")) {
1434 restore_node = true;
1435 old_node = bdev->dev->of_node;
1436 bdev->dev->of_node = of_find_compatible_node(NULL, NULL,
1437 "mediatek,mt7921s-bluetooth");
1438 }
1439
1440 bdev->reset = devm_gpiod_get_optional(bdev->dev, "reset",
1441 GPIOD_OUT_LOW);
1442 if (IS_ERR(bdev->reset))
1443 err = PTR_ERR(bdev->reset);
1444
1445 if (restore_node) {
1446 of_node_put(bdev->dev->of_node);
1447 bdev->dev->of_node = old_node;
1448 }
1449
1450 return err;
1451 }
1452
btmtksdio_remove(struct sdio_func * func)1453 static void btmtksdio_remove(struct sdio_func *func)
1454 {
1455 struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
1456 struct hci_dev *hdev;
1457
1458 if (!bdev)
1459 return;
1460
1461 hdev = bdev->hdev;
1462
1463 /* Make sure to call btmtksdio_close before removing sdio card */
1464 if (test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1465 btmtksdio_close(hdev);
1466
1467 /* Be consistent the state in btmtksdio_probe */
1468 pm_runtime_get_noresume(bdev->dev);
1469
1470 sdio_set_drvdata(func, NULL);
1471 hci_unregister_dev(hdev);
1472 hci_free_dev(hdev);
1473 }
1474
1475 #ifdef CONFIG_PM
btmtksdio_runtime_suspend(struct device * dev)1476 static int btmtksdio_runtime_suspend(struct device *dev)
1477 {
1478 struct sdio_func *func = dev_to_sdio_func(dev);
1479 struct btmtksdio_dev *bdev;
1480 int err;
1481
1482 bdev = sdio_get_drvdata(func);
1483 if (!bdev)
1484 return 0;
1485
1486 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1487 return 0;
1488
1489 sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1490
1491 err = btmtksdio_fw_pmctrl(bdev);
1492
1493 bt_dev_dbg(bdev->hdev, "status (%d) return ownership to device", err);
1494
1495 return err;
1496 }
1497
btmtksdio_system_suspend(struct device * dev)1498 static int btmtksdio_system_suspend(struct device *dev)
1499 {
1500 struct sdio_func *func = dev_to_sdio_func(dev);
1501 struct btmtksdio_dev *bdev;
1502
1503 bdev = sdio_get_drvdata(func);
1504 if (!bdev)
1505 return 0;
1506
1507 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1508 return 0;
1509
1510 set_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state);
1511
1512 return btmtksdio_runtime_suspend(dev);
1513 }
1514
btmtksdio_runtime_resume(struct device * dev)1515 static int btmtksdio_runtime_resume(struct device *dev)
1516 {
1517 struct sdio_func *func = dev_to_sdio_func(dev);
1518 struct btmtksdio_dev *bdev;
1519 int err;
1520
1521 bdev = sdio_get_drvdata(func);
1522 if (!bdev)
1523 return 0;
1524
1525 if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1526 return 0;
1527
1528 err = btmtksdio_drv_pmctrl(bdev);
1529
1530 bt_dev_dbg(bdev->hdev, "status (%d) get ownership from device", err);
1531
1532 return err;
1533 }
1534
btmtksdio_system_resume(struct device * dev)1535 static int btmtksdio_system_resume(struct device *dev)
1536 {
1537 return btmtksdio_runtime_resume(dev);
1538 }
1539
1540 static const struct dev_pm_ops btmtksdio_pm_ops = {
1541 SYSTEM_SLEEP_PM_OPS(btmtksdio_system_suspend, btmtksdio_system_resume)
1542 RUNTIME_PM_OPS(btmtksdio_runtime_suspend, btmtksdio_runtime_resume, NULL)
1543 };
1544
1545 #define BTMTKSDIO_PM_OPS (&btmtksdio_pm_ops)
1546 #else /* CONFIG_PM */
1547 #define BTMTKSDIO_PM_OPS NULL
1548 #endif /* CONFIG_PM */
1549
1550 static struct sdio_driver btmtksdio_driver = {
1551 .name = "btmtksdio",
1552 .probe = btmtksdio_probe,
1553 .remove = btmtksdio_remove,
1554 .id_table = btmtksdio_table,
1555 .drv = {
1556 .pm = BTMTKSDIO_PM_OPS,
1557 }
1558 };
1559
1560 module_sdio_driver(btmtksdio_driver);
1561
1562 module_param(enable_autosuspend, bool, 0644);
1563 MODULE_PARM_DESC(enable_autosuspend, "Enable autosuspend by default");
1564
1565 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
1566 MODULE_DESCRIPTION("MediaTek Bluetooth SDIO driver ver " VERSION);
1567 MODULE_VERSION(VERSION);
1568 MODULE_LICENSE("GPL");
1569