1	// SPDX-License-Identifier: GPL-2.0
2	// Copyright (c) 2019 MediaTek Inc.
3
4	/*
5	* Bluetooth support for MediaTek SDIO devices
6	*
7	* This file is written based on btsdio.c and btmtkuart.c.
8	*
9	* Author: Sean Wang <sean.wang@mediatek.com>
10	*
11	*/
12
13	#include <linux/unaligned.h>
14	#include <linux/atomic.h>
15	#include <linux/gpio/consumer.h>
16	#include <linux/init.h>
17	#include <linux/iopoll.h>
18	#include <linux/kernel.h>
19	#include <linux/module.h>
20	#include <linux/of.h>
21	#include <linux/pm_runtime.h>
22	#include <linux/skbuff.h>
23	#include <linux/usb.h>
24
25	#include <linux/mmc/host.h>
26	#include <linux/mmc/sdio_ids.h>
27	#include <linux/mmc/sdio_func.h>
28
29	#include <net/bluetooth/bluetooth.h>
30	#include <net/bluetooth/hci_core.h>
31
32	#include "hci_uart.h"
33	#include "btmtk.h"
34
35	#define VERSION "0.1"
36
37	#define MTKBTSDIO_AUTOSUSPEND_DELAY 1000
38
39	static bool enable_autosuspend = true;
40
41	struct btmtksdio_data {
42	const char *fwname;
43	u16 chipid;
44	bool lp_mbox_supported;
45	};
46
47	static const struct btmtksdio_data mt7663_data = {
48	.fwname = FIRMWARE_MT7663,
49	.chipid = 0x7663,
50	.lp_mbox_supported = false,
51	};
52
53	static const struct btmtksdio_data mt7668_data = {
54	.fwname = FIRMWARE_MT7668,
55	.chipid = 0x7668,
56	.lp_mbox_supported = false,
57	};
58
59	static const struct btmtksdio_data mt7921_data = {
60	.fwname = FIRMWARE_MT7961,
61	.chipid = 0x7921,
62	.lp_mbox_supported = true,
63	};
64
65	static const struct sdio_device_id btmtksdio_table[] = {
66	{SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7663),
67	.driver_data = (kernel_ulong_t)&mt7663_data },
68	{SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7668),
69	.driver_data = (kernel_ulong_t)&mt7668_data },
70	{SDIO_DEVICE(SDIO_VENDOR_ID_MEDIATEK, SDIO_DEVICE_ID_MEDIATEK_MT7961),
71	.driver_data = (kernel_ulong_t)&mt7921_data },
72	{ } /* Terminating entry */
73	};
74	MODULE_DEVICE_TABLE(sdio, btmtksdio_table);
75
76	#define MTK_REG_CHLPCR 0x4 /* W1S */
77	#define C_INT_EN_SET BIT(0)
78	#define C_INT_EN_CLR BIT(1)
79	#define C_FW_OWN_REQ_SET BIT(8) /* For write */
80	#define C_COM_DRV_OWN BIT(8) /* For read */
81	#define C_FW_OWN_REQ_CLR BIT(9)
82
83	#define MTK_REG_CSDIOCSR 0x8
84	#define SDIO_RE_INIT_EN BIT(0)
85	#define SDIO_INT_CTL BIT(2)
86
87	#define MTK_REG_CHCR 0xc
88	#define C_INT_CLR_CTRL BIT(1)
89	#define BT_RST_DONE BIT(8)
90
91	/* CHISR have the same bits field definition with CHIER */
92	#define MTK_REG_CHISR 0x10
93	#define MTK_REG_CHIER 0x14
94	#define FW_OWN_BACK_INT BIT(0)
95	#define RX_DONE_INT BIT(1)
96	#define TX_EMPTY BIT(2)
97	#define TX_FIFO_OVERFLOW BIT(8)
98	#define FW_MAILBOX_INT BIT(15)
99	#define INT_MASK GENMASK(15, 0)
100	#define RX_PKT_LEN GENMASK(31, 16)
101
102	#define MTK_REG_CSICR 0xc0
103	#define CSICR_CLR_MBOX_ACK BIT(0)
104	#define MTK_REG_PH2DSM0R 0xc4
105	#define PH2DSM0R_DRIVER_OWN BIT(0)
106	#define MTK_REG_PD2HRM0R 0xdc
107	#define PD2HRM0R_DRV_OWN BIT(0)
108
109	#define MTK_REG_CTDR 0x18
110
111	#define MTK_REG_CRDR 0x1c
112
113	#define MTK_REG_CRPLR 0x24
114
115	#define MTK_SDIO_BLOCK_SIZE 256
116
117	#define BTMTKSDIO_TX_WAIT_VND_EVT 1
118	#define BTMTKSDIO_HW_TX_READY 2
119	#define BTMTKSDIO_FUNC_ENABLED 3
120	#define BTMTKSDIO_PATCH_ENABLED 4
121	#define BTMTKSDIO_HW_RESET_ACTIVE 5
122	#define BTMTKSDIO_BT_WAKE_ENABLED 6
123
124	struct mtkbtsdio_hdr {
125	__le16 len;
126	__le16 reserved;
127	u8 bt_type;
128	} __packed;
129
130	struct btmtksdio_dev {
131	struct hci_dev *hdev;
132	struct sdio_func *func;
133	struct device *dev;
134
135	struct work_struct txrx_work;
136	unsigned long tx_state;
137	struct sk_buff_head txq;
138
139	struct sk_buff *evt_skb;
140
141	const struct btmtksdio_data *data;
142
143	struct gpio_desc *reset;
144	};
145
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, addr: &bdev->tx_state);
175
176	err = __hci_cmd_send(hdev, opcode: 0xfc6f, plen: hlen, param: wc);
177	if (err < 0) {
178	clear_bit(BTMTKSDIO_TX_WAIT_VND_EVT, addr: &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(word: &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, addr: &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, addr: &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(skb: bdev->evt_skb);
251	bdev->evt_skb = NULL;
252	err_free_wc:
253	kfree(objp: wc);
254
255	return err;
256	}
257
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, nhead: sizeof(*sdio_hdr), ntail: 0,
267	GFP_ATOMIC);
268	if (err < 0)
269	return err;
270	}
271
272	/* Prepend MediaTek SDIO Specific Header */
273	skb_push(skb, len: 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, addr: &bdev->tx_state);
281	err = sdio_writesb(func: bdev->func, MTK_REG_CTDR, src: 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, len: sizeof(*sdio_hdr));
294
295	return err;
296	}
297
298	static u32 btmtksdio_drv_own_query(struct btmtksdio_dev *bdev)
299	{
300	return sdio_readl(func: bdev->func, MTK_REG_CHLPCR, NULL);
301	}
302
303	static u32 btmtksdio_drv_own_query_79xx(struct btmtksdio_dev *bdev)
304	{
305	return sdio_readl(func: bdev->func, MTK_REG_PD2HRM0R, NULL);
306	}
307
308	static u32 btmtksdio_chcr_query(struct btmtksdio_dev *bdev)
309	{
310	return sdio_readl(func: bdev->func, MTK_REG_CHCR, NULL);
311	}
312
313	static int btmtksdio_fw_pmctrl(struct btmtksdio_dev *bdev)
314	{
315	u32 status;
316	int err;
317
318	sdio_claim_host(func: bdev->func);
319
320	if (bdev->data->lp_mbox_supported &&
321	test_bit(BTMTKSDIO_PATCH_ENABLED, &bdev->tx_state)) {
322	sdio_writel(func: bdev->func, CSICR_CLR_MBOX_ACK, MTK_REG_CSICR,
323	err_ret: &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(func: bdev->func, C_FW_OWN_REQ_SET, MTK_REG_CHLPCR, err_ret: &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(func: bdev->func);
343
344	if (err < 0)
345	bt_dev_err(bdev->hdev, "Cannot return ownership to device");
346
347	return err;
348	}
349
350	static int btmtksdio_drv_pmctrl(struct btmtksdio_dev *bdev)
351	{
352	u32 status;
353	int err;
354
355	sdio_claim_host(func: bdev->func);
356
357	/* Get ownership from the device */
358	sdio_writel(func: bdev->func, C_FW_OWN_REQ_CLR, MTK_REG_CHLPCR, err_ret: &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(func: bdev->func);
373
374	if (err < 0)
375	bt_dev_err(bdev->hdev, "Cannot get ownership from device");
376
377	return err;
378	}
379
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	addr: &bdev->tx_state)) {
405	/* Barrier to sync with other CPUs */
406	smp_mb__after_atomic();
407	wake_up_bit(word: &bdev->tx_state, BTMTKSDIO_TX_WAIT_VND_EVT);
408	}
409	}
410
411	return 0;
412
413	err_free_skb:
414	kfree_skb(skb: bdev->evt_skb);
415	bdev->evt_skb = NULL;
416
417	err_out:
418	return err;
419	}
420
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(dev: 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
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(len: rx_size, GFP_KERNEL);
462	if (!skb)
463	return -ENOMEM;
464
465	skb_put(skb, len: rx_size);
466
467	err = sdio_readsb(func: bdev->func, dst: skb->data, MTK_REG_CRDR, count: 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, len: 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(p: 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, len: 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
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(dev: bdev->dev);
555
556	sdio_claim_host(func: bdev->func);
557
558	/* Disable interrupt */
559	sdio_writel(func: 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(func: 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(func: bdev->func, b: 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(func: 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, addr: &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(list: &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(list: &bdev->txq, newsk: skb);
600	}
601	}
602	}
603
604	if (int_status & RX_DONE_INT) {
605	rx_size = sdio_readl(func: bdev->func, MTK_REG_CRPLR, NULL);
606	rx_size = (rx_size & RX_PKT_LEN) >> 16;
607	if (btmtksdio_rx_packet(bdev, rx_size) < 0)
608	bdev->hdev->stat.err_rx++;
609	}
610	} while (int_status || time_is_before_jiffies(txrx_timeout));
611
612	/* Enable interrupt */
613	if (bdev->func->irq_handler)
614	sdio_writel(func: bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, NULL);
615
616	sdio_release_host(func: bdev->func);
617
618	pm_runtime_put_autosuspend(dev: bdev->dev);
619	}
620
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(dev: bdev->dev, msec: 0);
628	clear_bit(BTMTKSDIO_BT_WAKE_ENABLED, addr: &bdev->tx_state);
629	}
630
631	/* Disable interrupt */
632	sdio_writel(func: bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
633
634	schedule_work(work: &bdev->txrx_work);
635	}
636
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(func: bdev->func);
644
645	err = sdio_enable_func(func: bdev->func);
646	if (err < 0)
647	goto err_release_host;
648
649	set_bit(BTMTKSDIO_FUNC_ENABLED, addr: &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(func: bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, err_ret: &err);
657	if (err < 0)
658	goto err_disable_func;
659
660	sdio_writel(func: bdev->func, b: 0, MTK_REG_CHIER, err_ret: &err);
661	if (err < 0)
662	goto err_disable_func;
663
664	err = sdio_claim_irq(func: bdev->func, handler: btmtksdio_interrupt);
665	if (err < 0)
666	goto err_disable_func;
667
668	err = sdio_set_block_size(func: 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(func: bdev->func, MTK_REG_CSDIOCSR, err_ret: &err);
676	if (err < 0)
677	goto err_release_irq;
678
679	val |= SDIO_INT_CTL;
680	sdio_writel(func: bdev->func, b: val, MTK_REG_CSDIOCSR, err_ret: &err);
681	if (err < 0)
682	goto err_release_irq;
683
684	/* Explicitly set write-1-clear method */
685	val = sdio_readl(func: bdev->func, MTK_REG_CHCR, err_ret: &err);
686	if (err < 0)
687	goto err_release_irq;
688
689	val |= C_INT_CLR_CTRL;
690	sdio_writel(func: bdev->func, b: val, MTK_REG_CHCR, err_ret: &err);
691	if (err < 0)
692	goto err_release_irq;
693
694	/* Setup interrupt sources */
695	sdio_writel(func: bdev->func, RX_DONE_INT | TX_EMPTY | TX_FIFO_OVERFLOW,
696	MTK_REG_CHIER, err_ret: &err);
697	if (err < 0)
698	goto err_release_irq;
699
700	/* Enable interrupt */
701	sdio_writel(func: bdev->func, C_INT_EN_SET, MTK_REG_CHLPCR, err_ret: &err);
702	if (err < 0)
703	goto err_release_irq;
704
705	sdio_release_host(func: bdev->func);
706
707	return 0;
708
709	err_release_irq:
710	sdio_release_irq(func: bdev->func);
711
712	err_disable_func:
713	sdio_disable_func(func: bdev->func);
714
715	err_release_host:
716	sdio_release_host(func: bdev->func);
717
718	return err;
719	}
720
721	static int btmtksdio_close(struct hci_dev *hdev)
722	{
723	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
724
725	/* Skip btmtksdio_close if BTMTKSDIO_FUNC_ENABLED isn't set */
726	if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
727	return 0;
728
729	sdio_claim_host(func: bdev->func);
730
731	/* Disable interrupt */
732	sdio_writel(func: bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
733
734	sdio_release_irq(func: bdev->func);
735
736	cancel_work_sync(work: &bdev->txrx_work);
737
738	btmtksdio_fw_pmctrl(bdev);
739
740	clear_bit(BTMTKSDIO_FUNC_ENABLED, addr: &bdev->tx_state);
741	sdio_disable_func(func: bdev->func);
742
743	sdio_release_host(func: bdev->func);
744
745	return 0;
746	}
747
748	static int btmtksdio_flush(struct hci_dev *hdev)
749	{
750	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
751
752	skb_queue_purge(list: &bdev->txq);
753
754	cancel_work_sync(work: &bdev->txrx_work);
755
756	return 0;
757	}
758
759	static int btmtksdio_func_query(struct hci_dev *hdev)
760	{
761	struct btmtk_hci_wmt_params wmt_params;
762	int status, err;
763	u8 param = 0;
764
765	/* Query whether the function is enabled */
766	wmt_params.op = BTMTK_WMT_FUNC_CTRL;
767	wmt_params.flag = 4;
768	wmt_params.dlen = sizeof(param);
769	wmt_params.data = &param;
770	wmt_params.status = &status;
771
772	err = mtk_hci_wmt_sync(hdev, wmt_params: &wmt_params);
773	if (err < 0) {
774	bt_dev_err(hdev, "Failed to query function status (%d)", err);
775	return err;
776	}
777
778	return status;
779	}
780
781	static int mt76xx_setup(struct hci_dev *hdev, const char *fwname)
782	{
783	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
784	struct btmtk_hci_wmt_params wmt_params;
785	struct btmtk_tci_sleep tci_sleep;
786	struct sk_buff *skb;
787	int err, status;
788	u8 param = 0x1;
789
790	/* Query whether the firmware is already download */
791	wmt_params.op = BTMTK_WMT_SEMAPHORE;
792	wmt_params.flag = 1;
793	wmt_params.dlen = 0;
794	wmt_params.data = NULL;
795	wmt_params.status = &status;
796
797	err = mtk_hci_wmt_sync(hdev, wmt_params: &wmt_params);
798	if (err < 0) {
799	bt_dev_err(hdev, "Failed to query firmware status (%d)", err);
800	return err;
801	}
802
803	if (status == BTMTK_WMT_PATCH_DONE) {
804	bt_dev_info(hdev, "Firmware already downloaded");
805	goto ignore_setup_fw;
806	}
807
808	/* Setup a firmware which the device definitely requires */
809	err = btmtk_setup_firmware(hdev, fwname, wmt_cmd_sync: mtk_hci_wmt_sync);
810	if (err < 0)
811	return err;
812
813	ignore_setup_fw:
814	/* Query whether the device is already enabled */
815	err = readx_poll_timeout(btmtksdio_func_query, hdev, status,
816	status < 0 || status != BTMTK_WMT_ON_PROGRESS,
817	2000, 5000000);
818	/* -ETIMEDOUT happens */
819	if (err < 0)
820	return err;
821
822	/* The other errors happen in btusb_mtk_func_query */
823	if (status < 0)
824	return status;
825
826	if (status == BTMTK_WMT_ON_DONE) {
827	bt_dev_info(hdev, "function already on");
828	goto ignore_func_on;
829	}
830
831	/* Enable Bluetooth protocol */
832	wmt_params.op = BTMTK_WMT_FUNC_CTRL;
833	wmt_params.flag = 0;
834	wmt_params.dlen = sizeof(param);
835	wmt_params.data = &param;
836	wmt_params.status = NULL;
837
838	err = mtk_hci_wmt_sync(hdev, wmt_params: &wmt_params);
839	if (err < 0) {
840	bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
841	return err;
842	}
843
844	set_bit(BTMTKSDIO_PATCH_ENABLED, addr: &bdev->tx_state);
845
846	ignore_func_on:
847	/* Apply the low power environment setup */
848	tci_sleep.mode = 0x5;
849	tci_sleep.duration = cpu_to_le16(0x640);
850	tci_sleep.host_duration = cpu_to_le16(0x640);
851	tci_sleep.host_wakeup_pin = 0;
852	tci_sleep.time_compensation = 0;
853
854	skb = __hci_cmd_sync(hdev, opcode: 0xfc7a, plen: sizeof(tci_sleep), param: &tci_sleep,
855	HCI_INIT_TIMEOUT);
856	if (IS_ERR(ptr: skb)) {
857	err = PTR_ERR(ptr: skb);
858	bt_dev_err(hdev, "Failed to apply low power setting (%d)", err);
859	return err;
860	}
861	kfree_skb(skb);
862
863	return 0;
864	}
865
866	static int mt79xx_setup(struct hci_dev *hdev, const char *fwname)
867	{
868	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
869	struct btmtk_hci_wmt_params wmt_params;
870	u8 param = 0x1;
871	int err;
872
873	err = btmtk_setup_firmware_79xx(hdev, fwname, wmt_cmd_sync: mtk_hci_wmt_sync);
874	if (err < 0) {
875	bt_dev_err(hdev, "Failed to setup 79xx firmware (%d)", err);
876	return err;
877	}
878
879	err = btmtksdio_fw_pmctrl(bdev);
880	if (err < 0)
881	return err;
882
883	err = btmtksdio_drv_pmctrl(bdev);
884	if (err < 0)
885	return err;
886
887	/* Enable Bluetooth protocol */
888	wmt_params.op = BTMTK_WMT_FUNC_CTRL;
889	wmt_params.flag = 0;
890	wmt_params.dlen = sizeof(param);
891	wmt_params.data = &param;
892	wmt_params.status = NULL;
893
894	err = mtk_hci_wmt_sync(hdev, wmt_params: &wmt_params);
895	if (err < 0) {
896	bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
897	return err;
898	}
899
900	hci_set_msft_opcode(hdev, opcode: 0xFD30);
901	hci_set_aosp_capable(hdev);
902	set_bit(BTMTKSDIO_PATCH_ENABLED, addr: &bdev->tx_state);
903
904	return err;
905	}
906
907	static int btmtksdio_mtk_reg_read(struct hci_dev *hdev, u32 reg, u32 *val)
908	{
909	struct btmtk_hci_wmt_params wmt_params;
910	struct reg_read_cmd reg_read = {
911	.type = 1,
912	.num = 1,
913	};
914	u32 status;
915	int err;
916
917	reg_read.addr = cpu_to_le32(reg);
918	wmt_params.op = BTMTK_WMT_REGISTER;
919	wmt_params.flag = BTMTK_WMT_REG_READ;
920	wmt_params.dlen = sizeof(reg_read);
921	wmt_params.data = &reg_read;
922	wmt_params.status = &status;
923
924	err = mtk_hci_wmt_sync(hdev, wmt_params: &wmt_params);
925	if (err < 0) {
926	bt_dev_err(hdev, "Failed to read reg (%d)", err);
927	return err;
928	}
929
930	*val = status;
931
932	return err;
933	}
934
935	static int btmtksdio_mtk_reg_write(struct hci_dev *hdev, u32 reg, u32 val, u32 mask)
936	{
937	struct btmtk_hci_wmt_params wmt_params;
938	const struct reg_write_cmd reg_write = {
939	.type = 1,
940	.num = 1,
941	.addr = cpu_to_le32(reg),
942	.data = cpu_to_le32(val),
943	.mask = cpu_to_le32(mask),
944	};
945	int err, status;
946
947	wmt_params.op = BTMTK_WMT_REGISTER;
948	wmt_params.flag = BTMTK_WMT_REG_WRITE;
949	wmt_params.dlen = sizeof(reg_write);
950	wmt_params.data = &reg_write;
951	wmt_params.status = &status;
952
953	err = mtk_hci_wmt_sync(hdev, wmt_params: &wmt_params);
954	if (err < 0)
955	bt_dev_err(hdev, "Failed to write reg (%d)", err);
956
957	return err;
958	}
959
960	static int btmtksdio_get_data_path_id(struct hci_dev *hdev, __u8 *data_path_id)
961	{
962	/* uses 1 as data path id for all the usecases */
963	*data_path_id = 1;
964	return 0;
965	}
966
967	static int btmtksdio_get_codec_config_data(struct hci_dev *hdev,
968	__u8 link, struct bt_codec *codec,
969	__u8 *ven_len, __u8 **ven_data)
970	{
971	int err = 0;
972
973	if (!ven_data || !ven_len)
974	return -EINVAL;
975
976	*ven_len = 0;
977	*ven_data = NULL;
978
979	if (link != ESCO_LINK) {
980	bt_dev_err(hdev, "Invalid link type(%u)", link);
981	return -EINVAL;
982	}
983
984	*ven_data = kmalloc(sizeof(__u8), GFP_KERNEL);
985	if (!*ven_data) {
986	err = -ENOMEM;
987	goto error;
988	}
989
990	/* supports only CVSD and mSBC offload codecs */
991	switch (codec->id) {
992	case 0x02:
993	**ven_data = 0x00;
994	break;
995	case 0x05:
996	**ven_data = 0x01;
997	break;
998	default:
999	err = -EINVAL;
1000	bt_dev_err(hdev, "Invalid codec id(%u)", codec->id);
1001	goto error;
1002	}
1003	/* codec and its capabilities are pre-defined to ids
1004	* preset id = 0x00 represents CVSD codec with sampling rate 8K
1005	* preset id = 0x01 represents mSBC codec with sampling rate 16K
1006	*/
1007	*ven_len = sizeof(__u8);
1008	return err;
1009
1010	error:
1011	kfree(objp: *ven_data);
1012	*ven_data = NULL;
1013	return err;
1014	}
1015
1016	static int btmtksdio_sco_setting(struct hci_dev *hdev)
1017	{
1018	const struct btmtk_sco sco_setting = {
1019	.clock_config = 0x49,
1020	.channel_format_config = 0x80,
1021	};
1022	struct sk_buff *skb;
1023	u32 val;
1024	int err;
1025
1026	/* Enable SCO over I2S/PCM for MediaTek chipset */
1027	skb = __hci_cmd_sync(hdev, opcode: 0xfc72, plen: sizeof(sco_setting),
1028	param: &sco_setting, HCI_CMD_TIMEOUT);
1029	if (IS_ERR(ptr: skb))
1030	return PTR_ERR(ptr: skb);
1031
1032	kfree_skb(skb);
1033
1034	err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_0, val: &val);
1035	if (err < 0)
1036	return err;
1037
1038	val |= 0x11000000;
1039	err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_0, val, mask: ~0);
1040	if (err < 0)
1041	return err;
1042
1043	err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, val: &val);
1044	if (err < 0)
1045	return err;
1046
1047	val |= 0x00000101;
1048	err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, mask: ~0);
1049	if (err < 0)
1050	return err;
1051
1052	hdev->get_data_path_id = btmtksdio_get_data_path_id;
1053	hdev->get_codec_config_data = btmtksdio_get_codec_config_data;
1054
1055	return err;
1056	}
1057
1058	static int btmtksdio_reset_setting(struct hci_dev *hdev)
1059	{
1060	int err;
1061	u32 val;
1062
1063	err = btmtksdio_mtk_reg_read(hdev, MT7921_PINMUX_1, val: &val);
1064	if (err < 0)
1065	return err;
1066
1067	val |= 0x20; /* set the pin (bit field 11:8) work as GPIO mode */
1068	err = btmtksdio_mtk_reg_write(hdev, MT7921_PINMUX_1, val, mask: ~0);
1069	if (err < 0)
1070	return err;
1071
1072	err = btmtksdio_mtk_reg_read(hdev, MT7921_BTSYS_RST, val: &val);
1073	if (err < 0)
1074	return err;
1075
1076	val |= MT7921_BTSYS_RST_WITH_GPIO;
1077	return btmtksdio_mtk_reg_write(hdev, MT7921_BTSYS_RST, val, mask: ~0);
1078	}
1079
1080	static int btmtksdio_setup(struct hci_dev *hdev)
1081	{
1082	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1083	ktime_t calltime, delta, rettime;
1084	unsigned long long duration;
1085	char fwname[64];
1086	int err, dev_id;
1087	u32 fw_version = 0, val;
1088
1089	calltime = ktime_get();
1090	set_bit(BTMTKSDIO_HW_TX_READY, addr: &bdev->tx_state);
1091
1092	switch (bdev->data->chipid) {
1093	case 0x7921:
1094	if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state)) {
1095	err = btmtksdio_mtk_reg_read(hdev, MT7921_DLSTATUS,
1096	val: &val);
1097	if (err < 0)
1098	return err;
1099
1100	val &= ~BT_DL_STATE;
1101	err = btmtksdio_mtk_reg_write(hdev, MT7921_DLSTATUS,
1102	val, mask: ~0);
1103	if (err < 0)
1104	return err;
1105
1106	btmtksdio_fw_pmctrl(bdev);
1107	msleep(msecs: 20);
1108	btmtksdio_drv_pmctrl(bdev);
1109
1110	clear_bit(BTMTKSDIO_HW_RESET_ACTIVE, addr: &bdev->tx_state);
1111	}
1112
1113	err = btmtksdio_mtk_reg_read(hdev, reg: 0x70010200, val: &dev_id);
1114	if (err < 0) {
1115	bt_dev_err(hdev, "Failed to get device id (%d)", err);
1116	return err;
1117	}
1118
1119	err = btmtksdio_mtk_reg_read(hdev, reg: 0x80021004, val: &fw_version);
1120	if (err < 0) {
1121	bt_dev_err(hdev, "Failed to get fw version (%d)", err);
1122	return err;
1123	}
1124
1125	btmtk_fw_get_filename(buf: fwname, size: sizeof(fwname), dev_id,
1126	fw_ver: fw_version, fw_flavor: 0);
1127
1128	snprintf(buf: fwname, size: sizeof(fwname),
1129	fmt: "mediatek/BT_RAM_CODE_MT%04x_1_%x_hdr.bin",
1130	dev_id & 0xffff, (fw_version & 0xff) + 1);
1131	err = mt79xx_setup(hdev, fwname);
1132	if (err < 0)
1133	return err;
1134
1135	/* Enable SCO over I2S/PCM */
1136	err = btmtksdio_sco_setting(hdev);
1137	if (err < 0) {
1138	bt_dev_err(hdev, "Failed to enable SCO setting (%d)", err);
1139	return err;
1140	}
1141
1142	/* Enable WBS with mSBC codec */
1143	hci_set_quirk(hdev, HCI_QUIRK_WIDEBAND_SPEECH_SUPPORTED);
1144
1145	/* Enable GPIO reset mechanism */
1146	if (bdev->reset) {
1147	err = btmtksdio_reset_setting(hdev);
1148	if (err < 0) {
1149	bt_dev_err(hdev, "Failed to enable Reset setting (%d)", err);
1150	devm_gpiod_put(dev: bdev->dev, desc: bdev->reset);
1151	bdev->reset = NULL;
1152	}
1153	}
1154
1155	break;
1156	case 0x7663:
1157	case 0x7668:
1158	err = mt76xx_setup(hdev, fwname: bdev->data->fwname);
1159	if (err < 0)
1160	return err;
1161	break;
1162	default:
1163	return -ENODEV;
1164	}
1165
1166	rettime = ktime_get();
1167	delta = ktime_sub(rettime, calltime);
1168	duration = (unsigned long long)ktime_to_ns(kt: delta) >> 10;
1169
1170	pm_runtime_set_autosuspend_delay(dev: bdev->dev,
1171	MTKBTSDIO_AUTOSUSPEND_DELAY);
1172	pm_runtime_use_autosuspend(dev: bdev->dev);
1173
1174	err = pm_runtime_set_active(dev: bdev->dev);
1175	if (err < 0)
1176	return err;
1177
1178	/* Default forbid runtime auto suspend, that can be allowed by
1179	* enable_autosuspend flag or the PM runtime entry under sysfs.
1180	*/
1181	pm_runtime_forbid(dev: bdev->dev);
1182	pm_runtime_enable(dev: bdev->dev);
1183
1184	if (enable_autosuspend)
1185	pm_runtime_allow(dev: bdev->dev);
1186
1187	bt_dev_info(hdev, "Device setup in %llu usecs", duration);
1188
1189	return 0;
1190	}
1191
1192	static int btmtksdio_shutdown(struct hci_dev *hdev)
1193	{
1194	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1195	struct btmtk_hci_wmt_params wmt_params;
1196	u8 param = 0x0;
1197	int err;
1198
1199	/* Get back the state to be consistent with the state
1200	* in btmtksdio_setup.
1201	*/
1202	pm_runtime_get_sync(dev: bdev->dev);
1203
1204	/* wmt command only works until the reset is complete */
1205	if (test_bit(BTMTKSDIO_HW_RESET_ACTIVE, &bdev->tx_state))
1206	goto ignore_wmt_cmd;
1207
1208	/* Disable the device */
1209	wmt_params.op = BTMTK_WMT_FUNC_CTRL;
1210	wmt_params.flag = 0;
1211	wmt_params.dlen = sizeof(param);
1212	wmt_params.data = &param;
1213	wmt_params.status = NULL;
1214
1215	err = mtk_hci_wmt_sync(hdev, wmt_params: &wmt_params);
1216	if (err < 0) {
1217	bt_dev_err(hdev, "Failed to send wmt func ctrl (%d)", err);
1218	return err;
1219	}
1220
1221	ignore_wmt_cmd:
1222	pm_runtime_put_noidle(dev: bdev->dev);
1223	pm_runtime_disable(dev: bdev->dev);
1224
1225	return 0;
1226	}
1227
1228	static int btmtksdio_send_frame(struct hci_dev *hdev, struct sk_buff *skb)
1229	{
1230	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1231
1232	switch (hci_skb_pkt_type(skb)) {
1233	case HCI_COMMAND_PKT:
1234	hdev->stat.cmd_tx++;
1235	break;
1236
1237	case HCI_ACLDATA_PKT:
1238	hdev->stat.acl_tx++;
1239	break;
1240
1241	case HCI_SCODATA_PKT:
1242	hdev->stat.sco_tx++;
1243	break;
1244
1245	default:
1246	return -EILSEQ;
1247	}
1248
1249	skb_queue_tail(list: &bdev->txq, newsk: skb);
1250
1251	schedule_work(work: &bdev->txrx_work);
1252
1253	return 0;
1254	}
1255
1256	static void btmtksdio_reset(struct hci_dev *hdev)
1257	{
1258	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1259	u32 status;
1260	int err;
1261
1262	if (!bdev->reset || bdev->data->chipid != 0x7921)
1263	return;
1264
1265	pm_runtime_get_sync(dev: bdev->dev);
1266
1267	if (test_and_set_bit(BTMTKSDIO_HW_RESET_ACTIVE, addr: &bdev->tx_state))
1268	return;
1269
1270	sdio_claim_host(func: bdev->func);
1271
1272	/* set drv_pmctrl if BT is closed before doing reset */
1273	if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) {
1274	sdio_enable_func(func: bdev->func);
1275	btmtksdio_drv_pmctrl(bdev);
1276	}
1277
1278	sdio_writel(func: bdev->func, C_INT_EN_CLR, MTK_REG_CHLPCR, NULL);
1279	skb_queue_purge(list: &bdev->txq);
1280	cancel_work_sync(work: &bdev->txrx_work);
1281
1282	gpiod_set_value_cansleep(desc: bdev->reset, value: 1);
1283	msleep(msecs: 100);
1284	gpiod_set_value_cansleep(desc: bdev->reset, value: 0);
1285
1286	err = readx_poll_timeout(btmtksdio_chcr_query, bdev, status,
1287	status & BT_RST_DONE, 100000, 2000000);
1288	if (err < 0) {
1289	bt_dev_err(hdev, "Failed to reset (%d)", err);
1290	goto err;
1291	}
1292
1293	/* set fw_pmctrl back if BT is closed after doing reset */
1294	if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state)) {
1295	btmtksdio_fw_pmctrl(bdev);
1296	sdio_disable_func(func: bdev->func);
1297	}
1298
1299	clear_bit(BTMTKSDIO_PATCH_ENABLED, addr: &bdev->tx_state);
1300	err:
1301	sdio_release_host(func: bdev->func);
1302
1303	pm_runtime_put_noidle(dev: bdev->dev);
1304	pm_runtime_disable(dev: bdev->dev);
1305
1306	hci_reset_dev(hdev);
1307	}
1308
1309	static bool btmtksdio_sdio_inband_wakeup(struct hci_dev *hdev)
1310	{
1311	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1312
1313	return device_may_wakeup(dev: bdev->dev);
1314	}
1315
1316	static bool btmtksdio_sdio_wakeup(struct hci_dev *hdev)
1317	{
1318	struct btmtksdio_dev *bdev = hci_get_drvdata(hdev);
1319	bool may_wakeup = device_may_wakeup(dev: bdev->dev);
1320	const struct btmtk_wakeon bt_awake = {
1321	.mode = 0x1,
1322	.gpo = 0,
1323	.active_high = 0x1,
1324	.enable_delay = cpu_to_le16(0xc80),
1325	.wakeup_delay = cpu_to_le16(0x20),
1326	};
1327
1328	if (may_wakeup && bdev->data->chipid == 0x7921) {
1329	struct sk_buff *skb;
1330
1331	skb = __hci_cmd_sync(hdev, opcode: 0xfc27, plen: sizeof(bt_awake),
1332	param: &bt_awake, HCI_CMD_TIMEOUT);
1333	if (IS_ERR(ptr: skb))
1334	may_wakeup = false;
1335	else
1336	kfree_skb(skb);
1337	}
1338
1339	return may_wakeup;
1340	}
1341
1342	static int btmtksdio_probe(struct sdio_func *func,
1343	const struct sdio_device_id *id)
1344	{
1345	struct btmtksdio_dev *bdev;
1346	struct hci_dev *hdev;
1347	struct device_node *old_node;
1348	bool restore_node;
1349	int err;
1350
1351	bdev = devm_kzalloc(dev: &func->dev, size: sizeof(*bdev), GFP_KERNEL);
1352	if (!bdev)
1353	return -ENOMEM;
1354
1355	bdev->data = (void *)id->driver_data;
1356	if (!bdev->data)
1357	return -ENODEV;
1358
1359	bdev->dev = &func->dev;
1360	bdev->func = func;
1361
1362	INIT_WORK(&bdev->txrx_work, btmtksdio_txrx_work);
1363	skb_queue_head_init(list: &bdev->txq);
1364
1365	/* Initialize and register HCI device */
1366	hdev = hci_alloc_dev();
1367	if (!hdev) {
1368	dev_err(&func->dev, "Can't allocate HCI device\n");
1369	return -ENOMEM;
1370	}
1371
1372	bdev->hdev = hdev;
1373
1374	hdev->bus = HCI_SDIO;
1375	hci_set_drvdata(hdev, data: bdev);
1376
1377	hdev->open = btmtksdio_open;
1378	hdev->close = btmtksdio_close;
1379	hdev->reset = btmtksdio_reset;
1380	hdev->flush = btmtksdio_flush;
1381	hdev->setup = btmtksdio_setup;
1382	hdev->shutdown = btmtksdio_shutdown;
1383	hdev->send = btmtksdio_send_frame;
1384	hdev->wakeup = btmtksdio_sdio_wakeup;
1385	/*
1386	* If SDIO controller supports wake on Bluetooth, sending a wakeon
1387	* command is not necessary.
1388	*/
1389	if (device_can_wakeup(dev: func->card->host->parent))
1390	hdev->wakeup = btmtksdio_sdio_inband_wakeup;
1391	else
1392	hdev->wakeup = btmtksdio_sdio_wakeup;
1393	hdev->set_bdaddr = btmtk_set_bdaddr;
1394
1395	SET_HCIDEV_DEV(hdev, &func->dev);
1396
1397	hdev->manufacturer = 70;
1398	hci_set_quirk(hdev, HCI_QUIRK_NON_PERSISTENT_SETUP);
1399
1400	sdio_set_drvdata(func, bdev);
1401
1402	err = hci_register_dev(hdev);
1403	if (err < 0) {
1404	dev_err(&func->dev, "Can't register HCI device\n");
1405	hci_free_dev(hdev);
1406	return err;
1407	}
1408
1409	/* pm_runtime_enable would be done after the firmware is being
1410	* downloaded because the core layer probably already enables
1411	* runtime PM for this func such as the case host->caps &
1412	* MMC_CAP_POWER_OFF_CARD.
1413	*/
1414	if (pm_runtime_enabled(dev: bdev->dev))
1415	pm_runtime_disable(dev: bdev->dev);
1416
1417	/* As explanation in drivers/mmc/core/sdio_bus.c tells us:
1418	* Unbound SDIO functions are always suspended.
1419	* During probe, the function is set active and the usage count
1420	* is incremented. If the driver supports runtime PM,
1421	* it should call pm_runtime_put_noidle() in its probe routine and
1422	* pm_runtime_get_noresume() in its remove routine.
1423	*
1424	* So, put a pm_runtime_put_noidle here !
1425	*/
1426	pm_runtime_put_noidle(dev: bdev->dev);
1427
1428	err = devm_device_init_wakeup(dev: bdev->dev);
1429	if (err)
1430	bt_dev_err(hdev, "failed to initialize device wakeup");
1431
1432	restore_node = false;
1433	if (!of_device_is_compatible(device: bdev->dev->of_node, "mediatek,mt7921s-bluetooth")) {
1434	restore_node = true;
1435	old_node = bdev->dev->of_node;
1436	bdev->dev->of_node = of_find_compatible_node(NULL, NULL,
1437	compat: "mediatek,mt7921s-bluetooth");
1438	}
1439
1440	bdev->reset = devm_gpiod_get_optional(dev: bdev->dev, con_id: "reset",
1441	flags: GPIOD_OUT_LOW);
1442	if (IS_ERR(ptr: bdev->reset))
1443	err = PTR_ERR(ptr: bdev->reset);
1444
1445	if (restore_node) {
1446	of_node_put(node: bdev->dev->of_node);
1447	bdev->dev->of_node = old_node;
1448	}
1449
1450	return err;
1451	}
1452
1453	static void btmtksdio_remove(struct sdio_func *func)
1454	{
1455	struct btmtksdio_dev *bdev = sdio_get_drvdata(func);
1456	struct hci_dev *hdev;
1457
1458	if (!bdev)
1459	return;
1460
1461	hdev = bdev->hdev;
1462
1463	/* Make sure to call btmtksdio_close before removing sdio card */
1464	if (test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1465	btmtksdio_close(hdev);
1466
1467	/* Be consistent the state in btmtksdio_probe */
1468	pm_runtime_get_noresume(dev: bdev->dev);
1469
1470	sdio_set_drvdata(func, NULL);
1471	hci_unregister_dev(hdev);
1472	hci_free_dev(hdev);
1473	}
1474
1475	#ifdef CONFIG_PM
1476	static int btmtksdio_runtime_suspend(struct device *dev)
1477	{
1478	struct sdio_func *func = dev_to_sdio_func(dev);
1479	struct btmtksdio_dev *bdev;
1480	int err;
1481
1482	bdev = sdio_get_drvdata(func);
1483	if (!bdev)
1484	return 0;
1485
1486	if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1487	return 0;
1488
1489	sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
1490
1491	err = btmtksdio_fw_pmctrl(bdev);
1492
1493	bt_dev_dbg(bdev->hdev, "status (%d) return ownership to device", err);
1494
1495	return err;
1496	}
1497
1498	static int btmtksdio_system_suspend(struct device *dev)
1499	{
1500	struct sdio_func *func = dev_to_sdio_func(dev);
1501	struct btmtksdio_dev *bdev;
1502
1503	bdev = sdio_get_drvdata(func);
1504	if (!bdev)
1505	return 0;
1506
1507	if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1508	return 0;
1509
1510	set_bit(BTMTKSDIO_BT_WAKE_ENABLED, addr: &bdev->tx_state);
1511
1512	return btmtksdio_runtime_suspend(dev);
1513	}
1514
1515	static int btmtksdio_runtime_resume(struct device *dev)
1516	{
1517	struct sdio_func *func = dev_to_sdio_func(dev);
1518	struct btmtksdio_dev *bdev;
1519	int err;
1520
1521	bdev = sdio_get_drvdata(func);
1522	if (!bdev)
1523	return 0;
1524
1525	if (!test_bit(BTMTKSDIO_FUNC_ENABLED, &bdev->tx_state))
1526	return 0;
1527
1528	err = btmtksdio_drv_pmctrl(bdev);
1529
1530	bt_dev_dbg(bdev->hdev, "status (%d) get ownership from device", err);
1531
1532	return err;
1533	}
1534
1535	static int btmtksdio_system_resume(struct device *dev)
1536	{
1537	return btmtksdio_runtime_resume(dev);
1538	}
1539
1540	static const struct dev_pm_ops btmtksdio_pm_ops = {
1541	SYSTEM_SLEEP_PM_OPS(btmtksdio_system_suspend, btmtksdio_system_resume)
1542	RUNTIME_PM_OPS(btmtksdio_runtime_suspend, btmtksdio_runtime_resume, NULL)
1543	};
1544
1545	#define BTMTKSDIO_PM_OPS (&btmtksdio_pm_ops)
1546	#else /* CONFIG_PM */
1547	#define BTMTKSDIO_PM_OPS NULL
1548	#endif /* CONFIG_PM */
1549
1550	static struct sdio_driver btmtksdio_driver = {
1551	.name = "btmtksdio",
1552	.probe = btmtksdio_probe,
1553	.remove = btmtksdio_remove,
1554	.id_table = btmtksdio_table,
1555	.drv = {
1556	.pm = BTMTKSDIO_PM_OPS,
1557	}
1558	};
1559
1560	module_sdio_driver(btmtksdio_driver);
1561
1562	module_param(enable_autosuspend, bool, 0644);
1563	MODULE_PARM_DESC(enable_autosuspend, "Enable autosuspend by default");
1564
1565	MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
1566	MODULE_DESCRIPTION("MediaTek Bluetooth SDIO driver ver " VERSION);
1567	MODULE_VERSION(VERSION);
1568	MODULE_LICENSE("GPL");
1569