git.oblomov.eu Git - linux-2.6/blob - sound/pci/ad1889.c

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