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 *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 *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
 621         switch (cmd)
 622         {
 623         case OSS_GETVERSION:
 624                 return put_user(SOUND_VERSION, (int *)arg);
 625
 626         case SNDCTL_DSP_RESET:
 627                 break;
 628
 629         case SNDCTL_DSP_SYNC:
 630                 break;
 631
 632         case SNDCTL_DSP_SPEED:
 633                 /* set sampling rate */
 634                 if (get_user(val, (int *)arg))
 635                         return -EFAULT;
 636                 if (val > 5400 && val < 48000)
 637                 {
 638                         if (file->f_mode & FMODE_WRITE)
 639                                 AD1889_WRITEW(ad1889_dev, AD_DSWAS, val);
 640                         if (file->f_mode & FMODE_READ)
 641                                 AD1889_WRITEW(ad1889_dev, AD_DSRES, val);
 642                 }
 643                 return 0;
 644
 645         case SNDCTL_DSP_STEREO: /* undocumented? */
 646                 if (get_user(val, (int *)arg))
 647                         return -EFAULT;
 648                 if (file->f_mode & FMODE_READ) {
 649                         val = AD1889_READW(ad1889_dev, AD_DSWSMC);
 650                         if (val) {
 651                                 val |= 0x0200;  /* set WAST */
 652                         } else {
 653                                 val &= ~0x0200; /* clear WAST */
 654                         }
 655                         AD1889_WRITEW(ad1889_dev, AD_DSWSMC, val);
 656                 }
 657                 if (file->f_mode & FMODE_WRITE) {
 658                         val = AD1889_READW(ad1889_dev, AD_DSRAMC);
 659                         if (val) {
 660                                 val |= 0x0002;  /* set ADST */
 661                         } else {
 662                                 val &= ~0x0002; /* clear ADST */
 663                         }
 664                         AD1889_WRITEW(ad1889_dev, AD_DSRAMC, val);
 665                 }
 666
 667                 return 0;
 668
 669         case SNDCTL_DSP_GETBLKSIZE:
 670                 return put_user(DMA_SIZE, (int *)arg);
 671
 672         case SNDCTL_DSP_GETFMTS:
 673                 return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
 674
 675         case SNDCTL_DSP_SETFMT:
 676                 if (get_user(val, (int *)arg))
 677                         return -EFAULT;
 678
 679                 if (file->f_mode & FMODE_READ)
 680                         ad1889_set_adc_fmt(dev, val);
 681
 682                 if (file->f_mode & FMODE_WRITE)
 683                         ad1889_set_wav_fmt(dev, val);
 684
 685                 return put_user(val, (int *)arg);
 686
 687         case SNDCTL_DSP_CHANNELS:
 688                 break;
 689
 690         case SNDCTL_DSP_POST:
 691                 /* send all data to device */
 692                 break;
 693
 694         case SNDCTL_DSP_SUBDIVIDE:
 695                 break;
 696
 697         case SNDCTL_DSP_SETFRAGMENT:
 698                 /* not supported; uses fixed fragment sizes */
 699                 return put_user(DMA_SIZE, (int *)arg);
 700
 701         case SNDCTL_DSP_GETOSPACE:
 702         case SNDCTL_DSP_GETISPACE:
 703                 /* space left in dma buffers */
 704                 if (cmd == SNDCTL_DSP_GETOSPACE)
 705                         dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
 706                 else
 707                         dmabuf = &dev->state[AD_ADC_STATE].dmabuf;
 708                 abinfo.fragments = 1;
 709                 abinfo.fragstotal = 1;
 710                 abinfo.fragsize = DMA_SIZE;
 711                 abinfo.bytes = DMA_SIZE;
 712                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 713         case SNDCTL_DSP_NONBLOCK:
 714                 file->f_flags |= O_NONBLOCK;
 715                 return 0;
 716
 717         case SNDCTL_DSP_GETCAPS:
 718                 return put_user(0, (int *)arg);
 719
 720         case SNDCTL_DSP_GETTRIGGER:
 721         case SNDCTL_DSP_SETTRIGGER:
 722                 break;
 723
 724         case SNDCTL_DSP_GETIPTR:
 725         case SNDCTL_DSP_GETOPTR:
 726                 break;
 727
 728         case SNDCTL_DSP_SETDUPLEX:
 729                 break;
 730
 731         case SNDCTL_DSP_GETODELAY:
 732                 break;
 733
 734         case SOUND_PCM_READ_RATE:
 735                 return put_user(AD1889_READW(ad1889_dev, AD_DSWAS), (int *)arg);
 736
 737         case SOUND_PCM_READ_CHANNELS:
 738         case SOUND_PCM_READ_BITS:
 739                 break;
 740
 741         case SNDCTL_DSP_MAPINBUF:
 742         case SNDCTL_DSP_MAPOUTBUF:
 743         case SNDCTL_DSP_SETSYNCRO:
 744         case SOUND_PCM_WRITE_FILTER:
 745         case SOUND_PCM_READ_FILTER:
 746                 break;
 747
 748         default:
 749                 break;
 750         }
 751
 752         return -ENOTTY;
 753 }
 754
 755 static int ad1889_open(struct inode *inode, struct file *file)
 756 {
 757         /* check minor; only support /dev/dsp atm */
 758         if (iminor(inode) != 3)
 759                 return -ENXIO;
 760
 761         file->private_data = ad1889_dev;
 762
 763         ad1889_set_wav_rate(ad1889_dev, 44100);
 764         ad1889_set_wav_fmt(ad1889_dev, AFMT_S16_LE);
 765         AD1889_WRITEW(ad1889_dev, AD_DSWADA, 0x0404); /* attenuation */
 766         return 0;
 767 }
 768
 769 static int ad1889_release(struct inode *inode, struct file *file)
 770 {
 771         /* if we have state free it here */
 772         return 0;
 773 }
 774
 775 static struct file_operations ad1889_fops = {
 776         .owner          = THIS_MODULE,
 777         .llseek         = no_llseek,
 778         .read           = ad1889_read,
 779         .write          = ad1889_write,
 780         .poll           = ad1889_poll,
 781         .ioctl          = ad1889_ioctl,
 782         .mmap           = ad1889_mmap,
 783         .open           = ad1889_open,
 784         .release        = ad1889_release,
 785 };
 786
 787 /************************* /dev/mixer interfaces ************************ */
 788 static int ad1889_mixer_open(struct inode *inode, struct file *file)
 789 {
 790         if (ad1889_dev->ac97_codec->dev_mixer != iminor(inode))
 791                 return -ENODEV;
 792
 793         file->private_data = ad1889_dev->ac97_codec;
 794         return 0;
 795 }
 796
 797 static int ad1889_mixer_release(struct inode *inode, struct file *file)
 798 {
 799         return 0;
 800 }
 801
 802 static int ad1889_mixer_ioctl(struct inode *inode, struct file *file,
 803         unsigned int cmd, unsigned long arg)
 804 {
 805         struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
 806         return codec->mixer_ioctl(codec, cmd, arg);
 807 }
 808
 809 static struct file_operations ad1889_mixer_fops = {
 810         .owner          = THIS_MODULE,
 811         .llseek         = no_llseek,
 812         .ioctl          = ad1889_mixer_ioctl,
 813         .open           = ad1889_mixer_open,
 814         .release        = ad1889_mixer_release,
 815 };
 816
 817 /************************* AC97 interfaces ****************************** */
 818 static void ad1889_codec_write(struct ac97_codec *ac97, u8 reg, u16 val)
 819 {
 820         ad1889_dev_t *dev = ac97->private_data;
 821
 822         //DBG("Writing 0x%x to 0x%lx\n", val, dev->regbase + 0x100 + reg);
 823         AD1889_WRITEW(dev, 0x100 + reg, val);
 824 }
 825
 826 static u16 ad1889_codec_read(struct ac97_codec *ac97, u8 reg)
 827 {
 828         ad1889_dev_t *dev = ac97->private_data;
 829         //DBG("Reading from 0x%lx\n", dev->regbase + 0x100 + reg);
 830         return AD1889_READW(dev, 0x100 + reg);
 831 }
 832
 833 static int ad1889_ac97_init(ad1889_dev_t *dev, int id)
 834 {
 835         struct ac97_codec *ac97;
 836         u16 eid;
 837
 838         if ((ac97 = ac97_alloc_codec()) == NULL)
 839                 return -ENOMEM;
 840
 841         ac97->private_data = dev;
 842         ac97->id = id;
 843
 844         ac97->codec_read = ad1889_codec_read;
 845         ac97->codec_write = ad1889_codec_write;
 846
 847         if (ac97_probe_codec(ac97) == 0) {
 848                 printk(DEVNAME ": ac97_probe_codec failed\n");
 849                 goto out_free;
 850         }
 851
 852         eid = ad1889_codec_read(ac97, AC97_EXTENDED_ID);
 853         if (eid == 0xffffff) {
 854                 printk(KERN_WARNING DEVNAME ": no codec attached?\n");
 855                 goto out_free;
 856         }
 857
 858         dev->ac97_features = eid;
 859
 860         if ((ac97->dev_mixer = register_sound_mixer(&ad1889_mixer_fops, -1)) < 0) {
 861                 printk(KERN_ERR DEVNAME ": cannot register mixer\n");
 862                 goto out_free;
 863         }
 864
 865         dev->ac97_codec = ac97;
 866         return 0;
 867
 868 out_free:
 869         ac97_release_codec(ac97);
 870         return -ENODEV;
 871 }
 872
 873 static int ad1889_aclink_reset(struct pci_dev * pcidev)
 874 {
 875         u16 stat;
 876         int retry = 200;
 877         ad1889_dev_t *dev = pci_get_drvdata(pcidev);
 878
 879         AD1889_WRITEW(dev, AD_DSCCS, 0x8000); /* turn on clock */
 880         AD1889_READW(dev, AD_DSCCS);
 881
 882         WAIT_10MS();
 883
 884         stat = AD1889_READW(dev, AD_ACIC);
 885         stat |= 0x0002;                         /* Reset Disable */
 886         AD1889_WRITEW(dev, AD_ACIC, stat);
 887         (void) AD1889_READW(dev, AD_ACIC);      /* flush posted write */
 888
 889         udelay(10);
 890
 891         stat = AD1889_READW(dev, AD_ACIC);
 892         stat |= 0x0001;                         /* Interface Enable */
 893         AD1889_WRITEW(dev, AD_ACIC, stat);
 894
 895         do {
 896                 if (AD1889_READW(dev, AD_ACIC) & 0x8000)        /* Ready */
 897                         break;
 898                 WAIT_10MS();
 899                 retry--;
 900         } while (retry > 0);
 901
 902         if (!retry) {
 903                 printk(KERN_ERR "ad1889_aclink_reset: codec is not ready [0x%x]\n",
 904                             AD1889_READW(dev, AD_ACIC));
 905                 return -EBUSY;
 906         }
 907
 908         /* TODO reset AC97 codec */
 909         /* TODO set wave/adc pci ctrl status */
 910
 911         stat = AD1889_READW(dev, AD_ACIC);
 912         stat |= 0x0004;                         /* Audio Stream Output Enable */
 913         AD1889_WRITEW(dev, AD_ACIC, stat);
 914         return 0;
 915 }
 916
 917 /************************* PCI interfaces ****************************** */
 918 /* PCI device table */
 919 static struct pci_device_id ad1889_id_tbl[] = {
 920         { PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS, PCI_ANY_ID,
 921           PCI_ANY_ID, 0, 0, (unsigned long)DEVNAME },
 922         { },
 923 };
 924 MODULE_DEVICE_TABLE(pci, ad1889_id_tbl);
 925
 926 static irqreturn_t ad1889_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 927 {
 928         u32 stat;
 929         ad1889_dev_t *dev = (ad1889_dev_t *)dev_id;
 930
 931         stat = AD1889_READL(dev, AD_DMADISR);
 932
 933         /* clear ISR */
 934         AD1889_WRITEL(dev, AD_DMADISR, stat);
 935
 936         if (stat & 0x8) {               /* WAVI */
 937                 DBG("WAV interrupt\n");
 938                 dev->stats.wav_intrs++;
 939                 if (dev->state[AD_WAV_STATE].dmabuf.ready) {
 940                         ad1889_stop_wav(&dev->state[AD_WAV_STATE]);     /* clean up */
 941                         ad1889_start_wav(&dev->state[AD_WAV_STATE]);    /* start new */
 942                 }
 943
 944         }
 945
 946         if ((stat & 0x2) && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */
 947                 DBG("ADC interrupt\n");
 948                 dev->stats.adc_intrs++;
 949         }
 950         if(stat)
 951                 return IRQ_HANDLED;
 952         return IRQ_NONE;
 953 }
 954
 955 static void ad1889_initcfg(ad1889_dev_t *dev)
 956 {
 957         u16 tmp;
 958
 959         /* make sure the interrupt bits are setup the way we want */
 960         tmp = AD1889_READW(dev, AD_DMAWAVCTRL);
 961         tmp &= ~0x00ff; /* flat dma, no sg, mask out the intr bits */
 962         tmp |= 0x0004;  /* intr on count, loop */
 963         AD1889_WRITEW(dev, AD_DMAWAVCTRL, tmp);
 964
 965         /* unmute... */
 966         tmp = AD1889_READW(dev, AD_DSWADA);
 967         tmp &= ~0x8080;
 968         AD1889_WRITEW(dev, AD_DSWADA, tmp);
 969 }
 970
 971 static int __devinit ad1889_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
 972 {
 973         int err;
 974         ad1889_dev_t *dev;
 975         unsigned long bar;
 976         struct proc_dir_entry *proc_root = NULL;
 977
 978         if ((err = pci_enable_device(pcidev)) != 0) {
 979                 printk(KERN_ERR DEVNAME ": pci_enable_device failed\n");
 980                 return err;
 981         }
 982
 983         pci_set_master(pcidev);
 984         if ((dev = ad1889_alloc_dev(pcidev)) == NULL) {
 985                 printk(KERN_ERR DEVNAME ": cannot allocate memory for device\n");
 986                 return -ENOMEM;
 987         }
 988         pci_set_drvdata(pcidev, dev);
 989         bar = pci_resource_start(pcidev, 0);
 990
 991         if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) {
 992                 printk(KERN_ERR DEVNAME ": memory region not assigned\n");
 993                 goto err_free_mem;
 994         }
 995
 996         if (request_irq(pcidev->irq, ad1889_interrupt, SA_SHIRQ, DEVNAME, dev) != 0) {
 997                 printk(KERN_ERR DEVNAME ": unable to request interrupt\n");
 998                 goto err_free_mem;
 999         }
