sound/soc/sti/uniperif_player.c

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