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%u)\n",
 358                         dev->state[i].dmabuf.rawbuf,
 359                         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 (minor(inode->i_rdev) != 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         MOD_INC_USE_COUNT;
 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         MOD_DEC_USE_COUNT;
 774         return 0;
 775 }
 776
 777 static struct file_operations ad1889_fops = {
 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 != minor(inode->i_rdev))
 792                 return -ENODEV;
 793
 794         file->private_data = ad1889_dev->ac97_codec;
 795         MOD_INC_USE_COUNT;
 796         return 0;
 797 }
 798
 799 static int ad1889_mixer_release(struct inode *inode, struct file *file)
 800 {
 801         MOD_DEC_USE_COUNT;
 802         return 0;
 803 }
 804
 805 static int ad1889_mixer_ioctl(struct inode *inode, struct file *file,
 806         unsigned int cmd, unsigned long arg)
 807 {
 808         struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
 809         return codec->mixer_ioctl(codec, cmd, arg);
 810 }
 811
 812 static struct file_operations ad1889_mixer_fops = {
 813         llseek:         no_llseek,
 814         ioctl:          ad1889_mixer_ioctl,
 815         open:           ad1889_mixer_open,
 816         release:        ad1889_mixer_release,
 817 };
 818
 819 /************************* AC97 interfaces ****************************** */
 820 static void ad1889_codec_write(struct ac97_codec *ac97, u8 reg, u16 val)
 821 {
 822         ad1889_dev_t *dev = ac97->private_data;
 823
 824         //DBG("Writing 0x%x to 0x%lx\n", val, dev->regbase + 0x100 + reg);
 825         AD1889_WRITEW(dev, 0x100 + reg, val);
 826 }
 827
 828 static u16 ad1889_codec_read(struct ac97_codec *ac97, u8 reg)
 829 {
 830         ad1889_dev_t *dev = ac97->private_data;
 831         //DBG("Reading from 0x%lx\n", dev->regbase + 0x100 + reg);
 832         return AD1889_READW(dev, 0x100 + reg);
 833 }
 834
 835 static int ad1889_ac97_init(ad1889_dev_t *dev, int id)
 836 {
 837         struct ac97_codec *ac97;
 838         u16 eid;
 839
 840         if ((ac97 = ac97_alloc_codec()) == NULL)
 841                 return -ENOMEM;
 842
 843         ac97->private_data = dev;
 844         ac97->id = id;
 845
 846         ac97->codec_read = ad1889_codec_read;
 847         ac97->codec_write = ad1889_codec_write;
 848
 849         if (ac97_probe_codec(ac97) == 0) {
 850                 printk(DEVNAME ": ac97_probe_codec failed\n");
 851                 goto out_free;
 852         }
 853
 854         eid = ad1889_codec_read(ac97, AC97_EXTENDED_ID);
 855         if (eid == 0xffffff) {
 856                 printk(KERN_WARNING DEVNAME ": no codec attached?\n");
 857                 goto out_free;
 858         }
 859
 860         dev->ac97_features = eid;
 861
 862         if ((ac97->dev_mixer = register_sound_mixer(&ad1889_mixer_fops, -1)) < 0) {
 863                 printk(KERN_ERR DEVNAME ": cannot register mixer\n");
 864                 goto out_free;
 865         }
 866
 867         dev->ac97_codec = ac97;
 868         return 0;
 869
 870 out_free:
 871         ac97_release_codec(ac97);
 872         return -ENODEV;
 873 }
 874
 875 static int ad1889_aclink_reset(struct pci_dev * pcidev)
 876 {
 877         u16 stat;
 878         int retry = 200;
 879         ad1889_dev_t *dev = pci_get_drvdata(pcidev);
 880
 881         AD1889_WRITEW(dev, AD_DSCCS, 0x8000); /* turn on clock */
 882         AD1889_READW(dev, AD_DSCCS);
 883
 884         WAIT_10MS();
 885
 886         stat = AD1889_READW(dev, AD_ACIC);
 887         stat |= 0x0002;                         /* Reset Disable */
 888         AD1889_WRITEW(dev, AD_ACIC, stat);
 889         (void) AD1889_READW(dev, AD_ACIC);      /* flush posted write */
 890
 891         udelay(10);
 892
 893         stat = AD1889_READW(dev, AD_ACIC);
 894         stat |= 0x0001;                         /* Interface Enable */
 895         AD1889_WRITEW(dev, AD_ACIC, stat);
 896
 897         do {
 898                 if (AD1889_READW(dev, AD_ACIC) & 0x8000)        /* Ready */
 899                         break;
 900                 WAIT_10MS();
 901                 retry--;
 902         } while (retry > 0);
 903
 904         if (!retry) {
 905                 printk(KERN_ERR "ad1889_aclink_reset: codec is not ready [0x%x]\n",
 906                             AD1889_READW(dev, AD_ACIC));
 907                 return -EBUSY;
 908         }
 909
 910         /* TODO reset AC97 codec */
 911         /* TODO set wave/adc pci ctrl status */
 912
 913         stat = AD1889_READW(dev, AD_ACIC);
 914         stat |= 0x0004;                         /* Audio Stream Output Enable */
 915         AD1889_WRITEW(dev, AD_ACIC, stat);
 916         return 0;
 917 }
 918
 919 /************************* PCI interfaces ****************************** */
 920 /* PCI device table */
 921 static struct pci_device_id ad1889_id_tbl[] = {
 922         { PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS, PCI_ANY_ID,
 923           PCI_ANY_ID, 0, 0, (unsigned long)DEVNAME },
 924         { },
 925 };
 926 MODULE_DEVICE_TABLE(pci, ad1889_id_tbl);
 927
 928 static irqreturn_t ad1889_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 929 {
 930         u32 stat;
 931         ad1889_dev_t *dev = (ad1889_dev_t *)dev_id;
 932
 933         stat = AD1889_READL(dev, AD_DMADISR);
 934
 935         /* clear ISR */
 936         AD1889_WRITEL(dev, AD_DMADISR, stat);
 937
 938         if (stat & 0x8) {               /* WAVI */
 939                 DBG("WAV interrupt\n");
 940                 dev->stats.wav_intrs++;
 941                 if (dev->state[AD_WAV_STATE].dmabuf.ready) {
 942                         ad1889_stop_wav(&dev->state[AD_WAV_STATE]);     /* clean up */
 943                         ad1889_start_wav(&dev->state[AD_WAV_STATE]);    /* start new */
 944                 }
 945
 946         }
 947
 948         if ((stat & 0x2) && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */
 949                 DBG("ADC interrupt\n");
 950                 dev->stats.adc_intrs++;
 951         }
 952         if(stat)
 953                 return IRQ_HANDLED;
 954         return IRQ_NONE;
 955 }
 956
 957 static void ad1889_initcfg(ad1889_dev_t *dev)
 958 {
 959         u16 tmp;
 960
 961         /* make sure the interrupt bits are setup the way we want */
 962         tmp = AD1889_READW(dev, AD_DMAWAVCTRL);
 963         tmp &= ~0x00ff; /* flat dma, no sg, mask out the intr bits */
 964         tmp |= 0x0004;  /* intr on count, loop */
 965         AD1889_WRITEW(dev, AD_DMAWAVCTRL, tmp);
 966
 967         /* unmute... */
 968         tmp = AD1889_READW(dev, AD_DSWADA);
 969         tmp &= ~0x8080;
 970         AD1889_WRITEW(dev, AD_DSWADA, tmp);
 971 }
 972
 973 static int __devinit ad1889_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
 974 {
 975         int err;
 976         ad1889_dev_t *dev;
 977         unsigned long bar;
 978         struct proc_dir_entry *proc_root = NULL;
 979
 980         if ((err = pci_enable_device(pcidev)) != 0) {
 981                 printk(KERN_ERR DEVNAME ": pci_enable_device failed\n");
 982                 return err;
 983         }
 984
 985         pci_set_master(pcidev);
 986         if ((dev = ad1889_alloc_dev(pcidev)) == NULL) {
 987                 printk(KERN_ERR DEVNAME ": cannot allocate memory for device\n");
 988                 return -ENOMEM;
 989         }
 990         pci_set_drvdata(pcidev, dev);
 991         bar = pci_resource_start(pcidev, 0);
 992
 993         if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) {
 994                 printk(KERN_ERR DEVNAME ": memory region not assigned\n");
 995                 goto err_free_mem;
 996         }
 997
 998         if (request_irq(pcidev->irq, ad1889_interrupt, SA_SHIRQ, DEVNAME, dev) != 0) {
 999                 printk(KERN_ERR DEVNAME ": unable to request interrupt\n");
1000                 goto err_free_mem;
1001         }
1002
1003         request_mem_region(bar, AD_DSIOMEMSIZE, DEVNAME);
1004         dev->regbase = (unsigned long)ioremap_nocache(bar, AD_DSIOMEMSIZE);
1005
1006         printk(KERN_INFO DEVNAME ": %s at 0x%lx IRQ %d\n",
1007                 (char *)ent->driver_data, dev->regbase, pcidev->irq);
1008
1009         if (ad1889_aclink_reset(pcidev) != 0)
1010                 goto err_free_mem;
1011
1012         /* register /dev/dsp */
1013         if ((dev->dev_audio = register_sound_dsp(&ad1889_fops, -1)) < 0) {
1014                 printk(KERN_ERR DEVNAME ": cannot register /dev/dsp\n");
1015                 goto err_free_irq;
1016         }
1017
1018         if ((err = ad1889_ac97_init(dev, 0)) != 0)
1019                 goto err_free_dsp;
1020
1021         if (((proc_root = proc_mkdir("driver/ad1889", 0)) == NULL) ||
1022             create_proc_read_entry("ac97", S_IFREG|S_IRUGO, proc_root, ac97_read_proc, dev->ac97_codec) == NULL ||
1023             create_proc_read_entry("info", S_IFREG|S_IRUGO, proc_root, ad1889_read_proc, dev) == NULL)
1024                 goto err_free_dsp;
1025
1026         ad1889_initcfg(dev);
1027
1028         //DBG(DEVNAME ": Driver initialization done!\n");
1029
1030         ad1889_dev = dev;
1031
1032         return 0;
1033
1034 err_free_dsp:
1035         unregister_sound_dsp(dev->dev_audio);
1036
1037 err_free_irq:
1038         free_irq(pcidev->irq, dev);
1039
1040 err_free_mem:
1041         ad1889_free_dev(dev);
1042         pci_set_drvdata(pcidev, 0);
1043
1044         return -ENODEV;
1045 }
1046
1047 static void __devexit ad1889_remove(struct pci_dev *pcidev)
1048 {
1049         ad1889_dev_t *dev = pci_get_drvdata(pcidev);
1050
1051         if (dev == NULL) return;
1052
1053         unregister_sound_mixer(dev->ac97_codec->dev_mixer);
1054         unregister_sound_dsp(dev->dev_audio);
1055         free_irq(pcidev->irq, dev);
1056         release_mem_region(dev->regbase, AD_DSIOMEMSIZE);
1057
1058         /* any hw programming needed? */
1059         ad1889_free_dev(dev);
1060 }
1061
1062 MODULE_AUTHOR("Randolph Chung");
1063 MODULE_DESCRIPTION("Analog Devices AD1889 PCI Audio");
1064 MODULE_LICENSE("GPL");
1065
1066 static struct pci_driver ad1889_driver = {
1067         name:           DEVNAME,
1068         id_table:       ad1889_id_tbl,
1069         probe:          ad1889_probe,
1070         remove:         __devexit_p(ad1889_remove),
1071 };
1072
1073 static int __init ad1889_init_module(void)
1074 {
1075         return pci_module_init(&ad1889_driver);
1076 }
1077
1078 static void ad1889_exit_module(void)
1079 {
1080         pci_unregister_driver(&ad1889_driver);
1081         return;
1082 }
1083
1084 module_init(ad1889_init_module);
1085 module_exit(ad1889_exit_module);