1000
1001         request_mem_region(bar, AD_DSIOMEMSIZE, DEVNAME);
1002         dev->regbase = (unsigned long)ioremap_nocache(bar, AD_DSIOMEMSIZE);
1003
1004         printk(KERN_INFO DEVNAME ": %s at 0x%lx IRQ %d\n",
1005                 (char *)ent->driver_data, dev->regbase, pcidev->irq);
1006
1007         if (ad1889_aclink_reset(pcidev) != 0)
1008                 goto err_free_mem;
1009
1010         /* register /dev/dsp */
1011         if ((dev->dev_audio = register_sound_dsp(&ad1889_fops, -1)) < 0) {
1012                 printk(KERN_ERR DEVNAME ": cannot register /dev/dsp\n");
1013                 goto err_free_irq;
1014         }
1015
1016         if ((err = ad1889_ac97_init(dev, 0)) != 0)
1017                 goto err_free_dsp;
1018
1019         if (((proc_root = proc_mkdir("driver/ad1889", 0)) == NULL) ||
1020             create_proc_read_entry("ac97", S_IFREG|S_IRUGO, proc_root, ac97_read_proc, dev->ac97_codec) == NULL ||
1021             create_proc_read_entry("info", S_IFREG|S_IRUGO, proc_root, ad1889_read_proc, dev) == NULL)
1022                 goto err_free_dsp;
1023
1024         ad1889_initcfg(dev);
1025
1026         //DBG(DEVNAME ": Driver initialization done!\n");
1027
1028         ad1889_dev = dev;
1029
1030         return 0;
1031
1032 err_free_dsp:
1033         unregister_sound_dsp(dev->dev_audio);
1034
1035 err_free_irq:
1036         free_irq(pcidev->irq, dev);
1037
1038 err_free_mem:
1039         ad1889_free_dev(dev);
1040         pci_set_drvdata(pcidev, 0);
1041
1042         return -ENODEV;
1043 }
1044
1045 static void __devexit ad1889_remove(struct pci_dev *pcidev)
1046 {
1047         ad1889_dev_t *dev = pci_get_drvdata(pcidev);
1048
1049         if (dev == NULL) return;
1050
1051         unregister_sound_mixer(dev->ac97_codec->dev_mixer);
1052         unregister_sound_dsp(dev->dev_audio);
1053         free_irq(pcidev->irq, dev);
1054         release_mem_region(dev->regbase, AD_DSIOMEMSIZE);
1055
1056         /* any hw programming needed? */
1057         ad1889_free_dev(dev);
1058 }
1059
1060 MODULE_AUTHOR("Randolph Chung");
1061 MODULE_DESCRIPTION("Analog Devices AD1889 PCI Audio");
1062 MODULE_LICENSE("GPL");
1063
1064 static struct pci_driver ad1889_driver = {
1065         .name           = DEVNAME,
1066         .id_table       = ad1889_id_tbl,
1067         .probe          = ad1889_probe,
1068         .remove         = __devexit_p(ad1889_remove),
1069 };
1070
1071 static int __init ad1889_init_module(void)
1072 {
1073         return pci_module_init(&ad1889_driver);
1074 }
1075
1076 static void ad1889_exit_module(void)
1077 {
1078         pci_unregister_driver(&ad1889_driver);
1079         return;
1080 }
1081
1082 module_init(ad1889_init_module);
1083 module_exit(ad1889_exit_module);