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 struct iov_iter *buf,
700 size_t count)
701 {
702 ssize_t read_size = 0, read_count = 0, cur_read_idx, cont;
703 unsigned long avail;
704 unsigned long flags;
705 unsigned int packet_size = bt->rx->packet_size;
706
707 while (count) {
708 spin_lock_irqsave(&bt->rx_lock, flags);
709 /* available data in RX packet buffer */
710 avail = (bt->rx->packet_w - bt->rx->packet_r) * packet_size;
711
712 cur_read_idx = (bt->rx->packet_r & SCO_RX_PACKET_MASK) *
713 packet_size;
714 spin_unlock_irqrestore(&bt->rx_lock, flags);
715
716 if (!avail) {
717 int ret = wait_for_bt_irq(bt, bt->rx);
718
719 if (ret)
720 return read_count;
721
722 continue;
723 }
724
725 /* count must be multiple of packet_size */
726 if (count % packet_size != 0 ||
727 avail % packet_size != 0) {
728 dev_warn(bt->dev, "%s(), count %zu or d %lu is not multiple of packet_size %dd\n",
729 __func__, count, avail, packet_size);
730
731 count -= count % packet_size;
732 avail -= avail % packet_size;
733 }
734
735 if (count > avail)
736 read_size = avail;
737 else
738 read_size = count;
739
740 /* calculate continue space */
741 cont = bt->rx->buf_size - cur_read_idx;
742 if (read_size > cont)
743 read_size = cont;
744
745 if (copy_to_iter(bt->rx_packet_buf + cur_read_idx,
746 read_size, buf) != read_size) {
747 dev_warn(bt->dev, "%s(), copy_to_iter fail\n",
748 __func__);
749 return -EFAULT;
750 }
751
752 spin_lock_irqsave(&bt->rx_lock, flags);
753 bt->rx->packet_r += read_size / packet_size;
754 spin_unlock_irqrestore(&bt->rx_lock, flags);
755
756 read_count += read_size;
757 count -= read_size;
758 }
759
760 /*
761 * save current timestamp & buffer time in times_tamp and
762 * buf_data_equivalent_time
763 */
764 bt->rx->time_stamp = sched_clock();
765 bt->rx->buf_data_equivalent_time =
766 (unsigned long long)(bt->rx->packet_w - bt->rx->packet_r) *
767 SCO_RX_PLC_SIZE * 16 * 1000 / 2 / 64;
768 bt->rx->buf_data_equivalent_time += read_count * SCO_RX_PLC_SIZE *
769 16 * 1000 / packet_size / 2 / 64;
770 /* return equivalent time(us) to data count */
771 bt->rx->buf_data_equivalent_time *= 1000;
772
773 return read_count;
774 }
775
776 static ssize_t mtk_btcvsd_snd_write(struct mtk_btcvsd_snd *bt,
777 struct iov_iter *buf,
778 size_t count)
779 {
780 int written_size = count, avail, cur_write_idx, write_size, cont;
781 unsigned long flags;
782 unsigned int packet_size = bt->tx->packet_size;
783
784 /*
785 * save current timestamp & buffer time in time_stamp and
786 * buf_data_equivalent_time
787 */
788 bt->tx->time_stamp = sched_clock();
789 bt->tx->buf_data_equivalent_time =
790 (unsigned long long)(bt->tx->packet_w - bt->tx->packet_r) *
791 packet_size * 16 * 1000 / 2 / 64;
792
793 /* return equivalent time(us) to data count */
794 bt->tx->buf_data_equivalent_time *= 1000;
795
796 while (count) {
797 spin_lock_irqsave(&bt->tx_lock, flags);
798 /* free space of TX packet buffer */
799 avail = bt->tx->buf_size -
800 (bt->tx->packet_w - bt->tx->packet_r) * packet_size;
801
802 cur_write_idx = (bt->tx->packet_w % SCO_TX_PACKER_BUF_NUM) *
803 packet_size;
804 spin_unlock_irqrestore(&bt->tx_lock, flags);
805
806 if (!avail) {
807 int ret = wait_for_bt_irq(bt, bt->tx);
808
809 if (ret)
810 return written_size;
811
812 continue;
813 }
814
815 /* count must be multiple of bt->tx->packet_size */
816 if (count % packet_size != 0 ||
817 avail % packet_size != 0) {
818 dev_warn(bt->dev, "%s(), count %zu or avail %d is not multiple of packet_size %d\n",
819 __func__, count, avail, packet_size);
820 count -= count % packet_size;
821 avail -= avail % packet_size;
822 }
823
824 if (count > avail)
825 write_size = avail;
826 else
827 write_size = count;
828
829 /* calculate continue space */
830 cont = bt->tx->buf_size - cur_write_idx;
831 if (write_size > cont)
832 write_size = cont;
833
834 if (copy_from_iter(bt->tx_packet_buf + cur_write_idx,
835 write_size, buf) != write_size) {
836 dev_warn(bt->dev, "%s(), copy_from_iter fail\n",
837 __func__);
838 return -EFAULT;
839 }
840
841 spin_lock_irqsave(&bt->tx_lock, flags);
842 bt->tx->packet_w += write_size / packet_size;
843 spin_unlock_irqrestore(&bt->tx_lock, flags);
844 count -= write_size;
845 }
846
847 return written_size;
848 }
849
850 static struct mtk_btcvsd_snd_stream *get_bt_stream
851 (struct mtk_btcvsd_snd *bt, struct snd_pcm_substream *substream)
852 {
853 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
854 return bt->tx;
855 else
856 return bt->rx;
857 }
858
859 /* pcm ops */
860 static const struct snd_pcm_hardware mtk_btcvsd_hardware = {
861 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
862 SNDRV_PCM_INFO_RESUME),
863 .formats = SNDRV_PCM_FMTBIT_S16_LE,
864 .buffer_bytes_max = 24 * 1024,
865 .period_bytes_max = 24 * 1024,
866 .periods_min = 2,
867 .periods_max = 16,
868 .fifo_size = 0,
869 };
870
871 static int mtk_pcm_btcvsd_open(struct snd_soc_component *component,
872 struct snd_pcm_substream *substream)
873 {
874 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
875 int ret;
876
877 dev_dbg(bt->dev, "%s(), stream %d, substream %p\n",
878 __func__, substream->stream, substream);
879
880 snd_soc_set_runtime_hwparams(substream, &mtk_btcvsd_hardware);
881
882 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
883 ret = mtk_btcvsd_snd_tx_init(bt);
884 bt->tx->substream = substream;
885 } else {
886 ret = mtk_btcvsd_snd_rx_init(bt);
887 bt->rx->substream = substream;
888 }
889
890 return ret;
891 }
892
893 static int mtk_pcm_btcvsd_close(struct snd_soc_component *component,
894 struct snd_pcm_substream *substream)
895 {
896 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
897 struct mtk_btcvsd_snd_stream *bt_stream = get_bt_stream(bt, substream);
898
899 dev_dbg(bt->dev, "%s(), stream %d\n", __func__, substream->stream);
900
901 mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_IDLE);
902 bt_stream->substream = NULL;
903 return 0;
904 }
905
906 static int mtk_pcm_btcvsd_hw_params(struct snd_soc_component *component,
907 struct snd_pcm_substream *substream,
908 struct snd_pcm_hw_params *hw_params)
909 {
910 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
911
912 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
913 params_buffer_bytes(hw_params) % bt->tx->packet_size != 0) {
914 dev_warn(bt->dev, "%s(), error, buffer size %d not valid\n",
915 __func__,
916 params_buffer_bytes(hw_params));
917 return -EINVAL;
918 }
919
920 substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
921 return 0;
922 }
923
924 static int mtk_pcm_btcvsd_hw_free(struct snd_soc_component *component,
925 struct snd_pcm_substream *substream)
926 {
927 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
928
929 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
930 btcvsd_tx_clean_buffer(bt);
931
932 return 0;
933 }
934
935 static int mtk_pcm_btcvsd_prepare(struct snd_soc_component *component,
936 struct snd_pcm_substream *substream)
937 {
938 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
939 struct mtk_btcvsd_snd_stream *bt_stream = get_bt_stream(bt, substream);
940
941 dev_dbg(bt->dev, "%s(), stream %d\n", __func__, substream->stream);
942
943 mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_RUNNING);
944 return 0;
945 }
946
947 static int mtk_pcm_btcvsd_trigger(struct snd_soc_component *component,
948 struct snd_pcm_substream *substream, int cmd)
949 {
950 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
951 struct mtk_btcvsd_snd_stream *bt_stream = get_bt_stream(bt, substream);
952 int stream = substream->stream;
953 int hw_packet_ptr;
954
955 dev_dbg(bt->dev, "%s(), stream %d, cmd %d\n",
956 __func__, substream->stream, cmd);
957
958 switch (cmd) {
959 case SNDRV_PCM_TRIGGER_START:
960 case SNDRV_PCM_TRIGGER_RESUME:
961 hw_packet_ptr = stream == SNDRV_PCM_STREAM_PLAYBACK ?
962 bt_stream->packet_r : bt_stream->packet_w;
963 bt_stream->prev_packet_idx = hw_packet_ptr;
964 bt_stream->prev_frame = 0;
965 bt_stream->trigger_start = 1;
966 return 0;
967 case SNDRV_PCM_TRIGGER_STOP:
968 case SNDRV_PCM_TRIGGER_SUSPEND:
969 bt_stream->trigger_start = 0;
970 mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_ENDING);
971 return 0;
972 default:
973 return -EINVAL;
974 }
975 }
976
977 static snd_pcm_uframes_t mtk_pcm_btcvsd_pointer(
978 struct snd_soc_component *component,
979 struct snd_pcm_substream *substream)
980 {
981 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
982 struct mtk_btcvsd_snd_stream *bt_stream;
983 snd_pcm_uframes_t frame = 0;
984 int byte = 0;
985 int hw_packet_ptr;
986 int packet_diff;
987 spinlock_t *lock; /* spinlock for bt stream control */
988 unsigned long flags;
989
990 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
991 lock = &bt->tx_lock;
992 bt_stream = bt->tx;
993 } else {
994 lock = &bt->rx_lock;
995 bt_stream = bt->rx;
996 }
997
998 spin_lock_irqsave(lock, flags);
999 hw_packet_ptr = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
1000 bt->tx->packet_r : bt->rx->packet_w;
1001
1002 /* get packet diff from last time */
1003 if (hw_packet_ptr >= bt_stream->prev_packet_idx) {
1004 packet_diff = hw_packet_ptr - bt_stream->prev_packet_idx;
1005 } else {
1006 /* integer overflow */
1007 packet_diff = (INT_MAX - bt_stream->prev_packet_idx) +
1008 (hw_packet_ptr - INT_MIN) + 1;
1009 }
1010 bt_stream->prev_packet_idx = hw_packet_ptr;
1011
1012 /* increased bytes */
1013 byte = packet_diff * bt_stream->packet_size;
1014
1015 frame = btcvsd_bytes_to_frame(substream, byte);
1016 frame += bt_stream->prev_frame;
1017 frame %= substream->runtime->buffer_size;
1018
1019 bt_stream->prev_frame = frame;
1020
1021 spin_unlock_irqrestore(lock, flags);
1022
1023 return frame;
1024 }
1025
1026 static int mtk_pcm_btcvsd_copy(struct snd_soc_component *component,
1027 struct snd_pcm_substream *substream,
1028 int channel, unsigned long pos,
1029 struct iov_iter *buf, unsigned long count)
1030 {
1031 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
1032
1033 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1034 return mtk_btcvsd_snd_write(bt, buf, count);
1035 else
1036 return mtk_btcvsd_snd_read(bt, buf, count);
1037 }
1038
1039 /* kcontrol */
1040 static const char *const btsco_band_str[] = {"NB", "WB"};
1041
1042 static const struct soc_enum btcvsd_enum[] = {
1043 SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(btsco_band_str), btsco_band_str),
1044 };
1045
1046 static int btcvsd_band_get(struct snd_kcontrol *kcontrol,
1047 struct snd_ctl_elem_value *ucontrol)
1048 {
1049 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1050 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1051
1052 ucontrol->value.integer.value[0] = bt->band;
1053 return 0;
1054 }
1055
1056 static int btcvsd_band_set(struct snd_kcontrol *kcontrol,
1057 struct snd_ctl_elem_value *ucontrol)
1058 {
1059 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1060 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1061 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1062
1063 if (ucontrol->value.enumerated.item[0] >= e->items)
1064 return -EINVAL;
1065
1066 bt->band = ucontrol->value.integer.value[0];
1067 dev_dbg(bt->dev, "%s(), band %d\n", __func__, bt->band);
1068 return 0;
1069 }
1070
1071 static int btcvsd_loopback_get(struct snd_kcontrol *kcontrol,
1072 struct snd_ctl_elem_value *ucontrol)
1073 {
1074 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1075 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1076 bool lpbk_en = bt->tx->state == BT_SCO_STATE_LOOPBACK;
1077
1078 ucontrol->value.integer.value[0] = lpbk_en;
1079 return 0;
1080 }
1081
1082 static int btcvsd_loopback_set(struct snd_kcontrol *kcontrol,
1083 struct snd_ctl_elem_value *ucontrol)
1084 {
1085 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1086 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1087
1088 if (ucontrol->value.integer.value[0]) {
1089 mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_LOOPBACK);
1090 mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_LOOPBACK);
1091 } else {
1092 mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_RUNNING);
1093 mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_RUNNING);
1094 }
1095 return 0;
1096 }
1097
1098 static int btcvsd_tx_mute_get(struct snd_kcontrol *kcontrol,
1099 struct snd_ctl_elem_value *ucontrol)
1100 {
1101 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1102 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1103
1104 if (!bt->tx) {
1105 ucontrol->value.integer.value[0] = 0;
1106 return 0;
1107 }
1108
1109 ucontrol->value.integer.value[0] = bt->tx->mute;
1110 return 0;
1111 }
1112
1113 static int btcvsd_tx_mute_set(struct snd_kcontrol *kcontrol,
1114 struct snd_ctl_elem_value *ucontrol)
1115 {
1116 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1117 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1118
1119 if (!bt->tx)
1120 return 0;
1121
1122 bt->tx->mute = ucontrol->value.integer.value[0];
1123 return 0;
1124 }
1125
1126 static int btcvsd_rx_irq_received_get(struct snd_kcontrol *kcontrol,
1127 struct snd_ctl_elem_value *ucontrol)
1128 {
1129 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1130 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1131
1132 if (!bt->rx)
1133 return 0;
1134
1135 ucontrol->value.integer.value[0] = bt->rx->rw_cnt ? 1 : 0;
1136 return 0;
1137 }
1138
1139 static int btcvsd_rx_timeout_get(struct snd_kcontrol *kcontrol,
1140 struct snd_ctl_elem_value *ucontrol)
1141 {
1142 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1143 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1144
1145 if (!bt->rx)
1146 return 0;
1147
1148 ucontrol->value.integer.value[0] = bt->rx->timeout;
1149 bt->rx->timeout = 0;
1150 return 0;
1151 }
1152
1153 static int btcvsd_rx_timestamp_get(struct snd_kcontrol *kcontrol,
1154 unsigned int __user *data, unsigned int size)
1155 {
1156 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1157 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1158 int ret = 0;
1159 struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_rx;
1160
1161 if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1162 return -EINVAL;
1163
1164 get_rx_time_stamp(bt, &time_buffer_info_rx);
1165
1166 dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1167 __func__,
1168 time_buffer_info_rx.time_stamp_us,
1169 time_buffer_info_rx.data_count_equi_time);
1170
1171 if (copy_to_user(data, &time_buffer_info_rx,
1172 sizeof(struct mtk_btcvsd_snd_time_buffer_info))) {
1173 dev_warn(bt->dev, "%s(), copy_to_user fail", __func__);
1174 ret = -EFAULT;
1175 }
1176
1177 return ret;
1178 }
1179
1180 static int btcvsd_tx_irq_received_get(struct snd_kcontrol *kcontrol,
1181 struct snd_ctl_elem_value *ucontrol)
1182 {
1183 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1184 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1185
1186 if (!bt->tx)
1187 return 0;
1188
1189 ucontrol->value.integer.value[0] = bt->tx->rw_cnt ? 1 : 0;
1190 return 0;
1191 }
1192
1193 static int btcvsd_tx_timeout_get(struct snd_kcontrol *kcontrol,
1194 struct snd_ctl_elem_value *ucontrol)
1195 {
1196 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1197 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1198
1199 ucontrol->value.integer.value[0] = bt->tx->timeout;
1200 return 0;
1201 }
1202
1203 static int btcvsd_tx_timestamp_get(struct snd_kcontrol *kcontrol,
1204 unsigned int __user *data, unsigned int size)
1205 {
1206 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1207 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1208 int ret = 0;
1209 struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_tx;
1210
1211 if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1212 return -EINVAL;
1213
1214 get_tx_time_stamp(bt, &time_buffer_info_tx);
1215
1216 dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1217 __func__,
1218 time_buffer_info_tx.time_stamp_us,
1219 time_buffer_info_tx.data_count_equi_time);
1220
1221 if (copy_to_user(data, &time_buffer_info_tx,
1222 sizeof(struct mtk_btcvsd_snd_time_buffer_info))) {
1223 dev_warn(bt->dev, "%s(), copy_to_user fail", __func__);
1224 ret = -EFAULT;
1225 }
1226
1227 return ret;
1228 }
1229
1230 static const struct snd_kcontrol_new mtk_btcvsd_snd_controls[] = {
1231 SOC_ENUM_EXT("BTCVSD Band", btcvsd_enum[0],
1232 btcvsd_band_get, btcvsd_band_set),
1233 SOC_SINGLE_BOOL_EXT("BTCVSD Loopback Switch", 0,
1234 btcvsd_loopback_get, btcvsd_loopback_set),
1235 SOC_SINGLE_BOOL_EXT("BTCVSD Tx Mute Switch", 0,
1236 btcvsd_tx_mute_get, btcvsd_tx_mute_set),
1237 SOC_SINGLE_BOOL_EXT("BTCVSD Tx Irq Received Switch", 0,
1238 btcvsd_tx_irq_received_get, NULL),
1239 SOC_SINGLE_BOOL_EXT("BTCVSD Tx Timeout Switch", 0,
1240 btcvsd_tx_timeout_get, NULL),
1241 SOC_SINGLE_BOOL_EXT("BTCVSD Rx Irq Received Switch", 0,
1242 btcvsd_rx_irq_received_get, NULL),
1243 SOC_SINGLE_BOOL_EXT("BTCVSD Rx Timeout Switch", 0,
1244 btcvsd_rx_timeout_get, NULL),
1245 SND_SOC_BYTES_TLV("BTCVSD Rx Timestamp",
1246 sizeof(struct mtk_btcvsd_snd_time_buffer_info),
1247 btcvsd_rx_timestamp_get, NULL),
1248 SND_SOC_BYTES_TLV("BTCVSD Tx Timestamp",
1249 sizeof(struct mtk_btcvsd_snd_time_buffer_info),
1250 btcvsd_tx_timestamp_get, NULL),
1251 };
1252
1253 static int mtk_btcvsd_snd_component_probe(struct snd_soc_component *component)
1254 {
1255 return snd_soc_add_component_controls(component,
1256 mtk_btcvsd_snd_controls,
1257 ARRAY_SIZE(mtk_btcvsd_snd_controls));
1258 }
1259
1260 static const struct snd_soc_component_driver mtk_btcvsd_snd_platform = {
1261 .name = BTCVSD_SND_NAME,
1262 .probe = mtk_btcvsd_snd_component_probe,
1263 .open = mtk_pcm_btcvsd_open,
1264 .close = mtk_pcm_btcvsd_close,
1265 .hw_params = mtk_pcm_btcvsd_hw_params,
1266 .hw_free = mtk_pcm_btcvsd_hw_free,
1267 .prepare = mtk_pcm_btcvsd_prepare,
1268 .trigger = mtk_pcm_btcvsd_trigger,
1269 .pointer = mtk_pcm_btcvsd_pointer,
1270 .copy = mtk_pcm_btcvsd_copy,
1271 };
1272
1273 static int mtk_btcvsd_snd_probe(struct platform_device *pdev)
1274 {
1275 int ret;
1276 int irq_id;
1277 u32 offset[5] = {0, 0, 0, 0, 0};
1278 struct mtk_btcvsd_snd *btcvsd;
1279 struct device *dev = &pdev->dev;
1280
1281 /* init btcvsd private data */
1282 btcvsd = devm_kzalloc(dev, sizeof(*btcvsd), GFP_KERNEL);
1283 if (!btcvsd)
1284 return -ENOMEM;
1285 platform_set_drvdata(pdev, btcvsd);
1286 btcvsd->dev = dev;
1287
1288 /* init tx/rx */
1289 btcvsd->rx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->rx), GFP_KERNEL);
1290 if (!btcvsd->rx)
1291 return -ENOMEM;
1292
1293 btcvsd->tx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->tx), GFP_KERNEL);
1294 if (!btcvsd->tx)
1295 return -ENOMEM;
1296
1297 spin_lock_init(&btcvsd->tx_lock);
1298 spin_lock_init(&btcvsd->rx_lock);
1299
1300 init_waitqueue_head(&btcvsd->tx_wait);
1301 init_waitqueue_head(&btcvsd->rx_wait);
1302
1303 mtk_btcvsd_snd_tx_init(btcvsd);
1304 mtk_btcvsd_snd_rx_init(btcvsd);
1305
1306 /* irq */
1307 irq_id = platform_get_irq(pdev, 0);
1308 if (irq_id <= 0)
1309 return irq_id < 0 ? irq_id : -ENXIO;
1310
1311 ret = devm_request_irq(dev, irq_id, mtk_btcvsd_snd_irq_handler,
1312 IRQF_TRIGGER_LOW, "BTCVSD_ISR_Handle",
1313 (void *)btcvsd);
1314 if (ret) {
1315 dev_err(dev, "could not request_irq for BTCVSD_ISR_Handle\n");
1316 return ret;
1317 }
1318
1319 btcvsd->irq_id = irq_id;
1320
1321 /* iomap */
1322 btcvsd->bt_pkv_base = of_iomap(dev->of_node, 0);
1323 if (!btcvsd->bt_pkv_base) {
1324 dev_err(dev, "iomap bt_pkv_base fail\n");
1325 return -EIO;
1326 }
1327
1328 btcvsd->bt_sram_bank2_base = of_iomap(dev->of_node, 1);
1329 if (!btcvsd->bt_sram_bank2_base) {
1330 dev_err(dev, "iomap bt_sram_bank2_base fail\n");
1331 ret = -EIO;
1332 goto unmap_pkv_err;
1333 }
1334
1335 btcvsd->infra = syscon_regmap_lookup_by_phandle(dev->of_node,
1336 "mediatek,infracfg");
1337 if (IS_ERR(btcvsd->infra)) {
1338 dev_err(dev, "cannot find infra controller: %ld\n",
1339 PTR_ERR(btcvsd->infra));
1340 ret = PTR_ERR(btcvsd->infra);
1341 goto unmap_bank2_err;
1342 }
1343
1344 /* get offset */
1345 ret = of_property_read_u32_array(dev->of_node, "mediatek,offset",
1346 offset,
1347 ARRAY_SIZE(offset));
1348 if (ret) {
1349 dev_warn(dev, "%s(), get offset fail, ret %d\n", __func__, ret);
1350 goto unmap_bank2_err;
1351 }
1352 btcvsd->infra_misc_offset = offset[0];
1353 btcvsd->conn_bt_cvsd_mask = offset[1];
1354 btcvsd->cvsd_mcu_read_offset = offset[2];
1355 btcvsd->cvsd_mcu_write_offset = offset[3];
1356 btcvsd->cvsd_packet_indicator = offset[4];
1357
1358 btcvsd->bt_reg_pkt_r = btcvsd->bt_pkv_base +
1359 btcvsd->cvsd_mcu_read_offset;
1360 btcvsd->bt_reg_pkt_w = btcvsd->bt_pkv_base +
1361 btcvsd->cvsd_mcu_write_offset;
1362 btcvsd->bt_reg_ctl = btcvsd->bt_pkv_base +
1363 btcvsd->cvsd_packet_indicator;
1364
1365 /* init state */
1366 mtk_btcvsd_snd_set_state(btcvsd, btcvsd->tx, BT_SCO_STATE_IDLE);
1367 mtk_btcvsd_snd_set_state(btcvsd, btcvsd->rx, BT_SCO_STATE_IDLE);
1368
1369 ret = devm_snd_soc_register_component(dev, &mtk_btcvsd_snd_platform,
1370 NULL, 0);
1371 if (ret)
1372 goto unmap_bank2_err;
1373
1374 return 0;
1375
1376 unmap_bank2_err:
1377 iounmap(btcvsd->bt_sram_bank2_base);
1378 unmap_pkv_err:
1379 iounmap(btcvsd->bt_pkv_base);
1380 return ret;
1381 }
1382
1383 static void mtk_btcvsd_snd_remove(struct platform_device *pdev)
1384 {
1385 struct mtk_btcvsd_snd *btcvsd = dev_get_drvdata(&pdev->dev);
1386
1387 iounmap(btcvsd->bt_pkv_base);
1388 iounmap(btcvsd->bt_sram_bank2_base);
1389 }
1390
1391 static const struct of_device_id mtk_btcvsd_snd_dt_match[] = {
1392 { .compatible = "mediatek,mtk-btcvsd-snd", },
1393 {},
1394 };
1395 MODULE_DEVICE_TABLE(of, mtk_btcvsd_snd_dt_match);
1396
1397 static struct platform_driver mtk_btcvsd_snd_driver = {
1398 .driver = {
1399 .name = "mtk-btcvsd-snd",
1400 .of_match_table = mtk_btcvsd_snd_dt_match,
1401 },
1402 .probe = mtk_btcvsd_snd_probe,
1403 .remove_new = mtk_btcvsd_snd_remove,
1404 };
1405
1406 module_platform_driver(mtk_btcvsd_snd_driver);
1407
1408 MODULE_DESCRIPTION("Mediatek ALSA BT SCO CVSD/MSBC Driver");
1409 MODULE_AUTHOR("KaiChieh Chuang <kaichieh.chuang@mediatek.com>");
1410 MODULE_LICENSE("GPL v2");
1411
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.