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 err = snd_pcm_hw_constraint_integer(runtime, 134 SNDRV_PCM_HW_PARAM_PERIODS); 135 if (err < 0) 136 return err; 137 /* Avoid PAGE_SIZE boundary to fall inside of a period. */ 138 err = snd_pcm_hw_constraint_pow2(runtime, 0, 139 SNDRV_PCM_HW_PARAM_PERIOD_BYTES); 140 if (err < 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 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 */ 269static 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 */ 303static 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 */ 336static 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 */ 399static 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 */ 422static 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 436static 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}; 443static 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 453static 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 460static 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 469static 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 483static 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 */ 500static 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 519static 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 530static 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 543static 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 580static const DECLARE_TLV_DB_MINMAX(vortex_pcm_vol_db_scale, -9600, 2400); 581 582static 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 */ 595static 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 err = snd_ctl_add(chip->card, kctl); 662 if (err < 0) 663 return err; 664 } 665 } 666 if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_ADB) { 667 for (i = 0; i < NR_PCM; i++) { 668 chip->pcm_vol[i].active = 0; 669 chip->pcm_vol[i].dma = -1; 670 kctl = snd_ctl_new1(&snd_vortex_pcm_vol, chip); 671 if (!kctl) 672 return -ENOMEM; 673 chip->pcm_vol[i].kctl = kctl; 674 kctl->id.device = 0; 675 kctl->id.subdevice = i; 676 err = snd_ctl_add(chip->card, kctl); 677 if (err < 0) 678 return err; 679 } 680 } 681 return 0; 682} 683