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 <sound/pcm.h>
22 /* Hardware descriptions for playback */
23 static struct snd_pcm_hardware ct_pcm_playback_hw = {
24 .info = (SNDRV_PCM_INFO_MMAP |
25 SNDRV_PCM_INFO_INTERLEAVED |
26 SNDRV_PCM_INFO_BLOCK_TRANSFER |
27 SNDRV_PCM_INFO_MMAP_VALID |
28 SNDRV_PCM_INFO_PAUSE),
29 .formats = (SNDRV_PCM_FMTBIT_U8 |
30 SNDRV_PCM_FMTBIT_S16_LE |
31 SNDRV_PCM_FMTBIT_S24_3LE |
32 SNDRV_PCM_FMTBIT_S32_LE |
33 SNDRV_PCM_FMTBIT_FLOAT_LE),
34 .rates = (SNDRV_PCM_RATE_CONTINUOUS |
35 SNDRV_PCM_RATE_8000_192000),
40 .buffer_bytes_max = (128*1024),
41 .period_bytes_min = (64),
42 .period_bytes_max = (128*1024),
48 static struct snd_pcm_hardware ct_spdif_passthru_playback_hw = {
49 .info = (SNDRV_PCM_INFO_MMAP |
50 SNDRV_PCM_INFO_INTERLEAVED |
51 SNDRV_PCM_INFO_BLOCK_TRANSFER |
52 SNDRV_PCM_INFO_MMAP_VALID |
53 SNDRV_PCM_INFO_PAUSE),
54 .formats = SNDRV_PCM_FMTBIT_S16_LE,
55 .rates = (SNDRV_PCM_RATE_48000 |
56 SNDRV_PCM_RATE_44100 |
57 SNDRV_PCM_RATE_32000),
62 .buffer_bytes_max = (128*1024),
63 .period_bytes_min = (64),
64 .period_bytes_max = (128*1024),
70 /* Hardware descriptions for capture */
71 static struct snd_pcm_hardware ct_pcm_capture_hw = {
72 .info = (SNDRV_PCM_INFO_MMAP |
73 SNDRV_PCM_INFO_INTERLEAVED |
74 SNDRV_PCM_INFO_BLOCK_TRANSFER |
75 SNDRV_PCM_INFO_PAUSE |
76 SNDRV_PCM_INFO_MMAP_VALID),
77 .formats = (SNDRV_PCM_FMTBIT_U8 |
78 SNDRV_PCM_FMTBIT_S16_LE |
79 SNDRV_PCM_FMTBIT_S24_3LE |
80 SNDRV_PCM_FMTBIT_S32_LE |
81 SNDRV_PCM_FMTBIT_FLOAT_LE),
82 .rates = (SNDRV_PCM_RATE_CONTINUOUS |
83 SNDRV_PCM_RATE_8000_96000),
88 .buffer_bytes_max = (128*1024),
89 .period_bytes_min = (384),
90 .period_bytes_max = (64*1024),
96 static void ct_atc_pcm_interrupt(struct ct_atc_pcm *atc_pcm)
98 struct ct_atc_pcm *apcm = atc_pcm;
100 if (NULL == apcm->substream)
103 snd_pcm_period_elapsed(apcm->substream);
106 static void ct_atc_pcm_free_substream(struct snd_pcm_runtime *runtime)
108 struct ct_atc_pcm *apcm = runtime->private_data;
109 struct ct_atc *atc = snd_pcm_substream_chip(apcm->substream);
111 atc->pcm_release_resources(atc, apcm);
112 ct_timer_instance_free(apcm->timer);
114 runtime->private_data = NULL;
117 /* pcm playback operations */
118 static int ct_pcm_playback_open(struct snd_pcm_substream *substream)
120 struct ct_atc *atc = snd_pcm_substream_chip(substream);
121 struct snd_pcm_runtime *runtime = substream->runtime;
122 struct ct_atc_pcm *apcm;
125 apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
129 apcm->substream = substream;
130 apcm->interrupt = ct_atc_pcm_interrupt;
131 runtime->private_data = apcm;
132 runtime->private_free = ct_atc_pcm_free_substream;
133 if (IEC958 == substream->pcm->device) {
134 runtime->hw = ct_spdif_passthru_playback_hw;
135 atc->spdif_out_passthru(atc, 1);
137 runtime->hw = ct_pcm_playback_hw;
138 if (FRONT == substream->pcm->device)
139 runtime->hw.channels_max = 8;
142 err = snd_pcm_hw_constraint_integer(runtime,
143 SNDRV_PCM_HW_PARAM_PERIODS);
148 err = snd_pcm_hw_constraint_minmax(runtime,
149 SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
156 apcm->timer = ct_timer_instance_new(atc->timer, apcm);
163 static int ct_pcm_playback_close(struct snd_pcm_substream *substream)
165 struct ct_atc *atc = snd_pcm_substream_chip(substream);
167 /* TODO: Notify mixer inactive. */
168 if (IEC958 == substream->pcm->device)
169 atc->spdif_out_passthru(atc, 0);
171 /* The ct_atc_pcm object will be freed by runtime->private_free */
176 static int ct_pcm_hw_params(struct snd_pcm_substream *substream,
177 struct snd_pcm_hw_params *hw_params)
179 return snd_pcm_lib_malloc_pages(substream,
180 params_buffer_bytes(hw_params));
183 static int ct_pcm_hw_free(struct snd_pcm_substream *substream)
185 /* Free snd-allocated pages */
186 return snd_pcm_lib_free_pages(substream);
190 static int ct_pcm_playback_prepare(struct snd_pcm_substream *substream)
193 struct ct_atc *atc = snd_pcm_substream_chip(substream);
194 struct snd_pcm_runtime *runtime = substream->runtime;
195 struct ct_atc_pcm *apcm = runtime->private_data;
197 if (IEC958 == substream->pcm->device)
198 err = atc->spdif_passthru_playback_prepare(atc, apcm);
200 err = atc->pcm_playback_prepare(atc, apcm);
203 printk(KERN_ERR "ctxfi: Preparing pcm playback failed!!!\n");
211 ct_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
213 struct ct_atc *atc = snd_pcm_substream_chip(substream);
214 struct snd_pcm_runtime *runtime = substream->runtime;
215 struct ct_atc_pcm *apcm = runtime->private_data;
218 case SNDRV_PCM_TRIGGER_START:
219 case SNDRV_PCM_TRIGGER_RESUME:
220 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
221 atc->pcm_playback_start(atc, apcm);
223 case SNDRV_PCM_TRIGGER_STOP:
224 case SNDRV_PCM_TRIGGER_SUSPEND:
225 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
226 atc->pcm_playback_stop(atc, apcm);
235 static snd_pcm_uframes_t
236 ct_pcm_playback_pointer(struct snd_pcm_substream *substream)
238 unsigned long position;
239 struct ct_atc *atc = snd_pcm_substream_chip(substream);
240 struct snd_pcm_runtime *runtime = substream->runtime;
241 struct ct_atc_pcm *apcm = runtime->private_data;
243 /* Read out playback position */
244 position = atc->pcm_playback_position(atc, apcm);
245 position = bytes_to_frames(runtime, position);
249 /* pcm capture operations */
250 static int ct_pcm_capture_open(struct snd_pcm_substream *substream)
252 struct ct_atc *atc = snd_pcm_substream_chip(substream);
253 struct snd_pcm_runtime *runtime = substream->runtime;
254 struct ct_atc_pcm *apcm;
257 apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
262 apcm->substream = substream;
263 apcm->interrupt = ct_atc_pcm_interrupt;
264 runtime->private_data = apcm;
265 runtime->private_free = ct_atc_pcm_free_substream;
266 runtime->hw = ct_pcm_capture_hw;
267 runtime->hw.rate_max = atc->rsr * atc->msr;
269 err = snd_pcm_hw_constraint_integer(runtime,
270 SNDRV_PCM_HW_PARAM_PERIODS);
275 err = snd_pcm_hw_constraint_minmax(runtime,
276 SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
283 apcm->timer = ct_timer_instance_new(atc->timer, apcm);
290 static int ct_pcm_capture_close(struct snd_pcm_substream *substream)
292 /* The ct_atc_pcm object will be freed by runtime->private_free */
293 /* TODO: Notify mixer inactive. */
297 static int ct_pcm_capture_prepare(struct snd_pcm_substream *substream)
300 struct ct_atc *atc = snd_pcm_substream_chip(substream);
301 struct snd_pcm_runtime *runtime = substream->runtime;
302 struct ct_atc_pcm *apcm = runtime->private_data;
304 err = atc->pcm_capture_prepare(atc, apcm);
306 printk(KERN_ERR "ctxfi: Preparing pcm capture failed!!!\n");
314 ct_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
316 struct ct_atc *atc = snd_pcm_substream_chip(substream);
317 struct snd_pcm_runtime *runtime = substream->runtime;
318 struct ct_atc_pcm *apcm = runtime->private_data;
321 case SNDRV_PCM_TRIGGER_START:
322 atc->pcm_capture_start(atc, apcm);
324 case SNDRV_PCM_TRIGGER_STOP:
325 atc->pcm_capture_stop(atc, apcm);
328 atc->pcm_capture_stop(atc, apcm);
335 static snd_pcm_uframes_t
336 ct_pcm_capture_pointer(struct snd_pcm_substream *substream)
338 unsigned long position;
339 struct ct_atc *atc = snd_pcm_substream_chip(substream);
340 struct snd_pcm_runtime *runtime = substream->runtime;
341 struct ct_atc_pcm *apcm = runtime->private_data;
343 /* Read out playback position */
344 position = atc->pcm_capture_position(atc, apcm);
345 position = bytes_to_frames(runtime, position);
349 /* PCM operators for playback */
350 static struct snd_pcm_ops ct_pcm_playback_ops = {
351 .open = ct_pcm_playback_open,
352 .close = ct_pcm_playback_close,
353 .ioctl = snd_pcm_lib_ioctl,
354 .hw_params = ct_pcm_hw_params,
355 .hw_free = ct_pcm_hw_free,
356 .prepare = ct_pcm_playback_prepare,
357 .trigger = ct_pcm_playback_trigger,
358 .pointer = ct_pcm_playback_pointer,
359 .page = snd_pcm_sgbuf_ops_page,
362 /* PCM operators for capture */
363 static struct snd_pcm_ops ct_pcm_capture_ops = {
364 .open = ct_pcm_capture_open,
365 .close = ct_pcm_capture_close,
366 .ioctl = snd_pcm_lib_ioctl,
367 .hw_params = ct_pcm_hw_params,
368 .hw_free = ct_pcm_hw_free,
369 .prepare = ct_pcm_capture_prepare,
370 .trigger = ct_pcm_capture_trigger,
371 .pointer = ct_pcm_capture_pointer,
372 .page = snd_pcm_sgbuf_ops_page,
375 /* Create ALSA pcm device */
376 int ct_alsa_pcm_create(struct ct_atc *atc,
377 enum CTALSADEVS device,
378 const char *device_name)
382 int playback_count, capture_count;
384 playback_count = (IEC958 == device) ? 1 : 8;
385 capture_count = (FRONT == device) ? 1 : 0;
386 err = snd_pcm_new(atc->card, "ctxfi", device,
387 playback_count, capture_count, &pcm);
389 printk(KERN_ERR "ctxfi: snd_pcm_new failed!! Err=%d\n", err);
393 pcm->private_data = atc;
395 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
396 strlcpy(pcm->name, device_name, sizeof(pcm->name));
398 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ct_pcm_playback_ops);
402 SNDRV_PCM_STREAM_CAPTURE, &ct_pcm_capture_ops);
404 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
405 snd_dma_pci_data(atc->pci), 128*1024, 128*1024);