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