sound/oss/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/interrupt.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         return dev;
 249
 250 err_free_dmabuf:
 251         while (--i >= 0)
 252                 kfree(dev->state[i].dmabuf.rawbuf);
 253         kfree(dev);
 254         return NULL;
 255 }
 256
 257 static void ad1889_free_dev(ad1889_dev_t *dev)
 258 {
 259         int j;
 260         struct dmabuf *dmabuf;
 261
 262         if (dev == NULL)
 263                 return;
 264
 265         if (dev->ac97_codec)
 266                 ac97_release_codec(dev->ac97_codec);
 267
 268         for (j = 0; j < AD_MAX_STATES; j++) {
 269                 dmabuf = &dev->state[j].dmabuf;
 270                 if (dmabuf->rawbuf != NULL)
 271                         kfree(dmabuf->rawbuf);
 272         }
 273
 274         kfree(dev);
 275 }
 276
 277 static inline void ad1889_trigger_playback(ad1889_dev_t *dev)
 278 {
 279 #if 0
 280         u32 val;
 281         struct dmabuf *dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
 282 #endif
 283
 284         ad1889_start_wav(&dev->state[AD_WAV_STATE]);
 285 }
 286
 287 int ad1889_read_proc (char *page, char **start, off_t off,
 288                       int count, int *eof, void *data)
 289 {
 290         char *out = page;
 291         int len, i;
 292         ad1889_dev_t *dev = data;
 293         ad1889_reg_t regs[] = {
 294                 { "WSMC", AD_DSWSMC, 16 },
 295                 { "RAMC", AD_DSRAMC, 16 },
 296                 { "WADA", AD_DSWADA, 16 },
 297                 { "SYDA", AD_DSSYDA, 16 },
 298                 { "WAS", AD_DSWAS, 16 },
 299                 { "RES", AD_DSRES, 16 },
 300                 { "CCS", AD_DSCCS, 16 },
 301                 { "ADCBA", AD_DMAADCBA, 32 },
 302                 { "ADCCA", AD_DMAADCCA, 32 },
 303                 { "ADCBC", AD_DMAADCBC, 32 },
 304                 { "ADCCC", AD_DMAADCCC, 32 },
 305                 { "ADCIBC", AD_DMAADCIBC, 32 },
 306                 { "ADCICC", AD_DMAADCICC, 32 },
 307                 { "ADCCTRL", AD_DMAADCCTRL, 16 },
 308                 { "WAVBA", AD_DMAWAVBA, 32 },
 309                 { "WAVCA", AD_DMAWAVCA, 32 },
 310                 { "WAVBC", AD_DMAWAVBC, 32 },
 311                 { "WAVCC", AD_DMAWAVCC, 32 },
 312                 { "WAVIBC", AD_DMAWAVIBC, 32 },
 313                 { "WAVICC", AD_DMAWAVICC, 32 },
 314                 { "WAVCTRL", AD_DMAWAVCTRL, 16 },
 315                 { "DISR", AD_DMADISR, 32 },
 316                 { "CHSS", AD_DMACHSS, 32 },
 317                 { "IPC", AD_GPIOIPC, 16 },
 318                 { "OP", AD_GPIOOP, 16 },
 319                 { "IP", AD_GPIOIP, 16 },
 320                 { "ACIC", AD_ACIC, 16 },
 321                 { "AC97_RESET", 0x100 + AC97_RESET, 16 },
 322                 { "AC97_MASTER_VOL_STEREO", 0x100 + AC97_MASTER_VOL_STEREO, 16 },
 323                 { "AC97_HEADPHONE_VOL", 0x100 + AC97_HEADPHONE_VOL, 16 },
 324                 { "AC97_MASTER_VOL_MONO", 0x100 + AC97_MASTER_VOL_MONO, 16 },
 325                 { "AC97_MASTER_TONE", 0x100 + AC97_MASTER_TONE, 16 },
 326                 { "AC97_PCBEEP_VOL", 0x100 + AC97_PCBEEP_VOL, 16 },
 327                 { "AC97_PHONE_VOL", 0x100 + AC97_PHONE_VOL, 16 },
 328                 { "AC97_MIC_VOL", 0x100 + AC97_MIC_VOL, 16 },
 329                 { "AC97_LINEIN_VOL", 0x100 + AC97_LINEIN_VOL, 16 },
 330                 { "AC97_CD_VOL", 0x100 + AC97_CD_VOL, 16 },
 331                 { "AC97_VIDEO_VOL", 0x100 + AC97_VIDEO_VOL, 16 },
 332                 { "AC97_AUX_VOL", 0x100 + AC97_AUX_VOL, 16 },
 333                 { "AC97_PCMOUT_VOL", 0x100 + AC97_PCMOUT_VOL, 16 },
 334                 { "AC97_RECORD_SELECT", 0x100 + AC97_RECORD_SELECT, 16 },
 335                 { "AC97_RECORD_GAIN", 0x100 + AC97_RECORD_GAIN, 16 },
 336                 { "AC97_RECORD_GAIN_MIC", 0x100 + AC97_RECORD_GAIN_MIC, 16 },
 337                 { "AC97_GENERAL_PURPOSE", 0x100 + AC97_GENERAL_PURPOSE, 16 },
 338                 { "AC97_3D_CONTROL", 0x100 + AC97_3D_CONTROL, 16 },
 339                 { "AC97_MODEM_RATE", 0x100 + AC97_MODEM_RATE, 16 },
 340                 { "AC97_POWER_CONTROL", 0x100 + AC97_POWER_CONTROL, 16 },
 341                 { 0 }
 342         };
 343
 344         if (dev == NULL)
 345                 return -ENODEV;
 346
 347         for (i = 0; regs[i].name != 0; i++)
 348                 out += sprintf(out, "%s: 0x%0*x\n", regs[i].name,
 349                         regs[i].width >> 2,
 350                         (regs[i].width == 16
 351                                 ? AD1889_READW(dev, regs[i].offset)
 352                                 : AD1889_READL(dev, regs[i].offset)));
 353
 354         for (i = 0; i < AD_MAX_STATES; i++) {
 355                 out += sprintf(out, "DMA status for %s:\n",
 356                         (i == AD_WAV_STATE ? "WAV" : "ADC"));
 357                 out += sprintf(out, "\t\t0x%p (IOVA: 0x%llu)\n",
 358                         dev->state[i].dmabuf.rawbuf,
 359                         (unsigned long long)dev->state[i].dmabuf.dma_handle);
 360
 361                 out += sprintf(out, "\tread ptr: offset %u\n",
 362                         (unsigned int)dev->state[i].dmabuf.rd_ptr);
 363                 out += sprintf(out, "\twrite ptr: offset %u\n",
 364                         (unsigned int)dev->state[i].dmabuf.wr_ptr);
 365                 out += sprintf(out, "\tdma len: offset %u\n",
 366                         (unsigned int)dev->state[i].dmabuf.dma_len);
 367         }
 368
 369         len = out - page - off;
 370         if (len < count) {
 371                 *eof = 1;
 372                 if (len <= 0) return 0;
 373         } else {
 374                 len = count;
 375         }
 376         *start = page + off;
 377         return len;
 378 }
 379
 380 /***************************** DMA interfaces ************************** */
 381 #if 0
 382 static inline unsigned long ad1889_get_dma_addr(ad1889_state_t *state)
 383 {
 384         struct dmabuf *dmabuf = &state->dmabuf;
 385         u32 offset;
 386
 387         if (!(dmabuf->enable & (DAC_RUNNING | ADC_RUNNING))) {
 388                 printk(KERN_ERR DEVNAME ": get_dma_addr called without dma enabled\n");
 389                 return 0;
 390         }
 391
 392         if (dmabuf->enable & DAC_RUNNING)
 393                 offset = le32_to_cpu(AD1889_READL(state->card, AD_DMAWAVBA));
 394         else
 395                 offset = le32_to_cpu(AD1889_READL(state->card, AD_DMAADCBA));
 396
 397         return (unsigned long)bus_to_virt((unsigned long)offset) - (unsigned long)dmabuf->rawbuf;
 398 }
 399
 400 static void ad1889_update_ptr(ad1889_dev_t *dev, int wake)
 401 {
 402         ad1889_state_t *state;
 403         struct dmabuf *dmabuf;
 404         unsigned long hwptr;
 405         int diff;
 406
 407         /* check ADC first */
 408         state = &dev->adc_state;
 409         dmabuf = &state->dmabuf;
 410         if (dmabuf->enable & ADC_RUNNING) {
 411                 hwptr = ad1889_get_dma_addr(state);
 412                 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
 413
 414                 dmabuf->hwptr = hwptr;
 415                 dmabuf->total_bytes += diff;
 416                 dmabuf->count += diff;
 417                 if (dmabuf->count > dmabuf->dmasize)
 418                         dmabuf->count = dmabuf->dmasize;
 419
 420                 if (dmabuf->mapped) {
 421                         if (wake & dmabuf->count >= dmabuf->fragsize)
 422                                 wake_up(&dmabuf->wait);
 423                 } else {
 424                         if (wake & dmabuf->count > 0)
 425                                 wake_up(&dmabuf->wait);
 426                 }
 427         }
 428
 429         /* check DAC */
 430         state = &dev->wav_state;
 431         dmabuf = &state->dmabuf;
 432         if (dmabuf->enable & DAC_RUNNING) {
 433 XXX
 434
 435 }
 436 #endif
 437
 438 /************************* /dev/dsp interfaces ************************* */
 439
 440 static ssize_t ad1889_read(struct file *file, char __user *buffer, size_t count,
 441         loff_t *ppos)
 442 {
 443         return 0;
 444 }
 445
 446 static ssize_t ad1889_write(struct file *file, const char __user *buffer, size_t count,
 447         loff_t *ppos)
 448 {
 449         ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
 450         ad1889_state_t *state = &dev->state[AD_WAV_STATE];
 451         volatile struct dmabuf *dmabuf = &state->dmabuf;
 452         ssize_t ret = 0;
 453         DECLARE_WAITQUEUE(wait, current);
 454
 455         if (ppos != &file->f_pos)
 456                 return -ESPIPE;
 457
 458         down(&state->sem);
 459 #if 0
 460         if (dmabuf->mapped) {
 461                 ret = -ENXIO;
 462                 goto err1;
 463         }
 464 #endif
 465         if (!access_ok(VERIFY_READ, buffer, count)) {
 466                 ret = -EFAULT;
 467                 goto err1;
 468         }
 469
 470         add_wait_queue(&state->dmabuf.wait, &wait);
 471
 472         /* start filling dma buffer.... */
 473         while (count > 0) {
 474                 long rem;
 475                 long cnt = count;
 476                 unsigned long flags;
 477
 478
 479                 for (;;) {
 480                         long used_bytes;
 481                         long timeout;   /* max time for DMA in jiffies */
 482
 483                         /* buffer is full if wr catches up to rd */
 484                         spin_lock_irqsave(&state->card->lock, flags);
 485                         used_bytes = dmabuf->wr_ptr - dmabuf->rd_ptr;
 486                         timeout = (dmabuf->dma_len * HZ) / dmabuf->rate;
 487                         spin_unlock_irqrestore(&state->card->lock, flags);
 488
 489                         /* adjust for buffer wrap around */
 490                         used_bytes = (used_bytes + DMA_SIZE) & (DMA_SIZE - 1);
 491
 492                         /* If at least one page unused */
 493                         if (used_bytes < (DMA_SIZE - 0x1000))
 494                                 break;
 495
 496                         /* dma buffer full */
 497
 498                         if (file->f_flags & O_NONBLOCK) {
 499                                 ret = -EAGAIN;
 500                                 goto err2;
 501                         }
 502
 503                         set_current_state(TASK_INTERRUPTIBLE);
 504                         if (!schedule_timeout(timeout + 1))
 505                                 printk(KERN_WARNING "AD1889 timeout(%ld) r/w %lx/%lx len %lx\n",
 506                                     timeout+1,
 507                                     dmabuf->rd_ptr, dmabuf->wr_ptr,
 508                                     dmabuf->dma_len);
 509
 510                         if (signal_pending(current)) {
 511                                 ret = -ERESTARTSYS;
 512                                 goto err2;
 513                         }
 514
 515                 }
 516
 517                 /* watch out for wrapping around static buffer */
 518                 spin_lock_irqsave(&state->card->lock, flags);
 519                 rem = DMA_SIZE - dmabuf->wr_ptr;
 520                 if (cnt > rem)
 521                         cnt = rem;
 522
 523                 rem = dmabuf->wr_ptr;
 524
 525                 /* update dma pointers */
 526                 dmabuf->wr_ptr += cnt;
 527                 dmabuf->wr_ptr &= DMA_SIZE - 1; /* wrap ptr if necessary */
 528                 spin_unlock_irqrestore(&state->card->lock, flags);
 529
 530                 /* transfer unwrapped chunk */
 531                 if (copy_from_user(dmabuf->rawbuf + rem, buffer, cnt)) {
 532                         ret = -EFAULT;
 533                         goto err2;
 534                 }
 535
 536                 DBG("Writing 0x%lx bytes to +0x%lx\n", cnt, rem);
 537
 538                 /* update counters */
 539                 count -= cnt;
 540                 buffer += cnt;
 541                 ret += cnt;
 542
 543                 /* we have something to play - go play it! */
 544                 ad1889_trigger_playback(dev);
 545         }
 546
 547 err2:
 548         remove_wait_queue(&state->dmabuf.wait, &wait);
 549 err1:
 550         up(&state->sem);
 551         return ret;
 552 }
 553
 554 static unsigned int ad1889_poll(struct file *file, struct poll_table_struct *wait)
 555 {
 556         unsigned int mask = 0;
 557 #if 0
 558         ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
 559         ad1889_state_t *state = NULL;
 560         struct dmabuf *dmabuf;
 561         unsigned long flags;
 562
 563         if (!(file->f_mode & (FMODE_READ | FMODE_WRITE)))
 564                 return -EINVAL;
 565
 566         if (file->f_mode & FMODE_WRITE) {
 567                 state = &dev->state[AD_WAV_STATE];
 568                 if (!state) return 0;
 569                 dmabuf = &state->dmabuf;
 570                 poll_wait(file, &dmabuf->wait, wait);
 571         }
 572
 573         if (file->f_mode & FMODE_READ) {
 574                 state = &dev->state[AD_ADC_STATE];
 575                 if (!state) return 0;
 576                 dmabuf = &state->dmabuf;
 577                 poll_wait(file, &dmabuf->wait, wait);
 578         }
 579
 580         spin_lock_irqsave(&dev->lock, flags);
 581         ad1889_update_ptr(dev, 0);
 582
 583         if (file->f_mode & FMODE_WRITE) {
 584                 state = &dev->state[WAV_STATE];
 585                 dmabuf = &state->dmabuf;
 586                 if (dmabuf->mapped) {
 587                         if (dmabuf->count >= (int)dmabuf->fragsize)
 588                                 mask |= POLLOUT | POLLWRNORM;
 589                 } else {
 590                         if ((int)dmabuf->dmasize >= dmabuf->count +
 591                                 (int)dmabuf->fragsize)
 592                                 mask |= POLLOUT | POLLWRNORM;
 593                 }
 594         }
 595
 596         if (file ->f_mode & FMODE_READ) {
 597                 state = &dev->state[AD_ADC_STATE];
 598                 dmabuf = &state->dmabuf;
 599                 if (dmabuf->count >= (int)dmabuf->fragsize)
 600                         mask |= POLLIN | POLLRDNORM;
 601         }
 602         spin_unlock_irqrestore(&dev->lock, flags);
 603
 604 #endif
 605         return mask;
 606 }
 607
 608 static int ad1889_mmap(struct file *file, struct vm_area_struct *vma)
 609 {
 610         return 0;
 611 }
 612
 613 static int ad1889_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 614         unsigned long arg)
 615 {
 616         int val = 0;
 617         ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
 618         struct dmabuf *dmabuf;
 619         audio_buf_info abinfo;
 620         int __user *p = (int __user *)arg;
 621
 622         switch (cmd)
 623         {
 624         case OSS_GETVERSION:
 625                 return put_user(SOUND_VERSION, p);
 626
 627         case SNDCTL_DSP_RESET:
 628                 break;
 629
 630         case SNDCTL_DSP_SYNC:
 631                 break;
 632
 633         case SNDCTL_DSP_SPEED:
 634                 /* set sampling rate */
 635                 if (get_user(val, p))
 636                         return -EFAULT;
 637                 if (val > 5400 && val < 48000)
 638                 {
 639                         if (file->f_mode & FMODE_WRITE)
 640                                 AD1889_WRITEW(ad1889_dev, AD_DSWAS, val);
 641                         if (file->f_mode & FMODE_READ)
 642                                 AD1889_WRITEW(ad1889_dev, AD_DSRES, val);
 643                 }
 644                 return 0;
 645
 646         case SNDCTL_DSP_STEREO: /* undocumented? */
 647                 if (get_user(val, p))
 648                         return -EFAULT;
 649                 if (file->f_mode & FMODE_READ) {
 650                         val = AD1889_READW(ad1889_dev, AD_DSWSMC);
 651                         if (val) {
 652                                 val |= 0x0200;  /* set WAST */
 653                         } else {
 654                                 val &= ~0x0200; /* clear WAST */
 655                         }
 656                         AD1889_WRITEW(ad1889_dev, AD_DSWSMC, val);
 657                 }
 658                 if (file->f_mode & FMODE_WRITE) {
 659                         val = AD1889_READW(ad1889_dev, AD_DSRAMC);
 660                         if (val) {
 661                                 val |= 0x0002;  /* set ADST */
 662                         } else {
 663                                 val &= ~0x0002; /* clear ADST */
 664                         }
 665                         AD1889_WRITEW(ad1889_dev, AD_DSRAMC, val);
 666                 }
 667
 668                 return 0;
 669
 670         case SNDCTL_DSP_GETBLKSIZE:
 671                 return put_user(DMA_SIZE, p);
 672
 673         case SNDCTL_DSP_GETFMTS:
 674                 return put_user(AFMT_S16_LE|AFMT_U8, p);
 675
 676         case SNDCTL_DSP_SETFMT:
 677                 if (get_user(val, p))
 678                         return -EFAULT;
 679
 680                 if (file->f_mode & FMODE_READ)
 681                         ad1889_set_adc_fmt(dev, val);
 682
 683                 if (file->f_mode & FMODE_WRITE)
 684                         ad1889_set_wav_fmt(dev, val);
 685
 686                 return put_user(val, p);
 687
 688         case SNDCTL_DSP_CHANNELS:
 689                 break;
 690
 691         case SNDCTL_DSP_POST:
 692                 /* send all data to device */
 693                 break;
 694
 695         case SNDCTL_DSP_SUBDIVIDE:
 696                 break;
 697
 698         case SNDCTL_DSP_SETFRAGMENT:
 699                 /* not supported; uses fixed fragment sizes */
 700                 return put_user(DMA_SIZE, p);
 701
 702         case SNDCTL_DSP_GETOSPACE:
 703         case SNDCTL_DSP_GETISPACE:
 704                 /* space left in dma buffers */
 705                 if (cmd == SNDCTL_DSP_GETOSPACE)
 706                         dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
 707                 else
 708                         dmabuf = &dev->state[AD_ADC_STATE].dmabuf;
 709                 abinfo.fragments = 1;
 710                 abinfo.fragstotal = 1;
 711                 abinfo.fragsize = DMA_SIZE;
 712                 abinfo.bytes = DMA_SIZE;
 713                 return copy_to_user(p, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 714         case SNDCTL_DSP_NONBLOCK:
 715                 file->f_flags |= O_NONBLOCK;
 716                 return 0;
 717
 718         case SNDCTL_DSP_GETCAPS:
 719                 return put_user(0, p);
 720
 721         case SNDCTL_DSP_GETTRIGGER:
 722         case SNDCTL_DSP_SETTRIGGER:
 723                 break;
 724
 725         case SNDCTL_DSP_GETIPTR:
 726         case SNDCTL_DSP_GETOPTR:
 727                 break;
 728
 729         case SNDCTL_DSP_SETDUPLEX:
 730                 break;
 731
 732         case SNDCTL_DSP_GETODELAY:
 733                 break;
 734
 735         case SOUND_PCM_READ_RATE:
 736                 return put_user(AD1889_READW(ad1889_dev, AD_DSWAS), p);
 737
 738         case SOUND_PCM_READ_CHANNELS:
 739         case SOUND_PCM_READ_BITS:
 740                 break;
 741
 742         case SNDCTL_DSP_MAPINBUF:
 743         case SNDCTL_DSP_MAPOUTBUF:
 744         case SNDCTL_DSP_SETSYNCRO:
 745         case SOUND_PCM_WRITE_FILTER:
 746         case SOUND_PCM_READ_FILTER:
 747                 break;
 748
 749         default:
 750                 break;
 751         }
 752
 753         return -ENOTTY;
 754 }
 755
 756 static int ad1889_open(struct inode *inode, struct file *file)
 757 {
 758         /* check minor; only support /dev/dsp atm */
 759         if (iminor(inode) != 3)
 760                 return -ENXIO;
 761
 762         file->private_data = ad1889_dev;
 763
 764         ad1889_set_wav_rate(ad1889_dev, 44100);
 765         ad1889_set_wav_fmt(ad1889_dev, AFMT_S16_LE);
 766         AD1889_WRITEW(ad1889_dev, AD_DSWADA, 0x0404); /* attenuation */
 767         return 0;
 768 }
 769
 770 static int ad1889_release(struct inode *inode, struct file *file)
 771 {
 772         /* if we have state free it here */
 773         return 0;
 774 }
 775
 776 static struct file_operations ad1889_fops = {
 777         .owner          = THIS_MODULE,
 778         .llseek         = no_llseek,
 779         .read           = ad1889_read,
 780         .write          = ad1889_write,
 781         .poll           = ad1889_poll,
 782         .ioctl          = ad1889_ioctl,
 783         .mmap           = ad1889_mmap,
 784         .open           = ad1889_open,
 785         .release        = ad1889_release,
 786 };
 787
 788 /************************* /dev/mixer interfaces ************************ */
 789 static int ad1889_mixer_open(struct inode *inode, struct file *file)
 790 {
 791         if (ad1889_dev->ac97_codec->dev_mixer != iminor(inode))
 792                 return -ENODEV;
 793
 794         file->private_data = ad1889_dev->ac97_codec;
 795         return 0;
 796 }
 797
 798 static int ad1889_mixer_release(struct inode *inode, struct file *file)
 799 {
 800         return 0;
 801 }
 802
 803 static int ad1889_mixer_ioctl(struct inode *inode, struct file *file,
 804         unsigned int cmd, unsigned long arg)
 805 {
 806         struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
 807         return codec->mixer_ioctl(codec, cmd, arg);
 808 }
 809
 810 static struct file_operations ad1889_mixer_fops = {
 811         .owner          = THIS_MODULE,
 812         .llseek         = no_llseek,
 813         .ioctl          = ad1889_mixer_ioctl,
 814         .open           = ad1889_mixer_open,
 815         .release        = ad1889_mixer_release,
 816 };
 817
 818 /************************* AC97 interfaces ****************************** */
 819 static void ad1889_codec_write(struct ac97_codec *ac97, u8 reg, u16 val)
 820 {
 821         ad1889_dev_t *dev = ac97->private_data;
 822
 823         //DBG("Writing 0x%x to 0x%lx\n", val, dev->regbase + 0x100 + reg);
 824         AD1889_WRITEW(dev, 0x100 + reg, val);
 825 }
 826
 827 static u16 ad1889_codec_read(struct ac97_codec *ac97, u8 reg)
 828 {
 829         ad1889_dev_t *dev = ac97->private_data;
 830         //DBG("Reading from 0x%lx\n", dev->regbase + 0x100 + reg);
 831         return AD1889_READW(dev, 0x100 + reg);
 832 }
 833
 834 static int ad1889_ac97_init(ad1889_dev_t *dev, int id)
 835 {
 836         struct ac97_codec *ac97;
 837         u16 eid;
 838
 839         if ((ac97 = ac97_alloc_codec()) == NULL)
 840                 return -ENOMEM;
 841
 842         ac97->private_data = dev;
 843         ac97->id = id;
 844
 845         ac97->codec_read = ad1889_codec_read;
 846         ac97->codec_write = ad1889_codec_write;
 847
 848         if (ac97_probe_codec(ac97) == 0) {
 849                 printk(DEVNAME ": ac97_probe_codec failed\n");
 850                 goto out_free;
 851         }
 852
 853         eid = ad1889_codec_read(ac97, AC97_EXTENDED_ID);
 854         if (eid == 0xffffff) {
 855                 printk(KERN_WARNING DEVNAME ": no codec attached?\n");
 856                 goto out_free;
 857         }
 858
 859         dev->ac97_features = eid;
 860
 861         if ((ac97->dev_mixer = register_sound_mixer(&ad1889_mixer_fops, -1)) < 0) {
 862                 printk(KERN_ERR DEVNAME ": cannot register mixer\n");
 863                 goto out_free;
 864         }
 865
 866         dev->ac97_codec = ac97;
 867         return 0;
 868
 869 out_free:
 870         ac97_release_codec(ac97);
 871         return -ENODEV;
 872 }
 873
 874 static int ad1889_aclink_reset(struct pci_dev * pcidev)
 875 {
 876         u16 stat;
 877         int retry = 200;
 878         ad1889_dev_t *dev = pci_get_drvdata(pcidev);
 879
 880         AD1889_WRITEW(dev, AD_DSCCS, 0x8000); /* turn on clock */
 881         AD1889_READW(dev, AD_DSCCS);
 882
 883         WAIT_10MS();
 884
 885         stat = AD1889_READW(dev, AD_ACIC);
 886         stat |= 0x0002;                         /* Reset Disable */
 887         AD1889_WRITEW(dev, AD_ACIC, stat);
 888         (void) AD1889_READW(dev, AD_ACIC);      /* flush posted write */
 889
 890         udelay(10);
 891
 892         stat = AD1889_READW(dev, AD_ACIC);
 893         stat |= 0x0001;                         /* Interface Enable */
 894         AD1889_WRITEW(dev, AD_ACIC, stat);
 895
 896         do {
 897                 if (AD1889_READW(dev, AD_ACIC) & 0x8000)        /* Ready */
 898                         break;
 899                 WAIT_10MS();
 900                 retry--;
 901         } while (retry > 0);
 902
 903         if (!retry) {
 904                 printk(KERN_ERR "ad1889_aclink_reset: codec is not ready [0x%x]\n",
 905                             AD1889_READW(dev, AD_ACIC));
 906                 return -EBUSY;
 907         }
 908
 909         /* TODO reset AC97 codec */
 910         /* TODO set wave/adc pci ctrl status */
 911
 912         stat = AD1889_READW(dev, AD_ACIC);
 913         stat |= 0x0004;                         /* Audio Stream Output Enable */
 914         AD1889_WRITEW(dev, AD_ACIC, stat);
 915         return 0;
 916 }
 917
 918 /************************* PCI interfaces ****************************** */
 919 /* PCI device table */
 920 static struct pci_device_id ad1889_id_tbl[] = {
 921         { PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS, PCI_ANY_ID,
 922           PCI_ANY_ID, 0, 0, (unsigned long)DEVNAME },
 923         { },
 924 };
 925 MODULE_DEVICE_TABLE(pci, ad1889_id_tbl);
 926
 927 static irqreturn_t ad1889_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 928 {
 929         u32 stat;
 930         ad1889_dev_t *dev = (ad1889_dev_t *)dev_id;
 931
 932         stat = AD1889_READL(dev, AD_DMADISR);
 933
 934         /* clear ISR */
 935         AD1889_WRITEL(dev, AD_DMADISR, stat);
 936
 937         if (stat & 0x8) {               /* WAVI */
 938                 DBG("WAV interrupt\n");
 939                 dev->stats.wav_intrs++;
 940                 if (dev->state[AD_WAV_STATE].dmabuf.ready) {
 941                         ad1889_stop_wav(&dev->state[AD_WAV_STATE]);     /* clean up */
 942                         ad1889_start_wav(&dev->state[AD_WAV_STATE]);    /* start new */
 943                 }
 944
 945         }
 946
 947         if ((stat & 0x2) && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */
 948                 DBG("ADC interrupt\n");
 949                 dev->stats.adc_intrs++;
 950         }
 951         if(stat)
 952                 return IRQ_HANDLED;
 953         return IRQ_NONE;
 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);