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                 { NULL }
 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         down(&state->sem);
 456 #if 0
 457         if (dmabuf->mapped) {
 458                 ret = -ENXIO;
 459                 goto err1;
 460         }
 461 #endif
 462         if (!access_ok(VERIFY_READ, buffer, count)) {
 463                 ret = -EFAULT;
 464                 goto err1;
 465         }
 466
 467         add_wait_queue(&state->dmabuf.wait, &wait);
 468
 469         /* start filling dma buffer.... */
 470         while (count > 0) {
 471                 long rem;
 472                 long cnt = count;
 473                 unsigned long flags;
 474
 475
 476                 for (;;) {
 477                         long used_bytes;
 478                         long timeout;   /* max time for DMA in jiffies */
 479
 480                         /* buffer is full if wr catches up to rd */
 481                         spin_lock_irqsave(&state->card->lock, flags);
 482                         used_bytes = dmabuf->wr_ptr - dmabuf->rd_ptr;
 483                         timeout = (dmabuf->dma_len * HZ) / dmabuf->rate;
 484                         spin_unlock_irqrestore(&state->card->lock, flags);
 485
 486                         /* adjust for buffer wrap around */
 487                         used_bytes = (used_bytes + DMA_SIZE) & (DMA_SIZE - 1);
 488
 489                         /* If at least one page unused */
 490                         if (used_bytes < (DMA_SIZE - 0x1000))
 491                                 break;
 492
 493                         /* dma buffer full */
 494
 495                         if (file->f_flags & O_NONBLOCK) {
 496                                 ret = -EAGAIN;
 497                                 goto err2;
 498                         }
 499
 500                         set_current_state(TASK_INTERRUPTIBLE);
 501                         if (!schedule_timeout(timeout + 1))
 502                                 printk(KERN_WARNING "AD1889 timeout(%ld) r/w %lx/%lx len %lx\n",
 503                                     timeout+1,
 504                                     dmabuf->rd_ptr, dmabuf->wr_ptr,
 505                                     dmabuf->dma_len);
 506
 507                         if (signal_pending(current)) {
 508                                 ret = -ERESTARTSYS;
 509                                 goto err2;
 510                         }
 511
 512                 }
 513
 514                 /* watch out for wrapping around static buffer */
 515                 spin_lock_irqsave(&state->card->lock, flags);
 516                 rem = DMA_SIZE - dmabuf->wr_ptr;
 517                 if (cnt > rem)
 518                         cnt = rem;
 519
 520                 rem = dmabuf->wr_ptr;
 521
 522                 /* update dma pointers */
 523                 dmabuf->wr_ptr += cnt;
 524                 dmabuf->wr_ptr &= DMA_SIZE - 1; /* wrap ptr if necessary */
 525                 spin_unlock_irqrestore(&state->card->lock, flags);
 526
 527                 /* transfer unwrapped chunk */
 528                 if (copy_from_user(dmabuf->rawbuf + rem, buffer, cnt)) {
 529                         ret = -EFAULT;
 530                         goto err2;
 531                 }
 532
 533                 DBG("Writing 0x%lx bytes to +0x%lx\n", cnt, rem);
 534
 535                 /* update counters */
 536                 count -= cnt;
 537                 buffer += cnt;
 538                 ret += cnt;
 539
 540                 /* we have something to play - go play it! */
 541                 ad1889_trigger_playback(dev);
 542         }
 543
 544 err2:
 545         remove_wait_queue(&state->dmabuf.wait, &wait);
 546 err1:
 547         up(&state->sem);
 548         return ret;
 549 }
 550
 551 static unsigned int ad1889_poll(struct file *file, struct poll_table_struct *wait)
 552 {
 553         unsigned int mask = 0;
 554 #if 0
 555         ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
 556         ad1889_state_t *state = NULL;
 557         struct dmabuf *dmabuf;
 558         unsigned long flags;
 559
 560         if (!(file->f_mode & (FMODE_READ | FMODE_WRITE)))
 561                 return -EINVAL;
 562
 563         if (file->f_mode & FMODE_WRITE) {
 564                 state = &dev->state[AD_WAV_STATE];
 565                 if (!state) return 0;
 566                 dmabuf = &state->dmabuf;
 567                 poll_wait(file, &dmabuf->wait, wait);
 568         }
 569
 570         if (file->f_mode & FMODE_READ) {
 571                 state = &dev->state[AD_ADC_STATE];
 572                 if (!state) return 0;
 573                 dmabuf = &state->dmabuf;
 574                 poll_wait(file, &dmabuf->wait, wait);
 575         }
 576
 577         spin_lock_irqsave(&dev->lock, flags);
 578         ad1889_update_ptr(dev, 0);
 579
 580         if (file->f_mode & FMODE_WRITE) {
 581                 state = &dev->state[WAV_STATE];
 582                 dmabuf = &state->dmabuf;
 583                 if (dmabuf->mapped) {
 584                         if (dmabuf->count >= (int)dmabuf->fragsize)
 585                                 mask |= POLLOUT | POLLWRNORM;
 586                 } else {
 587                         if ((int)dmabuf->dmasize >= dmabuf->count +
 588                                 (int)dmabuf->fragsize)
 589                                 mask |= POLLOUT | POLLWRNORM;
 590                 }
 591         }
 592
 593         if (file ->f_mode & FMODE_READ) {
 594                 state = &dev->state[AD_ADC_STATE];
 595                 dmabuf = &state->dmabuf;
 596                 if (dmabuf->count >= (int)dmabuf->fragsize)
 597                         mask |= POLLIN | POLLRDNORM;
 598         }
 599         spin_unlock_irqrestore(&dev->lock, flags);
 600
 601 #endif
 602         return mask;
 603 }
 604
 605 static int ad1889_mmap(struct file *file, struct vm_area_struct *vma)
 606 {
 607         return 0;
 608 }
 609
 610 static int ad1889_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 611         unsigned long arg)
 612 {
 613         int val = 0;
 614         ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
 615         struct dmabuf *dmabuf;
 616         audio_buf_info abinfo;
 617         int __user *p = (int __user *)arg;
 618
 619         switch (cmd)
 620         {
 621         case OSS_GETVERSION:
 622                 return put_user(SOUND_VERSION, p);
 623
 624         case SNDCTL_DSP_RESET:
 625                 break;
 626
 627         case SNDCTL_DSP_SYNC:
 628                 break;
 629
 630         case SNDCTL_DSP_SPEED:
 631                 /* set sampling rate */
 632                 if (get_user(val, p))
 633                         return -EFAULT;
 634                 if (val > 5400 && val < 48000)
 635                 {
 636                         if (file->f_mode & FMODE_WRITE)
 637                                 AD1889_WRITEW(ad1889_dev, AD_DSWAS, val);
 638                         if (file->f_mode & FMODE_READ)
 639                                 AD1889_WRITEW(ad1889_dev, AD_DSRES, val);
 640                 }
 641                 return 0;
 642
 643         case SNDCTL_DSP_STEREO: /* undocumented? */
 644                 if (get_user(val, p))
 645                         return -EFAULT;
 646                 if (file->f_mode & FMODE_READ) {
 647                         val = AD1889_READW(ad1889_dev, AD_DSWSMC);
 648                         if (val) {
 649                                 val |= 0x0200;  /* set WAST */
 650                         } else {
 651                                 val &= ~0x0200; /* clear WAST */
 652                         }
 653                         AD1889_WRITEW(ad1889_dev, AD_DSWSMC, val);
 654                 }
 655                 if (file->f_mode & FMODE_WRITE) {
 656                         val = AD1889_READW(ad1889_dev, AD_DSRAMC);
 657                         if (val) {
 658                                 val |= 0x0002;  /* set ADST */
 659                         } else {
 660                                 val &= ~0x0002; /* clear ADST */
 661                         }
 662                         AD1889_WRITEW(ad1889_dev, AD_DSRAMC, val);
 663                 }
 664
 665                 return 0;
 666
 667         case SNDCTL_DSP_GETBLKSIZE:
 668                 return put_user(DMA_SIZE, p);
 669
 670         case SNDCTL_DSP_GETFMTS:
 671                 return put_user(AFMT_S16_LE|AFMT_U8, p);
 672
 673         case SNDCTL_DSP_SETFMT:
 674                 if (get_user(val, p))
 675                         return -EFAULT;
 676
 677                 if (file->f_mode & FMODE_READ)
 678                         ad1889_set_adc_fmt(dev, val);
 679
 680                 if (file->f_mode & FMODE_WRITE)
 681                         ad1889_set_wav_fmt(dev, val);
 682
 683                 return put_user(val, p);
 684
 685         case SNDCTL_DSP_CHANNELS:
 686                 break;
 687
 688         case SNDCTL_DSP_POST:
 689                 /* send all data to device */
 690                 break;
 691
 692         case SNDCTL_DSP_SUBDIVIDE:
 693                 break;
 694
 695         case SNDCTL_DSP_SETFRAGMENT:
 696                 /* not supported; uses fixed fragment sizes */
 697                 return put_user(DMA_SIZE, p);
 698
 699         case SNDCTL_DSP_GETOSPACE:
 700         case SNDCTL_DSP_GETISPACE:
 701                 /* space left in dma buffers */
 702                 if (cmd == SNDCTL_DSP_GETOSPACE)
 703                         dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
 704                 else
 705                         dmabuf = &dev->state[AD_ADC_STATE].dmabuf;
 706                 abinfo.fragments = 1;
 707                 abinfo.fragstotal = 1;
 708                 abinfo.fragsize = DMA_SIZE;
 709                 abinfo.bytes = DMA_SIZE;
 710                 return copy_to_user(p, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
 711         case SNDCTL_DSP_NONBLOCK:
 712                 file->f_flags |= O_NONBLOCK;
 713                 return 0;
 714
 715         case SNDCTL_DSP_GETCAPS:
 716                 return put_user(0, p);
 717
 718         case SNDCTL_DSP_GETTRIGGER:
 719         case SNDCTL_DSP_SETTRIGGER:
 720                 break;
 721
 722         case SNDCTL_DSP_GETIPTR:
 723         case SNDCTL_DSP_GETOPTR:
 724                 break;
 725
 726         case SNDCTL_DSP_SETDUPLEX:
 727                 break;
 728
 729         case SNDCTL_DSP_GETODELAY:
 730                 break;
 731
 732         case SOUND_PCM_READ_RATE:
 733                 return put_user(AD1889_READW(ad1889_dev, AD_DSWAS), p);
 734
 735         case SOUND_PCM_READ_CHANNELS:
 736         case SOUND_PCM_READ_BITS:
 737                 break;
 738
 739         case SNDCTL_DSP_MAPINBUF:
 740         case SNDCTL_DSP_MAPOUTBUF:
 741         case SNDCTL_DSP_SETSYNCRO:
 742         case SOUND_PCM_WRITE_FILTER:
 743         case SOUND_PCM_READ_FILTER:
 744                 break;
 745
 746         default:
 747                 break;
 748         }
 749
 750         return -ENOTTY;
 751 }
 752
 753 static int ad1889_open(struct inode *inode, struct file *file)
 754 {
 755         /* check minor; only support /dev/dsp atm */
 756         if (iminor(inode) != 3)
 757                 return -ENXIO;
 758
 759         file->private_data = ad1889_dev;
 760
 761         ad1889_set_wav_rate(ad1889_dev, 44100);
 762         ad1889_set_wav_fmt(ad1889_dev, AFMT_S16_LE);
 763         AD1889_WRITEW(ad1889_dev, AD_DSWADA, 0x0404); /* attenuation */
 764         return nonseekable_open(inode, file);
 765 }
 766
 767 static int ad1889_release(struct inode *inode, struct file *file)
 768 {
 769         /* if we have state free it here */
 770         return 0;
 771 }
 772
 773 static struct file_operations ad1889_fops = {
 774         .owner          = THIS_MODULE,
 775         .llseek         = no_llseek,
 776         .read           = ad1889_read,
 777         .write          = ad1889_write,
 778         .poll           = ad1889_poll,
 779         .ioctl          = ad1889_ioctl,
 780         .mmap           = ad1889_mmap,
 781         .open           = ad1889_open,
 782         .release        = ad1889_release,
 783 };
 784
 785 /************************* /dev/mixer interfaces ************************ */
 786 static int ad1889_mixer_open(struct inode *inode, struct file *file)
 787 {
 788         if (ad1889_dev->ac97_codec->dev_mixer != iminor(inode))
 789                 return -ENODEV;
 790
 791         file->private_data = ad1889_dev->ac97_codec;
 792         return 0;
 793 }
 794
 795 static int ad1889_mixer_release(struct inode *inode, struct file *file)
 796 {
 797         return 0;
 798 }
 799
 800 static int ad1889_mixer_ioctl(struct inode *inode, struct file *file,
 801         unsigned int cmd, unsigned long arg)
 802 {
 803         struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
 804         return codec->mixer_ioctl(codec, cmd, arg);
 805 }
 806
 807 static struct file_operations ad1889_mixer_fops = {
 808         .owner          = THIS_MODULE,
 809         .llseek         = no_llseek,
 810         .ioctl          = ad1889_mixer_ioctl,
 811         .open           = ad1889_mixer_open,
 812         .release        = ad1889_mixer_release,
 813 };
 814
 815 /************************* AC97 interfaces ****************************** */
 816 static void ad1889_codec_write(struct ac97_codec *ac97, u8 reg, u16 val)
 817 {
 818         ad1889_dev_t *dev = ac97->private_data;
 819
 820         //DBG("Writing 0x%x to 0x%lx\n", val, dev->regbase + 0x100 + reg);
 821         AD1889_WRITEW(dev, 0x100 + reg, val);
 822 }
 823
 824 static u16 ad1889_codec_read(struct ac97_codec *ac97, u8 reg)
 825 {
 826         ad1889_dev_t *dev = ac97->private_data;
 827         //DBG("Reading from 0x%lx\n", dev->regbase + 0x100 + reg);
 828         return AD1889_READW(dev, 0x100 + reg);
 829 }
 830
 831 static int ad1889_ac97_init(ad1889_dev_t *dev, int id)
 832 {
 833         struct ac97_codec *ac97;
 834         u16 eid;
 835
 836         if ((ac97 = ac97_alloc_codec()) == NULL)
 837                 return -ENOMEM;
 838
 839         ac97->private_data = dev;
 840         ac97->id = id;
 841
 842         ac97->codec_read = ad1889_codec_read;
 843         ac97->codec_write = ad1889_codec_write;
 844
 845         if (ac97_probe_codec(ac97) == 0) {
 846                 printk(DEVNAME ": ac97_probe_codec failed\n");
 847                 goto out_free;
 848         }
 849
 850         eid = ad1889_codec_read(ac97, AC97_EXTENDED_ID);
 851         if (eid == 0xffff) {
 852                 printk(KERN_WARNING DEVNAME ": no codec attached?\n");
 853                 goto out_free;
 854         }
 855
 856         dev->ac97_features = eid;
 857
 858         if ((ac97->dev_mixer = register_sound_mixer(&ad1889_mixer_fops, -1)) < 0) {
 859                 printk(KERN_ERR DEVNAME ": cannot register mixer\n");
 860                 goto out_free;
 861         }
 862
 863         dev->ac97_codec = ac97;
 864         return 0;
 865
 866 out_free:
 867         ac97_release_codec(ac97);
 868         return -ENODEV;
 869 }
 870
 871 static int ad1889_aclink_reset(struct pci_dev * pcidev)
 872 {
 873         u16 stat;
 874         int retry = 200;
 875         ad1889_dev_t *dev = pci_get_drvdata(pcidev);
 876
 877         AD1889_WRITEW(dev, AD_DSCCS, 0x8000); /* turn on clock */
 878         AD1889_READW(dev, AD_DSCCS);
 879
 880         WAIT_10MS();
 881
 882         stat = AD1889_READW(dev, AD_ACIC);
 883         stat |= 0x0002;                         /* Reset Disable */
 884         AD1889_WRITEW(dev, AD_ACIC, stat);
 885         (void) AD1889_READW(dev, AD_ACIC);      /* flush posted write */
 886
 887         udelay(10);
 888
 889         stat = AD1889_READW(dev, AD_ACIC);
 890         stat |= 0x0001;                         /* Interface Enable */
 891         AD1889_WRITEW(dev, AD_ACIC, stat);
 892
 893         do {
 894                 if (AD1889_READW(dev, AD_ACIC) & 0x8000)        /* Ready */
 895                         break;
 896                 WAIT_10MS();
 897                 retry--;
 898         } while (retry > 0);
 899
 900         if (!retry) {
 901                 printk(KERN_ERR "ad1889_aclink_reset: codec is not ready [0x%x]\n",
 902                             AD1889_READW(dev, AD_ACIC));
 903                 return -EBUSY;
 904         }
 905
 906         /* TODO reset AC97 codec */
 907         /* TODO set wave/adc pci ctrl status */
 908
 909         stat = AD1889_READW(dev, AD_ACIC);
 910         stat |= 0x0004;                         /* Audio Stream Output Enable */
 911         AD1889_WRITEW(dev, AD_ACIC, stat);
 912         return 0;
 913 }
 914
 915 /************************* PCI interfaces ****************************** */
 916 /* PCI device table */
 917 static struct pci_device_id ad1889_id_tbl[] = {
 918         { PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS, PCI_ANY_ID,
 919           PCI_ANY_ID, 0, 0, (unsigned long)DEVNAME },
 920         { },
 921 };
 922 MODULE_DEVICE_TABLE(pci, ad1889_id_tbl);
 923
 924 static irqreturn_t ad1889_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 925 {
 926         u32 stat;
 927         ad1889_dev_t *dev = (ad1889_dev_t *)dev_id;
 928
 929         stat = AD1889_READL(dev, AD_DMADISR);
 930
 931         /* clear ISR */
 932         AD1889_WRITEL(dev, AD_DMADISR, stat);
 933
 934         if (stat & 0x8) {               /* WAVI */
 935                 DBG("WAV interrupt\n");
 936                 dev->stats.wav_intrs++;
 937                 if (dev->state[AD_WAV_STATE].dmabuf.ready) {
 938                         ad1889_stop_wav(&dev->state[AD_WAV_STATE]);     /* clean up */
 939                         ad1889_start_wav(&dev->state[AD_WAV_STATE]);    /* start new */
 940                 }
 941
 942         }
 943
 944         if ((stat & 0x2) && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */
 945                 DBG("ADC interrupt\n");
 946                 dev->stats.adc_intrs++;
 947         }
 948         if(stat)
 949                 return IRQ_HANDLED;
 950         return IRQ_NONE;
 951 }
 952
 953 static void ad1889_initcfg(ad1889_dev_t *dev)
 954 {
 955         u16 tmp;
 956
 957         /* make sure the interrupt bits are setup the way we want */
 958         tmp = AD1889_READW(dev, AD_DMAWAVCTRL);
 959         tmp &= ~0x00ff; /* flat dma, no sg, mask out the intr bits */
 960         tmp |= 0x0004;  /* intr on count, loop */
 961         AD1889_WRITEW(dev, AD_DMAWAVCTRL, tmp);
 962
 963         /* unmute... */
 964         tmp = AD1889_READW(dev, AD_DSWADA);
 965         tmp &= ~0x8080;
 966         AD1889_WRITEW(dev, AD_DSWADA, tmp);
 967 }
 968
 969 static int __devinit ad1889_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
 970 {
 971         int err;
 972         ad1889_dev_t *dev;
 973         unsigned long bar;
 974         struct proc_dir_entry *proc_root = NULL;
 975
 976         if ((err = pci_enable_device(pcidev)) != 0) {
 977                 printk(KERN_ERR DEVNAME ": pci_enable_device failed\n");
 978                 return err;
 979         }
 980
 981         pci_set_master(pcidev);
 982         if ((dev = ad1889_alloc_dev(pcidev)) == NULL) {
 983                 printk(KERN_ERR DEVNAME ": cannot allocate memory for device\n");
 984                 return -ENOMEM;
 985         }
 986         pci_set_drvdata(pcidev, dev);
 987         bar = pci_resource_start(pcidev, 0);
 988
 989         if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) {
 990                 printk(KERN_ERR DEVNAME ": memory region not assigned\n");
 991                 goto err_free_mem;
 992         }
 993
 994         if (request_irq(pcidev->irq, ad1889_interrupt, SA_SHIRQ, DEVNAME, dev) != 0) {
 995                 printk(KERN_ERR DEVNAME ": unable to request interrupt\n");
 996                 goto err_free_mem;
 997         }
 998
 999         request_mem_region(bar, AD_DSIOMEMSIZE, DEVNAME);
1000         dev->regbase = (unsigned long)ioremap_nocache(bar, AD_DSIOMEMSIZE);
1001
1002         printk(KERN_INFO DEVNAME ": %s at 0x%lx IRQ %d\n",
1003                 (char *)ent->driver_data, dev->regbase, pcidev->irq);
1004
1005         if (ad1889_aclink_reset(pcidev) != 0)
1006                 goto err_free_mem;
1007
1008         /* register /dev/dsp */
1009         if ((dev->dev_audio = register_sound_dsp(&ad1889_fops, -1)) < 0) {
1010                 printk(KERN_ERR DEVNAME ": cannot register /dev/dsp\n");
1011                 goto err_free_irq;
1012         }
1013
1014         if ((err = ad1889_ac97_init(dev, 0)) != 0)
1015                 goto err_free_dsp;
1016
1017         if (((proc_root = proc_mkdir("driver/ad1889", NULL)) == NULL) ||
1018             create_proc_read_entry("ac97", S_IFREG|S_IRUGO, proc_root, ac97_read_proc, dev->ac97_codec) == NULL ||
1019             create_proc_read_entry("info", S_IFREG|S_IRUGO, proc_root, ad1889_read_proc, dev) == NULL)
1020                 goto err_free_dsp;
1021
1022         ad1889_initcfg(dev);
1023
1024         //DBG(DEVNAME ": Driver initialization done!\n");
1025
1026         ad1889_dev = dev;
1027
1028         return 0;
1029
1030 err_free_dsp:
1031         unregister_sound_dsp(dev->dev_audio);
1032
1033 err_free_irq:
1034         free_irq(pcidev->irq, dev);
1035
1036 err_free_mem:
1037         ad1889_free_dev(dev);
1038         pci_set_drvdata(pcidev, NULL);
1039
1040         return -ENODEV;
1041 }
1042
1043 static void __devexit ad1889_remove(struct pci_dev *pcidev)
1044 {
1045         ad1889_dev_t *dev = pci_get_drvdata(pcidev);
1046
1047         if (dev == NULL) return;
1048
1049         unregister_sound_mixer(dev->ac97_codec->dev_mixer);
1050         unregister_sound_dsp(dev->dev_audio);
1051         free_irq(pcidev->irq, dev);
1052         release_mem_region(dev->regbase, AD_DSIOMEMSIZE);
1053
1054         /* any hw programming needed? */
1055         ad1889_free_dev(dev);
1056 }
1057
1058 MODULE_AUTHOR("Randolph Chung");
1059 MODULE_DESCRIPTION("Analog Devices AD1889 PCI Audio");
1060 MODULE_LICENSE("GPL");
1061
1062 static struct pci_driver ad1889_driver = {
1063         .name           = DEVNAME,
1064         .id_table       = ad1889_id_tbl,
1065         .probe          = ad1889_probe,
1066         .remove         = __devexit_p(ad1889_remove),
1067 };
1068
1069 static int __init ad1889_init_module(void)
1070 {
1071         return pci_module_init(&ad1889_driver);
1072 }
1073
1074 static void ad1889_exit_module(void)
1075 {
1076         pci_unregister_driver(&ad1889_driver);
1077         return;
1078 }
1079
1080 module_init(ad1889_init_module);
1081 module_exit(ad1889_exit_module);