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