1 /* 2 * Copyright (C) STMicroelectronics SA 2015 3 * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com> 4 * for STMicroelectronics. 5 * License terms: GNU General Public License (GPL), version 2 6 */ 7 8 #include <linux/clk.h> 9 #include <linux/delay.h> 10 #include <linux/io.h> 11 #include <linux/mfd/syscon.h> 12 13 #include <sound/asoundef.h> 14 #include <sound/soc.h> 15 16 #include "uniperif.h" 17 18 /* 19 * Some hardware-related definitions 20 */ 21 22 /* sys config registers definitions */ 23 #define SYS_CFG_AUDIO_GLUE 0xA4 24 #define SYS_CFG_AUDI0_GLUE_PCM_CLKX 8 25 26 /* 27 * Driver specific types. 28 */ 29 #define UNIPERIF_PLAYER_TYPE_IS_HDMI(p) \ 30 ((p)->info->player_type == SND_ST_UNIPERIF_PLAYER_TYPE_HDMI) 31 #define UNIPERIF_PLAYER_TYPE_IS_PCM(p) \ 32 ((p)->info->player_type == SND_ST_UNIPERIF_PLAYER_TYPE_PCM) 33 #define UNIPERIF_PLAYER_TYPE_IS_SPDIF(p) \ 34 ((p)->info->player_type == SND_ST_UNIPERIF_PLAYER_TYPE_SPDIF) 35 #define UNIPERIF_PLAYER_TYPE_IS_IEC958(p) \ 36 (UNIPERIF_PLAYER_TYPE_IS_HDMI(p) || \ 37 UNIPERIF_PLAYER_TYPE_IS_SPDIF(p)) 38 39 #define UNIPERIF_PLAYER_CLK_ADJ_MIN -999999 40 #define UNIPERIF_PLAYER_CLK_ADJ_MAX 1000000 41 42 /* 43 * Note: snd_pcm_hardware is linked to DMA controller but is declared here to 44 * integrate DAI_CPU capability in term of rate and supported channels 45 */ 46 static const struct snd_pcm_hardware uni_player_pcm_hw = { 47 .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | 48 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP | 49 SNDRV_PCM_INFO_MMAP_VALID, 50 .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE, 51 52 .rates = SNDRV_PCM_RATE_CONTINUOUS, 53 .rate_min = 8000, 54 .rate_max = 192000, 55 56 .channels_min = 2, 57 .channels_max = 8, 58 59 .periods_min = 2, 60 .periods_max = 48, 61 62 .period_bytes_min = 128, 63 .period_bytes_max = 64 * PAGE_SIZE, 64 .buffer_bytes_max = 256 * PAGE_SIZE 65 }; 66 67 static inline int reset_player(struct uniperif *player) 68 { 69 int count = 10; 70 71 if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) { 72 while (GET_UNIPERIF_SOFT_RST_SOFT_RST(player) && count) { 73 udelay(5); 74 count--; 75 } 76 } 77 78 if (!count) { 79 dev_err(player->dev, "Failed to reset uniperif"); 80 return -EIO; 81 } 82 83 return 0; 84 } 85 86 /* 87 * uni_player_irq_handler 88 * In case of error audio stream is stopped; stop action is protected via PCM 89 * stream lock to avoid race condition with trigger callback. 90 */ 91 static irqreturn_t uni_player_irq_handler(int irq, void *dev_id) 92 { 93 irqreturn_t ret = IRQ_NONE; 94 struct uniperif *player = dev_id; 95 unsigned int status; 96 unsigned int tmp; 97 98 if (player->state == UNIPERIF_STATE_STOPPED) { 99 /* Unexpected IRQ: do nothing */ 100 return IRQ_NONE; 101 } 102 103 /* Get interrupt status & clear them immediately */ 104 status = GET_UNIPERIF_ITS(player); 105 SET_UNIPERIF_ITS_BCLR(player, status); 106 107 /* Check for fifo error (underrun) */ 108 if (unlikely(status & UNIPERIF_ITS_FIFO_ERROR_MASK(player))) { 109 dev_err(player->dev, "FIFO underflow error detected"); 110 111 /* Interrupt is just for information when underflow recovery */ 112 if (player->info->underflow_enabled) { 113 /* Update state to underflow */ 114 player->state = UNIPERIF_STATE_UNDERFLOW; 115 116 } else { 117 /* Disable interrupt so doesn't continually fire */ 118 SET_UNIPERIF_ITM_BCLR_FIFO_ERROR(player); 119 120 /* Stop the player */ 121 snd_pcm_stream_lock(player->substream); 122 snd_pcm_stop(player->substream, SNDRV_PCM_STATE_XRUN); 123 snd_pcm_stream_unlock(player->substream); 124 } 125 126 ret = IRQ_HANDLED; 127 } 128 129 /* Check for dma error (overrun) */ 130 if (unlikely(status & UNIPERIF_ITS_DMA_ERROR_MASK(player))) { 131 dev_err(player->dev, "DMA error detected"); 132 133 /* Disable interrupt so doesn't continually fire */ 134 SET_UNIPERIF_ITM_BCLR_DMA_ERROR(player); 135 136 /* Stop the player */ 137 snd_pcm_stream_lock(player->substream); 138 snd_pcm_stop(player->substream, SNDRV_PCM_STATE_XRUN); 139 snd_pcm_stream_unlock(player->substream); 140 141 ret = IRQ_HANDLED; 142 } 143 144 /* Check for underflow recovery done */ 145 if (unlikely(status & UNIPERIF_ITM_UNDERFLOW_REC_DONE_MASK(player))) { 146 if (!player->info->underflow_enabled) { 147 dev_err(player->dev, "unexpected Underflow recovering"); 148 return -EPERM; 149 } 150 /* Read the underflow recovery duration */ 151 tmp = GET_UNIPERIF_STATUS_1_UNDERFLOW_DURATION(player); 152 153 /* Clear the underflow recovery duration */ 154 SET_UNIPERIF_BIT_CONTROL_CLR_UNDERFLOW_DURATION(player); 155 156 /* Update state to started */ 157 player->state = UNIPERIF_STATE_STARTED; 158 159 ret = IRQ_HANDLED; 160 } 161 162 /* Check if underflow recovery failed */ 163 if (unlikely(status & 164 UNIPERIF_ITM_UNDERFLOW_REC_FAILED_MASK(player))) { 165 dev_err(player->dev, "Underflow recovery failed"); 166 167 /* Stop the player */ 168 snd_pcm_stream_lock(player->substream); 169 snd_pcm_stop(player->substream, SNDRV_PCM_STATE_XRUN); 170 snd_pcm_stream_unlock(player->substream); 171 172 ret = IRQ_HANDLED; 173 } 174 175 return ret; 176 } 177 178 static int uni_player_clk_set_rate(struct uniperif *player, unsigned long rate) 179 { 180 int rate_adjusted, rate_achieved, delta, ret; 181 int adjustment = player->clk_adj; 182 183 /* 184 * a 185 * F = f + --------- * f = f + d 186 * 1000000 187 * 188 * a 189 * d = --------- * f 190 * 1000000 191 * 192 * where: 193 * f - nominal rate 194 * a - adjustment in ppm (parts per milion) 195 * F - rate to be set in synthesizer 196 * d - delta (difference) between f and F 197 */ 198 if (adjustment < 0) { 199 /* div64_64 operates on unsigned values... */ 200 delta = -1; 201 adjustment = -adjustment; 202 } else { 203 delta = 1; 204 } 205 /* 500000 ppm is 0.5, which is used to round up values */ 206 delta *= (int)div64_u64((uint64_t)rate * 207 (uint64_t)adjustment + 500000, 1000000); 208 rate_adjusted = rate + delta; 209 210 /* Adjusted rate should never be == 0 */ 211 if (!rate_adjusted) 212 return -EINVAL; 213 214 ret = clk_set_rate(player->clk, rate_adjusted); 215 if (ret < 0) 216 return ret; 217 218 rate_achieved = clk_get_rate(player->clk); 219 if (!rate_achieved) 220 /* If value is 0 means that clock or parent not valid */ 221 return -EINVAL; 222 223 /* 224 * Using ALSA's adjustment control, we can modify the rate to be up 225 * to twice as much as requested, but no more 226 */ 227 delta = rate_achieved - rate; 228 if (delta < 0) { 229 /* div64_64 operates on unsigned values... */ 230 delta = -delta; 231 adjustment = -1; 232 } else { 233 adjustment = 1; 234 } 235 /* Frequency/2 is added to round up result */ 236 adjustment *= (int)div64_u64((uint64_t)delta * 1000000 + rate / 2, 237 rate); 238 player->clk_adj = adjustment; 239 return 0; 240 } 241 242 static void uni_player_set_channel_status(struct uniperif *player, 243 struct snd_pcm_runtime *runtime) 244 { 245 int n; 246 unsigned int status; 247 248 /* 249 * Some AVRs and TVs require the channel status to contain a correct 250 * sampling frequency. If no sample rate is already specified, then 251 * set one. 252 */ 253 mutex_lock(&player->ctrl_lock); 254 if (runtime && (player->stream_settings.iec958.status[3] 255 == IEC958_AES3_CON_FS_NOTID)) { 256 switch (runtime->rate) { 257 case 22050: 258 player->stream_settings.iec958.status[3] = 259 IEC958_AES3_CON_FS_22050; 260 break; 261 case 44100: 262 player->stream_settings.iec958.status[3] = 263 IEC958_AES3_CON_FS_44100; 264 break; 265 case 88200: 266 player->stream_settings.iec958.status[3] = 267 IEC958_AES3_CON_FS_88200; 268 break; 269 case 176400: 270 player->stream_settings.iec958.status[3] = 271 IEC958_AES3_CON_FS_176400; 272 break; 273 case 24000: 274 player->stream_settings.iec958.status[3] = 275 IEC958_AES3_CON_FS_24000; 276 break; 277 case 48000: 278 player->stream_settings.iec958.status[3] = 279 IEC958_AES3_CON_FS_48000; 280 break; 281 case 96000: 282 player->stream_settings.iec958.status[3] = 283 IEC958_AES3_CON_FS_96000; 284 break; 285 case 192000: 286 player->stream_settings.iec958.status[3] = 287 IEC958_AES3_CON_FS_192000; 288 break; 289 case 32000: 290 player->stream_settings.iec958.status[3] = 291 IEC958_AES3_CON_FS_32000; 292 break; 293 default: 294 /* Mark as sampling frequency not indicated */ 295 player->stream_settings.iec958.status[3] = 296 IEC958_AES3_CON_FS_NOTID; 297 break; 298 } 299 } 300 301 /* Audio mode: 302 * Use audio mode status to select PCM or encoded mode 303 */ 304 if (player->stream_settings.iec958.status[0] & IEC958_AES0_NONAUDIO) 305 player->stream_settings.encoding_mode = 306 UNIPERIF_IEC958_ENCODING_MODE_ENCODED; 307 else 308 player->stream_settings.encoding_mode = 309 UNIPERIF_IEC958_ENCODING_MODE_PCM; 310 311 if (player->stream_settings.encoding_mode == 312 UNIPERIF_IEC958_ENCODING_MODE_PCM) 313 /* Clear user validity bits */ 314 SET_UNIPERIF_USER_VALIDITY_VALIDITY_LR(player, 0); 315 else 316 /* Set user validity bits */ 317 SET_UNIPERIF_USER_VALIDITY_VALIDITY_LR(player, 1); 318 319 /* Program the new channel status */ 320 for (n = 0; n < 6; ++n) { 321 status = 322 player->stream_settings.iec958.status[0 + (n * 4)] & 0xf; 323 status |= 324 player->stream_settings.iec958.status[1 + (n * 4)] << 8; 325 status |= 326 player->stream_settings.iec958.status[2 + (n * 4)] << 16; 327 status |= 328 player->stream_settings.iec958.status[3 + (n * 4)] << 24; 329 SET_UNIPERIF_CHANNEL_STA_REGN(player, n, status); 330 } 331 mutex_unlock(&player->ctrl_lock); 332 333 /* Update the channel status */ 334 if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) 335 SET_UNIPERIF_CONFIG_CHL_STS_UPDATE(player); 336 else 337 SET_UNIPERIF_BIT_CONTROL_CHL_STS_UPDATE(player); 338 } 339 340 static int uni_player_prepare_iec958(struct uniperif *player, 341 struct snd_pcm_runtime *runtime) 342 { 343 int clk_div; 344 345 clk_div = player->mclk / runtime->rate; 346 347 /* Oversampling must be multiple of 128 as iec958 frame is 32-bits */ 348 if ((clk_div % 128) || (clk_div <= 0)) { 349 dev_err(player->dev, "%s: invalid clk_div %d", 350 __func__, clk_div); 351 return -EINVAL; 352 } 353 354 switch (runtime->format) { 355 case SNDRV_PCM_FORMAT_S16_LE: 356 /* 16/16 memory format */ 357 SET_UNIPERIF_CONFIG_MEM_FMT_16_16(player); 358 /* 16-bits per sub-frame */ 359 SET_UNIPERIF_I2S_FMT_NBIT_32(player); 360 /* Set 16-bit sample precision */ 361 SET_UNIPERIF_I2S_FMT_DATA_SIZE_16(player); 362 break; 363 case SNDRV_PCM_FORMAT_S32_LE: 364 /* 16/0 memory format */ 365 SET_UNIPERIF_CONFIG_MEM_FMT_16_0(player); 366 /* 32-bits per sub-frame */ 367 SET_UNIPERIF_I2S_FMT_NBIT_32(player); 368 /* Set 24-bit sample precision */ 369 SET_UNIPERIF_I2S_FMT_DATA_SIZE_24(player); 370 break; 371 default: 372 dev_err(player->dev, "format not supported"); 373 return -EINVAL; 374 } 375 376 /* Set parity to be calculated by the hardware */ 377 SET_UNIPERIF_CONFIG_PARITY_CNTR_BY_HW(player); 378 379 /* Set channel status bits to be inserted by the hardware */ 380 SET_UNIPERIF_CONFIG_CHANNEL_STA_CNTR_BY_HW(player); 381 382 /* Set user data bits to be inserted by the hardware */ 383 SET_UNIPERIF_CONFIG_USER_DAT_CNTR_BY_HW(player); 384 385 /* Set validity bits to be inserted by the hardware */ 386 SET_UNIPERIF_CONFIG_VALIDITY_DAT_CNTR_BY_HW(player); 387 388 /* Set full software control to disabled */ 389 SET_UNIPERIF_CONFIG_SPDIF_SW_CTRL_DISABLE(player); 390 391 SET_UNIPERIF_CTRL_ZERO_STUFF_HW(player); 392 393 /* Update the channel status */ 394 uni_player_set_channel_status(player, runtime); 395 396 /* Clear the user validity user bits */ 397 SET_UNIPERIF_USER_VALIDITY_VALIDITY_LR(player, 0); 398 399 /* Disable one-bit audio mode */ 400 SET_UNIPERIF_CONFIG_ONE_BIT_AUD_DISABLE(player); 401 402 /* Enable consecutive frames repetition of Z preamble (not for HBRA) */ 403 SET_UNIPERIF_CONFIG_REPEAT_CHL_STS_ENABLE(player); 404 405 /* Change to SUF0_SUBF1 and left/right channels swap! */ 406 SET_UNIPERIF_CONFIG_SUBFRAME_SEL_SUBF1_SUBF0(player); 407 408 /* Set data output as MSB first */ 409 SET_UNIPERIF_I2S_FMT_ORDER_MSB(player); 410 411 if (player->stream_settings.encoding_mode == 412 UNIPERIF_IEC958_ENCODING_MODE_ENCODED) 413 SET_UNIPERIF_CTRL_EXIT_STBY_ON_EOBLOCK_ON(player); 414 else 415 SET_UNIPERIF_CTRL_EXIT_STBY_ON_EOBLOCK_OFF(player); 416 417 SET_UNIPERIF_I2S_FMT_NUM_CH(player, runtime->channels / 2); 418 419 /* Set rounding to off */ 420 SET_UNIPERIF_CTRL_ROUNDING_OFF(player); 421 422 /* Set clock divisor */ 423 SET_UNIPERIF_CTRL_DIVIDER(player, clk_div / 128); 424 425 /* Set the spdif latency to not wait before starting player */ 426 SET_UNIPERIF_CTRL_SPDIF_LAT_OFF(player); 427 428 /* 429 * Ensure iec958 formatting is off. It will be enabled in function 430 * uni_player_start() at the same time as the operation 431 * mode is set to work around a silicon issue. 432 */ 433 if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) 434 SET_UNIPERIF_CTRL_SPDIF_FMT_OFF(player); 435 else 436 SET_UNIPERIF_CTRL_SPDIF_FMT_ON(player); 437 438 return 0; 439 } 440 441 static int uni_player_prepare_pcm(struct uniperif *player, 442 struct snd_pcm_runtime *runtime) 443 { 444 int output_frame_size, slot_width, clk_div; 445 446 /* Force slot width to 32 in I2S mode (HW constraint) */ 447 if ((player->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) == 448 SND_SOC_DAIFMT_I2S) { 449 slot_width = 32; 450 } else { 451 switch (runtime->format) { 452 case SNDRV_PCM_FORMAT_S16_LE: 453 slot_width = 16; 454 break; 455 default: 456 slot_width = 32; 457 break; 458 } 459 } 460 output_frame_size = slot_width * runtime->channels; 461 462 clk_div = player->mclk / runtime->rate; 463 /* 464 * For 32 bits subframe clk_div must be a multiple of 128, 465 * for 16 bits must be a multiple of 64 466 */ 467 if ((slot_width == 32) && (clk_div % 128)) { 468 dev_err(player->dev, "%s: invalid clk_div", __func__); 469 return -EINVAL; 470 } 471 472 if ((slot_width == 16) && (clk_div % 64)) { 473 dev_err(player->dev, "%s: invalid clk_div", __func__); 474 return -EINVAL; 475 } 476 477 /* 478 * Number of bits per subframe (which is one channel sample) 479 * on output - Transfer 16 or 32 bits from FIFO 480 */ 481 switch (slot_width) { 482 case 32: 483 SET_UNIPERIF_I2S_FMT_NBIT_32(player); 484 SET_UNIPERIF_I2S_FMT_DATA_SIZE_32(player); 485 break; 486 case 16: 487 SET_UNIPERIF_I2S_FMT_NBIT_16(player); 488 SET_UNIPERIF_I2S_FMT_DATA_SIZE_16(player); 489 break; 490 default: 491 dev_err(player->dev, "subframe format not supported"); 492 return -EINVAL; 493 } 494 495 /* Configure data memory format */ 496 switch (runtime->format) { 497 case SNDRV_PCM_FORMAT_S16_LE: 498 /* One data word contains two samples */ 499 SET_UNIPERIF_CONFIG_MEM_FMT_16_16(player); 500 break; 501 502 case SNDRV_PCM_FORMAT_S32_LE: 503 /* 504 * Actually "16 bits/0 bits" means "32/28/24/20/18/16 bits 505 * on the left than zeros (if less than 32 bytes)"... ;-) 506 */ 507 SET_UNIPERIF_CONFIG_MEM_FMT_16_0(player); 508 break; 509 510 default: 511 dev_err(player->dev, "format not supported"); 512 return -EINVAL; 513 } 514 515 /* Set rounding to off */ 516 SET_UNIPERIF_CTRL_ROUNDING_OFF(player); 517 518 /* Set clock divisor */ 519 SET_UNIPERIF_CTRL_DIVIDER(player, clk_div / (2 * output_frame_size)); 520 521 /* Number of channelsmust be even*/ 522 if ((runtime->channels % 2) || (runtime->channels < 2) || 523 (runtime->channels > 10)) { 524 dev_err(player->dev, "%s: invalid nb of channels", __func__); 525 return -EINVAL; 526 } 527 528 SET_UNIPERIF_I2S_FMT_NUM_CH(player, runtime->channels / 2); 529 530 /* Set 1-bit audio format to disabled */ 531 SET_UNIPERIF_CONFIG_ONE_BIT_AUD_DISABLE(player); 532 533 SET_UNIPERIF_I2S_FMT_ORDER_MSB(player); 534 SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player); 535 536 /* No iec958 formatting as outputting to DAC */ 537 SET_UNIPERIF_CTRL_SPDIF_FMT_OFF(player); 538 539 return 0; 540 } 541 542 /* 543 * ALSA uniperipheral iec958 controls 544 */ 545 static int uni_player_ctl_iec958_info(struct snd_kcontrol *kcontrol, 546 struct snd_ctl_elem_info *uinfo) 547 { 548 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 549 uinfo->count = 1; 550 551 return 0; 552 } 553 554 static int uni_player_ctl_iec958_get(struct snd_kcontrol *kcontrol, 555 struct snd_ctl_elem_value *ucontrol) 556 { 557 struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol); 558 struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); 559 struct uniperif *player = priv->dai_data.uni; 560 struct snd_aes_iec958 *iec958 = &player->stream_settings.iec958; 561 562 mutex_lock(&player->ctrl_lock); 563 ucontrol->value.iec958.status[0] = iec958->status[0]; 564 ucontrol->value.iec958.status[1] = iec958->status[1]; 565 ucontrol->value.iec958.status[2] = iec958->status[2]; 566 ucontrol->value.iec958.status[3] = iec958->status[3]; 567 mutex_unlock(&player->ctrl_lock); 568 return 0; 569 } 570 571 static int uni_player_ctl_iec958_put(struct snd_kcontrol *kcontrol, 572 struct snd_ctl_elem_value *ucontrol) 573 { 574 struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol); 575 struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); 576 struct uniperif *player = priv->dai_data.uni; 577 struct snd_aes_iec958 *iec958 = &player->stream_settings.iec958; 578 579 mutex_lock(&player->ctrl_lock); 580 iec958->status[0] = ucontrol->value.iec958.status[0]; 581 iec958->status[1] = ucontrol->value.iec958.status[1]; 582 iec958->status[2] = ucontrol->value.iec958.status[2]; 583 iec958->status[3] = ucontrol->value.iec958.status[3]; 584 mutex_unlock(&player->ctrl_lock); 585 586 uni_player_set_channel_status(player, NULL); 587 588 return 0; 589 } 590 591 static struct snd_kcontrol_new uni_player_iec958_ctl = { 592 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 593 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT), 594 .info = uni_player_ctl_iec958_info, 595 .get = uni_player_ctl_iec958_get, 596 .put = uni_player_ctl_iec958_put, 597 }; 598 599 /* 600 * uniperif rate adjustement control 601 */ 602 static int snd_sti_clk_adjustment_info(struct snd_kcontrol *kcontrol, 603 struct snd_ctl_elem_info *uinfo) 604 { 605 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 606 uinfo->count = 1; 607 uinfo->value.integer.min = UNIPERIF_PLAYER_CLK_ADJ_MIN; 608 uinfo->value.integer.max = UNIPERIF_PLAYER_CLK_ADJ_MAX; 609 uinfo->value.integer.step = 1; 610 611 return 0; 612 } 613 614 static int snd_sti_clk_adjustment_get(struct snd_kcontrol *kcontrol, 615 struct snd_ctl_elem_value *ucontrol) 616 { 617 struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol); 618 struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); 619 struct uniperif *player = priv->dai_data.uni; 620 621 mutex_lock(&player->ctrl_lock); 622 ucontrol->value.integer.value[0] = player->clk_adj; 623 mutex_unlock(&player->ctrl_lock); 624 625 return 0; 626 } 627 628 static int snd_sti_clk_adjustment_put(struct snd_kcontrol *kcontrol, 629 struct snd_ctl_elem_value *ucontrol) 630 { 631 struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol); 632 struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); 633 struct uniperif *player = priv->dai_data.uni; 634 int ret = 0; 635 636 if ((ucontrol->value.integer.value[0] < UNIPERIF_PLAYER_CLK_ADJ_MIN) || 637 (ucontrol->value.integer.value[0] > UNIPERIF_PLAYER_CLK_ADJ_MAX)) 638 return -EINVAL; 639 640 mutex_lock(&player->ctrl_lock); 641 player->clk_adj = ucontrol->value.integer.value[0]; 642 643 if (player->mclk) 644 ret = uni_player_clk_set_rate(player, player->mclk); 645 mutex_unlock(&player->ctrl_lock); 646 647 return ret; 648 } 649 650 static struct snd_kcontrol_new uni_player_clk_adj_ctl = { 651 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 652 .name = "PCM Playback Oversampling Freq. Adjustment", 653 .info = snd_sti_clk_adjustment_info, 654 .get = snd_sti_clk_adjustment_get, 655 .put = snd_sti_clk_adjustment_put, 656 }; 657 658 static struct snd_kcontrol_new *snd_sti_pcm_ctl[] = { 659 &uni_player_clk_adj_ctl, 660 }; 661 662 static struct snd_kcontrol_new *snd_sti_iec_ctl[] = { 663 &uni_player_iec958_ctl, 664 &uni_player_clk_adj_ctl, 665 }; 666 667 static int uni_player_startup(struct snd_pcm_substream *substream, 668 struct snd_soc_dai *dai) 669 { 670 struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); 671 struct uniperif *player = priv->dai_data.uni; 672 player->substream = substream; 673 674 player->clk_adj = 0; 675 676 return 0; 677 } 678 679 static int uni_player_set_sysclk(struct snd_soc_dai *dai, int clk_id, 680 unsigned int freq, int dir) 681 { 682 struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); 683 struct uniperif *player = priv->dai_data.uni; 684 int ret; 685 686 if (dir == SND_SOC_CLOCK_IN) 687 return 0; 688 689 if (clk_id != 0) 690 return -EINVAL; 691 692 mutex_lock(&player->ctrl_lock); 693 ret = uni_player_clk_set_rate(player, freq); 694 if (!ret) 695 player->mclk = freq; 696 mutex_unlock(&player->ctrl_lock); 697 698 return ret; 699 } 700 701 static int uni_player_prepare(struct snd_pcm_substream *substream, 702 struct snd_soc_dai *dai) 703 { 704 struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); 705 struct uniperif *player = priv->dai_data.uni; 706 struct snd_pcm_runtime *runtime = substream->runtime; 707 int transfer_size, trigger_limit; 708 int ret; 709 710 /* The player should be stopped */ 711 if (player->state != UNIPERIF_STATE_STOPPED) { 712 dev_err(player->dev, "%s: invalid player state %d", __func__, 713 player->state); 714 return -EINVAL; 715 } 716 717 /* Calculate transfer size (in fifo cells and bytes) for frame count */ 718 transfer_size = runtime->channels * UNIPERIF_FIFO_FRAMES; 719 720 /* Calculate number of empty cells available before asserting DREQ */ 721 if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) { 722 trigger_limit = UNIPERIF_FIFO_SIZE - transfer_size; 723 } else { 724 /* 725 * Since SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0 726 * FDMA_TRIGGER_LIMIT also controls when the state switches 727 * from OFF or STANDBY to AUDIO DATA. 728 */ 729 trigger_limit = transfer_size; 730 } 731 732 /* Trigger limit must be an even number */ 733 if ((!trigger_limit % 2) || (trigger_limit != 1 && transfer_size % 2) || 734 (trigger_limit > UNIPERIF_CONFIG_DMA_TRIG_LIMIT_MASK(player))) { 735 dev_err(player->dev, "invalid trigger limit %d", trigger_limit); 736 return -EINVAL; 737 } 738 739 SET_UNIPERIF_CONFIG_DMA_TRIG_LIMIT(player, trigger_limit); 740 741 /* Uniperipheral setup depends on player type */ 742 switch (player->info->player_type) { 743 case SND_ST_UNIPERIF_PLAYER_TYPE_HDMI: 744 ret = uni_player_prepare_iec958(player, runtime); 745 break; 746 case SND_ST_UNIPERIF_PLAYER_TYPE_PCM: 747 ret = uni_player_prepare_pcm(player, runtime); 748 break; 749 case SND_ST_UNIPERIF_PLAYER_TYPE_SPDIF: 750 ret = uni_player_prepare_iec958(player, runtime); 751 break; 752 default: 753 dev_err(player->dev, "invalid player type"); 754 return -EINVAL; 755 } 756 757 if (ret) 758 return ret; 759 760 switch (player->daifmt & SND_SOC_DAIFMT_INV_MASK) { 761 case SND_SOC_DAIFMT_NB_NF: 762 SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player); 763 SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player); 764 break; 765 case SND_SOC_DAIFMT_NB_IF: 766 SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player); 767 SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player); 768 break; 769 case SND_SOC_DAIFMT_IB_NF: 770 SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player); 771 SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player); 772 break; 773 case SND_SOC_DAIFMT_IB_IF: 774 SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player); 775 SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player); 776 break; 777 } 778 779 switch (player->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) { 780 case SND_SOC_DAIFMT_I2S: 781 SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player); 782 SET_UNIPERIF_I2S_FMT_PADDING_I2S_MODE(player); 783 break; 784 case SND_SOC_DAIFMT_LEFT_J: 785 SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player); 786 SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player); 787 break; 788 case SND_SOC_DAIFMT_RIGHT_J: 789 SET_UNIPERIF_I2S_FMT_ALIGN_RIGHT(player); 790 SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player); 791 break; 792 default: 793 dev_err(player->dev, "format not supported"); 794 return -EINVAL; 795 } 796 797 SET_UNIPERIF_I2S_FMT_NO_OF_SAMPLES_TO_READ(player, 0); 798 799 /* Reset uniperipheral player */ 800 SET_UNIPERIF_SOFT_RST_SOFT_RST(player); 801 802 return reset_player(player); 803 } 804 805 static int uni_player_start(struct uniperif *player) 806 { 807 int ret; 808 809 /* The player should be stopped */ 810 if (player->state != UNIPERIF_STATE_STOPPED) { 811 dev_err(player->dev, "%s: invalid player state", __func__); 812 return -EINVAL; 813 } 814 815 ret = clk_prepare_enable(player->clk); 816 if (ret) { 817 dev_err(player->dev, "%s: Failed to enable clock", __func__); 818 return ret; 819 } 820 821 /* Clear any pending interrupts */ 822 SET_UNIPERIF_ITS_BCLR(player, GET_UNIPERIF_ITS(player)); 823 824 /* Set the interrupt mask */ 825 SET_UNIPERIF_ITM_BSET_DMA_ERROR(player); 826 SET_UNIPERIF_ITM_BSET_FIFO_ERROR(player); 827 828 /* Enable underflow recovery interrupts */ 829 if (player->info->underflow_enabled) { 830 SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_DONE(player); 831 SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_FAILED(player); 832 } 833 834 /* Reset uniperipheral player */ 835 SET_UNIPERIF_SOFT_RST_SOFT_RST(player); 836 837 ret = reset_player(player); 838 if (ret < 0) 839 return ret; 840 841 /* 842 * Does not use IEC61937 features of the uniperipheral hardware. 843 * Instead it performs IEC61937 in software and inserts it directly 844 * into the audio data stream. As such, when encoded mode is selected, 845 * linear pcm mode is still used, but with the differences of the 846 * channel status bits set for encoded mode and the validity bits set. 847 */ 848 SET_UNIPERIF_CTRL_OPERATION_PCM_DATA(player); 849 850 /* 851 * If iec958 formatting is required for hdmi or spdif, then it must be 852 * enabled after the operation mode is set. If set prior to this, it 853 * will not take affect and hang the player. 854 */ 855 if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) 856 if (UNIPERIF_PLAYER_TYPE_IS_IEC958(player)) 857 SET_UNIPERIF_CTRL_SPDIF_FMT_ON(player); 858 859 /* Force channel status update (no update if clk disable) */ 860 if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) 861 SET_UNIPERIF_CONFIG_CHL_STS_UPDATE(player); 862 else 863 SET_UNIPERIF_BIT_CONTROL_CHL_STS_UPDATE(player); 864 865 /* Update state to started */ 866 player->state = UNIPERIF_STATE_STARTED; 867 868 return 0; 869 } 870 871 static int uni_player_stop(struct uniperif *player) 872 { 873 int ret; 874 875 /* The player should not be in stopped state */ 876 if (player->state == UNIPERIF_STATE_STOPPED) { 877 dev_err(player->dev, "%s: invalid player state", __func__); 878 return -EINVAL; 879 } 880 881 /* Turn the player off */ 882 SET_UNIPERIF_CTRL_OPERATION_OFF(player); 883 884 /* Soft reset the player */ 885 SET_UNIPERIF_SOFT_RST_SOFT_RST(player); 886 887 ret = reset_player(player); 888 if (ret < 0) 889 return ret; 890 891 /* Disable interrupts */ 892 SET_UNIPERIF_ITM_BCLR(player, GET_UNIPERIF_ITM(player)); 893 894 /* Disable clock */ 895 clk_disable_unprepare(player->clk); 896 897 /* Update state to stopped and return */ 898 player->state = UNIPERIF_STATE_STOPPED; 899 900 return 0; 901 } 902 903 int uni_player_resume(struct uniperif *player) 904 { 905 int ret; 906 907 /* Select the frequency synthesizer clock */ 908 if (player->clk_sel) { 909 ret = regmap_field_write(player->clk_sel, 1); 910 if (ret) { 911 dev_err(player->dev, 912 "%s: Failed to select freq synth clock", 913 __func__); 914 return ret; 915 } 916 } 917 918 SET_UNIPERIF_CONFIG_BACK_STALL_REQ_DISABLE(player); 919 SET_UNIPERIF_CTRL_ROUNDING_OFF(player); 920 SET_UNIPERIF_CTRL_SPDIF_LAT_OFF(player); 921 SET_UNIPERIF_CONFIG_IDLE_MOD_DISABLE(player); 922 923 return 0; 924 } 925 EXPORT_SYMBOL_GPL(uni_player_resume); 926 927 static int uni_player_trigger(struct snd_pcm_substream *substream, 928 int cmd, struct snd_soc_dai *dai) 929 { 930 struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); 931 struct uniperif *player = priv->dai_data.uni; 932 933 switch (cmd) { 934 case SNDRV_PCM_TRIGGER_START: 935 return uni_player_start(player); 936 case SNDRV_PCM_TRIGGER_STOP: 937 return uni_player_stop(player); 938 case SNDRV_PCM_TRIGGER_RESUME: 939 return uni_player_resume(player); 940 default: 941 return -EINVAL; 942 } 943 } 944 945 static void uni_player_shutdown(struct snd_pcm_substream *substream, 946 struct snd_soc_dai *dai) 947 { 948 struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); 949 struct uniperif *player = priv->dai_data.uni; 950 951 if (player->state != UNIPERIF_STATE_STOPPED) 952 /* Stop the player */ 953 uni_player_stop(player); 954 955 player->substream = NULL; 956 } 957 958 static int uni_player_parse_dt_clk_glue(struct platform_device *pdev, 959 struct uniperif *player) 960 { 961 int bit_offset; 962 struct device_node *node = pdev->dev.of_node; 963 struct regmap *regmap; 964 965 bit_offset = SYS_CFG_AUDI0_GLUE_PCM_CLKX + player->info->id; 966 967 regmap = syscon_regmap_lookup_by_phandle(node, "st,syscfg"); 968 969 if (regmap) { 970 struct reg_field regfield = 971 REG_FIELD(SYS_CFG_AUDIO_GLUE, bit_offset, bit_offset); 972 973 player->clk_sel = regmap_field_alloc(regmap, regfield); 974 } else { 975 dev_err(&pdev->dev, "sti-audio-clk-glue syscf not found\n"); 976 return -EINVAL; 977 } 978 979 return 0; 980 } 981 982 static int uni_player_parse_dt(struct platform_device *pdev, 983 struct uniperif *player) 984 { 985 struct uniperif_info *info; 986 struct device *dev = &pdev->dev; 987 struct device_node *pnode = pdev->dev.of_node; 988 const char *mode; 989 990 /* Allocate memory for the info structure */ 991 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL); 992 if (!info) 993 return -ENOMEM; 994 995 if (of_property_read_u32(pnode, "st,version", &player->ver) || 996 player->ver == SND_ST_UNIPERIF_VERSION_UNKNOWN) { 997 dev_err(dev, "Unknown uniperipheral version "); 998 return -EINVAL; 999 } 1000 /* Underflow recovery is only supported on later ip revisions */ 1001 if (player->ver >= SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) 1002 info->underflow_enabled = 1; 1003 1004 if (of_property_read_u32(pnode, "st,uniperiph-id", &info->id)) { 1005 dev_err(dev, "uniperipheral id not defined"); 1006 return -EINVAL; 1007 } 1008 1009 /* Read the device mode property */ 1010 if (of_property_read_string(pnode, "st,mode", &mode)) { 1011 dev_err(dev, "uniperipheral mode not defined"); 1012 return -EINVAL; 1013 } 1014 1015 if (strcasecmp(mode, "hdmi") == 0) 1016 info->player_type = SND_ST_UNIPERIF_PLAYER_TYPE_HDMI; 1017 else if (strcasecmp(mode, "pcm") == 0) 1018 info->player_type = SND_ST_UNIPERIF_PLAYER_TYPE_PCM; 1019 else if (strcasecmp(mode, "spdif") == 0) 1020 info->player_type = SND_ST_UNIPERIF_PLAYER_TYPE_SPDIF; 1021 else 1022 info->player_type = SND_ST_UNIPERIF_PLAYER_TYPE_NONE; 1023 1024 /* Save the info structure */ 1025 player->info = info; 1026 1027 /* Get the PCM_CLK_SEL bit from audio-glue-ctrl SoC register */ 1028 if (uni_player_parse_dt_clk_glue(pdev, player)) 1029 return -EINVAL; 1030 1031 return 0; 1032 } 1033 1034 static const struct snd_soc_dai_ops uni_player_dai_ops = { 1035 .startup = uni_player_startup, 1036 .shutdown = uni_player_shutdown, 1037 .prepare = uni_player_prepare, 1038 .trigger = uni_player_trigger, 1039 .hw_params = sti_uniperiph_dai_hw_params, 1040 .set_fmt = sti_uniperiph_dai_set_fmt, 1041 .set_sysclk = uni_player_set_sysclk 1042 }; 1043 1044 int uni_player_init(struct platform_device *pdev, 1045 struct uniperif *player) 1046 { 1047 int ret = 0; 1048 1049 player->dev = &pdev->dev; 1050 player->state = UNIPERIF_STATE_STOPPED; 1051 player->hw = &uni_player_pcm_hw; 1052 player->dai_ops = &uni_player_dai_ops; 1053 1054 ret = uni_player_parse_dt(pdev, player); 1055 1056 if (ret < 0) { 1057 dev_err(player->dev, "Failed to parse DeviceTree"); 1058 return ret; 1059 } 1060 1061 /* Get uniperif resource */ 1062 player->clk = of_clk_get(pdev->dev.of_node, 0); 1063 if (IS_ERR(player->clk)) 1064 ret = PTR_ERR(player->clk); 1065 1066 /* Select the frequency synthesizer clock */ 1067 if (player->clk_sel) { 1068 ret = regmap_field_write(player->clk_sel, 1); 1069 if (ret) { 1070 dev_err(player->dev, 1071 "%s: Failed to select freq synth clock", 1072 __func__); 1073 return ret; 1074 } 1075 } 1076 1077 ret = devm_request_irq(&pdev->dev, player->irq, 1078 uni_player_irq_handler, IRQF_SHARED, 1079 dev_name(&pdev->dev), player); 1080 if (ret < 0) 1081 return ret; 1082 1083 mutex_init(&player->ctrl_lock); 1084 1085 /* Ensure that disabled by default */ 1086 SET_UNIPERIF_CONFIG_BACK_STALL_REQ_DISABLE(player); 1087 SET_UNIPERIF_CTRL_ROUNDING_OFF(player); 1088 SET_UNIPERIF_CTRL_SPDIF_LAT_OFF(player); 1089 SET_UNIPERIF_CONFIG_IDLE_MOD_DISABLE(player); 1090 1091 if (UNIPERIF_PLAYER_TYPE_IS_IEC958(player)) { 1092 /* Set default iec958 status bits */ 1093 1094 /* Consumer, PCM, copyright, 2ch, mode 0 */ 1095 player->stream_settings.iec958.status[0] = 0x00; 1096 /* Broadcast reception category */ 1097 player->stream_settings.iec958.status[1] = 1098 IEC958_AES1_CON_GENERAL; 1099 /* Do not take into account source or channel number */ 1100 player->stream_settings.iec958.status[2] = 1101 IEC958_AES2_CON_SOURCE_UNSPEC; 1102 /* Sampling frequency not indicated */ 1103 player->stream_settings.iec958.status[3] = 1104 IEC958_AES3_CON_FS_NOTID; 1105 /* Max sample word 24-bit, sample word length not indicated */ 1106 player->stream_settings.iec958.status[4] = 1107 IEC958_AES4_CON_MAX_WORDLEN_24 | 1108 IEC958_AES4_CON_WORDLEN_24_20; 1109 1110 player->num_ctrls = ARRAY_SIZE(snd_sti_iec_ctl); 1111 player->snd_ctrls = snd_sti_iec_ctl[0]; 1112 } else { 1113 player->num_ctrls = ARRAY_SIZE(snd_sti_pcm_ctl); 1114 player->snd_ctrls = snd_sti_pcm_ctl[0]; 1115 } 1116 1117 return 0; 1118 } 1119 EXPORT_SYMBOL_GPL(uni_player_init); 1120