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 #ifdef CHIP_AU8830 46 .channels_max = 4, 47 #else 48 .channels_max = 2, 49 #endif 50 .buffer_bytes_max = 0x10000, 51 .period_bytes_min = 0x1, 52 .period_bytes_max = 0x1000, 53 .periods_min = 2, 54 .periods_max = 32, 55 }; 56 57 #ifndef CHIP_AU8820 58 static struct snd_pcm_hardware snd_vortex_playback_hw_a3d = { 59 .info = 60 (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */ 61 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED | 62 SNDRV_PCM_INFO_MMAP_VALID), 63 .formats = 64 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 | 65 SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW, 66 .rates = SNDRV_PCM_RATE_CONTINUOUS, 67 .rate_min = 5000, 68 .rate_max = 48000, 69 .channels_min = 1, 70 .channels_max = 1, 71 .buffer_bytes_max = 0x10000, 72 .period_bytes_min = 0x100, 73 .period_bytes_max = 0x1000, 74 .periods_min = 2, 75 .periods_max = 64, 76 }; 77 #endif 78 static struct snd_pcm_hardware snd_vortex_playback_hw_spdif = { 79 .info = 80 (SNDRV_PCM_INFO_MMAP | /* SNDRV_PCM_INFO_RESUME | */ 81 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_INTERLEAVED | 82 SNDRV_PCM_INFO_MMAP_VALID), 83 .formats = 84 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_U8 | 85 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE | SNDRV_PCM_FMTBIT_MU_LAW | 86 SNDRV_PCM_FMTBIT_A_LAW, 87 .rates = 88 SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, 89 .rate_min = 32000, 90 .rate_max = 48000, 91 .channels_min = 1, 92 .channels_max = 2, 93 .buffer_bytes_max = 0x10000, 94 .period_bytes_min = 0x100, 95 .period_bytes_max = 0x1000, 96 .periods_min = 2, 97 .periods_max = 64, 98 }; 99 100 #ifndef CHIP_AU8810 101 static struct snd_pcm_hardware snd_vortex_playback_hw_wt = { 102 .info = (SNDRV_PCM_INFO_MMAP | 103 SNDRV_PCM_INFO_INTERLEAVED | 104 SNDRV_PCM_INFO_BLOCK_TRANSFER | SNDRV_PCM_INFO_MMAP_VALID), 105 .formats = SNDRV_PCM_FMTBIT_S16_LE, 106 .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_CONTINUOUS, // SNDRV_PCM_RATE_48000, 107 .rate_min = 8000, 108 .rate_max = 48000, 109 .channels_min = 1, 110 .channels_max = 2, 111 .buffer_bytes_max = 0x10000, 112 .period_bytes_min = 0x0400, 113 .period_bytes_max = 0x1000, 114 .periods_min = 2, 115 .periods_max = 64, 116 }; 117 #endif 118 /* open callback */ 119 static int snd_vortex_pcm_open(struct snd_pcm_substream *substream) 120 { 121 vortex_t *vortex = snd_pcm_substream_chip(substream); 122 struct snd_pcm_runtime *runtime = substream->runtime; 123 int err; 124 125 /* Force equal size periods */ 126 if ((err = 127 snd_pcm_hw_constraint_integer(runtime, 128 SNDRV_PCM_HW_PARAM_PERIODS)) < 0) 129 return err; 130 /* Avoid PAGE_SIZE boundary to fall inside of a period. */ 131 if ((err = 132 snd_pcm_hw_constraint_pow2(runtime, 0, 133 SNDRV_PCM_HW_PARAM_PERIOD_BYTES)) < 0) 134 return err; 135 136 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) { 137 #ifndef CHIP_AU8820 138 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_A3D) { 139 runtime->hw = snd_vortex_playback_hw_a3d; 140 } 141 #endif 142 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_SPDIF) { 143 runtime->hw = snd_vortex_playback_hw_spdif; 144 switch (vortex->spdif_sr) { 145 case 32000: 146 runtime->hw.rates = SNDRV_PCM_RATE_32000; 147 break; 148 case 44100: 149 runtime->hw.rates = SNDRV_PCM_RATE_44100; 150 break; 151 case 48000: 152 runtime->hw.rates = SNDRV_PCM_RATE_48000; 153 break; 154 } 155 } 156 if (VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_ADB 157 || VORTEX_PCM_TYPE(substream->pcm) == VORTEX_PCM_I2S) 158 runtime->hw = snd_vortex_playback_hw_adb; 159 substream->runtime->private_data = NULL; 160 } 161 #ifndef CHIP_AU8810 162 else { 163 runtime->hw = snd_vortex_playback_hw_wt; 164 substream->runtime->private_data = NULL; 165 } 166 #endif 167 return 0; 168 } 169 170 /* close callback */ 171 static int snd_vortex_pcm_close(struct snd_pcm_substream *substream) 172 { 173 //vortex_t *chip = snd_pcm_substream_chip(substream); 174 stream_t *stream = (stream_t *) substream->runtime->private_data; 175 176 // the hardware-specific codes will be here 177 if (stream != NULL) { 178 stream->substream = NULL; 179 stream->nr_ch = 0; 180 } 181 substream->runtime->private_data = NULL; 182 return 0; 183 } 184 185 /* hw_params callback */ 186 static int 187 snd_vortex_pcm_hw_params(struct snd_pcm_substream *substream, 188 struct snd_pcm_hw_params *hw_params) 189 { 190 vortex_t *chip = snd_pcm_substream_chip(substream); 191 stream_t *stream = (stream_t *) (substream->runtime->private_data); 192 struct snd_sg_buf *sgbuf; 193 int err; 194 195 // Alloc buffer memory. 196 err = 197 snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params)); 198 if (err < 0) { 199 printk(KERN_ERR "Vortex: pcm page alloc failed!\n"); 200 return err; 201 } 202 //sgbuf = (struct snd_sg_buf *) substream->runtime->dma_private; 203 sgbuf = snd_pcm_substream_sgbuf(substream); 204 /* 205 printk(KERN_INFO "Vortex: periods %d, period_bytes %d, channels = %d\n", params_periods(hw_params), 206 params_period_bytes(hw_params), params_channels(hw_params)); 207 */ 208 spin_lock_irq(&chip->lock); 209 // Make audio routes and config buffer DMA. 210 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) { 211 int dma, type = VORTEX_PCM_TYPE(substream->pcm); 212 /* Dealloc any routes. */ 213 if (stream != NULL) 214 vortex_adb_allocroute(chip, stream->dma, 215 stream->nr_ch, stream->dir, 216 stream->type); 217 /* Alloc routes. */ 218 dma = 219 vortex_adb_allocroute(chip, -1, 220 params_channels(hw_params), 221 substream->stream, type); 222 if (dma < 0) { 223 spin_unlock_irq(&chip->lock); 224 return dma; 225 } 226 stream = substream->runtime->private_data = &chip->dma_adb[dma]; 227 stream->substream = substream; 228 /* Setup Buffers. */ 229 vortex_adbdma_setbuffers(chip, dma, sgbuf, 230 params_period_bytes(hw_params), 231 params_periods(hw_params)); 232 } 233 #ifndef CHIP_AU8810 234 else { 235 /* if (stream != NULL) 236 vortex_wt_allocroute(chip, substream->number, 0); */ 237 vortex_wt_allocroute(chip, substream->number, 238 params_channels(hw_params)); 239 stream = substream->runtime->private_data = 240 &chip->dma_wt[substream->number]; 241 stream->dma = substream->number; 242 stream->substream = substream; 243 vortex_wtdma_setbuffers(chip, substream->number, sgbuf, 244 params_period_bytes(hw_params), 245 params_periods(hw_params)); 246 } 247 #endif 248 spin_unlock_irq(&chip->lock); 249 return 0; 250 } 251 252 /* hw_free callback */ 253 static int snd_vortex_pcm_hw_free(struct snd_pcm_substream *substream) 254 { 255 vortex_t *chip = snd_pcm_substream_chip(substream); 256 stream_t *stream = (stream_t *) (substream->runtime->private_data); 257 258 spin_lock_irq(&chip->lock); 259 // Delete audio routes. 260 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) { 261 if (stream != NULL) 262 vortex_adb_allocroute(chip, stream->dma, 263 stream->nr_ch, stream->dir, 264 stream->type); 265 } 266 #ifndef CHIP_AU8810 267 else { 268 if (stream != NULL) 269 vortex_wt_allocroute(chip, stream->dma, 0); 270 } 271 #endif 272 substream->runtime->private_data = NULL; 273 spin_unlock_irq(&chip->lock); 274 275 return snd_pcm_lib_free_pages(substream); 276 } 277 278 /* prepare callback */ 279 static int snd_vortex_pcm_prepare(struct snd_pcm_substream *substream) 280 { 281 vortex_t *chip = snd_pcm_substream_chip(substream); 282 struct snd_pcm_runtime *runtime = substream->runtime; 283 stream_t *stream = (stream_t *) substream->runtime->private_data; 284 int dma = stream->dma, fmt, dir; 285 286 // set up the hardware with the current configuration. 287 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 288 dir = 1; 289 else 290 dir = 0; 291 fmt = vortex_alsafmt_aspfmt(runtime->format); 292 spin_lock_irq(&chip->lock); 293 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) { 294 vortex_adbdma_setmode(chip, dma, 1, dir, fmt, 0 /*? */ , 295 0); 296 vortex_adbdma_setstartbuffer(chip, dma, 0); 297 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_SPDIF) 298 vortex_adb_setsrc(chip, dma, runtime->rate, dir); 299 } 300 #ifndef CHIP_AU8810 301 else { 302 vortex_wtdma_setmode(chip, dma, 1, fmt, 0, 0); 303 // FIXME: Set rate (i guess using vortex_wt_writereg() somehow). 304 vortex_wtdma_setstartbuffer(chip, dma, 0); 305 } 306 #endif 307 spin_unlock_irq(&chip->lock); 308 return 0; 309 } 310 311 /* trigger callback */ 312 static int snd_vortex_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 313 { 314 vortex_t *chip = snd_pcm_substream_chip(substream); 315 stream_t *stream = (stream_t *) substream->runtime->private_data; 316 int dma = stream->dma; 317 318 spin_lock(&chip->lock); 319 switch (cmd) { 320 case SNDRV_PCM_TRIGGER_START: 321 // do something to start the PCM engine 322 //printk(KERN_INFO "vortex: start %d\n", dma); 323 stream->fifo_enabled = 1; 324 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) { 325 vortex_adbdma_resetup(chip, dma); 326 vortex_adbdma_startfifo(chip, dma); 327 } 328 #ifndef CHIP_AU8810 329 else { 330 printk(KERN_INFO "vortex: wt start %d\n", dma); 331 vortex_wtdma_startfifo(chip, dma); 332 } 333 #endif 334 break; 335 case SNDRV_PCM_TRIGGER_STOP: 336 // do something to stop the PCM engine 337 //printk(KERN_INFO "vortex: stop %d\n", dma); 338 stream->fifo_enabled = 0; 339 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) 340 vortex_adbdma_pausefifo(chip, dma); 341 //vortex_adbdma_stopfifo(chip, dma); 342 #ifndef CHIP_AU8810 343 else { 344 printk(KERN_INFO "vortex: wt stop %d\n", dma); 345 vortex_wtdma_stopfifo(chip, dma); 346 } 347 #endif 348 break; 349 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 350 //printk(KERN_INFO "vortex: pause %d\n", dma); 351 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) 352 vortex_adbdma_pausefifo(chip, dma); 353 #ifndef CHIP_AU8810 354 else 355 vortex_wtdma_pausefifo(chip, dma); 356 #endif 357 break; 358 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 359 //printk(KERN_INFO "vortex: resume %d\n", dma); 360 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) 361 vortex_adbdma_resumefifo(chip, dma); 362 #ifndef CHIP_AU8810 363 else 364 vortex_wtdma_resumefifo(chip, dma); 365 #endif 366 break; 367 default: 368 spin_unlock(&chip->lock); 369 return -EINVAL; 370 } 371 spin_unlock(&chip->lock); 372 return 0; 373 } 374 375 /* pointer callback */ 376 static snd_pcm_uframes_t snd_vortex_pcm_pointer(struct snd_pcm_substream *substream) 377 { 378 vortex_t *chip = snd_pcm_substream_chip(substream); 379 stream_t *stream = (stream_t *) substream->runtime->private_data; 380 int dma = stream->dma; 381 snd_pcm_uframes_t current_ptr = 0; 382 383 spin_lock(&chip->lock); 384 if (VORTEX_PCM_TYPE(substream->pcm) != VORTEX_PCM_WT) 385 current_ptr = vortex_adbdma_getlinearpos(chip, dma); 386 #ifndef CHIP_AU8810 387 else 388 current_ptr = vortex_wtdma_getlinearpos(chip, dma); 389 #endif 390 //printk(KERN_INFO "vortex: pointer = 0x%x\n", current_ptr); 391 spin_unlock(&chip->lock); 392 return (bytes_to_frames(substream->runtime, current_ptr)); 393 } 394 395 /* Page callback. */ 396 /* 397 static struct page *snd_pcm_sgbuf_ops_page(struct snd_pcm_substream *substream, unsigned long offset) { 398 399 400 } 401 */ 402 /* operators */ 403 static struct snd_pcm_ops snd_vortex_playback_ops = { 404 .open = snd_vortex_pcm_open, 405 .close = snd_vortex_pcm_close, 406 .ioctl = snd_pcm_lib_ioctl, 407 .hw_params = snd_vortex_pcm_hw_params, 408 .hw_free = snd_vortex_pcm_hw_free, 409 .prepare = snd_vortex_pcm_prepare, 410 .trigger = snd_vortex_pcm_trigger, 411 .pointer = snd_vortex_pcm_pointer, 412 .page = snd_pcm_sgbuf_ops_page, 413 }; 414 415 /* 416 * definitions of capture are omitted here... 417 */ 418 419 static char *vortex_pcm_prettyname[VORTEX_PCM_LAST] = { 420 "AU88x0 ADB", 421 "AU88x0 SPDIF", 422 "AU88x0 A3D", 423 "AU88x0 WT", 424 "AU88x0 I2S", 425 }; 426 static char *vortex_pcm_name[VORTEX_PCM_LAST] = { 427 "adb", 428 "spdif", 429 "a3d", 430 "wt", 431 "i2s", 432 }; 433 434 /* SPDIF kcontrol */ 435 436 static int snd_vortex_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 437 { 438 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 439 uinfo->count = 1; 440 return 0; 441 } 442 443 static int snd_vortex_spdif_mask_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 444 { 445 ucontrol->value.iec958.status[0] = 0xff; 446 ucontrol->value.iec958.status[1] = 0xff; 447 ucontrol->value.iec958.status[2] = 0xff; 448 ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS; 449 return 0; 450 } 451 452 static int snd_vortex_spdif_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 453 { 454 vortex_t *vortex = snd_kcontrol_chip(kcontrol); 455 ucontrol->value.iec958.status[0] = 0x00; 456 ucontrol->value.iec958.status[1] = IEC958_AES1_CON_ORIGINAL|IEC958_AES1_CON_DIGDIGCONV_ID; 457 ucontrol->value.iec958.status[2] = 0x00; 458 switch (vortex->spdif_sr) { 459 case 32000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_32000; break; 460 case 44100: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_44100; break; 461 case 48000: ucontrol->value.iec958.status[3] = IEC958_AES3_CON_FS_48000; break; 462 } 463 return 0; 464 } 465 466 static int snd_vortex_spdif_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 467 { 468 vortex_t *vortex = snd_kcontrol_chip(kcontrol); 469 int spdif_sr = 48000; 470 switch (ucontrol->value.iec958.status[3] & IEC958_AES3_CON_FS) { 471 case IEC958_AES3_CON_FS_32000: spdif_sr = 32000; break; 472 case IEC958_AES3_CON_FS_44100: spdif_sr = 44100; break; 473 case IEC958_AES3_CON_FS_48000: spdif_sr = 48000; break; 474 } 475 if (spdif_sr == vortex->spdif_sr) 476 return 0; 477 vortex->spdif_sr = spdif_sr; 478 vortex_spdif_init(vortex, vortex->spdif_sr, 1); 479 return 1; 480 } 481 482 /* spdif controls */ 483 static struct snd_kcontrol_new snd_vortex_mixer_spdif[] __devinitdata = { 484 { 485 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 486 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 487 .info = snd_vortex_spdif_info, 488 .get = snd_vortex_spdif_get, 489 .put = snd_vortex_spdif_put, 490 }, 491 { 492 .access = SNDRV_CTL_ELEM_ACCESS_READ, 493 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 494 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK), 495 .info = snd_vortex_spdif_info, 496 .get = snd_vortex_spdif_mask_get 497 }, 498 }; 499 500 /* create a pcm device */ 501 static int __devinit snd_vortex_new_pcm(vortex_t *chip, int idx, int nr) 502 { 503 struct snd_pcm *pcm; 504 struct snd_kcontrol *kctl; 505 int i; 506 int err, nr_capt; 507 508 if (!chip || idx < 0 || idx >= VORTEX_PCM_LAST) 509 return -ENODEV; 510 511 /* idx indicates which kind of PCM device. ADB, SPDIF, I2S and A3D share the 512 * same dma engine. WT uses it own separate dma engine whcih cant capture. */ 513 if (idx == VORTEX_PCM_ADB) 514 nr_capt = nr; 515 else 516 nr_capt = 0; 517 err = snd_pcm_new(chip->card, vortex_pcm_prettyname[idx], idx, nr, 518 nr_capt, &pcm); 519 if (err < 0) 520 return err; 521 strcpy(pcm->name, vortex_pcm_name[idx]); 522 chip->pcm[idx] = pcm; 523 // This is an evil hack, but it saves a lot of duplicated code. 524 VORTEX_PCM_TYPE(pcm) = idx; 525 pcm->private_data = chip; 526 /* set operators */ 527 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 528 &snd_vortex_playback_ops); 529 if (idx == VORTEX_PCM_ADB) 530 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 531 &snd_vortex_playback_ops); 532 533 /* pre-allocation of Scatter-Gather buffers */ 534 535 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG, 536 snd_dma_pci_data(chip->pci_dev), 537 0x10000, 0x10000); 538 539 if (VORTEX_PCM_TYPE(pcm) == VORTEX_PCM_SPDIF) { 540 for (i = 0; i < ARRAY_SIZE(snd_vortex_mixer_spdif); i++) { 541 kctl = snd_ctl_new1(&snd_vortex_mixer_spdif[i], chip); 542 if (!kctl) 543 return -ENOMEM; 544 if ((err = snd_ctl_add(chip->card, kctl)) < 0) 545 return err; 546 } 547 } 548 return 0; 549 } 550