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->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->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         if (player->substream && player->substream->runtime)
 618                 uni_player_set_channel_status(player,
 619                                               player->substream->runtime);
 620         else
 621                 uni_player_set_channel_status(player, NULL);
 622
 623         return 0;
 624 }
 625
 626 static struct snd_kcontrol_new uni_player_iec958_ctl = {
 627         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
 628         .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
 629         .info = uni_player_ctl_iec958_info,
 630         .get = uni_player_ctl_iec958_get,
 631         .put = uni_player_ctl_iec958_put,
 632 };
 633
 634 /*
 635  * uniperif rate adjustement control
 636  */
 637 static int snd_sti_clk_adjustment_info(struct snd_kcontrol *kcontrol,
 638                                        struct snd_ctl_elem_info *uinfo)
 639 {
 640         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 641         uinfo->count = 1;
 642         uinfo->value.integer.min = UNIPERIF_PLAYER_CLK_ADJ_MIN;
 643         uinfo->value.integer.max = UNIPERIF_PLAYER_CLK_ADJ_MAX;
 644         uinfo->value.integer.step = 1;
 645
 646         return 0;
 647 }
 648
 649 static int snd_sti_clk_adjustment_get(struct snd_kcontrol *kcontrol,
 650                                       struct snd_ctl_elem_value *ucontrol)
 651 {
 652         struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol);
 653         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 654         struct uniperif *player = priv->dai_data.uni;
 655
 656         mutex_lock(&player->ctrl_lock);
 657         ucontrol->value.integer.value[0] = player->clk_adj;
 658         mutex_unlock(&player->ctrl_lock);
 659
 660         return 0;
 661 }
 662
 663 static int snd_sti_clk_adjustment_put(struct snd_kcontrol *kcontrol,
 664                                       struct snd_ctl_elem_value *ucontrol)
 665 {
 666         struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol);
 667         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 668         struct uniperif *player = priv->dai_data.uni;
 669         int ret = 0;
 670
 671         if ((ucontrol->value.integer.value[0] < UNIPERIF_PLAYER_CLK_ADJ_MIN) ||
 672             (ucontrol->value.integer.value[0] > UNIPERIF_PLAYER_CLK_ADJ_MAX))
 673                 return -EINVAL;
 674
 675         mutex_lock(&player->ctrl_lock);
 676         player->clk_adj = ucontrol->value.integer.value[0];
 677
 678         if (player->mclk)
 679                 ret = uni_player_clk_set_rate(player, player->mclk);
 680         mutex_unlock(&player->ctrl_lock);
 681
 682         return ret;
 683 }
 684
 685 static struct snd_kcontrol_new uni_player_clk_adj_ctl = {
 686         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
 687         .name = "PCM Playback Oversampling Freq. Adjustment",
 688         .info = snd_sti_clk_adjustment_info,
 689         .get = snd_sti_clk_adjustment_get,
 690         .put = snd_sti_clk_adjustment_put,
 691 };
 692
 693 static struct snd_kcontrol_new *snd_sti_pcm_ctl[] = {
 694         &uni_player_clk_adj_ctl,
 695 };
 696
 697 static struct snd_kcontrol_new *snd_sti_iec_ctl[] = {
 698         &uni_player_iec958_ctl,
 699         &uni_player_clk_adj_ctl,
 700 };
 701
 702 static int uni_player_startup(struct snd_pcm_substream *substream,
 703                               struct snd_soc_dai *dai)
 704 {
 705         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 706         struct uniperif *player = priv->dai_data.uni;
 707         int ret;
 708
 709         player->substream = substream;
 710
 711         player->clk_adj = 0;
 712
 713         if (!UNIPERIF_TYPE_IS_TDM(player))
 714                 return 0;
 715
 716         /* refine hw constraint in tdm mode */
 717         ret = snd_pcm_hw_rule_add(substream->runtime, 0,
 718                                   SNDRV_PCM_HW_PARAM_CHANNELS,
 719                                   sti_uniperiph_fix_tdm_chan,
 720                                   player, SNDRV_PCM_HW_PARAM_CHANNELS,
 721                                   -1);
 722         if (ret < 0)
 723                 return ret;
 724
 725         return snd_pcm_hw_rule_add(substream->runtime, 0,
 726                                    SNDRV_PCM_HW_PARAM_FORMAT,
 727                                    sti_uniperiph_fix_tdm_format,
 728                                    player, SNDRV_PCM_HW_PARAM_FORMAT,
 729                                    -1);
 730 }
 731
 732 static int uni_player_set_sysclk(struct snd_soc_dai *dai, int clk_id,
 733                                  unsigned int freq, int dir)
 734 {
 735         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 736         struct uniperif *player = priv->dai_data.uni;
 737         int ret;
 738
 739         if (UNIPERIF_TYPE_IS_TDM(player) || (dir == SND_SOC_CLOCK_IN))
 740                 return 0;
 741
 742         if (clk_id != 0)
 743                 return -EINVAL;
 744
 745         mutex_lock(&player->ctrl_lock);
 746         ret = uni_player_clk_set_rate(player, freq);
 747         if (!ret)
 748                 player->mclk = freq;
 749         mutex_unlock(&player->ctrl_lock);
 750
 751         return ret;
 752 }
 753
 754 static int uni_player_prepare(struct snd_pcm_substream *substream,
 755                               struct snd_soc_dai *dai)
 756 {
 757         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 758         struct uniperif *player = priv->dai_data.uni;
 759         struct snd_pcm_runtime *runtime = substream->runtime;
 760         int transfer_size, trigger_limit;
 761         int ret;
 762
 763         /* The player should be stopped */
 764         if (player->state != UNIPERIF_STATE_STOPPED) {
 765                 dev_err(player->dev, "%s: invalid player state %d", __func__,
 766                         player->state);
 767                 return -EINVAL;
 768         }
 769
 770         /* Calculate transfer size (in fifo cells and bytes) for frame count */
 771         if (player->type == SND_ST_UNIPERIF_TYPE_TDM) {
 772                 /* transfer size = user frame size (in 32 bits FIFO cell) */
 773                 transfer_size =
 774                         sti_uniperiph_get_user_frame_size(runtime) / 4;
 775         } else {
 776                 transfer_size = runtime->channels * UNIPERIF_FIFO_FRAMES;
 777         }
 778
 779         /* Calculate number of empty cells available before asserting DREQ */
 780         if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) {
 781                 trigger_limit = UNIPERIF_FIFO_SIZE - transfer_size;
 782         } else {
 783                 /*
 784                  * Since SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0
 785                  * FDMA_TRIGGER_LIMIT also controls when the state switches
 786                  * from OFF or STANDBY to AUDIO DATA.
 787                  */
 788                 trigger_limit = transfer_size;
 789         }
 790
 791         /* Trigger limit must be an even number */
 792         if ((!trigger_limit % 2) || (trigger_limit != 1 && transfer_size % 2) ||
 793             (trigger_limit > UNIPERIF_CONFIG_DMA_TRIG_LIMIT_MASK(player))) {
 794                 dev_err(player->dev, "invalid trigger limit %d", trigger_limit);
 795                 return -EINVAL;
 796         }
 797
 798         SET_UNIPERIF_CONFIG_DMA_TRIG_LIMIT(player, trigger_limit);
 799
 800         /* Uniperipheral setup depends on player type */
 801         switch (player->type) {
 802         case SND_ST_UNIPERIF_TYPE_HDMI:
 803                 ret = uni_player_prepare_iec958(player, runtime);
 804                 break;
 805         case SND_ST_UNIPERIF_TYPE_PCM:
 806                 ret = uni_player_prepare_pcm(player, runtime);
 807                 break;
 808         case SND_ST_UNIPERIF_TYPE_SPDIF:
 809                 ret = uni_player_prepare_iec958(player, runtime);
 810                 break;
 811         case SND_ST_UNIPERIF_TYPE_TDM:
 812                 ret = uni_player_prepare_tdm(player, runtime);
 813                 break;
 814         default:
 815                 dev_err(player->dev, "invalid player type");
 816                 return -EINVAL;
 817         }
 818
 819         if (ret)
 820                 return ret;
 821
 822         switch (player->daifmt & SND_SOC_DAIFMT_INV_MASK) {
 823         case SND_SOC_DAIFMT_NB_NF:
 824                 SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player);
 825                 SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player);
 826                 break;
 827         case SND_SOC_DAIFMT_NB_IF:
 828                 SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player);
 829                 SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player);
 830                 break;
 831         case SND_SOC_DAIFMT_IB_NF:
 832                 SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player);
 833                 SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player);
 834                 break;
 835         case SND_SOC_DAIFMT_IB_IF:
 836                 SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player);
 837                 SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player);
 838                 break;
 839         }
 840
 841         switch (player->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 842         case SND_SOC_DAIFMT_I2S:
 843                 SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player);
 844                 SET_UNIPERIF_I2S_FMT_PADDING_I2S_MODE(player);
 845                 break;
 846         case SND_SOC_DAIFMT_LEFT_J:
 847                 SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player);
 848                 SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player);
 849                 break;
 850         case SND_SOC_DAIFMT_RIGHT_J:
 851                 SET_UNIPERIF_I2S_FMT_ALIGN_RIGHT(player);
 852                 SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player);
 853                 break;
 854         default:
 855                 dev_err(player->dev, "format not supported");
 856                 return -EINVAL;
 857         }
 858
 859         SET_UNIPERIF_I2S_FMT_NO_OF_SAMPLES_TO_READ(player, 0);
 860
 861         /* Reset uniperipheral player */
 862         SET_UNIPERIF_SOFT_RST_SOFT_RST(player);
 863
 864         return reset_player(player);
 865 }
 866
 867 static int uni_player_start(struct uniperif *player)
 868 {
 869         int ret;
 870
 871         /* The player should be stopped */
 872         if (player->state != UNIPERIF_STATE_STOPPED) {
 873                 dev_err(player->dev, "%s: invalid player state", __func__);
 874                 return -EINVAL;
 875         }
 876
 877         ret = clk_prepare_enable(player->clk);
 878         if (ret) {
 879                 dev_err(player->dev, "%s: Failed to enable clock", __func__);
 880                 return ret;
 881         }
 882
 883         /* Clear any pending interrupts */
 884         SET_UNIPERIF_ITS_BCLR(player, GET_UNIPERIF_ITS(player));
 885
 886         /* Set the interrupt mask */
 887         SET_UNIPERIF_ITM_BSET_DMA_ERROR(player);
 888         SET_UNIPERIF_ITM_BSET_FIFO_ERROR(player);
 889
 890         /* Enable underflow recovery interrupts */
 891         if (player->underflow_enabled) {
 892                 SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_DONE(player);
 893                 SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_FAILED(player);
 894         }
 895
 896         /* Reset uniperipheral player */
 897         SET_UNIPERIF_SOFT_RST_SOFT_RST(player);
 898
 899         ret = reset_player(player);
 900         if (ret < 0) {
 901                 clk_disable_unprepare(player->clk);
 902                 return ret;
 903         }
 904
 905         /*
 906          * Does not use IEC61937 features of the uniperipheral hardware.
 907          * Instead it performs IEC61937 in software and inserts it directly
 908          * into the audio data stream. As such, when encoded mode is selected,
 909          * linear pcm mode is still used, but with the differences of the
 910          * channel status bits set for encoded mode and the validity bits set.
 911          */
 912         SET_UNIPERIF_CTRL_OPERATION_PCM_DATA(player);
 913
 914         /*
 915          * If iec958 formatting is required for hdmi or spdif, then it must be
 916          * enabled after the operation mode is set. If set prior to this, it
 917          * will not take affect and hang the player.
 918          */
 919         if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
 920                 if (UNIPERIF_TYPE_IS_IEC958(player))
 921                         SET_UNIPERIF_CTRL_SPDIF_FMT_ON(player);
 922
 923         /* Force channel status update (no update if clk disable) */
 924         if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
 925                 SET_UNIPERIF_CONFIG_CHL_STS_UPDATE(player);
 926         else
 927                 SET_UNIPERIF_BIT_CONTROL_CHL_STS_UPDATE(player);
 928
 929         /* Update state to started */
 930         player->state = UNIPERIF_STATE_STARTED;
 931
 932         return 0;
 933 }
 934
 935 static int uni_player_stop(struct uniperif *player)
 936 {
 937         int ret;
 938
 939         /* The player should not be in stopped state */
 940         if (player->state == UNIPERIF_STATE_STOPPED) {
 941                 dev_err(player->dev, "%s: invalid player state", __func__);
 942                 return -EINVAL;
 943         }
 944
 945         /* Turn the player off */
 946         SET_UNIPERIF_CTRL_OPERATION_OFF(player);
 947
 948         /* Soft reset the player */
 949         SET_UNIPERIF_SOFT_RST_SOFT_RST(player);
 950
 951         ret = reset_player(player);
 952         if (ret < 0)
 953                 return ret;
 954
 955         /* Disable interrupts */
 956         SET_UNIPERIF_ITM_BCLR(player, GET_UNIPERIF_ITM(player));
 957
 958         /* Disable clock */
 959         clk_disable_unprepare(player->clk);
 960
 961         /* Update state to stopped and return */
 962         player->state = UNIPERIF_STATE_STOPPED;
 963
 964         return 0;
 965 }
 966
 967 int uni_player_resume(struct uniperif *player)
 968 {
 969         int ret;
 970
 971         /* Select the frequency synthesizer clock */
 972         if (player->clk_sel) {
 973                 ret = regmap_field_write(player->clk_sel, 1);
 974                 if (ret) {
 975                         dev_err(player->dev,
 976                                 "%s: Failed to select freq synth clock",
 977                                 __func__);
 978                         return ret;
 979                 }
 980         }
 981
 982         SET_UNIPERIF_CONFIG_BACK_STALL_REQ_DISABLE(player);
 983         SET_UNIPERIF_CTRL_ROUNDING_OFF(player);
 984         SET_UNIPERIF_CTRL_SPDIF_LAT_OFF(player);
 985         SET_UNIPERIF_CONFIG_IDLE_MOD_DISABLE(player);
 986
 987         return 0;
 988 }
 989 EXPORT_SYMBOL_GPL(uni_player_resume);
 990
 991 static int uni_player_trigger(struct snd_pcm_substream *substream,
 992                               int cmd, struct snd_soc_dai *dai)
 993 {
 994         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 995         struct uniperif *player = priv->dai_data.uni;
 996
 997         switch (cmd) {
 998         case SNDRV_PCM_TRIGGER_START:
 999                 return uni_player_start(player);
1000         case SNDRV_PCM_TRIGGER_STOP:
1001                 return uni_player_stop(player);
1002         case SNDRV_PCM_TRIGGER_RESUME:
1003                 return uni_player_resume(player);
1004         default:
1005                 return -EINVAL;
1006         }
1007 }
1008
1009 static void uni_player_shutdown(struct snd_pcm_substream *substream,
1010                                 struct snd_soc_dai *dai)
1011 {
1012         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
1013         struct uniperif *player = priv->dai_data.uni;
1014
1015         if (player->state != UNIPERIF_STATE_STOPPED)
1016                 /* Stop the player */
1017                 uni_player_stop(player);
1018
1019         player->substream = NULL;
1020 }
1021
1022 static int uni_player_parse_dt_audio_glue(struct platform_device *pdev,
1023                                           struct uniperif *player)
1024 {
1025         struct device_node *node = pdev->dev.of_node;
1026         struct regmap *regmap;
1027         struct reg_field regfield[2] = {
1028                 /* PCM_CLK_SEL */
1029                 REG_FIELD(SYS_CFG_AUDIO_GLUE,
1030                           8 + player->id,
1031                           8 + player->id),
1032                 /* PCMP_VALID_SEL */
1033                 REG_FIELD(SYS_CFG_AUDIO_GLUE, 0, 1)
1034         };
1035
1036         regmap = syscon_regmap_lookup_by_phandle(node, "st,syscfg");
1037
1038         if (IS_ERR(regmap)) {
1039                 dev_err(&pdev->dev, "sti-audio-clk-glue syscf not found\n");
1040                 return PTR_ERR(regmap);
1041         }
1042
1043         player->clk_sel = regmap_field_alloc(regmap, regfield[0]);
1044         player->valid_sel = regmap_field_alloc(regmap, regfield[1]);
1045
1046         return 0;
1047 }
1048
1049 static const struct snd_soc_dai_ops uni_player_dai_ops = {
1050                 .startup = uni_player_startup,
1051                 .shutdown = uni_player_shutdown,
1052                 .prepare = uni_player_prepare,
1053                 .trigger = uni_player_trigger,
1054                 .hw_params = sti_uniperiph_dai_hw_params,
1055                 .set_fmt = sti_uniperiph_dai_set_fmt,
1056                 .set_sysclk = uni_player_set_sysclk,
1057                 .set_tdm_slot = sti_uniperiph_set_tdm_slot
1058 };
1059
1060 int uni_player_init(struct platform_device *pdev,
1061                     struct uniperif *player)
1062 {
1063         int ret = 0;
1064
1065         player->dev = &pdev->dev;
1066         player->state = UNIPERIF_STATE_STOPPED;
1067         player->dai_ops = &uni_player_dai_ops;
1068
1069         /* Get PCM_CLK_SEL & PCMP_VALID_SEL from audio-glue-ctrl SoC reg */
1070         ret = uni_player_parse_dt_audio_glue(pdev, player);
1071
1072         if (ret < 0) {
1073                 dev_err(player->dev, "Failed to parse DeviceTree");
1074                 return ret;
1075         }
1076
1077         /* Underflow recovery is only supported on later ip revisions */
1078         if (player->ver >= SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
1079                 player->underflow_enabled = 1;
1080
1081         if (UNIPERIF_TYPE_IS_TDM(player))
1082                 player->hw = &uni_tdm_hw;
1083         else
1084                 player->hw = &uni_player_pcm_hw;
1085
1086         /* Get uniperif resource */
1087         player->clk = of_clk_get(pdev->dev.of_node, 0);
1088         if (IS_ERR(player->clk))
1089                 ret = PTR_ERR(player->clk);
1090
1091         /* Select the frequency synthesizer clock */
1092         if (player->clk_sel) {
1093                 ret = regmap_field_write(player->clk_sel, 1);
1094                 if (ret) {
1095                         dev_err(player->dev,
1096                                 "%s: Failed to select freq synth clock",
1097                                 __func__);
1098                         return ret;
1099                 }
1100         }
1101
1102         /* connect to I2S/TDM TX bus */
1103         if (player->valid_sel &&
1104             (player->id == UNIPERIF_PLAYER_I2S_OUT)) {
1105                 ret = regmap_field_write(player->valid_sel, player->id);
1106                 if (ret) {
1107                         dev_err(player->dev,
1108                                 "%s: unable to connect to tdm bus", __func__);
1109                         return ret;
1110                 }
1111         }
1112
1113         ret = devm_request_irq(&pdev->dev, player->irq,
1114                                uni_player_irq_handler, IRQF_SHARED,
1115                                dev_name(&pdev->dev), player);
1116         if (ret < 0)
1117                 return ret;
1118
1119         mutex_init(&player->ctrl_lock);
1120
1121         /* Ensure that disabled by default */
1122         SET_UNIPERIF_CONFIG_BACK_STALL_REQ_DISABLE(player);
1123         SET_UNIPERIF_CTRL_ROUNDING_OFF(player);
1124         SET_UNIPERIF_CTRL_SPDIF_LAT_OFF(player);
1125         SET_UNIPERIF_CONFIG_IDLE_MOD_DISABLE(player);
1126
1127         if (UNIPERIF_TYPE_IS_IEC958(player)) {
1128                 /* Set default iec958 status bits  */
1129
1130                 /* Consumer, PCM, copyright, 2ch, mode 0 */
1131                 player->stream_settings.iec958.status[0] = 0x00;
1132                 /* Broadcast reception category */
1133                 player->stream_settings.iec958.status[1] =
1134                                         IEC958_AES1_CON_GENERAL;
1135                 /* Do not take into account source or channel number */
1136                 player->stream_settings.iec958.status[2] =
1137                                         IEC958_AES2_CON_SOURCE_UNSPEC;
1138                 /* Sampling frequency not indicated */
1139                 player->stream_settings.iec958.status[3] =
1140                                         IEC958_AES3_CON_FS_NOTID;
1141                 /* Max sample word 24-bit, sample word length not indicated */
1142                 player->stream_settings.iec958.status[4] =
1143                                         IEC958_AES4_CON_MAX_WORDLEN_24 |
1144                                         IEC958_AES4_CON_WORDLEN_24_20;
1145
1146                 player->num_ctrls = ARRAY_SIZE(snd_sti_iec_ctl);
1147                 player->snd_ctrls = snd_sti_iec_ctl[0];
1148         } else {
1149                 player->num_ctrls = ARRAY_SIZE(snd_sti_pcm_ctl);
1150                 player->snd_ctrls = snd_sti_pcm_ctl[0];
1151         }
1152
1153         return 0;
1154 }
1155 EXPORT_SYMBOL_GPL(uni_player_init);