~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/mediatek/common/mtk-btcvsd.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp