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_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai); struct uniperif *player = priv->dai_data.uni; struct snd_pcm_runtime *runtime = substream->runtime; int transfer_size, trigger_limit; int ret; /* The player should be stopped */ if (player->state != UNIPERIF_STATE_STOPPED) { dev_err(player->dev, "%s: invalid player state %d\n", __func__, player->state); return -EINVAL; } /* Calculate transfer size (in fifo cells and bytes) for frame count */ if (player->type == SND_ST_UNIPERIF_TYPE_TDM) { /* transfer size = user frame size (in 32 bits FIFO cell) */ transfer_size = sti_uniperiph_get_user_frame_size(runtime) / 4; } else { transfer_size = runtime->channels * UNIPERIF_FIFO_FRAMES; } /* Calculate number of empty cells available before asserting DREQ */ if (player->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(player))) { dev_err(player->dev, "invalid trigger limit %d\n", trigger_limit); return -EINVAL; } SET_UNIPERIF_CONFIG_DMA_TRIG_LIMIT(player, trigger_limit); /* Uniperipheral setup depends on player type */ switch (player->type) { case SND_ST_UNIPERIF_TYPE_HDMI: ret = uni_player_prepare_iec958(player, runtime); break; case SND_ST_UNIPERIF_TYPE_PCM: ret = uni_player_prepare_pcm(player, runtime); break; case SND_ST_UNIPERIF_TYPE_SPDIF: ret = uni_player_prepare_iec958(player, runtime); break; case SND_ST_UNIPERIF_TYPE_TDM: ret = uni_player_prepare_tdm(player, runtime); break; default: dev_err(player->dev, "invalid player type\n"); return -EINVAL; } if (ret) return ret; switch (player->daifmt & SND_SOC_DAIFMT_INV_MASK) { case SND_SOC_DAIFMT_NB_NF: SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player); SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player); break; case SND_SOC_DAIFMT_NB_IF: SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player); SET_UNIPERIF_I2S_FMT_SCLK_EDGE_RISING(player); break; case SND_SOC_DAIFMT_IB_NF: SET_UNIPERIF_I2S_FMT_LR_POL_LOW(player); SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player); break; case SND_SOC_DAIFMT_IB_IF: SET_UNIPERIF_I2S_FMT_LR_POL_HIG(player); SET_UNIPERIF_I2S_FMT_SCLK_EDGE_FALLING(player); break; } switch (player->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) { case SND_SOC_DAIFMT_I2S: SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player); SET_UNIPERIF_I2S_FMT_PADDING_I2S_MODE(player); break; case SND_SOC_DAIFMT_LEFT_J: SET_UNIPERIF_I2S_FMT_ALIGN_LEFT(player); SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player); break; case SND_SOC_DAIFMT_RIGHT_J: SET_UNIPERIF_I2S_FMT_ALIGN_RIGHT(player); SET_UNIPERIF_I2S_FMT_PADDING_SONY_MODE(player); break; default: dev_err(player->dev, "format not supported\n"); return -EINVAL; } SET_UNIPERIF_I2S_FMT_NO_OF_SAMPLES_TO_READ(player, 0); return sti_uniperiph_reset(player); }