Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 //
0003 // Mediatek ALSA BT SCO CVSD/MSBC Driver
0004 //
0005 // Copyright (c) 2019 MediaTek Inc.
0006 // Author: KaiChieh Chuang <kaichieh.chuang@mediatek.com>
0007 
0008 #include <linux/mfd/syscon.h>
0009 #include <linux/module.h>
0010 #include <linux/of_address.h>
0011 #include <linux/sched/clock.h>
0012 
0013 #include <sound/soc.h>
0014 
0015 #define BTCVSD_SND_NAME "mtk-btcvsd-snd"
0016 
0017 #define BT_CVSD_TX_NREADY   BIT(21)
0018 #define BT_CVSD_RX_READY    BIT(22)
0019 #define BT_CVSD_TX_UNDERFLOW    BIT(23)
0020 #define BT_CVSD_RX_OVERFLOW BIT(24)
0021 #define BT_CVSD_INTERRUPT   BIT(31)
0022 
0023 #define BT_CVSD_CLEAR \
0024     (BT_CVSD_TX_NREADY | BT_CVSD_RX_READY | BT_CVSD_TX_UNDERFLOW |\
0025      BT_CVSD_RX_OVERFLOW | BT_CVSD_INTERRUPT)
0026 
0027 /* TX */
0028 #define SCO_TX_ENCODE_SIZE (60)
0029 /* 18 = 6 * 180 / SCO_TX_ENCODE_SIZE */
0030 #define SCO_TX_PACKER_BUF_NUM (18)
0031 
0032 /* RX */
0033 #define SCO_RX_PLC_SIZE (30)
0034 #define SCO_RX_PACKER_BUF_NUM (64)
0035 #define SCO_RX_PACKET_MASK (0x3F)
0036 
0037 #define SCO_CVSD_PACKET_VALID_SIZE 2
0038 
0039 #define SCO_PACKET_120 120
0040 #define SCO_PACKET_180 180
0041 
0042 #define BTCVSD_RX_PACKET_SIZE (SCO_RX_PLC_SIZE + SCO_CVSD_PACKET_VALID_SIZE)
0043 #define BTCVSD_TX_PACKET_SIZE (SCO_TX_ENCODE_SIZE)
0044 
0045 #define BTCVSD_RX_BUF_SIZE (BTCVSD_RX_PACKET_SIZE * SCO_RX_PACKER_BUF_NUM)
0046 #define BTCVSD_TX_BUF_SIZE (BTCVSD_TX_PACKET_SIZE * SCO_TX_PACKER_BUF_NUM)
0047 
0048 enum bt_sco_state {
0049     BT_SCO_STATE_IDLE,
0050     BT_SCO_STATE_RUNNING,
0051     BT_SCO_STATE_ENDING,
0052     BT_SCO_STATE_LOOPBACK,
0053 };
0054 
0055 enum bt_sco_direct {
0056     BT_SCO_DIRECT_BT2ARM,
0057     BT_SCO_DIRECT_ARM2BT,
0058 };
0059 
0060 enum bt_sco_packet_len {
0061     BT_SCO_CVSD_30 = 0,
0062     BT_SCO_CVSD_60,
0063     BT_SCO_CVSD_90,
0064     BT_SCO_CVSD_120,
0065     BT_SCO_CVSD_10,
0066     BT_SCO_CVSD_20,
0067     BT_SCO_CVSD_MAX,
0068 };
0069 
0070 enum BT_SCO_BAND {
0071     BT_SCO_NB,
0072     BT_SCO_WB,
0073 };
0074 
0075 struct mtk_btcvsd_snd_hw_info {
0076     unsigned int num_valid_addr;
0077     unsigned long bt_sram_addr[20];
0078     unsigned int packet_length;
0079     unsigned int packet_num;
0080 };
0081 
0082 struct mtk_btcvsd_snd_stream {
0083     struct snd_pcm_substream *substream;
0084     int stream;
0085 
0086     enum bt_sco_state state;
0087 
0088     unsigned int packet_size;
0089     unsigned int buf_size;
0090     u8 temp_packet_buf[SCO_PACKET_180];
0091 
0092     int packet_w;
0093     int packet_r;
0094     snd_pcm_uframes_t prev_frame;
0095     int prev_packet_idx;
0096 
0097     unsigned int xrun:1;
0098     unsigned int timeout:1;
0099     unsigned int mute:1;
0100     unsigned int trigger_start:1;
0101     unsigned int wait_flag:1;
0102     unsigned int rw_cnt;
0103 
0104     unsigned long long time_stamp;
0105     unsigned long long buf_data_equivalent_time;
0106 
0107     struct mtk_btcvsd_snd_hw_info buffer_info;
0108 };
0109 
0110 struct mtk_btcvsd_snd {
0111     struct device *dev;
0112     int irq_id;
0113 
0114     struct regmap *infra;
0115     void __iomem *bt_pkv_base;
0116     void __iomem *bt_sram_bank2_base;
0117 
0118     unsigned int infra_misc_offset;
0119     unsigned int conn_bt_cvsd_mask;
0120     unsigned int cvsd_mcu_read_offset;
0121     unsigned int cvsd_mcu_write_offset;
0122     unsigned int cvsd_packet_indicator;
0123 
0124     u32 *bt_reg_pkt_r;
0125     u32 *bt_reg_pkt_w;
0126     u32 *bt_reg_ctl;
0127 
0128     unsigned int irq_disabled:1;
0129 
0130     spinlock_t tx_lock; /* spinlock for bt tx stream control */
0131     spinlock_t rx_lock; /* spinlock for bt rx stream control */
0132     wait_queue_head_t tx_wait;
0133     wait_queue_head_t rx_wait;
0134 
0135     struct mtk_btcvsd_snd_stream *tx;
0136     struct mtk_btcvsd_snd_stream *rx;
0137     u8 tx_packet_buf[BTCVSD_TX_BUF_SIZE];
0138     u8 rx_packet_buf[BTCVSD_RX_BUF_SIZE];
0139 
0140     enum BT_SCO_BAND band;
0141 };
0142 
0143 struct mtk_btcvsd_snd_time_buffer_info {
0144     unsigned long long data_count_equi_time;
0145     unsigned long long time_stamp_us;
0146 };
0147 
0148 static const unsigned int btsco_packet_valid_mask[BT_SCO_CVSD_MAX][6] = {
0149     {0x1, 0x1 << 1, 0x1 << 2, 0x1 << 3, 0x1 << 4, 0x1 << 5},
0150     {0x1, 0x1, 0x2, 0x2, 0x4, 0x4},
0151     {0x1, 0x1, 0x1, 0x2, 0x2, 0x2},
0152     {0x1, 0x1, 0x1, 0x1, 0x0, 0x0},
0153     {0x7, 0x7 << 3, 0x7 << 6, 0x7 << 9, 0x7 << 12, 0x7 << 15},
0154     {0x3, 0x3 << 1, 0x3 << 3, 0x3 << 4, 0x3 << 6, 0x3 << 7},
0155 };
0156 
0157 static const unsigned int btsco_packet_info[BT_SCO_CVSD_MAX][4] = {
0158     {30, 6, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
0159      SCO_PACKET_180 / SCO_RX_PLC_SIZE},
0160     {60, 3, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
0161      SCO_PACKET_180 / SCO_RX_PLC_SIZE},
0162     {90, 2, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
0163      SCO_PACKET_180 / SCO_RX_PLC_SIZE},
0164     {120, 1, SCO_PACKET_120 / SCO_TX_ENCODE_SIZE,
0165      SCO_PACKET_120 / SCO_RX_PLC_SIZE},
0166     {10, 18, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
0167      SCO_PACKET_180 / SCO_RX_PLC_SIZE},
0168     {20, 9, SCO_PACKET_180 / SCO_TX_ENCODE_SIZE,
0169      SCO_PACKET_180 / SCO_RX_PLC_SIZE},
0170 };
0171 
0172 static const u8 table_msbc_silence[SCO_PACKET_180] = {
0173     0x01, 0x38, 0xad, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00,
0174     0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d,
0175     0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7,
0176     0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd,
0177     0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77,
0178     0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6c, 0x00,
0179     0x01, 0xc8, 0xad, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00,
0180     0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d,
0181     0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7,
0182     0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd,
0183     0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77,
0184     0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6c, 0x00,
0185     0x01, 0xf8, 0xad, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00,
0186     0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d,
0187     0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7,
0188     0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77, 0x6d, 0xb6, 0xdd,
0189     0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6d, 0xdd, 0xb6, 0xdb, 0x77,
0190     0x6d, 0xb6, 0xdd, 0xdb, 0x6d, 0xb7, 0x76, 0xdb, 0x6c, 0x00
0191 };
0192 
0193 static void mtk_btcvsd_snd_irq_enable(struct mtk_btcvsd_snd *bt)
0194 {
0195     regmap_update_bits(bt->infra, bt->infra_misc_offset,
0196                bt->conn_bt_cvsd_mask, 0);
0197 }
0198 
0199 static void mtk_btcvsd_snd_irq_disable(struct mtk_btcvsd_snd *bt)
0200 {
0201     regmap_update_bits(bt->infra, bt->infra_misc_offset,
0202                bt->conn_bt_cvsd_mask, bt->conn_bt_cvsd_mask);
0203 }
0204 
0205 static void mtk_btcvsd_snd_set_state(struct mtk_btcvsd_snd *bt,
0206                      struct mtk_btcvsd_snd_stream *bt_stream,
0207                      int state)
0208 {
0209     dev_dbg(bt->dev, "%s(), stream %d, state %d, tx->state %d, rx->state %d, irq_disabled %d\n",
0210         __func__,
0211         bt_stream->stream, state,
0212         bt->tx->state, bt->rx->state, bt->irq_disabled);
0213 
0214     bt_stream->state = state;
0215 
0216     if (bt->tx->state == BT_SCO_STATE_IDLE &&
0217         bt->rx->state == BT_SCO_STATE_IDLE) {
0218         if (!bt->irq_disabled) {
0219             disable_irq(bt->irq_id);
0220             mtk_btcvsd_snd_irq_disable(bt);
0221             bt->irq_disabled = 1;
0222         }
0223     } else {
0224         if (bt->irq_disabled) {
0225             enable_irq(bt->irq_id);
0226             mtk_btcvsd_snd_irq_enable(bt);
0227             bt->irq_disabled = 0;
0228         }
0229     }
0230 }
0231 
0232 static int mtk_btcvsd_snd_tx_init(struct mtk_btcvsd_snd *bt)
0233 {
0234     memset(bt->tx, 0, sizeof(*bt->tx));
0235     memset(bt->tx_packet_buf, 0, sizeof(bt->tx_packet_buf));
0236 
0237     bt->tx->packet_size = BTCVSD_TX_PACKET_SIZE;
0238     bt->tx->buf_size = BTCVSD_TX_BUF_SIZE;
0239     bt->tx->timeout = 0;
0240     bt->tx->rw_cnt = 0;
0241     bt->tx->stream = SNDRV_PCM_STREAM_PLAYBACK;
0242     return 0;
0243 }
0244 
0245 static int mtk_btcvsd_snd_rx_init(struct mtk_btcvsd_snd *bt)
0246 {
0247     memset(bt->rx, 0, sizeof(*bt->rx));
0248     memset(bt->rx_packet_buf, 0, sizeof(bt->rx_packet_buf));
0249 
0250     bt->rx->packet_size = BTCVSD_RX_PACKET_SIZE;
0251     bt->rx->buf_size = BTCVSD_RX_BUF_SIZE;
0252     bt->rx->timeout = 0;
0253     bt->rx->rw_cnt = 0;
0254     bt->rx->stream = SNDRV_PCM_STREAM_CAPTURE;
0255     return 0;
0256 }
0257 
0258 static void get_tx_time_stamp(struct mtk_btcvsd_snd *bt,
0259                   struct mtk_btcvsd_snd_time_buffer_info *ts)
0260 {
0261     ts->time_stamp_us = bt->tx->time_stamp;
0262     ts->data_count_equi_time = bt->tx->buf_data_equivalent_time;
0263 }
0264 
0265 static void get_rx_time_stamp(struct mtk_btcvsd_snd *bt,
0266                   struct mtk_btcvsd_snd_time_buffer_info *ts)
0267 {
0268     ts->time_stamp_us = bt->rx->time_stamp;
0269     ts->data_count_equi_time = bt->rx->buf_data_equivalent_time;
0270 }
0271 
0272 static int btcvsd_bytes_to_frame(struct snd_pcm_substream *substream,
0273                  int bytes)
0274 {
0275     int count = bytes;
0276     struct snd_pcm_runtime *runtime = substream->runtime;
0277 
0278     if (runtime->format == SNDRV_PCM_FORMAT_S32_LE ||
0279         runtime->format == SNDRV_PCM_FORMAT_U32_LE)
0280         count = count >> 2;
0281     else
0282         count = count >> 1;
0283 
0284     count = count / runtime->channels;
0285     return count;
0286 }
0287 
0288 static void mtk_btcvsd_snd_data_transfer(enum bt_sco_direct dir,
0289                      u8 *src, u8 *dst,
0290                      unsigned int blk_size,
0291                      unsigned int blk_num)
0292 {
0293     unsigned int i, j;
0294 
0295     if (blk_size == 60 || blk_size == 120 || blk_size == 20) {
0296         u32 *src_32 = (u32 *)src;
0297         u32 *dst_32 = (u32 *)dst;
0298 
0299         for (i = 0; i < (blk_size * blk_num / 4); i++)
0300             *dst_32++ = *src_32++;
0301     } else {
0302         u16 *src_16 = (u16 *)src;
0303         u16 *dst_16 = (u16 *)dst;
0304 
0305         for (j = 0; j < blk_num; j++) {
0306             for (i = 0; i < (blk_size / 2); i++)
0307                 *dst_16++ = *src_16++;
0308 
0309             if (dir == BT_SCO_DIRECT_BT2ARM)
0310                 src_16++;
0311             else
0312                 dst_16++;
0313         }
0314     }
0315 }
0316 
0317 /* write encoded mute data to bt sram */
0318 static int btcvsd_tx_clean_buffer(struct mtk_btcvsd_snd *bt)
0319 {
0320     unsigned int i;
0321     unsigned int num_valid_addr;
0322     unsigned long flags;
0323     enum BT_SCO_BAND band = bt->band;
0324 
0325     /* prepare encoded mute data */
0326     if (band == BT_SCO_NB)
0327         memset(bt->tx->temp_packet_buf, 170, SCO_PACKET_180);
0328     else
0329         memcpy(bt->tx->temp_packet_buf,
0330                table_msbc_silence, SCO_PACKET_180);
0331 
0332     /* write mute data to bt tx sram buffer */
0333     spin_lock_irqsave(&bt->tx_lock, flags);
0334     num_valid_addr = bt->tx->buffer_info.num_valid_addr;
0335 
0336     dev_info(bt->dev, "%s(), band %d, num_valid_addr %u\n",
0337          __func__, band, num_valid_addr);
0338 
0339     for (i = 0; i < num_valid_addr; i++) {
0340         void *dst;
0341 
0342         dev_info(bt->dev, "%s(), clean addr 0x%lx\n", __func__,
0343              bt->tx->buffer_info.bt_sram_addr[i]);
0344 
0345         dst = (void *)bt->tx->buffer_info.bt_sram_addr[i];
0346 
0347         mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT,
0348                          bt->tx->temp_packet_buf, dst,
0349                          bt->tx->buffer_info.packet_length,
0350                          bt->tx->buffer_info.packet_num);
0351     }
0352     spin_unlock_irqrestore(&bt->tx_lock, flags);
0353 
0354     return 0;
0355 }
0356 
0357 static int mtk_btcvsd_read_from_bt(struct mtk_btcvsd_snd *bt,
0358                    enum bt_sco_packet_len packet_type,
0359                    unsigned int packet_length,
0360                    unsigned int packet_num,
0361                    unsigned int blk_size,
0362                    unsigned int control)
0363 {
0364     unsigned int i;
0365     int pv;
0366     u8 *src;
0367     unsigned int packet_buf_ofs;
0368     unsigned long flags;
0369     unsigned long connsys_addr_rx, ap_addr_rx;
0370 
0371     connsys_addr_rx = *bt->bt_reg_pkt_r;
0372     ap_addr_rx = (unsigned long)bt->bt_sram_bank2_base +
0373              (connsys_addr_rx & 0xFFFF);
0374 
0375     if (connsys_addr_rx == 0xdeadfeed) {
0376         /* bt return 0xdeadfeed if read register during bt sleep */
0377         dev_warn(bt->dev, "%s(), connsys_addr_rx == 0xdeadfeed",
0378              __func__);
0379         return -EIO;
0380     }
0381 
0382     src = (u8 *)ap_addr_rx;
0383 
0384     mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_BT2ARM, src,
0385                      bt->rx->temp_packet_buf, packet_length,
0386                      packet_num);
0387 
0388     spin_lock_irqsave(&bt->rx_lock, flags);
0389     for (i = 0; i < blk_size; i++) {
0390         packet_buf_ofs = (bt->rx->packet_w & SCO_RX_PACKET_MASK) *
0391                  bt->rx->packet_size;
0392         memcpy(bt->rx_packet_buf + packet_buf_ofs,
0393                bt->rx->temp_packet_buf + (SCO_RX_PLC_SIZE * i),
0394                SCO_RX_PLC_SIZE);
0395         if ((control & btsco_packet_valid_mask[packet_type][i]) ==
0396             btsco_packet_valid_mask[packet_type][i])
0397             pv = 1;
0398         else
0399             pv = 0;
0400 
0401         packet_buf_ofs += SCO_RX_PLC_SIZE;
0402         memcpy(bt->rx_packet_buf + packet_buf_ofs, (void *)&pv,
0403                SCO_CVSD_PACKET_VALID_SIZE);
0404         bt->rx->packet_w++;
0405     }
0406     spin_unlock_irqrestore(&bt->rx_lock, flags);
0407     return 0;
0408 }
0409 
0410 static int mtk_btcvsd_write_to_bt(struct mtk_btcvsd_snd *bt,
0411                   enum bt_sco_packet_len packet_type,
0412                   unsigned int packet_length,
0413                   unsigned int packet_num,
0414                   unsigned int blk_size)
0415 {
0416     unsigned int i;
0417     unsigned long flags;
0418     u8 *dst;
0419     unsigned long connsys_addr_tx, ap_addr_tx;
0420     bool new_ap_addr_tx = true;
0421 
0422     connsys_addr_tx = *bt->bt_reg_pkt_w;
0423     ap_addr_tx = (unsigned long)bt->bt_sram_bank2_base +
0424              (connsys_addr_tx & 0xFFFF);
0425 
0426     if (connsys_addr_tx == 0xdeadfeed) {
0427         /* bt return 0xdeadfeed if read register during bt sleep */
0428         dev_warn(bt->dev, "%s(), connsys_addr_tx == 0xdeadfeed\n",
0429              __func__);
0430         return -EIO;
0431     }
0432 
0433     spin_lock_irqsave(&bt->tx_lock, flags);
0434     for (i = 0; i < blk_size; i++) {
0435         memcpy(bt->tx->temp_packet_buf + (bt->tx->packet_size * i),
0436                (bt->tx_packet_buf +
0437             (bt->tx->packet_r % SCO_TX_PACKER_BUF_NUM) *
0438             bt->tx->packet_size),
0439                bt->tx->packet_size);
0440 
0441         bt->tx->packet_r++;
0442     }
0443     spin_unlock_irqrestore(&bt->tx_lock, flags);
0444 
0445     dst = (u8 *)ap_addr_tx;
0446 
0447     if (!bt->tx->mute) {
0448         mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT,
0449                          bt->tx->temp_packet_buf, dst,
0450                          packet_length, packet_num);
0451     }
0452 
0453     /* store bt tx buffer sram info */
0454     bt->tx->buffer_info.packet_length = packet_length;
0455     bt->tx->buffer_info.packet_num = packet_num;
0456     for (i = 0; i < bt->tx->buffer_info.num_valid_addr; i++) {
0457         if (bt->tx->buffer_info.bt_sram_addr[i] == ap_addr_tx) {
0458             new_ap_addr_tx = false;
0459             break;
0460         }
0461     }
0462     if (new_ap_addr_tx) {
0463         unsigned int next_idx;
0464 
0465         spin_lock_irqsave(&bt->tx_lock, flags);
0466         bt->tx->buffer_info.num_valid_addr++;
0467         next_idx = bt->tx->buffer_info.num_valid_addr - 1;
0468         bt->tx->buffer_info.bt_sram_addr[next_idx] = ap_addr_tx;
0469         spin_unlock_irqrestore(&bt->tx_lock, flags);
0470         dev_info(bt->dev, "%s(), new ap_addr_tx = 0x%lx, num_valid_addr %d\n",
0471              __func__, ap_addr_tx,
0472              bt->tx->buffer_info.num_valid_addr);
0473     }
0474 
0475     if (bt->tx->mute)
0476         btcvsd_tx_clean_buffer(bt);
0477 
0478     return 0;
0479 }
0480 
0481 static irqreturn_t mtk_btcvsd_snd_irq_handler(int irq_id, void *dev)
0482 {
0483     struct mtk_btcvsd_snd *bt = dev;
0484     unsigned int packet_type, packet_num, packet_length;
0485     unsigned int buf_cnt_tx, buf_cnt_rx, control;
0486 
0487     if (bt->rx->state != BT_SCO_STATE_RUNNING &&
0488         bt->rx->state != BT_SCO_STATE_ENDING &&
0489         bt->tx->state != BT_SCO_STATE_RUNNING &&
0490         bt->tx->state != BT_SCO_STATE_ENDING &&
0491         bt->tx->state != BT_SCO_STATE_LOOPBACK) {
0492         dev_warn(bt->dev, "%s(), in idle state: rx->state: %d, tx->state: %d\n",
0493              __func__, bt->rx->state, bt->tx->state);
0494         goto irq_handler_exit;
0495     }
0496 
0497     control = *bt->bt_reg_ctl;
0498     packet_type = (control >> 18) & 0x7;
0499 
0500     if (((control >> 31) & 1) == 0) {
0501         dev_warn(bt->dev, "%s(), ((control >> 31) & 1) == 0, control 0x%x\n",
0502              __func__, control);
0503         goto irq_handler_exit;
0504     }
0505 
0506     if (packet_type >= BT_SCO_CVSD_MAX) {
0507         dev_warn(bt->dev, "%s(), invalid packet_type %u, exit\n",
0508              __func__, packet_type);
0509         goto irq_handler_exit;
0510     }
0511 
0512     packet_length = btsco_packet_info[packet_type][0];
0513     packet_num = btsco_packet_info[packet_type][1];
0514     buf_cnt_tx = btsco_packet_info[packet_type][2];
0515     buf_cnt_rx = btsco_packet_info[packet_type][3];
0516 
0517     if (bt->tx->state == BT_SCO_STATE_LOOPBACK) {
0518         u8 *src, *dst;
0519         unsigned long connsys_addr_rx, ap_addr_rx;
0520         unsigned long connsys_addr_tx, ap_addr_tx;
0521 
0522         connsys_addr_rx = *bt->bt_reg_pkt_r;
0523         ap_addr_rx = (unsigned long)bt->bt_sram_bank2_base +
0524                  (connsys_addr_rx & 0xFFFF);
0525 
0526         connsys_addr_tx = *bt->bt_reg_pkt_w;
0527         ap_addr_tx = (unsigned long)bt->bt_sram_bank2_base +
0528                  (connsys_addr_tx & 0xFFFF);
0529 
0530         if (connsys_addr_tx == 0xdeadfeed ||
0531             connsys_addr_rx == 0xdeadfeed) {
0532             /* bt return 0xdeadfeed if read reg during bt sleep */
0533             dev_warn(bt->dev, "%s(), connsys_addr_tx == 0xdeadfeed\n",
0534                  __func__);
0535             goto irq_handler_exit;
0536         }
0537 
0538         src = (u8 *)ap_addr_rx;
0539         dst = (u8 *)ap_addr_tx;
0540 
0541         mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_BT2ARM, src,
0542                          bt->tx->temp_packet_buf,
0543                          packet_length,
0544                          packet_num);
0545         mtk_btcvsd_snd_data_transfer(BT_SCO_DIRECT_ARM2BT,
0546                          bt->tx->temp_packet_buf, dst,
0547                          packet_length,
0548                          packet_num);
0549         bt->rx->rw_cnt++;
0550         bt->tx->rw_cnt++;
0551     }
0552 
0553     if (bt->rx->state == BT_SCO_STATE_RUNNING ||
0554         bt->rx->state == BT_SCO_STATE_ENDING) {
0555         if (bt->rx->xrun) {
0556             if (bt->rx->packet_w - bt->rx->packet_r <=
0557                 SCO_RX_PACKER_BUF_NUM - 2 * buf_cnt_rx) {
0558                 /*
0559                  * free space is larger then
0560                  * twice interrupt rx data size
0561                  */
0562                 bt->rx->xrun = 0;
0563                 dev_warn(bt->dev, "%s(), rx->xrun 0!\n",
0564                      __func__);
0565             }
0566         }
0567 
0568         if (!bt->rx->xrun &&
0569             (bt->rx->packet_w - bt->rx->packet_r <=
0570              SCO_RX_PACKER_BUF_NUM - buf_cnt_rx)) {
0571             mtk_btcvsd_read_from_bt(bt,
0572                         packet_type,
0573                         packet_length,
0574                         packet_num,
0575                         buf_cnt_rx,
0576                         control);
0577             bt->rx->rw_cnt++;
0578         } else {
0579             bt->rx->xrun = 1;
0580             dev_warn(bt->dev, "%s(), rx->xrun 1\n", __func__);
0581         }
0582     }
0583 
0584     /* tx */
0585     bt->tx->timeout = 0;
0586     if ((bt->tx->state == BT_SCO_STATE_RUNNING ||
0587          bt->tx->state == BT_SCO_STATE_ENDING) &&
0588         bt->tx->trigger_start) {
0589         if (bt->tx->xrun) {
0590             /* prepared data is larger then twice
0591              * interrupt tx data size
0592              */
0593             if (bt->tx->packet_w - bt->tx->packet_r >=
0594                 2 * buf_cnt_tx) {
0595                 bt->tx->xrun = 0;
0596                 dev_warn(bt->dev, "%s(), tx->xrun 0\n",
0597                      __func__);
0598             }
0599         }
0600 
0601         if ((!bt->tx->xrun &&
0602              (bt->tx->packet_w - bt->tx->packet_r >= buf_cnt_tx)) ||
0603             bt->tx->state == BT_SCO_STATE_ENDING) {
0604             mtk_btcvsd_write_to_bt(bt,
0605                            packet_type,
0606                            packet_length,
0607                            packet_num,
0608                            buf_cnt_tx);
0609             bt->tx->rw_cnt++;
0610         } else {
0611             bt->tx->xrun = 1;
0612             dev_warn(bt->dev, "%s(), tx->xrun 1\n", __func__);
0613         }
0614     }
0615 
0616     *bt->bt_reg_ctl &= ~BT_CVSD_CLEAR;
0617 
0618     if (bt->rx->state == BT_SCO_STATE_RUNNING ||
0619         bt->rx->state == BT_SCO_STATE_ENDING) {
0620         bt->rx->wait_flag = 1;
0621         wake_up_interruptible(&bt->rx_wait);
0622         snd_pcm_period_elapsed(bt->rx->substream);
0623     }
0624     if (bt->tx->state == BT_SCO_STATE_RUNNING ||
0625         bt->tx->state == BT_SCO_STATE_ENDING) {
0626         bt->tx->wait_flag = 1;
0627         wake_up_interruptible(&bt->tx_wait);
0628         snd_pcm_period_elapsed(bt->tx->substream);
0629     }
0630 
0631     return IRQ_HANDLED;
0632 irq_handler_exit:
0633     *bt->bt_reg_ctl &= ~BT_CVSD_CLEAR;
0634     return IRQ_HANDLED;
0635 }
0636 
0637 static int wait_for_bt_irq(struct mtk_btcvsd_snd *bt,
0638                struct mtk_btcvsd_snd_stream *bt_stream)
0639 {
0640     unsigned long long t1, t2;
0641     /* one interrupt period = 22.5ms */
0642     unsigned long long timeout_limit = 22500000;
0643     int max_timeout_trial = 2;
0644     int ret;
0645 
0646     bt_stream->wait_flag = 0;
0647 
0648     while (max_timeout_trial && !bt_stream->wait_flag) {
0649         t1 = sched_clock();
0650         if (bt_stream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
0651             ret = wait_event_interruptible_timeout(bt->tx_wait,
0652                 bt_stream->wait_flag,
0653                 nsecs_to_jiffies(timeout_limit));
0654         } else {
0655             ret = wait_event_interruptible_timeout(bt->rx_wait,
0656                 bt_stream->wait_flag,
0657                 nsecs_to_jiffies(timeout_limit));
0658         }
0659 
0660         t2 = sched_clock();
0661         t2 = t2 - t1; /* in ns (10^9) */
0662 
0663         if (t2 > timeout_limit) {
0664             dev_warn(bt->dev, "%s(), stream %d, timeout %llu, limit %llu, ret %d, flag %d\n",
0665                  __func__, bt_stream->stream,
0666                  t2, timeout_limit, ret,
0667                  bt_stream->wait_flag);
0668         }
0669 
0670         if (ret < 0) {
0671             /*
0672              * error, -ERESTARTSYS if it was interrupted by
0673              * a signal
0674              */
0675             dev_warn(bt->dev, "%s(), stream %d, error, trial left %d\n",
0676                  __func__,
0677                  bt_stream->stream, max_timeout_trial);
0678 
0679             bt_stream->timeout = 1;
0680             return ret;
0681         } else if (ret == 0) {
0682             /* conidtion is false after timeout */
0683             max_timeout_trial--;
0684             dev_warn(bt->dev, "%s(), stream %d, error, timeout, condition is false, trial left %d\n",
0685                  __func__,
0686                  bt_stream->stream, max_timeout_trial);
0687 
0688             if (max_timeout_trial <= 0) {
0689                 bt_stream->timeout = 1;
0690                 return -ETIME;
0691             }
0692         }
0693     }
0694 
0695     return 0;
0696 }
0697 
0698 static ssize_t mtk_btcvsd_snd_read(struct mtk_btcvsd_snd *bt,
0699                    char __user *buf,
0700                    size_t count)
0701 {
0702     ssize_t read_size = 0, read_count = 0, cur_read_idx, cont;
0703     unsigned int cur_buf_ofs = 0;
0704     unsigned long avail;
0705     unsigned long flags;
0706     unsigned int packet_size = bt->rx->packet_size;
0707 
0708     while (count) {
0709         spin_lock_irqsave(&bt->rx_lock, flags);
0710         /* available data in RX packet buffer */
0711         avail = (bt->rx->packet_w - bt->rx->packet_r) * packet_size;
0712 
0713         cur_read_idx = (bt->rx->packet_r & SCO_RX_PACKET_MASK) *
0714                    packet_size;
0715         spin_unlock_irqrestore(&bt->rx_lock, flags);
0716 
0717         if (!avail) {
0718             int ret = wait_for_bt_irq(bt, bt->rx);
0719 
0720             if (ret)
0721                 return read_count;
0722 
0723             continue;
0724         }
0725 
0726         /* count must be multiple of packet_size */
0727         if (count % packet_size != 0 ||
0728             avail % packet_size != 0) {
0729             dev_warn(bt->dev, "%s(), count %zu or d %lu is not multiple of packet_size %dd\n",
0730                  __func__, count, avail, packet_size);
0731 
0732             count -= count % packet_size;
0733             avail -= avail % packet_size;
0734         }
0735 
0736         if (count > avail)
0737             read_size = avail;
0738         else
0739             read_size = count;
0740 
0741         /* calculate continue space */
0742         cont = bt->rx->buf_size - cur_read_idx;
0743         if (read_size > cont)
0744             read_size = cont;
0745 
0746         if (copy_to_user(buf + cur_buf_ofs,
0747                  bt->rx_packet_buf + cur_read_idx,
0748                  read_size)) {
0749             dev_warn(bt->dev, "%s(), copy_to_user fail\n",
0750                  __func__);
0751             return -EFAULT;
0752         }
0753 
0754         spin_lock_irqsave(&bt->rx_lock, flags);
0755         bt->rx->packet_r += read_size / packet_size;
0756         spin_unlock_irqrestore(&bt->rx_lock, flags);
0757 
0758         read_count += read_size;
0759         cur_buf_ofs += read_size;
0760         count -= read_size;
0761     }
0762 
0763     /*
0764      * save current timestamp & buffer time in times_tamp and
0765      * buf_data_equivalent_time
0766      */
0767     bt->rx->time_stamp = sched_clock();
0768     bt->rx->buf_data_equivalent_time =
0769         (unsigned long long)(bt->rx->packet_w - bt->rx->packet_r) *
0770         SCO_RX_PLC_SIZE * 16 * 1000 / 2 / 64;
0771     bt->rx->buf_data_equivalent_time += read_count * SCO_RX_PLC_SIZE *
0772                         16 * 1000 / packet_size / 2 / 64;
0773     /* return equivalent time(us) to data count */
0774     bt->rx->buf_data_equivalent_time *= 1000;
0775 
0776     return read_count;
0777 }
0778 
0779 static ssize_t mtk_btcvsd_snd_write(struct mtk_btcvsd_snd *bt,
0780                     char __user *buf,
0781                     size_t count)
0782 {
0783     int written_size = count, avail, cur_write_idx, write_size, cont;
0784     unsigned int cur_buf_ofs = 0;
0785     unsigned long flags;
0786     unsigned int packet_size = bt->tx->packet_size;
0787 
0788     /*
0789      * save current timestamp & buffer time in time_stamp and
0790      * buf_data_equivalent_time
0791      */
0792     bt->tx->time_stamp = sched_clock();
0793     bt->tx->buf_data_equivalent_time =
0794         (unsigned long long)(bt->tx->packet_w - bt->tx->packet_r) *
0795         packet_size * 16 * 1000 / 2 / 64;
0796 
0797     /* return equivalent time(us) to data count */
0798     bt->tx->buf_data_equivalent_time *= 1000;
0799 
0800     while (count) {
0801         spin_lock_irqsave(&bt->tx_lock, flags);
0802         /* free space of TX packet buffer */
0803         avail = bt->tx->buf_size -
0804             (bt->tx->packet_w - bt->tx->packet_r) * packet_size;
0805 
0806         cur_write_idx = (bt->tx->packet_w % SCO_TX_PACKER_BUF_NUM) *
0807                 packet_size;
0808         spin_unlock_irqrestore(&bt->tx_lock, flags);
0809 
0810         if (!avail) {
0811             int ret = wait_for_bt_irq(bt, bt->tx);
0812 
0813             if (ret)
0814                 return written_size;
0815 
0816             continue;
0817         }
0818 
0819         /* count must be multiple of bt->tx->packet_size */
0820         if (count % packet_size != 0 ||
0821             avail % packet_size != 0) {
0822             dev_warn(bt->dev, "%s(), count %zu or avail %d is not multiple of packet_size %d\n",
0823                  __func__, count, avail, packet_size);
0824             count -= count % packet_size;
0825             avail -= avail % packet_size;
0826         }
0827 
0828         if (count > avail)
0829             write_size = avail;
0830         else
0831             write_size = count;
0832 
0833         /* calculate continue space */
0834         cont = bt->tx->buf_size - cur_write_idx;
0835         if (write_size > cont)
0836             write_size = cont;
0837 
0838         if (copy_from_user(bt->tx_packet_buf +
0839                    cur_write_idx,
0840                    buf + cur_buf_ofs,
0841                    write_size)) {
0842             dev_warn(bt->dev, "%s(), copy_from_user fail\n",
0843                  __func__);
0844             return -EFAULT;
0845         }
0846 
0847         spin_lock_irqsave(&bt->tx_lock, flags);
0848         bt->tx->packet_w += write_size / packet_size;
0849         spin_unlock_irqrestore(&bt->tx_lock, flags);
0850         cur_buf_ofs += write_size;
0851         count -= write_size;
0852     }
0853 
0854     return written_size;
0855 }
0856 
0857 static struct mtk_btcvsd_snd_stream *get_bt_stream
0858     (struct mtk_btcvsd_snd *bt, struct snd_pcm_substream *substream)
0859 {
0860     if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
0861         return bt->tx;
0862     else
0863         return bt->rx;
0864 }
0865 
0866 /* pcm ops */
0867 static const struct snd_pcm_hardware mtk_btcvsd_hardware = {
0868     .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
0869          SNDRV_PCM_INFO_RESUME),
0870     .formats = SNDRV_PCM_FMTBIT_S16_LE,
0871     .buffer_bytes_max = 24 * 1024,
0872     .period_bytes_max = 24 * 1024,
0873     .periods_min = 2,
0874     .periods_max = 16,
0875     .fifo_size = 0,
0876 };
0877 
0878 static int mtk_pcm_btcvsd_open(struct snd_soc_component *component,
0879                    struct snd_pcm_substream *substream)
0880 {
0881     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
0882     int ret;
0883 
0884     dev_dbg(bt->dev, "%s(), stream %d, substream %p\n",
0885         __func__, substream->stream, substream);
0886 
0887     snd_soc_set_runtime_hwparams(substream, &mtk_btcvsd_hardware);
0888 
0889     if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
0890         ret = mtk_btcvsd_snd_tx_init(bt);
0891         bt->tx->substream = substream;
0892     } else {
0893         ret = mtk_btcvsd_snd_rx_init(bt);
0894         bt->rx->substream = substream;
0895     }
0896 
0897     return ret;
0898 }
0899 
0900 static int mtk_pcm_btcvsd_close(struct snd_soc_component *component,
0901                 struct snd_pcm_substream *substream)
0902 {
0903     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
0904     struct mtk_btcvsd_snd_stream *bt_stream = get_bt_stream(bt, substream);
0905 
0906     dev_dbg(bt->dev, "%s(), stream %d\n", __func__, substream->stream);
0907 
0908     mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_IDLE);
0909     bt_stream->substream = NULL;
0910     return 0;
0911 }
0912 
0913 static int mtk_pcm_btcvsd_hw_params(struct snd_soc_component *component,
0914                     struct snd_pcm_substream *substream,
0915                     struct snd_pcm_hw_params *hw_params)
0916 {
0917     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
0918 
0919     if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
0920         params_buffer_bytes(hw_params) % bt->tx->packet_size != 0) {
0921         dev_warn(bt->dev, "%s(), error, buffer size %d not valid\n",
0922              __func__,
0923              params_buffer_bytes(hw_params));
0924         return -EINVAL;
0925     }
0926 
0927     substream->runtime->dma_bytes = params_buffer_bytes(hw_params);
0928     return 0;
0929 }
0930 
0931 static int mtk_pcm_btcvsd_hw_free(struct snd_soc_component *component,
0932                   struct snd_pcm_substream *substream)
0933 {
0934     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
0935 
0936     if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
0937         btcvsd_tx_clean_buffer(bt);
0938 
0939     return 0;
0940 }
0941 
0942 static int mtk_pcm_btcvsd_prepare(struct snd_soc_component *component,
0943                   struct snd_pcm_substream *substream)
0944 {
0945     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
0946     struct mtk_btcvsd_snd_stream *bt_stream = get_bt_stream(bt, substream);
0947 
0948     dev_dbg(bt->dev, "%s(), stream %d\n", __func__, substream->stream);
0949 
0950     mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_RUNNING);
0951     return 0;
0952 }
0953 
0954 static int mtk_pcm_btcvsd_trigger(struct snd_soc_component *component,
0955                   struct snd_pcm_substream *substream, int cmd)
0956 {
0957     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
0958     struct mtk_btcvsd_snd_stream *bt_stream = get_bt_stream(bt, substream);
0959     int stream = substream->stream;
0960     int hw_packet_ptr;
0961 
0962     dev_dbg(bt->dev, "%s(), stream %d, cmd %d\n",
0963         __func__, substream->stream, cmd);
0964 
0965     switch (cmd) {
0966     case SNDRV_PCM_TRIGGER_START:
0967     case SNDRV_PCM_TRIGGER_RESUME:
0968         hw_packet_ptr = stream == SNDRV_PCM_STREAM_PLAYBACK ?
0969                 bt_stream->packet_r : bt_stream->packet_w;
0970         bt_stream->prev_packet_idx = hw_packet_ptr;
0971         bt_stream->prev_frame = 0;
0972         bt_stream->trigger_start = 1;
0973         return 0;
0974     case SNDRV_PCM_TRIGGER_STOP:
0975     case SNDRV_PCM_TRIGGER_SUSPEND:
0976         bt_stream->trigger_start = 0;
0977         mtk_btcvsd_snd_set_state(bt, bt_stream, BT_SCO_STATE_ENDING);
0978         return 0;
0979     default:
0980         return -EINVAL;
0981     }
0982 }
0983 
0984 static snd_pcm_uframes_t mtk_pcm_btcvsd_pointer(
0985     struct snd_soc_component *component,
0986     struct snd_pcm_substream *substream)
0987 {
0988     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
0989     struct mtk_btcvsd_snd_stream *bt_stream;
0990     snd_pcm_uframes_t frame = 0;
0991     int byte = 0;
0992     int hw_packet_ptr;
0993     int packet_diff;
0994     spinlock_t *lock;   /* spinlock for bt stream control */
0995     unsigned long flags;
0996 
0997     if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
0998         lock = &bt->tx_lock;
0999         bt_stream = bt->tx;
1000     } else {
1001         lock = &bt->rx_lock;
1002         bt_stream = bt->rx;
1003     }
1004 
1005     spin_lock_irqsave(lock, flags);
1006     hw_packet_ptr = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
1007             bt->tx->packet_r : bt->rx->packet_w;
1008 
1009     /* get packet diff from last time */
1010     if (hw_packet_ptr >= bt_stream->prev_packet_idx) {
1011         packet_diff = hw_packet_ptr - bt_stream->prev_packet_idx;
1012     } else {
1013         /* integer overflow */
1014         packet_diff = (INT_MAX - bt_stream->prev_packet_idx) +
1015                   (hw_packet_ptr - INT_MIN) + 1;
1016     }
1017     bt_stream->prev_packet_idx = hw_packet_ptr;
1018 
1019     /* increased bytes */
1020     byte = packet_diff * bt_stream->packet_size;
1021 
1022     frame = btcvsd_bytes_to_frame(substream, byte);
1023     frame += bt_stream->prev_frame;
1024     frame %= substream->runtime->buffer_size;
1025 
1026     bt_stream->prev_frame = frame;
1027 
1028     spin_unlock_irqrestore(lock, flags);
1029 
1030     return frame;
1031 }
1032 
1033 static int mtk_pcm_btcvsd_copy(struct snd_soc_component *component,
1034                    struct snd_pcm_substream *substream,
1035                    int channel, unsigned long pos,
1036                    void __user *buf, unsigned long count)
1037 {
1038     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(component);
1039 
1040     if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1041         mtk_btcvsd_snd_write(bt, buf, count);
1042     else
1043         mtk_btcvsd_snd_read(bt, buf, count);
1044 
1045     return 0;
1046 }
1047 
1048 /* kcontrol */
1049 static const char *const btsco_band_str[] = {"NB", "WB"};
1050 
1051 static const struct soc_enum btcvsd_enum[] = {
1052     SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(btsco_band_str), btsco_band_str),
1053 };
1054 
1055 static int btcvsd_band_get(struct snd_kcontrol *kcontrol,
1056                struct snd_ctl_elem_value *ucontrol)
1057 {
1058     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1059     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1060 
1061     ucontrol->value.integer.value[0] = bt->band;
1062     return 0;
1063 }
1064 
1065 static int btcvsd_band_set(struct snd_kcontrol *kcontrol,
1066                struct snd_ctl_elem_value *ucontrol)
1067 {
1068     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1069     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1070     struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1071 
1072     if (ucontrol->value.enumerated.item[0] >= e->items)
1073         return -EINVAL;
1074 
1075     bt->band = ucontrol->value.integer.value[0];
1076     dev_dbg(bt->dev, "%s(), band %d\n", __func__, bt->band);
1077     return 0;
1078 }
1079 
1080 static int btcvsd_loopback_get(struct snd_kcontrol *kcontrol,
1081                    struct snd_ctl_elem_value *ucontrol)
1082 {
1083     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1084     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1085     bool lpbk_en = bt->tx->state == BT_SCO_STATE_LOOPBACK;
1086 
1087     ucontrol->value.integer.value[0] = lpbk_en;
1088     return 0;
1089 }
1090 
1091 static int btcvsd_loopback_set(struct snd_kcontrol *kcontrol,
1092                    struct snd_ctl_elem_value *ucontrol)
1093 {
1094     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1095     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1096 
1097     if (ucontrol->value.integer.value[0]) {
1098         mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_LOOPBACK);
1099         mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_LOOPBACK);
1100     } else {
1101         mtk_btcvsd_snd_set_state(bt, bt->tx, BT_SCO_STATE_RUNNING);
1102         mtk_btcvsd_snd_set_state(bt, bt->rx, BT_SCO_STATE_RUNNING);
1103     }
1104     return 0;
1105 }
1106 
1107 static int btcvsd_tx_mute_get(struct snd_kcontrol *kcontrol,
1108                   struct snd_ctl_elem_value *ucontrol)
1109 {
1110     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1111     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1112 
1113     if (!bt->tx) {
1114         ucontrol->value.integer.value[0] = 0;
1115         return 0;
1116     }
1117 
1118     ucontrol->value.integer.value[0] = bt->tx->mute;
1119     return 0;
1120 }
1121 
1122 static int btcvsd_tx_mute_set(struct snd_kcontrol *kcontrol,
1123                   struct snd_ctl_elem_value *ucontrol)
1124 {
1125     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1126     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1127 
1128     if (!bt->tx)
1129         return 0;
1130 
1131     bt->tx->mute = ucontrol->value.integer.value[0];
1132     return 0;
1133 }
1134 
1135 static int btcvsd_rx_irq_received_get(struct snd_kcontrol *kcontrol,
1136                       struct snd_ctl_elem_value *ucontrol)
1137 {
1138     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1139     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1140 
1141     if (!bt->rx)
1142         return 0;
1143 
1144     ucontrol->value.integer.value[0] = bt->rx->rw_cnt ? 1 : 0;
1145     return 0;
1146 }
1147 
1148 static int btcvsd_rx_timeout_get(struct snd_kcontrol *kcontrol,
1149                  struct snd_ctl_elem_value *ucontrol)
1150 {
1151     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1152     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1153 
1154     if (!bt->rx)
1155         return 0;
1156 
1157     ucontrol->value.integer.value[0] = bt->rx->timeout;
1158     bt->rx->timeout = 0;
1159     return 0;
1160 }
1161 
1162 static int btcvsd_rx_timestamp_get(struct snd_kcontrol *kcontrol,
1163                    unsigned int __user *data, unsigned int size)
1164 {
1165     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1166     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1167     int ret = 0;
1168     struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_rx;
1169 
1170     if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1171         return -EINVAL;
1172 
1173     get_rx_time_stamp(bt, &time_buffer_info_rx);
1174 
1175     dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1176         __func__,
1177         time_buffer_info_rx.time_stamp_us,
1178         time_buffer_info_rx.data_count_equi_time);
1179 
1180     if (copy_to_user(data, &time_buffer_info_rx,
1181              sizeof(struct mtk_btcvsd_snd_time_buffer_info))) {
1182         dev_warn(bt->dev, "%s(), copy_to_user fail", __func__);
1183         ret = -EFAULT;
1184     }
1185 
1186     return ret;
1187 }
1188 
1189 static int btcvsd_tx_irq_received_get(struct snd_kcontrol *kcontrol,
1190                       struct snd_ctl_elem_value *ucontrol)
1191 {
1192     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1193     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1194 
1195     if (!bt->tx)
1196         return 0;
1197 
1198     ucontrol->value.integer.value[0] = bt->tx->rw_cnt ? 1 : 0;
1199     return 0;
1200 }
1201 
1202 static int btcvsd_tx_timeout_get(struct snd_kcontrol *kcontrol,
1203                  struct snd_ctl_elem_value *ucontrol)
1204 {
1205     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1206     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1207 
1208     ucontrol->value.integer.value[0] = bt->tx->timeout;
1209     return 0;
1210 }
1211 
1212 static int btcvsd_tx_timestamp_get(struct snd_kcontrol *kcontrol,
1213                    unsigned int __user *data, unsigned int size)
1214 {
1215     struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
1216     struct mtk_btcvsd_snd *bt = snd_soc_component_get_drvdata(cmpnt);
1217     int ret = 0;
1218     struct mtk_btcvsd_snd_time_buffer_info time_buffer_info_tx;
1219 
1220     if (size > sizeof(struct mtk_btcvsd_snd_time_buffer_info))
1221         return -EINVAL;
1222 
1223     get_tx_time_stamp(bt, &time_buffer_info_tx);
1224 
1225     dev_dbg(bt->dev, "%s(), time_stamp_us %llu, data_count_equi_time %llu",
1226         __func__,
1227         time_buffer_info_tx.time_stamp_us,
1228         time_buffer_info_tx.data_count_equi_time);
1229 
1230     if (copy_to_user(data, &time_buffer_info_tx,
1231              sizeof(struct mtk_btcvsd_snd_time_buffer_info))) {
1232         dev_warn(bt->dev, "%s(), copy_to_user fail", __func__);
1233         ret = -EFAULT;
1234     }
1235 
1236     return ret;
1237 }
1238 
1239 static const struct snd_kcontrol_new mtk_btcvsd_snd_controls[] = {
1240     SOC_ENUM_EXT("BTCVSD Band", btcvsd_enum[0],
1241              btcvsd_band_get, btcvsd_band_set),
1242     SOC_SINGLE_BOOL_EXT("BTCVSD Loopback Switch", 0,
1243                 btcvsd_loopback_get, btcvsd_loopback_set),
1244     SOC_SINGLE_BOOL_EXT("BTCVSD Tx Mute Switch", 0,
1245                 btcvsd_tx_mute_get, btcvsd_tx_mute_set),
1246     SOC_SINGLE_BOOL_EXT("BTCVSD Tx Irq Received Switch", 0,
1247                 btcvsd_tx_irq_received_get, NULL),
1248     SOC_SINGLE_BOOL_EXT("BTCVSD Tx Timeout Switch", 0,
1249                 btcvsd_tx_timeout_get, NULL),
1250     SOC_SINGLE_BOOL_EXT("BTCVSD Rx Irq Received Switch", 0,
1251                 btcvsd_rx_irq_received_get, NULL),
1252     SOC_SINGLE_BOOL_EXT("BTCVSD Rx Timeout Switch", 0,
1253                 btcvsd_rx_timeout_get, NULL),
1254     SND_SOC_BYTES_TLV("BTCVSD Rx Timestamp",
1255               sizeof(struct mtk_btcvsd_snd_time_buffer_info),
1256               btcvsd_rx_timestamp_get, NULL),
1257     SND_SOC_BYTES_TLV("BTCVSD Tx Timestamp",
1258               sizeof(struct mtk_btcvsd_snd_time_buffer_info),
1259               btcvsd_tx_timestamp_get, NULL),
1260 };
1261 
1262 static int mtk_btcvsd_snd_component_probe(struct snd_soc_component *component)
1263 {
1264     return snd_soc_add_component_controls(component,
1265         mtk_btcvsd_snd_controls,
1266         ARRAY_SIZE(mtk_btcvsd_snd_controls));
1267 }
1268 
1269 static const struct snd_soc_component_driver mtk_btcvsd_snd_platform = {
1270     .name       = BTCVSD_SND_NAME,
1271     .probe      = mtk_btcvsd_snd_component_probe,
1272     .open       = mtk_pcm_btcvsd_open,
1273     .close      = mtk_pcm_btcvsd_close,
1274     .hw_params  = mtk_pcm_btcvsd_hw_params,
1275     .hw_free    = mtk_pcm_btcvsd_hw_free,
1276     .prepare    = mtk_pcm_btcvsd_prepare,
1277     .trigger    = mtk_pcm_btcvsd_trigger,
1278     .pointer    = mtk_pcm_btcvsd_pointer,
1279     .copy_user  = mtk_pcm_btcvsd_copy,
1280 };
1281 
1282 static int mtk_btcvsd_snd_probe(struct platform_device *pdev)
1283 {
1284     int ret;
1285     int irq_id;
1286     u32 offset[5] = {0, 0, 0, 0, 0};
1287     struct mtk_btcvsd_snd *btcvsd;
1288     struct device *dev = &pdev->dev;
1289 
1290     /* init btcvsd private data */
1291     btcvsd = devm_kzalloc(dev, sizeof(*btcvsd), GFP_KERNEL);
1292     if (!btcvsd)
1293         return -ENOMEM;
1294     platform_set_drvdata(pdev, btcvsd);
1295     btcvsd->dev = dev;
1296 
1297     /* init tx/rx */
1298     btcvsd->rx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->rx), GFP_KERNEL);
1299     if (!btcvsd->rx)
1300         return -ENOMEM;
1301 
1302     btcvsd->tx = devm_kzalloc(btcvsd->dev, sizeof(*btcvsd->tx), GFP_KERNEL);
1303     if (!btcvsd->tx)
1304         return -ENOMEM;
1305 
1306     spin_lock_init(&btcvsd->tx_lock);
1307     spin_lock_init(&btcvsd->rx_lock);
1308 
1309     init_waitqueue_head(&btcvsd->tx_wait);
1310     init_waitqueue_head(&btcvsd->rx_wait);
1311 
1312     mtk_btcvsd_snd_tx_init(btcvsd);
1313     mtk_btcvsd_snd_rx_init(btcvsd);
1314 
1315     /* irq */
1316     irq_id = platform_get_irq(pdev, 0);
1317     if (irq_id <= 0)
1318         return irq_id < 0 ? irq_id : -ENXIO;
1319 
1320     ret = devm_request_irq(dev, irq_id, mtk_btcvsd_snd_irq_handler,
1321                    IRQF_TRIGGER_LOW, "BTCVSD_ISR_Handle",
1322                    (void *)btcvsd);
1323     if (ret) {
1324         dev_err(dev, "could not request_irq for BTCVSD_ISR_Handle\n");
1325         return ret;
1326     }
1327 
1328     btcvsd->irq_id = irq_id;
1329 
1330     /* iomap */
1331     btcvsd->bt_pkv_base = of_iomap(dev->of_node, 0);
1332     if (!btcvsd->bt_pkv_base) {
1333         dev_err(dev, "iomap bt_pkv_base fail\n");
1334         return -EIO;
1335     }
1336 
1337     btcvsd->bt_sram_bank2_base = of_iomap(dev->of_node, 1);
1338     if (!btcvsd->bt_sram_bank2_base) {
1339         dev_err(dev, "iomap bt_sram_bank2_base fail\n");
1340         ret = -EIO;
1341         goto unmap_pkv_err;
1342     }
1343 
1344     btcvsd->infra = syscon_regmap_lookup_by_phandle(dev->of_node,
1345                             "mediatek,infracfg");
1346     if (IS_ERR(btcvsd->infra)) {
1347         dev_err(dev, "cannot find infra controller: %ld\n",
1348             PTR_ERR(btcvsd->infra));
1349         ret = PTR_ERR(btcvsd->infra);
1350         goto unmap_bank2_err;
1351     }
1352 
1353     /* get offset */
1354     ret = of_property_read_u32_array(dev->of_node, "mediatek,offset",
1355                      offset,
1356                      ARRAY_SIZE(offset));
1357     if (ret) {
1358         dev_warn(dev, "%s(), get offset fail, ret %d\n", __func__, ret);
1359         goto unmap_bank2_err;
1360     }
1361     btcvsd->infra_misc_offset = offset[0];
1362     btcvsd->conn_bt_cvsd_mask = offset[1];
1363     btcvsd->cvsd_mcu_read_offset = offset[2];
1364     btcvsd->cvsd_mcu_write_offset = offset[3];
1365     btcvsd->cvsd_packet_indicator = offset[4];
1366 
1367     btcvsd->bt_reg_pkt_r = btcvsd->bt_pkv_base +
1368                    btcvsd->cvsd_mcu_read_offset;
1369     btcvsd->bt_reg_pkt_w = btcvsd->bt_pkv_base +
1370                    btcvsd->cvsd_mcu_write_offset;
1371     btcvsd->bt_reg_ctl = btcvsd->bt_pkv_base +
1372                  btcvsd->cvsd_packet_indicator;
1373 
1374     /* init state */
1375     mtk_btcvsd_snd_set_state(btcvsd, btcvsd->tx, BT_SCO_STATE_IDLE);
1376     mtk_btcvsd_snd_set_state(btcvsd, btcvsd->rx, BT_SCO_STATE_IDLE);
1377 
1378     ret = devm_snd_soc_register_component(dev, &mtk_btcvsd_snd_platform,
1379                           NULL, 0);
1380     if (ret)
1381         goto unmap_bank2_err;
1382 
1383     return 0;
1384 
1385 unmap_bank2_err:
1386     iounmap(btcvsd->bt_sram_bank2_base);
1387 unmap_pkv_err:
1388     iounmap(btcvsd->bt_pkv_base);
1389     return ret;
1390 }
1391 
1392 static int mtk_btcvsd_snd_remove(struct platform_device *pdev)
1393 {
1394     struct mtk_btcvsd_snd *btcvsd = dev_get_drvdata(&pdev->dev);
1395 
1396     iounmap(btcvsd->bt_pkv_base);
1397     iounmap(btcvsd->bt_sram_bank2_base);
1398     return 0;
1399 }
1400 
1401 static const struct of_device_id mtk_btcvsd_snd_dt_match[] = {
1402     { .compatible = "mediatek,mtk-btcvsd-snd", },
1403     {},
1404 };
1405 MODULE_DEVICE_TABLE(of, mtk_btcvsd_snd_dt_match);
1406 
1407 static struct platform_driver mtk_btcvsd_snd_driver = {
1408     .driver = {
1409         .name = "mtk-btcvsd-snd",
1410         .of_match_table = mtk_btcvsd_snd_dt_match,
1411     },
1412     .probe = mtk_btcvsd_snd_probe,
1413     .remove = mtk_btcvsd_snd_remove,
1414 };
1415 
1416 module_platform_driver(mtk_btcvsd_snd_driver);
1417 
1418 MODULE_DESCRIPTION("Mediatek ALSA BT SCO CVSD/MSBC Driver");
1419 MODULE_AUTHOR("KaiChieh Chuang <kaichieh.chuang@mediatek.com>");
1420 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!