drivers/sound/ad1889.c

   1 /*
   2  *  Copyright 2001 Randolph Chung <tausq@debian.org>
   3  *
   4  *  Analog Devices 1889 PCI audio driver (AD1819 AC97-compatible codec)
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  *   Notes:
  21  *   1. Only flat DMA is supported; s-g is not supported right now
  22  *
  23  *
  24 <jsm> tausq: Anyway, to set up sample rates for D to A, you just use the sample rate on the codec. For A to D, you need to set the codec always to 48K (using the split sample rate feature on the codec) and then set the resampler on the AD1889 to the sample rate you want.
  25 <jsm> Also, when changing the sample rate on the codec you need to power it down and re power it up for the change to take effect!
  26  *
  27  * $Id: ad1889.c,v 1.3 2002/10/19 21:31:44 grundler Exp $
  28  */
  29 #include <linux/config.h>
  30 #include <linux/module.h>
  31 #include <linux/init.h>
  32 #include <linux/ioport.h>
  33 #include <linux/pci.h>
  34 #include <linux/poll.h>
  35 #include <linux/proc_fs.h>
  36 #include <linux/slab.h>
  37 #include <linux/soundcard.h>
  38 #include <linux/ac97_codec.h>
  39 #include <linux/sound.h>
  40 #include <linux/wrapper.h>
  41
  42 #include <asm/delay.h>
  43 #include <asm/io.h>
  44 #include <asm/dma.h>
  45 #include <asm/uaccess.h>
  46
  47 #include "ad1889.h"
  48
  49 #define DBG(fmt, arg...) printk(fmt, ##arg)
  50 #define DEVNAME "ad1889"
  51
  52 #define NR_HW_CH        4
  53 #define DAC_RUNNING     1
  54 #define ADC_RUNNING     2
  55
  56 #define UNDERRUN(dev)   (0)
  57
  58 #define AD1889_READW(dev,reg) readw(dev->regbase + reg)
  59 #define AD1889_WRITEW(dev,reg,val) writew((val), dev->regbase + reg)
  60 #define AD1889_READL(dev,reg) readl(dev->regbase + reg)
  61 #define AD1889_WRITEL(dev,reg,val) writel((val), dev->regbase + reg)
  62
  63 //now 100ms
  64 #define WAIT_10MS()     do { int __i; for (__i = 0; __i < 100; __i++) udelay(1000); } while(0)
  65
  66 /* currently only support a single device */
  67 static ad1889_dev_t *ad1889_dev = NULL;
  68
  69 /************************* helper routines ***************************** */
  70 static inline void ad1889_set_wav_rate(ad1889_dev_t *dev, int rate)
  71 {
  72         dev->state[AD_WAV_STATE].dmabuf.rate = rate;
  73         AD1889_WRITEW(dev, AD_DSWAS, rate);
  74 }
  75
  76 static inline void ad1889_set_adc_rate(ad1889_dev_t *dev, int rate)
  77 {
  78         dev->state[AD_ADC_STATE].dmabuf.rate = rate;
  79         AD1889_WRITEW(dev, AD_DSRES, rate);
  80 }
  81
  82 static inline void ad1889_set_wav_fmt(ad1889_dev_t *dev, int fmt)
  83 {
  84         u16 tmp;
  85
  86         tmp = AD1889_READW(ad1889_dev, AD_DSWSMC);
  87         if (fmt == AFMT_S16_LE) {
  88                 //tmp |= 0x0100; /* set WA16 */
  89                 tmp |= 0x0300; /* set WA16 stereo */
  90         } else if (fmt == AFMT_U8) {
  91                 tmp &= ~0x0100; /* clear WA16 */
  92         }
  93         AD1889_WRITEW(ad1889_dev, AD_DSWSMC, tmp);
  94 }
  95
  96 static inline void ad1889_set_adc_fmt(ad1889_dev_t *dev, int fmt)
  97 {
  98         u16 tmp;
  99
 100         tmp = AD1889_READW(ad1889_dev, AD_DSRAMC);
 101         if (fmt == AFMT_S16_LE) {
 102                 tmp |= 0x0100; /* set WA16 */
 103         } else if (fmt == AFMT_U8) {
 104                 tmp &= ~0x0100; /* clear WA16 */
 105         }
 106         AD1889_WRITEW(ad1889_dev, AD_DSRAMC, tmp);
 107 }
 108
 109 static void ad1889_start_wav(ad1889_state_t *state)
 110 {
 111         unsigned long flags;
 112         struct dmabuf *dmabuf = &state->dmabuf;
 113         int cnt;
 114         u16 tmp;
 115
 116         spin_lock_irqsave(&state->card->lock, flags);
 117
 118         if (dmabuf->dma_len)    /* DMA already in flight */
 119                 goto skip_dma;
 120
 121         /* setup dma */
 122         cnt = dmabuf->wr_ptr - dmabuf->rd_ptr;
 123         if (cnt == 0)           /* done - don't need to do anything */
 124                 goto skip_dma;
 125
 126         /* If the wr_ptr has wrapped, only map to the end */
 127         if (cnt < 0)
 128                 cnt = DMA_SIZE - dmabuf->rd_ptr;
 129
 130         dmabuf->dma_handle = pci_map_single(ad1889_dev->pci,
 131                                         dmabuf->rawbuf + dmabuf->rd_ptr,
 132                                         cnt, PCI_DMA_TODEVICE);
 133         dmabuf->dma_len = cnt;
 134         dmabuf->ready = 1;
 135
 136         /* load up the current register set */
 137         AD1889_WRITEL(ad1889_dev, AD_DMAWAVCC, cnt);
 138         AD1889_WRITEL(ad1889_dev, AD_DMAWAVICC, cnt);
 139         AD1889_WRITEL(ad1889_dev, AD_DMAWAVCA, dmabuf->dma_handle);
 140
 141         /* TODO: for now we load the base registers with the same thing */
 142         AD1889_WRITEL(ad1889_dev, AD_DMAWAVBC, cnt);
 143         AD1889_WRITEL(ad1889_dev, AD_DMAWAVIBC, cnt);
 144         AD1889_WRITEL(ad1889_dev, AD_DMAWAVBA, dmabuf->dma_handle);
 145
 146         /* and we're off to the races... */
 147         AD1889_WRITEL(ad1889_dev, AD_DMACHSS, 0x8);
 148         tmp = AD1889_READW(ad1889_dev, AD_DSWSMC);
 149         tmp |= 0x0400; /* set WAEN */
 150         AD1889_WRITEW(ad1889_dev, AD_DSWSMC, tmp);
 151         (void) AD1889_READW(ad1889_dev, AD_DSWSMC); /* flush posted PCI write */
 152
 153         dmabuf->enable |= DAC_RUNNING;
 154
 155 skip_dma:
 156         spin_unlock_irqrestore(&state->card->lock, flags);
 157 }
 158
 159
 160 static void ad1889_stop_wav(ad1889_state_t *state)
 161 {
 162         unsigned long flags;
 163         struct dmabuf *dmabuf = &state->dmabuf;
 164
 165         spin_lock_irqsave(&state->card->lock, flags);
 166
 167         if (dmabuf->enable & DAC_RUNNING) {
 168                 u16 tmp;
 169                 unsigned long cnt = dmabuf->dma_len;
 170
 171                 tmp = AD1889_READW(ad1889_dev, AD_DSWSMC);
 172                 tmp &= ~0x0400; /* clear WAEN */
 173                 AD1889_WRITEW(ad1889_dev, AD_DSWSMC, tmp);
 174                 (void) AD1889_READW(ad1889_dev, AD_DSWSMC); /* flush posted PCI write */
 175                 pci_unmap_single(ad1889_dev->pci, dmabuf->dma_handle,
 176                                 cnt, PCI_DMA_TODEVICE);
 177
 178                 dmabuf->enable &= ~DAC_RUNNING;
 179
 180                 /* update dma pointers */
 181                 dmabuf->rd_ptr += cnt;
 182                 dmabuf->rd_ptr &= (DMA_SIZE - 1);
 183
 184                 dmabuf->dma_handle = 0;
 185                 dmabuf->dma_len = 0;
 186                 dmabuf->ready = 0;
 187
 188                 wake_up(&dmabuf->wait);
 189         }
 190
 191         spin_unlock_irqrestore(&state->card->lock, flags);
 192 }
 193
 194
 195 #if 0
 196 static void ad1889_startstop_adc(ad1889_state_t *state, int start)
 197 {
 198         u16 tmp;
 199         unsigned long flags;
 200
 201         spin_lock_irqsave(&state->card->lock, flags);
 202
 203         tmp = AD1889_READW(ad1889_dev, AD_DSRAMC);
 204         if (start) {
 205                 state->dmabuf.enable |= ADC_RUNNING;
 206                 tmp |= 0x0004; /* set ADEN */
 207         } else {
 208                 state->dmabuf.enable &= ~ADC_RUNNING;
 209                 tmp &= ~0x0004; /* clear ADEN */
 210         }
 211         AD1889_WRITEW(ad1889_dev, AD_DSRAMC, tmp);
 212
 213         spin_unlock_irqrestore(&state->card->lock, flags);
 214 }
 215 #endif
 216
 217 static ad1889_dev_t *ad1889_alloc_dev(struct pci_dev *pci)
 218 {
 219         ad1889_dev_t *dev;
 220         struct dmabuf *dmabuf;
 221         int i;
 222
 223         if ((dev = kmalloc(sizeof(ad1889_dev_t), GFP_KERNEL)) == NULL)
 224                 return NULL;
 225         memset(dev, 0, sizeof(ad1889_dev_t));
 226         spin_lock_init(&dev->lock);
 227         dev->pci = pci;
 228
 229         for (i = 0; i < AD_MAX_STATES; i++) {
 230                 dev->state[i].card = dev;
 231                 init_MUTEX(&dev->state[i].sem);
 232                 init_waitqueue_head(&dev->state[i].dmabuf.wait);
 233         }
 234
 235         /* allocate dma buffer */
 236
 237         for (i = 0; i < AD_MAX_STATES; i++) {
 238                 dmabuf = &dev->state[i].dmabuf;
 239                 dmabuf->rawbuf = kmalloc(DMA_SIZE, GFP_KERNEL|GFP_DMA);
 240                 if (!dmabuf->rawbuf)
 241                         goto err_free_dmabuf;
 242                 dmabuf->rawbuf_size = DMA_SIZE;
 243                 dmabuf->dma_handle = 0;
 244                 dmabuf->rd_ptr = dmabuf->wr_ptr = dmabuf->dma_len = 0UL;
 245                 dmabuf->ready = 0;
 246                 dmabuf->rate = 44100;
 247         }
 248 out:
 249         return dev;
 250
 251 err_free_dmabuf:
 252         while (--i >= 0)
 253                 kfree(dev->state[i].dmabuf.rawbuf);
 254         kfree(dev);
 255         dev = NULL;
 256         goto out;
 257 }
 258
 259 static void ad1889_free_dev(ad1889_dev_t *dev)
 260 {
 261         int j;
 262         struct dmabuf *dmabuf;
 263
 264         if (dev == NULL)
 265                 return;
 266
 267         if (dev->ac97_codec)
 268                 ac97_release_codec(dev->ac97_codec);
 269
 270         for (j = 0; j < AD_MAX_STATES; j++) {
 271                 dmabuf = &dev->state[j].dmabuf;
 272                 if (dmabuf->rawbuf != NULL)
 273                         kfree(dmabuf->rawbuf);
 274         }
 275
 276         kfree(dev);
 277 }
 278
 279 static inline void ad1889_trigger_playback(ad1889_dev_t *dev)
 280 {
 281 #if 0
 282         u32 val;
 283         struct dmabuf *dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
 284 #endif
 285
 286         ad1889_start_wav(&dev->state[AD_WAV_STATE]);
 287 }
 288
 289 int ad1889_read_proc (char *page, char **start, off_t off,
 290                       int count, int *eof, void *data)
 291 {
 292         char *out = page;
 293         int len, i;
 294         ad1889_dev_t *dev = data;
 295         ad1889_reg_t regs[] = {
 296                 { "WSMC", AD_DSWSMC, 16 },
 297                 { "RAMC", AD_DSRAMC, 16 },
 298                 { "WADA", AD_DSWADA, 16 },
 299                 { "SYDA", AD_DSSYDA, 16 },
 300                 { "WAS", AD_DSWAS, 16 },
 301                 { "RES", AD_DSRES, 16 },
 302                 { "CCS", AD_DSCCS, 16 },
 303                 { "ADCBA", AD_DMAADCBA, 32 },
 304                 { "ADCCA", AD_DMAADCCA, 32 },
 305                 { "ADCBC", AD_DMAADCBC, 32 },
 306                 { "ADCCC", AD_DMAADCCC, 32 },
 307                 { "ADCIBC", AD_DMAADCIBC, 32 },
 308                 { "ADCICC", AD_DMAADCICC, 32 },
 309                 { "ADCCTRL", AD_DMAADCCTRL, 16 },
 310                 { "WAVBA", AD_DMAWAVBA, 32 },
 311                 { "WAVCA", AD_DMAWAVCA, 32 },
 312                 { "WAVBC", AD_DMAWAVBC, 32 },
 313                 { "WAVCC", AD_DMAWAVCC, 32 },
 314                 { "WAVIBC", AD_DMAWAVIBC, 32 },
 315                 { "WAVICC", AD_DMAWAVICC, 32 },
 316                 { "WAVCTRL", AD_DMAWAVCTRL, 16 },
 317                 { "DISR", AD_DMADISR, 32 },
 318                 { "CHSS", AD_DMACHSS, 32 },
 319                 { "IPC", AD_GPIOIPC, 16 },
 320                 { "OP", AD_GPIOOP, 16 },
 321                 { "IP", AD_GPIOIP, 16 },
 322                 { "ACIC", AD_ACIC, 16 },
 323                 { "AC97_RESET", 0x100 + AC97_RESET, 16 },
 324                 { "AC97_MASTER_VOL_STEREO", 0x100 + AC97_MASTER_VOL_STEREO, 16 },
 325                 { "AC97_HEADPHONE_VOL", 0x100 + AC97_HEADPHONE_VOL, 16 },
 326                 { "AC97_MASTER_VOL_MONO", 0x100 + AC97_MASTER_VOL_MONO, 16 },
 327                 { "AC97_MASTER_TONE", 0x100 + AC97_MASTER_TONE, 16 },
 328                 { "AC97_PCBEEP_VOL", 0x100 + AC97_PCBEEP_VOL, 16 },
 329                 { "AC97_PHONE_VOL", 0x100 + AC97_PHONE_VOL, 16 },
 330                 { "AC97_MIC_VOL", 0x100 + AC97_MIC_VOL, 16 },
 331                 { "AC97_LINEIN_VOL", 0x100 + AC97_LINEIN_VOL, 16 },
 332                 { "AC97_CD_VOL", 0x100 + AC97_CD_VOL, 16 },
 333                 { "AC97_VIDEO_VOL", 0x100 + AC97_VIDEO_VOL, 16 },
 334                 { "AC97_AUX_VOL", 0x100 + AC97_AUX_VOL, 16 },
 335                 { "AC97_PCMOUT_VOL", 0x100 + AC97_PCMOUT_VOL, 16 },
 336                 { "AC97_RECORD_SELECT", 0x100 + AC97_RECORD_SELECT, 16 },
 337                 { "AC97_RECORD_GAIN", 0x100 + AC97_RECORD_GAIN, 16 },
 338                 { "AC97_RECORD_GAIN_MIC", 0x100 + AC97_RECORD_GAIN_MIC, 16 },
 339                 { "AC97_GENERAL_PURPOSE", 0x100 + AC97_GENERAL_PURPOSE, 16 },
 340                 { "AC97_3D_CONTROL", 0x100 + AC97_3D_CONTROL, 16 },
 341                 { "AC97_MODEM_RATE", 0x100 + AC97_MODEM_RATE, 16 },
 342                 { "AC97_POWER_CONTROL", 0x100 + AC97_POWER_CONTROL, 16 },
 343                 { 0 }
 344         };
 345
 346         if (dev == NULL)
 347                 return -ENODEV;
 348
 349         for (i = 0; regs[i].name != 0; i++)
 350                 out += sprintf(out, "%s: 0x%0*x\n", regs[i].name,
 351                         regs[i].width >> 2,
 352                         (regs[i].width == 16
 353                                 ? AD1889_READW(dev, regs[i].offset)
 354                                 : AD1889_READL(dev, regs[i].offset)));
 355
 356         for (i = 0; i < AD_MAX_STATES; i++) {
 357                 out += sprintf(out, "DMA status for %s:\n",
 358                         (i == AD_WAV_STATE ? "WAV" : "ADC"));
 359                 out += sprintf(out, "\t\t0x%p (IOVA: 0x%u)\n",
 360                         dev->state[i].dmabuf.rawbuf,
 361                         dev->state[i].dmabuf.dma_handle);
 362
 363                 out += sprintf(out, "\tread ptr: offset %u\n",
 364                         (unsigned int)dev->state[i].dmabuf.rd_ptr);
 365                 out += sprintf(out, "\twrite ptr: offset %u\n",
 366                         (unsigned int)dev->state[i].dmabuf.wr_ptr);
 367                 out += sprintf(out, "\tdma len: offset %u\n",
 368                         (unsigned int)dev->state[i].dmabuf.dma_len);
 369         }
 370
 371         len = out - page - off;
 372         if (len < count) {
 373                 *eof = 1;
 374                 if (len <= 0) return 0;
 375         } else {
 376                 len = count;
 377         }
 378         *start = page + off;
 379         return len;
 380 }
 381
 382 /***************************** DMA interfaces ************************** */
 383 #if 0
 384 static inline unsigned long ad1889_get_dma_addr(ad1889_state_t *state)
 385 {
 386         struct dmabuf *dmabuf = &state->dmabuf;
 387         u32 offset;
 388
 389         if (!(dmabuf->enable & (DAC_RUNNING | ADC_RUNNING))) {
 390                 printk(KERN_ERR DEVNAME ": get_dma_addr called without dma enabled\n");
 391                 return 0;
 392         }
 393
 394         if (dmabuf->enable & DAC_RUNNING)
 395                 offset = le32_to_cpu(AD1889_READL(state->card, AD_DMAWAVBA));
 396         else
 397                 offset = le32_to_cpu(AD1889_READL(state->card, AD_DMAADCBA));
 398
 399         return (unsigned long)bus_to_virt((unsigned long)offset) - (unsigned long)dmabuf->rawbuf;
 400 }
 401
 402 static void ad1889_update_ptr(ad1889_dev_t *dev, int wake)
 403 {
 404         ad1889_state_t *state;
 405         struct dmabuf *dmabuf;
 406         unsigned long hwptr;
 407         int diff;
 408
 409         /* check ADC first */
 410         state = &dev->adc_state;
 411         dmabuf = &state->dmabuf;
 412         if (dmabuf->enable & ADC_RUNNING) {
 413                 hwptr = ad1889_get_dma_addr(state);
 414                 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
 415
 416                 dmabuf->hwptr = hwptr;
 417                 dmabuf->total_bytes += diff;
 418                 dmabuf->count += diff;
 419                 if (dmabuf->count > dmabuf->dmasize)
 420                         dmabuf->count = dmabuf->dmasize;
 421
 422                 if (dmabuf->mapped) {
 423                         if (wake & dmabuf->count >= dmabuf->fragsize)
 424                                 wake_up(&dmabuf->wait);
 425                 } else {
 426                         if (wake & dmabuf->count > 0)
 427                                 wake_up(&dmabuf->wait);
 428                 }
 429         }
 430
 431         /* check DAC */
 432         state = &dev->wav_state;
 433         dmabuf = &state->dmabuf;
 434         if (dmabuf->enable & DAC_RUNNING) {
 435 XXX
 436
 437 }
 438 #endif
 439
 440 /************************* /dev/dsp interfaces ************************* */
 441
 442 static ssize_t ad1889_read(struct file *file, char *buffer, size_t count,
 443         loff_t *ppos)
 444 {
 445         return 0;
 446 }
 447
 448 static ssize_t ad1889_write(struct file *file, const char *buffer, size_t count,
 449         loff_t *ppos)
 450 {
 451         ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
 452         ad1889_state_t *state = &dev->state[AD_WAV_STATE];
 453         volatile struct dmabuf *dmabuf = &state->dmabuf;
 454         ssize_t ret = 0;
 455         DECLARE_WAITQUEUE(wait, current);
 456
 457         if (ppos != &file->f_pos)
 458                 return -ESPIPE;
 459
 460         down(&state->sem);
 461 #if 0
 462         if (dmabuf->mapped) {
 463                 ret = -ENXIO;
 464                 goto err1;
 465         }
 466 #endif
 467         if (!access_ok(VERIFY_READ, buffer, count)) {
 468                 ret = -EFAULT;
 469                 goto err1;
 470         }
 471
 472         add_wait_queue(&state->dmabuf.wait, &wait);
 473
 474         /* start filling dma buffer.... */
 475         while (count > 0) {
 476                 long rem;
 477                 long cnt = count;
 478                 unsigned long flags;
 479
 480
 481                 for (;;) {
 482                         long used_bytes;
 483                         long timeout;   /* max time for DMA in jiffies */
 484
 485                         /* buffer is full if wr catches up to rd */
 486                         spin_lock_irqsave(&state->card->lock, flags);
 487                         used_bytes = dmabuf->wr_ptr - dmabuf->rd_ptr;
 488                         timeout = (dmabuf->dma_len * HZ) / dmabuf->rate;
 489                         spin_unlock_irqrestore(&state->card->lock, flags);
 490
 491                         /* adjust for buffer wrap around */
 492                         used_bytes = (used_bytes + DMA_SIZE) & (DMA_SIZE - 1);
 493
 494                         /* If at least one page unused */
 495                         if (used_bytes < (DMA_SIZE - 0x1000))
 496                                 break;
 497
 498                         /* dma buffer full */
 499
 500                         if (file->f_flags & O_NONBLOCK) {
 501                                 ret = -EAGAIN;
 502                                 goto err2;
 503                         }
 504
 505                         set_current_state(TASK_INTERRUPTIBLE);
 506                         if (!schedule_timeout(timeout + 1))
 507                                 printk(KERN_WARNING "AD1889 timeout(%ld) r/w %lx/%lx len %lx\n",
 508                                     timeout+1,
 509                                     dmabuf->rd_ptr, dmabuf->wr_ptr,
 510                                     dmabuf->dma_len);
 511
 512                         if (signal_pending(current)) {
 513                                 ret = -ERESTARTSYS;
 514                                 goto err2;
 515                         }
 516
 517                 }
 518
 519                 /* watch out for wrapping around static buffer */
 520                 spin_lock_irqsave(&state->card->lock, flags);
 521                 rem = DMA_SIZE - dmabuf->wr_ptr;
 522                 if (cnt > rem)
 523                         cnt = rem;
 524
 525                 rem = dmabuf->wr_ptr;
 526
 527                 /* update dma pointers */
 528                 dmabuf->wr_ptr += cnt;
 529                 dmabuf->wr_ptr &= DMA_SIZE - 1; /* wrap ptr if necessary */
 530                 spin_unlock_irqrestore(&state->card->lock, flags);
 531
 532                 /* transfer unwrapped chunk */
 533                 if (copy_from_user(dmabuf->rawbuf + rem, buffer, cnt)) {
 534                         ret = -EFAULT;
 535                         goto err2;
 536                 }
 537
 538                 DBG("Writing 0x%lx bytes to +0x%lx\n", cnt, rem);
 539
 540                 /* update counters */
 541                 count -= cnt;
 542                 buffer += cnt;
 543                 ret += cnt;
 544
 545                 /* we have something to play - go play it! */
 546                 ad1889_trigger_playback(dev);
 547         }
 548
 549 err2:
 550         remove_wait_queue(&state->dmabuf.wait, &wait);
 551 err1:
 552         up(&state->sem);
 553         return ret;
 554 }
 555
 556 static unsigned int ad1889_poll(struct file *file, struct poll_table_struct *wait)
 557 {
 558         unsigned int mask = 0;
 559 #if 0
 560         ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
 561         ad1889_state_t *state = NULL;
 562         struct dmabuf *dmabuf;
 563         unsigned long flags;
 564
 565         if (!(file->f_mode & (FMODE_READ | FMODE_WRITE)))
 566                 return -EINVAL;
 567
 568         if (file->f_mode & FMODE_WRITE) {
 569                 state = &dev->state[AD_WAV_STATE];
 570                 if (!state) return 0;
 571                 dmabuf = &state->dmabuf;
 572                 poll_wait(file, &dmabuf->wait, wait);
 573         }
 574
 575         if (file->f_mode & FMODE_READ) {
 576                 state = &dev->state[AD_ADC_STATE];
 577                 if (!state) return 0;
 578                 dmabuf = &state->dmabuf;
 579                 poll_wait(file, &dmabuf->wait, wait);
 580         }
 581
 582         spin_lock_irqsave(&dev->lock, flags);
 583         ad1889_update_ptr(dev, 0);
 584
 585         if (file->f_mode & FMODE_WRITE) {
 586                 state = &dev->state[WAV_STATE];
 587                 dmabuf = &state->dmabuf;
 588                 if (dmabuf->mapped) {
 589                         if (dmabuf->count >= (int)dmabuf->fragsize)
 590                                 mask |= POLLOUT | POLLWRNORM;
 591                 } else {
 592                         if ((int)dmabuf->dmasize >= dmabuf->count +
 593                                 (int)dmabuf->fragsize)
 594                                 mask |= POLLOUT | POLLWRNORM;
 595                 }
 596         }
 597
 598         if (file ->f_mode & FMODE_READ) {
 599                 state = &dev->state[AD_ADC_STATE];
 600                 dmabuf = &state->dmabuf;
 601                 if (dmabuf->count >= (int)dmabuf->fragsize)
 602                         mask |= POLLIN | POLLRDNORM;
 603         }
 604         spin_unlock_irqrestore(&dev->lock, flags);
 605
 606 #endif
 607         return mask;
 608 }
 609
 610 static int ad1889_mmap(struct file *file, struct vm_area_struct *vma)
 611 {
 612         return 0;
 613 }
 614
 615 static int ad1889_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 616         unsigned long arg)
 617 {
 618         int val = 0;
 619         ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
 620         struct dmabuf *dmabuf;
 621         audio_buf_info abinfo;
 622
 623         switch (cmd)
 624         {
 625         case OSS_GETVERSION:
 626                 return put_user(SOUND_VERSION, (int *)arg);
 627
 628         case SNDCTL_DSP_RESET:
 629                 break;
 630
 631         case SNDCTL_DSP_SYNC:
 632                 break;
 633
 634         case SNDCTL_DSP_SPEED:
 635                 /* set sampling rate */
 636                 if (get_user(val, (int *)arg))
 637                         return -EFAULT;
 638                 if (val > 5400 && val < 48000)
 639                 {
 640                         if (file->f_mode & FMODE_WRITE)
 641                                 AD1889_WRITEW(ad1889_dev, AD_DSWAS, val);
 642                         if (file->f_mode & FMODE_READ)
 643                                 AD1889_WRITEW(ad1889_dev, AD_DSRES, val);
 644                 }
 645                 return 0;
 646
 647         case SNDCTL_DSP_STEREO: /* undocumented? */
 648                 if (get_user(val, (int *)arg))
 649                         return -EFAULT;
 650                 if (file->f_mode & FMODE_READ) {
 651                         val = AD1889_READW(ad1889_dev, AD_DSWSMC);
 652                         if (val) {
 653                                 val |= 0x0200;  /* set WAST */
 654                         } else {
 655                                 val &= ~0x0200; /* clear WAST */
 656                         }
 657                         AD1889_WRITEW(ad1889_dev, AD_DSWSMC, val);
 658                 }
 659                 if (file->f_mode & FMODE_WRITE) {
 660                         val = AD1889_READW(ad1889_dev, AD_DSRAMC);
 661                         if (val) {
 662                                 val |= 0x0002;  /* set ADST */
 663                         } else {
 664                                 val &= ~0x0002; /* clear ADST */
 665                         }
 666                         AD1889_WRITEW(ad1889_dev, AD_DSRAMC, val);
 667                 }
 668
 669                 return 0;
 670
 671         case SNDCTL_DSP_GETBLKSIZE:
 672                 return put_user(DMA_SIZE, (int *)arg);
 673
 674         case SNDCTL_DSP_GETFMTS:
 675                 return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
 676
 677         case SNDCTL_DSP_SETFMT:
 678                 if (get_user(val, (int *)arg))
 679                         return -EFAULT;
 680
 681                 if (file->f_mode & FMODE_READ)
 682                         ad1889_set_adc_fmt(dev, val);
 683
 684                 if (file->f_mode & FMODE_WRITE)
 685                         ad1889_set_wav_fmt(dev, val);
 686
 687                 return put_user(val, (int *)arg);
 688
 689         case SNDCTL_DSP_CHANNELS:
 690                 break;
 691
 692         case SNDCTL_DSP_POST:
 693                 /* send all data to device */
 694                 break;
 695
 696         case SNDCTL_DSP_SUBDIVIDE:
 697                 break;
 698
 699         case SNDCTL_DSP_SETFRAGMENT:
 700                 /* not supported; uses fixed fragment sizes */
 701                 return put_user(DMA_SIZE, (int *)arg);
 702
 703         case SNDCTL_DSP_GETOSPACE:
 704         case SNDCTL_DSP_GETISPACE:
 705                 /* space left in dma buffers */
 706                 if (cmd == SNDCTL_DSP_GETOSPACE)
 707                         dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
 708                 else
 709                         dmabuf = &dev->state[AD_ADC_STATE].dmabuf;
 710                 abinfo.fragments = 1;
 711                 abinfo.fragstotal = 1;
 712                 abinfo.fragsize = DMA_SIZE;
 713                 abinfo.bytes = DMA_SIZE;
 714                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 715         case SNDCTL_DSP_NONBLOCK:
 716                 file->f_flags |= O_NONBLOCK;
 717                 return 0;
 718
 719         case SNDCTL_DSP_GETCAPS:
 720                 return put_user(0, (int *)arg);
 721
 722         case SNDCTL_DSP_GETTRIGGER:
 723         case SNDCTL_DSP_SETTRIGGER:
 724                 break;
 725
 726         case SNDCTL_DSP_GETIPTR:
 727         case SNDCTL_DSP_GETOPTR:
 728                 break;
 729
 730         case SNDCTL_DSP_SETDUPLEX:
 731                 break;
 732
 733         case SNDCTL_DSP_GETODELAY:
 734                 break;
 735
 736         case SOUND_PCM_READ_RATE:
 737                 return put_user(AD1889_READW(ad1889_dev, AD_DSWAS), (int *)arg);
 738
 739         case SOUND_PCM_READ_CHANNELS:
 740         case SOUND_PCM_READ_BITS:
 741                 break;
 742
 743         case SNDCTL_DSP_MAPINBUF:
 744         case SNDCTL_DSP_MAPOUTBUF:
 745         case SNDCTL_DSP_SETSYNCRO:
 746         case SOUND_PCM_WRITE_FILTER:
 747         case SOUND_PCM_READ_FILTER:
 748                 break;
 749
 750         default:
 751                 break;
 752         }
 753
 754         return -ENOTTY;
 755 }
 756
 757 static int ad1889_open(struct inode *inode, struct file *file)
 758 {
 759         /* check minor; only support /dev/dsp atm */
 760         if (MINOR(inode->i_rdev) != 3)
 761                 return -ENXIO;
 762
 763         file->private_data = ad1889_dev;
 764
 765         ad1889_set_wav_rate(ad1889_dev, 44100);
 766         ad1889_set_wav_fmt(ad1889_dev, AFMT_S16_LE);
 767         AD1889_WRITEW(ad1889_dev, AD_DSWADA, 0x0404); /* attenuation */
 768         MOD_INC_USE_COUNT;
 769         return 0;
 770 }
 771
 772 static int ad1889_release(struct inode *inode, struct file *file)
 773 {
 774         /* if we have state free it here */
 775         MOD_DEC_USE_COUNT;
 776         return 0;
 777 }
 778
 779 static struct file_operations ad1889_fops = {
 780         llseek:         no_llseek,
 781         read:           ad1889_read,
 782         write:          ad1889_write,
 783         poll:           ad1889_poll,
 784         ioctl:          ad1889_ioctl,
 785         mmap:           ad1889_mmap,
 786         open:           ad1889_open,
 787         release:        ad1889_release,
 788 };
 789
 790 /************************* /dev/mixer interfaces ************************ */
 791 static int ad1889_mixer_open(struct inode *inode, struct file *file)
 792 {
 793         if (ad1889_dev->ac97_codec->dev_mixer != MINOR(inode->i_rdev))
 794                 return -ENODEV;
 795
 796         file->private_data = ad1889_dev->ac97_codec;
 797         MOD_INC_USE_COUNT;
 798         return 0;
 799 }
 800
 801 static int ad1889_mixer_release(struct inode *inode, struct file *file)
 802 {
 803         MOD_DEC_USE_COUNT;
 804         return 0;
 805 }
 806
 807 static int ad1889_mixer_ioctl(struct inode *inode, struct file *file,
 808         unsigned int cmd, unsigned long arg)
 809 {
 810         struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
 811         return codec->mixer_ioctl(codec, cmd, arg);
 812 }
 813
 814 static struct file_operations ad1889_mixer_fops = {
 815         llseek:         no_llseek,
 816         ioctl:          ad1889_mixer_ioctl,
 817         open:           ad1889_mixer_open,
 818         release:        ad1889_mixer_release,
 819 };
 820
 821 /************************* AC97 interfaces ****************************** */
 822 static void ad1889_codec_write(struct ac97_codec *ac97, u8 reg, u16 val)
 823 {
 824         ad1889_dev_t *dev = ac97->private_data;
 825
 826         //DBG("Writing 0x%x to 0x%lx\n", val, dev->regbase + 0x100 + reg);
 827         AD1889_WRITEW(dev, 0x100 + reg, val);
 828 }
 829
 830 static u16 ad1889_codec_read(struct ac97_codec *ac97, u8 reg)
 831 {
 832         ad1889_dev_t *dev = ac97->private_data;
 833         //DBG("Reading from 0x%lx\n", dev->regbase + 0x100 + reg);
 834         return AD1889_READW(dev, 0x100 + reg);
 835 }
 836
 837 static int ad1889_ac97_init(ad1889_dev_t *dev, int id)
 838 {
 839         struct ac97_codec *ac97;
 840         u16 eid;
 841
 842         if ((ac97 = ac97_alloc_codec()) == NULL)
 843                 return -ENOMEM;
 844
 845         ac97->private_data = dev;
 846         ac97->id = id;
 847
 848         ac97->codec_read = ad1889_codec_read;
 849         ac97->codec_write = ad1889_codec_write;
 850
 851         if (ac97_probe_codec(ac97) == 0) {
 852                 printk(DEVNAME ": ac97_probe_codec failed\n");
 853                 goto out_free;
 854         }
 855
 856         eid = ad1889_codec_read(ac97, AC97_EXTENDED_ID);
 857         if (eid == 0xffffff) {
 858                 printk(KERN_WARNING DEVNAME ": no codec attached?\n");
 859                 goto out_free;
 860         }
 861
 862         dev->ac97_features = eid;
 863
 864         if ((ac97->dev_mixer = register_sound_mixer(&ad1889_mixer_fops, -1)) < 0) {
 865                 printk(KERN_ERR DEVNAME ": cannot register mixer\n");
 866                 goto out_free;
 867         }
 868
 869         dev->ac97_codec = ac97;
 870         return 0;
 871
 872 out_free:
 873         ac97_release_codec(ac97);
 874         return -ENODEV;
 875 }
 876
 877 static int ad1889_aclink_reset(struct pci_dev * pcidev)
 878 {
 879         u16 stat;
 880         int retry = 200;
 881         ad1889_dev_t *dev = pci_get_drvdata(pcidev);
 882
 883         AD1889_WRITEW(dev, AD_DSCCS, 0x8000); /* turn on clock */
 884         AD1889_READW(dev, AD_DSCCS);
 885
 886         WAIT_10MS();
 887
 888         stat = AD1889_READW(dev, AD_ACIC);
 889         stat |= 0x0002;                         /* Reset Disable */
 890         AD1889_WRITEW(dev, AD_ACIC, stat);
 891         (void) AD1889_READW(dev, AD_ACIC);      /* flush posted write */
 892
 893         udelay(10);
 894
 895         stat = AD1889_READW(dev, AD_ACIC);
 896         stat |= 0x0001;                         /* Interface Enable */
 897         AD1889_WRITEW(dev, AD_ACIC, stat);
 898
 899         do {
 900                 if (AD1889_READW(dev, AD_ACIC) & 0x8000)        /* Ready */
 901                         break;
 902                 WAIT_10MS();
 903                 retry--;
 904         } while (retry > 0);
 905
 906         if (!retry) {
 907                 printk(KERN_ERR "ad1889_aclink_reset: codec is not ready [0x%x]\n",
 908                             AD1889_READW(dev, AD_ACIC));
 909                 return -EBUSY;
 910         }
 911
 912         /* TODO reset AC97 codec */
 913         /* TODO set wave/adc pci ctrl status */
 914
 915         stat = AD1889_READW(dev, AD_ACIC);
 916         stat |= 0x0004;                         /* Audio Stream Output Enable */
 917         AD1889_WRITEW(dev, AD_ACIC, stat);
 918         return 0;
 919 }
 920
 921 /************************* PCI interfaces ****************************** */
 922 /* PCI device table */
 923 static struct pci_device_id ad1889_id_tbl[] __devinitdata = {
 924         { PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS, PCI_ANY_ID,
 925           PCI_ANY_ID, 0, 0, (unsigned long)DEVNAME },
 926         { },
 927 };
 928 MODULE_DEVICE_TABLE(pci, ad1889_id_tbl);
 929
 930 static void ad1889_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 931 {
 932         u32 stat;
 933         ad1889_dev_t *dev = (ad1889_dev_t *)dev_id;
 934
 935         stat = AD1889_READL(dev, AD_DMADISR);
 936
 937         /* clear ISR */
 938         AD1889_WRITEL(dev, AD_DMADISR, stat);
 939
 940         if (stat & 0x8) {               /* WAVI */
 941                 DBG("WAV interrupt\n");
 942                 dev->stats.wav_intrs++;
 943                 if (dev->state[AD_WAV_STATE].dmabuf.ready) {
 944                         ad1889_stop_wav(&dev->state[AD_WAV_STATE]);     /* clean up */
 945                         ad1889_start_wav(&dev->state[AD_WAV_STATE]);    /* start new */
 946                 }
 947
 948         }
 949
 950         if (stat & 0x2 && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */
 951                 DBG("ADC interrupt\n");
 952                 dev->stats.adc_intrs++;
 953         }
 954 }
 955
 956 static void ad1889_initcfg(ad1889_dev_t *dev)
 957 {
 958         u16 tmp;
 959
 960         /* make sure the interrupt bits are setup the way we want */
 961         tmp = AD1889_READW(dev, AD_DMAWAVCTRL);
 962         tmp &= ~0x00ff; /* flat dma, no sg, mask out the intr bits */
 963         tmp |= 0x0004;  /* intr on count, loop */
 964         AD1889_WRITEW(dev, AD_DMAWAVCTRL, tmp);
 965
 966         /* unmute... */
 967         tmp = AD1889_READW(dev, AD_DSWADA);
 968         tmp &= ~0x8080;
 969         AD1889_WRITEW(dev, AD_DSWADA, tmp);
 970 }
 971
 972 static int __devinit ad1889_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
 973 {
 974         int err;
 975         ad1889_dev_t *dev;
 976         unsigned long bar;
 977         struct proc_dir_entry *proc_root = NULL;
 978
 979         if ((err = pci_enable_device(pcidev)) != 0) {
 980                 printk(KERN_ERR DEVNAME ": pci_enable_device failed\n");
 981                 return err;
 982         }
 983
 984         pci_set_master(pcidev);
 985         if ((dev = ad1889_alloc_dev(pcidev)) == NULL) {
 986                 printk(KERN_ERR DEVNAME ": cannot allocate memory for device\n");
 987                 return -ENOMEM;
 988         }
 989         pci_set_drvdata(pcidev, dev);
 990         bar = pci_resource_start(pcidev, 0);
 991
 992         if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) {
 993                 printk(KERN_ERR DEVNAME ": memory region not assigned\n");
 994                 goto err_free_mem;
 995         }
 996
 997         if (request_irq(pcidev->irq, ad1889_interrupt, SA_SHIRQ, DEVNAME, dev) != 0) {
 998                 printk(KERN_ERR DEVNAME ": unable to request interrupt\n");
 999                 goto err_free_mem;
1000         }
1001
1002         request_mem_region(bar, AD_DSIOMEMSIZE, DEVNAME);
1003         dev->regbase = (unsigned long)ioremap_nocache(bar, AD_DSIOMEMSIZE);
1004
1005         printk(KERN_INFO DEVNAME ": %s at 0x%lx IRQ %d\n",
1006                 (char *)ent->driver_data, dev->regbase, pcidev->irq);
1007
1008         if (ad1889_aclink_reset(pcidev) != 0)
1009                 goto err_free_mem;
1010
1011         /* register /dev/dsp */
1012         if ((dev->dev_audio = register_sound_dsp(&ad1889_fops, -1)) < 0) {
1013                 printk(KERN_ERR DEVNAME ": cannot register /dev/dsp\n");
1014                 goto err_free_irq;
1015         }
1016
1017         if ((err = ad1889_ac97_init(dev, 0)) != 0)
1018                 goto err_free_dsp;
1019
1020         if (((proc_root = proc_mkdir("driver/ad1889", 0)) == NULL) ||
1021             create_proc_read_entry("ac97", S_IFREG|S_IRUGO, proc_root, ac97_read_proc, dev->ac97_codec) == NULL ||
1022             create_proc_read_entry("info", S_IFREG|S_IRUGO, proc_root, ad1889_read_proc, dev) == NULL)
1023                 goto err_free_dsp;
1024
1025         ad1889_initcfg(dev);
1026
1027         //DBG(DEVNAME ": Driver initialization done!\n");
1028
1029         ad1889_dev = dev;
1030
1031         return 0;
1032
1033 err_free_dsp:
1034         unregister_sound_dsp(dev->dev_audio);
1035
1036 err_free_irq:
1037         free_irq(pcidev->irq, dev);
1038
1039 err_free_mem:
1040         ad1889_free_dev(dev);
1041         pci_set_drvdata(pcidev, 0);
1042
1043         return -ENODEV;
1044 }
1045
1046 static void __devexit ad1889_remove(struct pci_dev *pcidev)
1047 {
1048         ad1889_dev_t *dev = pci_get_drvdata(pcidev);
1049
1050         if (dev == NULL) return;
1051
1052         unregister_sound_mixer(dev->ac97_codec->dev_mixer);
1053         unregister_sound_dsp(dev->dev_audio);
1054         free_irq(pcidev->irq, dev);
1055         release_mem_region(dev->regbase, AD_DSIOMEMSIZE);
1056
1057         /* any hw programming needed? */
1058         ad1889_free_dev(dev);
1059 }
1060
1061 MODULE_AUTHOR("Randolph Chung");
1062 MODULE_DESCRIPTION("Analog Devices AD1889 PCI Audio");
1063 MODULE_LICENSE("GPL");
1064
1065 static struct pci_driver ad1889_driver = {
1066         name:           DEVNAME,
1067         id_table:       ad1889_id_tbl,
1068         probe:          ad1889_probe,
1069         remove:         __devexit_p(ad1889_remove),
1070 };
1071
1072 static int __init ad1889_init_module(void)
1073 {
1074         return pci_module_init(&ad1889_driver);
1075 }
1076
1077 static void ad1889_exit_module(void)
1078 {
1079         pci_unregister_driver(&ad1889_driver);
1080         return;
1081 }
1082
1083 module_init(ad1889_init_module);
1084 module_exit(ad1889_exit_module);