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 } 549