xref: /openbmc/linux/sound/soc/sti/sti_uniperif.c (revision 641de16b)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) STMicroelectronics SA 2015
4  * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
5  *          for STMicroelectronics.
6  */
7 
8 #include <linux/module.h>
9 #include <linux/pinctrl/consumer.h>
10 #include <linux/delay.h>
11 
12 #include "uniperif.h"
13 
14 /*
15  * User frame size shall be 2, 4, 6 or 8 32-bits words length
16  * (i.e. 8, 16, 24 or 32 bytes)
17  * This constraint comes from allowed values for
18  * UNIPERIF_I2S_FMT_NUM_CH register
19  */
20 #define UNIPERIF_MAX_FRAME_SZ 0x20
21 #define UNIPERIF_ALLOWED_FRAME_SZ (0x08 | 0x10 | 0x18 | UNIPERIF_MAX_FRAME_SZ)
22 
23 struct sti_uniperiph_dev_data {
24 	unsigned int id; /* Nb available player instances */
25 	unsigned int version; /* player IP version */
26 	unsigned int stream;
27 	const char *dai_names;
28 	enum uniperif_type type;
29 };
30 
31 static const struct sti_uniperiph_dev_data sti_uniplayer_hdmi = {
32 	.id = 0,
33 	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
34 	.stream = SNDRV_PCM_STREAM_PLAYBACK,
35 	.dai_names = "Uni Player #0 (HDMI)",
36 	.type = SND_ST_UNIPERIF_TYPE_HDMI
37 };
38 
39 static const struct sti_uniperiph_dev_data sti_uniplayer_pcm_out = {
40 	.id = 1,
41 	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
42 	.stream = SNDRV_PCM_STREAM_PLAYBACK,
43 	.dai_names = "Uni Player #1 (PCM OUT)",
44 	.type = SND_ST_UNIPERIF_TYPE_PCM | SND_ST_UNIPERIF_TYPE_TDM,
45 };
46 
47 static const struct sti_uniperiph_dev_data sti_uniplayer_dac = {
48 	.id = 2,
49 	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
50 	.stream = SNDRV_PCM_STREAM_PLAYBACK,
51 	.dai_names = "Uni Player #2 (DAC)",
52 	.type = SND_ST_UNIPERIF_TYPE_PCM,
53 };
54 
55 static const struct sti_uniperiph_dev_data sti_uniplayer_spdif = {
56 	.id = 3,
57 	.version = SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0,
58 	.stream = SNDRV_PCM_STREAM_PLAYBACK,
59 	.dai_names = "Uni Player #3 (SPDIF)",
60 	.type = SND_ST_UNIPERIF_TYPE_SPDIF
61 };
62 
63 static const struct sti_uniperiph_dev_data sti_unireader_pcm_in = {
64 	.id = 0,
65 	.version = SND_ST_UNIPERIF_VERSION_UNI_RDR_1_0,
66 	.stream = SNDRV_PCM_STREAM_CAPTURE,
67 	.dai_names = "Uni Reader #0 (PCM IN)",
68 	.type = SND_ST_UNIPERIF_TYPE_PCM | SND_ST_UNIPERIF_TYPE_TDM,
69 };
70 
71 static const struct sti_uniperiph_dev_data sti_unireader_hdmi_in = {
72 	.id = 1,
73 	.version = SND_ST_UNIPERIF_VERSION_UNI_RDR_1_0,
74 	.stream = SNDRV_PCM_STREAM_CAPTURE,
75 	.dai_names = "Uni Reader #1 (HDMI IN)",
76 	.type = SND_ST_UNIPERIF_TYPE_PCM,
77 };
78 
79 static const struct of_device_id snd_soc_sti_match[] = {
80 	{ .compatible = "st,stih407-uni-player-hdmi",
81 	  .data = &sti_uniplayer_hdmi
82 	},
83 	{ .compatible = "st,stih407-uni-player-pcm-out",
84 	  .data = &sti_uniplayer_pcm_out
85 	},
86 	{ .compatible = "st,stih407-uni-player-dac",
87 	  .data = &sti_uniplayer_dac
88 	},
89 	{ .compatible = "st,stih407-uni-player-spdif",
90 	  .data = &sti_uniplayer_spdif
91 	},
92 	{ .compatible = "st,stih407-uni-reader-pcm_in",
93 	  .data = &sti_unireader_pcm_in
94 	},
95 	{ .compatible = "st,stih407-uni-reader-hdmi",
96 	  .data = &sti_unireader_hdmi_in
97 	},
98 	{},
99 };
100 MODULE_DEVICE_TABLE(of, snd_soc_sti_match);
101 
sti_uniperiph_reset(struct uniperif * uni)102 int  sti_uniperiph_reset(struct uniperif *uni)
103 {
104 	int count = 10;
105 
106 	/* Reset uniperipheral uni */
107 	SET_UNIPERIF_SOFT_RST_SOFT_RST(uni);
108 
109 	if (uni->ver < SND_ST_UNIPERIF_VERSION_UNI_PLR_TOP_1_0) {
110 		while (GET_UNIPERIF_SOFT_RST_SOFT_RST(uni) && count) {
111 			udelay(5);
112 			count--;
113 		}
114 	}
115 
116 	if (!count) {
117 		dev_err(uni->dev, "Failed to reset uniperif\n");
118 		return -EIO;
119 	}
120 
121 	return 0;
122 }
123 
sti_uniperiph_set_tdm_slot(struct snd_soc_dai * dai,unsigned int tx_mask,unsigned int rx_mask,int slots,int slot_width)124 int sti_uniperiph_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
125 			       unsigned int rx_mask, int slots,
126 			       int slot_width)
127 {
128 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
129 	struct uniperif *uni = priv->dai_data.uni;
130 	int i, frame_size, avail_slots;
131 
132 	if (!UNIPERIF_TYPE_IS_TDM(uni)) {
133 		dev_err(uni->dev, "cpu dai not in tdm mode\n");
134 		return -EINVAL;
135 	}
136 
137 	/* store info in unip context */
138 	uni->tdm_slot.slots = slots;
139 	uni->tdm_slot.slot_width = slot_width;
140 	/* unip is unidirectionnal */
141 	uni->tdm_slot.mask = (tx_mask != 0) ? tx_mask : rx_mask;
142 
143 	/* number of available timeslots */
144 	for (i = 0, avail_slots = 0; i < uni->tdm_slot.slots; i++) {
145 		if ((uni->tdm_slot.mask >> i) & 0x01)
146 			avail_slots++;
147 	}
148 	uni->tdm_slot.avail_slots = avail_slots;
149 
150 	/* frame size in bytes */
151 	frame_size = uni->tdm_slot.avail_slots * uni->tdm_slot.slot_width / 8;
152 
153 	/* check frame size is allowed */
154 	if ((frame_size > UNIPERIF_MAX_FRAME_SZ) ||
155 	    (frame_size & ~(int)UNIPERIF_ALLOWED_FRAME_SZ)) {
156 		dev_err(uni->dev, "frame size not allowed: %d bytes\n",
157 			frame_size);
158 		return -EINVAL;
159 	}
160 
161 	return 0;
162 }
163 
sti_uniperiph_fix_tdm_chan(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)164 int sti_uniperiph_fix_tdm_chan(struct snd_pcm_hw_params *params,
165 			       struct snd_pcm_hw_rule *rule)
166 {
167 	struct uniperif *uni = rule->private;
168 	struct snd_interval t;
169 
170 	t.min = uni->tdm_slot.avail_slots;
171 	t.max = uni->tdm_slot.avail_slots;
172 	t.openmin = 0;
173 	t.openmax = 0;
174 	t.integer = 0;
175 
176 	return snd_interval_refine(hw_param_interval(params, rule->var), &t);
177 }
178 
sti_uniperiph_fix_tdm_format(struct snd_pcm_hw_params * params,struct snd_pcm_hw_rule * rule)179 int sti_uniperiph_fix_tdm_format(struct snd_pcm_hw_params *params,
180 				 struct snd_pcm_hw_rule *rule)
181 {
182 	struct uniperif *uni = rule->private;
183 	struct snd_mask *maskp = hw_param_mask(params, rule->var);
184 	u64 format;
185 
186 	switch (uni->tdm_slot.slot_width) {
187 	case 16:
188 		format = SNDRV_PCM_FMTBIT_S16_LE;
189 		break;
190 	case 32:
191 		format = SNDRV_PCM_FMTBIT_S32_LE;
192 		break;
193 	default:
194 		dev_err(uni->dev, "format not supported: %d bits\n",
195 			uni->tdm_slot.slot_width);
196 		return -EINVAL;
197 	}
198 
199 	maskp->bits[0] &= (u_int32_t)format;
200 	maskp->bits[1] &= (u_int32_t)(format >> 32);
201 	/* clear remaining indexes */
202 	memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX - 64) / 8);
203 
204 	if (!maskp->bits[0] && !maskp->bits[1])
205 		return -EINVAL;
206 
207 	return 0;
208 }
209 
sti_uniperiph_get_tdm_word_pos(struct uniperif * uni,unsigned int * word_pos)210 int sti_uniperiph_get_tdm_word_pos(struct uniperif *uni,
211 				   unsigned int *word_pos)
212 {
213 	int slot_width = uni->tdm_slot.slot_width / 8;
214 	int slots_num = uni->tdm_slot.slots;
215 	unsigned int slots_mask = uni->tdm_slot.mask;
216 	int i, j, k;
217 	unsigned int word16_pos[4];
218 
219 	/* word16_pos:
220 	 * word16_pos[0] = WORDX_LSB
221 	 * word16_pos[1] = WORDX_MSB,
222 	 * word16_pos[2] = WORDX+1_LSB
223 	 * word16_pos[3] = WORDX+1_MSB
224 	 */
225 
226 	/* set unip word position */
227 	for (i = 0, j = 0, k = 0; (i < slots_num) && (k < WORD_MAX); i++) {
228 		if ((slots_mask >> i) & 0x01) {
229 			word16_pos[j] = i * slot_width;
230 
231 			if (slot_width == 4) {
232 				word16_pos[j + 1] = word16_pos[j] + 2;
233 				j++;
234 			}
235 			j++;
236 
237 			if (j > 3) {
238 				word_pos[k] = word16_pos[1] |
239 					      (word16_pos[0] << 8) |
240 					      (word16_pos[3] << 16) |
241 					      (word16_pos[2] << 24);
242 				j = 0;
243 				k++;
244 			}
245 		}
246 	}
247 
248 	return 0;
249 }
250 
251 /*
252  * sti_uniperiph_dai_create_ctrl
253  * This function is used to create Ctrl associated to DAI but also pcm device.
254  * Request is done by front end to associate ctrl with pcm device id
255  */
sti_uniperiph_dai_create_ctrl(struct snd_soc_dai * dai)256 static int sti_uniperiph_dai_create_ctrl(struct snd_soc_dai *dai)
257 {
258 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
259 	struct uniperif *uni = priv->dai_data.uni;
260 	struct snd_kcontrol_new *ctrl;
261 	int i;
262 
263 	if (!uni->num_ctrls)
264 		return 0;
265 
266 	for (i = 0; i < uni->num_ctrls; i++) {
267 		/*
268 		 * Several Control can have same name. Controls are indexed on
269 		 * Uniperipheral instance ID
270 		 */
271 		ctrl = &uni->snd_ctrls[i];
272 		ctrl->index = uni->id;
273 		ctrl->device = uni->id;
274 	}
275 
276 	return snd_soc_add_dai_controls(dai, uni->snd_ctrls, uni->num_ctrls);
277 }
278 
279 /*
280  * DAI
281  */
sti_uniperiph_dai_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)282 int sti_uniperiph_dai_hw_params(struct snd_pcm_substream *substream,
283 				struct snd_pcm_hw_params *params,
284 				struct snd_soc_dai *dai)
285 {
286 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
287 	struct uniperif *uni = priv->dai_data.uni;
288 	struct snd_dmaengine_dai_dma_data *dma_data;
289 	int transfer_size;
290 
291 	if (uni->type == SND_ST_UNIPERIF_TYPE_TDM)
292 		/* transfer size = user frame size (in 32-bits FIFO cell) */
293 		transfer_size = snd_soc_params_to_frame_size(params) / 32;
294 	else
295 		transfer_size = params_channels(params) * UNIPERIF_FIFO_FRAMES;
296 
297 	dma_data = snd_soc_dai_get_dma_data(dai, substream);
298 	dma_data->maxburst = transfer_size;
299 
300 	return 0;
301 }
302 
sti_uniperiph_dai_set_fmt(struct snd_soc_dai * dai,unsigned int fmt)303 int sti_uniperiph_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
304 {
305 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
306 
307 	priv->dai_data.uni->daifmt = fmt;
308 
309 	return 0;
310 }
311 
sti_uniperiph_suspend(struct snd_soc_component * component)312 static int sti_uniperiph_suspend(struct snd_soc_component *component)
313 {
314 	struct sti_uniperiph_data *priv = snd_soc_component_get_drvdata(component);
315 	struct uniperif *uni = priv->dai_data.uni;
316 	int ret;
317 
318 	/* The uniperipheral should be in stopped state */
319 	if (uni->state != UNIPERIF_STATE_STOPPED) {
320 		dev_err(uni->dev, "%s: invalid uni state( %d)\n",
321 			__func__, (int)uni->state);
322 		return -EBUSY;
323 	}
324 
325 	/* Pinctrl: switch pinstate to sleep */
326 	ret = pinctrl_pm_select_sleep_state(uni->dev);
327 	if (ret)
328 		dev_err(uni->dev, "%s: failed to select pinctrl state\n",
329 			__func__);
330 
331 	return ret;
332 }
333 
sti_uniperiph_resume(struct snd_soc_component * component)334 static int sti_uniperiph_resume(struct snd_soc_component *component)
335 {
336 	struct sti_uniperiph_data *priv = snd_soc_component_get_drvdata(component);
337 	struct uniperif *uni = priv->dai_data.uni;
338 	int ret;
339 
340 	if (priv->dai_data.stream == SNDRV_PCM_STREAM_PLAYBACK) {
341 		ret = uni_player_resume(uni);
342 		if (ret)
343 			return ret;
344 	}
345 
346 	/* pinctrl: switch pinstate to default */
347 	ret = pinctrl_pm_select_default_state(uni->dev);
348 	if (ret)
349 		dev_err(uni->dev, "%s: failed to select pinctrl state\n",
350 			__func__);
351 
352 	return ret;
353 }
354 
sti_uniperiph_dai_probe(struct snd_soc_dai * dai)355 int sti_uniperiph_dai_probe(struct snd_soc_dai *dai)
356 {
357 	struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
358 	struct sti_uniperiph_dai *dai_data = &priv->dai_data;
359 
360 	/* DMA settings*/
361 	if (priv->dai_data.stream == SNDRV_PCM_STREAM_PLAYBACK)
362 		snd_soc_dai_init_dma_data(dai, &dai_data->dma_data, NULL);
363 	else
364 		snd_soc_dai_init_dma_data(dai, NULL, &dai_data->dma_data);
365 
366 	dai_data->dma_data.addr = dai_data->uni->fifo_phys_address;
367 	dai_data->dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
368 
369 	return sti_uniperiph_dai_create_ctrl(dai);
370 }
371 
372 static const struct snd_soc_dai_ops sti_uniperiph_dai_ops = {
373 	.probe = sti_uniperiph_dai_probe,
374 };
375 
376 static const struct snd_soc_dai_driver sti_uniperiph_dai_template = {
377 	.ops = &sti_uniperiph_dai_ops,
378 };
379 
380 static const struct snd_soc_component_driver sti_uniperiph_dai_component = {
381 	.name = "sti_cpu_dai",
382 	.suspend = sti_uniperiph_suspend,
383 	.resume = sti_uniperiph_resume,
384 	.legacy_dai_naming = 1,
385 };
386 
sti_uniperiph_cpu_dai_of(struct device_node * node,struct sti_uniperiph_data * priv)387 static int sti_uniperiph_cpu_dai_of(struct device_node *node,
388 				    struct sti_uniperiph_data *priv)
389 {
390 	struct device *dev = &priv->pdev->dev;
391 	struct sti_uniperiph_dai *dai_data = &priv->dai_data;
392 	struct snd_soc_dai_driver *dai = priv->dai;
393 	struct snd_soc_pcm_stream *stream;
394 	struct uniperif *uni;
395 	const struct of_device_id *of_id;
396 	const struct sti_uniperiph_dev_data *dev_data;
397 	const char *mode;
398 	int ret;
399 
400 	/* Populate data structure depending on compatibility */
401 	of_id = of_match_node(snd_soc_sti_match, node);
402 	if (!of_id->data) {
403 		dev_err(dev, "data associated to device is missing\n");
404 		return -EINVAL;
405 	}
406 	dev_data = (struct sti_uniperiph_dev_data *)of_id->data;
407 
408 	uni = devm_kzalloc(dev, sizeof(*uni), GFP_KERNEL);
409 	if (!uni)
410 		return -ENOMEM;
411 
412 	uni->id = dev_data->id;
413 	uni->ver = dev_data->version;
414 
415 	*dai = sti_uniperiph_dai_template;
416 	dai->name = dev_data->dai_names;
417 
418 	/* Get resources and base address */
419 	uni->base = devm_platform_get_and_ioremap_resource(priv->pdev, 0, &uni->mem_region);
420 	if (IS_ERR(uni->base))
421 		return PTR_ERR(uni->base);
422 
423 	uni->fifo_phys_address = uni->mem_region->start +
424 				     UNIPERIF_FIFO_DATA_OFFSET(uni);
425 
426 	uni->irq = platform_get_irq(priv->pdev, 0);
427 	if (uni->irq < 0)
428 		return -ENXIO;
429 
430 	uni->type = dev_data->type;
431 
432 	/* check if player should be configured for tdm */
433 	if (dev_data->type & SND_ST_UNIPERIF_TYPE_TDM) {
434 		if (!of_property_read_string(node, "st,tdm-mode", &mode))
435 			uni->type = SND_ST_UNIPERIF_TYPE_TDM;
436 		else
437 			uni->type = SND_ST_UNIPERIF_TYPE_PCM;
438 	}
439 
440 	dai_data->uni = uni;
441 	dai_data->stream = dev_data->stream;
442 
443 	if (priv->dai_data.stream == SNDRV_PCM_STREAM_PLAYBACK) {
444 		ret = uni_player_init(priv->pdev, uni);
445 		stream = &dai->playback;
446 	} else {
447 		ret = uni_reader_init(priv->pdev, uni);
448 		stream = &dai->capture;
449 	}
450 	if (ret < 0)
451 		return ret;
452 
453 	dai->ops = uni->dai_ops;
454 
455 	stream->stream_name = dai->name;
456 	stream->channels_min = uni->hw->channels_min;
457 	stream->channels_max = uni->hw->channels_max;
458 	stream->rates = uni->hw->rates;
459 	stream->formats = uni->hw->formats;
460 
461 	return 0;
462 }
463 
464 static const struct snd_dmaengine_pcm_config dmaengine_pcm_config = {
465 	.prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
466 };
467 
sti_uniperiph_probe(struct platform_device * pdev)468 static int sti_uniperiph_probe(struct platform_device *pdev)
469 {
470 	struct sti_uniperiph_data *priv;
471 	struct device_node *node = pdev->dev.of_node;
472 	int ret;
473 
474 	/* Allocate the private data and the CPU_DAI array */
475 	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
476 	if (!priv)
477 		return -ENOMEM;
478 	priv->dai = devm_kzalloc(&pdev->dev, sizeof(*priv->dai), GFP_KERNEL);
479 	if (!priv->dai)
480 		return -ENOMEM;
481 
482 	priv->pdev = pdev;
483 
484 	ret = sti_uniperiph_cpu_dai_of(node, priv);
485 	if (ret < 0)
486 		return ret;
487 
488 	dev_set_drvdata(&pdev->dev, priv);
489 
490 	ret = devm_snd_soc_register_component(&pdev->dev,
491 					      &sti_uniperiph_dai_component,
492 					      priv->dai, 1);
493 	if (ret < 0)
494 		return ret;
495 
496 	return devm_snd_dmaengine_pcm_register(&pdev->dev,
497 					       &dmaengine_pcm_config, 0);
498 }
499 
500 static struct platform_driver sti_uniperiph_driver = {
501 	.driver = {
502 		.name = "sti-uniperiph-dai",
503 		.of_match_table = snd_soc_sti_match,
504 	},
505 	.probe = sti_uniperiph_probe,
506 };
507 module_platform_driver(sti_uniperiph_driver);
508 
509 MODULE_DESCRIPTION("uniperipheral DAI driver");
510 MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@st.com>");
511 MODULE_LICENSE("GPL v2");
512