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 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 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 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 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 unsigned int au8830_channels[3] = { 116 1, 2, 4, 117 }; 118 119 static 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 /* open callback */ 126 static 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 */ 191 static 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 */ 206 static int 207 snd_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 printk(KERN_ERR "Vortex: pcm page alloc failed!\n"); 219 return err; 220 } 221 /* 222 printk(KERN_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 /* Alloc routes. */ 235 dma = 236 vortex_adb_allocroute(chip, -1, 237 params_channels(hw_params), 238 substream->stream, type); 239 if (dma < 0) { 240 spin_unlock_irq(&chip->lock); 241 return dma; 242 } 243 stream = substream->runtime->private_data = &chip->dma_adb[dma]; 244 stream->substream = substream; 245 /* Setup Buffers. */ 246 vortex_adbdma_setbuffers(chip, dma, 247 params_period_bytes(hw_params), 248 params_periods(hw_params)); 249 } 250 #ifndef CHIP_AU8810 251 else { 252 /* if (stream != NULL) 253 vortex_wt_allocroute(chip, substream->number, 0); */ 254 vortex_wt_allocroute(chip, substream->number, 255 params_channels(hw_params)); 256 stream = substream->runtime->private_data = 257 &chip->dma_wt[substream->number]; 258 stream->dma = substream->number; 259 stream->substream = substream; 260 vortex_wtdma_setbuffers(chip, substream->number, 261 params_period_bytes(hw_params), 262 params_periods(hw_params)); 263 } 264 #endif 265 spin_unlock_irq(&chip->lock); 266 return 0; 267 } 268 269 /* hw_free callback */ 270 static int snd_vortex_pcm_hw_free(struct snd_pcm_substream *substream) 271 { 272 vortex_t *chip = snd_pcm_substream_chip(substream); 273 stream_t *stream = (stream_t *) (substream->runtime->private_data); 274 275 spin_lock_irq(&chip->lock); 276 // Delete audio routes. 277 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) { 278 if (stream != NULL) 279 vortex_adb_allocroute(chip, stream->dma, 280 stream->nr_ch, stream->dir, 281 stream->type); 282 } 283 #ifndef CHIP_AU8810 284 else { 285 if (stream != NULL) 286 vortex_wt_allocroute(chip, stream->dma, 0); 287 } 288 #endif 289 substream->runtime->private_data = NULL; 290 spin_unlock_irq(&chip->lock); 291 292 return snd_pcm_lib_free_pages(substream); 293 } 294 295 /* prepare callback */ 296 static int snd_vortex_pcm_prepare(struct snd_pcm_substream *substream) 297 { 298 vortex_t *chip = snd_pcm_substream_chip(substream); 299 struct snd_pcm_runtime *runtime = substream->runtime; 300 stream_t *stream = (stream_t *) substream->runtime->private_data; 301 int dma = stream->dma, fmt, dir; 302 303 // set up the hardware with the current configuration. 304 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 305 dir = 1; 306 else 307 dir = 0; 308 fmt = vortex_alsafmt_aspfmt(runtime->format); 309 spin_lock_irq(&chip->lock); 310 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) { 311 vortex_adbdma_setmode(chip, dma, 1, dir, fmt, 312 runtime->channels == 1 ? 0 : 1, 0); 313 vortex_adbdma_setstartbuffer(chip, dma, 0); 314 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_SPDIF) 315 vortex_adb_setsrc(chip, dma, runtime->rate, dir); 316 } 317 #ifndef CHIP_AU8810 318 else { 319 vortex_wtdma_setmode(chip, dma, 1, fmt, 0, 0); 320 // FIXME: Set rate (i guess using vortex_wt_writereg() somehow). 321 vortex_wtdma_setstartbuffer(chip, dma, 0); 322 } 323 #endif 324 spin_unlock_irq(&chip->lock); 325 return 0; 326 } 327 328 /* trigger callback */ 329 static int snd_vortex_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 330 { 331 vortex_t *chip = snd_pcm_substream_chip(substream); 332 stream_t *stream = (stream_t *) substream->runtime->private_data; 333 int dma = stream->dma; 334 335 spin_lock(&chip->lock); 336 switch (cmd) { 337 case SNDRV_PCM_TRIGGER_START: 338 // do something to start the PCM engine 339 //printk(KERN_INFO "vortex: start %d\n", dma); 340 stream->fifo_enabled = 1; 341 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) { 342 vortex_adbdma_resetup(chip, dma); 343 vortex_adbdma_startfifo(chip, dma); 344 } 345 #ifndef CHIP_AU8810 346 else { 347 printk(KERN_INFO "vortex: wt start %d\n", dma); 348 vortex_wtdma_startfifo(chip, dma); 349 } 350 #endif 351 break; 352 case SNDRV_PCM_TRIGGER_STOP: 353 // do something to stop the PCM engine 354 //printk(KERN_INFO "vortex: stop %d\n", dma); 355 stream->fifo_enabled = 0; 356 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) 357 vortex_adbdma_stopfifo(chip, dma); 358 #ifndef CHIP_AU8810 359 else { 360 printk(KERN_INFO "vortex: wt stop %d\n", dma); 361 vortex_wtdma_stopfifo(chip, dma); 362 } 363 #endif 364 break; 365 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 366 //printk(KERN_INFO "vortex: pause %d\n", dma); 367 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) 368 vortex_adbdma_pausefifo(chip, dma); 369 #ifndef CHIP_AU8810 370 else 371 vortex_wtdma_pausefifo(chip, dma); 372 #endif 373 break; 374 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 375 //printk(KERN_INFO "vortex: resume %d\n", dma); 376 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) 377 vortex_adbdma_resumefifo(chip, dma); 378 #ifndef CHIP_AU8810 379 else 380 vortex_wtdma_resumefifo(chip, dma); 381 #endif 382 break; 383 default: 384 spin_unlock(&chip->lock); 385 return -EINVAL; 386 } 387 spin_unlock(&chip->lock); 388 return 0; 389 } 390 391 /* pointer callback */ 392 static snd_pcm_uframes_t snd_vortex_pcm_pointer(struct snd_pcm_substream *substream) 393 { 394 vortex_t *chip = snd_pcm_substream_chip(substream); 395 stream_t *stream = (stream_t *) substream->runtime->private_data; 396 int dma = stream->dma; 397 snd_pcm_uframes_t current_ptr = 0; 398 399 spin_lock(&chip->lock); 400 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) 401 current_ptr = vortex_adbdma_getlinearpos(chip, dma); 402 #ifndef CHIP_AU8810 403 else 404 current_ptr = vortex_wtdma_getlinearpos(chip, dma); 405 #endif 406 //printk(KERN_INFO "vortex: pointer = 0x%x\n", current_ptr); 407 spin_unlock(&chip->lock); 408 return (bytes_to_frames(substream->runtime, current_ptr)); 409 } 410 411 /* operators */ 412 static struct snd_pcm_ops snd_vortex_playback_ops = { 413 .open = snd_vortex_pcm_open, 414 .close = snd_vortex_pcm_close, 415 .ioctl = snd_pcm_lib_ioctl, 416 .hw_params = snd_vortex_pcm_hw_params, 417 .hw_free = snd_vortex_pcm_hw_free, 418 .prepare = snd_vortex_pcm_prepare, 419 .trigger = snd_vortex_pcm_trigger, 420 .pointer = snd_vortex_pcm_pointer, 421 .page = snd_pcm_sgbuf_ops_page, 422 }; 423 424 /* 425 * definitions of capture are omitted here... 426 */ 427 428 static char *vortex_pcm_prettyname[VORTEX_PCM_LAST] = { 429 CARD_NAME " ADB", 430 CARD_NAME " SPDIF", 431 CARD_NAME " A3D", 432 CARD_NAME " WT", 433 CARD_NAME " I2S", 434 }; 435 static char *vortex_pcm_name[VORTEX_PCM_LAST] = { 436 "adb", 437 "spdif", 438 "a3d", 439 "wt", 440 "i2s", 441 }; 442 443 /* SPDIF kcontrol */ 444 445 static int snd_vortex_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 446 { 447 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 448 uinfo->count = 1; 449 return 0; 450 } 451 452 static int snd_vortex_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 453 { 454 ucontrol->value.iec958.status[0] = 0xff; 455 ucontrol->value.iec958.status[1] = 0xff; 456 ucontrol->value.iec958.status[2] = 0xff; 457 ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS; 458 return 0; 459 } 460 461 static int snd_vortex_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 462 { 463 vortex_t *vortex = snd_kcontrol_chip(kcontrol); 464 ucontrol->value.iec958.status[0] = 0x00; 465 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_ORIGINAL|IEC958_AES1_CON_DIGDIGCONV_ID; 466 ucontrol->value.iec958.status[2] = 0x00; 467 switch (vortex->spdif_sr) { 468 case 32000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_32000; break; 469 case 44100: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_44100; break; 470 case 48000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_48000; break; 471 } 472 return 0; 473 } 474 475 static int snd_vortex_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 476 { 477 vortex_t *vortex = snd_kcontrol_chip(kcontrol); 478 int spdif_sr = 48000; 479 switch (ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) { 480 case IEC958_AES3_CON_FS_32000: spdif_sr = 32000; break; 481 case IEC958_AES3_CON_FS_44100: spdif_sr = 44100; break; 482 case IEC958_AES3_CON_FS_48000: spdif_sr = 48000; break; 483 } 484 if (spdif_sr == vortex->spdif_sr) 485 return 0; 486 vortex->spdif_sr = spdif_sr; 487 vortex_spdif_init(vortex, vortex->spdif_sr, 1); 488 return 1; 489 } 490 491 /* spdif controls */ 492 static struct snd_kcontrol_new snd_vortex_mixer_spdif[] __devinitdata = { 493 { 494 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 495 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 496 .info = snd_vortex_spdif_info, 497 .get = snd_vortex_spdif_get, 498 .put = snd_vortex_spdif_put, 499 }, 500 { 501 .access = SNDRV_CTL_ELEM_ACCESS_READ, 502 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 503 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK), 504 .info = snd_vortex_spdif_info, 505 .get = snd_vortex_spdif_mask_get 506 }, 507 }; 508 509 /* create a pcm device */ 510 static int __devinit snd_vortex_new_pcm(vortex_t *chip, int idx, int nr) 511 { 512 struct snd_pcm *pcm; 513 struct snd_kcontrol *kctl; 514 int i; 515 int err, nr_capt; 516 517 if (!chip || idx < 0 || idx >= VORTEX_PCM_LAST) 518 return -ENODEV; 519 520 /* idx indicates which kind of PCM device. ADB, SPDIF, I2S and A3D share the 521 * same dma engine. WT uses it own separate dma engine which can't capture. */ 522 if (idx == VORTEX_PCM_ADB) 523 nr_capt = nr; 524 else 525 nr_capt = 0; 526 err = snd_pcm_new(chip->card, vortex_pcm_prettyname[idx], idx, nr, 527 nr_capt, &pcm); 528 if (err < 0) 529 return err; 530 snprintf(pcm->name, sizeof(pcm->name), 531 "%s %s", CARD_NAME_SHORT, vortex_pcm_name[idx]); 532 chip->pcm[idx] = pcm; 533 // This is an evil hack, but it saves a lot of duplicated code. 534 VORTEX_PCM_TYPE(pcm) = idx; 535 pcm->private_data = chip; 536 /* set operators */ 537 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 538 &snd_vortex_playback_ops); 539 if (idx == VORTEX_PCM_ADB) 540 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 541 &snd_vortex_playback_ops); 542 543 /* pre-allocation of Scatter-Gather buffers */ 544 545 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, 546 snd_dma_pci_data(chip->pci_dev), 547 0x10000, 0x10000); 548 549 if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_SPDIF) { 550 for (i = 0; i < ARRAY_SIZE(snd_vortex_mixer_spdif); i++) { 551 kctl = snd_ctl_new1(&snd_vortex_mixer_spdif[i], chip); 552 if (!kctl) 553 return -ENOMEM; 554 if ((err = snd_ctl_add(chip->card, kctl)) < 0) 555 return err; 556 } 557 } 558 return 0; 559 } 560