xref: /openbmc/linux/sound/soc/stm/stm32_adfsdm.c (revision ae40e94f)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * This file is part of STM32 DFSDM ASoC DAI driver
4  *
5  * Copyright (C) 2017, STMicroelectronics - All Rights Reserved
6  * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
7  *          Olivier Moysan <olivier.moysan@st.com>
8  */
9 
10 #include <linux/clk.h>
11 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/slab.h>
14 
15 #include <linux/iio/iio.h>
16 #include <linux/iio/consumer.h>
17 #include <linux/iio/adc/stm32-dfsdm-adc.h>
18 
19 #include <sound/pcm.h>
20 #include <sound/soc.h>
21 
22 #define STM32_ADFSDM_DRV_NAME "stm32-adfsdm"
23 
24 #define DFSDM_MAX_PERIOD_SIZE	(PAGE_SIZE / 2)
25 #define DFSDM_MAX_PERIODS	6
26 
27 struct stm32_adfsdm_priv {
28 	struct snd_soc_dai_driver dai_drv;
29 	struct snd_pcm_substream *substream;
30 	struct device *dev;
31 
32 	/* IIO */
33 	struct iio_channel *iio_ch;
34 	struct iio_cb_buffer *iio_cb;
35 	bool iio_active;
36 
37 	/* PCM buffer */
38 	unsigned char *pcm_buff;
39 	unsigned int pos;
40 };
41 
42 static const struct snd_pcm_hardware stm32_adfsdm_pcm_hw = {
43 	.info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
44 	    SNDRV_PCM_INFO_PAUSE,
45 	.formats = SNDRV_PCM_FMTBIT_S32_LE,
46 
47 	.rate_min = 8000,
48 	.rate_max = 32000,
49 
50 	.channels_min = 1,
51 	.channels_max = 1,
52 
53 	.periods_min = 2,
54 	.periods_max = DFSDM_MAX_PERIODS,
55 
56 	.period_bytes_max = DFSDM_MAX_PERIOD_SIZE,
57 	.buffer_bytes_max = DFSDM_MAX_PERIODS * DFSDM_MAX_PERIOD_SIZE
58 };
59 
60 static void stm32_adfsdm_shutdown(struct snd_pcm_substream *substream,
61 				  struct snd_soc_dai *dai)
62 {
63 	struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
64 
65 	if (priv->iio_active) {
66 		iio_channel_stop_all_cb(priv->iio_cb);
67 		priv->iio_active = false;
68 	}
69 }
70 
71 static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream,
72 				    struct snd_soc_dai *dai)
73 {
74 	struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
75 	int ret;
76 
77 	ret = iio_write_channel_attribute(priv->iio_ch,
78 					  substream->runtime->rate, 0,
79 					  IIO_CHAN_INFO_SAMP_FREQ);
80 	if (ret < 0) {
81 		dev_err(dai->dev, "%s: Failed to set %d sampling rate\n",
82 			__func__, substream->runtime->rate);
83 		return ret;
84 	}
85 
86 	if (!priv->iio_active) {
87 		ret = iio_channel_start_all_cb(priv->iio_cb);
88 		if (!ret)
89 			priv->iio_active = true;
90 		else
91 			dev_err(dai->dev, "%s: IIO channel start failed (%d)\n",
92 				__func__, ret);
93 	}
94 
95 	return ret;
96 }
97 
98 static int stm32_adfsdm_set_sysclk(struct snd_soc_dai *dai, int clk_id,
99 				   unsigned int freq, int dir)
100 {
101 	struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai);
102 	ssize_t size;
103 	char str_freq[10];
104 
105 	dev_dbg(dai->dev, "%s: Enter for freq %d\n", __func__, freq);
106 
107 	/* Set IIO frequency if CODEC is master as clock comes from SPI_IN */
108 
109 	snprintf(str_freq, sizeof(str_freq), "%d\n", freq);
110 	size = iio_write_channel_ext_info(priv->iio_ch, "spi_clk_freq",
111 					  str_freq, sizeof(str_freq));
112 	if (size != sizeof(str_freq)) {
113 		dev_err(dai->dev, "%s: Failed to set SPI clock\n",
114 			__func__);
115 		return -EINVAL;
116 	}
117 	return 0;
118 }
119 
120 static const struct snd_soc_dai_ops stm32_adfsdm_dai_ops = {
121 	.shutdown = stm32_adfsdm_shutdown,
122 	.prepare = stm32_adfsdm_dai_prepare,
123 	.set_sysclk = stm32_adfsdm_set_sysclk,
124 };
125 
126 static const struct snd_soc_dai_driver stm32_adfsdm_dai = {
127 	.capture = {
128 		    .channels_min = 1,
129 		    .channels_max = 1,
130 		    .formats = SNDRV_PCM_FMTBIT_S32_LE,
131 		    .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |
132 			      SNDRV_PCM_RATE_32000),
133 		    },
134 	.ops = &stm32_adfsdm_dai_ops,
135 };
136 
137 static const struct snd_soc_component_driver stm32_adfsdm_dai_component = {
138 	.name = "stm32_dfsdm_audio",
139 };
140 
141 static int stm32_afsdm_pcm_cb(const void *data, size_t size, void *private)
142 {
143 	struct stm32_adfsdm_priv *priv = private;
144 	struct snd_soc_pcm_runtime *rtd = priv->substream->private_data;
145 	u8 *pcm_buff = priv->pcm_buff;
146 	u8 *src_buff = (u8 *)data;
147 	unsigned int buff_size = snd_pcm_lib_buffer_bytes(priv->substream);
148 	unsigned int period_size = snd_pcm_lib_period_bytes(priv->substream);
149 	unsigned int old_pos = priv->pos;
150 	unsigned int cur_size = size;
151 
152 	dev_dbg(rtd->dev, "%s: buff_add :%pK, pos = %d, size = %zu\n",
153 		__func__, &pcm_buff[priv->pos], priv->pos, size);
154 
155 	if ((priv->pos + size) > buff_size) {
156 		memcpy(&pcm_buff[priv->pos], src_buff, buff_size - priv->pos);
157 		cur_size -= buff_size - priv->pos;
158 		priv->pos = 0;
159 	}
160 
161 	memcpy(&pcm_buff[priv->pos], &src_buff[size - cur_size], cur_size);
162 	priv->pos = (priv->pos + cur_size) % buff_size;
163 
164 	if (cur_size != size || (old_pos && (old_pos % period_size < size)))
165 		snd_pcm_period_elapsed(priv->substream);
166 
167 	return 0;
168 }
169 
170 static int stm32_adfsdm_trigger(struct snd_pcm_substream *substream, int cmd)
171 {
172 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
173 	struct stm32_adfsdm_priv *priv =
174 		snd_soc_dai_get_drvdata(rtd->cpu_dai);
175 
176 	switch (cmd) {
177 	case SNDRV_PCM_TRIGGER_START:
178 	case SNDRV_PCM_TRIGGER_RESUME:
179 		priv->pos = 0;
180 		return stm32_dfsdm_get_buff_cb(priv->iio_ch->indio_dev,
181 					       stm32_afsdm_pcm_cb, priv);
182 	case SNDRV_PCM_TRIGGER_SUSPEND:
183 	case SNDRV_PCM_TRIGGER_STOP:
184 		return stm32_dfsdm_release_buff_cb(priv->iio_ch->indio_dev);
185 	}
186 
187 	return -EINVAL;
188 }
189 
190 static int stm32_adfsdm_pcm_open(struct snd_pcm_substream *substream)
191 {
192 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
193 	struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(rtd->cpu_dai);
194 	int ret;
195 
196 	ret =  snd_soc_set_runtime_hwparams(substream, &stm32_adfsdm_pcm_hw);
197 	if (!ret)
198 		priv->substream = substream;
199 
200 	return ret;
201 }
202 
203 static int stm32_adfsdm_pcm_close(struct snd_pcm_substream *substream)
204 {
205 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
206 	struct stm32_adfsdm_priv *priv =
207 		snd_soc_dai_get_drvdata(rtd->cpu_dai);
208 
209 	snd_pcm_lib_free_pages(substream);
210 	priv->substream = NULL;
211 
212 	return 0;
213 }
214 
215 static snd_pcm_uframes_t stm32_adfsdm_pcm_pointer(
216 					    struct snd_pcm_substream *substream)
217 {
218 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
219 	struct stm32_adfsdm_priv *priv =
220 		snd_soc_dai_get_drvdata(rtd->cpu_dai);
221 
222 	return bytes_to_frames(substream->runtime, priv->pos);
223 }
224 
225 static int stm32_adfsdm_pcm_hw_params(struct snd_pcm_substream *substream,
226 				      struct snd_pcm_hw_params *params)
227 {
228 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
229 	struct stm32_adfsdm_priv *priv =
230 		snd_soc_dai_get_drvdata(rtd->cpu_dai);
231 	int ret;
232 
233 	ret =  snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
234 	if (ret < 0)
235 		return ret;
236 	priv->pcm_buff = substream->runtime->dma_area;
237 
238 	return iio_channel_cb_set_buffer_watermark(priv->iio_cb,
239 						   params_period_size(params));
240 }
241 
242 static int stm32_adfsdm_pcm_hw_free(struct snd_pcm_substream *substream)
243 {
244 	snd_pcm_lib_free_pages(substream);
245 
246 	return 0;
247 }
248 
249 static struct snd_pcm_ops stm32_adfsdm_pcm_ops = {
250 	.open		= stm32_adfsdm_pcm_open,
251 	.close		= stm32_adfsdm_pcm_close,
252 	.hw_params	= stm32_adfsdm_pcm_hw_params,
253 	.hw_free	= stm32_adfsdm_pcm_hw_free,
254 	.trigger	= stm32_adfsdm_trigger,
255 	.pointer	= stm32_adfsdm_pcm_pointer,
256 };
257 
258 static int stm32_adfsdm_pcm_new(struct snd_soc_pcm_runtime *rtd)
259 {
260 	struct snd_pcm *pcm = rtd->pcm;
261 	struct stm32_adfsdm_priv *priv =
262 		snd_soc_dai_get_drvdata(rtd->cpu_dai);
263 	unsigned int size = DFSDM_MAX_PERIODS * DFSDM_MAX_PERIOD_SIZE;
264 
265 	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
266 					      priv->dev, size, size);
267 	return 0;
268 }
269 
270 static void stm32_adfsdm_pcm_free(struct snd_pcm *pcm)
271 {
272 	struct snd_pcm_substream *substream;
273 
274 	substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
275 	if (substream)
276 		snd_pcm_lib_preallocate_free_for_all(pcm);
277 }
278 
279 static struct snd_soc_component_driver stm32_adfsdm_soc_platform = {
280 	.ops		= &stm32_adfsdm_pcm_ops,
281 	.pcm_new	= stm32_adfsdm_pcm_new,
282 	.pcm_free	= stm32_adfsdm_pcm_free,
283 };
284 
285 static const struct of_device_id stm32_adfsdm_of_match[] = {
286 	{.compatible = "st,stm32h7-dfsdm-dai"},
287 	{}
288 };
289 MODULE_DEVICE_TABLE(of, stm32_adfsdm_of_match);
290 
291 static int stm32_adfsdm_probe(struct platform_device *pdev)
292 {
293 	struct stm32_adfsdm_priv *priv;
294 	int ret;
295 
296 	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
297 	if (!priv)
298 		return -ENOMEM;
299 
300 	priv->dev = &pdev->dev;
301 	priv->dai_drv = stm32_adfsdm_dai;
302 
303 	dev_set_drvdata(&pdev->dev, priv);
304 
305 	ret = devm_snd_soc_register_component(&pdev->dev,
306 					      &stm32_adfsdm_dai_component,
307 					      &priv->dai_drv, 1);
308 	if (ret < 0)
309 		return ret;
310 
311 	/* Associate iio channel */
312 	priv->iio_ch  = devm_iio_channel_get_all(&pdev->dev);
313 	if (IS_ERR(priv->iio_ch))
314 		return PTR_ERR(priv->iio_ch);
315 
316 	priv->iio_cb = iio_channel_get_all_cb(&pdev->dev, NULL, NULL);
317 	if (IS_ERR(priv->iio_cb))
318 		return PTR_ERR(priv->iio_cb);
319 
320 	ret = devm_snd_soc_register_component(&pdev->dev,
321 					      &stm32_adfsdm_soc_platform,
322 					      NULL, 0);
323 	if (ret < 0)
324 		dev_err(&pdev->dev, "%s: Failed to register PCM platform\n",
325 			__func__);
326 
327 	return ret;
328 }
329 
330 static struct platform_driver stm32_adfsdm_driver = {
331 	.driver = {
332 		   .name = STM32_ADFSDM_DRV_NAME,
333 		   .of_match_table = stm32_adfsdm_of_match,
334 		   },
335 	.probe = stm32_adfsdm_probe,
336 };
337 
338 module_platform_driver(stm32_adfsdm_driver);
339 
340 MODULE_DESCRIPTION("stm32 DFSDM DAI driver");
341 MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@st.com>");
342 MODULE_LICENSE("GPL v2");
343 MODULE_ALIAS("platform:" STM32_ADFSDM_DRV_NAME);
344