2 * Copyright 2001 Randolph Chung <tausq@debian.org>
4 * Analog Devices 1889 PCI audio driver (AD1819 AC97-compatible codec)
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.
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.
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.
21 * 1. Only flat DMA is supported; s-g is not supported right now
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!
27 * $Id: ad1889.c,v 1.3 2002/10/19 21:31:44 grundler Exp $
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>
42 #include <asm/delay.h>
45 #include <asm/uaccess.h>
49 #define DBG(fmt, arg...) printk(fmt, ##arg)
50 #define DEVNAME "ad1889"
56 #define UNDERRUN(dev) (0)
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)
64 #define WAIT_10MS() do { int __i; for (__i = 0; __i < 100; __i++) udelay(1000); } while(0)
66 /* currently only support a single device */
67 static ad1889_dev_t *ad1889_dev = NULL;
69 /************************* helper routines ***************************** */
70 static inline void ad1889_set_wav_rate(ad1889_dev_t *dev, int rate)
72 dev->state[AD_WAV_STATE].dmabuf.rate = rate;
73 AD1889_WRITEW(dev, AD_DSWAS, rate);
76 static inline void ad1889_set_adc_rate(ad1889_dev_t *dev, int rate)
78 dev->state[AD_ADC_STATE].dmabuf.rate = rate;
79 AD1889_WRITEW(dev, AD_DSRES, rate);
82 static inline void ad1889_set_wav_fmt(ad1889_dev_t *dev, int fmt)
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 */
93 AD1889_WRITEW(ad1889_dev, AD_DSWSMC, tmp);
96 static inline void ad1889_set_adc_fmt(ad1889_dev_t *dev, int fmt)
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 */
106 AD1889_WRITEW(ad1889_dev, AD_DSRAMC, tmp);
109 static void ad1889_start_wav(ad1889_state_t *state)
112 struct dmabuf *dmabuf = &state->dmabuf;
116 spin_lock_irqsave(&state->card->lock, flags);
118 if (dmabuf->dma_len) /* DMA already in flight */
122 cnt = dmabuf->wr_ptr - dmabuf->rd_ptr;
123 if (cnt == 0) /* done - don't need to do anything */
126 /* If the wr_ptr has wrapped, only map to the end */
128 cnt = DMA_SIZE - dmabuf->rd_ptr;
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;
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);
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);
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 */
153 dmabuf->enable |= DAC_RUNNING;
156 spin_unlock_irqrestore(&state->card->lock, flags);
160 static void ad1889_stop_wav(ad1889_state_t *state)
163 struct dmabuf *dmabuf = &state->dmabuf;
165 spin_lock_irqsave(&state->card->lock, flags);
167 if (dmabuf->enable & DAC_RUNNING) {
169 unsigned long cnt = dmabuf->dma_len;
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);
178 dmabuf->enable &= ~DAC_RUNNING;
180 /* update dma pointers */
181 dmabuf->rd_ptr += cnt;
182 dmabuf->rd_ptr &= (DMA_SIZE - 1);
184 dmabuf->dma_handle = 0;
188 wake_up(&dmabuf->wait);
191 spin_unlock_irqrestore(&state->card->lock, flags);
196 static void ad1889_startstop_adc(ad1889_state_t *state, int start)
201 spin_lock_irqsave(&state->card->lock, flags);
203 tmp = AD1889_READW(ad1889_dev, AD_DSRAMC);
205 state->dmabuf.enable |= ADC_RUNNING;
206 tmp |= 0x0004; /* set ADEN */
208 state->dmabuf.enable &= ~ADC_RUNNING;
209 tmp &= ~0x0004; /* clear ADEN */
211 AD1889_WRITEW(ad1889_dev, AD_DSRAMC, tmp);
213 spin_unlock_irqrestore(&state->card->lock, flags);
217 static ad1889_dev_t *ad1889_alloc_dev(struct pci_dev *pci)
220 struct dmabuf *dmabuf;
223 if ((dev = kmalloc(sizeof(ad1889_dev_t), GFP_KERNEL)) == NULL)
225 memset(dev, 0, sizeof(ad1889_dev_t));
226 spin_lock_init(&dev->lock);
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);
235 /* allocate dma buffer */
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);
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;
246 dmabuf->rate = 44100;
252 kfree(dev->state[i].dmabuf.rawbuf);
257 static void ad1889_free_dev(ad1889_dev_t *dev)
260 struct dmabuf *dmabuf;
266 ac97_release_codec(dev->ac97_codec);
268 for (j = 0; j < AD_MAX_STATES; j++) {
269 dmabuf = &dev->state[j].dmabuf;
270 if (dmabuf->rawbuf != NULL)
271 kfree(dmabuf->rawbuf);
277 static inline void ad1889_trigger_playback(ad1889_dev_t *dev)
281 struct dmabuf *dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
284 ad1889_start_wav(&dev->state[AD_WAV_STATE]);
287 int ad1889_read_proc (char *page, char **start, off_t off,
288 int count, int *eof, void *data)
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 },
347 for (i = 0; regs[i].name != 0; i++)
348 out += sprintf(out, "%s: 0x%0*x\n", regs[i].name,
351 ? AD1889_READW(dev, regs[i].offset)
352 : AD1889_READL(dev, regs[i].offset)));
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);
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);
369 len = out - page - off;
372 if (len <= 0) return 0;
380 /***************************** DMA interfaces ************************** */
382 static inline unsigned long ad1889_get_dma_addr(ad1889_state_t *state)
384 struct dmabuf *dmabuf = &state->dmabuf;
387 if (!(dmabuf->enable & (DAC_RUNNING | ADC_RUNNING))) {
388 printk(KERN_ERR DEVNAME ": get_dma_addr called without dma enabled\n");
392 if (dmabuf->enable & DAC_RUNNING)
393 offset = le32_to_cpu(AD1889_READL(state->card, AD_DMAWAVBA));
395 offset = le32_to_cpu(AD1889_READL(state->card, AD_DMAADCBA));
397 return (unsigned long)bus_to_virt((unsigned long)offset) - (unsigned long)dmabuf->rawbuf;
400 static void ad1889_update_ptr(ad1889_dev_t *dev, int wake)
402 ad1889_state_t *state;
403 struct dmabuf *dmabuf;
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;
414 dmabuf->hwptr = hwptr;
415 dmabuf->total_bytes += diff;
416 dmabuf->count += diff;
417 if (dmabuf->count > dmabuf->dmasize)
418 dmabuf->count = dmabuf->dmasize;
420 if (dmabuf->mapped) {
421 if (wake & dmabuf->count >= dmabuf->fragsize)
422 wake_up(&dmabuf->wait);
424 if (wake & dmabuf->count > 0)
425 wake_up(&dmabuf->wait);
430 state = &dev->wav_state;
431 dmabuf = &state->dmabuf;
432 if (dmabuf->enable & DAC_RUNNING) {
438 /************************* /dev/dsp interfaces ************************* */
440 static ssize_t ad1889_read(struct file *file, char *buffer, size_t count,
446 static ssize_t ad1889_write(struct file *file, const char *buffer, size_t count,
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;
453 DECLARE_WAITQUEUE(wait, current);
455 if (ppos != &file->f_pos)
460 if (dmabuf->mapped) {
465 if (!access_ok(VERIFY_READ, buffer, count)) {
470 add_wait_queue(&state->dmabuf.wait, &wait);
472 /* start filling dma buffer.... */
481 long timeout; /* max time for DMA in jiffies */
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);
489 /* adjust for buffer wrap around */
490 used_bytes = (used_bytes + DMA_SIZE) & (DMA_SIZE - 1);
492 /* If at least one page unused */
493 if (used_bytes < (DMA_SIZE - 0x1000))
496 /* dma buffer full */
498 if (file->f_flags & O_NONBLOCK) {
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",
507 dmabuf->rd_ptr, dmabuf->wr_ptr,
510 if (signal_pending(current)) {
517 /* watch out for wrapping around static buffer */
518 spin_lock_irqsave(&state->card->lock, flags);
519 rem = DMA_SIZE - dmabuf->wr_ptr;
523 rem = dmabuf->wr_ptr;
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);
530 /* transfer unwrapped chunk */
531 if (copy_from_user(dmabuf->rawbuf + rem, buffer, cnt)) {
536 DBG("Writing 0x%lx bytes to +0x%lx\n", cnt, rem);
538 /* update counters */
543 /* we have something to play - go play it! */
544 ad1889_trigger_playback(dev);
548 remove_wait_queue(&state->dmabuf.wait, &wait);
554 static unsigned int ad1889_poll(struct file *file, struct poll_table_struct *wait)
556 unsigned int mask = 0;
558 ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
559 ad1889_state_t *state = NULL;
560 struct dmabuf *dmabuf;
563 if (!(file->f_mode & (FMODE_READ | FMODE_WRITE)))
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);
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);
580 spin_lock_irqsave(&dev->lock, flags);
581 ad1889_update_ptr(dev, 0);
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;
590 if ((int)dmabuf->dmasize >= dmabuf->count +
591 (int)dmabuf->fragsize)
592 mask |= POLLOUT | POLLWRNORM;
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;
602 spin_unlock_irqrestore(&dev->lock, flags);
608 static int ad1889_mmap(struct file *file, struct vm_area_struct *vma)
613 static int ad1889_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
617 ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
618 struct dmabuf *dmabuf;
619 audio_buf_info abinfo;
624 return put_user(SOUND_VERSION, (int *)arg);
626 case SNDCTL_DSP_RESET:
629 case SNDCTL_DSP_SYNC:
632 case SNDCTL_DSP_SPEED:
633 /* set sampling rate */
634 if (get_user(val, (int *)arg))
636 if (val > 5400 && val < 48000)
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);
645 case SNDCTL_DSP_STEREO: /* undocumented? */
646 if (get_user(val, (int *)arg))
648 if (file->f_mode & FMODE_READ) {
649 val = AD1889_READW(ad1889_dev, AD_DSWSMC);
651 val |= 0x0200; /* set WAST */
653 val &= ~0x0200; /* clear WAST */
655 AD1889_WRITEW(ad1889_dev, AD_DSWSMC, val);
657 if (file->f_mode & FMODE_WRITE) {
658 val = AD1889_READW(ad1889_dev, AD_DSRAMC);
660 val |= 0x0002; /* set ADST */
662 val &= ~0x0002; /* clear ADST */
664 AD1889_WRITEW(ad1889_dev, AD_DSRAMC, val);
669 case SNDCTL_DSP_GETBLKSIZE:
670 return put_user(DMA_SIZE, (int *)arg);
672 case SNDCTL_DSP_GETFMTS:
673 return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
675 case SNDCTL_DSP_SETFMT:
676 if (get_user(val, (int *)arg))
679 if (file->f_mode & FMODE_READ)
680 ad1889_set_adc_fmt(dev, val);
682 if (file->f_mode & FMODE_WRITE)
683 ad1889_set_wav_fmt(dev, val);
685 return put_user(val, (int *)arg);
687 case SNDCTL_DSP_CHANNELS:
690 case SNDCTL_DSP_POST:
691 /* send all data to device */
694 case SNDCTL_DSP_SUBDIVIDE:
697 case SNDCTL_DSP_SETFRAGMENT:
698 /* not supported; uses fixed fragment sizes */
699 return put_user(DMA_SIZE, (int *)arg);
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;
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;
717 case SNDCTL_DSP_GETCAPS:
718 return put_user(0, (int *)arg);
720 case SNDCTL_DSP_GETTRIGGER:
721 case SNDCTL_DSP_SETTRIGGER:
724 case SNDCTL_DSP_GETIPTR:
725 case SNDCTL_DSP_GETOPTR:
728 case SNDCTL_DSP_SETDUPLEX:
731 case SNDCTL_DSP_GETODELAY:
734 case SOUND_PCM_READ_RATE:
735 return put_user(AD1889_READW(ad1889_dev, AD_DSWAS), (int *)arg);
737 case SOUND_PCM_READ_CHANNELS:
738 case SOUND_PCM_READ_BITS:
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:
755 static int ad1889_open(struct inode *inode, struct file *file)
757 /* check minor; only support /dev/dsp atm */
758 if (iminor(inode) != 3)
761 file->private_data = ad1889_dev;
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 */
769 static int ad1889_release(struct inode *inode, struct file *file)
771 /* if we have state free it here */
775 static struct file_operations ad1889_fops = {
776 .owner = THIS_MODULE,
779 .write = ad1889_write,
781 .ioctl = ad1889_ioctl,
784 .release = ad1889_release,
787 /************************* /dev/mixer interfaces ************************ */
788 static int ad1889_mixer_open(struct inode *inode, struct file *file)
790 if (ad1889_dev->ac97_codec->dev_mixer != iminor(inode))
793 file->private_data = ad1889_dev->ac97_codec;
797 static int ad1889_mixer_release(struct inode *inode, struct file *file)
802 static int ad1889_mixer_ioctl(struct inode *inode, struct file *file,
803 unsigned int cmd, unsigned long arg)
805 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
806 return codec->mixer_ioctl(codec, cmd, arg);
809 static struct file_operations ad1889_mixer_fops = {
810 .owner = THIS_MODULE,
812 .ioctl = ad1889_mixer_ioctl,
813 .open = ad1889_mixer_open,
814 .release = ad1889_mixer_release,
817 /************************* AC97 interfaces ****************************** */
818 static void ad1889_codec_write(struct ac97_codec *ac97, u8 reg, u16 val)
820 ad1889_dev_t *dev = ac97->private_data;
822 //DBG("Writing 0x%x to 0x%lx\n", val, dev->regbase + 0x100 + reg);
823 AD1889_WRITEW(dev, 0x100 + reg, val);
826 static u16 ad1889_codec_read(struct ac97_codec *ac97, u8 reg)
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);
833 static int ad1889_ac97_init(ad1889_dev_t *dev, int id)
835 struct ac97_codec *ac97;
838 if ((ac97 = ac97_alloc_codec()) == NULL)
841 ac97->private_data = dev;
844 ac97->codec_read = ad1889_codec_read;
845 ac97->codec_write = ad1889_codec_write;
847 if (ac97_probe_codec(ac97) == 0) {
848 printk(DEVNAME ": ac97_probe_codec failed\n");
852 eid = ad1889_codec_read(ac97, AC97_EXTENDED_ID);
853 if (eid == 0xffffff) {
854 printk(KERN_WARNING DEVNAME ": no codec attached?\n");
858 dev->ac97_features = eid;
860 if ((ac97->dev_mixer = register_sound_mixer(&ad1889_mixer_fops, -1)) < 0) {
861 printk(KERN_ERR DEVNAME ": cannot register mixer\n");
865 dev->ac97_codec = ac97;
869 ac97_release_codec(ac97);
873 static int ad1889_aclink_reset(struct pci_dev * pcidev)
877 ad1889_dev_t *dev = pci_get_drvdata(pcidev);
879 AD1889_WRITEW(dev, AD_DSCCS, 0x8000); /* turn on clock */
880 AD1889_READW(dev, AD_DSCCS);
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 */
891 stat = AD1889_READW(dev, AD_ACIC);
892 stat |= 0x0001; /* Interface Enable */
893 AD1889_WRITEW(dev, AD_ACIC, stat);
896 if (AD1889_READW(dev, AD_ACIC) & 0x8000) /* Ready */
903 printk(KERN_ERR "ad1889_aclink_reset: codec is not ready [0x%x]\n",
904 AD1889_READW(dev, AD_ACIC));
908 /* TODO reset AC97 codec */
909 /* TODO set wave/adc pci ctrl status */
911 stat = AD1889_READW(dev, AD_ACIC);
912 stat |= 0x0004; /* Audio Stream Output Enable */
913 AD1889_WRITEW(dev, AD_ACIC, stat);
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 },
924 MODULE_DEVICE_TABLE(pci, ad1889_id_tbl);
926 static irqreturn_t ad1889_interrupt(int irq, void *dev_id, struct pt_regs *regs)
929 ad1889_dev_t *dev = (ad1889_dev_t *)dev_id;
931 stat = AD1889_READL(dev, AD_DMADISR);
934 AD1889_WRITEL(dev, AD_DMADISR, stat);
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 */
946 if ((stat & 0x2) && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */
947 DBG("ADC interrupt\n");
948 dev->stats.adc_intrs++;
955 static void ad1889_initcfg(ad1889_dev_t *dev)
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);
966 tmp = AD1889_READW(dev, AD_DSWADA);
968 AD1889_WRITEW(dev, AD_DSWADA, tmp);
971 static int __devinit ad1889_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
976 struct proc_dir_entry *proc_root = NULL;
978 if ((err = pci_enable_device(pcidev)) != 0) {
979 printk(KERN_ERR DEVNAME ": pci_enable_device failed\n");
983 pci_set_master(pcidev);
984 if ((dev = ad1889_alloc_dev(pcidev)) == NULL) {
985 printk(KERN_ERR DEVNAME ": cannot allocate memory for device\n");
988 pci_set_drvdata(pcidev, dev);
989 bar = pci_resource_start(pcidev, 0);
991 if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) {
992 printk(KERN_ERR DEVNAME ": memory region not assigned\n");
996 if (request_irq(pcidev->irq, ad1889_interrupt, SA_SHIRQ, DEVNAME, dev) != 0) {
997 printk(KERN_ERR DEVNAME ": unable to request interrupt\n");
1001 request_mem_region(bar, AD_DSIOMEMSIZE, DEVNAME);
1002 dev->regbase = (unsigned long)ioremap_nocache(bar, AD_DSIOMEMSIZE);
1004 printk(KERN_INFO DEVNAME ": %s at 0x%lx IRQ %d\n",
1005 (char *)ent->driver_data, dev->regbase, pcidev->irq);
1007 if (ad1889_aclink_reset(pcidev) != 0)
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");
1016 if ((err = ad1889_ac97_init(dev, 0)) != 0)
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)
1024 ad1889_initcfg(dev);
1026 //DBG(DEVNAME ": Driver initialization done!\n");
1033 unregister_sound_dsp(dev->dev_audio);
1036 free_irq(pcidev->irq, dev);
1039 ad1889_free_dev(dev);
1040 pci_set_drvdata(pcidev, 0);
1045 static void __devexit ad1889_remove(struct pci_dev *pcidev)
1047 ad1889_dev_t *dev = pci_get_drvdata(pcidev);
1049 if (dev == NULL) return;
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);
1056 /* any hw programming needed? */
1057 ad1889_free_dev(dev);
1060 MODULE_AUTHOR("Randolph Chung");
1061 MODULE_DESCRIPTION("Analog Devices AD1889 PCI Audio");
1062 MODULE_LICENSE("GPL");
1064 static struct pci_driver ad1889_driver = {
1066 .id_table = ad1889_id_tbl,
1067 .probe = ad1889_probe,
1068 .remove = __devexit_p(ad1889_remove),
1071 static int __init ad1889_init_module(void)
1073 return pci_module_init(&ad1889_driver);
1076 static void ad1889_exit_module(void)
1078 pci_unregister_driver(&ad1889_driver);
1082 module_init(ad1889_init_module);
1083 module_exit(ad1889_exit_module);