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

TOMOYO Linux Cross Reference
Linux/sound/pci/au88x0/au88x0_pcm.c

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

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