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