2 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
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.
11 * This file contains the definition of the pcm device functions.
20 #include <linux/slab.h>
21 #include <sound/pcm.h>
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),
41 .buffer_bytes_max = (128*1024),
42 .period_bytes_min = (64),
43 .period_bytes_max = (128*1024),
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),
63 .buffer_bytes_max = (128*1024),
64 .period_bytes_min = (64),
65 .period_bytes_max = (128*1024),
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),
89 .buffer_bytes_max = (128*1024),
90 .period_bytes_min = (384),
91 .period_bytes_max = (64*1024),
97 static void ct_atc_pcm_interrupt(struct ct_atc_pcm *atc_pcm)
99 struct ct_atc_pcm *apcm = atc_pcm;
101 if (!apcm->substream)
104 snd_pcm_period_elapsed(apcm->substream);
107 static void ct_atc_pcm_free_substream(struct snd_pcm_runtime *runtime)
109 struct ct_atc_pcm *apcm = runtime->private_data;
110 struct ct_atc *atc = snd_pcm_substream_chip(apcm->substream);
112 atc->pcm_release_resources(atc, apcm);
113 ct_timer_instance_free(apcm->timer);
115 runtime->private_data = NULL;
118 /* pcm playback operations */
119 static int ct_pcm_playback_open(struct snd_pcm_substream *substream)
121 struct ct_atc *atc = snd_pcm_substream_chip(substream);
122 struct snd_pcm_runtime *runtime = substream->runtime;
123 struct ct_atc_pcm *apcm;
126 apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
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);
136 runtime->hw = ct_pcm_playback_hw;
137 if (FRONT == substream->pcm->device)
138 runtime->hw.channels_max = 8;
141 err = snd_pcm_hw_constraint_integer(runtime,
142 SNDRV_PCM_HW_PARAM_PERIODS);
147 err = snd_pcm_hw_constraint_minmax(runtime,
148 SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
155 apcm->timer = ct_timer_instance_new(atc->timer, apcm);
160 runtime->private_data = apcm;
161 runtime->private_free = ct_atc_pcm_free_substream;
166 static int ct_pcm_playback_close(struct snd_pcm_substream *substream)
168 struct ct_atc *atc = snd_pcm_substream_chip(substream);
170 /* TODO: Notify mixer inactive. */
171 if (IEC958 == substream->pcm->device)
172 atc->spdif_out_passthru(atc, 0);
174 /* The ct_atc_pcm object will be freed by runtime->private_free */
179 static int ct_pcm_hw_params(struct snd_pcm_substream *substream,
180 struct snd_pcm_hw_params *hw_params)
182 struct ct_atc *atc = snd_pcm_substream_chip(substream);
183 struct ct_atc_pcm *apcm = substream->runtime->private_data;
186 err = snd_pcm_lib_malloc_pages(substream,
187 params_buffer_bytes(hw_params));
190 /* clear previous resources */
191 atc->pcm_release_resources(atc, apcm);
195 static int ct_pcm_hw_free(struct snd_pcm_substream *substream)
197 struct ct_atc *atc = snd_pcm_substream_chip(substream);
198 struct ct_atc_pcm *apcm = substream->runtime->private_data;
200 /* clear previous resources */
201 atc->pcm_release_resources(atc, apcm);
202 /* Free snd-allocated pages */
203 return snd_pcm_lib_free_pages(substream);
207 static int ct_pcm_playback_prepare(struct snd_pcm_substream *substream)
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;
214 if (IEC958 == substream->pcm->device)
215 err = atc->spdif_passthru_playback_prepare(atc, apcm);
217 err = atc->pcm_playback_prepare(atc, apcm);
220 printk(KERN_ERR "ctxfi: Preparing pcm playback failed!!!\n");
228 ct_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
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;
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);
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);
252 static snd_pcm_uframes_t
253 ct_pcm_playback_pointer(struct snd_pcm_substream *substream)
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;
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)
268 /* pcm capture operations */
269 static int ct_pcm_capture_open(struct snd_pcm_substream *substream)
271 struct ct_atc *atc = snd_pcm_substream_chip(substream);
272 struct snd_pcm_runtime *runtime = substream->runtime;
273 struct ct_atc_pcm *apcm;
276 apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
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;
286 err = snd_pcm_hw_constraint_integer(runtime,
287 SNDRV_PCM_HW_PARAM_PERIODS);
292 err = snd_pcm_hw_constraint_minmax(runtime,
293 SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
300 apcm->timer = ct_timer_instance_new(atc->timer, apcm);
305 runtime->private_data = apcm;
306 runtime->private_free = ct_atc_pcm_free_substream;
311 static int ct_pcm_capture_close(struct snd_pcm_substream *substream)
313 /* The ct_atc_pcm object will be freed by runtime->private_free */
314 /* TODO: Notify mixer inactive. */
318 static int ct_pcm_capture_prepare(struct snd_pcm_substream *substream)
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;
325 err = atc->pcm_capture_prepare(atc, apcm);
327 printk(KERN_ERR "ctxfi: Preparing pcm capture failed!!!\n");
335 ct_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
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;
342 case SNDRV_PCM_TRIGGER_START:
343 atc->pcm_capture_start(atc, apcm);
345 case SNDRV_PCM_TRIGGER_STOP:
346 atc->pcm_capture_stop(atc, apcm);
349 atc->pcm_capture_stop(atc, apcm);
356 static snd_pcm_uframes_t
357 ct_pcm_capture_pointer(struct snd_pcm_substream *substream)
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;
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)
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,
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,
398 static const struct snd_pcm_chmap_elem surround_map[] = {
400 .map = { SNDRV_CHMAP_MONO } },
402 .map = { SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
406 static const struct snd_pcm_chmap_elem clfe_map[] = {
408 .map = { SNDRV_CHMAP_MONO } },
410 .map = { SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE } },
414 static const struct snd_pcm_chmap_elem side_map[] = {
416 .map = { SNDRV_CHMAP_MONO } },
418 .map = { SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
422 /* Create ALSA pcm device */
423 int ct_alsa_pcm_create(struct ct_atc *atc,
424 enum CTALSADEVS device,
425 const char *device_name)
428 const struct snd_pcm_chmap_elem *map;
431 int playback_count, capture_count;
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);
438 printk(KERN_ERR "ctxfi: snd_pcm_new failed!! Err=%d\n", err);
442 pcm->private_data = atc;
444 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
445 strlcpy(pcm->name, device_name, sizeof(pcm->name));
447 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ct_pcm_playback_ops);
451 SNDRV_PCM_STREAM_CAPTURE, &ct_pcm_capture_ops);
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);
460 map = snd_pcm_std_chmaps;
472 map = snd_pcm_std_chmaps;
475 err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, chs,
480 #ifdef CONFIG_PM_SLEEP
481 atc->pcms[device] = pcm;