sound/soc/sti/sti_uniperif.c - third_party/linux - Git at Google

 /*
  * Copyright (C) STMicroelectronics SA 2015
  * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
  *          for STMicroelectronics.
  * License terms:  GNU General Public License (GPL), version 2
  */

 #include <linux/module.h>
 #include <linux/pinctrl/consumer.h>
 #include <linux/delay.h>

 #include "uniperif.h"

 /*
  * User frame size shall be 2, 4, 6 or 8 32-bits words length
  * (i.e. 8, 16, 24 or 32 bytes)
  * This constraint comes from allowed values for
  * UNIPERIF_I2S_FMT_NUM_CH register
  */
 #define UNIPERIF_MAX_FRAME_SZ 0x20
 #define UNIPERIF_ALLOWED_FRAME_SZ (0x08 | 0x10 | 0x18 | UNIPERIF_MAX_FRAME_SZ)

 struct sti_uniperiph_dev_data {
 	unsigned int id; /* Nb available player instances */
 	unsigned int version; /* player IP version */
 	unsigned int stream;
 	const char *dai_names;
 	enum uniperif_type type;
 };

 static const struct sti_uniperiph_dev_data sti_uniplayer_hdmi = {
 	.id = 0,
 	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
 	.stream = SNDRV_PCM_STREAM_PLAYBACK,
 	.dai_names = "Uni Player #0 (HDMI)",
 	.type = SND_ST_UNIPERIF_TYPE_HDMI
 };

 static const struct sti_uniperiph_dev_data sti_uniplayer_pcm_out = {
 	.id = 1,
 	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
 	.stream = SNDRV_PCM_STREAM_PLAYBACK,
 	.dai_names = "Uni Player #1 (PCM OUT)",
 	.type = SND_ST_UNIPERIF_TYPE_PCM | SND_ST_UNIPERIF_TYPE_TDM,
 };

 static const struct sti_uniperiph_dev_data sti_uniplayer_dac = {
 	.id = 2,
 	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
 	.stream = SNDRV_PCM_STREAM_PLAYBACK,
 	.dai_names = "Uni Player #2 (DAC)",
 	.type = SND_ST_UNIPERIF_TYPE_PCM,
 };

 static const struct sti_uniperiph_dev_data sti_uniplayer_spdif = {
 	.id = 3,
 	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
 	.stream = SNDRV_PCM_STREAM_PLAYBACK,
 	.dai_names = "Uni Player #3 (SPDIF)",
 	.type = SND_ST_UNIPERIF_TYPE_SPDIF
 };

 static const struct sti_uniperiph_dev_data sti_unireader_pcm_in = {
 	.id = 0,
 	.version = SND_ST_UNIPERIF_VERSION_UNI_RDR_1_0,
 	.stream = SNDRV_PCM_STREAM_CAPTURE,
 	.dai_names = "Uni Reader #0 (PCM IN)",
 	.type = SND_ST_UNIPERIF_TYPE_PCM | SND_ST_UNIPERIF_TYPE_TDM,
 };

 static const struct sti_uniperiph_dev_data sti_unireader_hdmi_in = {
 	.id = 1,
 	.version = SND_ST_UNIPERIF_VERSION_UNI_RDR_1_0,
 	.stream = SNDRV_PCM_STREAM_CAPTURE,
 	.dai_names = "Uni Reader #1 (HDMI IN)",
 	.type = SND_ST_UNIPERIF_TYPE_PCM,
 };

 static const struct of_device_id snd_soc_sti_match[] = {
 	{ .compatible = "st,stih407-uni-player-hdmi",
 	  .data = &sti_uniplayer_hdmi
 	},
 	{ .compatible = "st,stih407-uni-player-pcm-out",
 	  .data = &sti_uniplayer_pcm_out
 	},
 	{ .compatible = "st,stih407-uni-player-dac",
 	  .data = &sti_uniplayer_dac
 	},
 	{ .compatible = "st,stih407-uni-player-spdif",
 	  .data = &sti_uniplayer_spdif
 	},
 	{ .compatible = "st,stih407-uni-reader-pcm_in",
 	  .data = &sti_unireader_pcm_in
 	},
 	{ .compatible = "st,stih407-uni-reader-hdmi",
 	  .data = &sti_unireader_hdmi_in
 	},
 	{},
 };

 int  sti_uniperiph_reset(struct uniperif *uni)
 {
 	int count = 10;

 	/* Reset uniperipheral uni */
 	SET_UNIPERIF_SOFT_RST_SOFT_RST(uni);

 	if (uni->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) {
 		while (GET_UNIPERIF_SOFT_RST_SOFT_RST(uni) && count) {
 			udelay(5);
 			count--;
 		}
 	}

 	if (!count) {
 		dev_err(uni->dev, "Failed to reset uniperif\n");
 		return -EIO;
 	}

 	return 0;
 }

 int sti_uniperiph_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
 			       unsigned int rx_mask, int slots,
 			       int slot_width)
 {
 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 	struct uniperif *uni = priv->dai_data.uni;
 	int i, frame_size, avail_slots;

 	if (!UNIPERIF_TYPE_IS_TDM(uni)) {
 		dev_err(uni->dev, "cpu dai not in tdm mode\n");
 		return -EINVAL;
 	}

 	/* store info in unip context */
 	uni->tdm_slot.slots = slots;
 	uni->tdm_slot.slot_width = slot_width;
 	/* unip is unidirectionnal */
 	uni->tdm_slot.mask = (tx_mask != 0) ? tx_mask : rx_mask;

 	/* number of available timeslots */
 	for (i = 0, avail_slots = 0; i < uni->tdm_slot.slots; i++) {
 		if ((uni->tdm_slot.mask >> i) & 0x01)
 			avail_slots++;
 	}
 	uni->tdm_slot.avail_slots = avail_slots;

 	/* frame size in bytes */
 	frame_size = uni->tdm_slot.avail_slots * uni->tdm_slot.slot_width / 8;

 	/* check frame size is allowed */
 	if ((frame_size > UNIPERIF_MAX_FRAME_SZ) ||
 	    (frame_size & ~(int)UNIPERIF_ALLOWED_FRAME_SZ)) {
 		dev_err(uni->dev, "frame size not allowed: %d bytes\n",
 			frame_size);
 		return -EINVAL;
 	}

 	return 0;
 }

 int sti_uniperiph_fix_tdm_chan(struct snd_pcm_hw_params *params,
 			       struct snd_pcm_hw_rule *rule)
 {
 	struct uniperif *uni = rule->private;
 	struct snd_interval t;

 	t.min = uni->tdm_slot.avail_slots;
 	t.max = uni->tdm_slot.avail_slots;
 	t.openmin = 0;
 	t.openmax = 0;
 	t.integer = 0;

 	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
 }

 int sti_uniperiph_fix_tdm_format(struct snd_pcm_hw_params *params,
 				 struct snd_pcm_hw_rule *rule)
 {
 	struct uniperif *uni = rule->private;
 	struct snd_mask *maskp = hw_param_mask(params, rule->var);
 	u64 format;

 	switch (uni->tdm_slot.slot_width) {
 	case 16:
 		format = SNDRV_PCM_FMTBIT_S16_LE;
 		break;
 	case 32:
 		format = SNDRV_PCM_FMTBIT_S32_LE;
 		break;
 	default:
 		dev_err(uni->dev, "format not supported: %d bits\n",
 			uni->tdm_slot.slot_width);
 		return -EINVAL;
 	}

 	maskp->bits[0] &= (u_int32_t)format;
 	maskp->bits[1] &= (u_int32_t)(format >> 32);
 	/* clear remaining indexes */
 	memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX - 64) / 8);

 	if (!maskp->bits[0] && !maskp->bits[1])
 		return -EINVAL;

 	return 0;
 }

 int sti_uniperiph_get_tdm_word_pos(struct uniperif *uni,
 				   unsigned int *word_pos)
 {
 	int slot_width = uni->tdm_slot.slot_width / 8;
 	int slots_num = uni->tdm_slot.slots;
 	unsigned int slots_mask = uni->tdm_slot.mask;
 	int i, j, k;
 	unsigned int word16_pos[4];

 	/* word16_pos:
 	 * word16_pos[0] = WORDX_LSB
 	 * word16_pos[1] = WORDX_MSB,
 	 * word16_pos[2] = WORDX+1_LSB
 	 * word16_pos[3] = WORDX+1_MSB
 	 */

 	/* set unip word position */
 	for (i = 0, j = 0, k = 0; (i < slots_num) && (k < WORD_MAX); i++) {
 		if ((slots_mask >> i) & 0x01) {
 			word16_pos[j] = i * slot_width;

 			if (slot_width == 4) {
 				word16_pos[j + 1] = word16_pos[j] + 2;
 				j++;
 			}
 			j++;

 			if (j > 3) {
 				word_pos[k] = word16_pos[1] |
 					      (word16_pos[0] << 8) |
 					      (word16_pos[3] << 16) |
 					      (word16_pos[2] << 24);
 				j = 0;
 				k++;
 			}
 		}
 	}

 	return 0;
 }

 /*
  * sti_uniperiph_dai_create_ctrl
  * This function is used to create Ctrl associated to DAI but also pcm device.
  * Request is done by front end to associate ctrl with pcm device id
  */
 static int sti_uniperiph_dai_create_ctrl(struct snd_soc_dai *dai)
 {
 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 	struct uniperif *uni = priv->dai_data.uni;
 	struct snd_kcontrol_new *ctrl;
 	int i;

 	if (!uni->num_ctrls)
 		return 0;

 	for (i = 0; i < uni->num_ctrls; i++) {
 		/*
 		 * Several Control can have same name. Controls are indexed on
 		 * Uniperipheral instance ID
 		 */
 		ctrl = &uni->snd_ctrls[i];
 		ctrl->index = uni->id;
 		ctrl->device = uni->id;
 	}

 	return snd_soc_add_dai_controls(dai, uni->snd_ctrls, uni->num_ctrls);
 }

 /*
  * DAI
  */
 int sti_uniperiph_dai_hw_params(struct snd_pcm_substream *substream,
 				struct snd_pcm_hw_params *params,
 				struct snd_soc_dai *dai)
 {
 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 	struct uniperif *uni = priv->dai_data.uni;
 	struct snd_dmaengine_dai_dma_data *dma_data;
 	int transfer_size;

 	if (uni->type == SND_ST_UNIPERIF_TYPE_TDM)
 		/* transfer size = user frame size (in 32-bits FIFO cell) */
 		transfer_size = snd_soc_params_to_frame_size(params) / 32;
 	else
 		transfer_size = params_channels(params) * UNIPERIF_FIFO_FRAMES;

 	dma_data = snd_soc_dai_get_dma_data(dai, substream);
 	dma_data->maxburst = transfer_size;

 	return 0;
 }

 int sti_uniperiph_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 {
 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);

 	priv->dai_data.uni->daifmt = fmt;

 	return 0;
 }

 static int sti_uniperiph_dai_suspend(struct snd_soc_dai *dai)
 {
 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 	struct uniperif *uni = priv->dai_data.uni;
 	int ret;

 	/* The uniperipheral should be in stopped state */
 	if (uni->state != UNIPERIF_STATE_STOPPED) {
 		dev_err(uni->dev, "%s: invalid uni state( %d)\n",
 			__func__, (int)uni->state);
 		return -EBUSY;
 	}

 	/* Pinctrl: switch pinstate to sleep */
 	ret = pinctrl_pm_select_sleep_state(uni->dev);
 	if (ret)
 		dev_err(uni->dev, "%s: failed to select pinctrl state\n",
 			__func__);

 	return ret;
 }

 static int sti_uniperiph_dai_resume(struct snd_soc_dai *dai)
 {
 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 	struct uniperif *uni = priv->dai_data.uni;
 	int ret;

 	if (priv->dai_data.stream == SNDRV_PCM_STREAM_PLAYBACK) {
 		ret = uni_player_resume(uni);
 		if (ret)
 			return ret;
 	}

 	/* pinctrl: switch pinstate to default */
 	ret = pinctrl_pm_select_default_state(uni->dev);
 	if (ret)
 		dev_err(uni->dev, "%s: failed to select pinctrl state\n",
 			__func__);

 	return ret;
 }

 static int sti_uniperiph_dai_probe(struct snd_soc_dai *dai)
 {
 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 	struct sti_uniperiph_dai *dai_data = &priv->dai_data;

 	/* DMA settings*/
 	if (priv->dai_data.stream == SNDRV_PCM_STREAM_PLAYBACK)
 		snd_soc_dai_init_dma_data(dai, &dai_data->dma_data, NULL);
 	else
 		snd_soc_dai_init_dma_data(dai, NULL, &dai_data->dma_data);

 	dai_data->dma_data.addr = dai_data->uni->fifo_phys_address;
 	dai_data->dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;

 	return sti_uniperiph_dai_create_ctrl(dai);
 }

 static const struct snd_soc_dai_driver sti_uniperiph_dai_template = {
 	.probe = sti_uniperiph_dai_probe,
 	.suspend = sti_uniperiph_dai_suspend,
 	.resume = sti_uniperiph_dai_resume
 };

 static const struct snd_soc_component_driver sti_uniperiph_dai_component = {
 	.name = "sti_cpu_dai",
 };

 static int sti_uniperiph_cpu_dai_of(struct device_node *node,
 				    struct sti_uniperiph_data *priv)
 {
 	struct device *dev = &priv->pdev->dev;
 	struct sti_uniperiph_dai *dai_data = &priv->dai_data;
 	struct snd_soc_dai_driver *dai = priv->dai;
 	struct snd_soc_pcm_stream *stream;
 	struct uniperif *uni;
 	const struct of_device_id *of_id;
 	const struct sti_uniperiph_dev_data *dev_data;
 	const char *mode;
 	int ret;

 	/* Populate data structure depending on compatibility */
 	of_id = of_match_node(snd_soc_sti_match, node);
 	if (!of_id->data) {
 		dev_err(dev, "data associated to device is missing\n");
 		return -EINVAL;
 	}
 	dev_data = (struct sti_uniperiph_dev_data *)of_id->data;

 	uni = devm_kzalloc(dev, sizeof(*uni), GFP_KERNEL);
 	if (!uni)
 		return -ENOMEM;

 	uni->id = dev_data->id;
 	uni->ver = dev_data->version;

 	*dai = sti_uniperiph_dai_template;
 	dai->name = dev_data->dai_names;

 	/* Get resources */
 	uni->mem_region = platform_get_resource(priv->pdev, IORESOURCE_MEM, 0);

 	if (!uni->mem_region) {
 		dev_err(dev, "Failed to get memory resource\n");
 		return -ENODEV;
 	}

 	uni->base = devm_ioremap_resource(dev, uni->mem_region);

 	if (IS_ERR(uni->base))
 		return PTR_ERR(uni->base);

 	uni->fifo_phys_address = uni->mem_region->start +
 				     UNIPERIF_FIFO_DATA_OFFSET(uni);

 	uni->irq = platform_get_irq(priv->pdev, 0);
 	if (uni->irq < 0) {
 		dev_err(dev, "Failed to get IRQ resource\n");
 		return -ENXIO;
 	}

 	uni->type = dev_data->type;

 	/* check if player should be configured for tdm */
 	if (dev_data->type & SND_ST_UNIPERIF_TYPE_TDM) {
 		if (!of_property_read_string(node, "st,tdm-mode", &mode))
 			uni->type = SND_ST_UNIPERIF_TYPE_TDM;
 		else
 			uni->type = SND_ST_UNIPERIF_TYPE_PCM;
 	}

 	dai_data->uni = uni;
 	dai_data->stream = dev_data->stream;

 	if (priv->dai_data.stream == SNDRV_PCM_STREAM_PLAYBACK) {
 		ret = uni_player_init(priv->pdev, uni);
 		stream = &dai->playback;
 	} else {
 		ret = uni_reader_init(priv->pdev, uni);
 		stream = &dai->capture;
 	}
 	if (ret < 0)
 		return ret;

 	dai->ops = uni->dai_ops;

 	stream->stream_name = dai->name;
 	stream->channels_min = uni->hw->channels_min;
 	stream->channels_max = uni->hw->channels_max;
 	stream->rates = uni->hw->rates;
 	stream->formats = uni->hw->formats;

 	return 0;
 }

 static const struct snd_dmaengine_pcm_config dmaengine_pcm_config = {
 	.prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
 };

 static int sti_uniperiph_probe(struct platform_device *pdev)
 {
 	struct sti_uniperiph_data *priv;
 	struct device_node *node = pdev->dev.of_node;
 	int ret;

 	/* Allocate the private data and the CPU_DAI array */
 	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;
 	priv->dai = devm_kzalloc(&pdev->dev, sizeof(*priv->dai), GFP_KERNEL);
 	if (!priv->dai)
 		return -ENOMEM;

 	priv->pdev = pdev;

 	ret = sti_uniperiph_cpu_dai_of(node, priv);

 	dev_set_drvdata(&pdev->dev, priv);

 	ret = devm_snd_soc_register_component(&pdev->dev,
 					      &sti_uniperiph_dai_component,
 					      priv->dai, 1);
 	if (ret < 0)
 		return ret;

 	return devm_snd_dmaengine_pcm_register(&pdev->dev,
 					       &dmaengine_pcm_config, 0);
 }

 static struct platform_driver sti_uniperiph_driver = {
 	.driver = {
 		.name = "sti-uniperiph-dai",
 		.of_match_table = snd_soc_sti_match,
 	},
 	.probe = sti_uniperiph_probe,
 };
 module_platform_driver(sti_uniperiph_driver);

 MODULE_DESCRIPTION("uniperipheral DAI driver");
 MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@st.com>");
 MODULE_LICENSE("GPL v2");
	/*
	* Copyright (C) STMicroelectronics SA 2015
	* Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
	* for STMicroelectronics.
	* License terms: GNU General Public License (GPL), version 2
	*/

	#include <linux/module.h>
	#include <linux/pinctrl/consumer.h>
	#include <linux/delay.h>

	#include "uniperif.h"

	/*
	* User frame size shall be 2, 4, 6 or 8 32-bits words length
	* (i.e. 8, 16, 24 or 32 bytes)
	* This constraint comes from allowed values for
	* UNIPERIF_I2S_FMT_NUM_CH register
	*/
	#define UNIPERIF_MAX_FRAME_SZ 0x20
	#define UNIPERIF_ALLOWED_FRAME_SZ (0x08 \| 0x10 \| 0x18 \| UNIPERIF_MAX_FRAME_SZ)

	struct sti_uniperiph_dev_data {
	unsigned int id; /* Nb available player instances */
	unsigned int version; /* player IP version */
	unsigned int stream;
	const char *dai_names;
	enum uniperif_type type;
	};

	static const struct sti_uniperiph_dev_data sti_uniplayer_hdmi = {
	.id = 0,
	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
	.stream = SNDRV_PCM_STREAM_PLAYBACK,
	.dai_names = "Uni Player #0 (HDMI)",
	.type = SND_ST_UNIPERIF_TYPE_HDMI
	};

	static const struct sti_uniperiph_dev_data sti_uniplayer_pcm_out = {
	.id = 1,
	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
	.stream = SNDRV_PCM_STREAM_PLAYBACK,
	.dai_names = "Uni Player #1 (PCM OUT)",
	.type = SND_ST_UNIPERIF_TYPE_PCM \| SND_ST_UNIPERIF_TYPE_TDM,
	};

	static const struct sti_uniperiph_dev_data sti_uniplayer_dac = {
	.id = 2,
	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
	.stream = SNDRV_PCM_STREAM_PLAYBACK,
	.dai_names = "Uni Player #2 (DAC)",
	.type = SND_ST_UNIPERIF_TYPE_PCM,
	};

	static const struct sti_uniperiph_dev_data sti_uniplayer_spdif = {
	.id = 3,
	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
	.stream = SNDRV_PCM_STREAM_PLAYBACK,
	.dai_names = "Uni Player #3 (SPDIF)",
	.type = SND_ST_UNIPERIF_TYPE_SPDIF
	};

	static const struct sti_uniperiph_dev_data sti_unireader_pcm_in = {
	.id = 0,
	.version = SND_ST_UNIPERIF_VERSION_UNI_RDR_1_0,
	.stream = SNDRV_PCM_STREAM_CAPTURE,
	.dai_names = "Uni Reader #0 (PCM IN)",
	.type = SND_ST_UNIPERIF_TYPE_PCM \| SND_ST_UNIPERIF_TYPE_TDM,
	};

	static const struct sti_uniperiph_dev_data sti_unireader_hdmi_in = {
	.id = 1,
	.version = SND_ST_UNIPERIF_VERSION_UNI_RDR_1_0,
	.stream = SNDRV_PCM_STREAM_CAPTURE,
	.dai_names = "Uni Reader #1 (HDMI IN)",
	.type = SND_ST_UNIPERIF_TYPE_PCM,
	};

	static const struct of_device_id snd_soc_sti_match[] = {
	{ .compatible = "st,stih407-uni-player-hdmi",
	.data = &sti_uniplayer_hdmi
	},
	{ .compatible = "st,stih407-uni-player-pcm-out",
	.data = &sti_uniplayer_pcm_out
	},
	{ .compatible = "st,stih407-uni-player-dac",
	.data = &sti_uniplayer_dac
	},
	{ .compatible = "st,stih407-uni-player-spdif",
	.data = &sti_uniplayer_spdif
	},
	{ .compatible = "st,stih407-uni-reader-pcm_in",
	.data = &sti_unireader_pcm_in
	},
	{ .compatible = "st,stih407-uni-reader-hdmi",
	.data = &sti_unireader_hdmi_in
	},
	{},
	};

	int sti_uniperiph_reset(struct uniperif *uni)
	{
	int count = 10;

	/* Reset uniperipheral uni */
	SET_UNIPERIF_SOFT_RST_SOFT_RST(uni);

	if (uni->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) {
	while (GET_UNIPERIF_SOFT_RST_SOFT_RST(uni) && count) {
	udelay(5);
	count--;
	}
	}

	if (!count) {
	dev_err(uni->dev, "Failed to reset uniperif\n");
	return -EIO;
	}

	return 0;
	}

	int sti_uniperiph_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
	unsigned int rx_mask, int slots,
	int slot_width)
	{
	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
	struct uniperif *uni = priv->dai_data.uni;
	int i, frame_size, avail_slots;

	if (!UNIPERIF_TYPE_IS_TDM(uni)) {
	dev_err(uni->dev, "cpu dai not in tdm mode\n");
	return -EINVAL;
	}

	/* store info in unip context */
	uni->tdm_slot.slots = slots;
	uni->tdm_slot.slot_width = slot_width;
	/* unip is unidirectionnal */
	uni->tdm_slot.mask = (tx_mask != 0) ? tx_mask : rx_mask;

	/* number of available timeslots */
	for (i = 0, avail_slots = 0; i < uni->tdm_slot.slots; i++) {
	if ((uni->tdm_slot.mask >> i) & 0x01)
	avail_slots++;
	}
	uni->tdm_slot.avail_slots = avail_slots;

	/* frame size in bytes */
	frame_size = uni->tdm_slot.avail_slots * uni->tdm_slot.slot_width / 8;

	/* check frame size is allowed */
	if ((frame_size > UNIPERIF_MAX_FRAME_SZ) \|\|
	(frame_size & ~(int)UNIPERIF_ALLOWED_FRAME_SZ)) {
	dev_err(uni->dev, "frame size not allowed: %d bytes\n",
	frame_size);
	return -EINVAL;
	}

	return 0;
	}

	int sti_uniperiph_fix_tdm_chan(struct snd_pcm_hw_params *params,
	struct snd_pcm_hw_rule *rule)
	{
	struct uniperif *uni = rule->private;
	struct snd_interval t;

	t.min = uni->tdm_slot.avail_slots;
	t.max = uni->tdm_slot.avail_slots;
	t.openmin = 0;
	t.openmax = 0;
	t.integer = 0;

	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
	}

	int sti_uniperiph_fix_tdm_format(struct snd_pcm_hw_params *params,
	struct snd_pcm_hw_rule *rule)
	{
	struct uniperif *uni = rule->private;
	struct snd_mask *maskp = hw_param_mask(params, rule->var);
	u64 format;

	switch (uni->tdm_slot.slot_width) {
	case 16:
	format = SNDRV_PCM_FMTBIT_S16_LE;
	break;
	case 32:
	format = SNDRV_PCM_FMTBIT_S32_LE;
	break;
	default:
	dev_err(uni->dev, "format not supported: %d bits\n",
	uni->tdm_slot.slot_width);
	return -EINVAL;
	}

	maskp->bits[0] &= (u_int32_t)format;
	maskp->bits[1] &= (u_int32_t)(format >> 32);
	/* clear remaining indexes */
	memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX - 64) / 8);

	if (!maskp->bits[0] && !maskp->bits[1])
	return -EINVAL;

	return 0;
	}

	int sti_uniperiph_get_tdm_word_pos(struct uniperif *uni,
	unsigned int *word_pos)
	{
	int slot_width = uni->tdm_slot.slot_width / 8;
	int slots_num = uni->tdm_slot.slots;
	unsigned int slots_mask = uni->tdm_slot.mask;
	int i, j, k;
	unsigned int word16_pos[4];

	/* word16_pos:
	* word16_pos[0] = WORDX_LSB
	* word16_pos[1] = WORDX_MSB,
	* word16_pos[2] = WORDX+1_LSB
	* word16_pos[3] = WORDX+1_MSB
	*/

	/* set unip word position */
	for (i = 0, j = 0, k = 0; (i < slots_num) && (k < WORD_MAX); i++) {
	if ((slots_mask >> i) & 0x01) {
	word16_pos[j] = i * slot_width;

	if (slot_width == 4) {
	word16_pos[j + 1] = word16_pos[j] + 2;
	j++;
	}
	j++;

	if (j > 3) {
	word_pos[k] = word16_pos[1] \|
	(word16_pos[0] << 8) \|
	(word16_pos[3] << 16) \|
	(word16_pos[2] << 24);
	j = 0;
	k++;
	}
	}
	}

	return 0;
	}

	/*
	* sti_uniperiph_dai_create_ctrl
	* This function is used to create Ctrl associated to DAI but also pcm device.
	* Request is done by front end to associate ctrl with pcm device id
	*/
	static int sti_uniperiph_dai_create_ctrl(struct snd_soc_dai *dai)
	{
	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
	struct uniperif *uni = priv->dai_data.uni;
	struct snd_kcontrol_new *ctrl;
	int i;

	if (!uni->num_ctrls)
	return 0;

	for (i = 0; i < uni->num_ctrls; i++) {
	/*
	* Several Control can have same name. Controls are indexed on
	* Uniperipheral instance ID
	*/
	ctrl = &uni->snd_ctrls[i];
	ctrl->index = uni->id;
	ctrl->device = uni->id;
	}

	return snd_soc_add_dai_controls(dai, uni->snd_ctrls, uni->num_ctrls);
	}

	/*
	* DAI
	*/
	int sti_uniperiph_dai_hw_params(struct snd_pcm_substream *substream,
	struct snd_pcm_hw_params *params,
	struct snd_soc_dai *dai)
	{
	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
	struct uniperif *uni = priv->dai_data.uni;
	struct snd_dmaengine_dai_dma_data *dma_data;
	int transfer_size;

	if (uni->type == SND_ST_UNIPERIF_TYPE_TDM)
	/* transfer size = user frame size (in 32-bits FIFO cell) */
	transfer_size = snd_soc_params_to_frame_size(params) / 32;
	else
	transfer_size = params_channels(params) * UNIPERIF_FIFO_FRAMES;

	dma_data = snd_soc_dai_get_dma_data(dai, substream);
	dma_data->maxburst = transfer_size;

	return 0;
	}

	int sti_uniperiph_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
	{
	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);

	priv->dai_data.uni->daifmt = fmt;

	return 0;
	}

	static int sti_uniperiph_dai_suspend(struct snd_soc_dai *dai)
	{
	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
	struct uniperif *uni = priv->dai_data.uni;
	int ret;

	/* The uniperipheral should be in stopped state */
	if (uni->state != UNIPERIF_STATE_STOPPED) {
	dev_err(uni->dev, "%s: invalid uni state( %d)\n",
	__func__, (int)uni->state);
	return -EBUSY;
	}

	/* Pinctrl: switch pinstate to sleep */
	ret = pinctrl_pm_select_sleep_state(uni->dev);
	if (ret)
	dev_err(uni->dev, "%s: failed to select pinctrl state\n",
	__func__);

	return ret;
	}

	static int sti_uniperiph_dai_resume(struct snd_soc_dai *dai)
	{
	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
	struct uniperif *uni = priv->dai_data.uni;
	int ret;

	if (priv->dai_data.stream == SNDRV_PCM_STREAM_PLAYBACK) {
	ret = uni_player_resume(uni);
	if (ret)
	return ret;
	}

	/* pinctrl: switch pinstate to default */
	ret = pinctrl_pm_select_default_state(uni->dev);
	if (ret)
	dev_err(uni->dev, "%s: failed to select pinctrl state\n",
	__func__);

	return ret;
	}

	static int sti_uniperiph_dai_probe(struct snd_soc_dai *dai)
	{
	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
	struct sti_uniperiph_dai *dai_data = &priv->dai_data;

	/* DMA settings*/
	if (priv->dai_data.stream == SNDRV_PCM_STREAM_PLAYBACK)
	snd_soc_dai_init_dma_data(dai, &dai_data->dma_data, NULL);
	else
	snd_soc_dai_init_dma_data(dai, NULL, &dai_data->dma_data);

	dai_data->dma_data.addr = dai_data->uni->fifo_phys_address;
	dai_data->dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;

	return sti_uniperiph_dai_create_ctrl(dai);
	}

	static const struct snd_soc_dai_driver sti_uniperiph_dai_template = {
	.probe = sti_uniperiph_dai_probe,
	.suspend = sti_uniperiph_dai_suspend,
	.resume = sti_uniperiph_dai_resume
	};

	static const struct snd_soc_component_driver sti_uniperiph_dai_component = {
	.name = "sti_cpu_dai",
	};

	static int sti_uniperiph_cpu_dai_of(struct device_node *node,
	struct sti_uniperiph_data *priv)
	{
	struct device *dev = &priv->pdev->dev;
	struct sti_uniperiph_dai *dai_data = &priv->dai_data;
	struct snd_soc_dai_driver *dai = priv->dai;
	struct snd_soc_pcm_stream *stream;
	struct uniperif *uni;
	const struct of_device_id *of_id;
	const struct sti_uniperiph_dev_data *dev_data;
	const char *mode;
	int ret;

	/* Populate data structure depending on compatibility */
	of_id = of_match_node(snd_soc_sti_match, node);
	if (!of_id->data) {
	dev_err(dev, "data associated to device is missing\n");
	return -EINVAL;
	}
	dev_data = (struct sti_uniperiph_dev_data *)of_id->data;

	uni = devm_kzalloc(dev, sizeof(*uni), GFP_KERNEL);
	if (!uni)
	return -ENOMEM;

	uni->id = dev_data->id;
	uni->ver = dev_data->version;

	*dai = sti_uniperiph_dai_template;
	dai->name = dev_data->dai_names;

	/* Get resources */
	uni->mem_region = platform_get_resource(priv->pdev, IORESOURCE_MEM, 0);

	if (!uni->mem_region) {
	dev_err(dev, "Failed to get memory resource\n");
	return -ENODEV;
	}

	uni->base = devm_ioremap_resource(dev, uni->mem_region);

	if (IS_ERR(uni->base))
	return PTR_ERR(uni->base);

	uni->fifo_phys_address = uni->mem_region->start +
	UNIPERIF_FIFO_DATA_OFFSET(uni);

	uni->irq = platform_get_irq(priv->pdev, 0);
	if (uni->irq < 0) {
	dev_err(dev, "Failed to get IRQ resource\n");
	return -ENXIO;
	}

	uni->type = dev_data->type;

	/* check if player should be configured for tdm */
	if (dev_data->type & SND_ST_UNIPERIF_TYPE_TDM) {
	if (!of_property_read_string(node, "st,tdm-mode", &mode))
	uni->type = SND_ST_UNIPERIF_TYPE_TDM;
	else
	uni->type = SND_ST_UNIPERIF_TYPE_PCM;
	}

	dai_data->uni = uni;
	dai_data->stream = dev_data->stream;

	if (priv->dai_data.stream == SNDRV_PCM_STREAM_PLAYBACK) {
	ret = uni_player_init(priv->pdev, uni);
	stream = &dai->playback;
	} else {
	ret = uni_reader_init(priv->pdev, uni);
	stream = &dai->capture;
	}
	if (ret < 0)
	return ret;

	dai->ops = uni->dai_ops;

	stream->stream_name = dai->name;
	stream->channels_min = uni->hw->channels_min;
	stream->channels_max = uni->hw->channels_max;
	stream->rates = uni->hw->rates;
	stream->formats = uni->hw->formats;

	return 0;
	}

	static const struct snd_dmaengine_pcm_config dmaengine_pcm_config = {
	.prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
	};

	static int sti_uniperiph_probe(struct platform_device *pdev)
	{
	struct sti_uniperiph_data *priv;
	struct device_node *node = pdev->dev.of_node;
	int ret;

	/* Allocate the private data and the CPU_DAI array */
	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
	return -ENOMEM;
	priv->dai = devm_kzalloc(&pdev->dev, sizeof(*priv->dai), GFP_KERNEL);
	if (!priv->dai)
	return -ENOMEM;

	priv->pdev = pdev;

	ret = sti_uniperiph_cpu_dai_of(node, priv);

	dev_set_drvdata(&pdev->dev, priv);

	ret = devm_snd_soc_register_component(&pdev->dev,
	&sti_uniperiph_dai_component,
	priv->dai, 1);
	if (ret < 0)
	return ret;

	return devm_snd_dmaengine_pcm_register(&pdev->dev,
	&dmaengine_pcm_config, 0);
	}

	static struct platform_driver sti_uniperiph_driver = {
	.driver = {
	.name = "sti-uniperiph-dai",
	.of_match_table = snd_soc_sti_match,
	},
	.probe = sti_uniperiph_probe,
	};
	module_platform_driver(sti_uniperiph_driver);

	MODULE_DESCRIPTION("uniperipheral DAI driver");
	MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@st.com>");
	MODULE_LICENSE("GPL v2");