1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Analog Devices 1889 audio driver 3 * 4 * This is a driver for the AD1889 PCI audio chipset found 5 * on the HP PA-RISC [BCJ]-xxx0 workstations. 6 * 7 * Copyright (C) 2004-2005, Kyle McMartin <kyle@parisc-linux.org> 8 * Copyright (C) 2005, Thibaut Varene <varenet@parisc-linux.org> 9 * Based on the OSS AD1889 driver by Randolph Chung <tausq@debian.org> 10 * 11 * TODO: 12 * Do we need to take care of CCS register? 13 * Maybe we could use finer grained locking (separate locks for pb/cap)? 14 * Wishlist: 15 * Control Interface (mixer) support 16 * Better AC97 support (VSR...)? 17 * PM support 18 * MIDI support 19 * Game Port support 20 * SG DMA support (this will need *a lot* of work) 21 */ 22 23 #include <linux/init.h> 24 #include <linux/pci.h> 25 #include <linux/dma-mapping.h> 26 #include <linux/slab.h> 27 #include <linux/interrupt.h> 28 #include <linux/compiler.h> 29 #include <linux/delay.h> 30 #include <linux/module.h> 31 #include <linux/io.h> 32 33 #include <sound/core.h> 34 #include <sound/pcm.h> 35 #include <sound/initval.h> 36 #include <sound/ac97_codec.h> 37 38 #include "ad1889.h" 39 #include "ac97/ac97_id.h" 40 41 #define AD1889_DRVVER "Version: 1.7" 42 43 MODULE_AUTHOR("Kyle McMartin <kyle@parisc-linux.org>, Thibaut Varene <t-bone@parisc-linux.org>"); 44 MODULE_DESCRIPTION("Analog Devices AD1889 ALSA sound driver"); 45 MODULE_LICENSE("GPL"); 46 MODULE_SUPPORTED_DEVICE("{{Analog Devices,AD1889}}"); 47 48 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; 49 module_param_array(index, int, NULL, 0444); 50 MODULE_PARM_DESC(index, "Index value for the AD1889 soundcard."); 51 52 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; 53 module_param_array(id, charp, NULL, 0444); 54 MODULE_PARM_DESC(id, "ID string for the AD1889 soundcard."); 55 56 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; 57 module_param_array(enable, bool, NULL, 0444); 58 MODULE_PARM_DESC(enable, "Enable AD1889 soundcard."); 59 60 static char *ac97_quirk[SNDRV_CARDS]; 61 module_param_array(ac97_quirk, charp, NULL, 0444); 62 MODULE_PARM_DESC(ac97_quirk, "AC'97 workaround for strange hardware."); 63 64 #define DEVNAME "ad1889" 65 #define PFX DEVNAME ": " 66 67 /* keep track of some hw registers */ 68 struct ad1889_register_state { 69 u16 reg; /* reg setup */ 70 u32 addr; /* dma base address */ 71 unsigned long size; /* DMA buffer size */ 72 }; 73 74 struct snd_ad1889 { 75 struct snd_card *card; 76 struct pci_dev *pci; 77 78 int irq; 79 unsigned long bar; 80 void __iomem *iobase; 81 82 struct snd_ac97 *ac97; 83 struct snd_ac97_bus *ac97_bus; 84 struct snd_pcm *pcm; 85 struct snd_info_entry *proc; 86 87 struct snd_pcm_substream *psubs; 88 struct snd_pcm_substream *csubs; 89 90 /* playback register state */ 91 struct ad1889_register_state wave; 92 struct ad1889_register_state ramc; 93 94 spinlock_t lock; 95 }; 96 97 static inline u16 98 ad1889_readw(struct snd_ad1889 *chip, unsigned reg) 99 { 100 return readw(chip->iobase + reg); 101 } 102 103 static inline void 104 ad1889_writew(struct snd_ad1889 *chip, unsigned reg, u16 val) 105 { 106 writew(val, chip->iobase + reg); 107 } 108 109 static inline u32 110 ad1889_readl(struct snd_ad1889 *chip, unsigned reg) 111 { 112 return readl(chip->iobase + reg); 113 } 114 115 static inline void 116 ad1889_writel(struct snd_ad1889 *chip, unsigned reg, u32 val) 117 { 118 writel(val, chip->iobase + reg); 119 } 120 121 static inline void 122 ad1889_unmute(struct snd_ad1889 *chip) 123 { 124 u16 st; 125 st = ad1889_readw(chip, AD_DS_WADA) & 126 ~(AD_DS_WADA_RWAM | AD_DS_WADA_LWAM); 127 ad1889_writew(chip, AD_DS_WADA, st); 128 ad1889_readw(chip, AD_DS_WADA); 129 } 130 131 static inline void 132 ad1889_mute(struct snd_ad1889 *chip) 133 { 134 u16 st; 135 st = ad1889_readw(chip, AD_DS_WADA) | AD_DS_WADA_RWAM | AD_DS_WADA_LWAM; 136 ad1889_writew(chip, AD_DS_WADA, st); 137 ad1889_readw(chip, AD_DS_WADA); 138 } 139 140 static inline void 141 ad1889_load_adc_buffer_address(struct snd_ad1889 *chip, u32 address) 142 { 143 ad1889_writel(chip, AD_DMA_ADCBA, address); 144 ad1889_writel(chip, AD_DMA_ADCCA, address); 145 } 146 147 static inline void 148 ad1889_load_adc_buffer_count(struct snd_ad1889 *chip, u32 count) 149 { 150 ad1889_writel(chip, AD_DMA_ADCBC, count); 151 ad1889_writel(chip, AD_DMA_ADCCC, count); 152 } 153 154 static inline void 155 ad1889_load_adc_interrupt_count(struct snd_ad1889 *chip, u32 count) 156 { 157 ad1889_writel(chip, AD_DMA_ADCIB, count); 158 ad1889_writel(chip, AD_DMA_ADCIC, count); 159 } 160 161 static inline void 162 ad1889_load_wave_buffer_address(struct snd_ad1889 *chip, u32 address) 163 { 164 ad1889_writel(chip, AD_DMA_WAVBA, address); 165 ad1889_writel(chip, AD_DMA_WAVCA, address); 166 } 167 168 static inline void 169 ad1889_load_wave_buffer_count(struct snd_ad1889 *chip, u32 count) 170 { 171 ad1889_writel(chip, AD_DMA_WAVBC, count); 172 ad1889_writel(chip, AD_DMA_WAVCC, count); 173 } 174 175 static inline void 176 ad1889_load_wave_interrupt_count(struct snd_ad1889 *chip, u32 count) 177 { 178 ad1889_writel(chip, AD_DMA_WAVIB, count); 179 ad1889_writel(chip, AD_DMA_WAVIC, count); 180 } 181 182 static void 183 ad1889_channel_reset(struct snd_ad1889 *chip, unsigned int channel) 184 { 185 u16 reg; 186 187 if (channel & AD_CHAN_WAV) { 188 /* Disable wave channel */ 189 reg = ad1889_readw(chip, AD_DS_WSMC) & ~AD_DS_WSMC_WAEN; 190 ad1889_writew(chip, AD_DS_WSMC, reg); 191 chip->wave.reg = reg; 192 193 /* disable IRQs */ 194 reg = ad1889_readw(chip, AD_DMA_WAV); 195 reg &= AD_DMA_IM_DIS; 196 reg &= ~AD_DMA_LOOP; 197 ad1889_writew(chip, AD_DMA_WAV, reg); 198 199 /* clear IRQ and address counters and pointers */ 200 ad1889_load_wave_buffer_address(chip, 0x0); 201 ad1889_load_wave_buffer_count(chip, 0x0); 202 ad1889_load_wave_interrupt_count(chip, 0x0); 203 204 /* flush */ 205 ad1889_readw(chip, AD_DMA_WAV); 206 } 207 208 if (channel & AD_CHAN_ADC) { 209 /* Disable ADC channel */ 210 reg = ad1889_readw(chip, AD_DS_RAMC) & ~AD_DS_RAMC_ADEN; 211 ad1889_writew(chip, AD_DS_RAMC, reg); 212 chip->ramc.reg = reg; 213 214 reg = ad1889_readw(chip, AD_DMA_ADC); 215 reg &= AD_DMA_IM_DIS; 216 reg &= ~AD_DMA_LOOP; 217 ad1889_writew(chip, AD_DMA_ADC, reg); 218 219 ad1889_load_adc_buffer_address(chip, 0x0); 220 ad1889_load_adc_buffer_count(chip, 0x0); 221 ad1889_load_adc_interrupt_count(chip, 0x0); 222 223 /* flush */ 224 ad1889_readw(chip, AD_DMA_ADC); 225 } 226 } 227 228 static u16 229 snd_ad1889_ac97_read(struct snd_ac97 *ac97, unsigned short reg) 230 { 231 struct snd_ad1889 *chip = ac97->private_data; 232 return ad1889_readw(chip, AD_AC97_BASE + reg); 233 } 234 235 static void 236 snd_ad1889_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val) 237 { 238 struct snd_ad1889 *chip = ac97->private_data; 239 ad1889_writew(chip, AD_AC97_BASE + reg, val); 240 } 241 242 static int 243 snd_ad1889_ac97_ready(struct snd_ad1889 *chip) 244 { 245 int retry = 400; /* average needs 352 msec */ 246 247 while (!(ad1889_readw(chip, AD_AC97_ACIC) & AD_AC97_ACIC_ACRDY) 248 && --retry) 249 usleep_range(1000, 2000); 250 if (!retry) { 251 dev_err(chip->card->dev, "[%s] Link is not ready.\n", 252 __func__); 253 return -EIO; 254 } 255 dev_dbg(chip->card->dev, "[%s] ready after %d ms\n", __func__, 400 - retry); 256 257 return 0; 258 } 259 260 static int 261 snd_ad1889_hw_params(struct snd_pcm_substream *substream, 262 struct snd_pcm_hw_params *hw_params) 263 { 264 return snd_pcm_lib_malloc_pages(substream, 265 params_buffer_bytes(hw_params)); 266 } 267 268 static int 269 snd_ad1889_hw_free(struct snd_pcm_substream *substream) 270 { 271 return snd_pcm_lib_free_pages(substream); 272 } 273 274 static const struct snd_pcm_hardware snd_ad1889_playback_hw = { 275 .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 276 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BLOCK_TRANSFER, 277 .formats = SNDRV_PCM_FMTBIT_S16_LE, 278 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000, 279 .rate_min = 8000, /* docs say 7000, but we're lazy */ 280 .rate_max = 48000, 281 .channels_min = 1, 282 .channels_max = 2, 283 .buffer_bytes_max = BUFFER_BYTES_MAX, 284 .period_bytes_min = PERIOD_BYTES_MIN, 285 .period_bytes_max = PERIOD_BYTES_MAX, 286 .periods_min = PERIODS_MIN, 287 .periods_max = PERIODS_MAX, 288 /*.fifo_size = 0,*/ 289 }; 290 291 static const struct snd_pcm_hardware snd_ad1889_capture_hw = { 292 .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 293 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_BLOCK_TRANSFER, 294 .formats = SNDRV_PCM_FMTBIT_S16_LE, 295 .rates = SNDRV_PCM_RATE_48000, 296 .rate_min = 48000, /* docs say we could to VSR, but we're lazy */ 297 .rate_max = 48000, 298 .channels_min = 1, 299 .channels_max = 2, 300 .buffer_bytes_max = BUFFER_BYTES_MAX, 301 .period_bytes_min = PERIOD_BYTES_MIN, 302 .period_bytes_max = PERIOD_BYTES_MAX, 303 .periods_min = PERIODS_MIN, 304 .periods_max = PERIODS_MAX, 305 /*.fifo_size = 0,*/ 306 }; 307 308 static int 309 snd_ad1889_playback_open(struct snd_pcm_substream *ss) 310 { 311 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 312 struct snd_pcm_runtime *rt = ss->runtime; 313 314 chip->psubs = ss; 315 rt->hw = snd_ad1889_playback_hw; 316 317 return 0; 318 } 319 320 static int 321 snd_ad1889_capture_open(struct snd_pcm_substream *ss) 322 { 323 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 324 struct snd_pcm_runtime *rt = ss->runtime; 325 326 chip->csubs = ss; 327 rt->hw = snd_ad1889_capture_hw; 328 329 return 0; 330 } 331 332 static int 333 snd_ad1889_playback_close(struct snd_pcm_substream *ss) 334 { 335 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 336 chip->psubs = NULL; 337 return 0; 338 } 339 340 static int 341 snd_ad1889_capture_close(struct snd_pcm_substream *ss) 342 { 343 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 344 chip->csubs = NULL; 345 return 0; 346 } 347 348 static int 349 snd_ad1889_playback_prepare(struct snd_pcm_substream *ss) 350 { 351 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 352 struct snd_pcm_runtime *rt = ss->runtime; 353 unsigned int size = snd_pcm_lib_buffer_bytes(ss); 354 unsigned int count = snd_pcm_lib_period_bytes(ss); 355 u16 reg; 356 357 ad1889_channel_reset(chip, AD_CHAN_WAV); 358 359 reg = ad1889_readw(chip, AD_DS_WSMC); 360 361 /* Mask out 16-bit / Stereo */ 362 reg &= ~(AD_DS_WSMC_WA16 | AD_DS_WSMC_WAST); 363 364 if (snd_pcm_format_width(rt->format) == 16) 365 reg |= AD_DS_WSMC_WA16; 366 367 if (rt->channels > 1) 368 reg |= AD_DS_WSMC_WAST; 369 370 /* let's make sure we don't clobber ourselves */ 371 spin_lock_irq(&chip->lock); 372 373 chip->wave.size = size; 374 chip->wave.reg = reg; 375 chip->wave.addr = rt->dma_addr; 376 377 ad1889_writew(chip, AD_DS_WSMC, chip->wave.reg); 378 379 /* Set sample rates on the codec */ 380 ad1889_writew(chip, AD_DS_WAS, rt->rate); 381 382 /* Set up DMA */ 383 ad1889_load_wave_buffer_address(chip, chip->wave.addr); 384 ad1889_load_wave_buffer_count(chip, size); 385 ad1889_load_wave_interrupt_count(chip, count); 386 387 /* writes flush */ 388 ad1889_readw(chip, AD_DS_WSMC); 389 390 spin_unlock_irq(&chip->lock); 391 392 dev_dbg(chip->card->dev, 393 "prepare playback: addr = 0x%x, count = %u, size = %u, reg = 0x%x, rate = %u\n", 394 chip->wave.addr, count, size, reg, rt->rate); 395 return 0; 396 } 397 398 static int 399 snd_ad1889_capture_prepare(struct snd_pcm_substream *ss) 400 { 401 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 402 struct snd_pcm_runtime *rt = ss->runtime; 403 unsigned int size = snd_pcm_lib_buffer_bytes(ss); 404 unsigned int count = snd_pcm_lib_period_bytes(ss); 405 u16 reg; 406 407 ad1889_channel_reset(chip, AD_CHAN_ADC); 408 409 reg = ad1889_readw(chip, AD_DS_RAMC); 410 411 /* Mask out 16-bit / Stereo */ 412 reg &= ~(AD_DS_RAMC_AD16 | AD_DS_RAMC_ADST); 413 414 if (snd_pcm_format_width(rt->format) == 16) 415 reg |= AD_DS_RAMC_AD16; 416 417 if (rt->channels > 1) 418 reg |= AD_DS_RAMC_ADST; 419 420 /* let's make sure we don't clobber ourselves */ 421 spin_lock_irq(&chip->lock); 422 423 chip->ramc.size = size; 424 chip->ramc.reg = reg; 425 chip->ramc.addr = rt->dma_addr; 426 427 ad1889_writew(chip, AD_DS_RAMC, chip->ramc.reg); 428 429 /* Set up DMA */ 430 ad1889_load_adc_buffer_address(chip, chip->ramc.addr); 431 ad1889_load_adc_buffer_count(chip, size); 432 ad1889_load_adc_interrupt_count(chip, count); 433 434 /* writes flush */ 435 ad1889_readw(chip, AD_DS_RAMC); 436 437 spin_unlock_irq(&chip->lock); 438 439 dev_dbg(chip->card->dev, 440 "prepare capture: addr = 0x%x, count = %u, size = %u, reg = 0x%x, rate = %u\n", 441 chip->ramc.addr, count, size, reg, rt->rate); 442 return 0; 443 } 444 445 /* this is called in atomic context with IRQ disabled. 446 Must be as fast as possible and not sleep. 447 DMA should be *triggered* by this call. 448 The WSMC "WAEN" bit triggers DMA Wave On/Off */ 449 static int 450 snd_ad1889_playback_trigger(struct snd_pcm_substream *ss, int cmd) 451 { 452 u16 wsmc; 453 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 454 455 wsmc = ad1889_readw(chip, AD_DS_WSMC); 456 457 switch (cmd) { 458 case SNDRV_PCM_TRIGGER_START: 459 /* enable DMA loop & interrupts */ 460 ad1889_writew(chip, AD_DMA_WAV, AD_DMA_LOOP | AD_DMA_IM_CNT); 461 wsmc |= AD_DS_WSMC_WAEN; 462 /* 1 to clear CHSS bit */ 463 ad1889_writel(chip, AD_DMA_CHSS, AD_DMA_CHSS_WAVS); 464 ad1889_unmute(chip); 465 break; 466 case SNDRV_PCM_TRIGGER_STOP: 467 ad1889_mute(chip); 468 wsmc &= ~AD_DS_WSMC_WAEN; 469 break; 470 default: 471 snd_BUG(); 472 return -EINVAL; 473 } 474 475 chip->wave.reg = wsmc; 476 ad1889_writew(chip, AD_DS_WSMC, wsmc); 477 ad1889_readw(chip, AD_DS_WSMC); /* flush */ 478 479 /* reset the chip when STOP - will disable IRQs */ 480 if (cmd == SNDRV_PCM_TRIGGER_STOP) 481 ad1889_channel_reset(chip, AD_CHAN_WAV); 482 483 return 0; 484 } 485 486 /* this is called in atomic context with IRQ disabled. 487 Must be as fast as possible and not sleep. 488 DMA should be *triggered* by this call. 489 The RAMC "ADEN" bit triggers DMA ADC On/Off */ 490 static int 491 snd_ad1889_capture_trigger(struct snd_pcm_substream *ss, int cmd) 492 { 493 u16 ramc; 494 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 495 496 ramc = ad1889_readw(chip, AD_DS_RAMC); 497 498 switch (cmd) { 499 case SNDRV_PCM_TRIGGER_START: 500 /* enable DMA loop & interrupts */ 501 ad1889_writew(chip, AD_DMA_ADC, AD_DMA_LOOP | AD_DMA_IM_CNT); 502 ramc |= AD_DS_RAMC_ADEN; 503 /* 1 to clear CHSS bit */ 504 ad1889_writel(chip, AD_DMA_CHSS, AD_DMA_CHSS_ADCS); 505 break; 506 case SNDRV_PCM_TRIGGER_STOP: 507 ramc &= ~AD_DS_RAMC_ADEN; 508 break; 509 default: 510 return -EINVAL; 511 } 512 513 chip->ramc.reg = ramc; 514 ad1889_writew(chip, AD_DS_RAMC, ramc); 515 ad1889_readw(chip, AD_DS_RAMC); /* flush */ 516 517 /* reset the chip when STOP - will disable IRQs */ 518 if (cmd == SNDRV_PCM_TRIGGER_STOP) 519 ad1889_channel_reset(chip, AD_CHAN_ADC); 520 521 return 0; 522 } 523 524 /* Called in atomic context with IRQ disabled */ 525 static snd_pcm_uframes_t 526 snd_ad1889_playback_pointer(struct snd_pcm_substream *ss) 527 { 528 size_t ptr = 0; 529 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 530 531 if (unlikely(!(chip->wave.reg & AD_DS_WSMC_WAEN))) 532 return 0; 533 534 ptr = ad1889_readl(chip, AD_DMA_WAVCA); 535 ptr -= chip->wave.addr; 536 537 if (snd_BUG_ON(ptr >= chip->wave.size)) 538 return 0; 539 540 return bytes_to_frames(ss->runtime, ptr); 541 } 542 543 /* Called in atomic context with IRQ disabled */ 544 static snd_pcm_uframes_t 545 snd_ad1889_capture_pointer(struct snd_pcm_substream *ss) 546 { 547 size_t ptr = 0; 548 struct snd_ad1889 *chip = snd_pcm_substream_chip(ss); 549 550 if (unlikely(!(chip->ramc.reg & AD_DS_RAMC_ADEN))) 551 return 0; 552 553 ptr = ad1889_readl(chip, AD_DMA_ADCCA); 554 ptr -= chip->ramc.addr; 555 556 if (snd_BUG_ON(ptr >= chip->ramc.size)) 557 return 0; 558 559 return bytes_to_frames(ss->runtime, ptr); 560 } 561 562 static const struct snd_pcm_ops snd_ad1889_playback_ops = { 563 .open = snd_ad1889_playback_open, 564 .close = snd_ad1889_playback_close, 565 .ioctl = snd_pcm_lib_ioctl, 566 .hw_params = snd_ad1889_hw_params, 567 .hw_free = snd_ad1889_hw_free, 568 .prepare = snd_ad1889_playback_prepare, 569 .trigger = snd_ad1889_playback_trigger, 570 .pointer = snd_ad1889_playback_pointer, 571 }; 572 573 static const struct snd_pcm_ops snd_ad1889_capture_ops = { 574 .open = snd_ad1889_capture_open, 575 .close = snd_ad1889_capture_close, 576 .ioctl = snd_pcm_lib_ioctl, 577 .hw_params = snd_ad1889_hw_params, 578 .hw_free = snd_ad1889_hw_free, 579 .prepare = snd_ad1889_capture_prepare, 580 .trigger = snd_ad1889_capture_trigger, 581 .pointer = snd_ad1889_capture_pointer, 582 }; 583 584 static irqreturn_t 585 snd_ad1889_interrupt(int irq, void *dev_id) 586 { 587 unsigned long st; 588 struct snd_ad1889 *chip = dev_id; 589 590 st = ad1889_readl(chip, AD_DMA_DISR); 591 592 /* clear ISR */ 593 ad1889_writel(chip, AD_DMA_DISR, st); 594 595 st &= AD_INTR_MASK; 596 597 if (unlikely(!st)) 598 return IRQ_NONE; 599 600 if (st & (AD_DMA_DISR_PMAI|AD_DMA_DISR_PTAI)) 601 dev_dbg(chip->card->dev, 602 "Unexpected master or target abort interrupt!\n"); 603 604 if ((st & AD_DMA_DISR_WAVI) && chip->psubs) 605 snd_pcm_period_elapsed(chip->psubs); 606 if ((st & AD_DMA_DISR_ADCI) && chip->csubs) 607 snd_pcm_period_elapsed(chip->csubs); 608 609 return IRQ_HANDLED; 610 } 611 612 static int 613 snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device) 614 { 615 int err; 616 struct snd_pcm *pcm; 617 618 err = snd_pcm_new(chip->card, chip->card->driver, device, 1, 1, &pcm); 619 if (err < 0) 620 return err; 621 622 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, 623 &snd_ad1889_playback_ops); 624 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, 625 &snd_ad1889_capture_ops); 626 627 pcm->private_data = chip; 628 pcm->info_flags = 0; 629 strcpy(pcm->name, chip->card->shortname); 630 631 chip->pcm = pcm; 632 chip->psubs = NULL; 633 chip->csubs = NULL; 634 635 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, 636 &chip->pci->dev, 637 BUFFER_BYTES_MAX / 2, 638 BUFFER_BYTES_MAX); 639 640 return 0; 641 } 642 643 static void 644 snd_ad1889_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) 645 { 646 struct snd_ad1889 *chip = entry->private_data; 647 u16 reg; 648 int tmp; 649 650 reg = ad1889_readw(chip, AD_DS_WSMC); 651 snd_iprintf(buffer, "Wave output: %s\n", 652 (reg & AD_DS_WSMC_WAEN) ? "enabled" : "disabled"); 653 snd_iprintf(buffer, "Wave Channels: %s\n", 654 (reg & AD_DS_WSMC_WAST) ? "stereo" : "mono"); 655 snd_iprintf(buffer, "Wave Quality: %d-bit linear\n", 656 (reg & AD_DS_WSMC_WA16) ? 16 : 8); 657 658 /* WARQ is at offset 12 */ 659 tmp = (reg & AD_DS_WSMC_WARQ) ? 660 ((((reg & AD_DS_WSMC_WARQ) >> 12) & 0x01) ? 12 : 18) : 4; 661 tmp /= (reg & AD_DS_WSMC_WAST) ? 2 : 1; 662 663 snd_iprintf(buffer, "Wave FIFO: %d %s words\n\n", tmp, 664 (reg & AD_DS_WSMC_WAST) ? "stereo" : "mono"); 665 666 667 snd_iprintf(buffer, "Synthesis output: %s\n", 668 reg & AD_DS_WSMC_SYEN ? "enabled" : "disabled"); 669 670 /* SYRQ is at offset 4 */ 671 tmp = (reg & AD_DS_WSMC_SYRQ) ? 672 ((((reg & AD_DS_WSMC_SYRQ) >> 4) & 0x01) ? 12 : 18) : 4; 673 tmp /= (reg & AD_DS_WSMC_WAST) ? 2 : 1; 674 675 snd_iprintf(buffer, "Synthesis FIFO: %d %s words\n\n", tmp, 676 (reg & AD_DS_WSMC_WAST) ? "stereo" : "mono"); 677 678 reg = ad1889_readw(chip, AD_DS_RAMC); 679 snd_iprintf(buffer, "ADC input: %s\n", 680 (reg & AD_DS_RAMC_ADEN) ? "enabled" : "disabled"); 681 snd_iprintf(buffer, "ADC Channels: %s\n", 682 (reg & AD_DS_RAMC_ADST) ? "stereo" : "mono"); 683 snd_iprintf(buffer, "ADC Quality: %d-bit linear\n", 684 (reg & AD_DS_RAMC_AD16) ? 16 : 8); 685 686 /* ACRQ is at offset 4 */ 687 tmp = (reg & AD_DS_RAMC_ACRQ) ? 688 ((((reg & AD_DS_RAMC_ACRQ) >> 4) & 0x01) ? 12 : 18) : 4; 689 tmp /= (reg & AD_DS_RAMC_ADST) ? 2 : 1; 690 691 snd_iprintf(buffer, "ADC FIFO: %d %s words\n\n", tmp, 692 (reg & AD_DS_RAMC_ADST) ? "stereo" : "mono"); 693 694 snd_iprintf(buffer, "Resampler input: %s\n", 695 reg & AD_DS_RAMC_REEN ? "enabled" : "disabled"); 696 697 /* RERQ is at offset 12 */ 698 tmp = (reg & AD_DS_RAMC_RERQ) ? 699 ((((reg & AD_DS_RAMC_RERQ) >> 12) & 0x01) ? 12 : 18) : 4; 700 tmp /= (reg & AD_DS_RAMC_ADST) ? 2 : 1; 701 702 snd_iprintf(buffer, "Resampler FIFO: %d %s words\n\n", tmp, 703 (reg & AD_DS_WSMC_WAST) ? "stereo" : "mono"); 704 705 706 /* doc says LSB represents -1.5dB, but the max value (-94.5dB) 707 suggests that LSB is -3dB, which is more coherent with the logarithmic 708 nature of the dB scale */ 709 reg = ad1889_readw(chip, AD_DS_WADA); 710 snd_iprintf(buffer, "Left: %s, -%d dB\n", 711 (reg & AD_DS_WADA_LWAM) ? "mute" : "unmute", 712 ((reg & AD_DS_WADA_LWAA) >> 8) * 3); 713 reg = ad1889_readw(chip, AD_DS_WADA); 714 snd_iprintf(buffer, "Right: %s, -%d dB\n", 715 (reg & AD_DS_WADA_RWAM) ? "mute" : "unmute", 716 (reg & AD_DS_WADA_RWAA) * 3); 717 718 reg = ad1889_readw(chip, AD_DS_WAS); 719 snd_iprintf(buffer, "Wave samplerate: %u Hz\n", reg); 720 reg = ad1889_readw(chip, AD_DS_RES); 721 snd_iprintf(buffer, "Resampler samplerate: %u Hz\n", reg); 722 } 723 724 static void 725 snd_ad1889_proc_init(struct snd_ad1889 *chip) 726 { 727 snd_card_ro_proc_new(chip->card, chip->card->driver, 728 chip, snd_ad1889_proc_read); 729 } 730 731 static const struct ac97_quirk ac97_quirks[] = { 732 { 733 .subvendor = 0x11d4, /* AD */ 734 .subdevice = 0x1889, /* AD1889 */ 735 .codec_id = AC97_ID_AD1819, 736 .name = "AD1889", 737 .type = AC97_TUNE_HP_ONLY 738 }, 739 { } /* terminator */ 740 }; 741 742 static void 743 snd_ad1889_ac97_xinit(struct snd_ad1889 *chip) 744 { 745 u16 reg; 746 747 reg = ad1889_readw(chip, AD_AC97_ACIC); 748 reg |= AD_AC97_ACIC_ACRD; /* Reset Disable */ 749 ad1889_writew(chip, AD_AC97_ACIC, reg); 750 ad1889_readw(chip, AD_AC97_ACIC); /* flush posted write */ 751 udelay(10); 752 /* Interface Enable */ 753 reg |= AD_AC97_ACIC_ACIE; 754 ad1889_writew(chip, AD_AC97_ACIC, reg); 755 756 snd_ad1889_ac97_ready(chip); 757 758 /* Audio Stream Output | Variable Sample Rate Mode */ 759 reg = ad1889_readw(chip, AD_AC97_ACIC); 760 reg |= AD_AC97_ACIC_ASOE | AD_AC97_ACIC_VSRM; 761 ad1889_writew(chip, AD_AC97_ACIC, reg); 762 ad1889_readw(chip, AD_AC97_ACIC); /* flush posted write */ 763 764 } 765 766 static void 767 snd_ad1889_ac97_bus_free(struct snd_ac97_bus *bus) 768 { 769 struct snd_ad1889 *chip = bus->private_data; 770 chip->ac97_bus = NULL; 771 } 772 773 static void 774 snd_ad1889_ac97_free(struct snd_ac97 *ac97) 775 { 776 struct snd_ad1889 *chip = ac97->private_data; 777 chip->ac97 = NULL; 778 } 779 780 static int 781 snd_ad1889_ac97_init(struct snd_ad1889 *chip, const char *quirk_override) 782 { 783 int err; 784 struct snd_ac97_template ac97; 785 static struct snd_ac97_bus_ops ops = { 786 .write = snd_ad1889_ac97_write, 787 .read = snd_ad1889_ac97_read, 788 }; 789 790 /* doing that here, it works. */ 791 snd_ad1889_ac97_xinit(chip); 792 793 err = snd_ac97_bus(chip->card, 0, &ops, chip, &chip->ac97_bus); 794 if (err < 0) 795 return err; 796 797 chip->ac97_bus->private_free = snd_ad1889_ac97_bus_free; 798 799 memset(&ac97, 0, sizeof(ac97)); 800 ac97.private_data = chip; 801 ac97.private_free = snd_ad1889_ac97_free; 802 ac97.pci = chip->pci; 803 804 err = snd_ac97_mixer(chip->ac97_bus, &ac97, &chip->ac97); 805 if (err < 0) 806 return err; 807 808 snd_ac97_tune_hardware(chip->ac97, ac97_quirks, quirk_override); 809 810 return 0; 811 } 812 813 static int 814 snd_ad1889_free(struct snd_ad1889 *chip) 815 { 816 if (chip->irq < 0) 817 goto skip_hw; 818 819 spin_lock_irq(&chip->lock); 820 821 ad1889_mute(chip); 822 823 /* Turn off interrupt on count and zero DMA registers */ 824 ad1889_channel_reset(chip, AD_CHAN_WAV | AD_CHAN_ADC); 825 826 /* clear DISR. If we don't, we'd better jump off the Eiffel Tower */ 827 ad1889_writel(chip, AD_DMA_DISR, AD_DMA_DISR_PTAI | AD_DMA_DISR_PMAI); 828 ad1889_readl(chip, AD_DMA_DISR); /* flush, dammit! */ 829 830 spin_unlock_irq(&chip->lock); 831 832 if (chip->irq >= 0) 833 free_irq(chip->irq, chip); 834 835 skip_hw: 836 iounmap(chip->iobase); 837 pci_release_regions(chip->pci); 838 pci_disable_device(chip->pci); 839 kfree(chip); 840 return 0; 841 } 842 843 static int 844 snd_ad1889_dev_free(struct snd_device *device) 845 { 846 struct snd_ad1889 *chip = device->device_data; 847 return snd_ad1889_free(chip); 848 } 849 850 static int 851 snd_ad1889_init(struct snd_ad1889 *chip) 852 { 853 ad1889_writew(chip, AD_DS_CCS, AD_DS_CCS_CLKEN); /* turn on clock */ 854 ad1889_readw(chip, AD_DS_CCS); /* flush posted write */ 855 856 usleep_range(10000, 11000); 857 858 /* enable Master and Target abort interrupts */ 859 ad1889_writel(chip, AD_DMA_DISR, AD_DMA_DISR_PMAE | AD_DMA_DISR_PTAE); 860 861 return 0; 862 } 863 864 static int 865 snd_ad1889_create(struct snd_card *card, 866 struct pci_dev *pci, 867 struct snd_ad1889 **rchip) 868 { 869 int err; 870 871 struct snd_ad1889 *chip; 872 static struct snd_device_ops ops = { 873 .dev_free = snd_ad1889_dev_free, 874 }; 875 876 *rchip = NULL; 877 878 if ((err = pci_enable_device(pci)) < 0) 879 return err; 880 881 /* check PCI availability (32bit DMA) */ 882 if (dma_set_mask(&pci->dev, DMA_BIT_MASK(32)) < 0 || 883 dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(32)) < 0) { 884 dev_err(card->dev, "error setting 32-bit DMA mask.\n"); 885 pci_disable_device(pci); 886 return -ENXIO; 887 } 888 889 /* allocate chip specific data with zero-filled memory */ 890 if ((chip = kzalloc(sizeof(*chip), GFP_KERNEL)) == NULL) { 891 pci_disable_device(pci); 892 return -ENOMEM; 893 } 894 895 chip->card = card; 896 card->private_data = chip; 897 chip->pci = pci; 898 chip->irq = -1; 899 900 /* (1) PCI resource allocation */ 901 if ((err = pci_request_regions(pci, card->driver)) < 0) 902 goto free_and_ret; 903 904 chip->bar = pci_resource_start(pci, 0); 905 chip->iobase = pci_ioremap_bar(pci, 0); 906 if (chip->iobase == NULL) { 907 dev_err(card->dev, "unable to reserve region.\n"); 908 err = -EBUSY; 909 goto free_and_ret; 910 } 911 912 pci_set_master(pci); 913 914 spin_lock_init(&chip->lock); /* only now can we call ad1889_free */ 915 916 if (request_irq(pci->irq, snd_ad1889_interrupt, 917 IRQF_SHARED, KBUILD_MODNAME, chip)) { 918 dev_err(card->dev, "cannot obtain IRQ %d\n", pci->irq); 919 snd_ad1889_free(chip); 920 return -EBUSY; 921 } 922 923 chip->irq = pci->irq; 924 synchronize_irq(chip->irq); 925 926 /* (2) initialization of the chip hardware */ 927 if ((err = snd_ad1889_init(chip)) < 0) { 928 snd_ad1889_free(chip); 929 return err; 930 } 931 932 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { 933 snd_ad1889_free(chip); 934 return err; 935 } 936 937 *rchip = chip; 938 939 return 0; 940 941 free_and_ret: 942 kfree(chip); 943 pci_disable_device(pci); 944 945 return err; 946 } 947 948 static int 949 snd_ad1889_probe(struct pci_dev *pci, 950 const struct pci_device_id *pci_id) 951 { 952 int err; 953 static int devno; 954 struct snd_card *card; 955 struct snd_ad1889 *chip; 956 957 /* (1) */ 958 if (devno >= SNDRV_CARDS) 959 return -ENODEV; 960 if (!enable[devno]) { 961 devno++; 962 return -ENOENT; 963 } 964 965 /* (2) */ 966 err = snd_card_new(&pci->dev, index[devno], id[devno], THIS_MODULE, 967 0, &card); 968 /* XXX REVISIT: we can probably allocate chip in this call */ 969 if (err < 0) 970 return err; 971 972 strcpy(card->driver, "AD1889"); 973 strcpy(card->shortname, "Analog Devices AD1889"); 974 975 /* (3) */ 976 err = snd_ad1889_create(card, pci, &chip); 977 if (err < 0) 978 goto free_and_ret; 979 980 /* (4) */ 981 sprintf(card->longname, "%s at 0x%lx irq %i", 982 card->shortname, chip->bar, chip->irq); 983 984 /* (5) */ 985 /* register AC97 mixer */ 986 err = snd_ad1889_ac97_init(chip, ac97_quirk[devno]); 987 if (err < 0) 988 goto free_and_ret; 989 990 err = snd_ad1889_pcm_init(chip, 0); 991 if (err < 0) 992 goto free_and_ret; 993 994 /* register proc interface */ 995 snd_ad1889_proc_init(chip); 996 997 /* (6) */ 998 err = snd_card_register(card); 999 if (err < 0) 1000 goto free_and_ret; 1001 1002 /* (7) */ 1003 pci_set_drvdata(pci, card); 1004 1005 devno++; 1006 return 0; 1007 1008 free_and_ret: 1009 snd_card_free(card); 1010 return err; 1011 } 1012 1013 static void 1014 snd_ad1889_remove(struct pci_dev *pci) 1015 { 1016 snd_card_free(pci_get_drvdata(pci)); 1017 } 1018 1019 static const struct pci_device_id snd_ad1889_ids[] = { 1020 { PCI_DEVICE(PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS) }, 1021 { 0, }, 1022 }; 1023 MODULE_DEVICE_TABLE(pci, snd_ad1889_ids); 1024 1025 static struct pci_driver ad1889_pci_driver = { 1026 .name = KBUILD_MODNAME, 1027 .id_table = snd_ad1889_ids, 1028 .probe = snd_ad1889_probe, 1029 .remove = snd_ad1889_remove, 1030 }; 1031 1032 module_pci_driver(ad1889_pci_driver); 1033