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
mtk_btcvsd_snd_irq_enable(struct mtk_btcvsd_snd * bt)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
mtk_btcvsd_snd_irq_disable(struct mtk_btcvsd_snd * bt)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
mtk_btcvsd_snd_set_state(struct mtk_btcvsd_snd * bt,struct mtk_btcvsd_snd_stream * bt_stream,int state)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
mtk_btcvsd_snd_tx_init(struct mtk_btcvsd_snd * bt)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
mtk_btcvsd_snd_rx_init(struct mtk_btcvsd_snd * bt)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
get_tx_time_stamp(struct mtk_btcvsd_snd * bt,struct mtk_btcvsd_snd_time_buffer_info * ts)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
get_rx_time_stamp(struct mtk_btcvsd_snd * bt,struct mtk_btcvsd_snd_time_buffer_info * ts)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
btcvsd_bytes_to_frame(struct snd_pcm_substream * substream,int bytes)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
mtk_btcvsd_snd_data_transfer(enum bt_sco_direct dir,u8 * src,u8 * dst,unsigned int blk_size,unsigned int blk_num)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 */
btcvsd_tx_clean_buffer(struct mtk_btcvsd_snd * bt)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
mtk_btcvsd_read_from_bt(struct mtk_btcvsd_snd * bt,enum bt_sco_packet_len packet_type,unsigned int packet_length,unsigned int packet_num,unsigned int blk_size,unsigned int control)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
mtk_btcvsd_write_to_bt(struct mtk_btcvsd_snd * bt,enum bt_sco_packet_len packet_type,unsigned int packet_length,unsigned int packet_num,unsigned int blk_size)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
mtk_btcvsd_snd_irq_handler(int irq_id,void * dev)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
wait_for_bt_irq(struct mtk_btcvsd_snd * bt,struct mtk_btcvsd_snd_stream * bt_stream)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
mtk_btcvsd_snd_read(struct mtk_btcvsd_snd * bt,char __user * buf,size_t count)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
mtk_btcvsd_snd_write(struct mtk_btcvsd_snd * bt,char __user * buf,size_t count)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
get_bt_stream(struct mtk_btcvsd_snd * bt,struct snd_pcm_substream * substream)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
mtk_pcm_btcvsd_open(struct snd_soc_component * component,struct snd_pcm_substream * substream)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
mtk_pcm_btcvsd_close(struct snd_soc_component * component,struct snd_pcm_substream * substream)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
mtk_pcm_btcvsd_hw_params(struct snd_soc_component * component,struct snd_pcm_substream * substream,struct snd_pcm_hw_params * hw_params)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
mtk_pcm_btcvsd_hw_free(struct snd_soc_component * component,struct snd_pcm_substream * substream)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
mtk_pcm_btcvsd_prepare(struct snd_soc_component * component,struct snd_pcm_substream * substream)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
mtk_pcm_btcvsd_trigger(struct snd_soc_component * component,struct snd_pcm_substream * substream,int cmd)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
mtk_pcm_btcvsd_pointer(struct snd_soc_component * component,struct snd_pcm_substream * substream)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
mtk_pcm_btcvsd_copy(struct snd_soc_component * component,struct snd_pcm_substream * substream,int channel,unsigned long pos,void __user * buf,unsigned long count)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 return mtk_btcvsd_snd_write(bt, buf, count);
1042 else
1043 return mtk_btcvsd_snd_read(bt, buf, count);
1044 }
1045
1046 /* kcontrol */
1047 static const char *const btsco_band_str[] = {"NB", "WB"};
1048
1049 static const struct soc_enum btcvsd_enum[] = {
1050 SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(btsco_band_str), btsco_band_str),
1051 };
1052
btcvsd_band_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1053 static int btcvsd_band_get(struct snd_kcontrol *kcontrol,
1054 struct snd_ctl_elem_value *ucontrol)
1055 {
1056 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1057 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1058
1059 ucontrol->value.integer.value[0] = bt->band;
1060 return 0;
1061 }
1062
btcvsd_band_set(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1063 static int btcvsd_band_set(struct snd_kcontrol *kcontrol,
1064 struct snd_ctl_elem_value *ucontrol)
1065 {
1066 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1067 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1068 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1069
1070 if (ucontrol->value.enumerated.item[0] >= e->items)
1071 return -EINVAL;
1072
1073 bt->band = ucontrol->value.integer.value[0];
1074 dev_dbg(bt->dev, "%s(), band %d\n", __func__, bt->band);
1075 return 0;
1076 }
1077
btcvsd_loopback_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1078 static int btcvsd_loopback_get(struct snd_kcontrol *kcontrol,
1079 struct snd_ctl_elem_value *ucontrol)
1080 {
1081 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1082 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1083 bool lpbk_en = bt->tx->state == BT_SCO_STATE_LOOPBACK;
1084
1085 ucontrol->value.integer.value[0] = lpbk_en;
1086 return 0;
1087 }
1088
btcvsd_loopback_set(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1089 static int btcvsd_loopback_set(struct snd_kcontrol *kcontrol,
1090 struct snd_ctl_elem_value *ucontrol)
1091 {
1092 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1093 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1094
1095 if (ucontrol->value.integer.value[0]) {
1096 mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_LOOPBACK);
1097 mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_LOOPBACK);
1098 } else {
1099 mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_RUNNING);
1100 mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_RUNNING);
1101 }
1102 return 0;
1103 }
1104
btcvsd_tx_mute_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1105 static int btcvsd_tx_mute_get(struct snd_kcontrol *kcontrol,
1106 struct snd_ctl_elem_value *ucontrol)
1107 {
1108 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1109 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1110
1111 if (!bt->tx) {
1112 ucontrol->value.integer.value[0] = 0;
1113 return 0;
1114 }
1115
1116 ucontrol->value.integer.value[0] = bt->tx->mute;
1117 return 0;
1118 }
1119
btcvsd_tx_mute_set(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1120 static int btcvsd_tx_mute_set(struct snd_kcontrol *kcontrol,
1121 struct snd_ctl_elem_value *ucontrol)
1122 {
1123 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1124 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1125
1126 if (!bt->tx)
1127 return 0;
1128
1129 bt->tx->mute = ucontrol->value.integer.value[0];
1130 return 0;
1131 }
1132
btcvsd_rx_irq_received_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1133 static int btcvsd_rx_irq_received_get(struct snd_kcontrol *kcontrol,
1134 struct snd_ctl_elem_value *ucontrol)
1135 {
1136 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1137 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1138
1139 if (!bt->rx)
1140 return 0;
1141
1142 ucontrol->value.integer.value[0] = bt->rx->rw_cnt ? 1 : 0;
1143 return 0;
1144 }
1145
btcvsd_rx_timeout_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1146 static int btcvsd_rx_timeout_get(struct snd_kcontrol *kcontrol,
1147 struct snd_ctl_elem_value *ucontrol)
1148 {
1149 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1150 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1151
1152 if (!bt->rx)
1153 return 0;
1154
1155 ucontrol->value.integer.value[0] = bt->rx->timeout;
1156 bt->rx->timeout = 0;
1157 return 0;
1158 }
1159
btcvsd_rx_timestamp_get(struct snd_kcontrol * kcontrol,unsigned int __user * data,unsigned int size)1160 static int btcvsd_rx_timestamp_get(struct snd_kcontrol *kcontrol,
1161 unsigned int __user *data, unsigned int size)
1162 {
1163 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1164 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1165 int ret = 0;
1166 struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_rx;
1167
1168 if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1169 return -EINVAL;
1170
1171 get_rx_time_stamp(bt, &time_buffer_info_rx);
1172
1173 dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1174 __func__,
1175 time_buffer_info_rx.time_stamp_us,
1176 time_buffer_info_rx.data_count_equi_time);
1177
1178 if (copy_to_user(data, &time_buffer_info_rx,
1179 sizeof(struct mtk_btcvsd_snd_time_buffer_info))) {
1180 dev_warn(bt->dev, "%s(), copy_to_user fail", __func__);
1181 ret = -EFAULT;
1182 }
1183
1184 return ret;
1185 }
1186
btcvsd_tx_irq_received_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1187 static int btcvsd_tx_irq_received_get(struct snd_kcontrol *kcontrol,
1188 struct snd_ctl_elem_value *ucontrol)
1189 {
1190 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1191 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1192
1193 if (!bt->tx)
1194 return 0;
1195
1196 ucontrol->value.integer.value[0] = bt->tx->rw_cnt ? 1 : 0;
1197 return 0;
1198 }
1199
btcvsd_tx_timeout_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1200 static int btcvsd_tx_timeout_get(struct snd_kcontrol *kcontrol,
1201 struct snd_ctl_elem_value *ucontrol)
1202 {
1203 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1204 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1205
1206 ucontrol->value.integer.value[0] = bt->tx->timeout;
1207 return 0;
1208 }
1209
btcvsd_tx_timestamp_get(struct snd_kcontrol * kcontrol,unsigned int __user * data,unsigned int size)1210 static int btcvsd_tx_timestamp_get(struct snd_kcontrol *kcontrol,
1211 unsigned int __user *data, unsigned int size)
1212 {
1213 struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1214 struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1215 int ret = 0;
1216 struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_tx;
1217
1218 if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1219 return -EINVAL;
1220
1221 get_tx_time_stamp(bt, &time_buffer_info_tx);
1222
1223 dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1224 __func__,
1225 time_buffer_info_tx.time_stamp_us,
1226 time_buffer_info_tx.data_count_equi_time);
1227
1228 if (copy_to_user(data, &time_buffer_info_tx,
1229 sizeof(struct mtk_btcvsd_snd_time_buffer_info))) {
1230 dev_warn(bt->dev, "%s(), copy_to_user fail", __func__);
1231 ret = -EFAULT;
1232 }
1233
1234 return ret;
1235 }
1236
1237 static const struct snd_kcontrol_new mtk_btcvsd_snd_controls[] = {
1238 SOC_ENUM_EXT("BTCVSD Band", btcvsd_enum[0],
1239 btcvsd_band_get, btcvsd_band_set),
1240 SOC_SINGLE_BOOL_EXT("BTCVSD Loopback Switch", 0,
1241 btcvsd_loopback_get, btcvsd_loopback_set),
1242 SOC_SINGLE_BOOL_EXT("BTCVSD Tx Mute Switch", 0,
1243 btcvsd_tx_mute_get, btcvsd_tx_mute_set),
1244 SOC_SINGLE_BOOL_EXT("BTCVSD Tx Irq Received Switch", 0,
1245 btcvsd_tx_irq_received_get, NULL),
1246 SOC_SINGLE_BOOL_EXT("BTCVSD Tx Timeout Switch", 0,
1247 btcvsd_tx_timeout_get, NULL),
1248 SOC_SINGLE_BOOL_EXT("BTCVSD Rx Irq Received Switch", 0,
1249 btcvsd_rx_irq_received_get, NULL),
1250 SOC_SINGLE_BOOL_EXT("BTCVSD Rx Timeout Switch", 0,
1251 btcvsd_rx_timeout_get, NULL),
1252 SND_SOC_BYTES_TLV("BTCVSD Rx Timestamp",
1253 sizeof(struct mtk_btcvsd_snd_time_buffer_info),
1254 btcvsd_rx_timestamp_get, NULL),
1255 SND_SOC_BYTES_TLV("BTCVSD Tx Timestamp",
1256 sizeof(struct mtk_btcvsd_snd_time_buffer_info),
1257 btcvsd_tx_timestamp_get, NULL),
1258 };
1259
mtk_btcvsd_snd_component_probe(struct snd_soc_component * component)1260 static int mtk_btcvsd_snd_component_probe(struct snd_soc_component *component)
1261 {
1262 return snd_soc_add_component_controls(component,
1263 mtk_btcvsd_snd_controls,
1264 ARRAY_SIZE(mtk_btcvsd_snd_controls));
1265 }
1266
1267 static const struct snd_soc_component_driver mtk_btcvsd_snd_platform = {
1268 .name = BTCVSD_SND_NAME,
1269 .probe = mtk_btcvsd_snd_component_probe,
1270 .open = mtk_pcm_btcvsd_open,
1271 .close = mtk_pcm_btcvsd_close,
1272 .hw_params = mtk_pcm_btcvsd_hw_params,
1273 .hw_free = mtk_pcm_btcvsd_hw_free,
1274 .prepare = mtk_pcm_btcvsd_prepare,
1275 .trigger = mtk_pcm_btcvsd_trigger,
1276 .pointer = mtk_pcm_btcvsd_pointer,
1277 .copy_user = mtk_pcm_btcvsd_copy,
1278 };
1279
mtk_btcvsd_snd_probe(struct platform_device * pdev)1280 static int mtk_btcvsd_snd_probe(struct platform_device *pdev)
1281 {
1282 int ret;
1283 int irq_id;
1284 u32 offset[5] = {0, 0, 0, 0, 0};
1285 struct mtk_btcvsd_snd *btcvsd;
1286 struct device *dev = &pdev->dev;
1287
1288 /* init btcvsd private data */
1289 btcvsd = devm_kzalloc(dev, sizeof(*btcvsd), GFP_KERNEL);
1290 if (!btcvsd)
1291 return -ENOMEM;
1292 platform_set_drvdata(pdev, btcvsd);
1293 btcvsd->dev = dev;
1294
1295 /* init tx/rx */
1296 btcvsd->rx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->rx), GFP_KERNEL);
1297 if (!btcvsd->rx)
1298 return -ENOMEM;
1299
1300 btcvsd->tx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->tx), GFP_KERNEL);
1301 if (!btcvsd->tx)
1302 return -ENOMEM;
1303
1304 spin_lock_init(&btcvsd->tx_lock);
1305 spin_lock_init(&btcvsd->rx_lock);
1306
1307 init_waitqueue_head(&btcvsd->tx_wait);
1308 init_waitqueue_head(&btcvsd->rx_wait);
1309
1310 mtk_btcvsd_snd_tx_init(btcvsd);
1311 mtk_btcvsd_snd_rx_init(btcvsd);
1312
1313 /* irq */
1314 irq_id = platform_get_irq(pdev, 0);
1315 if (irq_id <= 0)
1316 return irq_id < 0 ? irq_id : -ENXIO;
1317
1318 ret = devm_request_irq(dev, irq_id, mtk_btcvsd_snd_irq_handler,
1319 IRQF_TRIGGER_LOW, "BTCVSD_ISR_Handle",
1320 (void *)btcvsd);
1321 if (ret) {
1322 dev_err(dev, "could not request_irq for BTCVSD_ISR_Handle\n");
1323 return ret;
1324 }
1325
1326 btcvsd->irq_id = irq_id;
1327
1328 /* iomap */
1329 btcvsd->bt_pkv_base = of_iomap(dev->of_node, 0);
1330 if (!btcvsd->bt_pkv_base) {
1331 dev_err(dev, "iomap bt_pkv_base fail\n");
1332 return -EIO;
1333 }
1334
1335 btcvsd->bt_sram_bank2_base = of_iomap(dev->of_node, 1);
1336 if (!btcvsd->bt_sram_bank2_base) {
1337 dev_err(dev, "iomap bt_sram_bank2_base fail\n");
1338 ret = -EIO;
1339 goto unmap_pkv_err;
1340 }
1341
1342 btcvsd->infra = syscon_regmap_lookup_by_phandle(dev->of_node,
1343 "mediatek,infracfg");
1344 if (IS_ERR(btcvsd->infra)) {
1345 dev_err(dev, "cannot find infra controller: %ld\n",
1346 PTR_ERR(btcvsd->infra));
1347 ret = PTR_ERR(btcvsd->infra);
1348 goto unmap_bank2_err;
1349 }
1350
1351 /* get offset */
1352 ret = of_property_read_u32_array(dev->of_node, "mediatek,offset",
1353 offset,
1354 ARRAY_SIZE(offset));
1355 if (ret) {
1356 dev_warn(dev, "%s(), get offset fail, ret %d\n", __func__, ret);
1357 goto unmap_bank2_err;
1358 }
1359 btcvsd->infra_misc_offset = offset[0];
1360 btcvsd->conn_bt_cvsd_mask = offset[1];
1361 btcvsd->cvsd_mcu_read_offset = offset[2];
1362 btcvsd->cvsd_mcu_write_offset = offset[3];
1363 btcvsd->cvsd_packet_indicator = offset[4];
1364
1365 btcvsd->bt_reg_pkt_r = btcvsd->bt_pkv_base +
1366 btcvsd->cvsd_mcu_read_offset;
1367 btcvsd->bt_reg_pkt_w = btcvsd->bt_pkv_base +
1368 btcvsd->cvsd_mcu_write_offset;
1369 btcvsd->bt_reg_ctl = btcvsd->bt_pkv_base +
1370 btcvsd->cvsd_packet_indicator;
1371
1372 /* init state */
1373 mtk_btcvsd_snd_set_state(btcvsd, btcvsd->tx, BT_SCO_STATE_IDLE);
1374 mtk_btcvsd_snd_set_state(btcvsd, btcvsd->rx, BT_SCO_STATE_IDLE);
1375
1376 ret = devm_snd_soc_register_component(dev, &mtk_btcvsd_snd_platform,
1377 NULL, 0);
1378 if (ret)
1379 goto unmap_bank2_err;
1380
1381 return 0;
1382
1383 unmap_bank2_err:
1384 iounmap(btcvsd->bt_sram_bank2_base);
1385 unmap_pkv_err:
1386 iounmap(btcvsd->bt_pkv_base);
1387 return ret;
1388 }
1389
mtk_btcvsd_snd_remove(struct platform_device * pdev)1390 static int mtk_btcvsd_snd_remove(struct platform_device *pdev)
1391 {
1392 struct mtk_btcvsd_snd *btcvsd = dev_get_drvdata(&pdev->dev);
1393
1394 iounmap(btcvsd->bt_pkv_base);
1395 iounmap(btcvsd->bt_sram_bank2_base);
1396 return 0;
1397 }
1398
1399 static const struct of_device_id mtk_btcvsd_snd_dt_match[] = {
1400 { .compatible = "mediatek,mtk-btcvsd-snd", },
1401 {},
1402 };
1403 MODULE_DEVICE_TABLE(of, mtk_btcvsd_snd_dt_match);
1404
1405 static struct platform_driver mtk_btcvsd_snd_driver = {
1406 .driver = {
1407 .name = "mtk-btcvsd-snd",
1408 .of_match_table = mtk_btcvsd_snd_dt_match,
1409 },
1410 .probe = mtk_btcvsd_snd_probe,
1411 .remove = mtk_btcvsd_snd_remove,
1412 };
1413
1414 module_platform_driver(mtk_btcvsd_snd_driver);
1415
1416 MODULE_DESCRIPTION("Mediatek ALSA BT SCO CVSD/MSBC Driver");
1417 MODULE_AUTHOR("KaiChieh Chuang <kaichieh.chuang@mediatek.com>");
1418 MODULE_LICENSE("GPL v2");
1419