1 // SPDX-License-Identifier: GPL-2.0
3 // Mediatek ALSA BT SCO CVSD/MSBC Driver
5 // Copyright (c) 2019 MediaTek Inc.
6 // Author: KaiChieh Chuang <kaichieh.chuang@mediatek.com>
8 #include <linux/mfd/syscon.h>
9 #include <linux/module.h>
10 #include <linux/of_address.h>
11 #include <linux/sched/clock.h>
13 #include <sound/soc.h>
15 #define BTCVSD_SND_NAME "mtk-btcvsd-snd"
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)
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)
28 #define SCO_TX_ENCODE_SIZE (60)
29 /* 18 = 6 * 180 / SCO_TX_ENCODE_SIZE */
30 #define SCO_TX_PACKER_BUF_NUM (18)
33 #define SCO_RX_PLC_SIZE (30)
34 #define SCO_RX_PACKER_BUF_NUM (64)
35 #define SCO_RX_PACKET_MASK (0x3F)
37 #define SCO_CVSD_PACKET_VALID_SIZE 2
39 #define SCO_PACKET_120 120
40 #define SCO_PACKET_180 180
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)
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)
52 BT_SCO_STATE_LOOPBACK,
60 enum bt_sco_packet_len {
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;
82 struct mtk_btcvsd_snd_stream {
83 struct snd_pcm_substream *substream;
86 enum bt_sco_state state;
88 unsigned int packet_size;
89 unsigned int buf_size;
90 u8 temp_packet_buf[SCO_PACKET_180];
94 snd_pcm_uframes_t prev_frame;
98 unsigned int timeout:1;
100 unsigned int trigger_start:1;
101 unsigned int wait_flag:1;
104 unsigned long long time_stamp;
105 unsigned long long buf_data_equivalent_time;
107 struct mtk_btcvsd_snd_hw_info buffer_info;
110 struct mtk_btcvsd_snd {
114 struct regmap *infra;
115 void __iomem *bt_pkv_base;
116 void __iomem *bt_sram_bank2_base;
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;
128 unsigned int irq_disabled:1;
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;
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];
140 enum BT_SCO_BAND band;
143 struct mtk_btcvsd_snd_time_buffer_info {
144 unsigned long long data_count_equi_time;
145 unsigned long long time_stamp_us;
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},
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},
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
193 static void mtk_btcvsd_snd_irq_enable(struct mtk_btcvsd_snd *bt)
195 regmap_update_bits(bt->infra, bt->infra_misc_offset,
196 bt->conn_bt_cvsd_mask, 0);
199 static void mtk_btcvsd_snd_irq_disable(struct mtk_btcvsd_snd *bt)
201 regmap_update_bits(bt->infra, bt->infra_misc_offset,
202 bt->conn_bt_cvsd_mask, bt->conn_bt_cvsd_mask);
205 static void mtk_btcvsd_snd_set_state(struct mtk_btcvsd_snd *bt,
206 struct mtk_btcvsd_snd_stream *bt_stream,
209 dev_dbg(bt->dev, "%s(), stream %d, state %d, tx->state %d, rx->state %d, irq_disabled %d\n",
211 bt_stream->stream, state,
212 bt->tx->state, bt->rx->state, bt->irq_disabled);
214 bt_stream->state = state;
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;
224 if (bt->irq_disabled) {
225 enable_irq(bt->irq_id);
226 mtk_btcvsd_snd_irq_enable(bt);
227 bt->irq_disabled = 0;
232 static int mtk_btcvsd_snd_tx_init(struct mtk_btcvsd_snd *bt)
234 memset(bt->tx, 0, sizeof(*bt->tx));
235 memset(bt->tx_packet_buf, 0, sizeof(bt->tx_packet_buf));
237 bt->tx->packet_size = BTCVSD_TX_PACKET_SIZE;
238 bt->tx->buf_size = BTCVSD_TX_BUF_SIZE;
241 bt->tx->stream = SNDRV_PCM_STREAM_PLAYBACK;
245 static int mtk_btcvsd_snd_rx_init(struct mtk_btcvsd_snd *bt)
247 memset(bt->rx, 0, sizeof(*bt->rx));
248 memset(bt->rx_packet_buf, 0, sizeof(bt->rx_packet_buf));
250 bt->rx->packet_size = BTCVSD_RX_PACKET_SIZE;
251 bt->rx->buf_size = BTCVSD_RX_BUF_SIZE;
254 bt->rx->stream = SNDRV_PCM_STREAM_CAPTURE;
258 static void get_tx_time_stamp(struct mtk_btcvsd_snd *bt,
259 struct mtk_btcvsd_snd_time_buffer_info *ts)
261 ts->time_stamp_us = bt->tx->time_stamp;
262 ts->data_count_equi_time = bt->tx->buf_data_equivalent_time;
265 static void get_rx_time_stamp(struct mtk_btcvsd_snd *bt,
266 struct mtk_btcvsd_snd_time_buffer_info *ts)
268 ts->time_stamp_us = bt->rx->time_stamp;
269 ts->data_count_equi_time = bt->rx->buf_data_equivalent_time;
272 static int btcvsd_bytes_to_frame(struct snd_pcm_substream *substream,
276 struct snd_pcm_runtime *runtime = substream->runtime;
278 if (runtime->format == SNDRV_PCM_FORMAT_S32_LE ||
279 runtime->format == SNDRV_PCM_FORMAT_U32_LE)
284 count = count / runtime->channels;
288 static void mtk_btcvsd_snd_data_transfer(enum bt_sco_direct dir,
290 unsigned int blk_size,
291 unsigned int blk_num)
295 if (blk_size == 60 || blk_size == 120 || blk_size == 20) {
296 u32 *src_32 = (u32 *)src;
297 u32 *dst_32 = (u32 *)dst;
299 for (i = 0; i < (blk_size * blk_num / 4); i++)
300 *dst_32++ = *src_32++;
302 u16 *src_16 = (u16 *)src;
303 u16 *dst_16 = (u16 *)dst;
305 for (j = 0; j < blk_num; j++) {
306 for (i = 0; i < (blk_size / 2); i++)
307 *dst_16++ = *src_16++;
309 if (dir == BT_SCO_DIRECT_BT2ARM)
317 /* write encoded mute data to bt sram */
318 static int btcvsd_tx_clean_buffer(struct mtk_btcvsd_snd *bt)
321 unsigned int num_valid_addr;
323 enum BT_SCO_BAND band = bt->band;
325 /* prepare encoded mute data */
326 if (band == BT_SCO_NB)
327 memset(bt->tx->temp_packet_buf, 170, SCO_PACKET_180);
329 memcpy(bt->tx->temp_packet_buf,
330 table_msbc_silence, SCO_PACKET_180);
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;
336 dev_info(bt->dev, "%s(), band %d, num_valid_addr %u\n",
337 __func__, band, num_valid_addr);
339 for (i = 0; i < num_valid_addr; i++) {
342 dev_info(bt->dev, "%s(), clean addr 0x%lx\n", __func__,
343 bt->tx->buffer_info.bt_sram_addr[i]);
345 dst = (void *)bt->tx->buffer_info.bt_sram_addr[i];
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);
352 spin_unlock_irqrestore(&bt->tx_lock, flags);
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)
367 unsigned int packet_buf_ofs;
369 unsigned long connsys_addr_rx, ap_addr_rx;
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);
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",
382 src = (u8 *)ap_addr_rx;
384 mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_BT2ARM, src,
385 bt->rx->temp_packet_buf, packet_length,
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) *
392 memcpy(bt->rx_packet_buf + packet_buf_ofs,
393 bt->rx->temp_packet_buf + (SCO_RX_PLC_SIZE * i),
395 if ((control & btsco_packet_valid_mask[packet_type][i]) ==
396 btsco_packet_valid_mask[packet_type][i])
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);
406 spin_unlock_irqrestore(&bt->rx_lock, flags);
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)
419 unsigned long connsys_addr_tx, ap_addr_tx;
420 bool new_ap_addr_tx = true;
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);
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",
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),
437 (bt->tx->packet_r % SCO_TX_PACKER_BUF_NUM) *
438 bt->tx->packet_size),
439 bt->tx->packet_size);
443 spin_unlock_irqrestore(&bt->tx_lock, flags);
445 dst = (u8 *)ap_addr_tx;
448 mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT,
449 bt->tx->temp_packet_buf, dst,
450 packet_length, packet_num);
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;
462 if (new_ap_addr_tx) {
463 unsigned int next_idx;
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);
476 btcvsd_tx_clean_buffer(bt);
481 static irqreturn_t mtk_btcvsd_snd_irq_handler(int irq_id, void *dev)
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;
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;
497 control = *bt->bt_reg_ctl;
498 packet_type = (control >> 18) & 0x7;
500 if (((control >> 31) & 1) == 0) {
501 dev_warn(bt->dev, "%s(), ((control >> 31) & 1) == 0, control 0x%x\n",
503 goto irq_handler_exit;
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;
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];
517 if (bt->tx->state == BT_SCO_STATE_LOOPBACK) {
519 unsigned long connsys_addr_rx, ap_addr_rx;
520 unsigned long connsys_addr_tx, ap_addr_tx;
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);
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);
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",
535 goto irq_handler_exit;
538 src = (u8 *)ap_addr_rx;
539 dst = (u8 *)ap_addr_tx;
541 mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_BT2ARM, src,
542 bt->tx->temp_packet_buf,
545 mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT,
546 bt->tx->temp_packet_buf, dst,
553 if (bt->rx->state == BT_SCO_STATE_RUNNING ||
554 bt->rx->state == BT_SCO_STATE_ENDING) {
556 if (bt->rx->packet_w - bt->rx->packet_r <=
557 SCO_RX_PACKER_BUF_NUM - 2 * buf_cnt_rx) {
559 * free space is larger then
560 * twice interrupt rx data size
563 dev_warn(bt->dev, "%s(), rx->xrun 0!\n",
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,
580 dev_warn(bt->dev, "%s(), rx->xrun 1\n", __func__);
586 if ((bt->tx->state == BT_SCO_STATE_RUNNING ||
587 bt->tx->state == BT_SCO_STATE_ENDING) &&
588 bt->tx->trigger_start) {
590 /* prepared data is larger then twice
591 * interrupt tx data size
593 if (bt->tx->packet_w - bt->tx->packet_r >=
596 dev_warn(bt->dev, "%s(), tx->xrun 0\n",
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,
612 dev_warn(bt->dev, "%s(), tx->xrun 1\n", __func__);
616 *bt->bt_reg_ctl &= ~BT_CVSD_CLEAR;
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);
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);
633 *bt->bt_reg_ctl &= ~BT_CVSD_CLEAR;
637 static int wait_for_bt_irq(struct mtk_btcvsd_snd *bt,
638 struct mtk_btcvsd_snd_stream *bt_stream)
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;
646 bt_stream->wait_flag = 0;
648 while (max_timeout_trial && !bt_stream->wait_flag) {
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));
655 ret = wait_event_interruptible_timeout(bt->rx_wait,
656 bt_stream->wait_flag,
657 nsecs_to_jiffies(timeout_limit));
661 t2 = t2 - t1; /* in ns (10^9) */
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);
672 * error, -ERESTARTSYS if it was interrupted by
675 dev_warn(bt->dev, "%s(), stream %d, error, trial left %d\n",
677 bt_stream->stream, max_timeout_trial);
679 bt_stream->timeout = 1;
681 } else if (ret == 0) {
682 /* conidtion is false after timeout */
684 dev_warn(bt->dev, "%s(), stream %d, error, timeout, condition is false, trial left %d\n",
686 bt_stream->stream, max_timeout_trial);
688 if (max_timeout_trial <= 0) {
689 bt_stream->timeout = 1;
698 static ssize_t mtk_btcvsd_snd_read(struct mtk_btcvsd_snd *bt,
702 ssize_t read_size = 0, read_count = 0, cur_read_idx, cont;
703 unsigned int cur_buf_ofs = 0;
706 unsigned int packet_size = bt->rx->packet_size;
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;
713 cur_read_idx = (bt->rx->packet_r & SCO_RX_PACKET_MASK) *
715 spin_unlock_irqrestore(&bt->rx_lock, flags);
718 int ret = wait_for_bt_irq(bt, bt->rx);
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);
732 count -= count % packet_size;
733 avail -= avail % packet_size;
741 /* calculate continue space */
742 cont = bt->rx->buf_size - cur_read_idx;
743 if (read_size > cont)
746 if (copy_to_user(buf + cur_buf_ofs,
747 bt->rx_packet_buf + cur_read_idx,
749 dev_warn(bt->dev, "%s(), copy_to_user fail\n",
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);
758 read_count += read_size;
759 cur_buf_ofs += read_size;
764 * save current timestamp & buffer time in times_tamp and
765 * buf_data_equivalent_time
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;
779 static ssize_t mtk_btcvsd_snd_write(struct mtk_btcvsd_snd *bt,
783 int written_size = count, avail, cur_write_idx, write_size, cont;
784 unsigned int cur_buf_ofs = 0;
786 unsigned int packet_size = bt->tx->packet_size;
789 * save current timestamp & buffer time in time_stamp and
790 * buf_data_equivalent_time
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;
797 /* return equivalent time(us) to data count */
798 bt->tx->buf_data_equivalent_time *= 1000;
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;
806 cur_write_idx = (bt->tx->packet_w % SCO_TX_PACKER_BUF_NUM) *
808 spin_unlock_irqrestore(&bt->tx_lock, flags);
811 int ret = wait_for_bt_irq(bt, bt->tx);
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;
833 /* calculate continue space */
834 cont = bt->tx->buf_size - cur_write_idx;
835 if (write_size > cont)
838 if (copy_from_user(bt->tx_packet_buf +
842 dev_warn(bt->dev, "%s(), copy_from_user fail\n",
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;
857 static struct mtk_btcvsd_snd_stream *get_bt_stream
858 (struct mtk_btcvsd_snd *bt, struct snd_pcm_substream *substream)
860 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
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,
878 static int mtk_pcm_btcvsd_open(struct snd_soc_component *component,
879 struct snd_pcm_substream *substream)
881 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
884 dev_dbg(bt->dev, "%s(), stream %d, substream %p\n",
885 __func__, substream->stream, substream);
887 snd_soc_set_runtime_hwparams(substream, &mtk_btcvsd_hardware);
889 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
890 ret = mtk_btcvsd_snd_tx_init(bt);
891 bt->tx->substream = substream;
893 ret = mtk_btcvsd_snd_rx_init(bt);
894 bt->rx->substream = substream;
900 static int mtk_pcm_btcvsd_close(struct snd_soc_component *component,
901 struct snd_pcm_substream *substream)
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);
906 dev_dbg(bt->dev, "%s(), stream %d\n", __func__, substream->stream);
908 mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_IDLE);
909 bt_stream->substream = NULL;
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)
917 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
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",
923 params_buffer_bytes(hw_params));
927 substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
931 static int mtk_pcm_btcvsd_hw_free(struct snd_soc_component *component,
932 struct snd_pcm_substream *substream)
934 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
936 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
937 btcvsd_tx_clean_buffer(bt);
942 static int mtk_pcm_btcvsd_prepare(struct snd_soc_component *component,
943 struct snd_pcm_substream *substream)
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);
948 dev_dbg(bt->dev, "%s(), stream %d\n", __func__, substream->stream);
950 mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_RUNNING);
954 static int mtk_pcm_btcvsd_trigger(struct snd_soc_component *component,
955 struct snd_pcm_substream *substream, int cmd)
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;
962 dev_dbg(bt->dev, "%s(), stream %d, cmd %d\n",
963 __func__, substream->stream, 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;
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);
984 static snd_pcm_uframes_t mtk_pcm_btcvsd_pointer(
985 struct snd_soc_component *component,
986 struct snd_pcm_substream *substream)
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;
994 spinlock_t *lock; /* spinlock for bt stream control */
997 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1001 lock = &bt->rx_lock;
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;
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;
1013 /* integer overflow */
1014 packet_diff = (INT_MAX - bt_stream->prev_packet_idx) +
1015 (hw_packet_ptr - INT_MIN) + 1;
1017 bt_stream->prev_packet_idx = hw_packet_ptr;
1019 /* increased bytes */
1020 byte = packet_diff * bt_stream->packet_size;
1022 frame = btcvsd_bytes_to_frame(substream, byte);
1023 frame += bt_stream->prev_frame;
1024 frame %= substream->runtime->buffer_size;
1026 bt_stream->prev_frame = frame;
1028 spin_unlock_irqrestore(lock, flags);
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)
1038 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
1040 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1041 mtk_btcvsd_snd_write(bt, buf, count);
1043 mtk_btcvsd_snd_read(bt, buf, count);
1049 static const char *const btsco_band_str[] = {"NB", "WB"};
1051 static const struct soc_enum btcvsd_enum[] = {
1052 SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(btsco_band_str), btsco_band_str),
1055 static int btcvsd_band_get(struct snd_kcontrol *kcontrol,
1056 struct snd_ctl_elem_value *ucontrol)
1058 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1059 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1061 ucontrol->value.integer.value[0] = bt->band;
1065 static int btcvsd_band_set(struct snd_kcontrol *kcontrol,
1066 struct snd_ctl_elem_value *ucontrol)
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;
1072 if (ucontrol->value.enumerated.item[0] >= e->items)
1075 bt->band = ucontrol->value.integer.value[0];
1076 dev_dbg(bt->dev, "%s(), band %d\n", __func__, bt->band);
1080 static int btcvsd_loopback_get(struct snd_kcontrol *kcontrol,
1081 struct snd_ctl_elem_value *ucontrol)
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;
1087 ucontrol->value.integer.value[0] = lpbk_en;
1091 static int btcvsd_loopback_set(struct snd_kcontrol *kcontrol,
1092 struct snd_ctl_elem_value *ucontrol)
1094 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1095 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
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);
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);
1107 static int btcvsd_tx_mute_get(struct snd_kcontrol *kcontrol,
1108 struct snd_ctl_elem_value *ucontrol)
1110 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1111 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1114 ucontrol->value.integer.value[0] = 0;
1118 ucontrol->value.integer.value[0] = bt->tx->mute;
1122 static int btcvsd_tx_mute_set(struct snd_kcontrol *kcontrol,
1123 struct snd_ctl_elem_value *ucontrol)
1125 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1126 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1131 bt->tx->mute = ucontrol->value.integer.value[0];
1135 static int btcvsd_rx_irq_received_get(struct snd_kcontrol *kcontrol,
1136 struct snd_ctl_elem_value *ucontrol)
1138 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1139 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1144 ucontrol->value.integer.value[0] = bt->rx->rw_cnt ? 1 : 0;
1148 static int btcvsd_rx_timeout_get(struct snd_kcontrol *kcontrol,
1149 struct snd_ctl_elem_value *ucontrol)
1151 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1152 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1157 ucontrol->value.integer.value[0] = bt->rx->timeout;
1158 bt->rx->timeout = 0;
1162 static int btcvsd_rx_timestamp_get(struct snd_kcontrol *kcontrol,
1163 unsigned int __user *data, unsigned int size)
1165 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1166 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1168 struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_rx;
1170 if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1173 get_rx_time_stamp(bt, &time_buffer_info_rx);
1175 dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1177 time_buffer_info_rx.time_stamp_us,
1178 time_buffer_info_rx.data_count_equi_time);
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__);
1189 static int btcvsd_tx_irq_received_get(struct snd_kcontrol *kcontrol,
1190 struct snd_ctl_elem_value *ucontrol)
1192 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1193 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1198 ucontrol->value.integer.value[0] = bt->tx->rw_cnt ? 1 : 0;
1202 static int btcvsd_tx_timeout_get(struct snd_kcontrol *kcontrol,
1203 struct snd_ctl_elem_value *ucontrol)
1205 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1206 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1208 ucontrol->value.integer.value[0] = bt->tx->timeout;
1212 static int btcvsd_tx_timestamp_get(struct snd_kcontrol *kcontrol,
1213 unsigned int __user *data, unsigned int size)
1215 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1216 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1218 struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_tx;
1220 if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1223 get_tx_time_stamp(bt, &time_buffer_info_tx);
1225 dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1227 time_buffer_info_tx.time_stamp_us,
1228 time_buffer_info_tx.data_count_equi_time);
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__);
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),
1262 static int mtk_btcvsd_snd_component_probe(struct snd_soc_component *component)
1264 return snd_soc_add_component_controls(component,
1265 mtk_btcvsd_snd_controls,
1266 ARRAY_SIZE(mtk_btcvsd_snd_controls));
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,
1282 static int mtk_btcvsd_snd_probe(struct platform_device *pdev)
1286 u32 offset[5] = {0, 0, 0, 0, 0};
1287 struct mtk_btcvsd_snd *btcvsd;
1288 struct device *dev = &pdev->dev;
1290 /* init btcvsd private data */
1291 btcvsd = devm_kzalloc(dev, sizeof(*btcvsd), GFP_KERNEL);
1294 platform_set_drvdata(pdev, btcvsd);
1298 btcvsd->rx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->rx), GFP_KERNEL);
1302 btcvsd->tx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->tx), GFP_KERNEL);
1306 spin_lock_init(&btcvsd->tx_lock);
1307 spin_lock_init(&btcvsd->rx_lock);
1309 init_waitqueue_head(&btcvsd->tx_wait);
1310 init_waitqueue_head(&btcvsd->rx_wait);
1312 mtk_btcvsd_snd_tx_init(btcvsd);
1313 mtk_btcvsd_snd_rx_init(btcvsd);
1316 irq_id = platform_get_irq(pdev, 0);
1318 return irq_id < 0 ? irq_id : -ENXIO;
1320 ret = devm_request_irq(dev, irq_id, mtk_btcvsd_snd_irq_handler,
1321 IRQF_TRIGGER_LOW, "BTCVSD_ISR_Handle",
1324 dev_err(dev, "could not request_irq for BTCVSD_ISR_Handle\n");
1328 btcvsd->irq_id = irq_id;
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");
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");
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;
1354 ret = of_property_read_u32_array(dev->of_node, "mediatek,offset",
1356 ARRAY_SIZE(offset));
1358 dev_warn(dev, "%s(), get offset fail, ret %d\n", __func__, ret);
1359 goto unmap_bank2_err;
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];
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;
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);
1378 ret = devm_snd_soc_register_component(dev, &mtk_btcvsd_snd_platform,
1381 goto unmap_bank2_err;
1386 iounmap(btcvsd->bt_sram_bank2_base);
1388 iounmap(btcvsd->bt_pkv_base);
1392 static int mtk_btcvsd_snd_remove(struct platform_device *pdev)
1394 struct mtk_btcvsd_snd *btcvsd = dev_get_drvdata(&pdev->dev);
1396 iounmap(btcvsd->bt_pkv_base);
1397 iounmap(btcvsd->bt_sram_bank2_base);
1401 static const struct of_device_id mtk_btcvsd_snd_dt_match[] = {
1402 { .compatible = "mediatek,mtk-btcvsd-snd", },
1405 MODULE_DEVICE_TABLE(of, mtk_btcvsd_snd_dt_match);
1407 static struct platform_driver mtk_btcvsd_snd_driver = {
1409 .name = "mtk-btcvsd-snd",
1410 .of_match_table = mtk_btcvsd_snd_dt_match,
1412 .probe = mtk_btcvsd_snd_probe,
1413 .remove = mtk_btcvsd_snd_remove,
1416 module_platform_driver(mtk_btcvsd_snd_driver);
1418 MODULE_DESCRIPTION("Mediatek ALSA BT SCO CVSD/MSBC Driver");
1419 MODULE_AUTHOR("KaiChieh Chuang <kaichieh.chuang@mediatek.com>");
1420 MODULE_LICENSE("GPL v2");