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/mutex.h> |
13 | #include <linux/platform_device.h> |
14 | #include <linux/slab.h> |
15 | #include <linux/pm_runtime.h> |
16 | #include <linux/iio/iio.h> |
17 | #include <linux/iio/consumer.h> |
18 | #include <linux/iio/adc/stm32-dfsdm-adc.h> |
19 | |
20 | #include <sound/pcm.h> |
21 | #include <sound/soc.h> |
22 | |
23 | #define STM32_ADFSDM_DRV_NAME "stm32-adfsdm" |
24 | |
25 | #define DFSDM_MAX_PERIOD_SIZE (PAGE_SIZE / 2) |
26 | #define DFSDM_MAX_PERIODS 6 |
27 | |
28 | struct stm32_adfsdm_priv { |
29 | struct snd_soc_dai_driver dai_drv; |
30 | struct snd_pcm_substream *substream; |
31 | struct device *dev; |
32 | |
33 | /* IIO */ |
34 | struct iio_channel *iio_ch; |
35 | struct iio_cb_buffer *iio_cb; |
36 | bool iio_active; |
37 | |
38 | /* PCM buffer */ |
39 | unsigned char *pcm_buff; |
40 | unsigned int pos; |
41 | |
42 | struct mutex lock; /* protect against race condition on iio state */ |
43 | }; |
44 | |
45 | static const struct snd_pcm_hardware stm32_adfsdm_pcm_hw = { |
46 | .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER | |
47 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_PAUSE, |
48 | .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE, |
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 | mutex_lock(&priv->lock); |
66 | if (priv->iio_active) { |
67 | iio_channel_stop_all_cb(cb_buff: priv->iio_cb); |
68 | priv->iio_active = false; |
69 | } |
70 | mutex_unlock(lock: &priv->lock); |
71 | } |
72 | |
73 | static int stm32_adfsdm_dai_prepare(struct snd_pcm_substream *substream, |
74 | struct snd_soc_dai *dai) |
75 | { |
76 | struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai); |
77 | int ret; |
78 | |
79 | mutex_lock(&priv->lock); |
80 | if (priv->iio_active) { |
81 | iio_channel_stop_all_cb(cb_buff: priv->iio_cb); |
82 | priv->iio_active = false; |
83 | } |
84 | |
85 | ret = iio_write_channel_attribute(chan: priv->iio_ch, |
86 | val: substream->runtime->rate, val2: 0, |
87 | attribute: IIO_CHAN_INFO_SAMP_FREQ); |
88 | if (ret < 0) { |
89 | dev_err(dai->dev, "%s: Failed to set %d sampling rate\n" , |
90 | __func__, substream->runtime->rate); |
91 | goto out; |
92 | } |
93 | |
94 | if (!priv->iio_active) { |
95 | ret = iio_channel_start_all_cb(cb_buff: priv->iio_cb); |
96 | if (!ret) |
97 | priv->iio_active = true; |
98 | else |
99 | dev_err(dai->dev, "%s: IIO channel start failed (%d)\n" , |
100 | __func__, ret); |
101 | } |
102 | |
103 | out: |
104 | mutex_unlock(lock: &priv->lock); |
105 | |
106 | return ret; |
107 | } |
108 | |
109 | static int stm32_adfsdm_set_sysclk(struct snd_soc_dai *dai, int clk_id, |
110 | unsigned int freq, int dir) |
111 | { |
112 | struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(dai); |
113 | ssize_t size; |
114 | char str_freq[10]; |
115 | |
116 | dev_dbg(dai->dev, "%s: Enter for freq %d\n" , __func__, freq); |
117 | |
118 | /* Set IIO frequency if CODEC is master as clock comes from SPI_IN */ |
119 | |
120 | snprintf(buf: str_freq, size: sizeof(str_freq), fmt: "%u\n" , freq); |
121 | size = iio_write_channel_ext_info(chan: priv->iio_ch, attr: "spi_clk_freq" , |
122 | buf: str_freq, len: sizeof(str_freq)); |
123 | if (size != sizeof(str_freq)) { |
124 | dev_err(dai->dev, "%s: Failed to set SPI clock\n" , |
125 | __func__); |
126 | return -EINVAL; |
127 | } |
128 | return 0; |
129 | } |
130 | |
131 | static const struct snd_soc_dai_ops stm32_adfsdm_dai_ops = { |
132 | .shutdown = stm32_adfsdm_shutdown, |
133 | .prepare = stm32_adfsdm_dai_prepare, |
134 | .set_sysclk = stm32_adfsdm_set_sysclk, |
135 | }; |
136 | |
137 | static const struct snd_soc_dai_driver stm32_adfsdm_dai = { |
138 | .capture = { |
139 | .channels_min = 1, |
140 | .channels_max = 1, |
141 | .formats = SNDRV_PCM_FMTBIT_S16_LE | |
142 | SNDRV_PCM_FMTBIT_S32_LE, |
143 | .rates = SNDRV_PCM_RATE_CONTINUOUS, |
144 | .rate_min = 8000, |
145 | .rate_max = 48000, |
146 | }, |
147 | .ops = &stm32_adfsdm_dai_ops, |
148 | }; |
149 | |
150 | static const struct snd_soc_component_driver stm32_adfsdm_dai_component = { |
151 | .name = "stm32_dfsdm_audio" , |
152 | .legacy_dai_naming = 1, |
153 | }; |
154 | |
155 | static void stm32_memcpy_32to16(void *dest, const void *src, size_t n) |
156 | { |
157 | unsigned int i = 0; |
158 | u16 *d = (u16 *)dest, *s = (u16 *)src; |
159 | |
160 | s++; |
161 | for (i = n >> 1; i > 0; i--) { |
162 | *d++ = *s++; |
163 | s++; |
164 | } |
165 | } |
166 | |
167 | static int stm32_afsdm_pcm_cb(const void *data, size_t size, void *private) |
168 | { |
169 | struct stm32_adfsdm_priv *priv = private; |
170 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(priv->substream); |
171 | u8 *pcm_buff = priv->pcm_buff; |
172 | u8 *src_buff = (u8 *)data; |
173 | unsigned int old_pos = priv->pos; |
174 | size_t buff_size = snd_pcm_lib_buffer_bytes(substream: priv->substream); |
175 | size_t period_size = snd_pcm_lib_period_bytes(substream: priv->substream); |
176 | size_t cur_size, src_size = size; |
177 | snd_pcm_format_t format = priv->substream->runtime->format; |
178 | |
179 | if (format == SNDRV_PCM_FORMAT_S16_LE) |
180 | src_size >>= 1; |
181 | cur_size = src_size; |
182 | |
183 | dev_dbg(rtd->dev, "%s: buff_add :%pK, pos = %d, size = %zu\n" , |
184 | __func__, &pcm_buff[priv->pos], priv->pos, src_size); |
185 | |
186 | if ((priv->pos + src_size) > buff_size) { |
187 | if (format == SNDRV_PCM_FORMAT_S16_LE) |
188 | stm32_memcpy_32to16(dest: &pcm_buff[priv->pos], src: src_buff, |
189 | n: buff_size - priv->pos); |
190 | else |
191 | memcpy(&pcm_buff[priv->pos], src_buff, |
192 | buff_size - priv->pos); |
193 | cur_size -= buff_size - priv->pos; |
194 | priv->pos = 0; |
195 | } |
196 | |
197 | if (format == SNDRV_PCM_FORMAT_S16_LE) |
198 | stm32_memcpy_32to16(dest: &pcm_buff[priv->pos], |
199 | src: &src_buff[src_size - cur_size], n: cur_size); |
200 | else |
201 | memcpy(&pcm_buff[priv->pos], &src_buff[src_size - cur_size], |
202 | cur_size); |
203 | |
204 | priv->pos = (priv->pos + cur_size) % buff_size; |
205 | |
206 | if (cur_size != src_size || (old_pos && (old_pos % period_size < size))) |
207 | snd_pcm_period_elapsed(substream: priv->substream); |
208 | |
209 | return 0; |
210 | } |
211 | |
212 | static int stm32_adfsdm_trigger(struct snd_soc_component *component, |
213 | struct snd_pcm_substream *substream, int cmd) |
214 | { |
215 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); |
216 | struct stm32_adfsdm_priv *priv = |
217 | snd_soc_dai_get_drvdata(snd_soc_rtd_to_cpu(rtd, 0)); |
218 | |
219 | switch (cmd) { |
220 | case SNDRV_PCM_TRIGGER_START: |
221 | case SNDRV_PCM_TRIGGER_RESUME: |
222 | priv->pos = 0; |
223 | return stm32_dfsdm_get_buff_cb(iio_dev: priv->iio_ch->indio_dev, |
224 | cb: stm32_afsdm_pcm_cb, private: priv); |
225 | case SNDRV_PCM_TRIGGER_SUSPEND: |
226 | case SNDRV_PCM_TRIGGER_STOP: |
227 | return stm32_dfsdm_release_buff_cb(iio_dev: priv->iio_ch->indio_dev); |
228 | } |
229 | |
230 | return -EINVAL; |
231 | } |
232 | |
233 | static int stm32_adfsdm_pcm_open(struct snd_soc_component *component, |
234 | struct snd_pcm_substream *substream) |
235 | { |
236 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); |
237 | struct stm32_adfsdm_priv *priv = snd_soc_dai_get_drvdata(snd_soc_rtd_to_cpu(rtd, 0)); |
238 | int ret; |
239 | |
240 | ret = snd_soc_set_runtime_hwparams(substream, hw: &stm32_adfsdm_pcm_hw); |
241 | if (!ret) |
242 | priv->substream = substream; |
243 | |
244 | return ret; |
245 | } |
246 | |
247 | static int stm32_adfsdm_pcm_close(struct snd_soc_component *component, |
248 | struct snd_pcm_substream *substream) |
249 | { |
250 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); |
251 | struct stm32_adfsdm_priv *priv = |
252 | snd_soc_dai_get_drvdata(snd_soc_rtd_to_cpu(rtd, 0)); |
253 | |
254 | priv->substream = NULL; |
255 | |
256 | return 0; |
257 | } |
258 | |
259 | static snd_pcm_uframes_t stm32_adfsdm_pcm_pointer( |
260 | struct snd_soc_component *component, |
261 | struct snd_pcm_substream *substream) |
262 | { |
263 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); |
264 | struct stm32_adfsdm_priv *priv = |
265 | snd_soc_dai_get_drvdata(snd_soc_rtd_to_cpu(rtd, 0)); |
266 | |
267 | return bytes_to_frames(runtime: substream->runtime, size: priv->pos); |
268 | } |
269 | |
270 | static int stm32_adfsdm_pcm_hw_params(struct snd_soc_component *component, |
271 | struct snd_pcm_substream *substream, |
272 | struct snd_pcm_hw_params *params) |
273 | { |
274 | struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); |
275 | struct stm32_adfsdm_priv *priv = |
276 | snd_soc_dai_get_drvdata(snd_soc_rtd_to_cpu(rtd, 0)); |
277 | |
278 | priv->pcm_buff = substream->runtime->dma_area; |
279 | |
280 | return iio_channel_cb_set_buffer_watermark(cb_buffer: priv->iio_cb, |
281 | watermark: params_period_size(p: params)); |
282 | } |
283 | |
284 | static int stm32_adfsdm_pcm_new(struct snd_soc_component *component, |
285 | struct snd_soc_pcm_runtime *rtd) |
286 | { |
287 | struct snd_pcm *pcm = rtd->pcm; |
288 | struct stm32_adfsdm_priv *priv = |
289 | snd_soc_dai_get_drvdata(snd_soc_rtd_to_cpu(rtd, 0)); |
290 | unsigned int size = DFSDM_MAX_PERIODS * DFSDM_MAX_PERIOD_SIZE; |
291 | |
292 | snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, |
293 | data: priv->dev, size, max: size); |
294 | return 0; |
295 | } |
296 | |
297 | static int stm32_adfsdm_dummy_cb(const void *data, void *private) |
298 | { |
299 | /* |
300 | * This dummy callback is requested by iio_channel_get_all_cb() API, |
301 | * but the stm32_dfsdm_get_buff_cb() API is used instead, to optimize |
302 | * DMA transfers. |
303 | */ |
304 | return 0; |
305 | } |
306 | |
307 | static void stm32_adfsdm_cleanup(void *data) |
308 | { |
309 | iio_channel_release_all_cb(cb_buffer: data); |
310 | } |
311 | |
312 | static struct snd_soc_component_driver stm32_adfsdm_soc_platform = { |
313 | .open = stm32_adfsdm_pcm_open, |
314 | .close = stm32_adfsdm_pcm_close, |
315 | .hw_params = stm32_adfsdm_pcm_hw_params, |
316 | .trigger = stm32_adfsdm_trigger, |
317 | .pointer = stm32_adfsdm_pcm_pointer, |
318 | .pcm_construct = stm32_adfsdm_pcm_new, |
319 | }; |
320 | |
321 | static const struct of_device_id stm32_adfsdm_of_match[] = { |
322 | {.compatible = "st,stm32h7-dfsdm-dai" }, |
323 | {} |
324 | }; |
325 | MODULE_DEVICE_TABLE(of, stm32_adfsdm_of_match); |
326 | |
327 | static int stm32_adfsdm_probe(struct platform_device *pdev) |
328 | { |
329 | struct stm32_adfsdm_priv *priv; |
330 | struct snd_soc_component *component; |
331 | int ret; |
332 | |
333 | priv = devm_kzalloc(dev: &pdev->dev, size: sizeof(*priv), GFP_KERNEL); |
334 | if (!priv) |
335 | return -ENOMEM; |
336 | |
337 | priv->dev = &pdev->dev; |
338 | priv->dai_drv = stm32_adfsdm_dai; |
339 | mutex_init(&priv->lock); |
340 | |
341 | dev_set_drvdata(dev: &pdev->dev, data: priv); |
342 | |
343 | ret = devm_snd_soc_register_component(dev: &pdev->dev, |
344 | component_driver: &stm32_adfsdm_dai_component, |
345 | dai_drv: &priv->dai_drv, num_dai: 1); |
346 | if (ret < 0) |
347 | return ret; |
348 | |
349 | /* Associate iio channel */ |
350 | priv->iio_ch = devm_iio_channel_get_all(dev: &pdev->dev); |
351 | if (IS_ERR(ptr: priv->iio_ch)) |
352 | return PTR_ERR(ptr: priv->iio_ch); |
353 | |
354 | priv->iio_cb = iio_channel_get_all_cb(dev: &pdev->dev, cb: &stm32_adfsdm_dummy_cb, NULL); |
355 | if (IS_ERR(ptr: priv->iio_cb)) |
356 | return PTR_ERR(ptr: priv->iio_cb); |
357 | |
358 | ret = devm_add_action_or_reset(&pdev->dev, stm32_adfsdm_cleanup, priv->iio_cb); |
359 | if (ret < 0) { |
360 | dev_err(&pdev->dev, "Unable to add action\n" ); |
361 | return ret; |
362 | } |
363 | |
364 | component = devm_kzalloc(dev: &pdev->dev, size: sizeof(*component), GFP_KERNEL); |
365 | if (!component) |
366 | return -ENOMEM; |
367 | |
368 | ret = snd_soc_component_initialize(component, |
369 | driver: &stm32_adfsdm_soc_platform, |
370 | dev: &pdev->dev); |
371 | if (ret < 0) |
372 | return ret; |
373 | #ifdef CONFIG_DEBUG_FS |
374 | component->debugfs_prefix = "pcm" ; |
375 | #endif |
376 | |
377 | ret = snd_soc_add_component(component, NULL, num_dai: 0); |
378 | if (ret < 0) { |
379 | dev_err(&pdev->dev, "%s: Failed to register PCM platform\n" , |
380 | __func__); |
381 | return ret; |
382 | } |
383 | |
384 | pm_runtime_enable(dev: &pdev->dev); |
385 | |
386 | return ret; |
387 | } |
388 | |
389 | static void stm32_adfsdm_remove(struct platform_device *pdev) |
390 | { |
391 | snd_soc_unregister_component(dev: &pdev->dev); |
392 | pm_runtime_disable(dev: &pdev->dev); |
393 | } |
394 | |
395 | static struct platform_driver stm32_adfsdm_driver = { |
396 | .driver = { |
397 | .name = STM32_ADFSDM_DRV_NAME, |
398 | .of_match_table = stm32_adfsdm_of_match, |
399 | }, |
400 | .probe = stm32_adfsdm_probe, |
401 | .remove_new = stm32_adfsdm_remove, |
402 | }; |
403 | |
404 | module_platform_driver(stm32_adfsdm_driver); |
405 | |
406 | MODULE_DESCRIPTION("stm32 DFSDM DAI driver" ); |
407 | MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@st.com>" ); |
408 | MODULE_LICENSE("GPL v2" ); |
409 | MODULE_ALIAS("platform:" STM32_ADFSDM_DRV_NAME); |
410 | |