ALSA: au88x0: More constifications
[muen/linux.git] / sound / pci / au88x0 / au88x0_pcm.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  */
4  
5 /*
6  * Vortex PCM ALSA driver.
7  *
8  * Supports ADB and WT DMA. Unfortunately, WT channels do not run yet.
9  * It remains stuck,and DMA transfers do not happen. 
10  */
11 #include <sound/asoundef.h>
12 #include <linux/time.h>
13 #include <sound/core.h>
14 #include <sound/pcm.h>
15 #include <sound/pcm_params.h>
16 #include "au88x0.h"
17
18 #define VORTEX_PCM_TYPE(x) (x->name[40])
19
20 /* hardware definition */
21 static const struct snd_pcm_hardware snd_vortex_playback_hw_adb = {
22         .info =
23             (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */
24              SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
25              SNDRV_PCM_INFO_MMAP_VALID),
26         .formats =
27             SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
28             SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW,
29         .rates = SNDRV_PCM_RATE_CONTINUOUS,
30         .rate_min = 5000,
31         .rate_max = 48000,
32         .channels_min = 1,
33         .channels_max = 2,
34         .buffer_bytes_max = 0x10000,
35         .period_bytes_min = 0x20,
36         .period_bytes_max = 0x1000,
37         .periods_min = 2,
38         .periods_max = 1024,
39 };
40
41 #ifndef CHIP_AU8820
42 static const struct snd_pcm_hardware snd_vortex_playback_hw_a3d = {
43         .info =
44             (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */
45              SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
46              SNDRV_PCM_INFO_MMAP_VALID),
47         .formats =
48             SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
49             SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW,
50         .rates = SNDRV_PCM_RATE_CONTINUOUS,
51         .rate_min = 5000,
52         .rate_max = 48000,
53         .channels_min = 1,
54         .channels_max = 1,
55         .buffer_bytes_max = 0x10000,
56         .period_bytes_min = 0x100,
57         .period_bytes_max = 0x1000,
58         .periods_min = 2,
59         .periods_max = 64,
60 };
61 #endif
62 static const struct snd_pcm_hardware snd_vortex_playback_hw_spdif = {
63         .info =
64             (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */
65              SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
66              SNDRV_PCM_INFO_MMAP_VALID),
67         .formats =
68             SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
69             SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE | SNDRV_PCM_FMTBIT_MU_LAW |
70             SNDRV_PCM_FMTBIT_A_LAW,
71         .rates =
72             SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
73         .rate_min = 32000,
74         .rate_max = 48000,
75         .channels_min = 1,
76         .channels_max = 2,
77         .buffer_bytes_max = 0x10000,
78         .period_bytes_min = 0x100,
79         .period_bytes_max = 0x1000,
80         .periods_min = 2,
81         .periods_max = 64,
82 };
83
84 #ifndef CHIP_AU8810
85 static const struct snd_pcm_hardware snd_vortex_playback_hw_wt = {
86         .info = (SNDRV_PCM_INFO_MMAP |
87                  SNDRV_PCM_INFO_INTERLEAVED |
88                  SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
89         .formats = SNDRV_PCM_FMTBIT_S16_LE,
90         .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_CONTINUOUS, // SNDRV_PCM_RATE_48000,
91         .rate_min = 8000,
92         .rate_max = 48000,
93         .channels_min = 1,
94         .channels_max = 2,
95         .buffer_bytes_max = 0x10000,
96         .period_bytes_min = 0x0400,
97         .period_bytes_max = 0x1000,
98         .periods_min = 2,
99         .periods_max = 64,
100 };
101 #endif
102 #ifdef CHIP_AU8830
103 static const unsigned int au8830_channels[3] = {
104         1, 2, 4,
105 };
106
107 static const struct snd_pcm_hw_constraint_list hw_constraints_au8830_channels = {
108         .count = ARRAY_SIZE(au8830_channels),
109         .list = au8830_channels,
110         .mask = 0,
111 };
112 #endif
113
114 static void vortex_notify_pcm_vol_change(struct snd_card *card,
115                         struct snd_kcontrol *kctl, int activate)
116 {
117         if (activate)
118                 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
119         else
120                 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
121         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE |
122                                 SNDRV_CTL_EVENT_MASK_INFO, &(kctl->id));
123 }
124
125 /* open callback */
126 static int snd_vortex_pcm_open(struct snd_pcm_substream *substream)
127 {
128         vortex_t *vortex = snd_pcm_substream_chip(substream);
129         struct snd_pcm_runtime *runtime = substream->runtime;
130         int err;
131         
132         /* Force equal size periods */
133         if ((err =
134              snd_pcm_hw_constraint_integer(runtime,
135                                            SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
136                 return err;
137         /* Avoid PAGE_SIZE boundary to fall inside of a period. */
138         if ((err =
139              snd_pcm_hw_constraint_pow2(runtime, 0,
140                                         SNDRV_PCM_HW_PARAM_PERIOD_BYTES)) < 0)
141                 return err;
142
143         snd_pcm_hw_constraint_step(runtime, 0,
144                                         SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 64);
145
146         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
147 #ifndef CHIP_AU8820
148                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_A3D) {
149                         runtime->hw = snd_vortex_playback_hw_a3d;
150                 }
151 #endif
152                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_SPDIF) {
153                         runtime->hw = snd_vortex_playback_hw_spdif;
154                         switch (vortex->spdif_sr) {
155                         case 32000:
156                                 runtime->hw.rates = SNDRV_PCM_RATE_32000;
157                                 break;
158                         case 44100:
159                                 runtime->hw.rates = SNDRV_PCM_RATE_44100;
160                                 break;
161                         case 48000:
162                                 runtime->hw.rates = SNDRV_PCM_RATE_48000;
163                                 break;
164                         }
165                 }
166                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB
167                     || VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_I2S)
168                         runtime->hw = snd_vortex_playback_hw_adb;
169 #ifdef CHIP_AU8830
170                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
171                         VORTEX_IS_QUAD(vortex) &&
172                         VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB) {
173                         runtime->hw.channels_max = 4;
174                         snd_pcm_hw_constraint_list(runtime, 0,
175                                 SNDRV_PCM_HW_PARAM_CHANNELS,
176                                 &hw_constraints_au8830_channels);
177                 }
178 #endif
179                 substream->runtime->private_data = NULL;
180         }
181 #ifndef CHIP_AU8810
182         else {
183                 runtime->hw = snd_vortex_playback_hw_wt;
184                 substream->runtime->private_data = NULL;
185         }
186 #endif
187         return 0;
188 }
189
190 /* close callback */
191 static int snd_vortex_pcm_close(struct snd_pcm_substream *substream)
192 {
193         //vortex_t *chip = snd_pcm_substream_chip(substream);
194         stream_t *stream = (stream_t *) substream->runtime->private_data;
195
196         // the hardware-specific codes will be here
197         if (stream != NULL) {
198                 stream->substream = NULL;
199                 stream->nr_ch = 0;
200         }
201         substream->runtime->private_data = NULL;
202         return 0;
203 }
204
205 /* hw_params callback */
206 static int
207 snd_vortex_pcm_hw_params(struct snd_pcm_substream *substream,
208                          struct snd_pcm_hw_params *hw_params)
209 {
210         vortex_t *chip = snd_pcm_substream_chip(substream);
211         stream_t *stream = (stream_t *) (substream->runtime->private_data);
212
213         /*
214            pr_info( "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params),
215            params_period_bytes(hw_params), params_channels(hw_params));
216          */
217         spin_lock_irq(&chip->lock);
218         // Make audio routes and config buffer DMA.
219         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
220                 int dma, type = VORTEX_PCM_TYPE(substream->pcm);
221                 /* Dealloc any routes. */
222                 if (stream != NULL)
223                         vortex_adb_allocroute(chip, stream->dma,
224                                               stream->nr_ch, stream->dir,
225                                               stream->type,
226                                               substream->number);
227                 /* Alloc routes. */
228                 dma =
229                     vortex_adb_allocroute(chip, -1,
230                                           params_channels(hw_params),
231                                           substream->stream, type,
232                                           substream->number);
233                 if (dma < 0) {
234                         spin_unlock_irq(&chip->lock);
235                         return dma;
236                 }
237                 stream = substream->runtime->private_data = &chip->dma_adb[dma];
238                 stream->substream = substream;
239                 /* Setup Buffers. */
240                 vortex_adbdma_setbuffers(chip, dma,
241                                          params_period_bytes(hw_params),
242                                          params_periods(hw_params));
243                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB) {
244                         chip->pcm_vol[substream->number].active = 1;
245                         vortex_notify_pcm_vol_change(chip->card,
246                                 chip->pcm_vol[substream->number].kctl, 1);
247                 }
248         }
249 #ifndef CHIP_AU8810
250         else {
251                 /* if (stream != NULL)
252                    vortex_wt_allocroute(chip, substream->number, 0); */
253                 vortex_wt_allocroute(chip, substream->number,
254                                      params_channels(hw_params));
255                 stream = substream->runtime->private_data =
256                     &chip->dma_wt[substream->number];
257                 stream->dma = substream->number;
258                 stream->substream = substream;
259                 vortex_wtdma_setbuffers(chip, substream->number,
260                                         params_period_bytes(hw_params),
261                                         params_periods(hw_params));
262         }
263 #endif
264         spin_unlock_irq(&chip->lock);
265         return 0;
266 }
267
268 /* hw_free callback */
269 static int snd_vortex_pcm_hw_free(struct snd_pcm_substream *substream)
270 {
271         vortex_t *chip = snd_pcm_substream_chip(substream);
272         stream_t *stream = (stream_t *) (substream->runtime->private_data);
273
274         spin_lock_irq(&chip->lock);
275         // Delete audio routes.
276         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
277                 if (stream != NULL) {
278                         if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB) {
279                                 chip->pcm_vol[substream->number].active = 0;
280                                 vortex_notify_pcm_vol_change(chip->card,
281                                         chip->pcm_vol[substream->number].kctl,
282                                         0);
283                         }
284                         vortex_adb_allocroute(chip, stream->dma,
285                                               stream->nr_ch, stream->dir,
286                                               stream->type,
287                                               substream->number);
288                 }
289         }
290 #ifndef CHIP_AU8810
291         else {
292                 if (stream != NULL)
293                         vortex_wt_allocroute(chip, stream->dma, 0);
294         }
295 #endif
296         substream->runtime->private_data = NULL;
297         spin_unlock_irq(&chip->lock);
298
299         return 0;
300 }
301
302 /* prepare callback */
303 static int snd_vortex_pcm_prepare(struct snd_pcm_substream *substream)
304 {
305         vortex_t *chip = snd_pcm_substream_chip(substream);
306         struct snd_pcm_runtime *runtime = substream->runtime;
307         stream_t *stream = (stream_t *) substream->runtime->private_data;
308         int dma = stream->dma, fmt, dir;
309
310         // set up the hardware with the current configuration.
311         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
312                 dir = 1;
313         else
314                 dir = 0;
315         fmt = vortex_alsafmt_aspfmt(runtime->format, chip);
316         spin_lock_irq(&chip->lock);
317         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
318                 vortex_adbdma_setmode(chip, dma, 1, dir, fmt,
319                                 runtime->channels == 1 ? 0 : 1, 0);
320                 vortex_adbdma_setstartbuffer(chip, dma, 0);
321                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_SPDIF)
322                         vortex_adb_setsrc(chip, dma, runtime->rate, dir);
323         }
324 #ifndef CHIP_AU8810
325         else {
326                 vortex_wtdma_setmode(chip, dma, 1, fmt, 0, 0);
327                 // FIXME: Set rate (i guess using vortex_wt_writereg() somehow).
328                 vortex_wtdma_setstartbuffer(chip, dma, 0);
329         }
330 #endif
331         spin_unlock_irq(&chip->lock);
332         return 0;
333 }
334
335 /* trigger callback */
336 static int snd_vortex_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
337 {
338         vortex_t *chip = snd_pcm_substream_chip(substream);
339         stream_t *stream = (stream_t *) substream->runtime->private_data;
340         int dma = stream->dma;
341
342         spin_lock(&chip->lock);
343         switch (cmd) {
344         case SNDRV_PCM_TRIGGER_START:
345                 // do something to start the PCM engine
346                 //printk(KERN_INFO "vortex: start %d\n", dma);
347                 stream->fifo_enabled = 1;
348                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
349                         vortex_adbdma_resetup(chip, dma);
350                         vortex_adbdma_startfifo(chip, dma);
351                 }
352 #ifndef CHIP_AU8810
353                 else {
354                         dev_info(chip->card->dev, "wt start %d\n", dma);
355                         vortex_wtdma_startfifo(chip, dma);
356                 }
357 #endif
358                 break;
359         case SNDRV_PCM_TRIGGER_STOP:
360                 // do something to stop the PCM engine
361                 //printk(KERN_INFO "vortex: stop %d\n", dma);
362                 stream->fifo_enabled = 0;
363                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
364                         vortex_adbdma_stopfifo(chip, dma);
365 #ifndef CHIP_AU8810
366                 else {
367                         dev_info(chip->card->dev, "wt stop %d\n", dma);
368                         vortex_wtdma_stopfifo(chip, dma);
369                 }
370 #endif
371                 break;
372         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
373                 //printk(KERN_INFO "vortex: pause %d\n", dma);
374                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
375                         vortex_adbdma_pausefifo(chip, dma);
376 #ifndef CHIP_AU8810
377                 else
378                         vortex_wtdma_pausefifo(chip, dma);
379 #endif
380                 break;
381         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
382                 //printk(KERN_INFO "vortex: resume %d\n", dma);
383                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
384                         vortex_adbdma_resumefifo(chip, dma);
385 #ifndef CHIP_AU8810
386                 else
387                         vortex_wtdma_resumefifo(chip, dma);
388 #endif
389                 break;
390         default:
391                 spin_unlock(&chip->lock);
392                 return -EINVAL;
393         }
394         spin_unlock(&chip->lock);
395         return 0;
396 }
397
398 /* pointer callback */
399 static snd_pcm_uframes_t snd_vortex_pcm_pointer(struct snd_pcm_substream *substream)
400 {
401         vortex_t *chip = snd_pcm_substream_chip(substream);
402         stream_t *stream = (stream_t *) substream->runtime->private_data;
403         int dma = stream->dma;
404         snd_pcm_uframes_t current_ptr = 0;
405
406         spin_lock(&chip->lock);
407         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
408                 current_ptr = vortex_adbdma_getlinearpos(chip, dma);
409 #ifndef CHIP_AU8810
410         else
411                 current_ptr = vortex_wtdma_getlinearpos(chip, dma);
412 #endif
413         //printk(KERN_INFO "vortex: pointer = 0x%x\n", current_ptr);
414         spin_unlock(&chip->lock);
415         current_ptr = bytes_to_frames(substream->runtime, current_ptr);
416         if (current_ptr >= substream->runtime->buffer_size)
417                 current_ptr = 0;
418         return current_ptr;
419 }
420
421 /* operators */
422 static const struct snd_pcm_ops snd_vortex_playback_ops = {
423         .open = snd_vortex_pcm_open,
424         .close = snd_vortex_pcm_close,
425         .hw_params = snd_vortex_pcm_hw_params,
426         .hw_free = snd_vortex_pcm_hw_free,
427         .prepare = snd_vortex_pcm_prepare,
428         .trigger = snd_vortex_pcm_trigger,
429         .pointer = snd_vortex_pcm_pointer,
430 };
431
432 /*
433 *  definitions of capture are omitted here...
434 */
435
436 static const char * const vortex_pcm_prettyname[VORTEX_PCM_LAST] = {
437         CARD_NAME " ADB",
438         CARD_NAME " SPDIF",
439         CARD_NAME " A3D",
440         CARD_NAME " WT",
441         CARD_NAME " I2S",
442 };
443 static const char * const vortex_pcm_name[VORTEX_PCM_LAST] = {
444         "adb",
445         "spdif",
446         "a3d",
447         "wt",
448         "i2s",
449 };
450
451 /* SPDIF kcontrol */
452
453 static int snd_vortex_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
454 {
455         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
456         uinfo->count = 1;
457         return 0;
458 }
459
460 static int snd_vortex_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
461 {
462         ucontrol->value.iec958.status[0] = 0xff;
463         ucontrol->value.iec958.status[1] = 0xff;
464         ucontrol->value.iec958.status[2] = 0xff;
465         ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
466         return 0;
467 }
468
469 static int snd_vortex_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
470 {
471         vortex_t *vortex = snd_kcontrol_chip(kcontrol);
472         ucontrol->value.iec958.status[0] = 0x00;
473         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_ORIGINAL|IEC958_AES1_CON_DIGDIGCONV_ID;
474         ucontrol->value.iec958.status[2] = 0x00;
475         switch (vortex->spdif_sr) {
476         case 32000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_32000; break;
477         case 44100: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_44100; break;
478         case 48000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_48000; break;
479         }
480         return 0;
481 }
482
483 static int snd_vortex_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
484 {
485         vortex_t *vortex = snd_kcontrol_chip(kcontrol);
486         int spdif_sr = 48000;
487         switch (ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) {
488         case IEC958_AES3_CON_FS_32000: spdif_sr = 32000; break;
489         case IEC958_AES3_CON_FS_44100: spdif_sr = 44100; break;
490         case IEC958_AES3_CON_FS_48000: spdif_sr = 48000; break;
491         }
492         if (spdif_sr == vortex->spdif_sr)
493                 return 0;
494         vortex->spdif_sr = spdif_sr;
495         vortex_spdif_init(vortex, vortex->spdif_sr, 1);
496         return 1;
497 }
498
499 /* spdif controls */
500 static const struct snd_kcontrol_new snd_vortex_mixer_spdif[] = {
501         {
502                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
503                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
504                 .info =         snd_vortex_spdif_info,
505                 .get =          snd_vortex_spdif_get,
506                 .put =          snd_vortex_spdif_put,
507         },
508         {
509                 .access =       SNDRV_CTL_ELEM_ACCESS_READ,
510                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
511                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
512                 .info =         snd_vortex_spdif_info,
513                 .get =          snd_vortex_spdif_mask_get
514         },
515 };
516
517 /* subdevice PCM Volume control */
518
519 static int snd_vortex_pcm_vol_info(struct snd_kcontrol *kcontrol,
520                                 struct snd_ctl_elem_info *uinfo)
521 {
522         vortex_t *vortex = snd_kcontrol_chip(kcontrol);
523         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
524         uinfo->count = (VORTEX_IS_QUAD(vortex) ? 4 : 2);
525         uinfo->value.integer.min = -128;
526         uinfo->value.integer.max = 32;
527         return 0;
528 }
529
530 static int snd_vortex_pcm_vol_get(struct snd_kcontrol *kcontrol,
531                                 struct snd_ctl_elem_value *ucontrol)
532 {
533         int i;
534         vortex_t *vortex = snd_kcontrol_chip(kcontrol);
535         int subdev = kcontrol->id.subdevice;
536         struct pcm_vol *p = &vortex->pcm_vol[subdev];
537         int max_chn = (VORTEX_IS_QUAD(vortex) ? 4 : 2);
538         for (i = 0; i < max_chn; i++)
539                 ucontrol->value.integer.value[i] = p->vol[i];
540         return 0;
541 }
542
543 static int snd_vortex_pcm_vol_put(struct snd_kcontrol *kcontrol,
544                                 struct snd_ctl_elem_value *ucontrol)
545 {
546         int i;
547         int changed = 0;
548         int mixin;
549         unsigned char vol;
550         vortex_t *vortex = snd_kcontrol_chip(kcontrol);
551         int subdev = kcontrol->id.subdevice;
552         struct pcm_vol *p = &vortex->pcm_vol[subdev];
553         int max_chn = (VORTEX_IS_QUAD(vortex) ? 4 : 2);
554         for (i = 0; i < max_chn; i++) {
555                 if (p->vol[i] != ucontrol->value.integer.value[i]) {
556                         p->vol[i] = ucontrol->value.integer.value[i];
557                         if (p->active) {
558                                 switch (vortex->dma_adb[p->dma].nr_ch) {
559                                 case 1:
560                                         mixin = p->mixin[0];
561                                         break;
562                                 case 2:
563                                 default:
564                                         mixin = p->mixin[(i < 2) ? i : (i - 2)];
565                                         break;
566                                 case 4:
567                                         mixin = p->mixin[i];
568                                         break;
569                                 }
570                                 vol = p->vol[i];
571                                 vortex_mix_setinputvolumebyte(vortex,
572                                         vortex->mixplayb[i], mixin, vol);
573                         }
574                         changed = 1;
575                 }
576         }
577         return changed;
578 }
579
580 static const DECLARE_TLV_DB_MINMAX(vortex_pcm_vol_db_scale, -9600, 2400);
581
582 static const struct snd_kcontrol_new snd_vortex_pcm_vol = {
583         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
584         .name = "PCM Playback Volume",
585         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
586                 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
587                 SNDRV_CTL_ELEM_ACCESS_INACTIVE,
588         .info = snd_vortex_pcm_vol_info,
589         .get = snd_vortex_pcm_vol_get,
590         .put = snd_vortex_pcm_vol_put,
591         .tlv = { .p = vortex_pcm_vol_db_scale },
592 };
593
594 /* create a pcm device */
595 static int snd_vortex_new_pcm(vortex_t *chip, int idx, int nr)
596 {
597         struct snd_pcm *pcm;
598         struct snd_kcontrol *kctl;
599         int i;
600         int err, nr_capt;
601
602         if (!chip || idx < 0 || idx >= VORTEX_PCM_LAST)
603                 return -ENODEV;
604
605         /* idx indicates which kind of PCM device. ADB, SPDIF, I2S and A3D share the 
606          * same dma engine. WT uses it own separate dma engine which can't capture. */
607         if (idx == VORTEX_PCM_ADB)
608                 nr_capt = nr;
609         else
610                 nr_capt = 0;
611         err = snd_pcm_new(chip->card, vortex_pcm_prettyname[idx], idx, nr,
612                           nr_capt, &pcm);
613         if (err < 0)
614                 return err;
615         snprintf(pcm->name, sizeof(pcm->name),
616                 "%s %s", CARD_NAME_SHORT, vortex_pcm_name[idx]);
617         chip->pcm[idx] = pcm;
618         // This is an evil hack, but it saves a lot of duplicated code.
619         VORTEX_PCM_TYPE(pcm) = idx;
620         pcm->private_data = chip;
621         /* set operators */
622         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
623                         &snd_vortex_playback_ops);
624         if (idx == VORTEX_PCM_ADB)
625                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
626                                 &snd_vortex_playback_ops);
627         
628         /* pre-allocation of Scatter-Gather buffers */
629         
630         snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
631                                        &chip->pci_dev->dev, 0x10000, 0x10000);
632
633         switch (VORTEX_PCM_TYPE(pcm)) {
634         case VORTEX_PCM_ADB:
635                 err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
636                                              snd_pcm_std_chmaps,
637                                              VORTEX_IS_QUAD(chip) ? 4 : 2,
638                                              0, NULL);
639                 if (err < 0)
640                         return err;
641                 err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_CAPTURE,
642                                              snd_pcm_std_chmaps, 2, 0, NULL);
643                 if (err < 0)
644                         return err;
645                 break;
646 #ifdef CHIP_AU8830
647         case VORTEX_PCM_A3D:
648                 err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
649                                              snd_pcm_std_chmaps, 1, 0, NULL);
650                 if (err < 0)
651                         return err;
652                 break;
653 #endif
654         }
655
656         if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_SPDIF) {
657                 for (i = 0; i < ARRAY_SIZE(snd_vortex_mixer_spdif); i++) {
658                         kctl = snd_ctl_new1(&snd_vortex_mixer_spdif[i], chip);
659                         if (!kctl)
660                                 return -ENOMEM;
661                         if ((err = snd_ctl_add(chip->card, kctl)) < 0)
662                                 return err;
663                 }
664         }
665         if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_ADB) {
666                 for (i = 0; i < NR_PCM; i++) {
667                         chip->pcm_vol[i].active = 0;
668                         chip->pcm_vol[i].dma = -1;
669                         kctl = snd_ctl_new1(&snd_vortex_pcm_vol, chip);
670                         if (!kctl)
671                                 return -ENOMEM;
672                         chip->pcm_vol[i].kctl = kctl;
673                         kctl->id.device = 0;
674                         kctl->id.subdevice = i;
675                         err = snd_ctl_add(chip->card, kctl);
676                         if (err < 0)
677                                 return err;
678                 }
679         }
680         return 0;
681 }