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