~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/sti/sti_uniperif.c

Version: ~ [ linux-5.10-rc6 ] ~ [ linux-5.9.12 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.81 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.161 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.210 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.247 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.247 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (C) STMicroelectronics SA 2015
  3  * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
  4  *          for STMicroelectronics.
  5  * License terms:  GNU General Public License (GPL), version 2
  6  */
  7 
  8 #include <linux/module.h>
  9 #include <linux/pinctrl/consumer.h>
 10 
 11 #include "uniperif.h"
 12 
 13 /*
 14  * User frame size shall be 2, 4, 6 or 8 32-bits words length
 15  * (i.e. 8, 16, 24 or 32 bytes)
 16  * This constraint comes from allowed values for
 17  * UNIPERIF_I2S_FMT_NUM_CH register
 18  */
 19 #define UNIPERIF_MAX_FRAME_SZ 0x20
 20 #define UNIPERIF_ALLOWED_FRAME_SZ (0x08 | 0x10 | 0x18 | UNIPERIF_MAX_FRAME_SZ)
 21 
 22 int sti_uniperiph_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
 23                                unsigned int rx_mask, int slots,
 24                                int slot_width)
 25 {
 26         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
 27         struct uniperif *uni = priv->dai_data.uni;
 28         int i, frame_size, avail_slots;
 29 
 30         if (!UNIPERIF_TYPE_IS_TDM(uni)) {
 31                 dev_err(uni->dev, "cpu dai not in tdm mode\n");
 32                 return -EINVAL;
 33         }
 34 
 35         /* store info in unip context */
 36         uni->tdm_slot.slots = slots;
 37         uni->tdm_slot.slot_width = slot_width;
 38         /* unip is unidirectionnal */
 39         uni->tdm_slot.mask = (tx_mask != 0) ? tx_mask : rx_mask;
 40 
 41         /* number of available timeslots */
 42         for (i = 0, avail_slots = 0; i < uni->tdm_slot.slots; i++) {
 43                 if ((uni->tdm_slot.mask >> i) & 0x01)
 44                         avail_slots++;
 45         }
 46         uni->tdm_slot.avail_slots = avail_slots;
 47 
 48         /* frame size in bytes */
 49         frame_size = uni->tdm_slot.avail_slots * uni->tdm_slot.slot_width / 8;
 50 
 51         /* check frame size is allowed */
 52         if ((frame_size > UNIPERIF_MAX_FRAME_SZ) ||
 53             (frame_size & ~(int)UNIPERIF_ALLOWED_FRAME_SZ)) {
 54                 dev_err(uni->dev, "frame size not allowed: %d bytes\n",
 55                         frame_size);
 56                 return -EINVAL;
 57         }
 58 
 59         return 0;
 60 }
 61 
 62 int sti_uniperiph_fix_tdm_chan(struct snd_pcm_hw_params *params,
 63                                struct snd_pcm_hw_rule *rule)
 64 {
 65         struct uniperif *uni = rule->private;
 66         struct snd_interval t;
 67 
 68         t.min = uni->tdm_slot.avail_slots;
 69         t.max = uni->tdm_slot.avail_slots;
 70         t.openmin = 0;
 71         t.openmax = 0;
 72         t.integer = 0;
 73 
 74         return snd_interval_refine(hw_param_interval(params, rule->var), &t);
 75 }
 76 
 77 int sti_uniperiph_fix_tdm_format(struct snd_pcm_hw_params *params,
 78                                  struct snd_pcm_hw_rule *rule)
 79 {
 80         struct uniperif *uni = rule->private;
 81         struct snd_mask *maskp = hw_param_mask(params, rule->var);
 82         u64 format;
 83 
 84         switch (uni->tdm_slot.slot_width) {
 85         case 16:
 86                 format = SNDRV_PCM_FMTBIT_S16_LE;
 87                 break;
 88         case 32:
 89                 format = SNDRV_PCM_FMTBIT_S32_LE;
 90                 break;
 91         default:
 92                 dev_err(uni->dev, "format not supported: %d bits\n",
 93                         uni->tdm_slot.slot_width);
 94                 return -EINVAL;
 95         }
 96 
 97         maskp->bits[0] &= (u_int32_t)format;
 98         maskp->bits[1] &= (u_int32_t)(format >> 32);
 99         /* clear remaining indexes */
100         memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX - 64) / 8);
101 
102         if (!maskp->bits[0] && !maskp->bits[1])
103                 return -EINVAL;
104 
105         return 0;
106 }
107 
108 int sti_uniperiph_get_tdm_word_pos(struct uniperif *uni,
109                                    unsigned int *word_pos)
110 {
111         int slot_width = uni->tdm_slot.slot_width / 8;
112         int slots_num = uni->tdm_slot.slots;
113         unsigned int slots_mask = uni->tdm_slot.mask;
114         int i, j, k;
115         unsigned int word16_pos[4];
116 
117         /* word16_pos:
118          * word16_pos[0] = WORDX_LSB
119          * word16_pos[1] = WORDX_MSB,
120          * word16_pos[2] = WORDX+1_LSB
121          * word16_pos[3] = WORDX+1_MSB
122          */
123 
124         /* set unip word position */
125         for (i = 0, j = 0, k = 0; (i < slots_num) && (k < WORD_MAX); i++) {
126                 if ((slots_mask >> i) & 0x01) {
127                         word16_pos[j] = i * slot_width;
128 
129                         if (slot_width == 4) {
130                                 word16_pos[j + 1] = word16_pos[j] + 2;
131                                 j++;
132                         }
133                         j++;
134 
135                         if (j > 3) {
136                                 word_pos[k] = word16_pos[1] |
137                                               (word16_pos[0] << 8) |
138                                               (word16_pos[3] << 16) |
139                                               (word16_pos[2] << 24);
140                                 j = 0;
141                                 k++;
142                         }
143                 }
144         }
145 
146         return 0;
147 }
148 
149 /*
150  * sti_uniperiph_dai_create_ctrl
151  * This function is used to create Ctrl associated to DAI but also pcm device.
152  * Request is done by front end to associate ctrl with pcm device id
153  */
154 static int sti_uniperiph_dai_create_ctrl(struct snd_soc_dai *dai)
155 {
156         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
157         struct uniperif *uni = priv->dai_data.uni;
158         struct snd_kcontrol_new *ctrl;
159         int i;
160 
161         if (!uni->num_ctrls)
162                 return 0;
163 
164         for (i = 0; i < uni->num_ctrls; i++) {
165                 /*
166                  * Several Control can have same name. Controls are indexed on
167                  * Uniperipheral instance ID
168                  */
169                 ctrl = &uni->snd_ctrls[i];
170                 ctrl->index = uni->info->id;
171                 ctrl->device = uni->info->id;
172         }
173 
174         return snd_soc_add_dai_controls(dai, uni->snd_ctrls, uni->num_ctrls);
175 }
176 
177 /*
178  * DAI
179  */
180 int sti_uniperiph_dai_hw_params(struct snd_pcm_substream *substream,
181                                 struct snd_pcm_hw_params *params,
182                                 struct snd_soc_dai *dai)
183 {
184         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
185         struct uniperif *uni = priv->dai_data.uni;
186         struct snd_dmaengine_dai_dma_data *dma_data;
187         int transfer_size;
188 
189         if (uni->info->type == SND_ST_UNIPERIF_TYPE_TDM)
190                 /* transfer size = user frame size (in 32-bits FIFO cell) */
191                 transfer_size = snd_soc_params_to_frame_size(params) / 32;
192         else
193                 transfer_size = params_channels(params) * UNIPERIF_FIFO_FRAMES;
194 
195         dma_data = snd_soc_dai_get_dma_data(dai, substream);
196         dma_data->maxburst = transfer_size;
197 
198         return 0;
199 }
200 
201 int sti_uniperiph_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
202 {
203         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
204 
205         priv->dai_data.uni->daifmt = fmt;
206 
207         return 0;
208 }
209 
210 static int sti_uniperiph_dai_suspend(struct snd_soc_dai *dai)
211 {
212         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
213         struct uniperif *uni = priv->dai_data.uni;
214         int ret;
215 
216         /* The uniperipheral should be in stopped state */
217         if (uni->state != UNIPERIF_STATE_STOPPED) {
218                 dev_err(uni->dev, "%s: invalid uni state( %d)",
219                         __func__, (int)uni->state);
220                 return -EBUSY;
221         }
222 
223         /* Pinctrl: switch pinstate to sleep */
224         ret = pinctrl_pm_select_sleep_state(uni->dev);
225         if (ret)
226                 dev_err(uni->dev, "%s: failed to select pinctrl state",
227                         __func__);
228 
229         return ret;
230 }
231 
232 static int sti_uniperiph_dai_resume(struct snd_soc_dai *dai)
233 {
234         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
235         struct uniperif *uni = priv->dai_data.uni;
236         int ret;
237 
238         if (of_device_is_compatible(dai->dev->of_node, "st,sti-uni-player")) {
239                 ret = uni_player_resume(uni);
240                 if (ret)
241                         return ret;
242         }
243 
244         /* pinctrl: switch pinstate to default */
245         ret = pinctrl_pm_select_default_state(uni->dev);
246         if (ret)
247                 dev_err(uni->dev, "%s: failed to select pinctrl state",
248                         __func__);
249 
250         return ret;
251 }
252 
253 static int sti_uniperiph_dai_probe(struct snd_soc_dai *dai)
254 {
255         struct sti_uniperiph_data *priv = snd_soc_dai_get_drvdata(dai);
256         struct sti_uniperiph_dai *dai_data = &priv->dai_data;
257 
258         /* DMA settings*/
259         if (of_device_is_compatible(dai->dev->of_node, "st,sti-uni-player"))
260                 snd_soc_dai_init_dma_data(dai, &dai_data->dma_data, NULL);
261         else
262                 snd_soc_dai_init_dma_data(dai, NULL, &dai_data->dma_data);
263 
264         dai_data->dma_data.addr = dai_data->uni->fifo_phys_address;
265         dai_data->dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
266 
267         return sti_uniperiph_dai_create_ctrl(dai);
268 }
269 
270 static const struct snd_soc_dai_driver sti_uniperiph_dai_template = {
271         .probe = sti_uniperiph_dai_probe,
272         .suspend = sti_uniperiph_dai_suspend,
273         .resume = sti_uniperiph_dai_resume
274 };
275 
276 static const struct snd_soc_component_driver sti_uniperiph_dai_component = {
277         .name = "sti_cpu_dai",
278 };
279 
280 static int sti_uniperiph_cpu_dai_of(struct device_node *node,
281                                     struct sti_uniperiph_data *priv)
282 {
283         const char *str;
284         int ret;
285         struct device *dev = &priv->pdev->dev;
286         struct sti_uniperiph_dai *dai_data = &priv->dai_data;
287         struct snd_soc_dai_driver *dai = priv->dai;
288         struct snd_soc_pcm_stream *stream;
289         struct uniperif *uni;
290 
291         uni = devm_kzalloc(dev, sizeof(*uni), GFP_KERNEL);
292         if (!uni)
293                 return -ENOMEM;
294 
295         *dai = sti_uniperiph_dai_template;
296         ret = of_property_read_string(node, "dai-name", &str);
297         if (ret < 0) {
298                 dev_err(dev, "%s: dai name missing.\n", __func__);
299                 return -EINVAL;
300         }
301         dai->name = str;
302 
303         /* Get resources */
304         uni->mem_region = platform_get_resource(priv->pdev, IORESOURCE_MEM, 0);
305 
306         if (!uni->mem_region) {
307                 dev_err(dev, "Failed to get memory resource");
308                 return -ENODEV;
309         }
310 
311         uni->base = devm_ioremap_resource(dev, uni->mem_region);
312 
313         if (IS_ERR(uni->base))
314                 return PTR_ERR(uni->base);
315 
316         uni->fifo_phys_address = uni->mem_region->start +
317                                      UNIPERIF_FIFO_DATA_OFFSET(uni);
318 
319         uni->irq = platform_get_irq(priv->pdev, 0);
320         if (uni->irq < 0) {
321                 dev_err(dev, "Failed to get IRQ resource");
322                 return -ENXIO;
323         }
324 
325         dai_data->uni = uni;
326 
327         if (of_device_is_compatible(node, "st,sti-uni-player")) {
328                 uni_player_init(priv->pdev, uni);
329                 stream = &dai->playback;
330         } else {
331                 uni_reader_init(priv->pdev, uni);
332                 stream = &dai->capture;
333         }
334         dai->ops = uni->dai_ops;
335 
336         stream->stream_name = dai->name;
337         stream->channels_min = uni->hw->channels_min;
338         stream->channels_max = uni->hw->channels_max;
339         stream->rates = uni->hw->rates;
340         stream->formats = uni->hw->formats;
341 
342         return 0;
343 }
344 
345 static const struct snd_dmaengine_pcm_config dmaengine_pcm_config = {
346         .prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
347 };
348 
349 static int sti_uniperiph_probe(struct platform_device *pdev)
350 {
351         struct sti_uniperiph_data *priv;
352         struct device_node *node = pdev->dev.of_node;
353         int ret;
354 
355         /* Allocate the private data and the CPU_DAI array */
356         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
357         if (!priv)
358                 return -ENOMEM;
359         priv->dai = devm_kzalloc(&pdev->dev, sizeof(*priv->dai), GFP_KERNEL);
360         if (!priv->dai)
361                 return -ENOMEM;
362 
363         priv->pdev = pdev;
364 
365         ret = sti_uniperiph_cpu_dai_of(node, priv);
366 
367         dev_set_drvdata(&pdev->dev, priv);
368 
369         ret = devm_snd_soc_register_component(&pdev->dev,
370                                               &sti_uniperiph_dai_component,
371                                               priv->dai, 1);
372         if (ret < 0)
373                 return ret;
374 
375         return devm_snd_dmaengine_pcm_register(&pdev->dev,
376                                                &dmaengine_pcm_config, 0);
377 }
378 
379 static const struct of_device_id snd_soc_sti_match[] = {
380         { .compatible = "st,sti-uni-player", },
381         { .compatible = "st,sti-uni-reader", },
382         {},
383 };
384 
385 static struct platform_driver sti_uniperiph_driver = {
386         .driver = {
387                 .name = "sti-uniperiph-dai",
388                 .of_match_table = snd_soc_sti_match,
389         },
390         .probe = sti_uniperiph_probe,
391 };
392 module_platform_driver(sti_uniperiph_driver);
393 
394 MODULE_DESCRIPTION("uniperipheral DAI driver");
395 MODULE_AUTHOR("Arnaud Pouliquen <arnaud.pouliquen@st.com>");
396 MODULE_LICENSE("GPL v2");
397 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp