static int uni_reader_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); struct uniperif *reader = priv->dai_data.uni; struct snd_pcm_runtime *runtime = substream->runtime; int transfer_size, trigger_limit; int slot_width; int count = 10; /* The reader should be stopped */ if (reader->state != UNIPERIF_STATE_STOPPED) { dev_err(reader->dev, "%s: invalid reader state %d", __func__, reader->state); return -EINVAL; } /* Calculate transfer size (in fifo cells and bytes) for frame count */ transfer_size = runtime->channels * UNIPERIF_FIFO_FRAMES; /* Calculate number of empty cells available before asserting DREQ */ if (reader->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) trigger_limit = UNIPERIF_FIFO_SIZE - transfer_size; else /* * Since SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0 * FDMA_TRIGGER_LIMIT also controls when the state switches * from OFF or STANDBY to AUDIO DATA. */ trigger_limit = transfer_size; /* Trigger limit must be an even number */ if ((!trigger_limit % 2) || (trigger_limit != 1 && transfer_size % 2) || (trigger_limit > UNIPERIF_CONFIG_DMA_TRIG_LIMIT_MASK(reader))) { dev_err(reader->dev, "invalid trigger limit %d", trigger_limit); return -EINVAL; } SET_UNIPERIF_CONFIG_DMA_TRIG_LIMIT(reader, trigger_limit); switch (reader->daifmt & SND_SOC_DAIFMT_INV_MASK) { case SND_SOC_DAIFMT_IB_IF: case SND_SOC_DAIFMT_NB_IF: SET_UNIPERIF_I2S_FMT_LR_POL_HIG(reader); break; default: SET_UNIPERIF_I2S_FMT_LR_POL_LOW(reader); } /* Force slot width to 32 in I2S mode */ if ((reader->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_I2S) { slot_width = 32; } else { switch (runtime->format) { case SNDRV_PCM_FORMAT_S16_LE: slot_width = 16; break; default: slot_width = 32; break; } } /* Number of bits per subframe (i.e one channel sample) on input. */ switch (slot_width) { case 32: SET_UNIPERIF_I2S_FMT_NBIT_32(reader); SET_UNIPERIF_I2S_FMT_DATA_SIZE_32(reader); break; case 16: SET_UNIPERIF_I2S_FMT_NBIT_16(reader); SET_UNIPERIF_I2S_FMT_DATA_SIZE_16(reader); break; default: dev_err(reader->dev, "subframe format not supported"); return -EINVAL; } /* Configure data memory format */ switch (runtime->format) { case SNDRV_PCM_FORMAT_S16_LE: /* One data word contains two samples */ SET_UNIPERIF_CONFIG_MEM_FMT_16_16(reader); break; case SNDRV_PCM_FORMAT_S32_LE: /* * Actually "16 bits/0 bits" means "32/28/24/20/18/16 bits * on the MSB then zeros (if less than 32 bytes)"... */ SET_UNIPERIF_CONFIG_MEM_FMT_16_0(reader); break; default: dev_err(reader->dev, "format not supported"); return -EINVAL; } switch (reader->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) { case SND_SOC_DAIFMT_I2S: SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(reader); SET_UNIPERIF_I2S_FMT_PADDING_I2S_MODE(reader); break; case SND_SOC_DAIFMT_LEFT_J: SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(reader); SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(reader); break; case SND_SOC_DAIFMT_RIGHT_J: SET_UNIPERIF_I2S_FMT_ALIGN_RIGHT(reader); SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(reader); break; default: dev_err(reader->dev, "format not supported"); return -EINVAL; } SET_UNIPERIF_I2S_FMT_ORDER_MSB(reader); /* Data clocking (changing) on the rising edge */ SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(reader); /* Number of channels must be even */ if ((runtime->channels % 2) || (runtime->channels < 2) || (runtime->channels > 10)) { dev_err(reader->dev, "%s: invalid nb of channels", __func__); return -EINVAL; } SET_UNIPERIF_I2S_FMT_NUM_CH(reader, runtime->channels / 2); /* Clear any pending interrupts */ SET_UNIPERIF_ITS_BCLR(reader, GET_UNIPERIF_ITS(reader)); SET_UNIPERIF_I2S_FMT_NO_OF_SAMPLES_TO_READ(reader, 0); /* Set the interrupt mask */ SET_UNIPERIF_ITM_BSET_DMA_ERROR(reader); SET_UNIPERIF_ITM_BSET_FIFO_ERROR(reader); SET_UNIPERIF_ITM_BSET_MEM_BLK_READ(reader); /* Enable underflow recovery interrupts */ if (reader->info->underflow_enabled) { SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_DONE(reader); SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_FAILED(reader); } /* Reset uniperipheral reader */ SET_UNIPERIF_SOFT_RST_SOFT_RST(reader); while (GET_UNIPERIF_SOFT_RST_SOFT_RST(reader)) { udelay(5); count--; } if (!count) { dev_err(reader->dev, "Failed to reset uniperif"); return -EIO; } return 0; }
static int uni_player_start(struct uniperif *player) { int ret; /* The player should be stopped */ if (player->state != UNIPERIF_STATE_STOPPED) { dev_err(player->dev, "%s: invalid player state\n", __func__); return -EINVAL; } ret = clk_prepare_enable(player->clk); if (ret) { dev_err(player->dev, "%s: Failed to enable clock\n", __func__); return ret; } /* Clear any pending interrupts */ SET_UNIPERIF_ITS_BCLR(player, GET_UNIPERIF_ITS(player)); /* Set the interrupt mask */ SET_UNIPERIF_ITM_BSET_DMA_ERROR(player); SET_UNIPERIF_ITM_BSET_FIFO_ERROR(player); /* Enable underflow recovery interrupts */ if (player->underflow_enabled) { SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_DONE(player); SET_UNIPERIF_ITM_BSET_UNDERFLOW_REC_FAILED(player); } ret = sti_uniperiph_reset(player); if (ret < 0) { clk_disable_unprepare(player->clk); return ret; } /* * Does not use IEC61937 features of the uniperipheral hardware. * Instead it performs IEC61937 in software and inserts it directly * into the audio data stream. As such, when encoded mode is selected, * linear pcm mode is still used, but with the differences of the * channel status bits set for encoded mode and the validity bits set. */ SET_UNIPERIF_CTRL_OPERATION_PCM_DATA(player); /* * If iec958 formatting is required for hdmi or spdif, then it must be * enabled after the operation mode is set. If set prior to this, it * will not take affect and hang the player. */ if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) if (UNIPERIF_TYPE_IS_IEC958(player)) SET_UNIPERIF_CTRL_SPDIF_FMT_ON(player); /* Force channel status update (no update if clk disable) */ if (player->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) SET_UNIPERIF_CONFIG_CHL_STS_UPDATE(player); else SET_UNIPERIF_BIT_CONTROL_CHL_STS_UPDATE(player); /* Update state to started */ player->state = UNIPERIF_STATE_STARTED; return 0; }