xref: /linux/drivers/bluetooth/btmtksdio.c (revision 3fd6c59042dbba50391e30862beac979491145fe)
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 
39 static bool enable_autosuspend = true;
40 
41 struct btmtksdio_data {
42 	const char *fwname;
43 	u16 chipid;
44 	bool lp_mbox_supported;
45 };
46 
47 static const struct btmtksdio_data mt7663_data = {
48 	.fwname = FIRMWARE_MT7663,
49 	.chipid = 0x7663,
50 	.lp_mbox_supported = false,
51 };
52 
53 static const struct btmtksdio_data mt7668_data = {
54 	.fwname = FIRMWARE_MT7668,
55 	.chipid = 0x7668,
56 	.lp_mbox_supported = false,
57 };
58 
59 static const struct btmtksdio_data mt7921_data = {
60 	.fwname = FIRMWARE_MT7961,
61 	.chipid = 0x7921,
62 	.lp_mbox_supported = true,
63 };
64 
65 static const struct sdio_device_id btmtksdio_table[] = {
66 	{SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7663),
67 	 .driver_data = (kernel_ulong_t)&mt7663_data },
68 	{SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7668),
69 	 .driver_data = (kernel_ulong_t)&mt7668_data },
70 	{SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7961),
71 	 .driver_data = (kernel_ulong_t)&mt7921_data },
72 	{ }	/* Terminating entry */
73 };
74 MODULE_DEVICE_TABLE(sdio, btmtksdio_table);
75 
76 #define MTK_REG_CHLPCR		0x4	/* W1S */
77 #define C_INT_EN_SET		BIT(0)
78 #define C_INT_EN_CLR		BIT(1)
79 #define C_FW_OWN_REQ_SET	BIT(8)  /* For write */
80 #define C_COM_DRV_OWN		BIT(8)  /* For read */
81 #define C_FW_OWN_REQ_CLR	BIT(9)
82 
83 #define MTK_REG_CSDIOCSR	0x8
84 #define SDIO_RE_INIT_EN		BIT(0)
85 #define SDIO_INT_CTL		BIT(2)
86 
87 #define MTK_REG_CHCR		0xc
88 #define C_INT_CLR_CTRL		BIT(1)
89 #define BT_RST_DONE		BIT(8)
90 
91 /* CHISR have the same bits field definition with CHIER */
92 #define MTK_REG_CHISR		0x10
93 #define MTK_REG_CHIER		0x14
94 #define FW_OWN_BACK_INT		BIT(0)
95 #define RX_DONE_INT		BIT(1)
96 #define TX_EMPTY		BIT(2)
97 #define TX_FIFO_OVERFLOW	BIT(8)
98 #define FW_MAILBOX_INT		BIT(15)
99 #define INT_MASK		GENMASK(15, 0)
100 #define RX_PKT_LEN		GENMASK(31, 16)
101 
102 #define MTK_REG_CSICR		0xc0
103 #define CSICR_CLR_MBOX_ACK BIT(0)
104 #define MTK_REG_PH2DSM0R	0xc4
105 #define PH2DSM0R_DRIVER_OWN	BIT(0)
106 #define MTK_REG_PD2HRM0R	0xdc
107 #define PD2HRM0R_DRV_OWN	BIT(0)
108 
109 #define MTK_REG_CTDR		0x18
110 
111 #define MTK_REG_CRDR		0x1c
112 
113 #define MTK_REG_CRPLR		0x24
114 
115 #define MTK_SDIO_BLOCK_SIZE	256
116 
117 #define BTMTKSDIO_TX_WAIT_VND_EVT	1
118 #define BTMTKSDIO_HW_TX_READY		2
119 #define BTMTKSDIO_FUNC_ENABLED		3
120 #define BTMTKSDIO_PATCH_ENABLED		4
121 #define BTMTKSDIO_HW_RESET_ACTIVE	5
122 #define BTMTKSDIO_BT_WAKE_ENABLED	6
123 
124 struct mtkbtsdio_hdr {
125 	__le16	len;
126 	__le16	reserved;
127 	u8	bt_type;
128 } __packed;
129 
130 struct btmtksdio_dev {
131 	struct hci_dev *hdev;
132 	struct sdio_func *func;
133 	struct device *dev;
134 
135 	struct work_struct txrx_work;
136 	unsigned long tx_state;
137 	struct sk_buff_head txq;
138 
139 	struct sk_buff *evt_skb;
140 
141 	const struct btmtksdio_data *data;
142 
143 	struct gpio_desc *reset;
144 };
145 
mtk_hci_wmt_sync(struct hci_dev * hdev,struct btmtk_hci_wmt_params * wmt_params)146 static int mtk_hci_wmt_sync(struct hci_dev *hdev,
147 			    struct btmtk_hci_wmt_params *wmt_params)
148 {
149 	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
150 	struct btmtk_hci_wmt_evt_funcc *wmt_evt_funcc;
151 	struct btmtk_hci_wmt_evt_reg *wmt_evt_reg;
152 	u32 hlen, status = BTMTK_WMT_INVALID;
153 	struct btmtk_hci_wmt_evt *wmt_evt;
154 	struct btmtk_hci_wmt_cmd *wc;
155 	struct btmtk_wmt_hdr *hdr;
156 	int err;
157 
158 	/* Send the WMT command and wait until the WMT event returns */
159 	hlen = sizeof(*hdr) + wmt_params->dlen;
160 	if (hlen > 255)
161 		return -EINVAL;
162 
163 	wc = kzalloc(hlen, GFP_KERNEL);
164 	if (!wc)
165 		return -ENOMEM;
166 
167 	hdr = &wc->hdr;
168 	hdr->dir = 1;
169 	hdr->op = wmt_params->op;
170 	hdr->dlen = cpu_to_le16(wmt_params->dlen + 1);
171 	hdr->flag = wmt_params->flag;
172 	memcpy(wc->data, wmt_params->data, wmt_params->dlen);
173 
174 	set_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
175 
176 	err = __hci_cmd_send(hdev, 0xfc6f, hlen, wc);
177 	if (err < 0) {
178 		clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
179 		goto err_free_wc;
180 	}
181 
182 	/* The vendor specific WMT commands are all answered by a vendor
183 	 * specific event and will not have the Command Status or Command
184 	 * Complete as with usual HCI command flow control.
185 	 *
186 	 * After sending the command, wait for BTMTKSDIO_TX_WAIT_VND_EVT
187 	 * state to be cleared. The driver specific event receive routine
188 	 * will clear that state and with that indicate completion of the
189 	 * WMT command.
190 	 */
191 	err = wait_on_bit_timeout(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT,
192 				  TASK_INTERRUPTIBLE, HCI_INIT_TIMEOUT);
193 	if (err == -EINTR) {
194 		bt_dev_err(hdev, "Execution of wmt command interrupted");
195 		clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
196 		goto err_free_wc;
197 	}
198 
199 	if (err) {
200 		bt_dev_err(hdev, "Execution of wmt command timed out");
201 		clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state);
202 		err = -ETIMEDOUT;
203 		goto err_free_wc;
204 	}
205 
206 	/* Parse and handle the return WMT event */
207 	wmt_evt = (struct btmtk_hci_wmt_evt *)bdev->evt_skb->data;
208 	if (wmt_evt->whdr.op != hdr->op) {
209 		bt_dev_err(hdev, "Wrong op received %d expected %d",
210 			   wmt_evt->whdr.op, hdr->op);
211 		err = -EIO;
212 		goto err_free_skb;
213 	}
214 
215 	switch (wmt_evt->whdr.op) {
216 	case BTMTK_WMT_SEMAPHORE:
217 		if (wmt_evt->whdr.flag == 2)
218 			status = BTMTK_WMT_PATCH_UNDONE;
219 		else
220 			status = BTMTK_WMT_PATCH_DONE;
221 		break;
222 	case BTMTK_WMT_FUNC_CTRL:
223 		wmt_evt_funcc = (struct btmtk_hci_wmt_evt_funcc *)wmt_evt;
224 		if (be16_to_cpu(wmt_evt_funcc->status) == 0x404)
225 			status = BTMTK_WMT_ON_DONE;
226 		else if (be16_to_cpu(wmt_evt_funcc->status) == 0x420)
227 			status = BTMTK_WMT_ON_PROGRESS;
228 		else
229 			status = BTMTK_WMT_ON_UNDONE;
230 		break;
231 	case BTMTK_WMT_PATCH_DWNLD:
232 		if (wmt_evt->whdr.flag == 2)
233 			status = BTMTK_WMT_PATCH_DONE;
234 		else if (wmt_evt->whdr.flag == 1)
235 			status = BTMTK_WMT_PATCH_PROGRESS;
236 		else
237 			status = BTMTK_WMT_PATCH_UNDONE;
238 		break;
239 	case BTMTK_WMT_REGISTER:
240 		wmt_evt_reg = (struct btmtk_hci_wmt_evt_reg *)wmt_evt;
241 		if (le16_to_cpu(wmt_evt->whdr.dlen) == 12)
242 			status = le32_to_cpu(wmt_evt_reg->val);
243 		break;
244 	}
245 
246 	if (wmt_params->status)
247 		*wmt_params->status = status;
248 
249 err_free_skb:
250 	kfree_skb(bdev->evt_skb);
251 	bdev->evt_skb = NULL;
252 err_free_wc:
253 	kfree(wc);
254 
255 	return err;
256 }
257 
btmtksdio_tx_packet(struct btmtksdio_dev * bdev,struct sk_buff * skb)258 static int btmtksdio_tx_packet(struct btmtksdio_dev *bdev,
259 			       struct sk_buff *skb)
260 {
261 	struct mtkbtsdio_hdr *sdio_hdr;
262 	int err;
263 
264 	/* Make sure that there are enough rooms for SDIO header */
265 	if (unlikely(skb_headroom(skb) < sizeof(*sdio_hdr))) {
266 		err = pskb_expand_head(skb, sizeof(*sdio_hdr), 0,
267 				       GFP_ATOMIC);
268 		if (err < 0)
269 			return err;
270 	}
271 
272 	/* Prepend MediaTek SDIO Specific Header */
273 	skb_push(skb, sizeof(*sdio_hdr));
274 
275 	sdio_hdr = (void *)skb->data;
276 	sdio_hdr->len = cpu_to_le16(skb->len);
277 	sdio_hdr->reserved = cpu_to_le16(0);
278 	sdio_hdr->bt_type = hci_skb_pkt_type(skb);
279 
280 	clear_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
281 	err = sdio_writesb(bdev->func, MTK_REG_CTDR, skb->data,
282 			   round_up(skb->len, MTK_SDIO_BLOCK_SIZE));
283 	if (err < 0)
284 		goto err_skb_pull;
285 
286 	bdev->hdev->stat.byte_tx += skb->len;
287 
288 	kfree_skb(skb);
289 
290 	return 0;
291 
292 err_skb_pull:
293 	skb_pull(skb, sizeof(*sdio_hdr));
294 
295 	return err;
296 }
297 
btmtksdio_drv_own_query(struct btmtksdio_dev * bdev)298 static u32 btmtksdio_drv_own_query(struct btmtksdio_dev *bdev)
299 {
300 	return sdio_readl(bdev->func, MTK_REG_CHLPCR, NULL);
301 }
302 
btmtksdio_drv_own_query_79xx(struct btmtksdio_dev * bdev)303 static u32 btmtksdio_drv_own_query_79xx(struct btmtksdio_dev *bdev)
304 {
305 	return sdio_readl(bdev->func, MTK_REG_PD2HRM0R, NULL);
306 }
307 
btmtksdio_chcr_query(struct btmtksdio_dev * bdev)308 static u32 btmtksdio_chcr_query(struct btmtksdio_dev *bdev)
309 {
310 	return sdio_readl(bdev->func, MTK_REG_CHCR, NULL);
311 }
312 
btmtksdio_fw_pmctrl(struct btmtksdio_dev * bdev)313 static int btmtksdio_fw_pmctrl(struct btmtksdio_dev *bdev)
314 {
315 	u32 status;
316 	int err;
317 
318 	sdio_claim_host(bdev->func);
319 
320 	if (bdev->data->lp_mbox_supported &&
321 	    test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state)) {
322 		sdio_writel(bdev->func, CSICR_CLR_MBOX_ACK, MTK_REG_CSICR,
323 			    &err);
324 		err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev,
325 					 status, !(status & PD2HRM0R_DRV_OWN),
326 					 2000, 1000000);
327 		if (err < 0) {
328 			bt_dev_err(bdev->hdev, "mailbox ACK not cleared");
329 			goto out;
330 		}
331 	}
332 
333 	/* Return ownership to the device */
334 	sdio_writel(bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, &err);
335 	if (err < 0)
336 		goto out;
337 
338 	err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
339 				 !(status & C_COM_DRV_OWN), 2000, 1000000);
340 
341 out:
342 	sdio_release_host(bdev->func);
343 
344 	if (err < 0)
345 		bt_dev_err(bdev->hdev, "Cannot return ownership to device");
346 
347 	return err;
348 }
349 
btmtksdio_drv_pmctrl(struct btmtksdio_dev * bdev)350 static int btmtksdio_drv_pmctrl(struct btmtksdio_dev *bdev)
351 {
352 	u32 status;
353 	int err;
354 
355 	sdio_claim_host(bdev->func);
356 
357 	/* Get ownership from the device */
358 	sdio_writel(bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, &err);
359 	if (err < 0)
360 		goto out;
361 
362 	err = readx_poll_timeout(btmtksdio_drv_own_query, bdev, status,
363 				 status & C_COM_DRV_OWN, 2000, 1000000);
364 
365 	if (!err && bdev->data->lp_mbox_supported &&
366 	    test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state))
367 		err = readx_poll_timeout(btmtksdio_drv_own_query_79xx, bdev,
368 					 status, status & PD2HRM0R_DRV_OWN,
369 					 2000, 1000000);
370 
371 out:
372 	sdio_release_host(bdev->func);
373 
374 	if (err < 0)
375 		bt_dev_err(bdev->hdev, "Cannot get ownership from device");
376 
377 	return err;
378 }
379 
btmtksdio_recv_event(struct hci_dev * hdev,struct sk_buff * skb)380 static int btmtksdio_recv_event(struct hci_dev *hdev, struct sk_buff *skb)
381 {
382 	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
383 	struct hci_event_hdr *hdr = (void *)skb->data;
384 	u8 evt = hdr->evt;
385 	int err;
386 
387 	/* When someone waits for the WMT event, the skb is being cloned
388 	 * and being processed the events from there then.
389 	 */
390 	if (test_bit(BTMTKSDIO_TX_WAIT_VND_EVT, &bdev->tx_state)) {
391 		bdev->evt_skb = skb_clone(skb, GFP_KERNEL);
392 		if (!bdev->evt_skb) {
393 			err = -ENOMEM;
394 			goto err_out;
395 		}
396 	}
397 
398 	err = hci_recv_frame(hdev, skb);
399 	if (err < 0)
400 		goto err_free_skb;
401 
402 	if (evt == HCI_EV_WMT) {
403 		if (test_and_clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT,
404 				       &bdev->tx_state)) {
405 			/* Barrier to sync with other CPUs */
406 			smp_mb__after_atomic();
407 			wake_up_bit(&bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT);
408 		}
409 	}
410 
411 	return 0;
412 
413 err_free_skb:
414 	kfree_skb(bdev->evt_skb);
415 	bdev->evt_skb = NULL;
416 
417 err_out:
418 	return err;
419 }
420 
btmtksdio_recv_acl(struct hci_dev * hdev,struct sk_buff * skb)421 static int btmtksdio_recv_acl(struct hci_dev *hdev, struct sk_buff *skb)
422 {
423 	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
424 	u16 handle = le16_to_cpu(hci_acl_hdr(skb)->handle);
425 
426 	switch (handle) {
427 	case 0xfc6f:
428 		/* Firmware dump from device: when the firmware hangs, the
429 		 * device can no longer suspend and thus disable auto-suspend.
430 		 */
431 		pm_runtime_forbid(bdev->dev);
432 		fallthrough;
433 	case 0x05ff:
434 	case 0x05fe:
435 		/* Firmware debug logging */
436 		return hci_recv_diag(hdev, skb);
437 	}
438 
439 	return hci_recv_frame(hdev, skb);
440 }
441 
442 static const struct h4_recv_pkt mtk_recv_pkts[] = {
443 	{ H4_RECV_ACL,      .recv = btmtksdio_recv_acl },
444 	{ H4_RECV_SCO,      .recv = hci_recv_frame },
445 	{ H4_RECV_EVENT,    .recv = btmtksdio_recv_event },
446 };
447 
btmtksdio_rx_packet(struct btmtksdio_dev * bdev,u16 rx_size)448 static int btmtksdio_rx_packet(struct btmtksdio_dev *bdev, u16 rx_size)
449 {
450 	const struct h4_recv_pkt *pkts = mtk_recv_pkts;
451 	int pkts_count = ARRAY_SIZE(mtk_recv_pkts);
452 	struct mtkbtsdio_hdr *sdio_hdr;
453 	int err, i, pad_size;
454 	struct sk_buff *skb;
455 	u16 dlen;
456 
457 	if (rx_size < sizeof(*sdio_hdr))
458 		return -EILSEQ;
459 
460 	/* A SDIO packet is exactly containing a Bluetooth packet */
461 	skb = bt_skb_alloc(rx_size, GFP_KERNEL);
462 	if (!skb)
463 		return -ENOMEM;
464 
465 	skb_put(skb, rx_size);
466 
467 	err = sdio_readsb(bdev->func, skb->data, MTK_REG_CRDR, rx_size);
468 	if (err < 0)
469 		goto err_kfree_skb;
470 
471 	sdio_hdr = (void *)skb->data;
472 
473 	/* We assume the default error as -EILSEQ simply to make the error path
474 	 * be cleaner.
475 	 */
476 	err = -EILSEQ;
477 
478 	if (rx_size != le16_to_cpu(sdio_hdr->len)) {
479 		bt_dev_err(bdev->hdev, "Rx size in sdio header is mismatched ");
480 		goto err_kfree_skb;
481 	}
482 
483 	hci_skb_pkt_type(skb) = sdio_hdr->bt_type;
484 
485 	/* Remove MediaTek SDIO header */
486 	skb_pull(skb, sizeof(*sdio_hdr));
487 
488 	/* We have to dig into the packet to get payload size and then know how
489 	 * many padding bytes at the tail, these padding bytes should be removed
490 	 * before the packet is indicated to the core layer.
491 	 */
492 	for (i = 0; i < pkts_count; i++) {
493 		if (sdio_hdr->bt_type == (&pkts[i])->type)
494 			break;
495 	}
496 
497 	if (i >= pkts_count) {
498 		bt_dev_err(bdev->hdev, "Invalid bt type 0x%02x",
499 			   sdio_hdr->bt_type);
500 		goto err_kfree_skb;
501 	}
502 
503 	/* Remaining bytes cannot hold a header*/
504 	if (skb->len < (&pkts[i])->hlen) {
505 		bt_dev_err(bdev->hdev, "The size of bt header is mismatched");
506 		goto err_kfree_skb;
507 	}
508 
509 	switch ((&pkts[i])->lsize) {
510 	case 1:
511 		dlen = skb->data[(&pkts[i])->loff];
512 		break;
513 	case 2:
514 		dlen = get_unaligned_le16(skb->data +
515 						  (&pkts[i])->loff);
516 		break;
517 	default:
518 		goto err_kfree_skb;
519 	}
520 
521 	pad_size = skb->len - (&pkts[i])->hlen -  dlen;
522 
523 	/* Remaining bytes cannot hold a payload */
524 	if (pad_size < 0) {
525 		bt_dev_err(bdev->hdev, "The size of bt payload is mismatched");
526 		goto err_kfree_skb;
527 	}
528 
529 	/* Remove padding bytes */
530 	skb_trim(skb, skb->len - pad_size);
531 
532 	/* Complete frame */
533 	(&pkts[i])->recv(bdev->hdev, skb);
534 
535 	bdev->hdev->stat.byte_rx += rx_size;
536 
537 	return 0;
538 
539 err_kfree_skb:
540 	kfree_skb(skb);
541 
542 	return err;
543 }
544 
btmtksdio_txrx_work(struct work_struct * work)545 static void btmtksdio_txrx_work(struct work_struct *work)
546 {
547 	struct btmtksdio_dev *bdev = container_of(work, struct btmtksdio_dev,
548 						  txrx_work);
549 	unsigned long txrx_timeout;
550 	u32 int_status, rx_size;
551 	struct sk_buff *skb;
552 	int err;
553 
554 	pm_runtime_get_sync(bdev->dev);
555 
556 	sdio_claim_host(bdev->func);
557 
558 	/* Disable interrupt */
559 	sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
560 
561 	txrx_timeout = jiffies + 5 * HZ;
562 
563 	do {
564 		int_status = sdio_readl(bdev->func, MTK_REG_CHISR, NULL);
565 
566 		/* Ack an interrupt as soon as possible before any operation on
567 		 * hardware.
568 		 *
569 		 * Note that we don't ack any status during operations to avoid race
570 		 * condition between the host and the device such as it's possible to
571 		 * mistakenly ack RX_DONE for the next packet and then cause interrupts
572 		 * not be raised again but there is still pending data in the hardware
573 		 * FIFO.
574 		 */
575 		sdio_writel(bdev->func, int_status, MTK_REG_CHISR, NULL);
576 		int_status &= INT_MASK;
577 
578 		if ((int_status & FW_MAILBOX_INT) &&
579 		    bdev->data->chipid == 0x7921) {
580 			sdio_writel(bdev->func, PH2DSM0R_DRIVER_OWN,
581 				    MTK_REG_PH2DSM0R, NULL);
582 		}
583 
584 		if (int_status & FW_OWN_BACK_INT)
585 			bt_dev_dbg(bdev->hdev, "Get fw own back");
586 
587 		if (int_status & TX_EMPTY)
588 			set_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state);
589 
590 		else if (unlikely(int_status & TX_FIFO_OVERFLOW))
591 			bt_dev_warn(bdev->hdev, "Tx fifo overflow");
592 
593 		if (test_bit(BTMTKSDIO_HW_TX_READY, &bdev->tx_state)) {
594 			skb = skb_dequeue(&bdev->txq);
595 			if (skb) {
596 				err = btmtksdio_tx_packet(bdev, skb);
597 				if (err < 0) {
598 					bdev->hdev->stat.err_tx++;
599 					skb_queue_head(&bdev->txq, skb);
600 				}
601 			}
602 		}
603 
604 		if (int_status & RX_DONE_INT) {
605 			rx_size = sdio_readl(bdev->func, MTK_REG_CRPLR, NULL);
606 			rx_size = (rx_size & RX_PKT_LEN) >> 16;
607 			if (btmtksdio_rx_packet(bdev, rx_size) < 0)
608 				bdev->hdev->stat.err_rx++;
609 		}
610 	} while (int_status || time_is_before_jiffies(txrx_timeout));
611 
612 	/* Enable interrupt */
613 	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 
btmtksdio_interrupt(struct sdio_func * func)621 static void btmtksdio_interrupt(struct sdio_func *func)
622 {
623 	struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
624 
625 	if (test_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state)) {
626 		if (bdev->hdev->suspended)
627 			pm_wakeup_event(bdev->dev, 0);
628 		clear_bit(BTMTKSDIO_BT_WAKE_ENABLED, &bdev->tx_state);
629 	}
630 
631 	/* Disable interrupt */
632 	sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
633 
634 	schedule_work(&bdev->txrx_work);
635 }
636 
btmtksdio_open(struct hci_dev * hdev)637 static int btmtksdio_open(struct hci_dev *hdev)
638 {
639 	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
640 	u32 val;
641 	int err;
642 
643 	sdio_claim_host(bdev->func);
644 
645 	err = sdio_enable_func(bdev->func);
646 	if (err < 0)
647 		goto err_release_host;
648 
649 	set_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state);
650 
651 	err = btmtksdio_drv_pmctrl(bdev);
652 	if (err < 0)
653 		goto err_disable_func;
654 
655 	/* Disable interrupt & mask out all interrupt sources */
656 	sdio_writel(bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, &err);
657 	if (err < 0)
658 		goto err_disable_func;
659 
660 	sdio_writel(bdev->func, 0, MTK_REG_CHIER, &err);
661 	if (err < 0)
662 		goto err_disable_func;
663 
664 	err = sdio_claim_irq(bdev->func, btmtksdio_interrupt);
665 	if (err < 0)
666 		goto err_disable_func;
667 
668 	err = sdio_set_block_size(bdev->func, MTK_SDIO_BLOCK_SIZE);
669 	if (err < 0)
670 		goto err_release_irq;
671 
672 	/* SDIO CMD 5 allows the SDIO device back to idle state an
673 	 * synchronous interrupt is supported in SDIO 4-bit mode
674 	 */
675 	val = sdio_readl(bdev->func, MTK_REG_CSDIOCSR, &err);
676 	if (err < 0)
677 		goto err_release_irq;
678 
679 	val |= SDIO_INT_CTL;
680 	sdio_writel(bdev->func, val, MTK_REG_CSDIOCSR, &err);
681 	if (err < 0)
682 		goto err_release_irq;
683 
684 	/* Explicitly set write-1-clear method */
685 	val = sdio_readl(bdev->func, MTK_REG_CHCR, &err);
686 	if (err < 0)
687 		goto err_release_irq;
688 
689 	val |= C_INT_CLR_CTRL;
690 	sdio_writel(bdev->func, val, MTK_REG_CHCR, &err);
691 	if (err < 0)
692 		goto err_release_irq;
693 
694 	/* Setup interrupt sources */
695 	sdio_writel(bdev->func, RX_DONE_INT | TX_EMPTY | TX_FIFO_OVERFLOW,
696 		    MTK_REG_CHIER, &err);
697 	if (err < 0)
698 		goto err_release_irq;
699 
700 	/* Enable interrupt */
701 	sdio_writel(bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, &err);
702 	if (err < 0)
703 		goto err_release_irq;
704 
705 	sdio_release_host(bdev->func);
706 
707 	return 0;
708 
709 err_release_irq:
710 	sdio_release_irq(bdev->func);
711 
712 err_disable_func:
713 	sdio_disable_func(bdev->func);
714 
715 err_release_host:
716 	sdio_release_host(bdev->func);
717 
718 	return err;
719 }
720 
btmtksdio_close(struct hci_dev * hdev)721 static int btmtksdio_close(struct hci_dev *hdev)
722 {
723 	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
724 
725 	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 
btmtksdio_flush(struct hci_dev * hdev)744 static 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 
btmtksdio_func_query(struct hci_dev * hdev)755 static 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 = &param;
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 
mt76xx_setup(struct hci_dev * hdev,const char * fwname)777 static 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 
809 ignore_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 = &param;
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 
842 ignore_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 
mt79xx_setup(struct hci_dev * hdev,const char * fwname)862 static 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 = &param;
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 
btmtksdio_mtk_reg_read(struct hci_dev * hdev,u32 reg,u32 * val)903 static 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 = &reg_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 
btmtksdio_mtk_reg_write(struct hci_dev * hdev,u32 reg,u32 val,u32 mask)931 static 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 = &reg_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 
btmtksdio_get_data_path_id(struct hci_dev * hdev,__u8 * data_path_id)956 static 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 
btmtksdio_get_codec_config_data(struct hci_dev * hdev,__u8 link,struct bt_codec * codec,__u8 * ven_len,__u8 ** ven_data)963 static 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 
1006 error:
1007 	kfree(*ven_data);
1008 	*ven_data = NULL;
1009 	return err;
1010 }
1011 
btmtksdio_sco_setting(struct hci_dev * hdev)1012 static 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 
btmtksdio_reset_setting(struct hci_dev * hdev)1054 static 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 
btmtksdio_setup(struct hci_dev * hdev)1076 static 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 
btmtksdio_shutdown(struct hci_dev * hdev)1188 static 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 = &param;
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 
1217 ignore_wmt_cmd:
1218 	pm_runtime_put_noidle(bdev->dev);
1219 	pm_runtime_disable(bdev->dev);
1220 
1221 	return 0;
1222 }
1223 
btmtksdio_send_frame(struct hci_dev * hdev,struct sk_buff * skb)1224 static 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 
btmtksdio_cmd_timeout(struct hci_dev * hdev)1252 static 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);
1284 err:
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 
btmtksdio_sdio_inband_wakeup(struct hci_dev * hdev)1293 static 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 
btmtksdio_sdio_wakeup(struct hci_dev * hdev)1300 static 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 
btmtksdio_probe(struct sdio_func * func,const struct sdio_device_id * id)1326 static 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 
btmtksdio_remove(struct sdio_func * func)1437 static 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
btmtksdio_runtime_suspend(struct device * dev)1456 static 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 
btmtksdio_system_suspend(struct device * dev)1478 static 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 
btmtksdio_runtime_resume(struct device * dev)1495 static 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 
btmtksdio_system_resume(struct device * dev)1515 static int btmtksdio_system_resume(struct device *dev)
1516 {
1517 	return btmtksdio_runtime_resume(dev);
1518 }
1519 
1520 static 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 
1530 static 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 
1540 module_sdio_driver(btmtksdio_driver);
1541 
1542 module_param(enable_autosuspend, bool, 0644);
1543 MODULE_PARM_DESC(enable_autosuspend, "Enable autosuspend by default");
1544 
1545 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
1546 MODULE_DESCRIPTION("MediaTek Bluetooth SDIO driver ver " VERSION);
1547 MODULE_VERSION(VERSION);
1548 MODULE_LICENSE("GPL");
1549