1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // Mediatek ALSA BT SCO CVSD/MSBC Driver
4 //
5 // Copyright (c) 2019 MediaTek Inc.
6 // Author: KaiChieh Chuang <kaichieh.chuang@mediatek.com>
7 
8 #include <linux/mfd/syscon.h>
9 #include <linux/module.h>
10 #include <linux/of_address.h>
11 #include <linux/sched/clock.h>
12 
13 #include <sound/soc.h>
14 
15 #define BTCVSD_SND_NAME "mtk-btcvsd-snd"
16 
17 #define BT_CVSD_TX_NREADY	BIT(21)
18 #define BT_CVSD_RX_READY	BIT(22)
19 #define BT_CVSD_TX_UNDERFLOW	BIT(23)
20 #define BT_CVSD_RX_OVERFLOW	BIT(24)
21 #define BT_CVSD_INTERRUPT	BIT(31)
22 
23 #define BT_CVSD_CLEAR \
24 	(BT_CVSD_TX_NREADY | BT_CVSD_RX_READY | BT_CVSD_TX_UNDERFLOW |\
25 	 BT_CVSD_RX_OVERFLOW | BT_CVSD_INTERRUPT)
26 
27 /* TX */
28 #define SCO_TX_ENCODE_SIZE (60)
29 /* 18 = 6 * 180 / SCO_TX_ENCODE_SIZE */
30 #define SCO_TX_PACKER_BUF_NUM (18)
31 
32 /* RX */
33 #define SCO_RX_PLC_SIZE (30)
34 #define SCO_RX_PACKER_BUF_NUM (64)
35 #define SCO_RX_PACKET_MASK (0x3F)
36 
37 #define SCO_CVSD_PACKET_VALID_SIZE 2
38 
39 #define SCO_PACKET_120 120
40 #define SCO_PACKET_180 180
41 
42 #define BTCVSD_RX_PACKET_SIZE (SCO_RX_PLC_SIZE + SCO_CVSD_PACKET_VALID_SIZE)
43 #define BTCVSD_TX_PACKET_SIZE (SCO_TX_ENCODE_SIZE)
44 
45 #define BTCVSD_RX_BUF_SIZE (BTCVSD_RX_PACKET_SIZE * SCO_RX_PACKER_BUF_NUM)
46 #define BTCVSD_TX_BUF_SIZE (BTCVSD_TX_PACKET_SIZE * SCO_TX_PACKER_BUF_NUM)
47 
48 enum bt_sco_state {
49 	BT_SCO_STATE_IDLE,
50 	BT_SCO_STATE_RUNNING,
51 	BT_SCO_STATE_ENDING,
52 	BT_SCO_STATE_LOOPBACK,
53 };
54 
55 enum bt_sco_direct {
56 	BT_SCO_DIRECT_BT2ARM,
57 	BT_SCO_DIRECT_ARM2BT,
58 };
59 
60 enum bt_sco_packet_len {
61 	BT_SCO_CVSD_30 = 0,
62 	BT_SCO_CVSD_60,
63 	BT_SCO_CVSD_90,
64 	BT_SCO_CVSD_120,
65 	BT_SCO_CVSD_10,
66 	BT_SCO_CVSD_20,
67 	BT_SCO_CVSD_MAX,
68 };
69 
70 enum BT_SCO_BAND {
71 	BT_SCO_NB,
72 	BT_SCO_WB,
73 };
74 
75 struct mtk_btcvsd_snd_hw_info {
76 	unsigned int num_valid_addr;
77 	unsigned long bt_sram_addr[20];
78 	unsigned int packet_length;
79 	unsigned int packet_num;
80 };
81 
82 struct mtk_btcvsd_snd_stream {
83 	struct snd_pcm_substream *substream;
84 	int stream;
85 
86 	enum bt_sco_state state;
87 
88 	unsigned int packet_size;
89 	unsigned int buf_size;
90 	u8 temp_packet_buf[SCO_PACKET_180];
91 
92 	int packet_w;
93 	int packet_r;
94 	snd_pcm_uframes_t prev_frame;
95 	int prev_packet_idx;
96 
97 	unsigned int xrun:1;
98 	unsigned int timeout:1;
99 	unsigned int mute:1;
100 	unsigned int trigger_start:1;
101 	unsigned int wait_flag:1;
102 	unsigned int rw_cnt;
103 
104 	unsigned long long time_stamp;
105 	unsigned long long buf_data_equivalent_time;
106 
107 	struct mtk_btcvsd_snd_hw_info buffer_info;
108 };
109 
110 struct mtk_btcvsd_snd {
111 	struct device *dev;
112 	int irq_id;
113 
114 	struct regmap *infra;
115 	void __iomem *bt_pkv_base;
116 	void __iomem *bt_sram_bank2_base;
117 
118 	unsigned int infra_misc_offset;
119 	unsigned int conn_bt_cvsd_mask;
120 	unsigned int cvsd_mcu_read_offset;
121 	unsigned int cvsd_mcu_write_offset;
122 	unsigned int cvsd_packet_indicator;
123 
124 	u32 *bt_reg_pkt_r;
125 	u32 *bt_reg_pkt_w;
126 	u32 *bt_reg_ctl;
127 
128 	unsigned int irq_disabled:1;
129 
130 	spinlock_t tx_lock;	/* spinlock for bt tx stream control */
131 	spinlock_t rx_lock;	/* spinlock for bt rx stream control */
132 	wait_queue_head_t tx_wait;
133 	wait_queue_head_t rx_wait;
134 
135 	struct mtk_btcvsd_snd_stream *tx;
136 	struct mtk_btcvsd_snd_stream *rx;
137 	u8 tx_packet_buf[BTCVSD_TX_BUF_SIZE];
138 	u8 rx_packet_buf[BTCVSD_RX_BUF_SIZE];
139 
140 	enum BT_SCO_BAND band;
141 };
142 
143 struct mtk_btcvsd_snd_time_buffer_info {
144 	unsigned long long data_count_equi_time;
145 	unsigned long long time_stamp_us;
146 };
147 
148 static const unsigned int btsco_packet_valid_mask[BT_SCO_CVSD_MAX][6] = {
149 	{0x1, 0x1 << 1, 0x1 << 2, 0x1 << 3, 0x1 << 4, 0x1 << 5},
150 	{0x1, 0x1, 0x2, 0x2, 0x4, 0x4},
151 	{0x1, 0x1, 0x1, 0x2, 0x2, 0x2},
152 	{0x1, 0x1, 0x1, 0x1, 0x0, 0x0},
153 	{0x7, 0x7 << 3, 0x7 << 6, 0x7 << 9, 0x7 << 12, 0x7 << 15},
154 	{0x3, 0x3 << 1, 0x3 << 3, 0x3 << 4, 0x3 << 6, 0x3 << 7},
155 };
156 
157 static const unsigned int btsco_packet_info[BT_SCO_CVSD_MAX][4] = {
158 	{30, 6, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
159 	 SCO_PACKET_180 / SCO_RX_PLC_SIZE},
160 	{60, 3, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
161 	 SCO_PACKET_180 / SCO_RX_PLC_SIZE},
162 	{90, 2, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
163 	 SCO_PACKET_180 / SCO_RX_PLC_SIZE},
164 	{120, 1, SCO_PACKET_120 / SCO_TX_ENCODE_SIZE,
165 	 SCO_PACKET_120 / SCO_RX_PLC_SIZE},
166 	{10, 18, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
167 	 SCO_PACKET_180 / SCO_RX_PLC_SIZE},
168 	{20, 9, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
169 	 SCO_PACKET_180 / SCO_RX_PLC_SIZE},
170 };
171 
172 static const u8 table_msbc_silence[SCO_PACKET_180] = {
173 	0x01, 0x38, 0xad, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00,
174 	0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d,
175 	0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7,
176 	0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd,
177 	0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77,
178 	0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6c, 0x00,
179 	0x01, 0xc8, 0xad, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00,
180 	0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d,
181 	0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7,
182 	0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd,
183 	0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77,
184 	0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6c, 0x00,
185 	0x01, 0xf8, 0xad, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00,
186 	0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d,
187 	0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7,
188 	0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd,
189 	0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77,
190 	0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6c, 0x00
191 };
192 
193 static void mtk_btcvsd_snd_irq_enable(struct mtk_btcvsd_snd *bt)
194 {
195 	regmap_update_bits(bt->infra, bt->infra_misc_offset,
196 			   bt->conn_bt_cvsd_mask, 0);
197 }
198 
199 static void mtk_btcvsd_snd_irq_disable(struct mtk_btcvsd_snd *bt)
200 {
201 	regmap_update_bits(bt->infra, bt->infra_misc_offset,
202 			   bt->conn_bt_cvsd_mask, bt->conn_bt_cvsd_mask);
203 }
204 
205 static void mtk_btcvsd_snd_set_state(struct mtk_btcvsd_snd *bt,
206 				     struct mtk_btcvsd_snd_stream *bt_stream,
207 				     int state)
208 {
209 	dev_dbg(bt->dev, "%s(), stream %d, state %d, tx->state %d, rx->state %d, irq_disabled %d\n",
210 		__func__,
211 		bt_stream->stream, state,
212 		bt->tx->state, bt->rx->state, bt->irq_disabled);
213 
214 	bt_stream->state = state;
215 
216 	if (bt->tx->state == BT_SCO_STATE_IDLE &&
217 	    bt->rx->state == BT_SCO_STATE_IDLE) {
218 		if (!bt->irq_disabled) {
219 			disable_irq(bt->irq_id);
220 			mtk_btcvsd_snd_irq_disable(bt);
221 			bt->irq_disabled = 1;
222 		}
223 	} else {
224 		if (bt->irq_disabled) {
225 			enable_irq(bt->irq_id);
226 			mtk_btcvsd_snd_irq_enable(bt);
227 			bt->irq_disabled = 0;
228 		}
229 	}
230 }
231 
232 static int mtk_btcvsd_snd_tx_init(struct mtk_btcvsd_snd *bt)
233 {
234 	memset(bt->tx, 0, sizeof(*bt->tx));
235 	memset(bt->tx_packet_buf, 0, sizeof(bt->tx_packet_buf));
236 
237 	bt->tx->packet_size = BTCVSD_TX_PACKET_SIZE;
238 	bt->tx->buf_size = BTCVSD_TX_BUF_SIZE;
239 	bt->tx->timeout = 0;
240 	bt->tx->rw_cnt = 0;
241 	bt->tx->stream = SNDRV_PCM_STREAM_PLAYBACK;
242 	return 0;
243 }
244 
245 static int mtk_btcvsd_snd_rx_init(struct mtk_btcvsd_snd *bt)
246 {
247 	memset(bt->rx, 0, sizeof(*bt->rx));
248 	memset(bt->rx_packet_buf, 0, sizeof(bt->rx_packet_buf));
249 
250 	bt->rx->packet_size = BTCVSD_RX_PACKET_SIZE;
251 	bt->rx->buf_size = BTCVSD_RX_BUF_SIZE;
252 	bt->rx->timeout = 0;
253 	bt->rx->rw_cnt = 0;
254 	bt->rx->stream = SNDRV_PCM_STREAM_CAPTURE;
255 	return 0;
256 }
257 
258 static void get_tx_time_stamp(struct mtk_btcvsd_snd *bt,
259 			      struct mtk_btcvsd_snd_time_buffer_info *ts)
260 {
261 	ts->time_stamp_us = bt->tx->time_stamp;
262 	ts->data_count_equi_time = bt->tx->buf_data_equivalent_time;
263 }
264 
265 static void get_rx_time_stamp(struct mtk_btcvsd_snd *bt,
266 			      struct mtk_btcvsd_snd_time_buffer_info *ts)
267 {
268 	ts->time_stamp_us = bt->rx->time_stamp;
269 	ts->data_count_equi_time = bt->rx->buf_data_equivalent_time;
270 }
271 
272 static int btcvsd_bytes_to_frame(struct snd_pcm_substream *substream,
273 				 int bytes)
274 {
275 	int count = bytes;
276 	struct snd_pcm_runtime *runtime = substream->runtime;
277 
278 	if (runtime->format == SNDRV_PCM_FORMAT_S32_LE ||
279 	    runtime->format == SNDRV_PCM_FORMAT_U32_LE)
280 		count = count >> 2;
281 	else
282 		count = count >> 1;
283 
284 	count = count / runtime->channels;
285 	return count;
286 }
287 
288 static void mtk_btcvsd_snd_data_transfer(enum bt_sco_direct dir,
289 					 u8 *src, u8 *dst,
290 					 unsigned int blk_size,
291 					 unsigned int blk_num)
292 {
293 	unsigned int i, j;
294 
295 	if (blk_size == 60 || blk_size == 120 || blk_size == 20) {
296 		u32 *src_32 = (u32 *)src;
297 		u32 *dst_32 = (u32 *)dst;
298 
299 		for (i = 0; i < (blk_size * blk_num / 4); i++)
300 			*dst_32++ = *src_32++;
301 	} else {
302 		u16 *src_16 = (u16 *)src;
303 		u16 *dst_16 = (u16 *)dst;
304 
305 		for (j = 0; j < blk_num; j++) {
306 			for (i = 0; i < (blk_size / 2); i++)
307 				*dst_16++ = *src_16++;
308 
309 			if (dir == BT_SCO_DIRECT_BT2ARM)
310 				src_16++;
311 			else
312 				dst_16++;
313 		}
314 	}
315 }
316 
317 /* write encoded mute data to bt sram */
318 static int btcvsd_tx_clean_buffer(struct mtk_btcvsd_snd *bt)
319 {
320 	unsigned int i;
321 	unsigned int num_valid_addr;
322 	unsigned long flags;
323 	enum BT_SCO_BAND band = bt->band;
324 
325 	/* prepare encoded mute data */
326 	if (band == BT_SCO_NB)
327 		memset(bt->tx->temp_packet_buf, 170, SCO_PACKET_180);
328 	else
329 		memcpy(bt->tx->temp_packet_buf,
330 		       table_msbc_silence, SCO_PACKET_180);
331 
332 	/* write mute data to bt tx sram buffer */
333 	spin_lock_irqsave(&bt->tx_lock, flags);
334 	num_valid_addr = bt->tx->buffer_info.num_valid_addr;
335 
336 	dev_info(bt->dev, "%s(), band %d, num_valid_addr %u\n",
337 		 __func__, band, num_valid_addr);
338 
339 	for (i = 0; i < num_valid_addr; i++) {
340 		void *dst;
341 
342 		dev_info(bt->dev, "%s(), clean addr 0x%lx\n", __func__,
343 			 bt->tx->buffer_info.bt_sram_addr[i]);
344 
345 		dst = (void *)bt->tx->buffer_info.bt_sram_addr[i];
346 
347 		mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT,
348 					     bt->tx->temp_packet_buf, dst,
349 					     bt->tx->buffer_info.packet_length,
350 					     bt->tx->buffer_info.packet_num);
351 	}
352 	spin_unlock_irqrestore(&bt->tx_lock, flags);
353 
354 	return 0;
355 }
356 
357 static int mtk_btcvsd_read_from_bt(struct mtk_btcvsd_snd *bt,
358 				   enum bt_sco_packet_len packet_type,
359 				   unsigned int packet_length,
360 				   unsigned int packet_num,
361 				   unsigned int blk_size,
362 				   unsigned int control)
363 {
364 	unsigned int i;
365 	int pv;
366 	u8 *src;
367 	unsigned int packet_buf_ofs;
368 	unsigned long flags;
369 	unsigned long connsys_addr_rx, ap_addr_rx;
370 
371 	connsys_addr_rx = *bt->bt_reg_pkt_r;
372 	ap_addr_rx = (unsigned long)bt->bt_sram_bank2_base +
373 		     (connsys_addr_rx & 0xFFFF);
374 
375 	if (connsys_addr_rx == 0xdeadfeed) {
376 		/* bt return 0xdeadfeed if read register during bt sleep */
377 		dev_warn(bt->dev, "%s(), connsys_addr_rx == 0xdeadfeed",
378 			 __func__);
379 		return -EIO;
380 	}
381 
382 	src = (u8 *)ap_addr_rx;
383 
384 	mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_BT2ARM, src,
385 				     bt->rx->temp_packet_buf, packet_length,
386 				     packet_num);
387 
388 	spin_lock_irqsave(&bt->rx_lock, flags);
389 	for (i = 0; i < blk_size; i++) {
390 		packet_buf_ofs = (bt->rx->packet_w & SCO_RX_PACKET_MASK) *
391 				 bt->rx->packet_size;
392 		memcpy(bt->rx_packet_buf + packet_buf_ofs,
393 		       bt->rx->temp_packet_buf + (SCO_RX_PLC_SIZE * i),
394 		       SCO_RX_PLC_SIZE);
395 		if ((control & btsco_packet_valid_mask[packet_type][i]) ==
396 		    btsco_packet_valid_mask[packet_type][i])
397 			pv = 1;
398 		else
399 			pv = 0;
400 
401 		packet_buf_ofs += SCO_RX_PLC_SIZE;
402 		memcpy(bt->rx_packet_buf + packet_buf_ofs, (void *)&pv,
403 		       SCO_CVSD_PACKET_VALID_SIZE);
404 		bt->rx->packet_w++;
405 	}
406 	spin_unlock_irqrestore(&bt->rx_lock, flags);
407 	return 0;
408 }
409 
410 static int mtk_btcvsd_write_to_bt(struct mtk_btcvsd_snd *bt,
411 				  enum bt_sco_packet_len packet_type,
412 				  unsigned int packet_length,
413 				  unsigned int packet_num,
414 				  unsigned int blk_size)
415 {
416 	unsigned int i;
417 	unsigned long flags;
418 	u8 *dst;
419 	unsigned long connsys_addr_tx, ap_addr_tx;
420 	bool new_ap_addr_tx = true;
421 
422 	connsys_addr_tx = *bt->bt_reg_pkt_w;
423 	ap_addr_tx = (unsigned long)bt->bt_sram_bank2_base +
424 		     (connsys_addr_tx & 0xFFFF);
425 
426 	if (connsys_addr_tx == 0xdeadfeed) {
427 		/* bt return 0xdeadfeed if read register during bt sleep */
428 		dev_warn(bt->dev, "%s(), connsys_addr_tx == 0xdeadfeed\n",
429 			 __func__);
430 		return -EIO;
431 	}
432 
433 	spin_lock_irqsave(&bt->tx_lock, flags);
434 	for (i = 0; i < blk_size; i++) {
435 		memcpy(bt->tx->temp_packet_buf + (bt->tx->packet_size * i),
436 		       (bt->tx_packet_buf +
437 			(bt->tx->packet_r % SCO_TX_PACKER_BUF_NUM) *
438 			bt->tx->packet_size),
439 		       bt->tx->packet_size);
440 
441 		bt->tx->packet_r++;
442 	}
443 	spin_unlock_irqrestore(&bt->tx_lock, flags);
444 
445 	dst = (u8 *)ap_addr_tx;
446 
447 	if (!bt->tx->mute) {
448 		mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT,
449 					     bt->tx->temp_packet_buf, dst,
450 					     packet_length, packet_num);
451 	}
452 
453 	/* store bt tx buffer sram info */
454 	bt->tx->buffer_info.packet_length = packet_length;
455 	bt->tx->buffer_info.packet_num = packet_num;
456 	for (i = 0; i < bt->tx->buffer_info.num_valid_addr; i++) {
457 		if (bt->tx->buffer_info.bt_sram_addr[i] == ap_addr_tx) {
458 			new_ap_addr_tx = false;
459 			break;
460 		}
461 	}
462 	if (new_ap_addr_tx) {
463 		unsigned int next_idx;
464 
465 		spin_lock_irqsave(&bt->tx_lock, flags);
466 		bt->tx->buffer_info.num_valid_addr++;
467 		next_idx = bt->tx->buffer_info.num_valid_addr - 1;
468 		bt->tx->buffer_info.bt_sram_addr[next_idx] = ap_addr_tx;
469 		spin_unlock_irqrestore(&bt->tx_lock, flags);
470 		dev_info(bt->dev, "%s(), new ap_addr_tx = 0x%lx, num_valid_addr %d\n",
471 			 __func__, ap_addr_tx,
472 			 bt->tx->buffer_info.num_valid_addr);
473 	}
474 
475 	if (bt->tx->mute)
476 		btcvsd_tx_clean_buffer(bt);
477 
478 	return 0;
479 }
480 
481 static irqreturn_t mtk_btcvsd_snd_irq_handler(int irq_id, void *dev)
482 {
483 	struct mtk_btcvsd_snd *bt = dev;
484 	unsigned int packet_type, packet_num, packet_length;
485 	unsigned int buf_cnt_tx, buf_cnt_rx, control;
486 
487 	if (bt->rx->state != BT_SCO_STATE_RUNNING &&
488 	    bt->rx->state != BT_SCO_STATE_ENDING &&
489 	    bt->tx->state != BT_SCO_STATE_RUNNING &&
490 	    bt->tx->state != BT_SCO_STATE_ENDING &&
491 	    bt->tx->state != BT_SCO_STATE_LOOPBACK) {
492 		dev_warn(bt->dev, "%s(), in idle state: rx->state: %d, tx->state: %d\n",
493 			 __func__, bt->rx->state, bt->tx->state);
494 		goto irq_handler_exit;
495 	}
496 
497 	control = *bt->bt_reg_ctl;
498 	packet_type = (control >> 18) & 0x7;
499 
500 	if (((control >> 31) & 1) == 0) {
501 		dev_warn(bt->dev, "%s(), ((control >> 31) & 1) == 0, control 0x%x\n",
502 			 __func__, control);
503 		goto irq_handler_exit;
504 	}
505 
506 	if (packet_type >= BT_SCO_CVSD_MAX) {
507 		dev_warn(bt->dev, "%s(), invalid packet_type %u, exit\n",
508 			 __func__, packet_type);
509 		goto irq_handler_exit;
510 	}
511 
512 	packet_length = btsco_packet_info[packet_type][0];
513 	packet_num = btsco_packet_info[packet_type][1];
514 	buf_cnt_tx = btsco_packet_info[packet_type][2];
515 	buf_cnt_rx = btsco_packet_info[packet_type][3];
516 
517 	if (bt->tx->state == BT_SCO_STATE_LOOPBACK) {
518 		u8 *src, *dst;
519 		unsigned long connsys_addr_rx, ap_addr_rx;
520 		unsigned long connsys_addr_tx, ap_addr_tx;
521 
522 		connsys_addr_rx = *bt->bt_reg_pkt_r;
523 		ap_addr_rx = (unsigned long)bt->bt_sram_bank2_base +
524 			     (connsys_addr_rx & 0xFFFF);
525 
526 		connsys_addr_tx = *bt->bt_reg_pkt_w;
527 		ap_addr_tx = (unsigned long)bt->bt_sram_bank2_base +
528 			     (connsys_addr_tx & 0xFFFF);
529 
530 		if (connsys_addr_tx == 0xdeadfeed ||
531 		    connsys_addr_rx == 0xdeadfeed) {
532 			/* bt return 0xdeadfeed if read reg during bt sleep */
533 			dev_warn(bt->dev, "%s(), connsys_addr_tx == 0xdeadfeed\n",
534 				 __func__);
535 			goto irq_handler_exit;
536 		}
537 
538 		src = (u8 *)ap_addr_rx;
539 		dst = (u8 *)ap_addr_tx;
540 
541 		mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_BT2ARM, src,
542 					     bt->tx->temp_packet_buf,
543 					     packet_length,
544 					     packet_num);
545 		mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT,
546 					     bt->tx->temp_packet_buf, dst,
547 					     packet_length,
548 					     packet_num);
549 		bt->rx->rw_cnt++;
550 		bt->tx->rw_cnt++;
551 	}
552 
553 	if (bt->rx->state == BT_SCO_STATE_RUNNING ||
554 	    bt->rx->state == BT_SCO_STATE_ENDING) {
555 		if (bt->rx->xrun) {
556 			if (bt->rx->packet_w - bt->rx->packet_r <=
557 			    SCO_RX_PACKER_BUF_NUM - 2 * buf_cnt_rx) {
558 				/*
559 				 * free space is larger then
560 				 * twice interrupt rx data size
561 				 */
562 				bt->rx->xrun = 0;
563 				dev_warn(bt->dev, "%s(), rx->xrun 0!\n",
564 					 __func__);
565 			}
566 		}
567 
568 		if (!bt->rx->xrun &&
569 		    (bt->rx->packet_w - bt->rx->packet_r <=
570 		     SCO_RX_PACKER_BUF_NUM - buf_cnt_rx)) {
571 			mtk_btcvsd_read_from_bt(bt,
572 						packet_type,
573 						packet_length,
574 						packet_num,
575 						buf_cnt_rx,
576 						control);
577 			bt->rx->rw_cnt++;
578 		} else {
579 			bt->rx->xrun = 1;
580 			dev_warn(bt->dev, "%s(), rx->xrun 1\n", __func__);
581 		}
582 	}
583 
584 	/* tx */
585 	bt->tx->timeout = 0;
586 	if ((bt->tx->state == BT_SCO_STATE_RUNNING ||
587 	     bt->tx->state == BT_SCO_STATE_ENDING) &&
588 	    bt->tx->trigger_start) {
589 		if (bt->tx->xrun) {
590 			/* prepared data is larger then twice
591 			 * interrupt tx data size
592 			 */
593 			if (bt->tx->packet_w - bt->tx->packet_r >=
594 			    2 * buf_cnt_tx) {
595 				bt->tx->xrun = 0;
596 				dev_warn(bt->dev, "%s(), tx->xrun 0\n",
597 					 __func__);
598 			}
599 		}
600 
601 		if ((!bt->tx->xrun &&
602 		     (bt->tx->packet_w - bt->tx->packet_r >= buf_cnt_tx)) ||
603 		    bt->tx->state == BT_SCO_STATE_ENDING) {
604 			mtk_btcvsd_write_to_bt(bt,
605 					       packet_type,
606 					       packet_length,
607 					       packet_num,
608 					       buf_cnt_tx);
609 			bt->tx->rw_cnt++;
610 		} else {
611 			bt->tx->xrun = 1;
612 			dev_warn(bt->dev, "%s(), tx->xrun 1\n", __func__);
613 		}
614 	}
615 
616 	*bt->bt_reg_ctl &= ~BT_CVSD_CLEAR;
617 
618 	if (bt->rx->state == BT_SCO_STATE_RUNNING ||
619 	    bt->rx->state == BT_SCO_STATE_ENDING) {
620 		bt->rx->wait_flag = 1;
621 		wake_up_interruptible(&bt->rx_wait);
622 		snd_pcm_period_elapsed(bt->rx->substream);
623 	}
624 	if (bt->tx->state == BT_SCO_STATE_RUNNING ||
625 	    bt->tx->state == BT_SCO_STATE_ENDING) {
626 		bt->tx->wait_flag = 1;
627 		wake_up_interruptible(&bt->tx_wait);
628 		snd_pcm_period_elapsed(bt->tx->substream);
629 	}
630 
631 	return IRQ_HANDLED;
632 irq_handler_exit:
633 	*bt->bt_reg_ctl &= ~BT_CVSD_CLEAR;
634 	return IRQ_HANDLED;
635 }
636 
637 static int wait_for_bt_irq(struct mtk_btcvsd_snd *bt,
638 			   struct mtk_btcvsd_snd_stream *bt_stream)
639 {
640 	unsigned long long t1, t2;
641 	/* one interrupt period = 22.5ms */
642 	unsigned long long timeout_limit = 22500000;
643 	int max_timeout_trial = 2;
644 	int ret;
645 
646 	bt_stream->wait_flag = 0;
647 
648 	while (max_timeout_trial && !bt_stream->wait_flag) {
649 		t1 = sched_clock();
650 		if (bt_stream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
651 			ret = wait_event_interruptible_timeout(bt->tx_wait,
652 				bt_stream->wait_flag,
653 				nsecs_to_jiffies(timeout_limit));
654 		} else {
655 			ret = wait_event_interruptible_timeout(bt->rx_wait,
656 				bt_stream->wait_flag,
657 				nsecs_to_jiffies(timeout_limit));
658 		}
659 
660 		t2 = sched_clock();
661 		t2 = t2 - t1; /* in ns (10^9) */
662 
663 		if (t2 > timeout_limit) {
664 			dev_warn(bt->dev, "%s(), stream %d, timeout %llu, limit %llu, ret %d, flag %d\n",
665 				 __func__, bt_stream->stream,
666 				 t2, timeout_limit, ret,
667 				 bt_stream->wait_flag);
668 		}
669 
670 		if (ret < 0) {
671 			/*
672 			 * error, -ERESTARTSYS if it was interrupted by
673 			 * a signal
674 			 */
675 			dev_warn(bt->dev, "%s(), stream %d, error, trial left %d\n",
676 				 __func__,
677 				 bt_stream->stream, max_timeout_trial);
678 
679 			bt_stream->timeout = 1;
680 			return ret;
681 		} else if (ret == 0) {
682 			/* conidtion is false after timeout */
683 			max_timeout_trial--;
684 			dev_warn(bt->dev, "%s(), stream %d, error, timeout, condition is false, trial left %d\n",
685 				 __func__,
686 				 bt_stream->stream, max_timeout_trial);
687 
688 			if (max_timeout_trial <= 0) {
689 				bt_stream->timeout = 1;
690 				return -ETIME;
691 			}
692 		}
693 	}
694 
695 	return 0;
696 }
697 
698 static ssize_t mtk_btcvsd_snd_read(struct mtk_btcvsd_snd *bt,
699 				   char __user *buf,
700 				   size_t count)
701 {
702 	ssize_t read_size = 0, read_count = 0, cur_read_idx, cont;
703 	unsigned int cur_buf_ofs = 0;
704 	unsigned long avail;
705 	unsigned long flags;
706 	unsigned int packet_size = bt->rx->packet_size;
707 
708 	while (count) {
709 		spin_lock_irqsave(&bt->rx_lock, flags);
710 		/* available data in RX packet buffer */
711 		avail = (bt->rx->packet_w - bt->rx->packet_r) * packet_size;
712 
713 		cur_read_idx = (bt->rx->packet_r & SCO_RX_PACKET_MASK) *
714 			       packet_size;
715 		spin_unlock_irqrestore(&bt->rx_lock, flags);
716 
717 		if (!avail) {
718 			int ret = wait_for_bt_irq(bt, bt->rx);
719 
720 			if (ret)
721 				return read_count;
722 
723 			continue;
724 		}
725 
726 		/* count must be multiple of packet_size */
727 		if (count % packet_size != 0 ||
728 		    avail % packet_size != 0) {
729 			dev_warn(bt->dev, "%s(), count %zu or d %lu is not multiple of packet_size %dd\n",
730 				 __func__, count, avail, packet_size);
731 
732 			count -= count % packet_size;
733 			avail -= avail % packet_size;
734 		}
735 
736 		if (count > avail)
737 			read_size = avail;
738 		else
739 			read_size = count;
740 
741 		/* calculate continue space */
742 		cont = bt->rx->buf_size - cur_read_idx;
743 		if (read_size > cont)
744 			read_size = cont;
745 
746 		if (copy_to_user(buf + cur_buf_ofs,
747 				 bt->rx_packet_buf + cur_read_idx,
748 				 read_size)) {
749 			dev_warn(bt->dev, "%s(), copy_to_user fail\n",
750 				 __func__);
751 			return -EFAULT;
752 		}
753 
754 		spin_lock_irqsave(&bt->rx_lock, flags);
755 		bt->rx->packet_r += read_size / packet_size;
756 		spin_unlock_irqrestore(&bt->rx_lock, flags);
757 
758 		read_count += read_size;
759 		cur_buf_ofs += read_size;
760 		count -= read_size;
761 	}
762 
763 	/*
764 	 * save current timestamp & buffer time in times_tamp and
765 	 * buf_data_equivalent_time
766 	 */
767 	bt->rx->time_stamp = sched_clock();
768 	bt->rx->buf_data_equivalent_time =
769 		(unsigned long long)(bt->rx->packet_w - bt->rx->packet_r) *
770 		SCO_RX_PLC_SIZE * 16 * 1000 / 2 / 64;
771 	bt->rx->buf_data_equivalent_time += read_count * SCO_RX_PLC_SIZE *
772 					    16 * 1000 / packet_size / 2 / 64;
773 	/* return equivalent time(us) to data count */
774 	bt->rx->buf_data_equivalent_time *= 1000;
775 
776 	return read_count;
777 }
778 
779 static ssize_t mtk_btcvsd_snd_write(struct mtk_btcvsd_snd *bt,
780 				    char __user *buf,
781 				    size_t count)
782 {
783 	int written_size = count, avail, cur_write_idx, write_size, cont;
784 	unsigned int cur_buf_ofs = 0;
785 	unsigned long flags;
786 	unsigned int packet_size = bt->tx->packet_size;
787 
788 	/*
789 	 * save current timestamp & buffer time in time_stamp and
790 	 * buf_data_equivalent_time
791 	 */
792 	bt->tx->time_stamp = sched_clock();
793 	bt->tx->buf_data_equivalent_time =
794 		(unsigned long long)(bt->tx->packet_w - bt->tx->packet_r) *
795 		packet_size * 16 * 1000 / 2 / 64;
796 
797 	/* return equivalent time(us) to data count */
798 	bt->tx->buf_data_equivalent_time *= 1000;
799 
800 	while (count) {
801 		spin_lock_irqsave(&bt->tx_lock, flags);
802 		/* free space of TX packet buffer */
803 		avail = bt->tx->buf_size -
804 			(bt->tx->packet_w - bt->tx->packet_r) * packet_size;
805 
806 		cur_write_idx = (bt->tx->packet_w % SCO_TX_PACKER_BUF_NUM) *
807 				packet_size;
808 		spin_unlock_irqrestore(&bt->tx_lock, flags);
809 
810 		if (!avail) {
811 			int ret = wait_for_bt_irq(bt, bt->tx);
812 
813 			if (ret)
814 				return written_size;
815 
816 			continue;
817 		}
818 
819 		/* count must be multiple of bt->tx->packet_size */
820 		if (count % packet_size != 0 ||
821 		    avail % packet_size != 0) {
822 			dev_warn(bt->dev, "%s(), count %zu or avail %d is not multiple of packet_size %d\n",
823 				 __func__, count, avail, packet_size);
824 			count -= count % packet_size;
825 			avail -= avail % packet_size;
826 		}
827 
828 		if (count > avail)
829 			write_size = avail;
830 		else
831 			write_size = count;
832 
833 		/* calculate continue space */
834 		cont = bt->tx->buf_size - cur_write_idx;
835 		if (write_size > cont)
836 			write_size = cont;
837 
838 		if (copy_from_user(bt->tx_packet_buf +
839 				   cur_write_idx,
840 				   buf + cur_buf_ofs,
841 				   write_size)) {
842 			dev_warn(bt->dev, "%s(), copy_from_user fail\n",
843 				 __func__);
844 			return -EFAULT;
845 		}
846 
847 		spin_lock_irqsave(&bt->tx_lock, flags);
848 		bt->tx->packet_w += write_size / packet_size;
849 		spin_unlock_irqrestore(&bt->tx_lock, flags);
850 		cur_buf_ofs += write_size;
851 		count -= write_size;
852 	}
853 
854 	return written_size;
855 }
856 
857 static struct mtk_btcvsd_snd_stream *get_bt_stream
858 	(struct mtk_btcvsd_snd *bt, struct snd_pcm_substream *substream)
859 {
860 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
861 		return bt->tx;
862 	else
863 		return bt->rx;
864 }
865 
866 /* pcm ops */
867 static const struct snd_pcm_hardware mtk_btcvsd_hardware = {
868 	.info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
869 		 SNDRV_PCM_INFO_RESUME),
870 	.formats = SNDRV_PCM_FMTBIT_S16_LE,
871 	.buffer_bytes_max = 24 * 1024,
872 	.period_bytes_max = 24 * 1024,
873 	.periods_min = 2,
874 	.periods_max = 16,
875 	.fifo_size = 0,
876 };
877 
878 static int mtk_pcm_btcvsd_open(struct snd_soc_component *component,
879 			       struct snd_pcm_substream *substream)
880 {
881 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
882 	int ret;
883 
884 	dev_dbg(bt->dev, "%s(), stream %d, substream %p\n",
885 		__func__, substream->stream, substream);
886 
887 	snd_soc_set_runtime_hwparams(substream, &mtk_btcvsd_hardware);
888 
889 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
890 		ret = mtk_btcvsd_snd_tx_init(bt);
891 		bt->tx->substream = substream;
892 	} else {
893 		ret = mtk_btcvsd_snd_rx_init(bt);
894 		bt->rx->substream = substream;
895 	}
896 
897 	return ret;
898 }
899 
900 static int mtk_pcm_btcvsd_close(struct snd_soc_component *component,
901 				struct snd_pcm_substream *substream)
902 {
903 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
904 	struct mtk_btcvsd_snd_stream *bt_stream = get_bt_stream(bt, substream);
905 
906 	dev_dbg(bt->dev, "%s(), stream %d\n", __func__, substream->stream);
907 
908 	mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_IDLE);
909 	bt_stream->substream = NULL;
910 	return 0;
911 }
912 
913 static int mtk_pcm_btcvsd_hw_params(struct snd_soc_component *component,
914 				    struct snd_pcm_substream *substream,
915 				    struct snd_pcm_hw_params *hw_params)
916 {
917 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
918 
919 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
920 	    params_buffer_bytes(hw_params) % bt->tx->packet_size != 0) {
921 		dev_warn(bt->dev, "%s(), error, buffer size %d not valid\n",
922 			 __func__,
923 			 params_buffer_bytes(hw_params));
924 		return -EINVAL;
925 	}
926 
927 	substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
928 	return 0;
929 }
930 
931 static int mtk_pcm_btcvsd_hw_free(struct snd_soc_component *component,
932 				  struct snd_pcm_substream *substream)
933 {
934 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
935 
936 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
937 		btcvsd_tx_clean_buffer(bt);
938 
939 	return 0;
940 }
941 
942 static int mtk_pcm_btcvsd_prepare(struct snd_soc_component *component,
943 				  struct snd_pcm_substream *substream)
944 {
945 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
946 	struct mtk_btcvsd_snd_stream *bt_stream = get_bt_stream(bt, substream);
947 
948 	dev_dbg(bt->dev, "%s(), stream %d\n", __func__, substream->stream);
949 
950 	mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_RUNNING);
951 	return 0;
952 }
953 
954 static int mtk_pcm_btcvsd_trigger(struct snd_soc_component *component,
955 				  struct snd_pcm_substream *substream, int cmd)
956 {
957 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
958 	struct mtk_btcvsd_snd_stream *bt_stream = get_bt_stream(bt, substream);
959 	int stream = substream->stream;
960 	int hw_packet_ptr;
961 
962 	dev_dbg(bt->dev, "%s(), stream %d, cmd %d\n",
963 		__func__, substream->stream, cmd);
964 
965 	switch (cmd) {
966 	case SNDRV_PCM_TRIGGER_START:
967 	case SNDRV_PCM_TRIGGER_RESUME:
968 		hw_packet_ptr = stream == SNDRV_PCM_STREAM_PLAYBACK ?
969 				bt_stream->packet_r : bt_stream->packet_w;
970 		bt_stream->prev_packet_idx = hw_packet_ptr;
971 		bt_stream->prev_frame = 0;
972 		bt_stream->trigger_start = 1;
973 		return 0;
974 	case SNDRV_PCM_TRIGGER_STOP:
975 	case SNDRV_PCM_TRIGGER_SUSPEND:
976 		bt_stream->trigger_start = 0;
977 		mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_ENDING);
978 		return 0;
979 	default:
980 		return -EINVAL;
981 	}
982 }
983 
984 static snd_pcm_uframes_t mtk_pcm_btcvsd_pointer(
985 	struct snd_soc_component *component,
986 	struct snd_pcm_substream *substream)
987 {
988 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
989 	struct mtk_btcvsd_snd_stream *bt_stream;
990 	snd_pcm_uframes_t frame = 0;
991 	int byte = 0;
992 	int hw_packet_ptr;
993 	int packet_diff;
994 	spinlock_t *lock;	/* spinlock for bt stream control */
995 	unsigned long flags;
996 
997 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
998 		lock = &bt->tx_lock;
999 		bt_stream = bt->tx;
1000 	} else {
1001 		lock = &bt->rx_lock;
1002 		bt_stream = bt->rx;
1003 	}
1004 
1005 	spin_lock_irqsave(lock, flags);
1006 	hw_packet_ptr = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
1007 			bt->tx->packet_r : bt->rx->packet_w;
1008 
1009 	/* get packet diff from last time */
1010 	if (hw_packet_ptr >= bt_stream->prev_packet_idx) {
1011 		packet_diff = hw_packet_ptr - bt_stream->prev_packet_idx;
1012 	} else {
1013 		/* integer overflow */
1014 		packet_diff = (INT_MAX - bt_stream->prev_packet_idx) +
1015 			      (hw_packet_ptr - INT_MIN) + 1;
1016 	}
1017 	bt_stream->prev_packet_idx = hw_packet_ptr;
1018 
1019 	/* increased bytes */
1020 	byte = packet_diff * bt_stream->packet_size;
1021 
1022 	frame = btcvsd_bytes_to_frame(substream, byte);
1023 	frame += bt_stream->prev_frame;
1024 	frame %= substream->runtime->buffer_size;
1025 
1026 	bt_stream->prev_frame = frame;
1027 
1028 	spin_unlock_irqrestore(lock, flags);
1029 
1030 	return frame;
1031 }
1032 
1033 static int mtk_pcm_btcvsd_copy(struct snd_soc_component *component,
1034 			       struct snd_pcm_substream *substream,
1035 			       int channel, unsigned long pos,
1036 			       void __user *buf, unsigned long count)
1037 {
1038 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
1039 
1040 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1041 		mtk_btcvsd_snd_write(bt, buf, count);
1042 	else
1043 		mtk_btcvsd_snd_read(bt, buf, count);
1044 
1045 	return 0;
1046 }
1047 
1048 /* kcontrol */
1049 static const char *const btsco_band_str[] = {"NB", "WB"};
1050 
1051 static const struct soc_enum btcvsd_enum[] = {
1052 	SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(btsco_band_str), btsco_band_str),
1053 };
1054 
1055 static int btcvsd_band_get(struct snd_kcontrol *kcontrol,
1056 			   struct snd_ctl_elem_value *ucontrol)
1057 {
1058 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1059 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1060 
1061 	ucontrol->value.integer.value[0] = bt->band;
1062 	return 0;
1063 }
1064 
1065 static int btcvsd_band_set(struct snd_kcontrol *kcontrol,
1066 			   struct snd_ctl_elem_value *ucontrol)
1067 {
1068 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1069 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1070 	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1071 
1072 	if (ucontrol->value.enumerated.item[0] >= e->items)
1073 		return -EINVAL;
1074 
1075 	bt->band = ucontrol->value.integer.value[0];
1076 	dev_dbg(bt->dev, "%s(), band %d\n", __func__, bt->band);
1077 	return 0;
1078 }
1079 
1080 static int btcvsd_loopback_get(struct snd_kcontrol *kcontrol,
1081 			       struct snd_ctl_elem_value *ucontrol)
1082 {
1083 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1084 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1085 	bool lpbk_en = bt->tx->state == BT_SCO_STATE_LOOPBACK;
1086 
1087 	ucontrol->value.integer.value[0] = lpbk_en;
1088 	return 0;
1089 }
1090 
1091 static int btcvsd_loopback_set(struct snd_kcontrol *kcontrol,
1092 			       struct snd_ctl_elem_value *ucontrol)
1093 {
1094 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1095 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1096 
1097 	if (ucontrol->value.integer.value[0]) {
1098 		mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_LOOPBACK);
1099 		mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_LOOPBACK);
1100 	} else {
1101 		mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_RUNNING);
1102 		mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_RUNNING);
1103 	}
1104 	return 0;
1105 }
1106 
1107 static int btcvsd_tx_mute_get(struct snd_kcontrol *kcontrol,
1108 			      struct snd_ctl_elem_value *ucontrol)
1109 {
1110 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1111 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1112 
1113 	if (!bt->tx) {
1114 		ucontrol->value.integer.value[0] = 0;
1115 		return 0;
1116 	}
1117 
1118 	ucontrol->value.integer.value[0] = bt->tx->mute;
1119 	return 0;
1120 }
1121 
1122 static int btcvsd_tx_mute_set(struct snd_kcontrol *kcontrol,
1123 			      struct snd_ctl_elem_value *ucontrol)
1124 {
1125 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1126 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1127 
1128 	if (!bt->tx)
1129 		return 0;
1130 
1131 	bt->tx->mute = ucontrol->value.integer.value[0];
1132 	return 0;
1133 }
1134 
1135 static int btcvsd_rx_irq_received_get(struct snd_kcontrol *kcontrol,
1136 				      struct snd_ctl_elem_value *ucontrol)
1137 {
1138 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1139 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1140 
1141 	if (!bt->rx)
1142 		return 0;
1143 
1144 	ucontrol->value.integer.value[0] = bt->rx->rw_cnt ? 1 : 0;
1145 	return 0;
1146 }
1147 
1148 static int btcvsd_rx_timeout_get(struct snd_kcontrol *kcontrol,
1149 				 struct snd_ctl_elem_value *ucontrol)
1150 {
1151 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1152 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1153 
1154 	if (!bt->rx)
1155 		return 0;
1156 
1157 	ucontrol->value.integer.value[0] = bt->rx->timeout;
1158 	bt->rx->timeout = 0;
1159 	return 0;
1160 }
1161 
1162 static int btcvsd_rx_timestamp_get(struct snd_kcontrol *kcontrol,
1163 				   unsigned int __user *data, unsigned int size)
1164 {
1165 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1166 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1167 	int ret = 0;
1168 	struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_rx;
1169 
1170 	if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1171 		return -EINVAL;
1172 
1173 	get_rx_time_stamp(bt, &time_buffer_info_rx);
1174 
1175 	dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1176 		__func__,
1177 		time_buffer_info_rx.time_stamp_us,
1178 		time_buffer_info_rx.data_count_equi_time);
1179 
1180 	if (copy_to_user(data, &time_buffer_info_rx,
1181 			 sizeof(struct mtk_btcvsd_snd_time_buffer_info))) {
1182 		dev_warn(bt->dev, "%s(), copy_to_user fail", __func__);
1183 		ret = -EFAULT;
1184 	}
1185 
1186 	return ret;
1187 }
1188 
1189 static int btcvsd_tx_irq_received_get(struct snd_kcontrol *kcontrol,
1190 				      struct snd_ctl_elem_value *ucontrol)
1191 {
1192 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1193 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1194 
1195 	if (!bt->tx)
1196 		return 0;
1197 
1198 	ucontrol->value.integer.value[0] = bt->tx->rw_cnt ? 1 : 0;
1199 	return 0;
1200 }
1201 
1202 static int btcvsd_tx_timeout_get(struct snd_kcontrol *kcontrol,
1203 				 struct snd_ctl_elem_value *ucontrol)
1204 {
1205 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1206 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1207 
1208 	ucontrol->value.integer.value[0] = bt->tx->timeout;
1209 	return 0;
1210 }
1211 
1212 static int btcvsd_tx_timestamp_get(struct snd_kcontrol *kcontrol,
1213 				   unsigned int __user *data, unsigned int size)
1214 {
1215 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1216 	struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1217 	int ret = 0;
1218 	struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_tx;
1219 
1220 	if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1221 		return -EINVAL;
1222 
1223 	get_tx_time_stamp(bt, &time_buffer_info_tx);
1224 
1225 	dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1226 		__func__,
1227 		time_buffer_info_tx.time_stamp_us,
1228 		time_buffer_info_tx.data_count_equi_time);
1229 
1230 	if (copy_to_user(data, &time_buffer_info_tx,
1231 			 sizeof(struct mtk_btcvsd_snd_time_buffer_info))) {
1232 		dev_warn(bt->dev, "%s(), copy_to_user fail", __func__);
1233 		ret = -EFAULT;
1234 	}
1235 
1236 	return ret;
1237 }
1238 
1239 static const struct snd_kcontrol_new mtk_btcvsd_snd_controls[] = {
1240 	SOC_ENUM_EXT("BTCVSD Band", btcvsd_enum[0],
1241 		     btcvsd_band_get, btcvsd_band_set),
1242 	SOC_SINGLE_BOOL_EXT("BTCVSD Loopback Switch", 0,
1243 			    btcvsd_loopback_get, btcvsd_loopback_set),
1244 	SOC_SINGLE_BOOL_EXT("BTCVSD Tx Mute Switch", 0,
1245 			    btcvsd_tx_mute_get, btcvsd_tx_mute_set),
1246 	SOC_SINGLE_BOOL_EXT("BTCVSD Tx Irq Received Switch", 0,
1247 			    btcvsd_tx_irq_received_get, NULL),
1248 	SOC_SINGLE_BOOL_EXT("BTCVSD Tx Timeout Switch", 0,
1249 			    btcvsd_tx_timeout_get, NULL),
1250 	SOC_SINGLE_BOOL_EXT("BTCVSD Rx Irq Received Switch", 0,
1251 			    btcvsd_rx_irq_received_get, NULL),
1252 	SOC_SINGLE_BOOL_EXT("BTCVSD Rx Timeout Switch", 0,
1253 			    btcvsd_rx_timeout_get, NULL),
1254 	SND_SOC_BYTES_TLV("BTCVSD Rx Timestamp",
1255 			  sizeof(struct mtk_btcvsd_snd_time_buffer_info),
1256 			  btcvsd_rx_timestamp_get, NULL),
1257 	SND_SOC_BYTES_TLV("BTCVSD Tx Timestamp",
1258 			  sizeof(struct mtk_btcvsd_snd_time_buffer_info),
1259 			  btcvsd_tx_timestamp_get, NULL),
1260 };
1261 
1262 static int mtk_btcvsd_snd_component_probe(struct snd_soc_component *component)
1263 {
1264 	return snd_soc_add_component_controls(component,
1265 		mtk_btcvsd_snd_controls,
1266 		ARRAY_SIZE(mtk_btcvsd_snd_controls));
1267 }
1268 
1269 static const struct snd_soc_component_driver mtk_btcvsd_snd_platform = {
1270 	.name		= BTCVSD_SND_NAME,
1271 	.probe		= mtk_btcvsd_snd_component_probe,
1272 	.open		= mtk_pcm_btcvsd_open,
1273 	.close		= mtk_pcm_btcvsd_close,
1274 	.hw_params	= mtk_pcm_btcvsd_hw_params,
1275 	.hw_free	= mtk_pcm_btcvsd_hw_free,
1276 	.prepare	= mtk_pcm_btcvsd_prepare,
1277 	.trigger	= mtk_pcm_btcvsd_trigger,
1278 	.pointer	= mtk_pcm_btcvsd_pointer,
1279 	.copy_user	= mtk_pcm_btcvsd_copy,
1280 };
1281 
1282 static int mtk_btcvsd_snd_probe(struct platform_device *pdev)
1283 {
1284 	int ret;
1285 	int irq_id;
1286 	u32 offset[5] = {0, 0, 0, 0, 0};
1287 	struct mtk_btcvsd_snd *btcvsd;
1288 	struct device *dev = &pdev->dev;
1289 
1290 	/* init btcvsd private data */
1291 	btcvsd = devm_kzalloc(dev, sizeof(*btcvsd), GFP_KERNEL);
1292 	if (!btcvsd)
1293 		return -ENOMEM;
1294 	platform_set_drvdata(pdev, btcvsd);
1295 	btcvsd->dev = dev;
1296 
1297 	/* init tx/rx */
1298 	btcvsd->rx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->rx), GFP_KERNEL);
1299 	if (!btcvsd->rx)
1300 		return -ENOMEM;
1301 
1302 	btcvsd->tx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->tx), GFP_KERNEL);
1303 	if (!btcvsd->tx)
1304 		return -ENOMEM;
1305 
1306 	spin_lock_init(&btcvsd->tx_lock);
1307 	spin_lock_init(&btcvsd->rx_lock);
1308 
1309 	init_waitqueue_head(&btcvsd->tx_wait);
1310 	init_waitqueue_head(&btcvsd->rx_wait);
1311 
1312 	mtk_btcvsd_snd_tx_init(btcvsd);
1313 	mtk_btcvsd_snd_rx_init(btcvsd);
1314 
1315 	/* irq */
1316 	irq_id = platform_get_irq(pdev, 0);
1317 	if (irq_id <= 0)
1318 		return irq_id < 0 ? irq_id : -ENXIO;
1319 
1320 	ret = devm_request_irq(dev, irq_id, mtk_btcvsd_snd_irq_handler,
1321 			       IRQF_TRIGGER_LOW, "BTCVSD_ISR_Handle",
1322 			       (void *)btcvsd);
1323 	if (ret) {
1324 		dev_err(dev, "could not request_irq for BTCVSD_ISR_Handle\n");
1325 		return ret;
1326 	}
1327 
1328 	btcvsd->irq_id = irq_id;
1329 
1330 	/* iomap */
1331 	btcvsd->bt_pkv_base = of_iomap(dev->of_node, 0);
1332 	if (!btcvsd->bt_pkv_base) {
1333 		dev_err(dev, "iomap bt_pkv_base fail\n");
1334 		return -EIO;
1335 	}
1336 
1337 	btcvsd->bt_sram_bank2_base = of_iomap(dev->of_node, 1);
1338 	if (!btcvsd->bt_sram_bank2_base) {
1339 		dev_err(dev, "iomap bt_sram_bank2_base fail\n");
1340 		ret = -EIO;
1341 		goto unmap_pkv_err;
1342 	}
1343 
1344 	btcvsd->infra = syscon_regmap_lookup_by_phandle(dev->of_node,
1345 							"mediatek,infracfg");
1346 	if (IS_ERR(btcvsd->infra)) {
1347 		dev_err(dev, "cannot find infra controller: %ld\n",
1348 			PTR_ERR(btcvsd->infra));
1349 		ret = PTR_ERR(btcvsd->infra);
1350 		goto unmap_bank2_err;
1351 	}
1352 
1353 	/* get offset */
1354 	ret = of_property_read_u32_array(dev->of_node, "mediatek,offset",
1355 					 offset,
1356 					 ARRAY_SIZE(offset));
1357 	if (ret) {
1358 		dev_warn(dev, "%s(), get offset fail, ret %d\n", __func__, ret);
1359 		goto unmap_bank2_err;
1360 	}
1361 	btcvsd->infra_misc_offset = offset[0];
1362 	btcvsd->conn_bt_cvsd_mask = offset[1];
1363 	btcvsd->cvsd_mcu_read_offset = offset[2];
1364 	btcvsd->cvsd_mcu_write_offset = offset[3];
1365 	btcvsd->cvsd_packet_indicator = offset[4];
1366 
1367 	btcvsd->bt_reg_pkt_r = btcvsd->bt_pkv_base +
1368 			       btcvsd->cvsd_mcu_read_offset;
1369 	btcvsd->bt_reg_pkt_w = btcvsd->bt_pkv_base +
1370 			       btcvsd->cvsd_mcu_write_offset;
1371 	btcvsd->bt_reg_ctl = btcvsd->bt_pkv_base +
1372 			     btcvsd->cvsd_packet_indicator;
1373 
1374 	/* init state */
1375 	mtk_btcvsd_snd_set_state(btcvsd, btcvsd->tx, BT_SCO_STATE_IDLE);
1376 	mtk_btcvsd_snd_set_state(btcvsd, btcvsd->rx, BT_SCO_STATE_IDLE);
1377 
1378 	ret = devm_snd_soc_register_component(dev, &mtk_btcvsd_snd_platform,
1379 					      NULL, 0);
1380 	if (ret)
1381 		goto unmap_bank2_err;
1382 
1383 	return 0;
1384 
1385 unmap_bank2_err:
1386 	iounmap(btcvsd->bt_sram_bank2_base);
1387 unmap_pkv_err:
1388 	iounmap(btcvsd->bt_pkv_base);
1389 	return ret;
1390 }
1391 
1392 static int mtk_btcvsd_snd_remove(struct platform_device *pdev)
1393 {
1394 	struct mtk_btcvsd_snd *btcvsd = dev_get_drvdata(&pdev->dev);
1395 
1396 	iounmap(btcvsd->bt_pkv_base);
1397 	iounmap(btcvsd->bt_sram_bank2_base);
1398 	return 0;
1399 }
1400 
1401 static const struct of_device_id mtk_btcvsd_snd_dt_match[] = {
1402 	{ .compatible = "mediatek,mtk-btcvsd-snd", },
1403 	{},
1404 };
1405 MODULE_DEVICE_TABLE(of, mtk_btcvsd_snd_dt_match);
1406 
1407 static struct platform_driver mtk_btcvsd_snd_driver = {
1408 	.driver = {
1409 		.name = "mtk-btcvsd-snd",
1410 		.of_match_table = mtk_btcvsd_snd_dt_match,
1411 	},
1412 	.probe = mtk_btcvsd_snd_probe,
1413 	.remove = mtk_btcvsd_snd_remove,
1414 };
1415 
1416 module_platform_driver(mtk_btcvsd_snd_driver);
1417 
1418 MODULE_DESCRIPTION("Mediatek ALSA BT SCO CVSD/MSBC Driver");
1419 MODULE_AUTHOR("KaiChieh Chuang <kaichieh.chuang@mediatek.com>");
1420 MODULE_LICENSE("GPL v2");
1421