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

TOMOYO Linux Cross Reference
Linux/sound/soc/qcom/qdsp6/q6asm-dai.c

Version: ~ [ linux-5.19-rc8 ] ~ [ linux-5.18.14 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.57 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.133 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.207 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.253 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.289 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.324 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ 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.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 // Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
  3 // Copyright (c) 2018, Linaro Limited
  4 
  5 #include <linux/init.h>
  6 #include <linux/err.h>
  7 #include <linux/module.h>
  8 #include <linux/platform_device.h>
  9 #include <linux/slab.h>
 10 #include <sound/soc.h>
 11 #include <sound/soc-dapm.h>
 12 #include <sound/pcm.h>
 13 #include <linux/spinlock.h>
 14 #include <sound/compress_driver.h>
 15 #include <asm/dma.h>
 16 #include <linux/dma-mapping.h>
 17 #include <linux/of_device.h>
 18 #include <sound/pcm_params.h>
 19 #include "q6asm.h"
 20 #include "q6routing.h"
 21 #include "q6dsp-errno.h"
 22 
 23 #define DRV_NAME        "q6asm-fe-dai"
 24 
 25 #define PLAYBACK_MIN_NUM_PERIODS    2
 26 #define PLAYBACK_MAX_NUM_PERIODS   8
 27 #define PLAYBACK_MAX_PERIOD_SIZE    65536
 28 #define PLAYBACK_MIN_PERIOD_SIZE    128
 29 #define CAPTURE_MIN_NUM_PERIODS     2
 30 #define CAPTURE_MAX_NUM_PERIODS     8
 31 #define CAPTURE_MAX_PERIOD_SIZE     4096
 32 #define CAPTURE_MIN_PERIOD_SIZE     320
 33 #define SID_MASK_DEFAULT        0xF
 34 
 35 /* Default values used if user space does not set */
 36 #define COMPR_PLAYBACK_MIN_FRAGMENT_SIZE (8 * 1024)
 37 #define COMPR_PLAYBACK_MAX_FRAGMENT_SIZE (128 * 1024)
 38 #define COMPR_PLAYBACK_MIN_NUM_FRAGMENTS (4)
 39 #define COMPR_PLAYBACK_MAX_NUM_FRAGMENTS (16 * 4)
 40 #define Q6ASM_DAI_TX_RX 0
 41 #define Q6ASM_DAI_TX    1
 42 #define Q6ASM_DAI_RX    2
 43 
 44 enum stream_state {
 45         Q6ASM_STREAM_IDLE = 0,
 46         Q6ASM_STREAM_STOPPED,
 47         Q6ASM_STREAM_RUNNING,
 48 };
 49 
 50 struct q6asm_dai_rtd {
 51         struct snd_pcm_substream *substream;
 52         struct snd_compr_stream *cstream;
 53         struct snd_compr_params codec_param;
 54         struct snd_dma_buffer dma_buffer;
 55         spinlock_t lock;
 56         phys_addr_t phys;
 57         unsigned int pcm_size;
 58         unsigned int pcm_count;
 59         unsigned int pcm_irq_pos;       /* IRQ position */
 60         unsigned int periods;
 61         unsigned int bytes_sent;
 62         unsigned int bytes_received;
 63         unsigned int copied_total;
 64         uint16_t bits_per_sample;
 65         uint16_t source; /* Encoding source bit mask */
 66         struct audio_client *audio_client;
 67         uint16_t session_id;
 68         enum stream_state state;
 69 };
 70 
 71 struct q6asm_dai_data {
 72         long long int sid;
 73 };
 74 
 75 static struct snd_pcm_hardware q6asm_dai_hardware_capture = {
 76         .info =                 (SNDRV_PCM_INFO_MMAP |
 77                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
 78                                 SNDRV_PCM_INFO_MMAP_VALID |
 79                                 SNDRV_PCM_INFO_INTERLEAVED |
 80                                 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME),
 81         .formats =              (SNDRV_PCM_FMTBIT_S16_LE |
 82                                 SNDRV_PCM_FMTBIT_S24_LE),
 83         .rates =                SNDRV_PCM_RATE_8000_48000,
 84         .rate_min =             8000,
 85         .rate_max =             48000,
 86         .channels_min =         1,
 87         .channels_max =         4,
 88         .buffer_bytes_max =     CAPTURE_MAX_NUM_PERIODS *
 89                                 CAPTURE_MAX_PERIOD_SIZE,
 90         .period_bytes_min =     CAPTURE_MIN_PERIOD_SIZE,
 91         .period_bytes_max =     CAPTURE_MAX_PERIOD_SIZE,
 92         .periods_min =          CAPTURE_MIN_NUM_PERIODS,
 93         .periods_max =          CAPTURE_MAX_NUM_PERIODS,
 94         .fifo_size =            0,
 95 };
 96 
 97 static struct snd_pcm_hardware q6asm_dai_hardware_playback = {
 98         .info =                 (SNDRV_PCM_INFO_MMAP |
 99                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
100                                 SNDRV_PCM_INFO_MMAP_VALID |
101                                 SNDRV_PCM_INFO_INTERLEAVED |
102                                 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME),
103         .formats =              (SNDRV_PCM_FMTBIT_S16_LE |
104                                 SNDRV_PCM_FMTBIT_S24_LE),
105         .rates =                SNDRV_PCM_RATE_8000_192000,
106         .rate_min =             8000,
107         .rate_max =             192000,
108         .channels_min =         1,
109         .channels_max =         8,
110         .buffer_bytes_max =     (PLAYBACK_MAX_NUM_PERIODS *
111                                 PLAYBACK_MAX_PERIOD_SIZE),
112         .period_bytes_min =     PLAYBACK_MIN_PERIOD_SIZE,
113         .period_bytes_max =     PLAYBACK_MAX_PERIOD_SIZE,
114         .periods_min =          PLAYBACK_MIN_NUM_PERIODS,
115         .periods_max =          PLAYBACK_MAX_NUM_PERIODS,
116         .fifo_size =            0,
117 };
118 
119 #define Q6ASM_FEDAI_DRIVER(num) { \
120                 .playback = {                                           \
121                         .stream_name = "MultiMedia"#num" Playback",     \
122                         .rates = (SNDRV_PCM_RATE_8000_192000|           \
123                                         SNDRV_PCM_RATE_KNOT),           \
124                         .formats = (SNDRV_PCM_FMTBIT_S16_LE |           \
125                                         SNDRV_PCM_FMTBIT_S24_LE),       \
126                         .channels_min = 1,                              \
127                         .channels_max = 8,                              \
128                         .rate_min =     8000,                           \
129                         .rate_max =     192000,                         \
130                 },                                                      \
131                 .capture = {                                            \
132                         .stream_name = "MultiMedia"#num" Capture",      \
133                         .rates = (SNDRV_PCM_RATE_8000_48000|            \
134                                         SNDRV_PCM_RATE_KNOT),           \
135                         .formats = (SNDRV_PCM_FMTBIT_S16_LE |           \
136                                     SNDRV_PCM_FMTBIT_S24_LE),           \
137                         .channels_min = 1,                              \
138                         .channels_max = 4,                              \
139                         .rate_min =     8000,                           \
140                         .rate_max =     48000,                          \
141                 },                                                      \
142                 .name = "MultiMedia"#num,                               \
143                 .id = MSM_FRONTEND_DAI_MULTIMEDIA##num,                 \
144         }
145 
146 /* Conventional and unconventional sample rate supported */
147 static unsigned int supported_sample_rates[] = {
148         8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000,
149         88200, 96000, 176400, 192000
150 };
151 
152 static struct snd_pcm_hw_constraint_list constraints_sample_rates = {
153         .count = ARRAY_SIZE(supported_sample_rates),
154         .list = supported_sample_rates,
155         .mask = 0,
156 };
157 
158 static const struct snd_compr_codec_caps q6asm_compr_caps = {
159         .num_descriptors = 1,
160         .descriptor[0].max_ch = 2,
161         .descriptor[0].sample_rates = { 8000, 11025, 12000, 16000, 22050,
162                                         24000, 32000, 44100, 48000, 88200,
163                                         96000, 176400, 192000 },
164         .descriptor[0].num_sample_rates = 13,
165         .descriptor[0].bit_rate[0] = 320,
166         .descriptor[0].bit_rate[1] = 128,
167         .descriptor[0].num_bitrates = 2,
168         .descriptor[0].profiles = 0,
169         .descriptor[0].modes = SND_AUDIOCHANMODE_MP3_STEREO,
170         .descriptor[0].formats = 0,
171 };
172 
173 static void event_handler(uint32_t opcode, uint32_t token,
174                           uint32_t *payload, void *priv)
175 {
176         struct q6asm_dai_rtd *prtd = priv;
177         struct snd_pcm_substream *substream = prtd->substream;
178 
179         switch (opcode) {
180         case ASM_CLIENT_EVENT_CMD_RUN_DONE:
181                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
182                         q6asm_write_async(prtd->audio_client,
183                                    prtd->pcm_count, 0, 0, NO_TIMESTAMP);
184                 break;
185         case ASM_CLIENT_EVENT_CMD_EOS_DONE:
186                 prtd->state = Q6ASM_STREAM_STOPPED;
187                 break;
188         case ASM_CLIENT_EVENT_DATA_WRITE_DONE: {
189                 prtd->pcm_irq_pos += prtd->pcm_count;
190                 snd_pcm_period_elapsed(substream);
191                 if (prtd->state == Q6ASM_STREAM_RUNNING)
192                         q6asm_write_async(prtd->audio_client,
193                                            prtd->pcm_count, 0, 0, NO_TIMESTAMP);
194 
195                 break;
196                 }
197         case ASM_CLIENT_EVENT_DATA_READ_DONE:
198                 prtd->pcm_irq_pos += prtd->pcm_count;
199                 snd_pcm_period_elapsed(substream);
200                 if (prtd->state == Q6ASM_STREAM_RUNNING)
201                         q6asm_read(prtd->audio_client);
202 
203                 break;
204         default:
205                 break;
206         }
207 }
208 
209 static int q6asm_dai_prepare(struct snd_soc_component *component,
210                              struct snd_pcm_substream *substream)
211 {
212         struct snd_pcm_runtime *runtime = substream->runtime;
213         struct snd_soc_pcm_runtime *soc_prtd = substream->private_data;
214         struct q6asm_dai_rtd *prtd = runtime->private_data;
215         struct q6asm_dai_data *pdata;
216         int ret, i;
217 
218         pdata = snd_soc_component_get_drvdata(component);
219         if (!pdata)
220                 return -EINVAL;
221 
222         if (!prtd || !prtd->audio_client) {
223                 pr_err("%s: private data null or audio client freed\n",
224                         __func__);
225                 return -EINVAL;
226         }
227 
228         prtd->pcm_count = snd_pcm_lib_period_bytes(substream);
229         prtd->pcm_irq_pos = 0;
230         /* rate and channels are sent to audio driver */
231         if (prtd->state) {
232                 /* clear the previous setup if any  */
233                 q6asm_cmd(prtd->audio_client, CMD_CLOSE);
234                 q6asm_unmap_memory_regions(substream->stream,
235                                            prtd->audio_client);
236                 q6routing_stream_close(soc_prtd->dai_link->id,
237                                          substream->stream);
238         }
239 
240         ret = q6asm_map_memory_regions(substream->stream, prtd->audio_client,
241                                        prtd->phys,
242                                        (prtd->pcm_size / prtd->periods),
243                                        prtd->periods);
244 
245         if (ret < 0) {
246                 pr_err("Audio Start: Buffer Allocation failed rc = %d\n",
247                                                         ret);
248                 return -ENOMEM;
249         }
250 
251         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
252                 ret = q6asm_open_write(prtd->audio_client, FORMAT_LINEAR_PCM,
253                                        prtd->bits_per_sample);
254         } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
255                 ret = q6asm_open_read(prtd->audio_client, FORMAT_LINEAR_PCM,
256                                        prtd->bits_per_sample);
257         }
258 
259         if (ret < 0) {
260                 pr_err("%s: q6asm_open_write failed\n", __func__);
261                 q6asm_audio_client_free(prtd->audio_client);
262                 prtd->audio_client = NULL;
263                 return -ENOMEM;
264         }
265 
266         prtd->session_id = q6asm_get_session_id(prtd->audio_client);
267         ret = q6routing_stream_open(soc_prtd->dai_link->id, LEGACY_PCM_MODE,
268                               prtd->session_id, substream->stream);
269         if (ret) {
270                 pr_err("%s: stream reg failed ret:%d\n", __func__, ret);
271                 return ret;
272         }
273 
274         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
275                 ret = q6asm_media_format_block_multi_ch_pcm(
276                                 prtd->audio_client, runtime->rate,
277                                 runtime->channels, NULL,
278                                 prtd->bits_per_sample);
279         } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
280                 ret = q6asm_enc_cfg_blk_pcm_format_support(prtd->audio_client,
281                                         runtime->rate, runtime->channels,
282                                         prtd->bits_per_sample);
283 
284                 /* Queue the buffers */
285                 for (i = 0; i < runtime->periods; i++)
286                         q6asm_read(prtd->audio_client);
287 
288         }
289         if (ret < 0)
290                 pr_info("%s: CMD Format block failed\n", __func__);
291 
292         prtd->state = Q6ASM_STREAM_RUNNING;
293 
294         return 0;
295 }
296 
297 static int q6asm_dai_trigger(struct snd_soc_component *component,
298                              struct snd_pcm_substream *substream, int cmd)
299 {
300         int ret = 0;
301         struct snd_pcm_runtime *runtime = substream->runtime;
302         struct q6asm_dai_rtd *prtd = runtime->private_data;
303 
304         switch (cmd) {
305         case SNDRV_PCM_TRIGGER_START:
306         case SNDRV_PCM_TRIGGER_RESUME:
307         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
308                 ret = q6asm_run_nowait(prtd->audio_client, 0, 0, 0);
309                 break;
310         case SNDRV_PCM_TRIGGER_STOP:
311                 prtd->state = Q6ASM_STREAM_STOPPED;
312                 ret = q6asm_cmd_nowait(prtd->audio_client, CMD_EOS);
313                 break;
314         case SNDRV_PCM_TRIGGER_SUSPEND:
315         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
316                 ret = q6asm_cmd_nowait(prtd->audio_client, CMD_PAUSE);
317                 break;
318         default:
319                 ret = -EINVAL;
320                 break;
321         }
322 
323         return ret;
324 }
325 
326 static int q6asm_dai_open(struct snd_soc_component *component,
327                           struct snd_pcm_substream *substream)
328 {
329         struct snd_pcm_runtime *runtime = substream->runtime;
330         struct snd_soc_pcm_runtime *soc_prtd = substream->private_data;
331         struct snd_soc_dai *cpu_dai = soc_prtd->cpu_dai;
332         struct q6asm_dai_rtd *prtd;
333         struct q6asm_dai_data *pdata;
334         struct device *dev = component->dev;
335         int ret = 0;
336         int stream_id;
337 
338         stream_id = cpu_dai->driver->id;
339 
340         pdata = snd_soc_component_get_drvdata(component);
341         if (!pdata) {
342                 pr_err("Drv data not found ..\n");
343                 return -EINVAL;
344         }
345 
346         prtd = kzalloc(sizeof(struct q6asm_dai_rtd), GFP_KERNEL);
347         if (prtd == NULL)
348                 return -ENOMEM;
349 
350         prtd->substream = substream;
351         prtd->audio_client = q6asm_audio_client_alloc(dev,
352                                 (q6asm_cb)event_handler, prtd, stream_id,
353                                 LEGACY_PCM_MODE);
354         if (IS_ERR(prtd->audio_client)) {
355                 pr_info("%s: Could not allocate memory\n", __func__);
356                 ret = PTR_ERR(prtd->audio_client);
357                 kfree(prtd);
358                 return ret;
359         }
360 
361         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
362                 runtime->hw = q6asm_dai_hardware_playback;
363         else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
364                 runtime->hw = q6asm_dai_hardware_capture;
365 
366         ret = snd_pcm_hw_constraint_list(runtime, 0,
367                                 SNDRV_PCM_HW_PARAM_RATE,
368                                 &constraints_sample_rates);
369         if (ret < 0)
370                 pr_info("snd_pcm_hw_constraint_list failed\n");
371         /* Ensure that buffer size is a multiple of period size */
372         ret = snd_pcm_hw_constraint_integer(runtime,
373                                             SNDRV_PCM_HW_PARAM_PERIODS);
374         if (ret < 0)
375                 pr_info("snd_pcm_hw_constraint_integer failed\n");
376 
377         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
378                 ret = snd_pcm_hw_constraint_minmax(runtime,
379                         SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
380                         PLAYBACK_MIN_NUM_PERIODS * PLAYBACK_MIN_PERIOD_SIZE,
381                         PLAYBACK_MAX_NUM_PERIODS * PLAYBACK_MAX_PERIOD_SIZE);
382                 if (ret < 0) {
383                         pr_err("constraint for buffer bytes min max ret = %d\n",
384                                                                         ret);
385                 }
386         }
387 
388         ret = snd_pcm_hw_constraint_step(runtime, 0,
389                 SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 32);
390         if (ret < 0) {
391                 pr_err("constraint for period bytes step ret = %d\n",
392                                                                 ret);
393         }
394         ret = snd_pcm_hw_constraint_step(runtime, 0,
395                 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 32);
396         if (ret < 0) {
397                 pr_err("constraint for buffer bytes step ret = %d\n",
398                                                                 ret);
399         }
400 
401         runtime->private_data = prtd;
402 
403         snd_soc_set_runtime_hwparams(substream, &q6asm_dai_hardware_playback);
404 
405         runtime->dma_bytes = q6asm_dai_hardware_playback.buffer_bytes_max;
406 
407 
408         if (pdata->sid < 0)
409                 prtd->phys = substream->dma_buffer.addr;
410         else
411                 prtd->phys = substream->dma_buffer.addr | (pdata->sid << 32);
412 
413         snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
414 
415         return 0;
416 }
417 
418 static int q6asm_dai_close(struct snd_soc_component *component,
419                            struct snd_pcm_substream *substream)
420 {
421         struct snd_pcm_runtime *runtime = substream->runtime;
422         struct snd_soc_pcm_runtime *soc_prtd = substream->private_data;
423         struct q6asm_dai_rtd *prtd = runtime->private_data;
424 
425         if (prtd->audio_client) {
426                 if (prtd->state)
427                         q6asm_cmd(prtd->audio_client, CMD_CLOSE);
428 
429                 q6asm_unmap_memory_regions(substream->stream,
430                                            prtd->audio_client);
431                 q6asm_audio_client_free(prtd->audio_client);
432                 prtd->audio_client = NULL;
433         }
434         q6routing_stream_close(soc_prtd->dai_link->id,
435                                                 substream->stream);
436         kfree(prtd);
437         return 0;
438 }
439 
440 static snd_pcm_uframes_t q6asm_dai_pointer(struct snd_soc_component *component,
441                                            struct snd_pcm_substream *substream)
442 {
443 
444         struct snd_pcm_runtime *runtime = substream->runtime;
445         struct q6asm_dai_rtd *prtd = runtime->private_data;
446 
447         if (prtd->pcm_irq_pos >= prtd->pcm_size)
448                 prtd->pcm_irq_pos = 0;
449 
450         return bytes_to_frames(runtime, (prtd->pcm_irq_pos));
451 }
452 
453 static int q6asm_dai_mmap(struct snd_soc_component *component,
454                           struct snd_pcm_substream *substream,
455                           struct vm_area_struct *vma)
456 {
457         struct snd_pcm_runtime *runtime = substream->runtime;
458         struct device *dev = component->dev;
459 
460         return dma_mmap_coherent(dev, vma,
461                         runtime->dma_area, runtime->dma_addr,
462                         runtime->dma_bytes);
463 }
464 
465 static int q6asm_dai_hw_params(struct snd_soc_component *component,
466                                struct snd_pcm_substream *substream,
467                                struct snd_pcm_hw_params *params)
468 {
469         struct snd_pcm_runtime *runtime = substream->runtime;
470         struct q6asm_dai_rtd *prtd = runtime->private_data;
471 
472         prtd->pcm_size = params_buffer_bytes(params);
473         prtd->periods = params_periods(params);
474 
475         switch (params_format(params)) {
476         case SNDRV_PCM_FORMAT_S16_LE:
477                 prtd->bits_per_sample = 16;
478                 break;
479         case SNDRV_PCM_FORMAT_S24_LE:
480                 prtd->bits_per_sample = 24;
481                 break;
482         }
483 
484         return 0;
485 }
486 
487 static void compress_event_handler(uint32_t opcode, uint32_t token,
488                                    uint32_t *payload, void *priv)
489 {
490         struct q6asm_dai_rtd *prtd = priv;
491         struct snd_compr_stream *substream = prtd->cstream;
492         unsigned long flags;
493         uint64_t avail;
494 
495         switch (opcode) {
496         case ASM_CLIENT_EVENT_CMD_RUN_DONE:
497                 spin_lock_irqsave(&prtd->lock, flags);
498                 if (!prtd->bytes_sent) {
499                         q6asm_write_async(prtd->audio_client, prtd->pcm_count,
500                                           0, 0, NO_TIMESTAMP);
501                         prtd->bytes_sent += prtd->pcm_count;
502                 }
503 
504                 spin_unlock_irqrestore(&prtd->lock, flags);
505                 break;
506 
507         case ASM_CLIENT_EVENT_CMD_EOS_DONE:
508                 prtd->state = Q6ASM_STREAM_STOPPED;
509                 break;
510 
511         case ASM_CLIENT_EVENT_DATA_WRITE_DONE:
512                 spin_lock_irqsave(&prtd->lock, flags);
513 
514                 prtd->copied_total += prtd->pcm_count;
515                 snd_compr_fragment_elapsed(substream);
516 
517                 if (prtd->state != Q6ASM_STREAM_RUNNING) {
518                         spin_unlock_irqrestore(&prtd->lock, flags);
519                         break;
520                 }
521 
522                 avail = prtd->bytes_received - prtd->bytes_sent;
523 
524                 if (avail >= prtd->pcm_count) {
525                         q6asm_write_async(prtd->audio_client,
526                                            prtd->pcm_count, 0, 0, NO_TIMESTAMP);
527                         prtd->bytes_sent += prtd->pcm_count;
528                 }
529 
530                 spin_unlock_irqrestore(&prtd->lock, flags);
531                 break;
532 
533         default:
534                 break;
535         }
536 }
537 
538 static int q6asm_dai_compr_open(struct snd_compr_stream *stream)
539 {
540         struct snd_soc_pcm_runtime *rtd = stream->private_data;
541         struct snd_soc_component *c = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
542         struct snd_compr_runtime *runtime = stream->runtime;
543         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
544         struct q6asm_dai_data *pdata;
545         struct device *dev = c->dev;
546         struct q6asm_dai_rtd *prtd;
547         int stream_id, size, ret;
548 
549         stream_id = cpu_dai->driver->id;
550         pdata = snd_soc_component_get_drvdata(c);
551         if (!pdata) {
552                 dev_err(dev, "Drv data not found ..\n");
553                 return -EINVAL;
554         }
555 
556         prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
557         if (!prtd)
558                 return -ENOMEM;
559 
560         prtd->cstream = stream;
561         prtd->audio_client = q6asm_audio_client_alloc(dev,
562                                         (q6asm_cb)compress_event_handler,
563                                         prtd, stream_id, LEGACY_PCM_MODE);
564         if (IS_ERR(prtd->audio_client)) {
565                 dev_err(dev, "Could not allocate memory\n");
566                 ret = PTR_ERR(prtd->audio_client);
567                 goto free_prtd;
568         }
569 
570         size = COMPR_PLAYBACK_MAX_FRAGMENT_SIZE *
571                         COMPR_PLAYBACK_MAX_NUM_FRAGMENTS;
572         ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, dev, size,
573                                   &prtd->dma_buffer);
574         if (ret) {
575                 dev_err(dev, "Cannot allocate buffer(s)\n");
576                 goto free_client;
577         }
578 
579         if (pdata->sid < 0)
580                 prtd->phys = prtd->dma_buffer.addr;
581         else
582                 prtd->phys = prtd->dma_buffer.addr | (pdata->sid << 32);
583 
584         snd_compr_set_runtime_buffer(stream, &prtd->dma_buffer);
585         spin_lock_init(&prtd->lock);
586         runtime->private_data = prtd;
587 
588         return 0;
589 
590 free_client:
591         q6asm_audio_client_free(prtd->audio_client);
592 free_prtd:
593         kfree(prtd);
594 
595         return ret;
596 }
597 
598 static int q6asm_dai_compr_free(struct snd_compr_stream *stream)
599 {
600         struct snd_compr_runtime *runtime = stream->runtime;
601         struct q6asm_dai_rtd *prtd = runtime->private_data;
602         struct snd_soc_pcm_runtime *rtd = stream->private_data;
603 
604         if (prtd->audio_client) {
605                 if (prtd->state)
606                         q6asm_cmd(prtd->audio_client, CMD_CLOSE);
607 
608                 snd_dma_free_pages(&prtd->dma_buffer);
609                 q6asm_unmap_memory_regions(stream->direction,
610                                            prtd->audio_client);
611                 q6asm_audio_client_free(prtd->audio_client);
612                 prtd->audio_client = NULL;
613         }
614         q6routing_stream_close(rtd->dai_link->id, stream->direction);
615         kfree(prtd);
616 
617         return 0;
618 }
619 
620 static int q6asm_dai_compr_set_params(struct snd_compr_stream *stream,
621                                       struct snd_compr_params *params)
622 {
623         struct snd_compr_runtime *runtime = stream->runtime;
624         struct q6asm_dai_rtd *prtd = runtime->private_data;
625         struct snd_soc_pcm_runtime *rtd = stream->private_data;
626         struct snd_soc_component *c = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
627         int dir = stream->direction;
628         struct q6asm_dai_data *pdata;
629         struct q6asm_flac_cfg flac_cfg;
630         struct device *dev = c->dev;
631         int ret;
632         union snd_codec_options *codec_options;
633         struct snd_dec_flac *flac;
634 
635         codec_options = &(prtd->codec_param.codec.options);
636 
637 
638         memcpy(&prtd->codec_param, params, sizeof(*params));
639 
640         pdata = snd_soc_component_get_drvdata(c);
641         if (!pdata)
642                 return -EINVAL;
643 
644         if (!prtd || !prtd->audio_client) {
645                 dev_err(dev, "private data null or audio client freed\n");
646                 return -EINVAL;
647         }
648 
649         prtd->periods = runtime->fragments;
650         prtd->pcm_count = runtime->fragment_size;
651         prtd->pcm_size = runtime->fragments * runtime->fragment_size;
652         prtd->bits_per_sample = 16;
653         if (dir == SND_COMPRESS_PLAYBACK) {
654                 ret = q6asm_open_write(prtd->audio_client, params->codec.id,
655                                         prtd->bits_per_sample);
656 
657                 if (ret < 0) {
658                         dev_err(dev, "q6asm_open_write failed\n");
659                         q6asm_audio_client_free(prtd->audio_client);
660                         prtd->audio_client = NULL;
661                         return ret;
662                 }
663         }
664 
665         prtd->session_id = q6asm_get_session_id(prtd->audio_client);
666         ret = q6routing_stream_open(rtd->dai_link->id, LEGACY_PCM_MODE,
667                               prtd->session_id, dir);
668         if (ret) {
669                 dev_err(dev, "Stream reg failed ret:%d\n", ret);
670                 return ret;
671         }
672 
673         switch (params->codec.id) {
674         case SND_AUDIOCODEC_FLAC:
675 
676                 memset(&flac_cfg, 0x0, sizeof(struct q6asm_flac_cfg));
677                 flac = &codec_options->flac_d;
678 
679                 flac_cfg.ch_cfg = params->codec.ch_in;
680                 flac_cfg.sample_rate =  params->codec.sample_rate;
681                 flac_cfg.stream_info_present = 1;
682                 flac_cfg.sample_size = flac->sample_size;
683                 flac_cfg.min_blk_size = flac->min_blk_size;
684                 flac_cfg.max_blk_size = flac->max_blk_size;
685                 flac_cfg.max_frame_size = flac->max_frame_size;
686                 flac_cfg.min_frame_size = flac->min_frame_size;
687 
688                 ret = q6asm_stream_media_format_block_flac(prtd->audio_client,
689                                                            &flac_cfg);
690                 if (ret < 0) {
691                         dev_err(dev, "FLAC CMD Format block failed:%d\n", ret);
692                         return -EIO;
693                 }
694                 break;
695         default:
696                 break;
697         }
698 
699         ret = q6asm_map_memory_regions(dir, prtd->audio_client, prtd->phys,
700                                        (prtd->pcm_size / prtd->periods),
701                                        prtd->periods);
702 
703         if (ret < 0) {
704                 dev_err(dev, "Buffer Mapping failed ret:%d\n", ret);
705                 return -ENOMEM;
706         }
707 
708         prtd->state = Q6ASM_STREAM_RUNNING;
709 
710         return 0;
711 }
712 
713 static int q6asm_dai_compr_trigger(struct snd_compr_stream *stream, int cmd)
714 {
715         struct snd_compr_runtime *runtime = stream->runtime;
716         struct q6asm_dai_rtd *prtd = runtime->private_data;
717         int ret = 0;
718 
719         switch (cmd) {
720         case SNDRV_PCM_TRIGGER_START:
721         case SNDRV_PCM_TRIGGER_RESUME:
722         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
723                 ret = q6asm_run_nowait(prtd->audio_client, 0, 0, 0);
724                 break;
725         case SNDRV_PCM_TRIGGER_STOP:
726                 prtd->state = Q6ASM_STREAM_STOPPED;
727                 ret = q6asm_cmd_nowait(prtd->audio_client, CMD_EOS);
728                 break;
729         case SNDRV_PCM_TRIGGER_SUSPEND:
730         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
731                 ret = q6asm_cmd_nowait(prtd->audio_client, CMD_PAUSE);
732                 break;
733         default:
734                 ret = -EINVAL;
735                 break;
736         }
737 
738         return ret;
739 }
740 
741 static int q6asm_dai_compr_pointer(struct snd_compr_stream *stream,
742                 struct snd_compr_tstamp *tstamp)
743 {
744         struct snd_compr_runtime *runtime = stream->runtime;
745         struct q6asm_dai_rtd *prtd = runtime->private_data;
746         unsigned long flags;
747 
748         spin_lock_irqsave(&prtd->lock, flags);
749 
750         tstamp->copied_total = prtd->copied_total;
751         tstamp->byte_offset = prtd->copied_total % prtd->pcm_size;
752 
753         spin_unlock_irqrestore(&prtd->lock, flags);
754 
755         return 0;
756 }
757 
758 static int q6asm_dai_compr_ack(struct snd_compr_stream *stream,
759                                 size_t count)
760 {
761         struct snd_compr_runtime *runtime = stream->runtime;
762         struct q6asm_dai_rtd *prtd = runtime->private_data;
763         unsigned long flags;
764 
765         spin_lock_irqsave(&prtd->lock, flags);
766         prtd->bytes_received += count;
767         spin_unlock_irqrestore(&prtd->lock, flags);
768 
769         return count;
770 }
771 
772 static int q6asm_dai_compr_mmap(struct snd_compr_stream *stream,
773                 struct vm_area_struct *vma)
774 {
775         struct snd_compr_runtime *runtime = stream->runtime;
776         struct q6asm_dai_rtd *prtd = runtime->private_data;
777         struct snd_soc_pcm_runtime *rtd = stream->private_data;
778         struct snd_soc_component *c = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
779         struct device *dev = c->dev;
780 
781         return dma_mmap_coherent(dev, vma,
782                         prtd->dma_buffer.area, prtd->dma_buffer.addr,
783                         prtd->dma_buffer.bytes);
784 }
785 
786 static int q6asm_dai_compr_get_caps(struct snd_compr_stream *stream,
787                                     struct snd_compr_caps *caps)
788 {
789         caps->direction = SND_COMPRESS_PLAYBACK;
790         caps->min_fragment_size = COMPR_PLAYBACK_MIN_FRAGMENT_SIZE;
791         caps->max_fragment_size = COMPR_PLAYBACK_MAX_FRAGMENT_SIZE;
792         caps->min_fragments = COMPR_PLAYBACK_MIN_NUM_FRAGMENTS;
793         caps->max_fragments = COMPR_PLAYBACK_MAX_NUM_FRAGMENTS;
794         caps->num_codecs = 2;
795         caps->codecs[0] = SND_AUDIOCODEC_MP3;
796         caps->codecs[1] = SND_AUDIOCODEC_FLAC;
797 
798         return 0;
799 }
800 
801 static int q6asm_dai_compr_get_codec_caps(struct snd_compr_stream *stream,
802                                           struct snd_compr_codec_caps *codec)
803 {
804         switch (codec->codec) {
805         case SND_AUDIOCODEC_MP3:
806                 *codec = q6asm_compr_caps;
807                 break;
808         default:
809                 break;
810         }
811 
812         return 0;
813 }
814 
815 static struct snd_compr_ops q6asm_dai_compr_ops = {
816         .open           = q6asm_dai_compr_open,
817         .free           = q6asm_dai_compr_free,
818         .set_params     = q6asm_dai_compr_set_params,
819         .pointer        = q6asm_dai_compr_pointer,
820         .trigger        = q6asm_dai_compr_trigger,
821         .get_caps       = q6asm_dai_compr_get_caps,
822         .get_codec_caps = q6asm_dai_compr_get_codec_caps,
823         .mmap           = q6asm_dai_compr_mmap,
824         .ack            = q6asm_dai_compr_ack,
825 };
826 
827 static int q6asm_dai_pcm_new(struct snd_soc_component *component,
828                              struct snd_soc_pcm_runtime *rtd)
829 {
830         struct snd_pcm_substream *psubstream, *csubstream;
831         struct snd_pcm *pcm = rtd->pcm;
832         struct device *dev;
833         int size, ret;
834 
835         dev = component->dev;
836         size = q6asm_dai_hardware_playback.buffer_bytes_max;
837         psubstream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
838         if (psubstream) {
839                 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, dev, size,
840                                           &psubstream->dma_buffer);
841                 if (ret) {
842                         dev_err(dev, "Cannot allocate buffer(s)\n");
843                         return ret;
844                 }
845         }
846 
847         csubstream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
848         if (csubstream) {
849                 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, dev, size,
850                                           &csubstream->dma_buffer);
851                 if (ret) {
852                         dev_err(dev, "Cannot allocate buffer(s)\n");
853                         if (psubstream)
854                                 snd_dma_free_pages(&psubstream->dma_buffer);
855                         return ret;
856                 }
857         }
858 
859         return 0;
860 }
861 
862 static void q6asm_dai_pcm_free(struct snd_soc_component *component,
863                                struct snd_pcm *pcm)
864 {
865         struct snd_pcm_substream *substream;
866         int i;
867 
868         for (i = 0; i < ARRAY_SIZE(pcm->streams); i++) {
869                 substream = pcm->streams[i].substream;
870                 if (substream) {
871                         snd_dma_free_pages(&substream->dma_buffer);
872                         substream->dma_buffer.area = NULL;
873                         substream->dma_buffer.addr = 0;
874                 }
875         }
876 }
877 
878 static const struct snd_soc_component_driver q6asm_fe_dai_component = {
879         .name           = DRV_NAME,
880         .open           = q6asm_dai_open,
881         .hw_params      = q6asm_dai_hw_params,
882         .close          = q6asm_dai_close,
883         .ioctl          = snd_soc_pcm_lib_ioctl,
884         .prepare        = q6asm_dai_prepare,
885         .trigger        = q6asm_dai_trigger,
886         .pointer        = q6asm_dai_pointer,
887         .mmap           = q6asm_dai_mmap,
888         .pcm_construct  = q6asm_dai_pcm_new,
889         .pcm_destruct   = q6asm_dai_pcm_free,
890         .compr_ops      = &q6asm_dai_compr_ops,
891 };
892 
893 static struct snd_soc_dai_driver q6asm_fe_dais[] = {
894         Q6ASM_FEDAI_DRIVER(1),
895         Q6ASM_FEDAI_DRIVER(2),
896         Q6ASM_FEDAI_DRIVER(3),
897         Q6ASM_FEDAI_DRIVER(4),
898         Q6ASM_FEDAI_DRIVER(5),
899         Q6ASM_FEDAI_DRIVER(6),
900         Q6ASM_FEDAI_DRIVER(7),
901         Q6ASM_FEDAI_DRIVER(8),
902 };
903 
904 static int of_q6asm_parse_dai_data(struct device *dev,
905                                     struct q6asm_dai_data *pdata)
906 {
907         static struct snd_soc_dai_driver *dai_drv;
908         struct snd_soc_pcm_stream empty_stream;
909         struct device_node *node;
910         int ret, id, dir;
911 
912         memset(&empty_stream, 0, sizeof(empty_stream));
913 
914         for_each_child_of_node(dev->of_node, node) {
915                 ret = of_property_read_u32(node, "reg", &id);
916                 if (ret || id >= MAX_SESSIONS || id < 0) {
917                         dev_err(dev, "valid dai id not found:%d\n", ret);
918                         continue;
919                 }
920 
921                 dai_drv = &q6asm_fe_dais[id];
922 
923                 ret = of_property_read_u32(node, "direction", &dir);
924                 if (ret)
925                         continue;
926 
927                 if (dir == Q6ASM_DAI_RX)
928                         dai_drv->capture = empty_stream;
929                 else if (dir == Q6ASM_DAI_TX)
930                         dai_drv->playback = empty_stream;
931 
932                 if (of_property_read_bool(node, "is-compress-dai"))
933                         dai_drv->compress_new = snd_soc_new_compress;
934         }
935 
936         return 0;
937 }
938 
939 static int q6asm_dai_probe(struct platform_device *pdev)
940 {
941         struct device *dev = &pdev->dev;
942         struct device_node *node = dev->of_node;
943         struct of_phandle_args args;
944         struct q6asm_dai_data *pdata;
945         int rc;
946 
947         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
948         if (!pdata)
949                 return -ENOMEM;
950 
951         rc = of_parse_phandle_with_fixed_args(node, "iommus", 1, 0, &args);
952         if (rc < 0)
953                 pdata->sid = -1;
954         else
955                 pdata->sid = args.args[0] & SID_MASK_DEFAULT;
956 
957         dev_set_drvdata(dev, pdata);
958 
959         of_q6asm_parse_dai_data(dev, pdata);
960 
961         return devm_snd_soc_register_component(dev, &q6asm_fe_dai_component,
962                                         q6asm_fe_dais,
963                                         ARRAY_SIZE(q6asm_fe_dais));
964 }
965 
966 static const struct of_device_id q6asm_dai_device_id[] = {
967         { .compatible = "qcom,q6asm-dais" },
968         {},
969 };
970 MODULE_DEVICE_TABLE(of, q6asm_dai_device_id);
971 
972 static struct platform_driver q6asm_dai_platform_driver = {
973         .driver = {
974                 .name = "q6asm-dai",
975                 .of_match_table = of_match_ptr(q6asm_dai_device_id),
976         },
977         .probe = q6asm_dai_probe,
978 };
979 module_platform_driver(q6asm_dai_platform_driver);
980 
981 MODULE_DESCRIPTION("Q6ASM dai driver");
982 MODULE_LICENSE("GPL v2");
983 

~ [ 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