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

TOMOYO Linux Cross Reference
Linux/sound/pci/ctxfi/ctpcm.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ 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) 2008, Creative Technology Ltd. All Rights Reserved.
  3  *
  4  * This source file is released under GPL v2 license (no other versions).
  5  * See the COPYING file included in the main directory of this source
  6  * distribution for the license terms and conditions.
  7  *
  8  * @File        ctpcm.c
  9  *
 10  * @Brief
 11  * This file contains the definition of the pcm device functions.
 12  *
 13  * @Author      Liu Chun
 14  * @Date        Apr 2 2008
 15  *
 16  */
 17 
 18 #include "ctpcm.h"
 19 #include "cttimer.h"
 20 #include <linux/slab.h>
 21 #include <sound/pcm.h>
 22 
 23 /* Hardware descriptions for playback */
 24 static struct snd_pcm_hardware ct_pcm_playback_hw = {
 25         .info                   = (SNDRV_PCM_INFO_MMAP |
 26                                    SNDRV_PCM_INFO_INTERLEAVED |
 27                                    SNDRV_PCM_INFO_BLOCK_TRANSFER |
 28                                    SNDRV_PCM_INFO_MMAP_VALID |
 29                                    SNDRV_PCM_INFO_PAUSE),
 30         .formats                = (SNDRV_PCM_FMTBIT_U8 |
 31                                    SNDRV_PCM_FMTBIT_S16_LE |
 32                                    SNDRV_PCM_FMTBIT_S24_3LE |
 33                                    SNDRV_PCM_FMTBIT_S32_LE |
 34                                    SNDRV_PCM_FMTBIT_FLOAT_LE),
 35         .rates                  = (SNDRV_PCM_RATE_CONTINUOUS |
 36                                    SNDRV_PCM_RATE_8000_192000),
 37         .rate_min               = 8000,
 38         .rate_max               = 192000,
 39         .channels_min           = 1,
 40         .channels_max           = 2,
 41         .buffer_bytes_max       = (128*1024),
 42         .period_bytes_min       = (64),
 43         .period_bytes_max       = (128*1024),
 44         .periods_min            = 2,
 45         .periods_max            = 1024,
 46         .fifo_size              = 0,
 47 };
 48 
 49 static struct snd_pcm_hardware ct_spdif_passthru_playback_hw = {
 50         .info                   = (SNDRV_PCM_INFO_MMAP |
 51                                    SNDRV_PCM_INFO_INTERLEAVED |
 52                                    SNDRV_PCM_INFO_BLOCK_TRANSFER |
 53                                    SNDRV_PCM_INFO_MMAP_VALID |
 54                                    SNDRV_PCM_INFO_PAUSE),
 55         .formats                = SNDRV_PCM_FMTBIT_S16_LE,
 56         .rates                  = (SNDRV_PCM_RATE_48000 |
 57                                    SNDRV_PCM_RATE_44100 |
 58                                    SNDRV_PCM_RATE_32000),
 59         .rate_min               = 32000,
 60         .rate_max               = 48000,
 61         .channels_min           = 2,
 62         .channels_max           = 2,
 63         .buffer_bytes_max       = (128*1024),
 64         .period_bytes_min       = (64),
 65         .period_bytes_max       = (128*1024),
 66         .periods_min            = 2,
 67         .periods_max            = 1024,
 68         .fifo_size              = 0,
 69 };
 70 
 71 /* Hardware descriptions for capture */
 72 static struct snd_pcm_hardware ct_pcm_capture_hw = {
 73         .info                   = (SNDRV_PCM_INFO_MMAP |
 74                                    SNDRV_PCM_INFO_INTERLEAVED |
 75                                    SNDRV_PCM_INFO_BLOCK_TRANSFER |
 76                                    SNDRV_PCM_INFO_PAUSE |
 77                                    SNDRV_PCM_INFO_MMAP_VALID),
 78         .formats                = (SNDRV_PCM_FMTBIT_U8 |
 79                                    SNDRV_PCM_FMTBIT_S16_LE |
 80                                    SNDRV_PCM_FMTBIT_S24_3LE |
 81                                    SNDRV_PCM_FMTBIT_S32_LE |
 82                                    SNDRV_PCM_FMTBIT_FLOAT_LE),
 83         .rates                  = (SNDRV_PCM_RATE_CONTINUOUS |
 84                                    SNDRV_PCM_RATE_8000_96000),
 85         .rate_min               = 8000,
 86         .rate_max               = 96000,
 87         .channels_min           = 1,
 88         .channels_max           = 2,
 89         .buffer_bytes_max       = (128*1024),
 90         .period_bytes_min       = (384),
 91         .period_bytes_max       = (64*1024),
 92         .periods_min            = 2,
 93         .periods_max            = 1024,
 94         .fifo_size              = 0,
 95 };
 96 
 97 static void ct_atc_pcm_interrupt(struct ct_atc_pcm *atc_pcm)
 98 {
 99         struct ct_atc_pcm *apcm = atc_pcm;
100 
101         if (!apcm->substream)
102                 return;
103 
104         snd_pcm_period_elapsed(apcm->substream);
105 }
106 
107 static void ct_atc_pcm_free_substream(struct snd_pcm_runtime *runtime)
108 {
109         struct ct_atc_pcm *apcm = runtime->private_data;
110         struct ct_atc *atc = snd_pcm_substream_chip(apcm->substream);
111 
112         atc->pcm_release_resources(atc, apcm);
113         ct_timer_instance_free(apcm->timer);
114         kfree(apcm);
115         runtime->private_data = NULL;
116 }
117 
118 /* pcm playback operations */
119 static int ct_pcm_playback_open(struct snd_pcm_substream *substream)
120 {
121         struct ct_atc *atc = snd_pcm_substream_chip(substream);
122         struct snd_pcm_runtime *runtime = substream->runtime;
123         struct ct_atc_pcm *apcm;
124         int err;
125 
126         apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
127         if (!apcm)
128                 return -ENOMEM;
129 
130         apcm->substream = substream;
131         apcm->interrupt = ct_atc_pcm_interrupt;
132         if (IEC958 == substream->pcm->device) {
133                 runtime->hw = ct_spdif_passthru_playback_hw;
134                 atc->spdif_out_passthru(atc, 1);
135         } else {
136                 runtime->hw = ct_pcm_playback_hw;
137                 if (FRONT == substream->pcm->device)
138                         runtime->hw.channels_max = 8;
139         }
140 
141         err = snd_pcm_hw_constraint_integer(runtime,
142                                             SNDRV_PCM_HW_PARAM_PERIODS);
143         if (err < 0) {
144                 kfree(apcm);
145                 return err;
146         }
147         err = snd_pcm_hw_constraint_minmax(runtime,
148                                            SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
149                                            1024, UINT_MAX);
150         if (err < 0) {
151                 kfree(apcm);
152                 return err;
153         }
154 
155         apcm->timer = ct_timer_instance_new(atc->timer, apcm);
156         if (!apcm->timer) {
157                 kfree(apcm);
158                 return -ENOMEM;
159         }
160         runtime->private_data = apcm;
161         runtime->private_free = ct_atc_pcm_free_substream;
162 
163         return 0;
164 }
165 
166 static int ct_pcm_playback_close(struct snd_pcm_substream *substream)
167 {
168         struct ct_atc *atc = snd_pcm_substream_chip(substream);
169 
170         /* TODO: Notify mixer inactive. */
171         if (IEC958 == substream->pcm->device)
172                 atc->spdif_out_passthru(atc, 0);
173 
174         /* The ct_atc_pcm object will be freed by runtime->private_free */
175 
176         return 0;
177 }
178 
179 static int ct_pcm_hw_params(struct snd_pcm_substream *substream,
180                                      struct snd_pcm_hw_params *hw_params)
181 {
182         struct ct_atc *atc = snd_pcm_substream_chip(substream);
183         struct ct_atc_pcm *apcm = substream->runtime->private_data;
184         int err;
185 
186         err = snd_pcm_lib_malloc_pages(substream,
187                                         params_buffer_bytes(hw_params));
188         if (err < 0)
189                 return err;
190         /* clear previous resources */
191         atc->pcm_release_resources(atc, apcm);
192         return err;
193 }
194 
195 static int ct_pcm_hw_free(struct snd_pcm_substream *substream)
196 {
197         struct ct_atc *atc = snd_pcm_substream_chip(substream);
198         struct ct_atc_pcm *apcm = substream->runtime->private_data;
199 
200         /* clear previous resources */
201         atc->pcm_release_resources(atc, apcm);
202         /* Free snd-allocated pages */
203         return snd_pcm_lib_free_pages(substream);
204 }
205 
206 
207 static int ct_pcm_playback_prepare(struct snd_pcm_substream *substream)
208 {
209         int err;
210         struct ct_atc *atc = snd_pcm_substream_chip(substream);
211         struct snd_pcm_runtime *runtime = substream->runtime;
212         struct ct_atc_pcm *apcm = runtime->private_data;
213 
214         if (IEC958 == substream->pcm->device)
215                 err = atc->spdif_passthru_playback_prepare(atc, apcm);
216         else
217                 err = atc->pcm_playback_prepare(atc, apcm);
218 
219         if (err < 0) {
220                 printk(KERN_ERR "ctxfi: Preparing pcm playback failed!!!\n");
221                 return err;
222         }
223 
224         return 0;
225 }
226 
227 static int
228 ct_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
229 {
230         struct ct_atc *atc = snd_pcm_substream_chip(substream);
231         struct snd_pcm_runtime *runtime = substream->runtime;
232         struct ct_atc_pcm *apcm = runtime->private_data;
233 
234         switch (cmd) {
235         case SNDRV_PCM_TRIGGER_START:
236         case SNDRV_PCM_TRIGGER_RESUME:
237         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
238                 atc->pcm_playback_start(atc, apcm);
239                 break;
240         case SNDRV_PCM_TRIGGER_STOP:
241         case SNDRV_PCM_TRIGGER_SUSPEND:
242         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
243                 atc->pcm_playback_stop(atc, apcm);
244                 break;
245         default:
246                 break;
247         }
248 
249         return 0;
250 }
251 
252 static snd_pcm_uframes_t
253 ct_pcm_playback_pointer(struct snd_pcm_substream *substream)
254 {
255         unsigned long position;
256         struct ct_atc *atc = snd_pcm_substream_chip(substream);
257         struct snd_pcm_runtime *runtime = substream->runtime;
258         struct ct_atc_pcm *apcm = runtime->private_data;
259 
260         /* Read out playback position */
261         position = atc->pcm_playback_position(atc, apcm);
262         position = bytes_to_frames(runtime, position);
263         if (position >= runtime->buffer_size)
264                 position = 0;
265         return position;
266 }
267 
268 /* pcm capture operations */
269 static int ct_pcm_capture_open(struct snd_pcm_substream *substream)
270 {
271         struct ct_atc *atc = snd_pcm_substream_chip(substream);
272         struct snd_pcm_runtime *runtime = substream->runtime;
273         struct ct_atc_pcm *apcm;
274         int err;
275 
276         apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
277         if (!apcm)
278                 return -ENOMEM;
279 
280         apcm->started = 0;
281         apcm->substream = substream;
282         apcm->interrupt = ct_atc_pcm_interrupt;
283         runtime->hw = ct_pcm_capture_hw;
284         runtime->hw.rate_max = atc->rsr * atc->msr;
285 
286         err = snd_pcm_hw_constraint_integer(runtime,
287                                             SNDRV_PCM_HW_PARAM_PERIODS);
288         if (err < 0) {
289                 kfree(apcm);
290                 return err;
291         }
292         err = snd_pcm_hw_constraint_minmax(runtime,
293                                            SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
294                                            1024, UINT_MAX);
295         if (err < 0) {
296                 kfree(apcm);
297                 return err;
298         }
299 
300         apcm->timer = ct_timer_instance_new(atc->timer, apcm);
301         if (!apcm->timer) {
302                 kfree(apcm);
303                 return -ENOMEM;
304         }
305         runtime->private_data = apcm;
306         runtime->private_free = ct_atc_pcm_free_substream;
307 
308         return 0;
309 }
310 
311 static int ct_pcm_capture_close(struct snd_pcm_substream *substream)
312 {
313         /* The ct_atc_pcm object will be freed by runtime->private_free */
314         /* TODO: Notify mixer inactive. */
315         return 0;
316 }
317 
318 static int ct_pcm_capture_prepare(struct snd_pcm_substream *substream)
319 {
320         int err;
321         struct ct_atc *atc = snd_pcm_substream_chip(substream);
322         struct snd_pcm_runtime *runtime = substream->runtime;
323         struct ct_atc_pcm *apcm = runtime->private_data;
324 
325         err = atc->pcm_capture_prepare(atc, apcm);
326         if (err < 0) {
327                 printk(KERN_ERR "ctxfi: Preparing pcm capture failed!!!\n");
328                 return err;
329         }
330 
331         return 0;
332 }
333 
334 static int
335 ct_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
336 {
337         struct ct_atc *atc = snd_pcm_substream_chip(substream);
338         struct snd_pcm_runtime *runtime = substream->runtime;
339         struct ct_atc_pcm *apcm = runtime->private_data;
340 
341         switch (cmd) {
342         case SNDRV_PCM_TRIGGER_START:
343                 atc->pcm_capture_start(atc, apcm);
344                 break;
345         case SNDRV_PCM_TRIGGER_STOP:
346                 atc->pcm_capture_stop(atc, apcm);
347                 break;
348         default:
349                 atc->pcm_capture_stop(atc, apcm);
350                 break;
351         }
352 
353         return 0;
354 }
355 
356 static snd_pcm_uframes_t
357 ct_pcm_capture_pointer(struct snd_pcm_substream *substream)
358 {
359         unsigned long position;
360         struct ct_atc *atc = snd_pcm_substream_chip(substream);
361         struct snd_pcm_runtime *runtime = substream->runtime;
362         struct ct_atc_pcm *apcm = runtime->private_data;
363 
364         /* Read out playback position */
365         position = atc->pcm_capture_position(atc, apcm);
366         position = bytes_to_frames(runtime, position);
367         if (position >= runtime->buffer_size)
368                 position = 0;
369         return position;
370 }
371 
372 /* PCM operators for playback */
373 static struct snd_pcm_ops ct_pcm_playback_ops = {
374         .open           = ct_pcm_playback_open,
375         .close          = ct_pcm_playback_close,
376         .ioctl          = snd_pcm_lib_ioctl,
377         .hw_params      = ct_pcm_hw_params,
378         .hw_free        = ct_pcm_hw_free,
379         .prepare        = ct_pcm_playback_prepare,
380         .trigger        = ct_pcm_playback_trigger,
381         .pointer        = ct_pcm_playback_pointer,
382         .page           = snd_pcm_sgbuf_ops_page,
383 };
384 
385 /* PCM operators for capture */
386 static struct snd_pcm_ops ct_pcm_capture_ops = {
387         .open           = ct_pcm_capture_open,
388         .close          = ct_pcm_capture_close,
389         .ioctl          = snd_pcm_lib_ioctl,
390         .hw_params      = ct_pcm_hw_params,
391         .hw_free        = ct_pcm_hw_free,
392         .prepare        = ct_pcm_capture_prepare,
393         .trigger        = ct_pcm_capture_trigger,
394         .pointer        = ct_pcm_capture_pointer,
395         .page           = snd_pcm_sgbuf_ops_page,
396 };
397 
398 static const struct snd_pcm_chmap_elem surround_map[] = {
399         { .channels = 1,
400           .map = { SNDRV_CHMAP_MONO } },
401         { .channels = 2,
402           .map = { SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
403         { }
404 };
405 
406 static const struct snd_pcm_chmap_elem clfe_map[] = {
407         { .channels = 1,
408           .map = { SNDRV_CHMAP_MONO } },
409         { .channels = 2,
410           .map = { SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE } },
411         { }
412 };
413 
414 static const struct snd_pcm_chmap_elem side_map[] = {
415         { .channels = 1,
416           .map = { SNDRV_CHMAP_MONO } },
417         { .channels = 2,
418           .map = { SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
419         { }
420 };
421 
422 /* Create ALSA pcm device */
423 int ct_alsa_pcm_create(struct ct_atc *atc,
424                        enum CTALSADEVS device,
425                        const char *device_name)
426 {
427         struct snd_pcm *pcm;
428         const struct snd_pcm_chmap_elem *map;
429         int chs;
430         int err;
431         int playback_count, capture_count;
432 
433         playback_count = (IEC958 == device) ? 1 : 256;
434         capture_count = (FRONT == device) ? 1 : 0;
435         err = snd_pcm_new(atc->card, "ctxfi", device,
436                           playback_count, capture_count, &pcm);
437         if (err < 0) {
438                 printk(KERN_ERR "ctxfi: snd_pcm_new failed!! Err=%d\n", err);
439                 return err;
440         }
441 
442         pcm->private_data = atc;
443         pcm->info_flags = 0;
444         pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
445         strlcpy(pcm->name, device_name, sizeof(pcm->name));
446 
447         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ct_pcm_playback_ops);
448 
449         if (FRONT == device)
450                 snd_pcm_set_ops(pcm,
451                                 SNDRV_PCM_STREAM_CAPTURE, &ct_pcm_capture_ops);
452 
453         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
454                         snd_dma_pci_data(atc->pci), 128*1024, 128*1024);
455 
456         chs = 2;
457         switch (device) {
458         case FRONT:
459                 chs = 8;
460                 map = snd_pcm_std_chmaps;
461                 break;
462         case SURROUND:
463                 map = surround_map;
464                 break;
465         case CLFE:
466                 map = clfe_map;
467                 break;
468         case SIDE:
469                 map = side_map;
470                 break;
471         default:
472                 map = snd_pcm_std_chmaps;
473                 break;
474         }
475         err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, chs,
476                                      0, NULL);
477         if (err < 0)
478                 return err;
479 
480 #ifdef CONFIG_PM_SLEEP
481         atc->pcms[device] = pcm;
482 #endif
483 
484         return 0;
485 }
486 

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