1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * ALSA SoC Audio Layer - Rockchip SAI Controller driver 4 * 5 * Copyright (c) 2022 Rockchip Electronics Co. Ltd. 6 * Copyright (c) 2025 Collabora Ltd. 7 */ 8 9 #include <linux/module.h> 10 #include <linux/mfd/syscon.h> 11 #include <linux/delay.h> 12 #include <linux/of_device.h> 13 #include <linux/clk.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/regmap.h> 16 #include <linux/reset.h> 17 #include <linux/spinlock.h> 18 #include <sound/pcm_params.h> 19 #include <sound/dmaengine_pcm.h> 20 #include <sound/tlv.h> 21 #include "rockchip_sai.h" 22 23 #define DRV_NAME "rockchip-sai" 24 25 #define CLK_SHIFT_RATE_HZ_MAX 5 26 #define FW_RATIO_MAX 8 27 #define FW_RATIO_MIN 1 28 #define MAXBURST_PER_FIFO 8 29 30 #define TIMEOUT_US 1000 31 #define WAIT_TIME_MS_MAX 10000 32 33 #define MAX_LANES 4 34 35 enum fpw_mode { 36 FPW_ONE_BCLK_WIDTH, 37 FPW_ONE_SLOT_WIDTH, 38 FPW_HALF_FRAME_WIDTH, 39 }; 40 41 struct rk_sai_dev { 42 struct device *dev; 43 struct clk *hclk; 44 struct clk *mclk; 45 struct regmap *regmap; 46 struct reset_control *rst_h; 47 struct reset_control *rst_m; 48 struct snd_dmaengine_dai_dma_data capture_dma_data; 49 struct snd_dmaengine_dai_dma_data playback_dma_data; 50 struct snd_pcm_substream *substreams[SNDRV_PCM_STREAM_LAST + 1]; 51 unsigned int mclk_rate; 52 unsigned int wait_time[SNDRV_PCM_STREAM_LAST + 1]; 53 unsigned int tx_lanes; 54 unsigned int rx_lanes; 55 unsigned int sdi[MAX_LANES]; 56 unsigned int sdo[MAX_LANES]; 57 unsigned int version; 58 enum fpw_mode fpw; 59 int fw_ratio; 60 bool has_capture; 61 bool has_playback; 62 bool is_master_mode; 63 bool is_tdm; 64 bool initialized; 65 /* protects register writes that depend on the state of XFER[1:0] */ 66 spinlock_t xfer_lock; 67 }; 68 69 static bool rockchip_sai_stream_valid(struct snd_pcm_substream *substream, 70 struct snd_soc_dai *dai) 71 { 72 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 73 74 if (!substream) 75 return false; 76 77 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 78 sai->has_playback) 79 return true; 80 81 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE && 82 sai->has_capture) 83 return true; 84 85 return false; 86 } 87 88 static int rockchip_sai_fsync_lost_detect(struct rk_sai_dev *sai, bool en) 89 { 90 unsigned int fw, cnt; 91 92 if (sai->is_master_mode || sai->version < SAI_VER_2311) 93 return 0; 94 95 regmap_read(sai->regmap, SAI_FSCR, &fw); 96 cnt = SAI_FSCR_FW_V(fw) << 1; /* two fsync lost */ 97 98 regmap_update_bits(sai->regmap, SAI_INTCR, 99 SAI_INTCR_FSLOSTC, SAI_INTCR_FSLOSTC); 100 regmap_update_bits(sai->regmap, SAI_INTCR, 101 SAI_INTCR_FSLOST_MASK, 102 SAI_INTCR_FSLOST(en)); 103 /* 104 * The `cnt` is the number of SCLK cycles of the CRU's SCLK signal that 105 * should be used as timeout. Consequently, in slave mode, this value 106 * is only correct if the CRU SCLK is equal to the external SCLK. 107 */ 108 regmap_update_bits(sai->regmap, SAI_FS_TIMEOUT, 109 SAI_FS_TIMEOUT_VAL_MASK | SAI_FS_TIMEOUT_EN_MASK, 110 SAI_FS_TIMEOUT_VAL(cnt) | SAI_FS_TIMEOUT_EN(en)); 111 112 return 0; 113 } 114 115 static int rockchip_sai_fsync_err_detect(struct rk_sai_dev *sai, 116 bool en) 117 { 118 if (sai->is_master_mode || sai->version < SAI_VER_2311) 119 return 0; 120 121 regmap_update_bits(sai->regmap, SAI_INTCR, 122 SAI_INTCR_FSERRC, SAI_INTCR_FSERRC); 123 regmap_update_bits(sai->regmap, SAI_INTCR, 124 SAI_INTCR_FSERR_MASK, 125 SAI_INTCR_FSERR(en)); 126 127 return 0; 128 } 129 130 static int rockchip_sai_poll_clk_idle(struct rk_sai_dev *sai) 131 { 132 unsigned int reg, idle, val; 133 int ret; 134 135 if (sai->version >= SAI_VER_2307) { 136 reg = SAI_STATUS; 137 idle = SAI_STATUS_FS_IDLE; 138 idle = sai->version >= SAI_VER_2311 ? idle >> 1 : idle; 139 } else { 140 reg = SAI_XFER; 141 idle = SAI_XFER_FS_IDLE; 142 } 143 144 ret = regmap_read_poll_timeout_atomic(sai->regmap, reg, val, 145 (val & idle), 10, TIMEOUT_US); 146 if (ret < 0) 147 dev_warn(sai->dev, "Failed to idle FS\n"); 148 149 return ret; 150 } 151 152 static int rockchip_sai_poll_stream_idle(struct rk_sai_dev *sai, bool playback, bool capture) 153 { 154 unsigned int reg, val; 155 unsigned int idle = 0; 156 int ret; 157 158 if (sai->version >= SAI_VER_2307) { 159 reg = SAI_STATUS; 160 if (playback) 161 idle |= SAI_STATUS_TX_IDLE; 162 if (capture) 163 idle |= SAI_STATUS_RX_IDLE; 164 idle = sai->version >= SAI_VER_2311 ? idle >> 1 : idle; 165 } else { 166 reg = SAI_XFER; 167 if (playback) 168 idle |= SAI_XFER_TX_IDLE; 169 if (capture) 170 idle |= SAI_XFER_RX_IDLE; 171 } 172 173 ret = regmap_read_poll_timeout_atomic(sai->regmap, reg, val, 174 (val & idle), 10, TIMEOUT_US); 175 if (ret < 0) 176 dev_warn(sai->dev, "Failed to idle stream\n"); 177 178 return ret; 179 } 180 181 /** 182 * rockchip_sai_xfer_clk_stop_and_wait() - stop the xfer clock and wait for it to be idle 183 * @sai: pointer to the driver instance's rk_sai_dev struct 184 * @to_restore: pointer to store the CLK/FSS register values in as they were 185 * found before they were cleared, or NULL. 186 * 187 * Clear the XFER_CLK and XFER_FSS registers if needed, then busy-waits for the 188 * XFER clocks to be idle. Before clearing the bits, it stores the state of the 189 * registers as it encountered them in to_restore if it isn't NULL. 190 * 191 * Context: Any context. Expects sai->xfer_lock to be held by caller. 192 */ 193 static void rockchip_sai_xfer_clk_stop_and_wait(struct rk_sai_dev *sai, unsigned int *to_restore) 194 { 195 unsigned int mask = SAI_XFER_CLK_MASK | SAI_XFER_FSS_MASK; 196 unsigned int disable = SAI_XFER_CLK_DIS | SAI_XFER_FSS_DIS; 197 unsigned int val; 198 199 assert_spin_locked(&sai->xfer_lock); 200 201 regmap_read(sai->regmap, SAI_XFER, &val); 202 if ((val & mask) == disable) 203 goto wait_for_idle; 204 205 if (sai->is_master_mode) 206 regmap_update_bits(sai->regmap, SAI_XFER, mask, disable); 207 208 wait_for_idle: 209 rockchip_sai_poll_clk_idle(sai); 210 211 if (to_restore) 212 *to_restore = val; 213 } 214 215 static int rockchip_sai_runtime_suspend(struct device *dev) 216 { 217 struct rk_sai_dev *sai = dev_get_drvdata(dev); 218 219 rockchip_sai_fsync_lost_detect(sai, 0); 220 rockchip_sai_fsync_err_detect(sai, 0); 221 222 scoped_guard(spinlock_irqsave, &sai->xfer_lock) 223 rockchip_sai_xfer_clk_stop_and_wait(sai, NULL); 224 225 regcache_cache_only(sai->regmap, true); 226 /* 227 * After FS is idle, we should wait at least 2 BCLK cycles to make sure 228 * the CLK gate operation has completed, and only then disable mclk. 229 * 230 * Otherwise, the BCLK is still ungated, and once the mclk is enabled, 231 * there is a risk that a few BCLK cycles leak. This is true especially 232 * at low speeds, such as with a samplerate of 8k. 233 * 234 * Ideally we'd adjust the delay based on the samplerate, but it's such 235 * a tiny value that we can just delay for the maximum clock period 236 * for the sake of simplicity. 237 * 238 * The maximum BCLK period is 31us @ 8K-8Bit (64kHz BCLK). We wait for 239 * 40us to give ourselves a safety margin in case udelay falls short. 240 */ 241 udelay(40); 242 clk_disable_unprepare(sai->mclk); 243 clk_disable_unprepare(sai->hclk); 244 245 return 0; 246 } 247 248 static int rockchip_sai_runtime_resume(struct device *dev) 249 { 250 struct rk_sai_dev *sai = dev_get_drvdata(dev); 251 int ret; 252 253 ret = clk_prepare_enable(sai->hclk); 254 if (ret) 255 goto err_hclk; 256 257 ret = clk_prepare_enable(sai->mclk); 258 if (ret) 259 goto err_mclk; 260 261 regcache_cache_only(sai->regmap, false); 262 regcache_mark_dirty(sai->regmap); 263 ret = regcache_sync(sai->regmap); 264 if (ret) 265 goto err_regmap; 266 267 return 0; 268 269 err_regmap: 270 clk_disable_unprepare(sai->mclk); 271 err_mclk: 272 clk_disable_unprepare(sai->hclk); 273 err_hclk: 274 return ret; 275 } 276 277 static void rockchip_sai_fifo_xrun_detect(struct rk_sai_dev *sai, 278 int stream, bool en) 279 { 280 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 281 /* clear irq status which was asserted before TXUIE enabled */ 282 regmap_update_bits(sai->regmap, SAI_INTCR, 283 SAI_INTCR_TXUIC, SAI_INTCR_TXUIC); 284 regmap_update_bits(sai->regmap, SAI_INTCR, 285 SAI_INTCR_TXUIE_MASK, 286 SAI_INTCR_TXUIE(en)); 287 } else { 288 /* clear irq status which was asserted before RXOIE enabled */ 289 regmap_update_bits(sai->regmap, SAI_INTCR, 290 SAI_INTCR_RXOIC, SAI_INTCR_RXOIC); 291 regmap_update_bits(sai->regmap, SAI_INTCR, 292 SAI_INTCR_RXOIE_MASK, 293 SAI_INTCR_RXOIE(en)); 294 } 295 } 296 297 static void rockchip_sai_dma_ctrl(struct rk_sai_dev *sai, 298 int stream, bool en) 299 { 300 if (!en) 301 rockchip_sai_fifo_xrun_detect(sai, stream, 0); 302 303 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 304 regmap_update_bits(sai->regmap, SAI_DMACR, 305 SAI_DMACR_TDE_MASK, 306 SAI_DMACR_TDE(en)); 307 } else { 308 regmap_update_bits(sai->regmap, SAI_DMACR, 309 SAI_DMACR_RDE_MASK, 310 SAI_DMACR_RDE(en)); 311 } 312 313 if (en) 314 rockchip_sai_fifo_xrun_detect(sai, stream, 1); 315 } 316 317 static void rockchip_sai_reset(struct rk_sai_dev *sai) 318 { 319 /* 320 * It is advised to reset the hclk domain before resetting the mclk 321 * domain, especially in slave mode without a clock input. 322 * 323 * To deal with the aforementioned case of slave mode without a clock 324 * input, we work around a potential issue by resetting the whole 325 * controller, bringing it back into master mode, and then recovering 326 * the controller configuration in the regmap. 327 */ 328 reset_control_assert(sai->rst_h); 329 udelay(10); 330 reset_control_deassert(sai->rst_h); 331 udelay(10); 332 reset_control_assert(sai->rst_m); 333 udelay(10); 334 reset_control_deassert(sai->rst_m); 335 udelay(10); 336 337 /* recover regmap config */ 338 regcache_mark_dirty(sai->regmap); 339 regcache_sync(sai->regmap); 340 } 341 342 static int rockchip_sai_clear(struct rk_sai_dev *sai, unsigned int clr) 343 { 344 unsigned int val = 0; 345 int ret = 0; 346 347 regmap_update_bits(sai->regmap, SAI_CLR, clr, clr); 348 ret = regmap_read_poll_timeout_atomic(sai->regmap, SAI_CLR, val, 349 !(val & clr), 10, TIMEOUT_US); 350 if (ret < 0) { 351 dev_warn(sai->dev, "Failed to clear %u\n", clr); 352 rockchip_sai_reset(sai); 353 } 354 355 return ret; 356 } 357 358 static void rockchip_sai_xfer_start(struct rk_sai_dev *sai, int stream) 359 { 360 unsigned int msk, val; 361 362 if (stream == SNDRV_PCM_STREAM_PLAYBACK) { 363 msk = SAI_XFER_TXS_MASK; 364 val = SAI_XFER_TXS_EN; 365 366 } else { 367 msk = SAI_XFER_RXS_MASK; 368 val = SAI_XFER_RXS_EN; 369 } 370 371 regmap_update_bits(sai->regmap, SAI_XFER, msk, val); 372 } 373 374 static void rockchip_sai_xfer_stop(struct rk_sai_dev *sai, int stream) 375 { 376 unsigned int msk = 0, val = 0, clr = 0; 377 bool capture = stream == SNDRV_PCM_STREAM_CAPTURE || stream < 0; 378 bool playback = stream == SNDRV_PCM_STREAM_PLAYBACK || stream < 0; 379 /* could be <= 0 but we don't want to depend on enum values */ 380 381 if (playback) { 382 msk |= SAI_XFER_TXS_MASK; 383 val |= SAI_XFER_TXS_DIS; 384 clr |= SAI_CLR_TXC; 385 } 386 if (capture) { 387 msk |= SAI_XFER_RXS_MASK; 388 val |= SAI_XFER_RXS_DIS; 389 clr |= SAI_CLR_RXC; 390 } 391 392 regmap_update_bits(sai->regmap, SAI_XFER, msk, val); 393 rockchip_sai_poll_stream_idle(sai, playback, capture); 394 395 rockchip_sai_clear(sai, clr); 396 } 397 398 static void rockchip_sai_start(struct rk_sai_dev *sai, int stream) 399 { 400 rockchip_sai_dma_ctrl(sai, stream, 1); 401 rockchip_sai_xfer_start(sai, stream); 402 } 403 404 static void rockchip_sai_stop(struct rk_sai_dev *sai, int stream) 405 { 406 rockchip_sai_dma_ctrl(sai, stream, 0); 407 rockchip_sai_xfer_stop(sai, stream); 408 } 409 410 static void rockchip_sai_fmt_create(struct rk_sai_dev *sai, unsigned int fmt) 411 { 412 unsigned int xcr_mask = 0, xcr_val = 0, xsft_mask = 0, xsft_val = 0; 413 unsigned int fscr_mask = 0, fscr_val = 0; 414 415 assert_spin_locked(&sai->xfer_lock); 416 417 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 418 case SND_SOC_DAIFMT_RIGHT_J: 419 xcr_mask = SAI_XCR_VDJ_MASK | SAI_XCR_EDGE_SHIFT_MASK; 420 xcr_val = SAI_XCR_VDJ_R | SAI_XCR_EDGE_SHIFT_0; 421 xsft_mask = SAI_XSHIFT_RIGHT_MASK; 422 xsft_val = SAI_XSHIFT_RIGHT(0); 423 fscr_mask = SAI_FSCR_EDGE_MASK; 424 fscr_val = SAI_FSCR_EDGE_DUAL; 425 sai->fpw = FPW_HALF_FRAME_WIDTH; 426 break; 427 case SND_SOC_DAIFMT_LEFT_J: 428 xcr_mask = SAI_XCR_VDJ_MASK | SAI_XCR_EDGE_SHIFT_MASK; 429 xcr_val = SAI_XCR_VDJ_L | SAI_XCR_EDGE_SHIFT_0; 430 xsft_mask = SAI_XSHIFT_RIGHT_MASK; 431 xsft_val = SAI_XSHIFT_RIGHT(0); 432 fscr_mask = SAI_FSCR_EDGE_MASK; 433 fscr_val = SAI_FSCR_EDGE_DUAL; 434 sai->fpw = FPW_HALF_FRAME_WIDTH; 435 break; 436 case SND_SOC_DAIFMT_I2S: 437 xcr_mask = SAI_XCR_VDJ_MASK | SAI_XCR_EDGE_SHIFT_MASK; 438 xcr_val = SAI_XCR_VDJ_L | SAI_XCR_EDGE_SHIFT_1; 439 xsft_mask = SAI_XSHIFT_RIGHT_MASK; 440 if (sai->is_tdm) 441 xsft_val = SAI_XSHIFT_RIGHT(1); 442 else 443 xsft_val = SAI_XSHIFT_RIGHT(2); 444 fscr_mask = SAI_FSCR_EDGE_MASK; 445 fscr_val = SAI_FSCR_EDGE_DUAL; 446 sai->fpw = FPW_HALF_FRAME_WIDTH; 447 break; 448 case SND_SOC_DAIFMT_DSP_A: 449 xcr_mask = SAI_XCR_VDJ_MASK | SAI_XCR_EDGE_SHIFT_MASK; 450 xcr_val = SAI_XCR_VDJ_L | SAI_XCR_EDGE_SHIFT_0; 451 xsft_mask = SAI_XSHIFT_RIGHT_MASK; 452 xsft_val = SAI_XSHIFT_RIGHT(2); 453 fscr_mask = SAI_FSCR_EDGE_MASK; 454 fscr_val = SAI_FSCR_EDGE_RISING; 455 sai->fpw = FPW_ONE_BCLK_WIDTH; 456 break; 457 case SND_SOC_DAIFMT_DSP_B: 458 xcr_mask = SAI_XCR_VDJ_MASK | SAI_XCR_EDGE_SHIFT_MASK; 459 xcr_val = SAI_XCR_VDJ_L | SAI_XCR_EDGE_SHIFT_0; 460 xsft_mask = SAI_XSHIFT_RIGHT_MASK; 461 xsft_val = SAI_XSHIFT_RIGHT(0); 462 fscr_mask = SAI_FSCR_EDGE_MASK; 463 fscr_val = SAI_FSCR_EDGE_RISING; 464 sai->fpw = FPW_ONE_BCLK_WIDTH; 465 break; 466 default: 467 dev_err(sai->dev, "Unsupported fmt %u\n", fmt); 468 break; 469 } 470 471 regmap_update_bits(sai->regmap, SAI_TXCR, xcr_mask, xcr_val); 472 regmap_update_bits(sai->regmap, SAI_RXCR, xcr_mask, xcr_val); 473 regmap_update_bits(sai->regmap, SAI_TX_SHIFT, xsft_mask, xsft_val); 474 regmap_update_bits(sai->regmap, SAI_RX_SHIFT, xsft_mask, xsft_val); 475 regmap_update_bits(sai->regmap, SAI_FSCR, fscr_mask, fscr_val); 476 } 477 478 static int rockchip_sai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) 479 { 480 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 481 unsigned int mask = 0, val = 0; 482 unsigned int clk_gates; 483 int ret = 0; 484 485 pm_runtime_get_sync(dai->dev); 486 487 mask = SAI_CKR_MSS_MASK; 488 switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) { 489 case SND_SOC_DAIFMT_BP_FP: 490 val = SAI_CKR_MSS_MASTER; 491 sai->is_master_mode = true; 492 break; 493 case SND_SOC_DAIFMT_BC_FC: 494 val = SAI_CKR_MSS_SLAVE; 495 sai->is_master_mode = false; 496 break; 497 default: 498 pm_runtime_put(dai->dev); 499 return -EINVAL; 500 } 501 502 scoped_guard(spinlock_irqsave, &sai->xfer_lock) { 503 rockchip_sai_xfer_clk_stop_and_wait(sai, &clk_gates); 504 if (sai->initialized) { 505 if (sai->has_capture && sai->has_playback) 506 rockchip_sai_xfer_stop(sai, -1); 507 else if (sai->has_capture) 508 rockchip_sai_xfer_stop(sai, SNDRV_PCM_STREAM_CAPTURE); 509 else 510 rockchip_sai_xfer_stop(sai, SNDRV_PCM_STREAM_PLAYBACK); 511 } else { 512 rockchip_sai_clear(sai, 0); 513 sai->initialized = true; 514 } 515 516 regmap_update_bits(sai->regmap, SAI_CKR, mask, val); 517 518 mask = SAI_CKR_CKP_MASK | SAI_CKR_FSP_MASK; 519 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 520 case SND_SOC_DAIFMT_NB_NF: 521 val = SAI_CKR_CKP_NORMAL | SAI_CKR_FSP_NORMAL; 522 break; 523 case SND_SOC_DAIFMT_NB_IF: 524 val = SAI_CKR_CKP_NORMAL | SAI_CKR_FSP_INVERTED; 525 break; 526 case SND_SOC_DAIFMT_IB_NF: 527 val = SAI_CKR_CKP_INVERTED | SAI_CKR_FSP_NORMAL; 528 break; 529 case SND_SOC_DAIFMT_IB_IF: 530 val = SAI_CKR_CKP_INVERTED | SAI_CKR_FSP_INVERTED; 531 break; 532 default: 533 ret = -EINVAL; 534 break; 535 } 536 537 if (ret == 0) { 538 regmap_update_bits(sai->regmap, SAI_CKR, mask, val); 539 rockchip_sai_fmt_create(sai, fmt); 540 } 541 542 if (clk_gates) 543 regmap_update_bits(sai->regmap, SAI_XFER, 544 SAI_XFER_CLK_MASK | SAI_XFER_FSS_MASK, 545 clk_gates); 546 } 547 548 pm_runtime_put(dai->dev); 549 550 return ret; 551 } 552 553 static int rockchip_sai_hw_params(struct snd_pcm_substream *substream, 554 struct snd_pcm_hw_params *params, 555 struct snd_soc_dai *dai) 556 { 557 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 558 struct snd_dmaengine_dai_dma_data *dma_data; 559 unsigned int mclk_rate, mclk_req_rate, bclk_rate, div_bclk; 560 unsigned int ch_per_lane, slot_width; 561 unsigned int val, fscr, reg; 562 unsigned int lanes, req_lanes; 563 int ret = 0; 564 565 if (!rockchip_sai_stream_valid(substream, dai)) 566 return 0; 567 568 dma_data = snd_soc_dai_get_dma_data(dai, substream); 569 dma_data->maxburst = MAXBURST_PER_FIFO * params_channels(params) / 2; 570 571 pm_runtime_get_sync(sai->dev); 572 573 regmap_read(sai->regmap, SAI_DMACR, &val); 574 575 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 576 reg = SAI_TXCR; 577 lanes = sai->tx_lanes; 578 } else { 579 reg = SAI_RXCR; 580 lanes = sai->rx_lanes; 581 } 582 583 if (!sai->is_tdm) { 584 req_lanes = DIV_ROUND_UP(params_channels(params), 2); 585 if (lanes < req_lanes) { 586 dev_err(sai->dev, "not enough lanes (%d) for requested number of %s channels (%d)\n", 587 lanes, reg == SAI_TXCR ? "playback" : "capture", 588 params_channels(params)); 589 pm_runtime_put(sai->dev); 590 return -EINVAL; 591 } else { 592 lanes = req_lanes; 593 } 594 } 595 596 dev_dbg(sai->dev, "using %d lanes totalling %d%s channels for %s\n", 597 lanes, params_channels(params), sai->is_tdm ? " (TDM)" : "", 598 reg == SAI_TXCR ? "playback" : "capture"); 599 600 switch (params_format(params)) { 601 case SNDRV_PCM_FORMAT_S8: 602 case SNDRV_PCM_FORMAT_U8: 603 val = SAI_XCR_VDW(8); 604 break; 605 case SNDRV_PCM_FORMAT_S16_LE: 606 val = SAI_XCR_VDW(16); 607 break; 608 case SNDRV_PCM_FORMAT_S24_LE: 609 val = SAI_XCR_VDW(24); 610 break; 611 case SNDRV_PCM_FORMAT_S32_LE: 612 case SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE: 613 val = SAI_XCR_VDW(32); 614 break; 615 default: 616 pm_runtime_put(sai->dev); 617 return -EINVAL; 618 } 619 620 val |= SAI_XCR_CSR(lanes); 621 622 scoped_guard(spinlock_irqsave, &sai->xfer_lock) { 623 624 regmap_update_bits(sai->regmap, reg, SAI_XCR_VDW_MASK | SAI_XCR_CSR_MASK, val); 625 626 if (!sai->is_tdm) 627 regmap_update_bits(sai->regmap, reg, SAI_XCR_SBW_MASK, 628 SAI_XCR_SBW(params_physical_width(params))); 629 630 regmap_read(sai->regmap, reg, &val); 631 632 slot_width = SAI_XCR_SBW_V(val); 633 ch_per_lane = params_channels(params) / lanes; 634 635 regmap_update_bits(sai->regmap, reg, SAI_XCR_SNB_MASK, 636 SAI_XCR_SNB(ch_per_lane)); 637 638 fscr = SAI_FSCR_FW(sai->fw_ratio * slot_width * ch_per_lane); 639 640 switch (sai->fpw) { 641 case FPW_ONE_BCLK_WIDTH: 642 fscr |= SAI_FSCR_FPW(1); 643 break; 644 case FPW_ONE_SLOT_WIDTH: 645 fscr |= SAI_FSCR_FPW(slot_width); 646 break; 647 case FPW_HALF_FRAME_WIDTH: 648 fscr |= SAI_FSCR_FPW(sai->fw_ratio * slot_width * ch_per_lane / 2); 649 break; 650 default: 651 dev_err(sai->dev, "Invalid Frame Pulse Width %d\n", sai->fpw); 652 ret = -EINVAL; 653 break; 654 } 655 656 if (ret == 0) { 657 regmap_update_bits(sai->regmap, SAI_FSCR, 658 SAI_FSCR_FW_MASK | SAI_FSCR_FPW_MASK, fscr); 659 660 if (sai->is_master_mode) { 661 bclk_rate = sai->fw_ratio * slot_width * 662 ch_per_lane * params_rate(params); 663 ret = clk_set_rate(sai->mclk, sai->mclk_rate); 664 if (ret) 665 dev_err(sai->dev, "Failed to set mclk to %u: %pe\n", 666 sai->mclk_rate, ERR_PTR(ret)); 667 else { 668 mclk_rate = clk_get_rate(sai->mclk); 669 if (mclk_rate < bclk_rate) { 670 dev_err(sai->dev, "Mismatch mclk: %u, at least %u\n", 671 mclk_rate, bclk_rate); 672 ret = -EINVAL; 673 } else { 674 675 div_bclk = DIV_ROUND_CLOSEST(mclk_rate, bclk_rate); 676 mclk_req_rate = bclk_rate * div_bclk; 677 678 if (mclk_rate < 679 mclk_req_rate - CLK_SHIFT_RATE_HZ_MAX || 680 mclk_rate > 681 mclk_req_rate + CLK_SHIFT_RATE_HZ_MAX) { 682 dev_err(sai->dev, 683 "Mismatch mclk: %u, expected %u (+/- %dHz)\n", 684 mclk_rate, mclk_req_rate, 685 CLK_SHIFT_RATE_HZ_MAX); 686 ret = -EINVAL; 687 } else 688 regmap_update_bits(sai->regmap, 689 SAI_CKR, 690 SAI_CKR_MDIV_MASK, 691 SAI_CKR_MDIV(div_bclk)); 692 } 693 } 694 } 695 } 696 } 697 698 pm_runtime_put(sai->dev); 699 700 return ret; 701 } 702 703 static int rockchip_sai_prepare(struct snd_pcm_substream *substream, 704 struct snd_soc_dai *dai) 705 { 706 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 707 708 if (!rockchip_sai_stream_valid(substream, dai)) 709 return 0; 710 711 if (sai->is_master_mode) { 712 /* 713 * We should wait for the first BCLK pulse to have definitely 714 * occurred after any DIV settings have potentially been 715 * changed in order to guarantee a clean clock signal once we 716 * ungate the clock. 717 * 718 * Ideally, this would be done depending on the samplerate, but 719 * for the sake of simplicity, we'll just delay for the maximum 720 * possible clock offset time, which is quite a small value. 721 * 722 * The maximum BCLK offset is 15.6us @ 8K-8Bit (64kHz BCLK). We 723 * wait for 20us in order to give us a safety margin in case 724 * udelay falls short. 725 */ 726 udelay(20); 727 scoped_guard(spinlock_irqsave, &sai->xfer_lock) 728 regmap_update_bits(sai->regmap, SAI_XFER, 729 SAI_XFER_CLK_MASK | 730 SAI_XFER_FSS_MASK, 731 SAI_XFER_CLK_EN | 732 SAI_XFER_FSS_EN); 733 } 734 735 rockchip_sai_fsync_lost_detect(sai, 1); 736 rockchip_sai_fsync_err_detect(sai, 1); 737 738 return 0; 739 } 740 741 static void rockchip_sai_path_config(struct rk_sai_dev *sai, 742 int num, bool is_rx) 743 { 744 int i; 745 746 if (is_rx) 747 for (i = 0; i < num; i++) 748 regmap_update_bits(sai->regmap, SAI_PATH_SEL, 749 SAI_RX_PATH_MASK(i), 750 SAI_RX_PATH(i, sai->sdi[i])); 751 else 752 for (i = 0; i < num; i++) 753 regmap_update_bits(sai->regmap, SAI_PATH_SEL, 754 SAI_TX_PATH_MASK(i), 755 SAI_TX_PATH(i, sai->sdo[i])); 756 } 757 758 static int rockchip_sai_path_prepare(struct rk_sai_dev *sai, 759 struct device_node *np, 760 bool is_rx) 761 { 762 const char *path_prop; 763 unsigned int *data; 764 unsigned int *lanes; 765 int i, num, ret; 766 767 if (is_rx) { 768 path_prop = "rockchip,sai-rx-route"; 769 data = sai->sdi; 770 lanes = &sai->rx_lanes; 771 } else { 772 path_prop = "rockchip,sai-tx-route"; 773 data = sai->sdo; 774 lanes = &sai->tx_lanes; 775 } 776 777 num = of_count_phandle_with_args(np, path_prop, NULL); 778 if (num == -ENOENT) { 779 return 0; 780 } else if (num > MAX_LANES || num == 0) { 781 dev_err(sai->dev, "found %d entries in %s, outside of range 1 to %d\n", 782 num, path_prop, MAX_LANES); 783 return -EINVAL; 784 } else if (num < 0) { 785 dev_err(sai->dev, "error in %s property: %pe\n", path_prop, 786 ERR_PTR(num)); 787 return num; 788 } 789 790 *lanes = num; 791 ret = device_property_read_u32_array(sai->dev, path_prop, data, num); 792 if (ret < 0) { 793 dev_err(sai->dev, "failed to read property '%s': %pe\n", 794 path_prop, ERR_PTR(ret)); 795 return ret; 796 } 797 798 for (i = 0; i < num; i++) { 799 if (data[i] >= MAX_LANES) { 800 dev_err(sai->dev, "%s[%d] is %d, should be less than %d\n", 801 path_prop, i, data[i], MAX_LANES); 802 return -EINVAL; 803 } 804 } 805 806 rockchip_sai_path_config(sai, num, is_rx); 807 808 return 0; 809 } 810 811 static int rockchip_sai_parse_paths(struct rk_sai_dev *sai, 812 struct device_node *np) 813 { 814 int ret; 815 816 if (sai->has_playback) { 817 sai->tx_lanes = 1; 818 ret = rockchip_sai_path_prepare(sai, np, false); 819 if (ret < 0) { 820 dev_err(sai->dev, "Failed to prepare TX path: %pe\n", 821 ERR_PTR(ret)); 822 return ret; 823 } 824 } 825 826 if (sai->has_capture) { 827 sai->rx_lanes = 1; 828 ret = rockchip_sai_path_prepare(sai, np, true); 829 if (ret < 0) { 830 dev_err(sai->dev, "Failed to prepare RX path: %pe\n", 831 ERR_PTR(ret)); 832 return ret; 833 } 834 } 835 836 return 0; 837 } 838 839 static int rockchip_sai_trigger(struct snd_pcm_substream *substream, 840 int cmd, struct snd_soc_dai *dai) 841 { 842 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 843 int ret = 0; 844 845 if (!rockchip_sai_stream_valid(substream, dai)) 846 return 0; 847 848 switch (cmd) { 849 case SNDRV_PCM_TRIGGER_START: 850 case SNDRV_PCM_TRIGGER_RESUME: 851 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 852 rockchip_sai_start(sai, substream->stream); 853 break; 854 case SNDRV_PCM_TRIGGER_SUSPEND: 855 case SNDRV_PCM_TRIGGER_STOP: 856 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 857 rockchip_sai_stop(sai, substream->stream); 858 break; 859 default: 860 ret = -EINVAL; 861 break; 862 } 863 864 return ret; 865 } 866 867 868 static int rockchip_sai_dai_probe(struct snd_soc_dai *dai) 869 { 870 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 871 872 snd_soc_dai_init_dma_data(dai, 873 sai->has_playback ? &sai->playback_dma_data : NULL, 874 sai->has_capture ? &sai->capture_dma_data : NULL); 875 876 return 0; 877 } 878 879 static int rockchip_sai_startup(struct snd_pcm_substream *substream, 880 struct snd_soc_dai *dai) 881 { 882 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 883 int stream = substream->stream; 884 885 if (!rockchip_sai_stream_valid(substream, dai)) 886 return 0; 887 888 if (sai->substreams[stream]) 889 return -EBUSY; 890 891 if (sai->wait_time[stream]) 892 substream->wait_time = sai->wait_time[stream]; 893 894 sai->substreams[stream] = substream; 895 896 return 0; 897 } 898 899 static void rockchip_sai_shutdown(struct snd_pcm_substream *substream, 900 struct snd_soc_dai *dai) 901 { 902 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 903 904 if (!rockchip_sai_stream_valid(substream, dai)) 905 return; 906 907 sai->substreams[substream->stream] = NULL; 908 } 909 910 static int rockchip_sai_set_tdm_slot(struct snd_soc_dai *dai, 911 unsigned int tx_mask, unsigned int rx_mask, 912 int slots, int slot_width) 913 { 914 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 915 unsigned int clk_gates; 916 int sw = slot_width; 917 918 if (!slots) { 919 /* Disabling TDM, set slot width back to 32 bits */ 920 sai->is_tdm = false; 921 sw = 32; 922 } else { 923 sai->is_tdm = true; 924 } 925 926 if (sw < 16 || sw > 32) 927 return -EINVAL; 928 929 pm_runtime_get_sync(dai->dev); 930 scoped_guard(spinlock_irqsave, &sai->xfer_lock) { 931 rockchip_sai_xfer_clk_stop_and_wait(sai, &clk_gates); 932 regmap_update_bits(sai->regmap, SAI_TXCR, SAI_XCR_SBW_MASK, 933 SAI_XCR_SBW(sw)); 934 regmap_update_bits(sai->regmap, SAI_RXCR, SAI_XCR_SBW_MASK, 935 SAI_XCR_SBW(sw)); 936 regmap_update_bits(sai->regmap, SAI_XFER, 937 SAI_XFER_CLK_MASK | SAI_XFER_FSS_MASK, 938 clk_gates); 939 } 940 pm_runtime_put(dai->dev); 941 942 return 0; 943 } 944 945 static int rockchip_sai_set_sysclk(struct snd_soc_dai *dai, int stream, 946 unsigned int freq, int dir) 947 { 948 struct rk_sai_dev *sai = snd_soc_dai_get_drvdata(dai); 949 950 sai->mclk_rate = freq; 951 952 return 0; 953 } 954 955 static const struct snd_soc_dai_ops rockchip_sai_dai_ops = { 956 .probe = rockchip_sai_dai_probe, 957 .startup = rockchip_sai_startup, 958 .shutdown = rockchip_sai_shutdown, 959 .hw_params = rockchip_sai_hw_params, 960 .set_fmt = rockchip_sai_set_fmt, 961 .set_sysclk = rockchip_sai_set_sysclk, 962 .prepare = rockchip_sai_prepare, 963 .trigger = rockchip_sai_trigger, 964 .set_tdm_slot = rockchip_sai_set_tdm_slot, 965 }; 966 967 static const struct snd_soc_dai_driver rockchip_sai_dai = { 968 .ops = &rockchip_sai_dai_ops, 969 .symmetric_rate = 1, 970 }; 971 972 static bool rockchip_sai_wr_reg(struct device *dev, unsigned int reg) 973 { 974 switch (reg) { 975 case SAI_TXCR: 976 case SAI_FSCR: 977 case SAI_RXCR: 978 case SAI_MONO_CR: 979 case SAI_XFER: 980 case SAI_CLR: 981 case SAI_CKR: 982 case SAI_DMACR: 983 case SAI_INTCR: 984 case SAI_TXDR: 985 case SAI_PATH_SEL: 986 case SAI_TX_SLOT_MASK0: 987 case SAI_TX_SLOT_MASK1: 988 case SAI_TX_SLOT_MASK2: 989 case SAI_TX_SLOT_MASK3: 990 case SAI_RX_SLOT_MASK0: 991 case SAI_RX_SLOT_MASK1: 992 case SAI_RX_SLOT_MASK2: 993 case SAI_RX_SLOT_MASK3: 994 case SAI_TX_SHIFT: 995 case SAI_RX_SHIFT: 996 case SAI_FSXN: 997 case SAI_FS_TIMEOUT: 998 case SAI_LOOPBACK_LR: 999 return true; 1000 default: 1001 return false; 1002 } 1003 } 1004 1005 static bool rockchip_sai_rd_reg(struct device *dev, unsigned int reg) 1006 { 1007 switch (reg) { 1008 case SAI_TXCR: 1009 case SAI_FSCR: 1010 case SAI_RXCR: 1011 case SAI_MONO_CR: 1012 case SAI_XFER: 1013 case SAI_CLR: 1014 case SAI_CKR: 1015 case SAI_TXFIFOLR: 1016 case SAI_RXFIFOLR: 1017 case SAI_DMACR: 1018 case SAI_INTCR: 1019 case SAI_INTSR: 1020 case SAI_TXDR: 1021 case SAI_RXDR: 1022 case SAI_PATH_SEL: 1023 case SAI_TX_SLOT_MASK0: 1024 case SAI_TX_SLOT_MASK1: 1025 case SAI_TX_SLOT_MASK2: 1026 case SAI_TX_SLOT_MASK3: 1027 case SAI_RX_SLOT_MASK0: 1028 case SAI_RX_SLOT_MASK1: 1029 case SAI_RX_SLOT_MASK2: 1030 case SAI_RX_SLOT_MASK3: 1031 case SAI_TX_DATA_CNT: 1032 case SAI_RX_DATA_CNT: 1033 case SAI_TX_SHIFT: 1034 case SAI_RX_SHIFT: 1035 case SAI_STATUS: 1036 case SAI_VERSION: 1037 case SAI_FSXN: 1038 case SAI_FS_TIMEOUT: 1039 case SAI_LOOPBACK_LR: 1040 return true; 1041 default: 1042 return false; 1043 } 1044 } 1045 1046 static bool rockchip_sai_volatile_reg(struct device *dev, unsigned int reg) 1047 { 1048 switch (reg) { 1049 case SAI_XFER: 1050 case SAI_INTCR: 1051 case SAI_INTSR: 1052 case SAI_CLR: 1053 case SAI_TXFIFOLR: 1054 case SAI_RXFIFOLR: 1055 case SAI_TXDR: 1056 case SAI_RXDR: 1057 case SAI_TX_DATA_CNT: 1058 case SAI_RX_DATA_CNT: 1059 case SAI_STATUS: 1060 case SAI_VERSION: 1061 return true; 1062 default: 1063 return false; 1064 } 1065 } 1066 1067 static bool rockchip_sai_precious_reg(struct device *dev, unsigned int reg) 1068 { 1069 switch (reg) { 1070 case SAI_RXDR: 1071 return true; 1072 default: 1073 return false; 1074 } 1075 } 1076 1077 static const struct reg_default rockchip_sai_reg_defaults[] = { 1078 { SAI_TXCR, 0x00000bff }, 1079 { SAI_FSCR, 0x0001f03f }, 1080 { SAI_RXCR, 0x00000bff }, 1081 { SAI_PATH_SEL, 0x0000e4e4 }, 1082 }; 1083 1084 static const struct regmap_config rockchip_sai_regmap_config = { 1085 .reg_bits = 32, 1086 .reg_stride = 4, 1087 .val_bits = 32, 1088 .max_register = SAI_LOOPBACK_LR, 1089 .reg_defaults = rockchip_sai_reg_defaults, 1090 .num_reg_defaults = ARRAY_SIZE(rockchip_sai_reg_defaults), 1091 .writeable_reg = rockchip_sai_wr_reg, 1092 .readable_reg = rockchip_sai_rd_reg, 1093 .volatile_reg = rockchip_sai_volatile_reg, 1094 .precious_reg = rockchip_sai_precious_reg, 1095 .cache_type = REGCACHE_FLAT, 1096 }; 1097 1098 static int rockchip_sai_init_dai(struct rk_sai_dev *sai, struct resource *res, 1099 struct snd_soc_dai_driver **dp) 1100 { 1101 struct device_node *node = sai->dev->of_node; 1102 struct snd_soc_dai_driver *dai; 1103 struct property *dma_names; 1104 const char *dma_name; 1105 1106 of_property_for_each_string(node, "dma-names", dma_names, dma_name) { 1107 if (!strcmp(dma_name, "tx")) 1108 sai->has_playback = true; 1109 if (!strcmp(dma_name, "rx")) 1110 sai->has_capture = true; 1111 } 1112 1113 dai = devm_kmemdup(sai->dev, &rockchip_sai_dai, 1114 sizeof(*dai), GFP_KERNEL); 1115 if (!dai) 1116 return -ENOMEM; 1117 1118 if (sai->has_playback) { 1119 dai->playback.stream_name = "Playback"; 1120 dai->playback.channels_min = 1; 1121 dai->playback.channels_max = 512; 1122 dai->playback.rates = SNDRV_PCM_RATE_8000_384000; 1123 dai->playback.formats = SNDRV_PCM_FMTBIT_S8 | 1124 SNDRV_PCM_FMTBIT_S16_LE | 1125 SNDRV_PCM_FMTBIT_S24_LE | 1126 SNDRV_PCM_FMTBIT_S32_LE | 1127 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE; 1128 1129 sai->playback_dma_data.addr = res->start + SAI_TXDR; 1130 sai->playback_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; 1131 sai->playback_dma_data.maxburst = MAXBURST_PER_FIFO; 1132 } 1133 1134 if (sai->has_capture) { 1135 dai->capture.stream_name = "Capture"; 1136 dai->capture.channels_min = 1; 1137 dai->capture.channels_max = 512; 1138 dai->capture.rates = SNDRV_PCM_RATE_8000_384000; 1139 dai->capture.formats = SNDRV_PCM_FMTBIT_S8 | 1140 SNDRV_PCM_FMTBIT_S16_LE | 1141 SNDRV_PCM_FMTBIT_S24_LE | 1142 SNDRV_PCM_FMTBIT_S32_LE | 1143 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE; 1144 1145 sai->capture_dma_data.addr = res->start + SAI_RXDR; 1146 sai->capture_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; 1147 sai->capture_dma_data.maxburst = MAXBURST_PER_FIFO; 1148 } 1149 1150 regmap_update_bits(sai->regmap, SAI_DMACR, SAI_DMACR_TDL_MASK, 1151 SAI_DMACR_TDL(16)); 1152 regmap_update_bits(sai->regmap, SAI_DMACR, SAI_DMACR_RDL_MASK, 1153 SAI_DMACR_RDL(16)); 1154 1155 if (dp) 1156 *dp = dai; 1157 1158 return 0; 1159 } 1160 1161 static const char * const mono_text[] = { "Disable", "Enable" }; 1162 1163 static DECLARE_TLV_DB_SCALE(rmss_tlv, 0, 128, 0); 1164 1165 static const char * const lplrc_text[] = { "L:MIC R:LP", "L:LP R:MIC" }; 1166 static const char * const lplr_text[] = { "Disable", "Enable" }; 1167 1168 static const char * const lpx_text[] = { 1169 "From SDO0", "From SDO1", "From SDO2", "From SDO3" }; 1170 1171 static const char * const lps_text[] = { "Disable", "Enable" }; 1172 static const char * const sync_out_text[] = { "From CRU", "From IO" }; 1173 static const char * const sync_in_text[] = { "From IO", "From Sync Port" }; 1174 1175 static const char * const rpaths_text[] = { 1176 "From SDI0", "From SDI1", "From SDI2", "From SDI3" }; 1177 1178 static const char * const tpaths_text[] = { 1179 "From PATH0", "From PATH1", "From PATH2", "From PATH3" }; 1180 1181 /* MONO_CR */ 1182 static SOC_ENUM_SINGLE_DECL(rmono_switch, SAI_MONO_CR, 1, mono_text); 1183 static SOC_ENUM_SINGLE_DECL(tmono_switch, SAI_MONO_CR, 0, mono_text); 1184 1185 /* PATH_SEL */ 1186 static SOC_ENUM_SINGLE_DECL(lp3_enum, SAI_PATH_SEL, 28, lpx_text); 1187 static SOC_ENUM_SINGLE_DECL(lp2_enum, SAI_PATH_SEL, 26, lpx_text); 1188 static SOC_ENUM_SINGLE_DECL(lp1_enum, SAI_PATH_SEL, 24, lpx_text); 1189 static SOC_ENUM_SINGLE_DECL(lp0_enum, SAI_PATH_SEL, 22, lpx_text); 1190 static SOC_ENUM_SINGLE_DECL(lp3_switch, SAI_PATH_SEL, 21, lps_text); 1191 static SOC_ENUM_SINGLE_DECL(lp2_switch, SAI_PATH_SEL, 20, lps_text); 1192 static SOC_ENUM_SINGLE_DECL(lp1_switch, SAI_PATH_SEL, 19, lps_text); 1193 static SOC_ENUM_SINGLE_DECL(lp0_switch, SAI_PATH_SEL, 18, lps_text); 1194 static SOC_ENUM_SINGLE_DECL(sync_out_switch, SAI_PATH_SEL, 17, sync_out_text); 1195 static SOC_ENUM_SINGLE_DECL(sync_in_switch, SAI_PATH_SEL, 16, sync_in_text); 1196 static SOC_ENUM_SINGLE_DECL(rpath3_enum, SAI_PATH_SEL, 14, rpaths_text); 1197 static SOC_ENUM_SINGLE_DECL(rpath2_enum, SAI_PATH_SEL, 12, rpaths_text); 1198 static SOC_ENUM_SINGLE_DECL(rpath1_enum, SAI_PATH_SEL, 10, rpaths_text); 1199 static SOC_ENUM_SINGLE_DECL(rpath0_enum, SAI_PATH_SEL, 8, rpaths_text); 1200 static SOC_ENUM_SINGLE_DECL(tpath3_enum, SAI_PATH_SEL, 6, tpaths_text); 1201 static SOC_ENUM_SINGLE_DECL(tpath2_enum, SAI_PATH_SEL, 4, tpaths_text); 1202 static SOC_ENUM_SINGLE_DECL(tpath1_enum, SAI_PATH_SEL, 2, tpaths_text); 1203 static SOC_ENUM_SINGLE_DECL(tpath0_enum, SAI_PATH_SEL, 0, tpaths_text); 1204 1205 /* LOOPBACK_LR */ 1206 static SOC_ENUM_SINGLE_DECL(lp3lrc_enum, SAI_LOOPBACK_LR, 7, lplrc_text); 1207 static SOC_ENUM_SINGLE_DECL(lp2lrc_enum, SAI_LOOPBACK_LR, 6, lplrc_text); 1208 static SOC_ENUM_SINGLE_DECL(lp1lrc_enum, SAI_LOOPBACK_LR, 5, lplrc_text); 1209 static SOC_ENUM_SINGLE_DECL(lp0lrc_enum, SAI_LOOPBACK_LR, 4, lplrc_text); 1210 static SOC_ENUM_SINGLE_DECL(lp3lr_switch, SAI_LOOPBACK_LR, 3, lplr_text); 1211 static SOC_ENUM_SINGLE_DECL(lp2lr_switch, SAI_LOOPBACK_LR, 2, lplr_text); 1212 static SOC_ENUM_SINGLE_DECL(lp1lr_switch, SAI_LOOPBACK_LR, 1, lplr_text); 1213 static SOC_ENUM_SINGLE_DECL(lp0lr_switch, SAI_LOOPBACK_LR, 0, lplr_text); 1214 1215 static int rockchip_sai_wait_time_info(struct snd_kcontrol *kcontrol, 1216 struct snd_ctl_elem_info *uinfo) 1217 { 1218 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1219 uinfo->count = 1; 1220 uinfo->value.integer.min = 0; 1221 uinfo->value.integer.max = WAIT_TIME_MS_MAX; 1222 uinfo->value.integer.step = 1; 1223 1224 return 0; 1225 } 1226 1227 static int rockchip_sai_rd_wait_time_get(struct snd_kcontrol *kcontrol, 1228 struct snd_ctl_elem_value *ucontrol) 1229 { 1230 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 1231 struct rk_sai_dev *sai = snd_soc_component_get_drvdata(component); 1232 1233 ucontrol->value.integer.value[0] = sai->wait_time[SNDRV_PCM_STREAM_CAPTURE]; 1234 1235 return 0; 1236 } 1237 1238 static int rockchip_sai_rd_wait_time_put(struct snd_kcontrol *kcontrol, 1239 struct snd_ctl_elem_value *ucontrol) 1240 { 1241 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 1242 struct rk_sai_dev *sai = snd_soc_component_get_drvdata(component); 1243 1244 if (ucontrol->value.integer.value[0] > WAIT_TIME_MS_MAX) 1245 return -EINVAL; 1246 1247 sai->wait_time[SNDRV_PCM_STREAM_CAPTURE] = ucontrol->value.integer.value[0]; 1248 1249 return 1; 1250 } 1251 1252 static int rockchip_sai_wr_wait_time_get(struct snd_kcontrol *kcontrol, 1253 struct snd_ctl_elem_value *ucontrol) 1254 { 1255 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 1256 struct rk_sai_dev *sai = snd_soc_component_get_drvdata(component); 1257 1258 ucontrol->value.integer.value[0] = sai->wait_time[SNDRV_PCM_STREAM_PLAYBACK]; 1259 1260 return 0; 1261 } 1262 1263 static int rockchip_sai_wr_wait_time_put(struct snd_kcontrol *kcontrol, 1264 struct snd_ctl_elem_value *ucontrol) 1265 { 1266 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 1267 struct rk_sai_dev *sai = snd_soc_component_get_drvdata(component); 1268 1269 if (ucontrol->value.integer.value[0] > WAIT_TIME_MS_MAX) 1270 return -EINVAL; 1271 1272 sai->wait_time[SNDRV_PCM_STREAM_PLAYBACK] = ucontrol->value.integer.value[0]; 1273 1274 return 1; 1275 } 1276 1277 #define SAI_PCM_WAIT_TIME(xname, xhandler_get, xhandler_put) \ 1278 { .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, \ 1279 .info = rockchip_sai_wait_time_info, \ 1280 .get = xhandler_get, .put = xhandler_put } 1281 1282 static const struct snd_kcontrol_new rockchip_sai_controls[] = { 1283 SOC_SINGLE_TLV("Receive Mono Slot Select", SAI_MONO_CR, 1284 2, 128, 0, rmss_tlv), 1285 SOC_ENUM("Receive Mono Switch", rmono_switch), 1286 SOC_ENUM("Transmit Mono Switch", tmono_switch), 1287 1288 SOC_ENUM("SDI3 Loopback I2S LR Channel Sel", lp3lrc_enum), 1289 SOC_ENUM("SDI2 Loopback I2S LR Channel Sel", lp2lrc_enum), 1290 SOC_ENUM("SDI1 Loopback I2S LR Channel Sel", lp1lrc_enum), 1291 SOC_ENUM("SDI0 Loopback I2S LR Channel Sel", lp0lrc_enum), 1292 SOC_ENUM("SDI3 Loopback I2S LR Switch", lp3lr_switch), 1293 SOC_ENUM("SDI2 Loopback I2S LR Switch", lp2lr_switch), 1294 SOC_ENUM("SDI1 Loopback I2S LR Switch", lp1lr_switch), 1295 SOC_ENUM("SDI0 Loopback I2S LR Switch", lp0lr_switch), 1296 1297 SOC_ENUM("SDI3 Loopback Src Select", lp3_enum), 1298 SOC_ENUM("SDI2 Loopback Src Select", lp2_enum), 1299 SOC_ENUM("SDI1 Loopback Src Select", lp1_enum), 1300 SOC_ENUM("SDI0 Loopback Src Select", lp0_enum), 1301 SOC_ENUM("SDI3 Loopback Switch", lp3_switch), 1302 SOC_ENUM("SDI2 Loopback Switch", lp2_switch), 1303 SOC_ENUM("SDI1 Loopback Switch", lp1_switch), 1304 SOC_ENUM("SDI0 Loopback Switch", lp0_switch), 1305 SOC_ENUM("Sync Out Switch", sync_out_switch), 1306 SOC_ENUM("Sync In Switch", sync_in_switch), 1307 SOC_ENUM("Receive PATH3 Source Select", rpath3_enum), 1308 SOC_ENUM("Receive PATH2 Source Select", rpath2_enum), 1309 SOC_ENUM("Receive PATH1 Source Select", rpath1_enum), 1310 SOC_ENUM("Receive PATH0 Source Select", rpath0_enum), 1311 SOC_ENUM("Transmit SDO3 Source Select", tpath3_enum), 1312 SOC_ENUM("Transmit SDO2 Source Select", tpath2_enum), 1313 SOC_ENUM("Transmit SDO1 Source Select", tpath1_enum), 1314 SOC_ENUM("Transmit SDO0 Source Select", tpath0_enum), 1315 1316 SAI_PCM_WAIT_TIME("PCM Read Wait Time MS", 1317 rockchip_sai_rd_wait_time_get, 1318 rockchip_sai_rd_wait_time_put), 1319 SAI_PCM_WAIT_TIME("PCM Write Wait Time MS", 1320 rockchip_sai_wr_wait_time_get, 1321 rockchip_sai_wr_wait_time_put), 1322 }; 1323 1324 static const struct snd_soc_component_driver rockchip_sai_component = { 1325 .name = DRV_NAME, 1326 .controls = rockchip_sai_controls, 1327 .num_controls = ARRAY_SIZE(rockchip_sai_controls), 1328 .legacy_dai_naming = 1, 1329 }; 1330 1331 static irqreturn_t rockchip_sai_isr(int irq, void *devid) 1332 { 1333 struct rk_sai_dev *sai = (struct rk_sai_dev *)devid; 1334 struct snd_pcm_substream *substream; 1335 u32 val; 1336 1337 regmap_read(sai->regmap, SAI_INTSR, &val); 1338 if (val & SAI_INTSR_TXUI_ACT) { 1339 dev_warn_ratelimited(sai->dev, "TX FIFO Underrun\n"); 1340 regmap_update_bits(sai->regmap, SAI_INTCR, 1341 SAI_INTCR_TXUIC, SAI_INTCR_TXUIC); 1342 regmap_update_bits(sai->regmap, SAI_INTCR, 1343 SAI_INTCR_TXUIE_MASK, 1344 SAI_INTCR_TXUIE(0)); 1345 substream = sai->substreams[SNDRV_PCM_STREAM_PLAYBACK]; 1346 if (substream) 1347 snd_pcm_stop_xrun(substream); 1348 } 1349 1350 if (val & SAI_INTSR_RXOI_ACT) { 1351 dev_warn_ratelimited(sai->dev, "RX FIFO Overrun\n"); 1352 regmap_update_bits(sai->regmap, SAI_INTCR, 1353 SAI_INTCR_RXOIC, SAI_INTCR_RXOIC); 1354 regmap_update_bits(sai->regmap, SAI_INTCR, 1355 SAI_INTCR_RXOIE_MASK, 1356 SAI_INTCR_RXOIE(0)); 1357 substream = sai->substreams[SNDRV_PCM_STREAM_CAPTURE]; 1358 if (substream) 1359 snd_pcm_stop_xrun(substream); 1360 } 1361 1362 if (val & SAI_INTSR_FSERRI_ACT) { 1363 dev_warn_ratelimited(sai->dev, "Frame Sync Error\n"); 1364 regmap_update_bits(sai->regmap, SAI_INTCR, 1365 SAI_INTCR_FSERRC, SAI_INTCR_FSERRC); 1366 regmap_update_bits(sai->regmap, SAI_INTCR, 1367 SAI_INTCR_FSERR_MASK, 1368 SAI_INTCR_FSERR(0)); 1369 } 1370 1371 if (val & SAI_INTSR_FSLOSTI_ACT) { 1372 dev_warn_ratelimited(sai->dev, "Frame Sync Lost\n"); 1373 regmap_update_bits(sai->regmap, SAI_INTCR, 1374 SAI_INTCR_FSLOSTC, SAI_INTCR_FSLOSTC); 1375 regmap_update_bits(sai->regmap, SAI_INTCR, 1376 SAI_INTCR_FSLOST_MASK, 1377 SAI_INTCR_FSLOST(0)); 1378 } 1379 1380 return IRQ_HANDLED; 1381 } 1382 1383 static int rockchip_sai_probe(struct platform_device *pdev) 1384 { 1385 struct device_node *node = pdev->dev.of_node; 1386 struct rk_sai_dev *sai; 1387 struct snd_soc_dai_driver *dai; 1388 struct resource *res; 1389 void __iomem *regs; 1390 int ret, irq; 1391 1392 sai = devm_kzalloc(&pdev->dev, sizeof(*sai), GFP_KERNEL); 1393 if (!sai) 1394 return -ENOMEM; 1395 1396 sai->dev = &pdev->dev; 1397 sai->fw_ratio = 1; 1398 /* match to register default */ 1399 sai->is_master_mode = true; 1400 dev_set_drvdata(&pdev->dev, sai); 1401 1402 spin_lock_init(&sai->xfer_lock); 1403 1404 sai->rst_h = devm_reset_control_get_optional_exclusive(&pdev->dev, "h"); 1405 if (IS_ERR(sai->rst_h)) 1406 return dev_err_probe(&pdev->dev, PTR_ERR(sai->rst_h), 1407 "Error in 'h' reset control\n"); 1408 1409 sai->rst_m = devm_reset_control_get_optional_exclusive(&pdev->dev, "m"); 1410 if (IS_ERR(sai->rst_m)) 1411 return dev_err_probe(&pdev->dev, PTR_ERR(sai->rst_m), 1412 "Error in 'm' reset control\n"); 1413 1414 regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res); 1415 if (IS_ERR(regs)) 1416 return dev_err_probe(&pdev->dev, PTR_ERR(regs), 1417 "Failed to get and ioremap resource\n"); 1418 1419 sai->regmap = devm_regmap_init_mmio(&pdev->dev, regs, 1420 &rockchip_sai_regmap_config); 1421 if (IS_ERR(sai->regmap)) 1422 return dev_err_probe(&pdev->dev, PTR_ERR(sai->regmap), 1423 "Failed to initialize regmap\n"); 1424 1425 irq = platform_get_irq_optional(pdev, 0); 1426 if (irq > 0) { 1427 ret = devm_request_irq(&pdev->dev, irq, rockchip_sai_isr, 1428 IRQF_SHARED, node->name, sai); 1429 if (ret) 1430 return dev_err_probe(&pdev->dev, ret, 1431 "Failed to request irq %d\n", irq); 1432 } else { 1433 dev_dbg(&pdev->dev, "Asked for an IRQ but got %d\n", irq); 1434 } 1435 1436 sai->mclk = devm_clk_get(&pdev->dev, "mclk"); 1437 if (IS_ERR(sai->mclk)) 1438 return dev_err_probe(&pdev->dev, PTR_ERR(sai->mclk), 1439 "Failed to get mclk\n"); 1440 1441 sai->hclk = devm_clk_get_enabled(&pdev->dev, "hclk"); 1442 if (IS_ERR(sai->hclk)) 1443 return dev_err_probe(&pdev->dev, PTR_ERR(sai->hclk), 1444 "Failed to get hclk\n"); 1445 1446 regmap_read(sai->regmap, SAI_VERSION, &sai->version); 1447 1448 ret = rockchip_sai_init_dai(sai, res, &dai); 1449 if (ret) 1450 return dev_err_probe(&pdev->dev, ret, "Failed to initialize DAI\n"); 1451 1452 ret = rockchip_sai_parse_paths(sai, node); 1453 if (ret) 1454 return dev_err_probe(&pdev->dev, ret, "Failed to parse paths\n"); 1455 1456 /* 1457 * From here on, all register accesses need to be wrapped in 1458 * pm_runtime_get_sync/pm_runtime_put calls 1459 * 1460 * NB: we don't rely on _resume_and_get in case of !CONFIG_PM 1461 */ 1462 devm_pm_runtime_enable(&pdev->dev); 1463 pm_runtime_get_noresume(&pdev->dev); 1464 ret = rockchip_sai_runtime_resume(&pdev->dev); 1465 if (ret) 1466 return dev_err_probe(&pdev->dev, ret, "Failed to resume device\n"); 1467 1468 ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0); 1469 if (ret) { 1470 dev_err(&pdev->dev, "Failed to register PCM: %d\n", ret); 1471 goto err_runtime_suspend; 1472 } 1473 1474 ret = devm_snd_soc_register_component(&pdev->dev, 1475 &rockchip_sai_component, 1476 dai, 1); 1477 if (ret) { 1478 dev_err(&pdev->dev, "Failed to register component: %d\n", ret); 1479 goto err_runtime_suspend; 1480 } 1481 1482 pm_runtime_use_autosuspend(&pdev->dev); 1483 pm_runtime_put(&pdev->dev); 1484 1485 clk_disable_unprepare(sai->hclk); 1486 1487 return 0; 1488 1489 err_runtime_suspend: 1490 if (IS_ENABLED(CONFIG_PM)) 1491 pm_runtime_put(&pdev->dev); 1492 else 1493 rockchip_sai_runtime_suspend(&pdev->dev); 1494 1495 return ret; 1496 } 1497 1498 static void rockchip_sai_remove(struct platform_device *pdev) 1499 { 1500 #ifndef CONFIG_PM 1501 rockchip_sai_runtime_suspend(&pdev->dev); 1502 #endif 1503 } 1504 1505 static const struct dev_pm_ops rockchip_sai_pm_ops = { 1506 SET_RUNTIME_PM_OPS(rockchip_sai_runtime_suspend, rockchip_sai_runtime_resume, NULL) 1507 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume) 1508 }; 1509 1510 static const struct of_device_id rockchip_sai_match[] = { 1511 { .compatible = "rockchip,rk3576-sai", }, 1512 {}, 1513 }; 1514 MODULE_DEVICE_TABLE(of, rockchip_sai_match); 1515 1516 static struct platform_driver rockchip_sai_driver = { 1517 .probe = rockchip_sai_probe, 1518 .remove = rockchip_sai_remove, 1519 .driver = { 1520 .name = DRV_NAME, 1521 .of_match_table = rockchip_sai_match, 1522 .pm = &rockchip_sai_pm_ops, 1523 }, 1524 }; 1525 module_platform_driver(rockchip_sai_driver); 1526 1527 MODULE_DESCRIPTION("Rockchip SAI ASoC Interface"); 1528 MODULE_AUTHOR("Sugar Zhang <sugar.zhang@rock-chips.com>"); 1529 MODULE_AUTHOR("Nicolas Frattaroli <nicolas.frattaroli@collabora.com>"); 1530 MODULE_LICENSE("GPL"); 1531