1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
8 * This file contains the definition of the pcm device functions.
16 #include <linux/slab.h>
17 #include <sound/pcm.h>
19 /* Hardware descriptions for playback */
20 static const struct snd_pcm_hardware ct_pcm_playback_hw = {
21 .info = (SNDRV_PCM_INFO_MMAP |
22 SNDRV_PCM_INFO_INTERLEAVED |
23 SNDRV_PCM_INFO_BLOCK_TRANSFER |
24 SNDRV_PCM_INFO_MMAP_VALID |
25 SNDRV_PCM_INFO_PAUSE),
26 .formats = (SNDRV_PCM_FMTBIT_U8 |
27 SNDRV_PCM_FMTBIT_S16_LE |
28 SNDRV_PCM_FMTBIT_S24_3LE |
29 SNDRV_PCM_FMTBIT_S32_LE |
30 SNDRV_PCM_FMTBIT_FLOAT_LE),
31 .rates = (SNDRV_PCM_RATE_CONTINUOUS |
32 SNDRV_PCM_RATE_8000_192000),
37 .buffer_bytes_max = (128*1024),
38 .period_bytes_min = (64),
39 .period_bytes_max = (128*1024),
45 static const struct snd_pcm_hardware ct_spdif_passthru_playback_hw = {
46 .info = (SNDRV_PCM_INFO_MMAP |
47 SNDRV_PCM_INFO_INTERLEAVED |
48 SNDRV_PCM_INFO_BLOCK_TRANSFER |
49 SNDRV_PCM_INFO_MMAP_VALID |
50 SNDRV_PCM_INFO_PAUSE),
51 .formats = SNDRV_PCM_FMTBIT_S16_LE,
52 .rates = (SNDRV_PCM_RATE_48000 |
53 SNDRV_PCM_RATE_44100 |
54 SNDRV_PCM_RATE_32000),
59 .buffer_bytes_max = (128*1024),
60 .period_bytes_min = (64),
61 .period_bytes_max = (128*1024),
67 /* Hardware descriptions for capture */
68 static const struct snd_pcm_hardware ct_pcm_capture_hw = {
69 .info = (SNDRV_PCM_INFO_MMAP |
70 SNDRV_PCM_INFO_INTERLEAVED |
71 SNDRV_PCM_INFO_BLOCK_TRANSFER |
72 SNDRV_PCM_INFO_PAUSE |
73 SNDRV_PCM_INFO_MMAP_VALID),
74 .formats = (SNDRV_PCM_FMTBIT_U8 |
75 SNDRV_PCM_FMTBIT_S16_LE |
76 SNDRV_PCM_FMTBIT_S24_3LE |
77 SNDRV_PCM_FMTBIT_S32_LE |
78 SNDRV_PCM_FMTBIT_FLOAT_LE),
79 .rates = (SNDRV_PCM_RATE_CONTINUOUS |
80 SNDRV_PCM_RATE_8000_96000),
85 .buffer_bytes_max = (128*1024),
86 .period_bytes_min = (384),
87 .period_bytes_max = (64*1024),
93 static void ct_atc_pcm_interrupt(struct ct_atc_pcm *atc_pcm)
95 struct ct_atc_pcm *apcm = atc_pcm;
100 snd_pcm_period_elapsed(apcm->substream);
103 static void ct_atc_pcm_free_substream(struct snd_pcm_runtime *runtime)
105 struct ct_atc_pcm *apcm = runtime->private_data;
106 struct ct_atc *atc = snd_pcm_substream_chip(apcm->substream);
108 atc->pcm_release_resources(atc, apcm);
109 ct_timer_instance_free(apcm->timer);
111 runtime->private_data = NULL;
114 /* pcm playback operations */
115 static int ct_pcm_playback_open(struct snd_pcm_substream *substream)
117 struct ct_atc *atc = snd_pcm_substream_chip(substream);
118 struct snd_pcm_runtime *runtime = substream->runtime;
119 struct ct_atc_pcm *apcm;
122 apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
126 apcm->substream = substream;
127 apcm->interrupt = ct_atc_pcm_interrupt;
128 if (IEC958 == substream->pcm->device) {
129 runtime->hw = ct_spdif_passthru_playback_hw;
130 atc->spdif_out_passthru(atc, 1);
132 runtime->hw = ct_pcm_playback_hw;
133 if (FRONT == substream->pcm->device)
134 runtime->hw.channels_max = 8;
137 err = snd_pcm_hw_constraint_integer(runtime,
138 SNDRV_PCM_HW_PARAM_PERIODS);
142 err = snd_pcm_hw_constraint_minmax(runtime,
143 SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
148 apcm->timer = ct_timer_instance_new(atc->timer, apcm);
153 runtime->private_data = apcm;
154 runtime->private_free = ct_atc_pcm_free_substream;
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 struct ct_atc *atc = snd_pcm_substream_chip(substream);
180 struct ct_atc_pcm *apcm = substream->runtime->private_data;
182 /* clear previous resources */
183 atc->pcm_release_resources(atc, apcm);
187 static int ct_pcm_hw_free(struct snd_pcm_substream *substream)
189 struct ct_atc *atc = snd_pcm_substream_chip(substream);
190 struct ct_atc_pcm *apcm = substream->runtime->private_data;
192 /* clear previous resources */
193 atc->pcm_release_resources(atc, apcm);
198 static int ct_pcm_playback_prepare(struct snd_pcm_substream *substream)
201 struct ct_atc *atc = snd_pcm_substream_chip(substream);
202 struct snd_pcm_runtime *runtime = substream->runtime;
203 struct ct_atc_pcm *apcm = runtime->private_data;
205 if (IEC958 == substream->pcm->device)
206 err = atc->spdif_passthru_playback_prepare(atc, apcm);
208 err = atc->pcm_playback_prepare(atc, apcm);
211 dev_err(atc->card->dev,
212 "Preparing pcm playback failed!!!\n");
220 ct_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
222 struct ct_atc *atc = snd_pcm_substream_chip(substream);
223 struct snd_pcm_runtime *runtime = substream->runtime;
224 struct ct_atc_pcm *apcm = runtime->private_data;
227 case SNDRV_PCM_TRIGGER_START:
228 case SNDRV_PCM_TRIGGER_RESUME:
229 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
230 atc->pcm_playback_start(atc, apcm);
232 case SNDRV_PCM_TRIGGER_STOP:
233 case SNDRV_PCM_TRIGGER_SUSPEND:
234 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
235 atc->pcm_playback_stop(atc, apcm);
244 static snd_pcm_uframes_t
245 ct_pcm_playback_pointer(struct snd_pcm_substream *substream)
247 unsigned long position;
248 struct ct_atc *atc = snd_pcm_substream_chip(substream);
249 struct snd_pcm_runtime *runtime = substream->runtime;
250 struct ct_atc_pcm *apcm = runtime->private_data;
252 /* Read out playback position */
253 position = atc->pcm_playback_position(atc, apcm);
254 position = bytes_to_frames(runtime, position);
255 if (position >= runtime->buffer_size)
260 /* pcm capture operations */
261 static int ct_pcm_capture_open(struct snd_pcm_substream *substream)
263 struct ct_atc *atc = snd_pcm_substream_chip(substream);
264 struct snd_pcm_runtime *runtime = substream->runtime;
265 struct ct_atc_pcm *apcm;
268 apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
273 apcm->substream = substream;
274 apcm->interrupt = ct_atc_pcm_interrupt;
275 runtime->hw = ct_pcm_capture_hw;
276 runtime->hw.rate_max = atc->rsr * atc->msr;
278 err = snd_pcm_hw_constraint_integer(runtime,
279 SNDRV_PCM_HW_PARAM_PERIODS);
283 err = snd_pcm_hw_constraint_minmax(runtime,
284 SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
289 apcm->timer = ct_timer_instance_new(atc->timer, apcm);
294 runtime->private_data = apcm;
295 runtime->private_free = ct_atc_pcm_free_substream;
304 static int ct_pcm_capture_close(struct snd_pcm_substream *substream)
306 /* The ct_atc_pcm object will be freed by runtime->private_free */
307 /* TODO: Notify mixer inactive. */
311 static int ct_pcm_capture_prepare(struct snd_pcm_substream *substream)
314 struct ct_atc *atc = snd_pcm_substream_chip(substream);
315 struct snd_pcm_runtime *runtime = substream->runtime;
316 struct ct_atc_pcm *apcm = runtime->private_data;
318 err = atc->pcm_capture_prepare(atc, apcm);
320 dev_err(atc->card->dev,
321 "Preparing pcm capture failed!!!\n");
329 ct_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
331 struct ct_atc *atc = snd_pcm_substream_chip(substream);
332 struct snd_pcm_runtime *runtime = substream->runtime;
333 struct ct_atc_pcm *apcm = runtime->private_data;
336 case SNDRV_PCM_TRIGGER_START:
337 atc->pcm_capture_start(atc, apcm);
339 case SNDRV_PCM_TRIGGER_STOP:
340 atc->pcm_capture_stop(atc, apcm);
343 atc->pcm_capture_stop(atc, apcm);
350 static snd_pcm_uframes_t
351 ct_pcm_capture_pointer(struct snd_pcm_substream *substream)
353 unsigned long position;
354 struct ct_atc *atc = snd_pcm_substream_chip(substream);
355 struct snd_pcm_runtime *runtime = substream->runtime;
356 struct ct_atc_pcm *apcm = runtime->private_data;
358 /* Read out playback position */
359 position = atc->pcm_capture_position(atc, apcm);
360 position = bytes_to_frames(runtime, position);
361 if (position >= runtime->buffer_size)
366 /* PCM operators for playback */
367 static const struct snd_pcm_ops ct_pcm_playback_ops = {
368 .open = ct_pcm_playback_open,
369 .close = ct_pcm_playback_close,
370 .hw_params = ct_pcm_hw_params,
371 .hw_free = ct_pcm_hw_free,
372 .prepare = ct_pcm_playback_prepare,
373 .trigger = ct_pcm_playback_trigger,
374 .pointer = ct_pcm_playback_pointer,
377 /* PCM operators for capture */
378 static const struct snd_pcm_ops ct_pcm_capture_ops = {
379 .open = ct_pcm_capture_open,
380 .close = ct_pcm_capture_close,
381 .hw_params = ct_pcm_hw_params,
382 .hw_free = ct_pcm_hw_free,
383 .prepare = ct_pcm_capture_prepare,
384 .trigger = ct_pcm_capture_trigger,
385 .pointer = ct_pcm_capture_pointer,
388 static const struct snd_pcm_chmap_elem surround_map[] = {
390 .map = { SNDRV_CHMAP_MONO } },
392 .map = { SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
396 static const struct snd_pcm_chmap_elem clfe_map[] = {
398 .map = { SNDRV_CHMAP_MONO } },
400 .map = { SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE } },
404 static const struct snd_pcm_chmap_elem side_map[] = {
406 .map = { SNDRV_CHMAP_MONO } },
408 .map = { SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
412 /* Create ALSA pcm device */
413 int ct_alsa_pcm_create(struct ct_atc *atc,
414 enum CTALSADEVS device,
415 const char *device_name)
418 const struct snd_pcm_chmap_elem *map;
421 int playback_count, capture_count;
423 playback_count = (IEC958 == device) ? 1 : 256;
424 capture_count = (FRONT == device) ? 1 : 0;
425 err = snd_pcm_new(atc->card, "ctxfi", device,
426 playback_count, capture_count, &pcm);
428 dev_err(atc->card->dev, "snd_pcm_new failed!! Err=%d\n",
433 pcm->private_data = atc;
435 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
436 strscpy(pcm->name, device_name, sizeof(pcm->name));
438 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ct_pcm_playback_ops);
442 SNDRV_PCM_STREAM_CAPTURE, &ct_pcm_capture_ops);
444 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
445 &atc->pci->dev, 128*1024, 128*1024);
451 map = snd_pcm_std_chmaps;
463 map = snd_pcm_std_chmaps;
466 err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, chs,
471 #ifdef CONFIG_PM_SLEEP
472 atc->pcms[device] = pcm;