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