Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) STMicroelectronics SA 2015
0004  * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
0005  *          for STMicroelectronics.
0006  */
0007 
0008 #include <linux/clk.h>
0009 #include <linux/mfd/syscon.h>
0010 
0011 #include <sound/asoundef.h>
0012 #include <sound/soc.h>
0013 
0014 #include "uniperif.h"
0015 
0016 /*
0017  * Some hardware-related definitions
0018  */
0019 
0020 /* sys config registers definitions */
0021 #define SYS_CFG_AUDIO_GLUE 0xA4
0022 
0023 /*
0024  * Driver specific types.
0025  */
0026 
0027 #define UNIPERIF_PLAYER_CLK_ADJ_MIN  -999999
0028 #define UNIPERIF_PLAYER_CLK_ADJ_MAX  1000000
0029 #define UNIPERIF_PLAYER_I2S_OUT 1 /* player id connected to I2S/TDM TX bus */
0030 
0031 /*
0032  * Note: snd_pcm_hardware is linked to DMA controller but is declared here to
0033  * integrate  DAI_CPU capability in term of rate and supported channels
0034  */
0035 static const struct snd_pcm_hardware uni_player_pcm_hw = {
0036     .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
0037         SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_MMAP |
0038         SNDRV_PCM_INFO_MMAP_VALID,
0039     .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE,
0040 
0041     .rates = SNDRV_PCM_RATE_CONTINUOUS,
0042     .rate_min = 8000,
0043     .rate_max = 192000,
0044 
0045     .channels_min = 2,
0046     .channels_max = 8,
0047 
0048     .periods_min = 2,
0049     .periods_max = 48,
0050 
0051     .period_bytes_min = 128,
0052     .period_bytes_max = 64 * PAGE_SIZE,
0053     .buffer_bytes_max = 256 * PAGE_SIZE
0054 };
0055 
0056 /*
0057  * uni_player_irq_handler
0058  * In case of error audio stream is stopped; stop action is protected via PCM
0059  * stream lock to avoid race condition with trigger callback.
0060  */
0061 static irqreturn_t uni_player_irq_handler(int irq, void *dev_id)
0062 {
0063     irqreturn_t ret = IRQ_NONE;
0064     struct uniperif *player = dev_id;
0065     unsigned int status;
0066     unsigned int tmp;
0067 
0068     spin_lock(&player->irq_lock);
0069     if (!player->substream)
0070         goto irq_spin_unlock;
0071 
0072     snd_pcm_stream_lock(player->substream);
0073     if (player->state == UNIPERIF_STATE_STOPPED)
0074         goto stream_unlock;
0075 
0076     /* Get interrupt status & clear them immediately */
0077     status = GET_UNIPERIF_ITS(player);
0078     SET_UNIPERIF_ITS_BCLR(player, status);
0079 
0080     /* Check for fifo error (underrun) */
0081     if (unlikely(status & UNIPERIF_ITS_FIFO_ERROR_MASK(player))) {
0082         dev_err(player->dev, "FIFO underflow error detected\n");
0083 
0084         /* Interrupt is just for information when underflow recovery */
0085         if (player->underflow_enabled) {
0086             /* Update state to underflow */
0087             player->state = UNIPERIF_STATE_UNDERFLOW;
0088 
0089         } else {
0090             /* Disable interrupt so doesn't continually fire */
0091             SET_UNIPERIF_ITM_BCLR_FIFO_ERROR(player);
0092 
0093             /* Stop the player */
0094             snd_pcm_stop(player->substream, SNDRV_PCM_STATE_XRUN);
0095         }
0096 
0097         ret = IRQ_HANDLED;
0098     }
0099 
0100     /* Check for dma error (overrun) */
0101     if (unlikely(status & UNIPERIF_ITS_DMA_ERROR_MASK(player))) {
0102         dev_err(player->dev, "DMA error detected\n");
0103 
0104         /* Disable interrupt so doesn't continually fire */
0105         SET_UNIPERIF_ITM_BCLR_DMA_ERROR(player);
0106 
0107         /* Stop the player */
0108         snd_pcm_stop(player->substream, SNDRV_PCM_STATE_XRUN);
0109 
0110         ret = IRQ_HANDLED;
0111     }
0112 
0113     /* Check for underflow recovery done */
0114     if (unlikely(status & UNIPERIF_ITM_UNDERFLOW_REC_DONE_MASK(player))) {
0115         if (!player->underflow_enabled) {
0116             dev_err(player->dev,
0117                 "unexpected Underflow recovering\n");
0118             ret = -EPERM;
0119             goto stream_unlock;
0120         }
0121         /* Read the underflow recovery duration */
0122         tmp = GET_UNIPERIF_STATUS_1_UNDERFLOW_DURATION(player);
0123         dev_dbg(player->dev, "Underflow recovered (%d LR clocks max)\n",
0124             tmp);
0125 
0126         /* Clear the underflow recovery duration */
0127         SET_UNIPERIF_BIT_CONTROL_CLR_UNDERFLOW_DURATION(player);
0128 
0129         /* Update state to started */
0130         player->state = UNIPERIF_STATE_STARTED;
0131 
0132         ret = IRQ_HANDLED;
0133     }
0134 
0135     /* Check if underflow recovery failed */
0136     if (unlikely(status &
0137              UNIPERIF_ITM_UNDERFLOW_REC_FAILED_MASK(player))) {
0138         dev_err(player->dev, "Underflow recovery failed\n");
0139 
0140         /* Stop the player */
0141         snd_pcm_stop(player->substream, SNDRV_PCM_STATE_XRUN);
0142 
0143         ret = IRQ_HANDLED;
0144     }
0145 
0146 stream_unlock:
0147     snd_pcm_stream_unlock(player->substream);
0148 irq_spin_unlock:
0149     spin_unlock(&player->irq_lock);
0150 
0151     return ret;
0152 }
0153 
0154 static int uni_player_clk_set_rate(struct uniperif *player, unsigned long rate)
0155 {
0156     int rate_adjusted, rate_achieved, delta, ret;
0157     int adjustment = player->clk_adj;
0158 
0159     /*
0160      *             a
0161      * F = f + --------- * f = f + d
0162      *          1000000
0163      *
0164      *         a
0165      * d = --------- * f
0166      *      1000000
0167      *
0168      * where:
0169      *   f - nominal rate
0170      *   a - adjustment in ppm (parts per milion)
0171      *   F - rate to be set in synthesizer
0172      *   d - delta (difference) between f and F
0173      */
0174     if (adjustment < 0) {
0175         /* div64_64 operates on unsigned values... */
0176         delta = -1;
0177         adjustment = -adjustment;
0178     } else {
0179         delta = 1;
0180     }
0181     /* 500000 ppm is 0.5, which is used to round up values */
0182     delta *= (int)div64_u64((uint64_t)rate *
0183                 (uint64_t)adjustment + 500000, 1000000);
0184     rate_adjusted = rate + delta;
0185 
0186     /* Adjusted rate should never be == 0 */
0187     if (!rate_adjusted)
0188         return -EINVAL;
0189 
0190     ret = clk_set_rate(player->clk, rate_adjusted);
0191     if (ret < 0)
0192         return ret;
0193 
0194     rate_achieved = clk_get_rate(player->clk);
0195     if (!rate_achieved)
0196         /* If value is 0 means that clock or parent not valid */
0197         return -EINVAL;
0198 
0199     /*
0200      * Using ALSA's adjustment control, we can modify the rate to be up
0201      * to twice as much as requested, but no more
0202      */
0203     delta = rate_achieved - rate;
0204     if (delta < 0) {
0205         /* div64_64 operates on unsigned values... */
0206         delta = -delta;
0207         adjustment = -1;
0208     } else {
0209         adjustment = 1;
0210     }
0211     /* Frequency/2 is added to round up result */
0212     adjustment *= (int)div64_u64((uint64_t)delta * 1000000 + rate / 2,
0213                      rate);
0214     player->clk_adj = adjustment;
0215     return 0;
0216 }
0217 
0218 static void uni_player_set_channel_status(struct uniperif *player,
0219                       struct snd_pcm_runtime *runtime)
0220 {
0221     int n;
0222     unsigned int status;
0223 
0224     /*
0225      * Some AVRs and TVs require the channel status to contain a correct
0226      * sampling frequency. If no sample rate is already specified, then
0227      * set one.
0228      */
0229     if (runtime) {
0230         switch (runtime->rate) {
0231         case 22050:
0232             player->stream_settings.iec958.status[3] =
0233                         IEC958_AES3_CON_FS_22050;
0234             break;
0235         case 44100:
0236             player->stream_settings.iec958.status[3] =
0237                         IEC958_AES3_CON_FS_44100;
0238             break;
0239         case 88200:
0240             player->stream_settings.iec958.status[3] =
0241                         IEC958_AES3_CON_FS_88200;
0242             break;
0243         case 176400:
0244             player->stream_settings.iec958.status[3] =
0245                         IEC958_AES3_CON_FS_176400;
0246             break;
0247         case 24000:
0248             player->stream_settings.iec958.status[3] =
0249                         IEC958_AES3_CON_FS_24000;
0250             break;
0251         case 48000:
0252             player->stream_settings.iec958.status[3] =
0253                         IEC958_AES3_CON_FS_48000;
0254             break;
0255         case 96000:
0256             player->stream_settings.iec958.status[3] =
0257                         IEC958_AES3_CON_FS_96000;
0258             break;
0259         case 192000:
0260             player->stream_settings.iec958.status[3] =
0261                         IEC958_AES3_CON_FS_192000;
0262             break;
0263         case 32000:
0264             player->stream_settings.iec958.status[3] =
0265                         IEC958_AES3_CON_FS_32000;
0266             break;
0267         default:
0268             /* Mark as sampling frequency not indicated */
0269             player->stream_settings.iec958.status[3] =
0270                         IEC958_AES3_CON_FS_NOTID;
0271             break;
0272         }
0273     }
0274 
0275     /* Audio mode:
0276      * Use audio mode status to select PCM or encoded mode
0277      */
0278     if (player->stream_settings.iec958.status[0] & IEC958_AES0_NONAUDIO)
0279         player->stream_settings.encoding_mode =
0280             UNIPERIF_IEC958_ENCODING_MODE_ENCODED;
0281     else
0282         player->stream_settings.encoding_mode =
0283             UNIPERIF_IEC958_ENCODING_MODE_PCM;
0284 
0285     if (player->stream_settings.encoding_mode ==
0286         UNIPERIF_IEC958_ENCODING_MODE_PCM)
0287         /* Clear user validity bits */
0288         SET_UNIPERIF_USER_VALIDITY_VALIDITY_LR(player, 0);
0289     else
0290         /* Set user validity bits */
0291         SET_UNIPERIF_USER_VALIDITY_VALIDITY_LR(player, 1);
0292 
0293     /* Program the new channel status */
0294     for (n = 0; n < 6; ++n) {
0295         status  =
0296         player->stream_settings.iec958.status[0 + (n * 4)] & 0xf;
0297         status |=
0298         player->stream_settings.iec958.status[1 + (n * 4)] << 8;
0299         status |=
0300         player->stream_settings.iec958.status[2 + (n * 4)] << 16;
0301         status |=
0302         player->stream_settings.iec958.status[3 + (n * 4)] << 24;
0303         SET_UNIPERIF_CHANNEL_STA_REGN(player, n, status);
0304     }
0305 
0306     /* Update the channel status */
0307     if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
0308         SET_UNIPERIF_CONFIG_CHL_STS_UPDATE(player);
0309     else
0310         SET_UNIPERIF_BIT_CONTROL_CHL_STS_UPDATE(player);
0311 }
0312 
0313 static int uni_player_prepare_iec958(struct uniperif *player,
0314                      struct snd_pcm_runtime *runtime)
0315 {
0316     int clk_div;
0317 
0318     clk_div = player->mclk / runtime->rate;
0319 
0320     /* Oversampling must be multiple of 128 as iec958 frame is 32-bits */
0321     if ((clk_div % 128) || (clk_div <= 0)) {
0322         dev_err(player->dev, "%s: invalid clk_div %d\n",
0323             __func__, clk_div);
0324         return -EINVAL;
0325     }
0326 
0327     switch (runtime->format) {
0328     case SNDRV_PCM_FORMAT_S16_LE:
0329         /* 16/16 memory format */
0330         SET_UNIPERIF_CONFIG_MEM_FMT_16_16(player);
0331         /* 16-bits per sub-frame */
0332         SET_UNIPERIF_I2S_FMT_NBIT_32(player);
0333         /* Set 16-bit sample precision */
0334         SET_UNIPERIF_I2S_FMT_DATA_SIZE_16(player);
0335         break;
0336     case SNDRV_PCM_FORMAT_S32_LE:
0337         /* 16/0 memory format */
0338         SET_UNIPERIF_CONFIG_MEM_FMT_16_0(player);
0339         /* 32-bits per sub-frame */
0340         SET_UNIPERIF_I2S_FMT_NBIT_32(player);
0341         /* Set 24-bit sample precision */
0342         SET_UNIPERIF_I2S_FMT_DATA_SIZE_24(player);
0343         break;
0344     default:
0345         dev_err(player->dev, "format not supported\n");
0346         return -EINVAL;
0347     }
0348 
0349     /* Set parity to be calculated by the hardware */
0350     SET_UNIPERIF_CONFIG_PARITY_CNTR_BY_HW(player);
0351 
0352     /* Set channel status bits to be inserted by the hardware */
0353     SET_UNIPERIF_CONFIG_CHANNEL_STA_CNTR_BY_HW(player);
0354 
0355     /* Set user data bits to be inserted by the hardware */
0356     SET_UNIPERIF_CONFIG_USER_DAT_CNTR_BY_HW(player);
0357 
0358     /* Set validity bits to be inserted by the hardware */
0359     SET_UNIPERIF_CONFIG_VALIDITY_DAT_CNTR_BY_HW(player);
0360 
0361     /* Set full software control to disabled */
0362     SET_UNIPERIF_CONFIG_SPDIF_SW_CTRL_DISABLE(player);
0363 
0364     SET_UNIPERIF_CTRL_ZERO_STUFF_HW(player);
0365 
0366     mutex_lock(&player->ctrl_lock);
0367     /* Update the channel status */
0368     uni_player_set_channel_status(player, runtime);
0369     mutex_unlock(&player->ctrl_lock);
0370 
0371     /* Clear the user validity user bits */
0372     SET_UNIPERIF_USER_VALIDITY_VALIDITY_LR(player, 0);
0373 
0374     /* Disable one-bit audio mode */
0375     SET_UNIPERIF_CONFIG_ONE_BIT_AUD_DISABLE(player);
0376 
0377     /* Enable consecutive frames repetition of Z preamble (not for HBRA) */
0378     SET_UNIPERIF_CONFIG_REPEAT_CHL_STS_ENABLE(player);
0379 
0380     /* Change to SUF0_SUBF1 and left/right channels swap! */
0381     SET_UNIPERIF_CONFIG_SUBFRAME_SEL_SUBF1_SUBF0(player);
0382 
0383     /* Set data output as MSB first */
0384     SET_UNIPERIF_I2S_FMT_ORDER_MSB(player);
0385 
0386     if (player->stream_settings.encoding_mode ==
0387                 UNIPERIF_IEC958_ENCODING_MODE_ENCODED)
0388         SET_UNIPERIF_CTRL_EXIT_STBY_ON_EOBLOCK_ON(player);
0389     else
0390         SET_UNIPERIF_CTRL_EXIT_STBY_ON_EOBLOCK_OFF(player);
0391 
0392     SET_UNIPERIF_I2S_FMT_NUM_CH(player, runtime->channels / 2);
0393 
0394     /* Set rounding to off */
0395     SET_UNIPERIF_CTRL_ROUNDING_OFF(player);
0396 
0397     /* Set clock divisor */
0398     SET_UNIPERIF_CTRL_DIVIDER(player, clk_div / 128);
0399 
0400     /* Set the spdif latency to not wait before starting player */
0401     SET_UNIPERIF_CTRL_SPDIF_LAT_OFF(player);
0402 
0403     /*
0404      * Ensure iec958 formatting is off. It will be enabled in function
0405      * uni_player_start() at the same time as the operation
0406      * mode is set to work around a silicon issue.
0407      */
0408     if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
0409         SET_UNIPERIF_CTRL_SPDIF_FMT_OFF(player);
0410     else
0411         SET_UNIPERIF_CTRL_SPDIF_FMT_ON(player);
0412 
0413     return 0;
0414 }
0415 
0416 static int uni_player_prepare_pcm(struct uniperif *player,
0417                   struct snd_pcm_runtime *runtime)
0418 {
0419     int output_frame_size, slot_width, clk_div;
0420 
0421     /* Force slot width to 32 in I2S mode (HW constraint) */
0422     if ((player->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) ==
0423         SND_SOC_DAIFMT_I2S)
0424         slot_width = 32;
0425     else
0426         slot_width = snd_pcm_format_width(runtime->format);
0427 
0428     output_frame_size = slot_width * runtime->channels;
0429 
0430     clk_div = player->mclk / runtime->rate;
0431     /*
0432      * For 32 bits subframe clk_div must be a multiple of 128,
0433      * for 16 bits must be a multiple of 64
0434      */
0435     if ((slot_width == 32) && (clk_div % 128)) {
0436         dev_err(player->dev, "%s: invalid clk_div\n", __func__);
0437         return -EINVAL;
0438     }
0439 
0440     if ((slot_width == 16) && (clk_div % 64)) {
0441         dev_err(player->dev, "%s: invalid clk_div\n", __func__);
0442         return -EINVAL;
0443     }
0444 
0445     /*
0446      * Number of bits per subframe (which is one channel sample)
0447      * on output - Transfer 16 or 32 bits from FIFO
0448      */
0449     switch (slot_width) {
0450     case 32:
0451         SET_UNIPERIF_I2S_FMT_NBIT_32(player);
0452         SET_UNIPERIF_I2S_FMT_DATA_SIZE_32(player);
0453         break;
0454     case 16:
0455         SET_UNIPERIF_I2S_FMT_NBIT_16(player);
0456         SET_UNIPERIF_I2S_FMT_DATA_SIZE_16(player);
0457         break;
0458     default:
0459         dev_err(player->dev, "subframe format not supported\n");
0460         return -EINVAL;
0461     }
0462 
0463     /* Configure data memory format */
0464     switch (runtime->format) {
0465     case SNDRV_PCM_FORMAT_S16_LE:
0466         /* One data word contains two samples */
0467         SET_UNIPERIF_CONFIG_MEM_FMT_16_16(player);
0468         break;
0469 
0470     case SNDRV_PCM_FORMAT_S32_LE:
0471         /*
0472          * Actually "16 bits/0 bits" means "32/28/24/20/18/16 bits
0473          * on the left than zeros (if less than 32 bytes)"... ;-)
0474          */
0475         SET_UNIPERIF_CONFIG_MEM_FMT_16_0(player);
0476         break;
0477 
0478     default:
0479         dev_err(player->dev, "format not supported\n");
0480         return -EINVAL;
0481     }
0482 
0483     /* Set rounding to off */
0484     SET_UNIPERIF_CTRL_ROUNDING_OFF(player);
0485 
0486     /* Set clock divisor */
0487     SET_UNIPERIF_CTRL_DIVIDER(player, clk_div / (2 * output_frame_size));
0488 
0489     /* Number of channelsmust be even*/
0490     if ((runtime->channels % 2) || (runtime->channels < 2) ||
0491         (runtime->channels > 10)) {
0492         dev_err(player->dev, "%s: invalid nb of channels\n", __func__);
0493         return -EINVAL;
0494     }
0495 
0496     SET_UNIPERIF_I2S_FMT_NUM_CH(player, runtime->channels / 2);
0497 
0498     /* Set 1-bit audio format to disabled */
0499     SET_UNIPERIF_CONFIG_ONE_BIT_AUD_DISABLE(player);
0500 
0501     SET_UNIPERIF_I2S_FMT_ORDER_MSB(player);
0502 
0503     /* No iec958 formatting as outputting to DAC  */
0504     SET_UNIPERIF_CTRL_SPDIF_FMT_OFF(player);
0505 
0506     return 0;
0507 }
0508 
0509 static int uni_player_prepare_tdm(struct uniperif *player,
0510                   struct snd_pcm_runtime *runtime)
0511 {
0512     int tdm_frame_size; /* unip tdm frame size in bytes */
0513     int user_frame_size; /* user tdm frame size in bytes */
0514     /* default unip TDM_WORD_POS_X_Y */
0515     unsigned int word_pos[4] = {
0516         0x04060002, 0x0C0E080A, 0x14161012, 0x1C1E181A};
0517     int freq, ret;
0518 
0519     tdm_frame_size =
0520         sti_uniperiph_get_unip_tdm_frame_size(player);
0521     user_frame_size =
0522         sti_uniperiph_get_user_frame_size(runtime);
0523 
0524     /* fix 16/0 format */
0525     SET_UNIPERIF_CONFIG_MEM_FMT_16_0(player);
0526     SET_UNIPERIF_I2S_FMT_DATA_SIZE_32(player);
0527 
0528     /* number of words inserted on the TDM line */
0529     SET_UNIPERIF_I2S_FMT_NUM_CH(player, user_frame_size / 4 / 2);
0530 
0531     SET_UNIPERIF_I2S_FMT_ORDER_MSB(player);
0532     SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player);
0533 
0534     /* Enable the tdm functionality */
0535     SET_UNIPERIF_TDM_ENABLE_TDM_ENABLE(player);
0536 
0537     /* number of 8 bits timeslots avail in unip tdm frame */
0538     SET_UNIPERIF_TDM_FS_REF_DIV_NUM_TIMESLOT(player, tdm_frame_size);
0539 
0540     /* set the timeslot allocation for words in FIFO */
0541     sti_uniperiph_get_tdm_word_pos(player, word_pos);
0542     SET_UNIPERIF_TDM_WORD_POS(player, 1_2, word_pos[WORD_1_2]);
0543     SET_UNIPERIF_TDM_WORD_POS(player, 3_4, word_pos[WORD_3_4]);
0544     SET_UNIPERIF_TDM_WORD_POS(player, 5_6, word_pos[WORD_5_6]);
0545     SET_UNIPERIF_TDM_WORD_POS(player, 7_8, word_pos[WORD_7_8]);
0546 
0547     /* set unip clk rate (not done vai set_sysclk ops) */
0548     freq = runtime->rate * tdm_frame_size * 8;
0549     mutex_lock(&player->ctrl_lock);
0550     ret = uni_player_clk_set_rate(player, freq);
0551     if (!ret)
0552         player->mclk = freq;
0553     mutex_unlock(&player->ctrl_lock);
0554 
0555     return 0;
0556 }
0557 
0558 /*
0559  * ALSA uniperipheral iec958 controls
0560  */
0561 static int  uni_player_ctl_iec958_info(struct snd_kcontrol *kcontrol,
0562                        struct snd_ctl_elem_info *uinfo)
0563 {
0564     uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
0565     uinfo->count = 1;
0566 
0567     return 0;
0568 }
0569 
0570 static int uni_player_ctl_iec958_get(struct snd_kcontrol *kcontrol,
0571                      struct snd_ctl_elem_value *ucontrol)
0572 {
0573     struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol);
0574     struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
0575     struct uniperif *player = priv->dai_data.uni;
0576     struct snd_aes_iec958 *iec958 = &player->stream_settings.iec958;
0577 
0578     mutex_lock(&player->ctrl_lock);
0579     ucontrol->value.iec958.status[0] = iec958->status[0];
0580     ucontrol->value.iec958.status[1] = iec958->status[1];
0581     ucontrol->value.iec958.status[2] = iec958->status[2];
0582     ucontrol->value.iec958.status[3] = iec958->status[3];
0583     mutex_unlock(&player->ctrl_lock);
0584     return 0;
0585 }
0586 
0587 static int uni_player_ctl_iec958_put(struct snd_kcontrol *kcontrol,
0588                      struct snd_ctl_elem_value *ucontrol)
0589 {
0590     struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol);
0591     struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
0592     struct uniperif *player = priv->dai_data.uni;
0593     struct snd_aes_iec958 *iec958 =  &player->stream_settings.iec958;
0594     unsigned long flags;
0595 
0596     mutex_lock(&player->ctrl_lock);
0597     iec958->status[0] = ucontrol->value.iec958.status[0];
0598     iec958->status[1] = ucontrol->value.iec958.status[1];
0599     iec958->status[2] = ucontrol->value.iec958.status[2];
0600     iec958->status[3] = ucontrol->value.iec958.status[3];
0601 
0602     spin_lock_irqsave(&player->irq_lock, flags);
0603     if (player->substream && player->substream->runtime)
0604         uni_player_set_channel_status(player,
0605                           player->substream->runtime);
0606     else
0607         uni_player_set_channel_status(player, NULL);
0608 
0609     spin_unlock_irqrestore(&player->irq_lock, flags);
0610     mutex_unlock(&player->ctrl_lock);
0611 
0612     return 0;
0613 }
0614 
0615 static struct snd_kcontrol_new uni_player_iec958_ctl = {
0616     .iface = SNDRV_CTL_ELEM_IFACE_PCM,
0617     .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
0618     .info = uni_player_ctl_iec958_info,
0619     .get = uni_player_ctl_iec958_get,
0620     .put = uni_player_ctl_iec958_put,
0621 };
0622 
0623 /*
0624  * uniperif rate adjustement control
0625  */
0626 static int snd_sti_clk_adjustment_info(struct snd_kcontrol *kcontrol,
0627                        struct snd_ctl_elem_info *uinfo)
0628 {
0629     uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0630     uinfo->count = 1;
0631     uinfo->value.integer.min = UNIPERIF_PLAYER_CLK_ADJ_MIN;
0632     uinfo->value.integer.max = UNIPERIF_PLAYER_CLK_ADJ_MAX;
0633     uinfo->value.integer.step = 1;
0634 
0635     return 0;
0636 }
0637 
0638 static int snd_sti_clk_adjustment_get(struct snd_kcontrol *kcontrol,
0639                       struct snd_ctl_elem_value *ucontrol)
0640 {
0641     struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol);
0642     struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
0643     struct uniperif *player = priv->dai_data.uni;
0644 
0645     mutex_lock(&player->ctrl_lock);
0646     ucontrol->value.integer.value[0] = player->clk_adj;
0647     mutex_unlock(&player->ctrl_lock);
0648 
0649     return 0;
0650 }
0651 
0652 static int snd_sti_clk_adjustment_put(struct snd_kcontrol *kcontrol,
0653                       struct snd_ctl_elem_value *ucontrol)
0654 {
0655     struct snd_soc_dai *dai = snd_kcontrol_chip(kcontrol);
0656     struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
0657     struct uniperif *player = priv->dai_data.uni;
0658     int ret = 0;
0659 
0660     if ((ucontrol->value.integer.value[0] < UNIPERIF_PLAYER_CLK_ADJ_MIN) ||
0661         (ucontrol->value.integer.value[0] > UNIPERIF_PLAYER_CLK_ADJ_MAX))
0662         return -EINVAL;
0663 
0664     mutex_lock(&player->ctrl_lock);
0665     player->clk_adj = ucontrol->value.integer.value[0];
0666 
0667     if (player->mclk)
0668         ret = uni_player_clk_set_rate(player, player->mclk);
0669     mutex_unlock(&player->ctrl_lock);
0670 
0671     return ret;
0672 }
0673 
0674 static struct snd_kcontrol_new uni_player_clk_adj_ctl = {
0675     .iface = SNDRV_CTL_ELEM_IFACE_PCM,
0676     .name = "PCM Playback Oversampling Freq. Adjustment",
0677     .info = snd_sti_clk_adjustment_info,
0678     .get = snd_sti_clk_adjustment_get,
0679     .put = snd_sti_clk_adjustment_put,
0680 };
0681 
0682 static struct snd_kcontrol_new *snd_sti_pcm_ctl[] = {
0683     &uni_player_clk_adj_ctl,
0684 };
0685 
0686 static struct snd_kcontrol_new *snd_sti_iec_ctl[] = {
0687     &uni_player_iec958_ctl,
0688     &uni_player_clk_adj_ctl,
0689 };
0690 
0691 static int uni_player_startup(struct snd_pcm_substream *substream,
0692                   struct snd_soc_dai *dai)
0693 {
0694     struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
0695     struct uniperif *player = priv->dai_data.uni;
0696     unsigned long flags;
0697     int ret;
0698 
0699     spin_lock_irqsave(&player->irq_lock, flags);
0700     player->substream = substream;
0701     spin_unlock_irqrestore(&player->irq_lock, flags);
0702 
0703     player->clk_adj = 0;
0704 
0705     if (!UNIPERIF_TYPE_IS_TDM(player))
0706         return 0;
0707 
0708     /* refine hw constraint in tdm mode */
0709     ret = snd_pcm_hw_rule_add(substream->runtime, 0,
0710                   SNDRV_PCM_HW_PARAM_CHANNELS,
0711                   sti_uniperiph_fix_tdm_chan,
0712                   player, SNDRV_PCM_HW_PARAM_CHANNELS,
0713                   -1);
0714     if (ret < 0)
0715         return ret;
0716 
0717     return snd_pcm_hw_rule_add(substream->runtime, 0,
0718                    SNDRV_PCM_HW_PARAM_FORMAT,
0719                    sti_uniperiph_fix_tdm_format,
0720                    player, SNDRV_PCM_HW_PARAM_FORMAT,
0721                    -1);
0722 }
0723 
0724 static int uni_player_set_sysclk(struct snd_soc_dai *dai, int clk_id,
0725                  unsigned int freq, int dir)
0726 {
0727     struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
0728     struct uniperif *player = priv->dai_data.uni;
0729     int ret;
0730 
0731     if (UNIPERIF_TYPE_IS_TDM(player) || (dir == SND_SOC_CLOCK_IN))
0732         return 0;
0733 
0734     if (clk_id != 0)
0735         return -EINVAL;
0736 
0737     mutex_lock(&player->ctrl_lock);
0738     ret = uni_player_clk_set_rate(player, freq);
0739     if (!ret)
0740         player->mclk = freq;
0741     mutex_unlock(&player->ctrl_lock);
0742 
0743     return ret;
0744 }
0745 
0746 static int uni_player_prepare(struct snd_pcm_substream *substream,
0747                   struct snd_soc_dai *dai)
0748 {
0749     struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
0750     struct uniperif *player = priv->dai_data.uni;
0751     struct snd_pcm_runtime *runtime = substream->runtime;
0752     int transfer_size, trigger_limit;
0753     int ret;
0754 
0755     /* The player should be stopped */
0756     if (player->state != UNIPERIF_STATE_STOPPED) {
0757         dev_err(player->dev, "%s: invalid player state %d\n", __func__,
0758             player->state);
0759         return -EINVAL;
0760     }
0761 
0762     /* Calculate transfer size (in fifo cells and bytes) for frame count */
0763     if (player->type == SND_ST_UNIPERIF_TYPE_TDM) {
0764         /* transfer size = user frame size (in 32 bits FIFO cell) */
0765         transfer_size =
0766             sti_uniperiph_get_user_frame_size(runtime) / 4;
0767     } else {
0768         transfer_size = runtime->channels * UNIPERIF_FIFO_FRAMES;
0769     }
0770 
0771     /* Calculate number of empty cells available before asserting DREQ */
0772     if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) {
0773         trigger_limit = UNIPERIF_FIFO_SIZE - transfer_size;
0774     } else {
0775         /*
0776          * Since SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0
0777          * FDMA_TRIGGER_LIMIT also controls when the state switches
0778          * from OFF or STANDBY to AUDIO DATA.
0779          */
0780         trigger_limit = transfer_size;
0781     }
0782 
0783     /* Trigger limit must be an even number */
0784     if ((!trigger_limit % 2) || (trigger_limit != 1 && transfer_size % 2) ||
0785         (trigger_limit > UNIPERIF_CONFIG_DMA_TRIG_LIMIT_MASK(player))) {
0786         dev_err(player->dev, "invalid trigger limit %d\n",
0787             trigger_limit);
0788         return -EINVAL;
0789     }
0790 
0791     SET_UNIPERIF_CONFIG_DMA_TRIG_LIMIT(player, trigger_limit);
0792 
0793     /* Uniperipheral setup depends on player type */
0794     switch (player->type) {
0795     case SND_ST_UNIPERIF_TYPE_HDMI:
0796         ret = uni_player_prepare_iec958(player, runtime);
0797         break;
0798     case SND_ST_UNIPERIF_TYPE_PCM:
0799         ret = uni_player_prepare_pcm(player, runtime);
0800         break;
0801     case SND_ST_UNIPERIF_TYPE_SPDIF:
0802         ret = uni_player_prepare_iec958(player, runtime);
0803         break;
0804     case SND_ST_UNIPERIF_TYPE_TDM:
0805         ret = uni_player_prepare_tdm(player, runtime);
0806         break;
0807     default:
0808         dev_err(player->dev, "invalid player type\n");
0809         return -EINVAL;
0810     }
0811 
0812     if (ret)
0813         return ret;
0814 
0815     switch (player->daifmt & SND_SOC_DAIFMT_INV_MASK) {
0816     case SND_SOC_DAIFMT_NB_NF:
0817         SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player);
0818         SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player);
0819         break;
0820     case SND_SOC_DAIFMT_NB_IF:
0821         SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player);
0822         SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player);
0823         break;
0824     case SND_SOC_DAIFMT_IB_NF:
0825         SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player);
0826         SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player);
0827         break;
0828     case SND_SOC_DAIFMT_IB_IF:
0829         SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player);
0830         SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player);
0831         break;
0832     }
0833 
0834     switch (player->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) {
0835     case SND_SOC_DAIFMT_I2S:
0836         SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player);
0837         SET_UNIPERIF_I2S_FMT_PADDING_I2S_MODE(player);
0838         break;
0839     case SND_SOC_DAIFMT_LEFT_J:
0840         SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player);
0841         SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player);
0842         break;
0843     case SND_SOC_DAIFMT_RIGHT_J:
0844         SET_UNIPERIF_I2S_FMT_ALIGN_RIGHT(player);
0845         SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player);
0846         break;
0847     default:
0848         dev_err(player->dev, "format not supported\n");
0849         return -EINVAL;
0850     }
0851 
0852     SET_UNIPERIF_I2S_FMT_NO_OF_SAMPLES_TO_READ(player, 0);
0853 
0854 
0855     return sti_uniperiph_reset(player);
0856 }
0857 
0858 static int uni_player_start(struct uniperif *player)
0859 {
0860     int ret;
0861 
0862     /* The player should be stopped */
0863     if (player->state != UNIPERIF_STATE_STOPPED) {
0864         dev_err(player->dev, "%s: invalid player state\n", __func__);
0865         return -EINVAL;
0866     }
0867 
0868     ret = clk_prepare_enable(player->clk);
0869     if (ret) {
0870         dev_err(player->dev, "%s: Failed to enable clock\n", __func__);
0871         return ret;
0872     }
0873 
0874     /* Clear any pending interrupts */
0875     SET_UNIPERIF_ITS_BCLR(player, GET_UNIPERIF_ITS(player));
0876 
0877     /* Set the interrupt mask */
0878     SET_UNIPERIF_ITM_BSET_DMA_ERROR(player);
0879     SET_UNIPERIF_ITM_BSET_FIFO_ERROR(player);
0880 
0881     /* Enable underflow recovery interrupts */
0882     if (player->underflow_enabled) {
0883         SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_DONE(player);
0884         SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_FAILED(player);
0885     }
0886 
0887     ret = sti_uniperiph_reset(player);
0888     if (ret < 0) {
0889         clk_disable_unprepare(player->clk);
0890         return ret;
0891     }
0892 
0893     /*
0894      * Does not use IEC61937 features of the uniperipheral hardware.
0895      * Instead it performs IEC61937 in software and inserts it directly
0896      * into the audio data stream. As such, when encoded mode is selected,
0897      * linear pcm mode is still used, but with the differences of the
0898      * channel status bits set for encoded mode and the validity bits set.
0899      */
0900     SET_UNIPERIF_CTRL_OPERATION_PCM_DATA(player);
0901 
0902     /*
0903      * If iec958 formatting is required for hdmi or spdif, then it must be
0904      * enabled after the operation mode is set. If set prior to this, it
0905      * will not take affect and hang the player.
0906      */
0907     if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
0908         if (UNIPERIF_TYPE_IS_IEC958(player))
0909             SET_UNIPERIF_CTRL_SPDIF_FMT_ON(player);
0910 
0911     /* Force channel status update (no update if clk disable) */
0912     if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
0913         SET_UNIPERIF_CONFIG_CHL_STS_UPDATE(player);
0914     else
0915         SET_UNIPERIF_BIT_CONTROL_CHL_STS_UPDATE(player);
0916 
0917     /* Update state to started */
0918     player->state = UNIPERIF_STATE_STARTED;
0919 
0920     return 0;
0921 }
0922 
0923 static int uni_player_stop(struct uniperif *player)
0924 {
0925     int ret;
0926 
0927     /* The player should not be in stopped state */
0928     if (player->state == UNIPERIF_STATE_STOPPED) {
0929         dev_err(player->dev, "%s: invalid player state\n", __func__);
0930         return -EINVAL;
0931     }
0932 
0933     /* Turn the player off */
0934     SET_UNIPERIF_CTRL_OPERATION_OFF(player);
0935 
0936     ret = sti_uniperiph_reset(player);
0937     if (ret < 0)
0938         return ret;
0939 
0940     /* Disable interrupts */
0941     SET_UNIPERIF_ITM_BCLR(player, GET_UNIPERIF_ITM(player));
0942 
0943     /* Disable clock */
0944     clk_disable_unprepare(player->clk);
0945 
0946     /* Update state to stopped and return */
0947     player->state = UNIPERIF_STATE_STOPPED;
0948 
0949     return 0;
0950 }
0951 
0952 int uni_player_resume(struct uniperif *player)
0953 {
0954     int ret;
0955 
0956     /* Select the frequency synthesizer clock */
0957     if (player->clk_sel) {
0958         ret = regmap_field_write(player->clk_sel, 1);
0959         if (ret) {
0960             dev_err(player->dev,
0961                 "%s: Failed to select freq synth clock\n",
0962                 __func__);
0963             return ret;
0964         }
0965     }
0966 
0967     SET_UNIPERIF_CONFIG_BACK_STALL_REQ_DISABLE(player);
0968     SET_UNIPERIF_CTRL_ROUNDING_OFF(player);
0969     SET_UNIPERIF_CTRL_SPDIF_LAT_OFF(player);
0970     SET_UNIPERIF_CONFIG_IDLE_MOD_DISABLE(player);
0971 
0972     return 0;
0973 }
0974 EXPORT_SYMBOL_GPL(uni_player_resume);
0975 
0976 static int uni_player_trigger(struct snd_pcm_substream *substream,
0977                   int cmd, struct snd_soc_dai *dai)
0978 {
0979     struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
0980     struct uniperif *player = priv->dai_data.uni;
0981 
0982     switch (cmd) {
0983     case SNDRV_PCM_TRIGGER_START:
0984         return uni_player_start(player);
0985     case SNDRV_PCM_TRIGGER_STOP:
0986         return uni_player_stop(player);
0987     case SNDRV_PCM_TRIGGER_RESUME:
0988         return uni_player_resume(player);
0989     default:
0990         return -EINVAL;
0991     }
0992 }
0993 
0994 static void uni_player_shutdown(struct snd_pcm_substream *substream,
0995                 struct snd_soc_dai *dai)
0996 {
0997     struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
0998     struct uniperif *player = priv->dai_data.uni;
0999     unsigned long flags;
1000 
1001     spin_lock_irqsave(&player->irq_lock, flags);
1002     if (player->state != UNIPERIF_STATE_STOPPED)
1003         /* Stop the player */
1004         uni_player_stop(player);
1005 
1006     player->substream = NULL;
1007     spin_unlock_irqrestore(&player->irq_lock, flags);
1008 }
1009 
1010 static int uni_player_parse_dt_audio_glue(struct platform_device *pdev,
1011                       struct uniperif *player)
1012 {
1013     struct device_node *node = pdev->dev.of_node;
1014     struct regmap *regmap;
1015     struct reg_field regfield[2] = {
1016         /* PCM_CLK_SEL */
1017         REG_FIELD(SYS_CFG_AUDIO_GLUE,
1018               8 + player->id,
1019               8 + player->id),
1020         /* PCMP_VALID_SEL */
1021         REG_FIELD(SYS_CFG_AUDIO_GLUE, 0, 1)
1022     };
1023 
1024     regmap = syscon_regmap_lookup_by_phandle(node, "st,syscfg");
1025 
1026     if (IS_ERR(regmap)) {
1027         dev_err(&pdev->dev, "sti-audio-clk-glue syscf not found\n");
1028         return PTR_ERR(regmap);
1029     }
1030 
1031     player->clk_sel = regmap_field_alloc(regmap, regfield[0]);
1032     player->valid_sel = regmap_field_alloc(regmap, regfield[1]);
1033 
1034     return 0;
1035 }
1036 
1037 static const struct snd_soc_dai_ops uni_player_dai_ops = {
1038         .startup = uni_player_startup,
1039         .shutdown = uni_player_shutdown,
1040         .prepare = uni_player_prepare,
1041         .trigger = uni_player_trigger,
1042         .hw_params = sti_uniperiph_dai_hw_params,
1043         .set_fmt = sti_uniperiph_dai_set_fmt,
1044         .set_sysclk = uni_player_set_sysclk,
1045         .set_tdm_slot = sti_uniperiph_set_tdm_slot
1046 };
1047 
1048 int uni_player_init(struct platform_device *pdev,
1049             struct uniperif *player)
1050 {
1051     int ret = 0;
1052 
1053     player->dev = &pdev->dev;
1054     player->state = UNIPERIF_STATE_STOPPED;
1055     player->dai_ops = &uni_player_dai_ops;
1056 
1057     /* Get PCM_CLK_SEL & PCMP_VALID_SEL from audio-glue-ctrl SoC reg */
1058     ret = uni_player_parse_dt_audio_glue(pdev, player);
1059 
1060     if (ret < 0) {
1061         dev_err(player->dev, "Failed to parse DeviceTree\n");
1062         return ret;
1063     }
1064 
1065     /* Underflow recovery is only supported on later ip revisions */
1066     if (player->ver >= SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0)
1067         player->underflow_enabled = 1;
1068 
1069     if (UNIPERIF_TYPE_IS_TDM(player))
1070         player->hw = &uni_tdm_hw;
1071     else
1072         player->hw = &uni_player_pcm_hw;
1073 
1074     /* Get uniperif resource */
1075     player->clk = of_clk_get(pdev->dev.of_node, 0);
1076     if (IS_ERR(player->clk)) {
1077         dev_err(player->dev, "Failed to get clock\n");
1078         return PTR_ERR(player->clk);
1079     }
1080 
1081     /* Select the frequency synthesizer clock */
1082     if (player->clk_sel) {
1083         ret = regmap_field_write(player->clk_sel, 1);
1084         if (ret) {
1085             dev_err(player->dev,
1086                 "%s: Failed to select freq synth clock\n",
1087                 __func__);
1088             return ret;
1089         }
1090     }
1091 
1092     /* connect to I2S/TDM TX bus */
1093     if (player->valid_sel &&
1094         (player->id == UNIPERIF_PLAYER_I2S_OUT)) {
1095         ret = regmap_field_write(player->valid_sel, player->id);
1096         if (ret) {
1097             dev_err(player->dev,
1098                 "%s: unable to connect to tdm bus\n", __func__);
1099             return ret;
1100         }
1101     }
1102 
1103     ret = devm_request_irq(&pdev->dev, player->irq,
1104                    uni_player_irq_handler, IRQF_SHARED,
1105                    dev_name(&pdev->dev), player);
1106     if (ret < 0) {
1107         dev_err(player->dev, "unable to request IRQ %d\n", player->irq);
1108         return ret;
1109     }
1110 
1111     mutex_init(&player->ctrl_lock);
1112     spin_lock_init(&player->irq_lock);
1113 
1114     /* Ensure that disabled by default */
1115     SET_UNIPERIF_CONFIG_BACK_STALL_REQ_DISABLE(player);
1116     SET_UNIPERIF_CTRL_ROUNDING_OFF(player);
1117     SET_UNIPERIF_CTRL_SPDIF_LAT_OFF(player);
1118     SET_UNIPERIF_CONFIG_IDLE_MOD_DISABLE(player);
1119 
1120     if (UNIPERIF_TYPE_IS_IEC958(player)) {
1121         /* Set default iec958 status bits  */
1122 
1123         /* Consumer, PCM, copyright, 2ch, mode 0 */
1124         player->stream_settings.iec958.status[0] = 0x00;
1125         /* Broadcast reception category */
1126         player->stream_settings.iec958.status[1] =
1127                     IEC958_AES1_CON_GENERAL;
1128         /* Do not take into account source or channel number */
1129         player->stream_settings.iec958.status[2] =
1130                     IEC958_AES2_CON_SOURCE_UNSPEC;
1131         /* Sampling frequency not indicated */
1132         player->stream_settings.iec958.status[3] =
1133                     IEC958_AES3_CON_FS_NOTID;
1134         /* Max sample word 24-bit, sample word length not indicated */
1135         player->stream_settings.iec958.status[4] =
1136                     IEC958_AES4_CON_MAX_WORDLEN_24 |
1137                     IEC958_AES4_CON_WORDLEN_24_20;
1138 
1139         player->num_ctrls = ARRAY_SIZE(snd_sti_iec_ctl);
1140         player->snd_ctrls = snd_sti_iec_ctl[0];
1141     } else {
1142         player->num_ctrls = ARRAY_SIZE(snd_sti_pcm_ctl);
1143         player->snd_ctrls = snd_sti_pcm_ctl[0];
1144     }
1145 
1146     return 0;
1147 }
1148 EXPORT_SYMBOL_GPL(uni_player_init);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!