LXR linux/sound/pci/au88x0/au88x0

   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 */
  21static 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
  42static 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
  62static 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
  85static 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
 103static const unsigned int au8830_channels[3] = {
 104        1, 2, 4,
 105};
 106
 107static 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
 114static 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 */
 126static 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 */
 191static 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 */
 206static int
 207snd_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        int err;
 213
 214        // Alloc buffer memory.
 215        err =
 216            snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 217        if (err < 0) {
 218                dev_err(chip->card->dev, "Vortex: pcm page alloc failed!\n");
 219                return err;
 220        }
 221        /*
 222           pr_info( "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params),
 223           params_period_bytes(hw_params), params_channels(hw_params));
 224         */
 225        spin_lock_irq(&chip->lock);
 226        // Make audio routes and config buffer DMA.
 227        if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
 228                int dma, type = VORTEX_PCM_TYPE(substream->pcm);
 229                /* Dealloc any routes. */
 230                if (stream != NULL)
 231                        vortex_adb_allocroute(chip, stream->dma,
 232                                              stream->nr_ch, stream->dir,
 233                                              stream->type,
 234                                              substream->number);
 235                /* Alloc routes. */
 236                dma =
 237                    vortex_adb_allocroute(chip, -1,
 238                                          params_channels(hw_params),
 239                                          substream->stream, type,
 240                                          substream->number);
 241                if (dma < 0) {
 242                        spin_unlock_irq(&chip->lock);
 243                        return dma;
 244                }
 245                stream = substream->runtime->private_data = &chip->dma_adb[dma];
 246                stream->substream = substream;
 247                /* Setup Buffers. */
 248                vortex_adbdma_setbuffers(chip, dma,
 249                                         params_period_bytes(hw_params),
 250                                         params_periods(hw_params));
 251                if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB) {
 252                        chip->pcm_vol[substream->number].active = 1;
 253                        vortex_notify_pcm_vol_change(chip->card,
 254                                chip->pcm_vol[substream->number].kctl, 1);
 255                }
 256        }
 257#ifndef CHIP_AU8810
 258        else {
 259                /* if (stream != NULL)
 260                   vortex_wt_allocroute(chip, substream->number, 0); */
 261                vortex_wt_allocroute(chip, substream->number,
 262                                     params_channels(hw_params));
 263                stream = substream->runtime->private_data =
 264                    &chip->dma_wt[substream->number];
 265                stream->dma = substream->number;
 266                stream->substream = substream;
 267                vortex_wtdma_setbuffers(chip, substream->number,
 268                                        params_period_bytes(hw_params),
 269                                        params_periods(hw_params));
 270        }
 271#endif
 272        spin_unlock_irq(&chip->lock);
 273        return 0;
 274}
 275
 276/* hw_free callback */
 277static int snd_vortex_pcm_hw_free(struct snd_pcm_substream *substream)
 278{
 279        vortex_t *chip = snd_pcm_substream_chip(substream);
 280        stream_t *stream = (stream_t *) (substream->runtime->private_data);
 281
 282        spin_lock_irq(&chip->lock);
 283        // Delete audio routes.
 284        if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
 285                if (stream != NULL) {
 286                        if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB) {
 287                                chip->pcm_vol[substream->number].active = 0;
 288                                vortex_notify_pcm_vol_change(chip->card,
 289                                        chip->pcm_vol[substream->number].kctl,
 290                                        0);
 291                        }
 292                        vortex_adb_allocroute(chip, stream->dma,
 293                                              stream->nr_ch, stream->dir,
 294                                              stream->type,
 295                                              substream->number);
 296                }
 297        }
 298#ifndef CHIP_AU8810
 299        else {
 300                if (stream != NULL)
 301                        vortex_wt_allocroute(chip, stream->dma, 0);
 302        }
 303#endif
 304        substream->runtime->private_data = NULL;
 305        spin_unlock_irq(&chip->lock);
 306
 307        return snd_pcm_lib_free_pages(substream);
 308}
 309
 310/* prepare callback */
 311static int snd_vortex_pcm_prepare(struct snd_pcm_substream *substream)
 312{
 313        vortex_t *chip = snd_pcm_substream_chip(substream);
 314        struct snd_pcm_runtime *runtime = substream->runtime;
 315        stream_t *stream = (stream_t *) substream->runtime->private_data;
 316        int dma = stream->dma, fmt, dir;
 317
 318        // set up the hardware with the current configuration.
 319        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 320                dir = 1;
 321        else
 322                dir = 0;
 323        fmt = vortex_alsafmt_aspfmt(runtime->format, chip);
 324        spin_lock_irq(&chip->lock);
 325        if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
 326                vortex_adbdma_setmode(chip, dma, 1, dir, fmt,
 327                                runtime->channels == 1 ? 0 : 1, 0);
 328                vortex_adbdma_setstartbuffer(chip, dma, 0);
 329                if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_SPDIF)
 330                        vortex_adb_setsrc(chip, dma, runtime->rate, dir);
 331        }
 332#ifndef CHIP_AU8810
 333        else {
 334                vortex_wtdma_setmode(chip, dma, 1, fmt, 0, 0);
 335                // FIXME: Set rate (i guess using vortex_wt_writereg() somehow).
 336                vortex_wtdma_setstartbuffer(chip, dma, 0);
 337        }
 338#endif
 339        spin_unlock_irq(&chip->lock);
 340        return 0;
 341}
 342
 343/* trigger callback */
 344static int snd_vortex_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 345{
 346        vortex_t *chip = snd_pcm_substream_chip(substream);
 347        stream_t *stream = (stream_t *) substream->runtime->private_data;
 348        int dma = stream->dma;
 349
 350        spin_lock(&chip->lock);
 351        switch (cmd) {
 352        case SNDRV_PCM_TRIGGER_START:
 353                // do something to start the PCM engine
 354                //printk(KERN_INFO "vortex: start %d\n", dma);
 355                stream->fifo_enabled = 1;
 356                if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) {
 357                        vortex_adbdma_resetup(chip, dma);
 358                        vortex_adbdma_startfifo(chip, dma);
 359                }
 360#ifndef CHIP_AU8810
 361                else {
 362                        dev_info(chip->card->dev, "wt start %d\n", dma);
 363                        vortex_wtdma_startfifo(chip, dma);
 364                }
 365#endif
 366                break;
 367        case SNDRV_PCM_TRIGGER_STOP:
 368                // do something to stop the PCM engine
 369                //printk(KERN_INFO "vortex: stop %d\n", dma);
 370                stream->fifo_enabled = 0;
 371                if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
 372                        vortex_adbdma_stopfifo(chip, dma);
 373#ifndef CHIP_AU8810
 374                else {
 375                        dev_info(chip->card->dev, "wt stop %d\n", dma);
 376                        vortex_wtdma_stopfifo(chip, dma);
 377                }
 378#endif
 379                break;
 380        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 381                //printk(KERN_INFO "vortex: pause %d\n", dma);
 382                if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
 383                        vortex_adbdma_pausefifo(chip, dma);
 384#ifndef CHIP_AU8810
 385                else
 386                        vortex_wtdma_pausefifo(chip, dma);
 387#endif
 388                break;
 389        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 390                //printk(KERN_INFO "vortex: resume %d\n", dma);
 391                if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
 392                        vortex_adbdma_resumefifo(chip, dma);
 393#ifndef CHIP_AU8810
 394                else
 395                        vortex_wtdma_resumefifo(chip, dma);
 396#endif
 397                break;
 398        default:
 399                spin_unlock(&chip->lock);
 400                return -EINVAL;
 401        }
 402        spin_unlock(&chip->lock);
 403        return 0;
 404}
 405
 406/* pointer callback */
 407static snd_pcm_uframes_t snd_vortex_pcm_pointer(struct snd_pcm_substream *substream)
 408{
 409        vortex_t *chip = snd_pcm_substream_chip(substream);
 410        stream_t *stream = (stream_t *) substream->runtime->private_data;
 411        int dma = stream->dma;
 412        snd_pcm_uframes_t current_ptr = 0;
 413
 414        spin_lock(&chip->lock);
 415        if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT)
 416                current_ptr = vortex_adbdma_getlinearpos(chip, dma);
 417#ifndef CHIP_AU8810
 418        else
 419                current_ptr = vortex_wtdma_getlinearpos(chip, dma);
 420#endif
 421        //printk(KERN_INFO "vortex: pointer = 0x%x\n", current_ptr);
 422        spin_unlock(&chip->lock);
 423        current_ptr = bytes_to_frames(substream->runtime, current_ptr);
 424        if (current_ptr >= substream->runtime->buffer_size)
 425                current_ptr = 0;
 426        return current_ptr;
 427}
 428
 429/* operators */
 430static const struct snd_pcm_ops snd_vortex_playback_ops = {
 431        .open = snd_vortex_pcm_open,
 432        .close = snd_vortex_pcm_close,
 433        .ioctl = snd_pcm_lib_ioctl,
 434        .hw_params = snd_vortex_pcm_hw_params,
 435        .hw_free = snd_vortex_pcm_hw_free,
 436        .prepare = snd_vortex_pcm_prepare,
 437        .trigger = snd_vortex_pcm_trigger,
 438        .pointer = snd_vortex_pcm_pointer,
 439        .page = snd_pcm_sgbuf_ops_page,
 440};
 441
 442/*
 443*  definitions of capture are omitted here...
 444*/
 445
 446static char *vortex_pcm_prettyname[VORTEX_PCM_LAST] = {
 447        CARD_NAME " ADB",
 448        CARD_NAME " SPDIF",
 449        CARD_NAME " A3D",
 450        CARD_NAME " WT",
 451        CARD_NAME " I2S",
 452};
 453static char *vortex_pcm_name[VORTEX_PCM_LAST] = {
 454        "adb",
 455        "spdif",
 456        "a3d",
 457        "wt",
 458        "i2s",
 459};
 460
 461/* SPDIF kcontrol */
 462
 463static int snd_vortex_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 464{
 465        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
 466        uinfo->count = 1;
 467        return 0;
 468}
 469
 470static int snd_vortex_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 471{
 472        ucontrol->value.iec958.status[0] = 0xff;
 473        ucontrol->value.iec958.status[1] = 0xff;
 474        ucontrol->value.iec958.status[2] = 0xff;
 475        ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS;
 476        return 0;
 477}
 478
 479static int snd_vortex_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 480{
 481        vortex_t *vortex = snd_kcontrol_chip(kcontrol);
 482        ucontrol->value.iec958.status[0] = 0x00;
 483        ucontrol->value.iec958.status[1] = IEC958_AES1_CON_ORIGINAL|IEC958_AES1_CON_DIGDIGCONV_ID;
 484        ucontrol->value.iec958.status[2] = 0x00;
 485        switch (vortex->spdif_sr) {
 486        case 32000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_32000; break;
 487        case 44100: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_44100; break;
 488        case 48000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_48000; break;
 489        }
 490        return 0;
 491}
 492
 493static int snd_vortex_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 494{
 495        vortex_t *vortex = snd_kcontrol_chip(kcontrol);
 496        int spdif_sr = 48000;
 497        switch (ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) {
 498        case IEC958_AES3_CON_FS_32000: spdif_sr = 32000; break;
 499        case IEC958_AES3_CON_FS_44100: spdif_sr = 44100; break;
 500        case IEC958_AES3_CON_FS_48000: spdif_sr = 48000; break;
 501        }
 502        if (spdif_sr == vortex->spdif_sr)
 503                return 0;
 504        vortex->spdif_sr = spdif_sr;
 505        vortex_spdif_init(vortex, vortex->spdif_sr, 1);
 506        return 1;
 507}
 508
 509/* spdif controls */
 510static struct snd_kcontrol_new snd_vortex_mixer_spdif[] = {
 511        {
 512                .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 513                .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
 514                .info =         snd_vortex_spdif_info,
 515                .get =          snd_vortex_spdif_get,
 516                .put =          snd_vortex_spdif_put,
 517        },
 518        {
 519                .access =       SNDRV_CTL_ELEM_ACCESS_READ,
 520                .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 521                .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
 522                .info =         snd_vortex_spdif_info,
 523                .get =          snd_vortex_spdif_mask_get
 524        },
 525};
 526
 527/* subdevice PCM Volume control */
 528
 529static int snd_vortex_pcm_vol_info(struct snd_kcontrol *kcontrol,
 530                                struct snd_ctl_elem_info *uinfo)
 531{
 532        vortex_t *vortex = snd_kcontrol_chip(kcontrol);
 533        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 534        uinfo->count = (VORTEX_IS_QUAD(vortex) ? 4 : 2);
 535        uinfo->value.integer.min = -128;
 536        uinfo->value.integer.max = 32;
 537        return 0;
 538}
 539
 540static int snd_vortex_pcm_vol_get(struct snd_kcontrol *kcontrol,
 541                                struct snd_ctl_elem_value *ucontrol)
 542{
 543        int i;
 544        vortex_t *vortex = snd_kcontrol_chip(kcontrol);
 545        int subdev = kcontrol->id.subdevice;
 546        struct pcm_vol *p = &vortex->pcm_vol[subdev];
 547        int max_chn = (VORTEX_IS_QUAD(vortex) ? 4 : 2);
 548        for (i = 0; i < max_chn; i++)
 549                ucontrol->value.integer.value[i] = p->vol[i];
 550        return 0;
 551}
 552
 553static int snd_vortex_pcm_vol_put(struct snd_kcontrol *kcontrol,
 554                                struct snd_ctl_elem_value *ucontrol)
 555{
 556        int i;
 557        int changed = 0;
 558        int mixin;
 559        unsigned char vol;
 560        vortex_t *vortex = snd_kcontrol_chip(kcontrol);
 561        int subdev = kcontrol->id.subdevice;
 562        struct pcm_vol *p = &vortex->pcm_vol[subdev];
 563        int max_chn = (VORTEX_IS_QUAD(vortex) ? 4 : 2);
 564        for (i = 0; i < max_chn; i++) {
 565                if (p->vol[i] != ucontrol->value.integer.value[i]) {
 566                        p->vol[i] = ucontrol->value.integer.value[i];
 567                        if (p->active) {
 568                                switch (vortex->dma_adb[p->dma].nr_ch) {
 569                                case 1:
 570                                        mixin = p->mixin[0];
 571                                        break;
 572                                case 2:
 573                                default:
 574                                        mixin = p->mixin[(i < 2) ? i : (i - 2)];
 575                                        break;
 576                                case 4:
 577                                        mixin = p->mixin[i];
 578                                        break;
 579                                }
 580                                vol = p->vol[i];
 581                                vortex_mix_setinputvolumebyte(vortex,
 582                                        vortex->mixplayb[i], mixin, vol);
 583                        }
 584                        changed = 1;
 585                }
 586        }
 587        return changed;
 588}
 589
 590static const DECLARE_TLV_DB_MINMAX(vortex_pcm_vol_db_scale, -9600, 2400);
 591
 592static const struct snd_kcontrol_new snd_vortex_pcm_vol = {
 593        .iface = SNDRV_CTL_ELEM_IFACE_PCM,
 594        .name = "PCM Playback Volume",
 595        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 596                SNDRV_CTL_ELEM_ACCESS_TLV_READ |
 597                SNDRV_CTL_ELEM_ACCESS_INACTIVE,
 598        .info = snd_vortex_pcm_vol_info,
 599        .get = snd_vortex_pcm_vol_get,
 600        .put = snd_vortex_pcm_vol_put,
 601        .tlv = { .p = vortex_pcm_vol_db_scale },
 602};
 603
 604/* create a pcm device */
 605static int snd_vortex_new_pcm(vortex_t *chip, int idx, int nr)
 606{
 607        struct snd_pcm *pcm;
 608        struct snd_kcontrol *kctl;
 609        int i;
 610        int err, nr_capt;
 611
 612        if (!chip || idx < 0 || idx >= VORTEX_PCM_LAST)
 613                return -ENODEV;
 614
 615        /* idx indicates which kind of PCM device. ADB, SPDIF, I2S and A3D share the 
 616         * same dma engine. WT uses it own separate dma engine which can't capture. */
 617        if (idx == VORTEX_PCM_ADB)
 618                nr_capt = nr;
 619        else
 620                nr_capt = 0;
 621        err = snd_pcm_new(chip->card, vortex_pcm_prettyname[idx], idx, nr,
 622                          nr_capt, &pcm);
 623        if (err < 0)
 624                return err;
 625        snprintf(pcm->name, sizeof(pcm->name),
 626                "%s %s", CARD_NAME_SHORT, vortex_pcm_name[idx]);
 627        chip->pcm[idx] = pcm;
 628        // This is an evil hack, but it saves a lot of duplicated code.
 629        VORTEX_PCM_TYPE(pcm) = idx;
 630        pcm->private_data = chip;
 631        /* set operators */
 632        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 633                        &snd_vortex_playback_ops);
 634        if (idx == VORTEX_PCM_ADB)
 635                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
 636                                &snd_vortex_playback_ops);
 637        
 638        /* pre-allocation of Scatter-Gather buffers */
 639        
 640        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
 641                                              snd_dma_pci_data(chip->pci_dev),
 642                                              0x10000, 0x10000);
 643
 644        switch (VORTEX_PCM_TYPE(pcm)) {
 645        case VORTEX_PCM_ADB:
 646                err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 647                                             snd_pcm_std_chmaps,
 648                                             VORTEX_IS_QUAD(chip) ? 4 : 2,
 649                                             0, NULL);
 650                if (err < 0)
 651                        return err;
 652                err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_CAPTURE,
 653                                             snd_pcm_std_chmaps, 2, 0, NULL);
 654                if (err < 0)
 655                        return err;
 656                break;
 657#ifdef CHIP_AU8830
 658        case VORTEX_PCM_A3D:
 659                err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
 660                                             snd_pcm_std_chmaps, 1, 0, NULL);
 661                if (err < 0)
 662                        return err;
 663                break;
 664#endif
 665        }
 666
 667        if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_SPDIF) {
 668                for (i = 0; i < ARRAY_SIZE(snd_vortex_mixer_spdif); i++) {
 669                        kctl = snd_ctl_new1(&snd_vortex_mixer_spdif[i], chip);
 670                        if (!kctl)
 671                                return -ENOMEM;
 672                        if ((err = snd_ctl_add(chip->card, kctl)) < 0)
 673                                return err;
 674                }
 675        }
 676        if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_ADB) {
 677                for (i = 0; i < NR_PCM; i++) {
 678                        chip->pcm_vol[i].active = 0;
 679                        chip->pcm_vol[i].dma = -1;
 680                        kctl = snd_ctl_new1(&snd_vortex_pcm_vol, chip);
 681                        if (!kctl)
 682                                return -ENOMEM;
 683                        chip->pcm_vol[i].kctl = kctl;
 684                        kctl->id.device = 0;
 685                        kctl->id.subdevice = i;
 686                        err = snd_ctl_add(chip->card, kctl);
 687                        if (err < 0)
 688                                return err;
 689                }
 690        }
 691        return 0;
 692}
 693