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 __user *buffer, size_t count,
446 static ssize_t ad1889_write(struct file *file, const char __user *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;
620 int __user *p = (int __user *)arg;
625 return put_user(SOUND_VERSION, p);
627 case SNDCTL_DSP_RESET:
630 case SNDCTL_DSP_SYNC:
633 case SNDCTL_DSP_SPEED:
634 /* set sampling rate */
635 if (get_user(val, p))
637 if (val > 5400 && val < 48000)
639 if (file->f_mode & FMODE_WRITE)
640 AD1889_WRITEW(ad1889_dev, AD_DSWAS, val);
641 if (file->f_mode & FMODE_READ)
642 AD1889_WRITEW(ad1889_dev, AD_DSRES, val);
646 case SNDCTL_DSP_STEREO: /* undocumented? */
647 if (get_user(val, p))
649 if (file->f_mode & FMODE_READ) {
650 val = AD1889_READW(ad1889_dev, AD_DSWSMC);
652 val |= 0x0200; /* set WAST */
654 val &= ~0x0200; /* clear WAST */
656 AD1889_WRITEW(ad1889_dev, AD_DSWSMC, val);
658 if (file->f_mode & FMODE_WRITE) {
659 val = AD1889_READW(ad1889_dev, AD_DSRAMC);
661 val |= 0x0002; /* set ADST */
663 val &= ~0x0002; /* clear ADST */
665 AD1889_WRITEW(ad1889_dev, AD_DSRAMC, val);
670 case SNDCTL_DSP_GETBLKSIZE:
671 return put_user(DMA_SIZE, p);
673 case SNDCTL_DSP_GETFMTS:
674 return put_user(AFMT_S16_LE|AFMT_U8, p);
676 case SNDCTL_DSP_SETFMT:
677 if (get_user(val, p))
680 if (file->f_mode & FMODE_READ)
681 ad1889_set_adc_fmt(dev, val);
683 if (file->f_mode & FMODE_WRITE)
684 ad1889_set_wav_fmt(dev, val);
686 return put_user(val, p);
688 case SNDCTL_DSP_CHANNELS:
691 case SNDCTL_DSP_POST:
692 /* send all data to device */
695 case SNDCTL_DSP_SUBDIVIDE:
698 case SNDCTL_DSP_SETFRAGMENT:
699 /* not supported; uses fixed fragment sizes */
700 return put_user(DMA_SIZE, p);
702 case SNDCTL_DSP_GETOSPACE:
703 case SNDCTL_DSP_GETISPACE:
704 /* space left in dma buffers */
705 if (cmd == SNDCTL_DSP_GETOSPACE)
706 dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
708 dmabuf = &dev->state[AD_ADC_STATE].dmabuf;
709 abinfo.fragments = 1;
710 abinfo.fragstotal = 1;
711 abinfo.fragsize = DMA_SIZE;
712 abinfo.bytes = DMA_SIZE;
713 return copy_to_user(p, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
714 case SNDCTL_DSP_NONBLOCK:
715 file->f_flags |= O_NONBLOCK;
718 case SNDCTL_DSP_GETCAPS:
719 return put_user(0, p);
721 case SNDCTL_DSP_GETTRIGGER:
722 case SNDCTL_DSP_SETTRIGGER:
725 case SNDCTL_DSP_GETIPTR:
726 case SNDCTL_DSP_GETOPTR:
729 case SNDCTL_DSP_SETDUPLEX:
732 case SNDCTL_DSP_GETODELAY:
735 case SOUND_PCM_READ_RATE:
736 return put_user(AD1889_READW(ad1889_dev, AD_DSWAS), p);
738 case SOUND_PCM_READ_CHANNELS:
739 case SOUND_PCM_READ_BITS:
742 case SNDCTL_DSP_MAPINBUF:
743 case SNDCTL_DSP_MAPOUTBUF:
744 case SNDCTL_DSP_SETSYNCRO:
745 case SOUND_PCM_WRITE_FILTER:
746 case SOUND_PCM_READ_FILTER:
756 static int ad1889_open(struct inode *inode, struct file *file)
758 /* check minor; only support /dev/dsp atm */
759 if (iminor(inode) != 3)
762 file->private_data = ad1889_dev;
764 ad1889_set_wav_rate(ad1889_dev, 44100);
765 ad1889_set_wav_fmt(ad1889_dev, AFMT_S16_LE);
766 AD1889_WRITEW(ad1889_dev, AD_DSWADA, 0x0404); /* attenuation */
770 static int ad1889_release(struct inode *inode, struct file *file)
772 /* if we have state free it here */
776 static struct file_operations ad1889_fops = {
777 .owner = THIS_MODULE,
780 .write = ad1889_write,
782 .ioctl = ad1889_ioctl,
785 .release = ad1889_release,
788 /************************* /dev/mixer interfaces ************************ */
789 static int ad1889_mixer_open(struct inode *inode, struct file *file)
791 if (ad1889_dev->ac97_codec->dev_mixer != iminor(inode))
794 file->private_data = ad1889_dev->ac97_codec;
798 static int ad1889_mixer_release(struct inode *inode, struct file *file)
803 static int ad1889_mixer_ioctl(struct inode *inode, struct file *file,
804 unsigned int cmd, unsigned long arg)
806 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
807 return codec->mixer_ioctl(codec, cmd, arg);
810 static struct file_operations ad1889_mixer_fops = {
811 .owner = THIS_MODULE,
813 .ioctl = ad1889_mixer_ioctl,
814 .open = ad1889_mixer_open,
815 .release = ad1889_mixer_release,
818 /************************* AC97 interfaces ****************************** */
819 static void ad1889_codec_write(struct ac97_codec *ac97, u8 reg, u16 val)
821 ad1889_dev_t *dev = ac97->private_data;
823 //DBG("Writing 0x%x to 0x%lx\n", val, dev->regbase + 0x100 + reg);
824 AD1889_WRITEW(dev, 0x100 + reg, val);
827 static u16 ad1889_codec_read(struct ac97_codec *ac97, u8 reg)
829 ad1889_dev_t *dev = ac97->private_data;
830 //DBG("Reading from 0x%lx\n", dev->regbase + 0x100 + reg);
831 return AD1889_READW(dev, 0x100 + reg);
834 static int ad1889_ac97_init(ad1889_dev_t *dev, int id)
836 struct ac97_codec *ac97;
839 if ((ac97 = ac97_alloc_codec()) == NULL)
842 ac97->private_data = dev;
845 ac97->codec_read = ad1889_codec_read;
846 ac97->codec_write = ad1889_codec_write;
848 if (ac97_probe_codec(ac97) == 0) {
849 printk(DEVNAME ": ac97_probe_codec failed\n");
853 eid = ad1889_codec_read(ac97, AC97_EXTENDED_ID);
854 if (eid == 0xffffff) {
855 printk(KERN_WARNING DEVNAME ": no codec attached?\n");
859 dev->ac97_features = eid;
861 if ((ac97->dev_mixer = register_sound_mixer(&ad1889_mixer_fops, -1)) < 0) {
862 printk(KERN_ERR DEVNAME ": cannot register mixer\n");
866 dev->ac97_codec = ac97;
870 ac97_release_codec(ac97);
874 static int ad1889_aclink_reset(struct pci_dev * pcidev)
878 ad1889_dev_t *dev = pci_get_drvdata(pcidev);
880 AD1889_WRITEW(dev, AD_DSCCS, 0x8000); /* turn on clock */
881 AD1889_READW(dev, AD_DSCCS);
885 stat = AD1889_READW(dev, AD_ACIC);
886 stat |= 0x0002; /* Reset Disable */
887 AD1889_WRITEW(dev, AD_ACIC, stat);
888 (void) AD1889_READW(dev, AD_ACIC); /* flush posted write */
892 stat = AD1889_READW(dev, AD_ACIC);
893 stat |= 0x0001; /* Interface Enable */
894 AD1889_WRITEW(dev, AD_ACIC, stat);
897 if (AD1889_READW(dev, AD_ACIC) & 0x8000) /* Ready */
904 printk(KERN_ERR "ad1889_aclink_reset: codec is not ready [0x%x]\n",
905 AD1889_READW(dev, AD_ACIC));
909 /* TODO reset AC97 codec */
910 /* TODO set wave/adc pci ctrl status */
912 stat = AD1889_READW(dev, AD_ACIC);
913 stat |= 0x0004; /* Audio Stream Output Enable */
914 AD1889_WRITEW(dev, AD_ACIC, stat);
918 /************************* PCI interfaces ****************************** */
919 /* PCI device table */
920 static struct pci_device_id ad1889_id_tbl[] = {
921 { PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS, PCI_ANY_ID,
922 PCI_ANY_ID, 0, 0, (unsigned long)DEVNAME },
925 MODULE_DEVICE_TABLE(pci, ad1889_id_tbl);
927 static irqreturn_t ad1889_interrupt(int irq, void *dev_id, struct pt_regs *regs)
930 ad1889_dev_t *dev = (ad1889_dev_t *)dev_id;
932 stat = AD1889_READL(dev, AD_DMADISR);
935 AD1889_WRITEL(dev, AD_DMADISR, stat);
937 if (stat & 0x8) { /* WAVI */
938 DBG("WAV interrupt\n");
939 dev->stats.wav_intrs++;
940 if (dev->state[AD_WAV_STATE].dmabuf.ready) {
941 ad1889_stop_wav(&dev->state[AD_WAV_STATE]); /* clean up */
942 ad1889_start_wav(&dev->state[AD_WAV_STATE]); /* start new */
947 if ((stat & 0x2) && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */
948 DBG("ADC interrupt\n");
949 dev->stats.adc_intrs++;
956 static void ad1889_initcfg(ad1889_dev_t *dev)
960 /* make sure the interrupt bits are setup the way we want */
961 tmp = AD1889_READW(dev, AD_DMAWAVCTRL);
962 tmp &= ~0x00ff; /* flat dma, no sg, mask out the intr bits */
963 tmp |= 0x0004; /* intr on count, loop */
964 AD1889_WRITEW(dev, AD_DMAWAVCTRL, tmp);
967 tmp = AD1889_READW(dev, AD_DSWADA);
969 AD1889_WRITEW(dev, AD_DSWADA, tmp);
972 static int __devinit ad1889_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
977 struct proc_dir_entry *proc_root = NULL;
979 if ((err = pci_enable_device(pcidev)) != 0) {
980 printk(KERN_ERR DEVNAME ": pci_enable_device failed\n");
984 pci_set_master(pcidev);
985 if ((dev = ad1889_alloc_dev(pcidev)) == NULL) {
986 printk(KERN_ERR DEVNAME ": cannot allocate memory for device\n");
989 pci_set_drvdata(pcidev, dev);
990 bar = pci_resource_start(pcidev, 0);
992 if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) {
993 printk(KERN_ERR DEVNAME ": memory region not assigned\n");
997 if (request_irq(pcidev->irq, ad1889_interrupt, SA_SHIRQ, DEVNAME, dev) != 0) {
998 printk(KERN_ERR DEVNAME ": unable to request interrupt\n");
1002 request_mem_region(bar, AD_DSIOMEMSIZE, DEVNAME);
1003 dev->regbase = (unsigned long)ioremap_nocache(bar, AD_DSIOMEMSIZE);
1005 printk(KERN_INFO DEVNAME ": %s at 0x%lx IRQ %d\n",
1006 (char *)ent->driver_data, dev->regbase, pcidev->irq);
1008 if (ad1889_aclink_reset(pcidev) != 0)
1011 /* register /dev/dsp */
1012 if ((dev->dev_audio = register_sound_dsp(&ad1889_fops, -1)) < 0) {
1013 printk(KERN_ERR DEVNAME ": cannot register /dev/dsp\n");
1017 if ((err = ad1889_ac97_init(dev, 0)) != 0)
1020 if (((proc_root = proc_mkdir("driver/ad1889", 0)) == NULL) ||
1021 create_proc_read_entry("ac97", S_IFREG|S_IRUGO, proc_root, ac97_read_proc, dev->ac97_codec) == NULL ||
1022 create_proc_read_entry("info", S_IFREG|S_IRUGO, proc_root, ad1889_read_proc, dev) == NULL)
1025 ad1889_initcfg(dev);
1027 //DBG(DEVNAME ": Driver initialization done!\n");
1034 unregister_sound_dsp(dev->dev_audio);
1037 free_irq(pcidev->irq, dev);
1040 ad1889_free_dev(dev);
1041 pci_set_drvdata(pcidev, 0);
1046 static void __devexit ad1889_remove(struct pci_dev *pcidev)
1048 ad1889_dev_t *dev = pci_get_drvdata(pcidev);
1050 if (dev == NULL) return;
1052 unregister_sound_mixer(dev->ac97_codec->dev_mixer);
1053 unregister_sound_dsp(dev->dev_audio);
1054 free_irq(pcidev->irq, dev);
1055 release_mem_region(dev->regbase, AD_DSIOMEMSIZE);
1057 /* any hw programming needed? */
1058 ad1889_free_dev(dev);
1061 MODULE_AUTHOR("Randolph Chung");
1062 MODULE_DESCRIPTION("Analog Devices AD1889 PCI Audio");
1063 MODULE_LICENSE("GPL");
1065 static struct pci_driver ad1889_driver = {
1067 .id_table = ad1889_id_tbl,
1068 .probe = ad1889_probe,
1069 .remove = __devexit_p(ad1889_remove),
1072 static int __init ad1889_init_module(void)
1074 return pci_module_init(&ad1889_driver);
1077 static void ad1889_exit_module(void)
1079 pci_unregister_driver(&ad1889_driver);
1083 module_init(ad1889_init_module);
1084 module_exit(ad1889_exit_module);