1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * mtk-afe-fe-dais.c -- Mediatek afe fe dai operator 4 * 5 * Copyright (c) 2016 MediaTek Inc. 6 * Author: Garlic Tseng <garlic.tseng@mediatek.com> 7 */ 8 9 #include <linux/io.h> 10 #include <linux/module.h> 11 #include <linux/pm_runtime.h> 12 #include <linux/regmap.h> 13 #include <sound/soc.h> 14 #include "mtk-afe-platform-driver.h" 15 #include <sound/pcm_params.h> 16 #include "mtk-afe-fe-dai.h" 17 #include "mtk-base-afe.h" 18 19 #define AFE_BASE_END_OFFSET 8 20 21 static int mtk_regmap_update_bits(struct regmap *map, int reg, 22 unsigned int mask, 23 unsigned int val, int shift) 24 { 25 if (reg < 0 || WARN_ON_ONCE(shift < 0)) 26 return 0; 27 return regmap_update_bits(map, reg, mask << shift, val << shift); 28 } 29 30 static int mtk_regmap_write(struct regmap *map, int reg, unsigned int val) 31 { 32 if (reg < 0) 33 return 0; 34 return regmap_write(map, reg, val); 35 } 36 37 int mtk_afe_fe_startup(struct snd_pcm_substream *substream, 38 struct snd_soc_dai *dai) 39 { 40 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 41 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 42 struct snd_pcm_runtime *runtime = substream->runtime; 43 int memif_num = asoc_rtd_to_cpu(rtd, 0)->id; 44 struct mtk_base_afe_memif *memif = &afe->memif[memif_num]; 45 const struct snd_pcm_hardware *mtk_afe_hardware = afe->mtk_afe_hardware; 46 int ret; 47 48 memif->substream = substream; 49 50 snd_pcm_hw_constraint_step(substream->runtime, 0, 51 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16); 52 /* enable agent */ 53 mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg, 54 1, 0, memif->data->agent_disable_shift); 55 56 snd_soc_set_runtime_hwparams(substream, mtk_afe_hardware); 57 58 /* 59 * Capture cannot use ping-pong buffer since hw_ptr at IRQ may be 60 * smaller than period_size due to AFE's internal buffer. 61 * This easily leads to overrun when avail_min is period_size. 62 * One more period can hold the possible unread buffer. 63 */ 64 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { 65 int periods_max = mtk_afe_hardware->periods_max; 66 67 ret = snd_pcm_hw_constraint_minmax(runtime, 68 SNDRV_PCM_HW_PARAM_PERIODS, 69 3, periods_max); 70 if (ret < 0) { 71 dev_err(afe->dev, "hw_constraint_minmax failed\n"); 72 return ret; 73 } 74 } 75 76 ret = snd_pcm_hw_constraint_integer(runtime, 77 SNDRV_PCM_HW_PARAM_PERIODS); 78 if (ret < 0) 79 dev_err(afe->dev, "snd_pcm_hw_constraint_integer failed\n"); 80 81 /* dynamic allocate irq to memif */ 82 if (memif->irq_usage < 0) { 83 int irq_id = mtk_dynamic_irq_acquire(afe); 84 85 if (irq_id != afe->irqs_size) { 86 /* link */ 87 memif->irq_usage = irq_id; 88 } else { 89 dev_err(afe->dev, "%s() error: no more asys irq\n", 90 __func__); 91 ret = -EBUSY; 92 } 93 } 94 return ret; 95 } 96 EXPORT_SYMBOL_GPL(mtk_afe_fe_startup); 97 98 void mtk_afe_fe_shutdown(struct snd_pcm_substream *substream, 99 struct snd_soc_dai *dai) 100 { 101 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 102 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 103 struct mtk_base_afe_memif *memif = &afe->memif[asoc_rtd_to_cpu(rtd, 0)->id]; 104 int irq_id; 105 106 irq_id = memif->irq_usage; 107 108 mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg, 109 1, 1, memif->data->agent_disable_shift); 110 111 if (!memif->const_irq) { 112 mtk_dynamic_irq_release(afe, irq_id); 113 memif->irq_usage = -1; 114 memif->substream = NULL; 115 } 116 } 117 EXPORT_SYMBOL_GPL(mtk_afe_fe_shutdown); 118 119 int mtk_afe_fe_hw_params(struct snd_pcm_substream *substream, 120 struct snd_pcm_hw_params *params, 121 struct snd_soc_dai *dai) 122 { 123 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 124 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 125 int id = asoc_rtd_to_cpu(rtd, 0)->id; 126 struct mtk_base_afe_memif *memif = &afe->memif[id]; 127 int ret; 128 unsigned int channels = params_channels(params); 129 unsigned int rate = params_rate(params); 130 snd_pcm_format_t format = params_format(params); 131 132 if (afe->request_dram_resource) 133 afe->request_dram_resource(afe->dev); 134 135 dev_dbg(afe->dev, "%s(), %s, ch %d, rate %d, fmt %d, dma_addr %pad, dma_area %p, dma_bytes 0x%zx\n", 136 __func__, memif->data->name, 137 channels, rate, format, 138 &substream->runtime->dma_addr, 139 substream->runtime->dma_area, 140 substream->runtime->dma_bytes); 141 142 memset_io((void __force __iomem *)substream->runtime->dma_area, 0, 143 substream->runtime->dma_bytes); 144 145 /* set addr */ 146 ret = mtk_memif_set_addr(afe, id, 147 substream->runtime->dma_area, 148 substream->runtime->dma_addr, 149 substream->runtime->dma_bytes); 150 if (ret) { 151 dev_err(afe->dev, "%s(), error, id %d, set addr, ret %d\n", 152 __func__, id, ret); 153 return ret; 154 } 155 156 /* set channel */ 157 ret = mtk_memif_set_channel(afe, id, channels); 158 if (ret) { 159 dev_err(afe->dev, "%s(), error, id %d, set channel %d, ret %d\n", 160 __func__, id, channels, ret); 161 return ret; 162 } 163 164 /* set rate */ 165 ret = mtk_memif_set_rate_substream(substream, id, rate); 166 if (ret) { 167 dev_err(afe->dev, "%s(), error, id %d, set rate %d, ret %d\n", 168 __func__, id, rate, ret); 169 return ret; 170 } 171 172 /* set format */ 173 ret = mtk_memif_set_format(afe, id, format); 174 if (ret) { 175 dev_err(afe->dev, "%s(), error, id %d, set format %d, ret %d\n", 176 __func__, id, format, ret); 177 return ret; 178 } 179 180 return 0; 181 } 182 EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_params); 183 184 int mtk_afe_fe_hw_free(struct snd_pcm_substream *substream, 185 struct snd_soc_dai *dai) 186 { 187 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 188 189 if (afe->release_dram_resource) 190 afe->release_dram_resource(afe->dev); 191 192 return 0; 193 } 194 EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_free); 195 196 int mtk_afe_fe_trigger(struct snd_pcm_substream *substream, int cmd, 197 struct snd_soc_dai *dai) 198 { 199 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 200 struct snd_pcm_runtime * const runtime = substream->runtime; 201 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 202 int id = asoc_rtd_to_cpu(rtd, 0)->id; 203 struct mtk_base_afe_memif *memif = &afe->memif[id]; 204 struct mtk_base_afe_irq *irqs = &afe->irqs[memif->irq_usage]; 205 const struct mtk_base_irq_data *irq_data = irqs->irq_data; 206 unsigned int counter = runtime->period_size; 207 int fs; 208 int ret; 209 210 dev_dbg(afe->dev, "%s %s cmd=%d\n", __func__, memif->data->name, cmd); 211 212 switch (cmd) { 213 case SNDRV_PCM_TRIGGER_START: 214 case SNDRV_PCM_TRIGGER_RESUME: 215 ret = mtk_memif_set_enable(afe, id); 216 if (ret) { 217 dev_err(afe->dev, "%s(), error, id %d, memif enable, ret %d\n", 218 __func__, id, ret); 219 return ret; 220 } 221 222 /* set irq counter */ 223 mtk_regmap_update_bits(afe->regmap, irq_data->irq_cnt_reg, 224 irq_data->irq_cnt_maskbit, counter, 225 irq_data->irq_cnt_shift); 226 227 /* set irq fs */ 228 fs = afe->irq_fs(substream, runtime->rate); 229 230 if (fs < 0) 231 return -EINVAL; 232 233 mtk_regmap_update_bits(afe->regmap, irq_data->irq_fs_reg, 234 irq_data->irq_fs_maskbit, fs, 235 irq_data->irq_fs_shift); 236 237 /* enable interrupt */ 238 mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg, 239 1, 1, irq_data->irq_en_shift); 240 241 return 0; 242 case SNDRV_PCM_TRIGGER_STOP: 243 case SNDRV_PCM_TRIGGER_SUSPEND: 244 ret = mtk_memif_set_disable(afe, id); 245 if (ret) { 246 dev_err(afe->dev, "%s(), error, id %d, memif enable, ret %d\n", 247 __func__, id, ret); 248 } 249 250 /* disable interrupt */ 251 mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg, 252 1, 0, irq_data->irq_en_shift); 253 /* and clear pending IRQ */ 254 mtk_regmap_write(afe->regmap, irq_data->irq_clr_reg, 255 1 << irq_data->irq_clr_shift); 256 return ret; 257 default: 258 return -EINVAL; 259 } 260 } 261 EXPORT_SYMBOL_GPL(mtk_afe_fe_trigger); 262 263 int mtk_afe_fe_prepare(struct snd_pcm_substream *substream, 264 struct snd_soc_dai *dai) 265 { 266 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 267 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai); 268 int id = asoc_rtd_to_cpu(rtd, 0)->id; 269 int pbuf_size; 270 271 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 272 if (afe->get_memif_pbuf_size) { 273 pbuf_size = afe->get_memif_pbuf_size(substream); 274 mtk_memif_set_pbuf_size(afe, id, pbuf_size); 275 } 276 } 277 return 0; 278 } 279 EXPORT_SYMBOL_GPL(mtk_afe_fe_prepare); 280 281 const struct snd_soc_dai_ops mtk_afe_fe_ops = { 282 .startup = mtk_afe_fe_startup, 283 .shutdown = mtk_afe_fe_shutdown, 284 .hw_params = mtk_afe_fe_hw_params, 285 .hw_free = mtk_afe_fe_hw_free, 286 .prepare = mtk_afe_fe_prepare, 287 .trigger = mtk_afe_fe_trigger, 288 }; 289 EXPORT_SYMBOL_GPL(mtk_afe_fe_ops); 290 291 static DEFINE_MUTEX(irqs_lock); 292 int mtk_dynamic_irq_acquire(struct mtk_base_afe *afe) 293 { 294 int i; 295 296 mutex_lock(&afe->irq_alloc_lock); 297 for (i = 0; i < afe->irqs_size; ++i) { 298 if (afe->irqs[i].irq_occupyed == 0) { 299 afe->irqs[i].irq_occupyed = 1; 300 mutex_unlock(&afe->irq_alloc_lock); 301 return i; 302 } 303 } 304 mutex_unlock(&afe->irq_alloc_lock); 305 return afe->irqs_size; 306 } 307 EXPORT_SYMBOL_GPL(mtk_dynamic_irq_acquire); 308 309 int mtk_dynamic_irq_release(struct mtk_base_afe *afe, int irq_id) 310 { 311 mutex_lock(&afe->irq_alloc_lock); 312 if (irq_id >= 0 && irq_id < afe->irqs_size) { 313 afe->irqs[irq_id].irq_occupyed = 0; 314 mutex_unlock(&afe->irq_alloc_lock); 315 return 0; 316 } 317 mutex_unlock(&afe->irq_alloc_lock); 318 return -EINVAL; 319 } 320 EXPORT_SYMBOL_GPL(mtk_dynamic_irq_release); 321 322 int mtk_afe_suspend(struct snd_soc_component *component) 323 { 324 struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component); 325 struct device *dev = afe->dev; 326 struct regmap *regmap = afe->regmap; 327 int i; 328 329 if (pm_runtime_status_suspended(dev) || afe->suspended) 330 return 0; 331 332 if (!afe->reg_back_up) 333 afe->reg_back_up = 334 devm_kcalloc(dev, afe->reg_back_up_list_num, 335 sizeof(unsigned int), GFP_KERNEL); 336 337 if (afe->reg_back_up) { 338 for (i = 0; i < afe->reg_back_up_list_num; i++) 339 regmap_read(regmap, afe->reg_back_up_list[i], 340 &afe->reg_back_up[i]); 341 } 342 343 afe->suspended = true; 344 afe->runtime_suspend(dev); 345 return 0; 346 } 347 EXPORT_SYMBOL_GPL(mtk_afe_suspend); 348 349 int mtk_afe_resume(struct snd_soc_component *component) 350 { 351 struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component); 352 struct device *dev = afe->dev; 353 struct regmap *regmap = afe->regmap; 354 int i = 0; 355 356 if (pm_runtime_status_suspended(dev) || !afe->suspended) 357 return 0; 358 359 afe->runtime_resume(dev); 360 361 if (!afe->reg_back_up) { 362 dev_dbg(dev, "%s no reg_backup\n", __func__); 363 } else { 364 for (i = 0; i < afe->reg_back_up_list_num; i++) 365 mtk_regmap_write(regmap, afe->reg_back_up_list[i], 366 afe->reg_back_up[i]); 367 } 368 369 afe->suspended = false; 370 return 0; 371 } 372 EXPORT_SYMBOL_GPL(mtk_afe_resume); 373 374 int mtk_memif_set_enable(struct mtk_base_afe *afe, int id) 375 { 376 struct mtk_base_afe_memif *memif = &afe->memif[id]; 377 378 if (memif->data->enable_shift < 0) { 379 dev_warn(afe->dev, "%s(), error, id %d, enable_shift < 0\n", 380 __func__, id); 381 return 0; 382 } 383 return mtk_regmap_update_bits(afe->regmap, memif->data->enable_reg, 384 1, 1, memif->data->enable_shift); 385 } 386 EXPORT_SYMBOL_GPL(mtk_memif_set_enable); 387 388 int mtk_memif_set_disable(struct mtk_base_afe *afe, int id) 389 { 390 struct mtk_base_afe_memif *memif = &afe->memif[id]; 391 392 if (memif->data->enable_shift < 0) { 393 dev_warn(afe->dev, "%s(), error, id %d, enable_shift < 0\n", 394 __func__, id); 395 return 0; 396 } 397 return mtk_regmap_update_bits(afe->regmap, memif->data->enable_reg, 398 1, 0, memif->data->enable_shift); 399 } 400 EXPORT_SYMBOL_GPL(mtk_memif_set_disable); 401 402 int mtk_memif_set_addr(struct mtk_base_afe *afe, int id, 403 unsigned char *dma_area, 404 dma_addr_t dma_addr, 405 size_t dma_bytes) 406 { 407 struct mtk_base_afe_memif *memif = &afe->memif[id]; 408 int msb_at_bit33 = upper_32_bits(dma_addr) ? 1 : 0; 409 unsigned int phys_buf_addr = lower_32_bits(dma_addr); 410 unsigned int phys_buf_addr_upper_32 = upper_32_bits(dma_addr); 411 412 memif->dma_area = dma_area; 413 memif->dma_addr = dma_addr; 414 memif->dma_bytes = dma_bytes; 415 416 /* start */ 417 mtk_regmap_write(afe->regmap, memif->data->reg_ofs_base, 418 phys_buf_addr); 419 /* end */ 420 if (memif->data->reg_ofs_end) 421 mtk_regmap_write(afe->regmap, 422 memif->data->reg_ofs_end, 423 phys_buf_addr + dma_bytes - 1); 424 else 425 mtk_regmap_write(afe->regmap, 426 memif->data->reg_ofs_base + 427 AFE_BASE_END_OFFSET, 428 phys_buf_addr + dma_bytes - 1); 429 430 /* set start, end, upper 32 bits */ 431 if (memif->data->reg_ofs_base_msb) { 432 mtk_regmap_write(afe->regmap, memif->data->reg_ofs_base_msb, 433 phys_buf_addr_upper_32); 434 mtk_regmap_write(afe->regmap, 435 memif->data->reg_ofs_end_msb, 436 phys_buf_addr_upper_32); 437 } 438 439 /* 440 * set MSB to 33-bit, for memif address 441 * only for memif base address, if msb_end_reg exists 442 */ 443 if (memif->data->msb_reg) 444 mtk_regmap_update_bits(afe->regmap, memif->data->msb_reg, 445 1, msb_at_bit33, memif->data->msb_shift); 446 447 /* set MSB to 33-bit, for memif end address */ 448 if (memif->data->msb_end_reg) 449 mtk_regmap_update_bits(afe->regmap, memif->data->msb_end_reg, 450 1, msb_at_bit33, 451 memif->data->msb_end_shift); 452 453 return 0; 454 } 455 EXPORT_SYMBOL_GPL(mtk_memif_set_addr); 456 457 int mtk_memif_set_channel(struct mtk_base_afe *afe, 458 int id, unsigned int channel) 459 { 460 struct mtk_base_afe_memif *memif = &afe->memif[id]; 461 unsigned int mono; 462 463 if (memif->data->mono_shift < 0) 464 return 0; 465 466 if (memif->data->quad_ch_mask) { 467 unsigned int quad_ch = (channel == 4) ? 1 : 0; 468 469 mtk_regmap_update_bits(afe->regmap, memif->data->quad_ch_reg, 470 memif->data->quad_ch_mask, 471 quad_ch, memif->data->quad_ch_shift); 472 } 473 474 if (memif->data->mono_invert) 475 mono = (channel == 1) ? 0 : 1; 476 else 477 mono = (channel == 1) ? 1 : 0; 478 479 /* for specific configuration of memif mono mode */ 480 if (memif->data->int_odd_flag_reg) 481 mtk_regmap_update_bits(afe->regmap, 482 memif->data->int_odd_flag_reg, 483 1, mono, 484 memif->data->int_odd_flag_shift); 485 486 return mtk_regmap_update_bits(afe->regmap, memif->data->mono_reg, 487 1, mono, memif->data->mono_shift); 488 } 489 EXPORT_SYMBOL_GPL(mtk_memif_set_channel); 490 491 static int mtk_memif_set_rate_fs(struct mtk_base_afe *afe, 492 int id, int fs) 493 { 494 struct mtk_base_afe_memif *memif = &afe->memif[id]; 495 496 if (memif->data->fs_shift >= 0) 497 mtk_regmap_update_bits(afe->regmap, memif->data->fs_reg, 498 memif->data->fs_maskbit, 499 fs, memif->data->fs_shift); 500 501 return 0; 502 } 503 504 int mtk_memif_set_rate(struct mtk_base_afe *afe, 505 int id, unsigned int rate) 506 { 507 int fs = 0; 508 509 if (!afe->get_dai_fs) { 510 dev_err(afe->dev, "%s(), error, afe->get_dai_fs == NULL\n", 511 __func__); 512 return -EINVAL; 513 } 514 515 fs = afe->get_dai_fs(afe, id, rate); 516 517 if (fs < 0) 518 return -EINVAL; 519 520 return mtk_memif_set_rate_fs(afe, id, fs); 521 } 522 EXPORT_SYMBOL_GPL(mtk_memif_set_rate); 523 524 int mtk_memif_set_rate_substream(struct snd_pcm_substream *substream, 525 int id, unsigned int rate) 526 { 527 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 528 struct snd_soc_component *component = 529 snd_soc_rtdcom_lookup(rtd, AFE_PCM_NAME); 530 struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component); 531 532 int fs = 0; 533 534 if (!afe->memif_fs) { 535 dev_err(afe->dev, "%s(), error, afe->memif_fs == NULL\n", 536 __func__); 537 return -EINVAL; 538 } 539 540 fs = afe->memif_fs(substream, rate); 541 542 if (fs < 0) 543 return -EINVAL; 544 545 return mtk_memif_set_rate_fs(afe, id, fs); 546 } 547 EXPORT_SYMBOL_GPL(mtk_memif_set_rate_substream); 548 549 int mtk_memif_set_format(struct mtk_base_afe *afe, 550 int id, snd_pcm_format_t format) 551 { 552 struct mtk_base_afe_memif *memif = &afe->memif[id]; 553 int hd_audio = 0; 554 int hd_align = 0; 555 556 /* set hd mode */ 557 switch (format) { 558 case SNDRV_PCM_FORMAT_S16_LE: 559 case SNDRV_PCM_FORMAT_U16_LE: 560 hd_audio = 0; 561 break; 562 case SNDRV_PCM_FORMAT_S32_LE: 563 case SNDRV_PCM_FORMAT_U32_LE: 564 if (afe->memif_32bit_supported) { 565 hd_audio = 2; 566 hd_align = 0; 567 } else { 568 hd_audio = 1; 569 hd_align = 1; 570 } 571 break; 572 case SNDRV_PCM_FORMAT_S24_LE: 573 case SNDRV_PCM_FORMAT_U24_LE: 574 hd_audio = 1; 575 break; 576 default: 577 dev_err(afe->dev, "%s() error: unsupported format %d\n", 578 __func__, format); 579 break; 580 } 581 582 mtk_regmap_update_bits(afe->regmap, memif->data->hd_reg, 583 0x3, hd_audio, memif->data->hd_shift); 584 585 mtk_regmap_update_bits(afe->regmap, memif->data->hd_align_reg, 586 0x1, hd_align, memif->data->hd_align_mshift); 587 588 return 0; 589 } 590 EXPORT_SYMBOL_GPL(mtk_memif_set_format); 591 592 int mtk_memif_set_pbuf_size(struct mtk_base_afe *afe, 593 int id, int pbuf_size) 594 { 595 const struct mtk_base_memif_data *memif_data = afe->memif[id].data; 596 597 if (memif_data->pbuf_mask == 0 || memif_data->minlen_mask == 0) 598 return 0; 599 600 mtk_regmap_update_bits(afe->regmap, memif_data->pbuf_reg, 601 memif_data->pbuf_mask, 602 pbuf_size, memif_data->pbuf_shift); 603 604 mtk_regmap_update_bits(afe->regmap, memif_data->minlen_reg, 605 memif_data->minlen_mask, 606 pbuf_size, memif_data->minlen_shift); 607 return 0; 608 } 609 EXPORT_SYMBOL_GPL(mtk_memif_set_pbuf_size); 610 611 MODULE_DESCRIPTION("Mediatek simple fe dai operator"); 612 MODULE_AUTHOR("Garlic Tseng <garlic.tseng@mediatek.com>"); 613 MODULE_LICENSE("GPL v2"); 614