sound/pci/au88x0/au88x0_pcm.c

   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 <sound/driver.h>
  25 #include <linux/time.h>
  26 #include <sound/core.h>
  27 #include <sound/pcm.h>
  28 #include <sound/pcm_params.h>
  29 #include "au88x0.h"
  30
  31 #define VORTEX_PCM_TYPE(x) (x->name[40])
  32
  33 /* hardware definition */
  34 static snd_pcm_hardware_t snd_vortex_playback_hw_adb = {
  35         .info =
  36             (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_RESUME |
  37              SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
  38              SNDRV_PCM_INFO_MMAP_VALID),
  39         .formats =
  40             SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
  41             SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW,
  42         .rates = SNDRV_PCM_RATE_CONTINUOUS,
  43         .rate_min = 5000,
  44         .rate_max = 48000,
  45         .channels_min = 1,
  46 #ifdef CHIP_AU8830
  47         .channels_max = 4,
  48 #else
  49         .channels_max = 2,
  50 #endif
  51         .buffer_bytes_max = 0x10000,
  52         .period_bytes_min = 0x1,
  53         .period_bytes_max = 0x1000,
  54         .periods_min = 2,
  55         .periods_max = 32,
  56 };
  57
  58 #ifndef CHIP_AU8820
  59 static snd_pcm_hardware_t snd_vortex_playback_hw_a3d = {
  60         .info =
  61             (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_RESUME |
  62              SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
  63              SNDRV_PCM_INFO_MMAP_VALID),
  64         .formats =
  65             SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
  66             SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW,
  67         .rates = SNDRV_PCM_RATE_CONTINUOUS,
  68         .rate_min = 5000,
  69         .rate_max = 48000,
  70         .channels_min = 1,
  71         .channels_max = 1,
  72         .buffer_bytes_max = 0x10000,
  73         .period_bytes_min = 0x100,
  74         .period_bytes_max = 0x1000,
  75         .periods_min = 2,
  76         .periods_max = 64,
  77 };
  78 #endif
  79 static snd_pcm_hardware_t snd_vortex_playback_hw_spdif = {
  80         .info =
  81             (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_RESUME |
  82              SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED |
  83              SNDRV_PCM_INFO_MMAP_VALID),
  84         .formats =
  85             SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 |
  86             SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE | SNDRV_PCM_FMTBIT_MU_LAW |
  87             SNDRV_PCM_FMTBIT_A_LAW,
  88         .rates =
  89             SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
  90         .rate_min = 32000,
  91         .rate_max = 48000,
  92         .channels_min = 1,
  93         .channels_max = 2,
  94         .buffer_bytes_max = 0x10000,
  95         .period_bytes_min = 0x100,
  96         .period_bytes_max = 0x1000,
  97         .periods_min = 2,
  98         .periods_max = 64,
  99 };
 100
 101 #ifndef CHIP_AU8810
 102 static snd_pcm_hardware_t snd_vortex_playback_hw_wt = {
 103         .info = (SNDRV_PCM_INFO_MMAP |
 104                  SNDRV_PCM_INFO_INTERLEAVED |
 105                  SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID),
 106         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 107         .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_CONTINUOUS, // SNDRV_PCM_RATE_48000,
 108         .rate_min = 8000,
 109         .rate_max = 48000,
 110         .channels_min = 1,
 111         .channels_max = 2,
 112         .buffer_bytes_max = 0x10000,
 113         .period_bytes_min = 0x0400,
 114         .period_bytes_max = 0x1000,
 115         .periods_min = 2,
 116         .periods_max = 64,
 117 };
 118 #endif
 119 /* open callback */
 120 static int snd_vortex_pcm_open(snd_pcm_substream_t * substream)
 121 {
 122         vortex_t *vortex = snd_pcm_substream_chip(substream);
 123         snd_pcm_runtime_t *runtime = substream->runtime;
 124         int err;
 125
 126         /* Force equal size periods */
 127         if ((err =
 128              snd_pcm_hw_constraint_integer(runtime,
 129                                            SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
 130                 return err;
 131         /* Avoid PAGE_SIZE boundary to fall inside of a period. */
 132         if ((err =
 133              snd_pcm_hw_constraint_pow2(runtime, 0,
 134                                         SNDRV_PCM_HW_PARAM_PERIOD_BYTES)) < 0)
 135                 return err;
 136
 137         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
 138 #ifndef CHIP_AU8820
 139                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_A3D) {
 140                         runtime->hw = snd_vortex_playback_hw_a3d;
 141                 }
 142 #endif
 143                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_SPDIF) {
 144                         runtime->hw = snd_vortex_playback_hw_spdif;
 145                         switch (vortex->spdif_sr) {
 146                         case 32000:
 147                                 runtime->hw.rates = SNDRV_PCM_RATE_32000;
 148                                 break;
 149                         case 44100:
 150                                 runtime->hw.rates = SNDRV_PCM_RATE_44100;
 151                                 break;
 152                         case 48000:
 153                                 runtime->hw.rates = SNDRV_PCM_RATE_48000;
 154                                 break;
 155                         }
 156                 }
 157                 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB
 158                     || VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_I2S)
 159                         runtime->hw = snd_vortex_playback_hw_adb;
 160                 substream->runtime->private_data = NULL;
 161         }
 162 #ifndef CHIP_AU8810
 163         else {
 164                 runtime->hw = snd_vortex_playback_hw_wt;
 165                 substream->runtime->private_data = NULL;
 166         }
 167 #endif
 168         return 0;
 169 }
 170
 171 /* close callback */
 172 static int snd_vortex_pcm_close(snd_pcm_substream_t * substream)
 173 {
 174         //vortex_t *chip = snd_pcm_substream_chip(substream);
 175         stream_t *stream = (stream_t *) substream->runtime->private_data;
 176
 177         // the hardware-specific codes will be here
 178         if (stream != NULL) {
 179                 stream->substream = NULL;
 180                 stream->nr_ch = 0;
 181         }
 182         substream->runtime->private_data = NULL;
 183         return 0;
 184 }
 185
 186 /* hw_params callback */
 187 static int
 188 snd_vortex_pcm_hw_params(snd_pcm_substream_t * substream,
 189                          snd_pcm_hw_params_t * hw_params)
 190 {
 191         vortex_t *chip = snd_pcm_substream_chip(substream);
 192         stream_t *stream = (stream_t *) (substream->runtime->private_data);
 193         snd_pcm_sgbuf_t *sgbuf;
 194         int err;
 195
 196         // Alloc buffer memory.
 197         err =
 198             snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 199         if (err < 0) {
 200                 printk(KERN_ERR "Vortex: pcm page alloc failed!\n");
 201                 return err;
 202         }
 203         //sgbuf = (snd_pcm_sgbuf_t *) substream->runtime->dma_private;
 204         sgbuf = snd_pcm_substream_sgbuf(substream);
 205         /*
 206            printk(KERN_INFO "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params),
 207            params_period_bytes(hw_params), params_channels(hw_params));
 208          */
 209         spin_lock_irq(&chip->lock);
 210         // Make audio routes and config buffer DMA.
 211         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
 212                 int dma, type = VORTEX_PCM_TYPE(substream->pcm);
 213                 /* Dealloc any routes. */
 214                 if (stream != NULL)
 215                         vortex_adb_allocroute(chip, stream->dma,
 216                                               stream->nr_ch, stream->dir,
 217                                               stream->type);
 218                 /* Alloc routes. */
 219                 dma =
 220                     vortex_adb_allocroute(chip, -1,
 221                                           params_channels(hw_params),
 222                                           substream->stream, type);
 223                 if (dma < 0)
 224                         return dma;
 225                 stream = substream->runtime->private_data = &chip->dma_adb[dma];
 226                 stream->substream = substream;
 227                 /* Setup Buffers. */
 228                 vortex_adbdma_setbuffers(chip, dma, sgbuf,
 229                                          params_period_bytes(hw_params),
 230                                          params_periods(hw_params));
 231         }
 232 #ifndef CHIP_AU8810
 233         else {
 234                 /* if (stream != NULL)
 235                    vortex_wt_allocroute(chip, substream->number, 0); */
 236                 vortex_wt_allocroute(chip, substream->number,
 237                                      params_channels(hw_params));
 238                 stream = substream->runtime->private_data =
 239                     &chip->dma_wt[substream->number];
 240                 stream->dma = substream->number;
 241                 stream->substream = substream;
 242                 vortex_wtdma_setbuffers(chip, substream->number, sgbuf,
 243                                         params_period_bytes(hw_params),
 244                                         params_periods(hw_params));
 245         }
 246 #endif
 247         spin_unlock_irq(&chip->lock);
 248         return 0;
 249 }
 250
 251 /* hw_free callback */
 252 static int snd_vortex_pcm_hw_free(snd_pcm_substream_t * substream)
 253 {
 254         vortex_t *chip = snd_pcm_substream_chip(substream);
 255         stream_t *stream = (stream_t *) (substream->runtime->private_data);
 256
 257         spin_lock_irq(&chip->lock);
 258         // Delete audio routes.
 259         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
 260                 if (stream != NULL)
 261                         vortex_adb_allocroute(chip, stream->dma,
 262                                               stream->nr_ch, stream->dir,
 263                                               stream->type);
 264         }
 265 #ifndef CHIP_AU8810
 266         else {
 267                 if (stream != NULL)
 268                         vortex_wt_allocroute(chip, stream->dma, 0);
 269         }
 270 #endif
 271         substream->runtime->private_data = NULL;
 272         spin_unlock_irq(&chip->lock);
 273
 274         return snd_pcm_lib_free_pages(substream);
 275 }
 276
 277 /* prepare callback */
 278 static int snd_vortex_pcm_prepare(snd_pcm_substream_t * substream)
 279 {
 280         vortex_t *chip = snd_pcm_substream_chip(substream);
 281         snd_pcm_runtime_t *runtime = substream->runtime;
 282         stream_t *stream = (stream_t *) substream->runtime->private_data;
 283         int dma = stream->dma, fmt, dir;
 284
 285         // set up the hardware with the current configuration.
 286         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 287                 dir = 1;
 288         else
 289                 dir = 0;
 290         fmt = vortex_alsafmt_aspfmt(runtime->format);
 291         spin_lock_irq(&chip->lock);
 292         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
 293                 vortex_adbdma_setmode(chip, dma, 1, dir, fmt, 0 /*? */ ,
 294                                       0);
 295                 vortex_adbdma_setstartbuffer(chip, dma, 0);
 296                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_SPDIF)
 297                         vortex_adb_setsrc(chip, dma, runtime->rate, dir);
 298         }
 299 #ifndef CHIP_AU8810
 300         else {
 301                 vortex_wtdma_setmode(chip, dma, 1, fmt, 0, 0);
 302                 // FIXME: Set rate (i guess using vortex_wt_writereg() somehow).
 303                 vortex_wtdma_setstartbuffer(chip, dma, 0);
 304         }
 305 #endif
 306         spin_unlock_irq(&chip->lock);
 307         return 0;
 308 }
 309
 310 /* trigger callback */
 311 static int snd_vortex_pcm_trigger(snd_pcm_substream_t * substream, int cmd)
 312 {
 313         vortex_t *chip = snd_pcm_substream_chip(substream);
 314         stream_t *stream = (stream_t *) substream->runtime->private_data;
 315         int dma = stream->dma;
 316
 317         spin_lock(&chip->lock);
 318         switch (cmd) {
 319         case SNDRV_PCM_TRIGGER_START:
 320                 // do something to start the PCM engine
 321                 //printk(KERN_INFO "vortex: start %d\n", dma);
 322                 stream->fifo_enabled = 1;
 323                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
 324                         vortex_adbdma_resetup(chip, dma);
 325                         vortex_adbdma_startfifo(chip, dma);
 326                 }
 327 #ifndef CHIP_AU8810
 328                 else {
 329                         printk(KERN_INFO "vortex: wt start %d\n", dma);
 330                         vortex_wtdma_startfifo(chip, dma);
 331                 }
 332 #endif
 333                 break;
 334         case SNDRV_PCM_TRIGGER_STOP:
 335                 // do something to stop the PCM engine
 336                 //printk(KERN_INFO "vortex: stop %d\n", dma);
 337                 stream->fifo_enabled = 0;
 338                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
 339                         vortex_adbdma_pausefifo(chip, dma);
 340                 //vortex_adbdma_stopfifo(chip, dma);
 341 #ifndef CHIP_AU8810
 342                 else {
 343                         printk(KERN_INFO "vortex: wt stop %d\n", dma);
 344                         vortex_wtdma_stopfifo(chip, dma);
 345                 }
 346 #endif
 347                 break;
 348         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 349                 //printk(KERN_INFO "vortex: pause %d\n", dma);
 350                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
 351                         vortex_adbdma_pausefifo(chip, dma);
 352 #ifndef CHIP_AU8810
 353                 else
 354                         vortex_wtdma_pausefifo(chip, dma);
 355 #endif
 356                 break;
 357         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 358                 //printk(KERN_INFO "vortex: resume %d\n", dma);
 359                 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
 360                         vortex_adbdma_resumefifo(chip, dma);
 361 #ifndef CHIP_AU8810
 362                 else
 363                         vortex_wtdma_resumefifo(chip, dma);
 364 #endif
 365                 break;
 366         default:
 367                 spin_unlock(&chip->lock);
 368                 return -EINVAL;
 369         }
 370         spin_unlock(&chip->lock);
 371         return 0;
 372 }
 373
 374 /* pointer callback */
 375 static snd_pcm_uframes_t snd_vortex_pcm_pointer(snd_pcm_substream_t * substream)
 376 {
 377         vortex_t *chip = snd_pcm_substream_chip(substream);
 378         stream_t *stream = (stream_t *) substream->runtime->private_data;
 379         int dma = stream->dma;
 380         snd_pcm_uframes_t current_ptr = 0;
 381
 382         spin_lock(&chip->lock);
 383         if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
 384                 current_ptr = vortex_adbdma_getlinearpos(chip, dma);
 385 #ifndef CHIP_AU8810
 386         else
 387                 current_ptr = vortex_wtdma_getlinearpos(chip, dma);
 388 #endif
 389         //printk(KERN_INFO "vortex: pointer = 0x%x\n", current_ptr);
 390         spin_unlock(&chip->lock);
 391         return (bytes_to_frames(substream->runtime, current_ptr));
 392 }
 393
 394 /* Page callback. */
 395 /*
 396 static struct page *snd_pcm_sgbuf_ops_page(snd_pcm_substream_t *substream, unsigned long offset) {
 397
 398
 399 }
 400 */
 401 /* operators */
 402 static snd_pcm_ops_t snd_vortex_playback_ops = {
 403         .open = snd_vortex_pcm_open,
 404         .close = snd_vortex_pcm_close,
 405         .ioctl = snd_pcm_lib_ioctl,
 406         .hw_params = snd_vortex_pcm_hw_params,
 407         .hw_free = snd_vortex_pcm_hw_free,
 408         .prepare = snd_vortex_pcm_prepare,
 409         .trigger = snd_vortex_pcm_trigger,
 410         .pointer = snd_vortex_pcm_pointer,
 411         .page = snd_pcm_sgbuf_ops_page,
 412 };
 413
 414 /*
 415 *  definitions of capture are omitted here...
 416 */
 417
 418 static char *vortex_pcm_prettyname[VORTEX_PCM_LAST] = {
 419         "AU88x0 ADB",
 420         "AU88x0 SPDIF",
 421         "AU88x0 A3D",
 422         "AU88x0 WT",
 423         "AU88x0 I2S",
 424 };
 425 static char *vortex_pcm_name[VORTEX_PCM_LAST] = {
 426         "adb",
 427         "spdif",
 428         "a3d",
 429         "wt",
 430         "i2s",
 431 };
 432
 433 /* SPDIF kcontrol */
 434
 435 static int snd_vortex_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 436 {
 437         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 438         uinfo->count = 1;
 439         return 0;
 440 }
 441
 442 static int snd_vortex_spdif_mask_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 443 {
 444         ucontrol->value.iec958.status[0] = 0xff;
 445         ucontrol->value.iec958.status[1] = 0xff;
 446         ucontrol->value.iec958.status[2] = 0xff;
 447         ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
 448         return 0;
 449 }
 450
 451 static int snd_vortex_spdif_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 452 {
 453         vortex_t *vortex = snd_kcontrol_chip(kcontrol);
 454         ucontrol->value.iec958.status[0] = 0x00;
 455         ucontrol->value.iec958.status[1] = IEC958_AES1_CON_ORIGINAL|IEC958_AES1_CON_DIGDIGCONV_ID;
 456         ucontrol->value.iec958.status[2] = 0x00;
 457         switch (vortex->spdif_sr) {
 458         case 32000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_32000; break;
 459         case 44100: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_44100; break;
 460         case 48000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_48000; break;
 461         }
 462         return 0;
 463 }
 464
 465 static int snd_vortex_spdif_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 466 {
 467         vortex_t *vortex = snd_kcontrol_chip(kcontrol);
 468         int spdif_sr = 48000;
 469         switch (ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) {
 470         case IEC958_AES3_CON_FS_32000: spdif_sr = 32000; break;
 471         case IEC958_AES3_CON_FS_44100: spdif_sr = 44100; break;
 472         case IEC958_AES3_CON_FS_48000: spdif_sr = 48000; break;
 473         }
 474         if (spdif_sr == vortex->spdif_sr)
 475                 return 0;
 476         vortex->spdif_sr = spdif_sr;
 477         vortex_spdif_init(vortex, vortex->spdif_sr, 1);
 478         return 1;
 479 }
 480
 481 /* spdif controls */
 482 static snd_kcontrol_new_t snd_vortex_mixer_spdif[] __devinitdata = {
 483         {
 484                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 485                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 486                 .info =         snd_vortex_spdif_info,
 487                 .get =          snd_vortex_spdif_get,
 488                 .put =          snd_vortex_spdif_put,
 489         },
 490         {
 491                 .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 492                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 493                 .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
 494                 .info =         snd_vortex_spdif_info,
 495                 .get =          snd_vortex_spdif_mask_get
 496         },
 497 };
 498
 499 /* create a pcm device */
 500 static int __devinit snd_vortex_new_pcm(vortex_t * chip, int idx, int nr)
 501 {
 502         snd_pcm_t *pcm;
 503         snd_kcontrol_t *kctl;
 504         int i;
 505         int err, nr_capt;
 506
 507         if ((chip == 0) || (idx < 0) || (idx > VORTEX_PCM_LAST))
 508                 return -ENODEV;
 509
 510         /* idx indicates which kind of PCM device. ADB, SPDIF, I2S and A3D share the
 511          * same dma engine. WT uses it own separate dma engine whcih cant capture. */
 512         if (idx == VORTEX_PCM_ADB)
 513                 nr_capt = nr;
 514         else
 515                 nr_capt = 0;
 516         if ((err =
 517              snd_pcm_new(chip->card, vortex_pcm_prettyname[idx], idx, nr,
 518                          nr_capt, &pcm)) < 0)
 519                 return err;
 520         strcpy(pcm->name, vortex_pcm_name[idx]);
 521         chip->pcm[idx] = pcm;
 522         // This is an evil hack, but it saves a lot of duplicated code.
 523         VORTEX_PCM_TYPE(pcm) = idx;
 524         pcm->private_data = chip;
 525         /* set operators */
 526         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 527                         &snd_vortex_playback_ops);
 528         if (idx == VORTEX_PCM_ADB)
 529                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
 530                                 &snd_vortex_playback_ops);
 531
 532         /* pre-allocation of Scatter-Gather buffers */
 533
 534         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
 535                                               snd_dma_pci_data(chip->pci_dev),
 536                                               0x10000, 0x10000);
 537
 538         if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_SPDIF) {
 539                 for (i = 0; i < ARRAY_SIZE(snd_vortex_mixer_spdif); i++) {
 540                         kctl = snd_ctl_new1(&snd_vortex_mixer_spdif[i], chip);
 541                         if (!kctl)
 542                                 return -ENOMEM;
 543                         if ((err = snd_ctl_add(chip->card, kctl)) < 0)
 544                                 return err;
 545                 }
 546         }
 547         return 0;
 548 }