?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/kyle/parisc-2.6
[linux/fpc-iii.git] / sound / oss / ad1889.c
blobc0730a3563a2962ab86a4c24ec39c063c4df0de4
1 /*
2 * Copyright 2001-2004 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/module.h>
30 #include <linux/init.h>
31 #include <linux/ioport.h>
32 #include <linux/pci.h>
33 #include <linux/poll.h>
34 #include <linux/proc_fs.h>
35 #include <linux/slab.h>
36 #include <linux/soundcard.h>
37 #include <linux/ac97_codec.h>
38 #include <linux/sound.h>
39 #include <linux/interrupt.h>
40 #include <linux/mutex.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() schedule_timeout(HZ/10) */
65 #define WAIT_10MS() do { int __i; for (__i = 0; __i < 100; __i++) udelay(1000); } while(0)
66
67 /* currently only support a single device */
68 static ad1889_dev_t *ad1889_dev = NULL;
69
70 /************************* helper routines ***************************** */
71 static inline void ad1889_set_wav_rate(ad1889_dev_t *dev, int rate)
72 {
73 struct ac97_codec *ac97_codec = dev->ac97_codec;
74
75 DBG("Setting WAV rate to %d\n", rate);
76 dev->state[AD_WAV_STATE].dmabuf.rate = rate;
77 AD1889_WRITEW(dev, AD_DS_WAS, rate);
78
79 /* Cycle the DAC to enable the new rate */
80 ac97_codec->codec_write(dev->ac97_codec, AC97_POWER_CONTROL, 0x0200);
81 WAIT_10MS();
82 ac97_codec->codec_write(dev->ac97_codec, AC97_POWER_CONTROL, 0);
83 }
84
85 static inline void ad1889_set_wav_fmt(ad1889_dev_t *dev, int fmt)
86 {
87 u16 tmp;
88
89 DBG("Setting WAV format to 0x%x\n", fmt);
90
91 tmp = AD1889_READW(ad1889_dev, AD_DS_WSMC);
92 if (fmt & AFMT_S16_LE) {
93 //tmp |= 0x0100; /* set WA16 */
94 tmp |= 0x0300; /* set WA16 stereo */
95 } else if (fmt & AFMT_U8) {
96 tmp &= ~0x0100; /* clear WA16 */
97 }
98 AD1889_WRITEW(ad1889_dev, AD_DS_WSMC, tmp);
99 }
100
101 static inline void ad1889_set_adc_fmt(ad1889_dev_t *dev, int fmt)
102 {
103 u16 tmp;
104
105 DBG("Setting ADC format to 0x%x\n", fmt);
106
107 tmp = AD1889_READW(ad1889_dev, AD_DS_RAMC);
108 if (fmt & AFMT_S16_LE) {
109 tmp |= 0x0100; /* set WA16 */
110 } else if (fmt & AFMT_U8) {
111 tmp &= ~0x0100; /* clear WA16 */
112 }
113 AD1889_WRITEW(ad1889_dev, AD_DS_RAMC, tmp);
114 }
115
116 static void ad1889_start_wav(ad1889_state_t *state)
117 {
118 unsigned long flags;
119 struct dmabuf *dmabuf = &state->dmabuf;
120 int cnt;
121 u16 tmp;
122
123 spin_lock_irqsave(&state->card->lock, flags);
124
125 if (dmabuf->dma_len) /* DMA already in flight */
126 goto skip_dma;
127
128 /* setup dma */
129 cnt = dmabuf->wr_ptr - dmabuf->rd_ptr;
130 if (cnt == 0) /* done - don't need to do anything */
131 goto skip_dma;
132
133 /* If the wr_ptr has wrapped, only map to the end */
134 if (cnt < 0)
135 cnt = DMA_SIZE - dmabuf->rd_ptr;
136
137 dmabuf->dma_handle = pci_map_single(ad1889_dev->pci,
138 dmabuf->rawbuf + dmabuf->rd_ptr,
139 cnt, PCI_DMA_TODEVICE);
140 dmabuf->dma_len = cnt;
141 dmabuf->ready = 1;
142
143 DBG("Starting playback at 0x%p for %ld bytes\n", dmabuf->rawbuf +
144 dmabuf->rd_ptr, dmabuf->dma_len);
145
146 /* load up the current register set */
147 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVCC, cnt);
148 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVICC, cnt);
149 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVCA, dmabuf->dma_handle);
150
151 /* TODO: for now we load the base registers with the same thing */
152 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVBC, cnt);
153 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVIBC, cnt);
154 AD1889_WRITEL(ad1889_dev, AD_DMA_WAVBA, dmabuf->dma_handle);
155
156 /* and we're off to the races... */
157 AD1889_WRITEL(ad1889_dev, AD_DMA_CHSS, 0x8);
158 tmp = AD1889_READW(ad1889_dev, AD_DS_WSMC);
159 tmp |= 0x0400; /* set WAEN */
160 AD1889_WRITEW(ad1889_dev, AD_DS_WSMC, tmp);
161 (void) AD1889_READW(ad1889_dev, AD_DS_WSMC); /* flush posted PCI write */
162
163 dmabuf->enable |= DAC_RUNNING;
164
165 skip_dma:
166 spin_unlock_irqrestore(&state->card->lock, flags);
167 }
168
169
170 static void ad1889_stop_wav(ad1889_state_t *state)
171 {
172 unsigned long flags;
173 struct dmabuf *dmabuf = &state->dmabuf;
174
175 spin_lock_irqsave(&state->card->lock, flags);
176
177 if (dmabuf->enable & DAC_RUNNING) {
178 u16 tmp;
179 unsigned long cnt = dmabuf->dma_len;
180
181 tmp = AD1889_READW(ad1889_dev, AD_DS_WSMC);
182 tmp &= ~0x0400; /* clear WAEN */
183 AD1889_WRITEW(ad1889_dev, AD_DS_WSMC, tmp);
184 (void) AD1889_READW(ad1889_dev, AD_DS_WSMC); /* flush posted PCI write */
185 pci_unmap_single(ad1889_dev->pci, dmabuf->dma_handle,
186 cnt, PCI_DMA_TODEVICE);
187
188 dmabuf->enable &= ~DAC_RUNNING;
189
190 /* update dma pointers */
191 dmabuf->rd_ptr += cnt;
192 dmabuf->rd_ptr &= (DMA_SIZE - 1);
193
194 dmabuf->dma_handle = 0;
195 dmabuf->dma_len = 0;
196 dmabuf->ready = 0;
197
198 wake_up(&dmabuf->wait);
199 }
200
201 spin_unlock_irqrestore(&state->card->lock, flags);
202 }
203
204
205 #if 0
206 static void ad1889_startstop_adc(ad1889_state_t *state, int start)
207 {
208 u16 tmp;
209 unsigned long flags;
210
211 spin_lock_irqsave(&state->card->lock, flags);
212
213 tmp = AD1889_READW(ad1889_dev, AD_DS_RAMC);
214 if (start) {
215 state->dmabuf.enable |= ADC_RUNNING;
216 tmp |= 0x0004; /* set ADEN */
217 } else {
218 state->dmabuf.enable &= ~ADC_RUNNING;
219 tmp &= ~0x0004; /* clear ADEN */
220 }
221 AD1889_WRITEW(ad1889_dev, AD_DS_RAMC, tmp);
222
223 spin_unlock_irqrestore(&state->card->lock, flags);
224 }
225 #endif
226
227 static ad1889_dev_t *ad1889_alloc_dev(struct pci_dev *pci)
228 {
229 ad1889_dev_t *dev;
230 struct dmabuf *dmabuf;
231 int i;
232
233 if ((dev = kzalloc(sizeof(ad1889_dev_t), GFP_KERNEL)) == NULL)
234 return NULL;
235 spin_lock_init(&dev->lock);
236 dev->pci = pci;
237
238 for (i = 0; i < AD_MAX_STATES; i++) {
239 dev->state[i].card = dev;
240 mutex_init(&dev->state[i].mutex);
241 init_waitqueue_head(&dev->state[i].dmabuf.wait);
242 }
243
244 /* allocate dma buffer */
245
246 for (i = 0; i < AD_MAX_STATES; i++) {
247 dmabuf = &dev->state[i].dmabuf;
248 dmabuf->rawbuf = kmalloc(DMA_SIZE, GFP_KERNEL|GFP_DMA);
249 if (!dmabuf->rawbuf)
250 goto err_free_dmabuf;
251 dmabuf->rawbuf_size = DMA_SIZE;
252 dmabuf->dma_handle = 0;
253 dmabuf->rd_ptr = dmabuf->wr_ptr = dmabuf->dma_len = 0UL;
254 dmabuf->ready = 0;
255 dmabuf->rate = 48000;
256 }
257 return dev;
258
259 err_free_dmabuf:
260 while (--i >= 0)
261 kfree(dev->state[i].dmabuf.rawbuf);
262 kfree(dev);
263 return NULL;
264 }
265
266 static void ad1889_free_dev(ad1889_dev_t *dev)
267 {
268 int j;
269 struct dmabuf *dmabuf;
270
271 if (dev == NULL)
272 return;
273
274 if (dev->ac97_codec)
275 ac97_release_codec(dev->ac97_codec);
276
277 for (j = 0; j < AD_MAX_STATES; j++) {
278 dmabuf = &dev->state[j].dmabuf;
279 kfree(dmabuf->rawbuf);
280 }
281
282 kfree(dev);
283 }
284
285 static inline void ad1889_trigger_playback(ad1889_dev_t *dev)
286 {
287 #if 0
288 u32 val;
289 struct dmabuf *dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
290 #endif
291
292 ad1889_start_wav(&dev->state[AD_WAV_STATE]);
293 }
294
295 static int ad1889_read_proc (char *page, char **start, off_t off,
296 int count, int *eof, void *data)
297 {
298 char *out = page;
299 int len, i;
300 ad1889_dev_t *dev = data;
301 ad1889_reg_t regs[] = {
302 { "WSMC", AD_DS_WSMC, 16 },
303 { "RAMC", AD_DS_RAMC, 16 },
304 { "WADA", AD_DS_WADA, 16 },
305 { "SYDA", AD_DS_SYDA, 16 },
306 { "WAS", AD_DS_WAS, 16 },
307 { "RES", AD_DS_RES, 16 },
308 { "CCS", AD_DS_CCS, 16 },
309 { "ADCBA", AD_DMA_ADCBA, 32 },
310 { "ADCCA", AD_DMA_ADCCA, 32 },
311 { "ADCBC", AD_DMA_ADCBC, 32 },
312 { "ADCCC", AD_DMA_ADCCC, 32 },
313 { "ADCIBC", AD_DMA_ADCIBC, 32 },
314 { "ADCICC", AD_DMA_ADCICC, 32 },
315 { "ADCCTRL", AD_DMA_ADCCTRL, 16 },
316 { "WAVBA", AD_DMA_WAVBA, 32 },
317 { "WAVCA", AD_DMA_WAVCA, 32 },
318 { "WAVBC", AD_DMA_WAVBC, 32 },
319 { "WAVCC", AD_DMA_WAVCC, 32 },
320 { "WAVIBC", AD_DMA_WAVIBC, 32 },
321 { "WAVICC", AD_DMA_WAVICC, 32 },
322 { "WAVCTRL", AD_DMA_WAVCTRL, 16 },
323 { "DISR", AD_DMA_DISR, 32 },
324 { "CHSS", AD_DMA_CHSS, 32 },
325 { "IPC", AD_GPIO_IPC, 16 },
326 { "OP", AD_GPIO_OP, 16 },
327 { "IP", AD_GPIO_IP, 16 },
328 { "ACIC", AD_AC97_ACIC, 16 },
329 { "AC97_RESET", AD_AC97_BASE + AC97_RESET, 16 },
330 { "AC97_MASTER_VOL_STEREO", AD_AC97_BASE + AC97_MASTER_VOL_STEREO, 16 },
331 { "AC97_HEADPHONE_VOL", AD_AC97_BASE + AC97_HEADPHONE_VOL, 16 },
332 { "AC97_MASTER_VOL_MONO", AD_AC97_BASE + AC97_MASTER_VOL_MONO, 16 },
333 { "AC97_MASTER_TONE", AD_AC97_BASE + AC97_MASTER_TONE, 16 },
334 { "AC97_PCBEEP_VOL", AD_AC97_BASE + AC97_PCBEEP_VOL, 16 },
335 { "AC97_PHONE_VOL", AD_AC97_BASE + AC97_PHONE_VOL, 16 },
336 { "AC97_MIC_VOL", AD_AC97_BASE + AC97_MIC_VOL, 16 },
337 { "AC97_LINEIN_VOL", AD_AC97_BASE + AC97_LINEIN_VOL, 16 },
338 { "AC97_CD_VOL", AD_AC97_BASE + AC97_CD_VOL, 16 },
339 { "AC97_VIDEO_VOL", AD_AC97_BASE + AC97_VIDEO_VOL, 16 },
340 { "AC97_AUX_VOL", AD_AC97_BASE + AC97_AUX_VOL, 16 },
341 { "AC97_PCMOUT_VOL", AD_AC97_BASE + AC97_PCMOUT_VOL, 16 },
342 { "AC97_RECORD_SELECT", AD_AC97_BASE + AC97_RECORD_SELECT, 16 },
343 { "AC97_RECORD_GAIN", AD_AC97_BASE + AC97_RECORD_GAIN, 16 },
344 { "AC97_RECORD_GAIN_MIC", AD_AC97_BASE + AC97_RECORD_GAIN_MIC, 16 },
345 { "AC97_GENERAL_PURPOSE", AD_AC97_BASE + AC97_GENERAL_PURPOSE, 16 },
346 { "AC97_3D_CONTROL", AD_AC97_BASE + AC97_3D_CONTROL, 16 },
347 { "AC97_MODEM_RATE", AD_AC97_BASE + AC97_MODEM_RATE, 16 },
348 { "AC97_POWER_CONTROL", AD_AC97_BASE + AC97_POWER_CONTROL, 16 },
349 { NULL }
350 };
351
352 if (dev == NULL)
353 return -ENODEV;
354
355 for (i = 0; regs[i].name != 0; i++)
356 out += sprintf(out, "%s: 0x%0*x\n", regs[i].name,
357 regs[i].width >> 2,
358 (regs[i].width == 16
359 ? AD1889_READW(dev, regs[i].offset)
360 : AD1889_READL(dev, regs[i].offset)));
361
362 for (i = 0; i < AD_MAX_STATES; i++) {
363 out += sprintf(out, "DMA status for %s:\n",
364 (i == AD_WAV_STATE ? "WAV" : "ADC"));
365 out += sprintf(out, "\t\t0x%p (IOVA: 0x%llu)\n",
366 dev->state[i].dmabuf.rawbuf,
367 (unsigned long long)dev->state[i].dmabuf.dma_handle);
368
369 out += sprintf(out, "\tread ptr: offset %u\n",
370 (unsigned int)dev->state[i].dmabuf.rd_ptr);
371 out += sprintf(out, "\twrite ptr: offset %u\n",
372 (unsigned int)dev->state[i].dmabuf.wr_ptr);
373 out += sprintf(out, "\tdma len: offset %u\n",
374 (unsigned int)dev->state[i].dmabuf.dma_len);
375 }
376
377 len = out - page - off;
378 if (len < count) {
379 *eof = 1;
380 if (len <= 0) return 0;
381 } else {
382 len = count;
383 }
384 *start = page + off;
385 return len;
386 }
387
388 /***************************** DMA interfaces ************************** */
389 #if 0
390 static inline unsigned long ad1889_get_dma_addr(ad1889_state_t *state)
391 {
392 struct dmabuf *dmabuf = &state->dmabuf;
393 u32 offset;
394
395 if (!(dmabuf->enable & (DAC_RUNNING | ADC_RUNNING))) {
396 printk(KERN_ERR DEVNAME ": get_dma_addr called without dma enabled\n");
397 return 0;
398 }
399
400 if (dmabuf->enable & DAC_RUNNING)
401 offset = le32_to_cpu(AD1889_READL(state->card, AD_DMA_WAVBA));
402 else
403 offset = le32_to_cpu(AD1889_READL(state->card, AD_DMA_ADCBA));
404
405 return (unsigned long)bus_to_virt((unsigned long)offset) - (unsigned long)dmabuf->rawbuf;
406 }
407
408 static void ad1889_update_ptr(ad1889_dev_t *dev, int wake)
409 {
410 ad1889_state_t *state;
411 struct dmabuf *dmabuf;
412 unsigned long hwptr;
413 int diff;
414
415 /* check ADC first */
416 state = &dev->adc_state;
417 dmabuf = &state->dmabuf;
418 if (dmabuf->enable & ADC_RUNNING) {
419 hwptr = ad1889_get_dma_addr(state);
420 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
421
422 dmabuf->hwptr = hwptr;
423 dmabuf->total_bytes += diff;
424 dmabuf->count += diff;
425 if (dmabuf->count > dmabuf->dmasize)
426 dmabuf->count = dmabuf->dmasize;
427
428 if (dmabuf->mapped) {
429 if (wake & dmabuf->count >= dmabuf->fragsize)
430 wake_up(&dmabuf->wait);
431 } else {
432 if (wake & dmabuf->count > 0)
433 wake_up(&dmabuf->wait);
434 }
435 }
436
437 /* check DAC */
438 state = &dev->wav_state;
439 dmabuf = &state->dmabuf;
440 if (dmabuf->enable & DAC_RUNNING) {
441 XXX
442
443 }
444 #endif
445
446 /************************* /dev/dsp interfaces ************************* */
447
448 static ssize_t ad1889_read(struct file *file, char __user *buffer, size_t count,
449 loff_t *ppos)
450 {
451 return 0;
452 }
453
454 static ssize_t ad1889_write(struct file *file, const char __user *buffer, size_t count,
455 loff_t *ppos)
456 {
457 ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
458 ad1889_state_t *state = &dev->state[AD_WAV_STATE];
459 volatile struct dmabuf *dmabuf = &state->dmabuf;
460 ssize_t ret = 0;
461 DECLARE_WAITQUEUE(wait, current);
462
463 mutex_lock(&state->mutex);
464 #if 0
465 if (dmabuf->mapped) {
466 ret = -ENXIO;
467 goto err1;
468 }
469 #endif
470 if (!access_ok(VERIFY_READ, buffer, count)) {
471 ret = -EFAULT;
472 goto err1;
473 }
474
475 add_wait_queue(&state->dmabuf.wait, &wait);
476
477 /* start filling dma buffer.... */
478 while (count > 0) {
479 long rem;
480 long cnt = count;
481 unsigned long flags;
482
483 for (;;) {
484 long used_bytes;
485 long timeout; /* max time for DMA in jiffies */
486
487 /* buffer is full if wr catches up to rd */
488 spin_lock_irqsave(&state->card->lock, flags);
489 used_bytes = dmabuf->wr_ptr - dmabuf->rd_ptr;
490 timeout = (dmabuf->dma_len * HZ) / dmabuf->rate;
491 spin_unlock_irqrestore(&state->card->lock, flags);
492
493 /* adjust for buffer wrap around */
494 used_bytes = (used_bytes + DMA_SIZE) & (DMA_SIZE - 1);
495
496 /* If at least one page unused */
497 if (used_bytes < (DMA_SIZE - 0x1000))
498 break;
499
500 /* dma buffer full */
501
502 if (file->f_flags & O_NONBLOCK) {
503 ret = -EAGAIN;
504 goto err2;
505 }
506
507 set_current_state(TASK_INTERRUPTIBLE);
508 schedule_timeout(timeout + 1);
509 if (signal_pending(current)) {
510 ret = -ERESTARTSYS;
511 goto err2;
512 }
513 }
514
515 /* watch out for wrapping around static buffer */
516 spin_lock_irqsave(&state->card->lock, flags);
517 rem = DMA_SIZE - dmabuf->wr_ptr;
518 if (cnt > rem)
519 cnt = rem;
520
521 rem = dmabuf->wr_ptr;
522
523 /* update dma pointers */
524 dmabuf->wr_ptr += cnt;
525 dmabuf->wr_ptr &= DMA_SIZE - 1; /* wrap ptr if necessary */
526 spin_unlock_irqrestore(&state->card->lock, flags);
527
528 /* transfer unwrapped chunk */
529 if (copy_from_user(dmabuf->rawbuf + rem, buffer, cnt)) {
530 ret = -EFAULT;
531 goto err2;
532 }
533
534 DBG("Writing 0x%lx bytes to +0x%lx\n", cnt, rem);
535
536 /* update counters */
537 count -= cnt;
538 buffer += cnt;
539 ret += cnt;
540
541 /* we have something to play - go play it! */
542 ad1889_trigger_playback(dev);
543 }
544
545 err2:
546 remove_wait_queue(&state->dmabuf.wait, &wait);
547 err1:
548 mutex_unlock(&state->mutex);
549 return ret;
550 }
551
552 static unsigned int ad1889_poll(struct file *file, struct poll_table_struct *wait)
553 {
554 unsigned int mask = 0;
555 #if 0
556 ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
557 ad1889_state_t *state = NULL;
558 struct dmabuf *dmabuf;
559 unsigned long flags;
560
561 if (!(file->f_mode & (FMODE_READ | FMODE_WRITE)))
562 return -EINVAL;
563
564 if (file->f_mode & FMODE_WRITE) {
565 state = &dev->state[AD_WAV_STATE];
566 if (!state) return 0;
567 dmabuf = &state->dmabuf;
568 poll_wait(file, &dmabuf->wait, wait);
569 }
570
571 if (file->f_mode & FMODE_READ) {
572 state = &dev->state[AD_ADC_STATE];
573 if (!state) return 0;
574 dmabuf = &state->dmabuf;
575 poll_wait(file, &dmabuf->wait, wait);
576 }
577
578 spin_lock_irqsave(&dev->lock, flags);
579 ad1889_update_ptr(dev, 0);
580
581 if (file->f_mode & FMODE_WRITE) {
582 state = &dev->state[WAV_STATE];
583 dmabuf = &state->dmabuf;
584 if (dmabuf->mapped) {
585 if (dmabuf->count >= (int)dmabuf->fragsize)
586 mask |= POLLOUT | POLLWRNORM;
587 } else {
588 if ((int)dmabuf->dmasize >= dmabuf->count +
589 (int)dmabuf->fragsize)
590 mask |= POLLOUT | POLLWRNORM;
591 }
592 }
593
594 if (file ->f_mode & FMODE_READ) {
595 state = &dev->state[AD_ADC_STATE];
596 dmabuf = &state->dmabuf;
597 if (dmabuf->count >= (int)dmabuf->fragsize)
598 mask |= POLLIN | POLLRDNORM;
599 }
600 spin_unlock_irqrestore(&dev->lock, flags);
601
602 #endif
603 return mask;
604 }
605
606 static int ad1889_mmap(struct file *file, struct vm_area_struct *vma)
607 {
608 return 0;
609 }
610
611 static int ad1889_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
612 unsigned long arg)
613 {
614 int val = 0;
615 ad1889_dev_t *dev = (ad1889_dev_t *)file->private_data;
616 struct dmabuf *dmabuf;
617 audio_buf_info abinfo;
618 int __user *p = (int __user *)arg;
619
620 DBG("ad1889_ioctl cmd 0x%x arg %lu\n", cmd, arg);
621
622 switch (cmd)
623 {
624 case OSS_GETVERSION:
625 return put_user(SOUND_VERSION, p);
626
627 case SNDCTL_DSP_RESET:
628 break;
629
630 case SNDCTL_DSP_SYNC:
631 break;
632
633 case SNDCTL_DSP_SPEED:
634 /* set sampling rate */
635 if (get_user(val, p))
636 return -EFAULT;
637 if (val > 5400 && val < 48000)
638 {
639 if (file->f_mode & FMODE_WRITE)
640 AD1889_WRITEW(ad1889_dev, AD_DS_WAS, val);
641 if (file->f_mode & FMODE_READ)
642 AD1889_WRITEW(ad1889_dev, AD_DS_RES, val);
643 }
644 return 0;
645
646 case SNDCTL_DSP_STEREO: /* undocumented? */
647 if (get_user(val, p))
648 return -EFAULT;
649 if (file->f_mode & FMODE_READ) {
650 val = AD1889_READW(ad1889_dev, AD_DS_WSMC);
651 if (val) {
652 val |= 0x0200; /* set WAST */
653 } else {
654 val &= ~0x0200; /* clear WAST */
655 }
656 AD1889_WRITEW(ad1889_dev, AD_DS_WSMC, val);
657 }
658 if (file->f_mode & FMODE_WRITE) {
659 val = AD1889_READW(ad1889_dev, AD_DS_RAMC);
660 if (val) {
661 val |= 0x0002; /* set ADST */
662 } else {
663 val &= ~0x0002; /* clear ADST */
664 }
665 AD1889_WRITEW(ad1889_dev, AD_DS_RAMC, val);
666 }
667
668 return 0;
669
670 case SNDCTL_DSP_GETBLKSIZE:
671 return put_user(DMA_SIZE, p);
672
673 case SNDCTL_DSP_GETFMTS:
674 return put_user(AFMT_S16_LE|AFMT_U8, p);
675
676 case SNDCTL_DSP_SETFMT:
677 if (get_user(val, p))
678 return -EFAULT;
679
680 if (val == 0) {
681 if (file->f_mode & FMODE_READ)
682 ad1889_set_adc_fmt(dev, val);
683
684 if (file->f_mode & FMODE_WRITE)
685 ad1889_set_wav_fmt(dev, val);
686 } else {
687 val = AFMT_S16_LE | AFMT_U8;
688 }
689
690 return put_user(val, p);
691
692 case SNDCTL_DSP_CHANNELS:
693 break;
694
695 case SNDCTL_DSP_POST:
696 /* send all data to device */
697 break;
698
699 case SNDCTL_DSP_SUBDIVIDE:
700 break;
701
702 case SNDCTL_DSP_SETFRAGMENT:
703 /* not supported; uses fixed fragment sizes */
704 return put_user(DMA_SIZE, p);
705
706 case SNDCTL_DSP_GETOSPACE:
707 case SNDCTL_DSP_GETISPACE:
708 /* space left in dma buffers */
709 if (cmd == SNDCTL_DSP_GETOSPACE)
710 dmabuf = &dev->state[AD_WAV_STATE].dmabuf;
711 else
712 dmabuf = &dev->state[AD_ADC_STATE].dmabuf;
713 abinfo.fragments = 1;
714 abinfo.fragstotal = 1;
715 abinfo.fragsize = DMA_SIZE;
716 abinfo.bytes = DMA_SIZE;
717 return copy_to_user(p, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
718 case SNDCTL_DSP_NONBLOCK:
719 file->f_flags |= O_NONBLOCK;
720 return 0;
721
722 case SNDCTL_DSP_GETCAPS:
723 return put_user(0, p);
724
725 case SNDCTL_DSP_GETTRIGGER:
726 case SNDCTL_DSP_SETTRIGGER:
727 break;
728
729 case SNDCTL_DSP_GETIPTR:
730 case SNDCTL_DSP_GETOPTR:
731 break;
732
733 case SNDCTL_DSP_SETDUPLEX:
734 break;
735
736 case SNDCTL_DSP_GETODELAY:
737 break;
738
739 case SOUND_PCM_READ_RATE:
740 return put_user(AD1889_READW(ad1889_dev, AD_DS_WAS), p);
741
742 case SOUND_PCM_READ_CHANNELS:
743 case SOUND_PCM_READ_BITS:
744 break;
745
746 case SNDCTL_DSP_MAPINBUF:
747 case SNDCTL_DSP_MAPOUTBUF:
748 case SNDCTL_DSP_SETSYNCRO:
749 case SOUND_PCM_WRITE_FILTER:
750 case SOUND_PCM_READ_FILTER:
751 break;
752
753 default:
754 break;
755 }
756
757 return -ENOTTY;
758 }
759
760 static int ad1889_open(struct inode *inode, struct file *file)
761 {
762 /* check minor; only support /dev/dsp atm */
763 if (iminor(inode) != 3)
764 return -ENXIO;
765
766 file->private_data = ad1889_dev;
767
768 ad1889_set_wav_rate(ad1889_dev, 48000);
769 ad1889_set_wav_fmt(ad1889_dev, AFMT_S16_LE);
770 AD1889_WRITEW(ad1889_dev, AD_DS_WADA, 0x0404); /* attenuation */
771 return nonseekable_open(inode, file);
772 }
773
774 static int ad1889_release(struct inode *inode, struct file *file)
775 {
776 /* if we have state free it here */
777 return 0;
778 }
779
780 static const struct file_operations ad1889_fops = {
781 .owner = THIS_MODULE,
782 .llseek = no_llseek,
783 .read = ad1889_read,
784 .write = ad1889_write,
785 .poll = ad1889_poll,
786 .ioctl = ad1889_ioctl,
787 .mmap = ad1889_mmap,
788 .open = ad1889_open,
789 .release = ad1889_release,
790 };
791
792 /************************* /dev/mixer interfaces ************************ */
793 static int ad1889_mixer_open(struct inode *inode, struct file *file)
794 {
795 if (ad1889_dev->ac97_codec->dev_mixer != iminor(inode))
796 return -ENODEV;
797
798 file->private_data = ad1889_dev->ac97_codec;
799 return 0;
800 }
801
802 static int ad1889_mixer_release(struct inode *inode, struct file *file)
803 {
804 return 0;
805 }
806
807 static int ad1889_mixer_ioctl(struct inode *inode, struct file *file,
808 unsigned int cmd, unsigned long arg)
809 {
810 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
811 return codec->mixer_ioctl(codec, cmd, arg);
812 }
813
814 static const struct file_operations ad1889_mixer_fops = {
815 .owner = THIS_MODULE,
816 .llseek = no_llseek,
817 .ioctl = ad1889_mixer_ioctl,
818 .open = ad1889_mixer_open,
819 .release = ad1889_mixer_release,
820 };
821
822 /************************* AC97 interfaces ****************************** */
823 static void ad1889_codec_write(struct ac97_codec *ac97, u8 reg, u16 val)
824 {
825 ad1889_dev_t *dev = ac97->private_data;
826
827 //DBG("Writing 0x%x to 0x%lx\n", val, dev->regbase + AD_AC97_BASE + reg);
828 AD1889_WRITEW(dev, AD_AC97_BASE + reg, val);
829 }
830
831 static u16 ad1889_codec_read(struct ac97_codec *ac97, u8 reg)
832 {
833 ad1889_dev_t *dev = ac97->private_data;
834 //DBG("Reading from 0x%lx\n", dev->regbase + AD_AC97_BASE + reg);
835 return AD1889_READW(dev, AD_AC97_BASE + reg);
836 }
837
838 static int ad1889_ac97_init(ad1889_dev_t *dev, int id)
839 {
840 struct ac97_codec *ac97;
841 u16 eid;
842
843 if ((ac97 = ac97_alloc_codec()) == NULL)
844 return -ENOMEM;
845
846 ac97->private_data = dev;
847 ac97->id = id;
848
849 ac97->codec_read = ad1889_codec_read;
850 ac97->codec_write = ad1889_codec_write;
851
852 if (ac97_probe_codec(ac97) == 0) {
853 printk(DEVNAME ": ac97_probe_codec failed\n");
854 goto out_free;
855 }
856
857 eid = ad1889_codec_read(ac97, AC97_EXTENDED_ID);
858 if (eid == 0xffff) {
859 printk(KERN_WARNING DEVNAME ": no codec attached?\n");
860 goto out_free;
861 }
862
863 dev->ac97_features = eid;
864
865 if ((ac97->dev_mixer = register_sound_mixer(&ad1889_mixer_fops, -1)) < 0) {
866 printk(KERN_ERR DEVNAME ": cannot register mixer\n");
867 goto out_free;
868 }
869
870 dev->ac97_codec = ac97;
871 return 0;
872
873 out_free:
874 ac97_release_codec(ac97);
875 return -ENODEV;
876 }
877
878 static int ad1889_aclink_reset(struct pci_dev * pcidev)
879 {
880 u16 stat;
881 int retry = 200;
882 ad1889_dev_t *dev = pci_get_drvdata(pcidev);
883
884 AD1889_WRITEW(dev, AD_DS_CCS, 0x8000); /* turn on clock */
885 AD1889_READW(dev, AD_DS_CCS);
886
887 WAIT_10MS();
888
889 stat = AD1889_READW(dev, AD_AC97_ACIC);
890 stat |= 0x0002; /* Reset Disable */
891 AD1889_WRITEW(dev, AD_AC97_ACIC, stat);
892 (void) AD1889_READW(dev, AD_AC97_ACIC); /* flush posted write */
893
894 udelay(10);
895
896 stat = AD1889_READW(dev, AD_AC97_ACIC);
897 stat |= 0x0001; /* Interface Enable */
898 AD1889_WRITEW(dev, AD_AC97_ACIC, stat);
899
900 do {
901 if (AD1889_READW(dev, AD_AC97_ACIC) & 0x8000) /* Ready */
902 break;
903 WAIT_10MS();
904 retry--;
905 } while (retry > 0);
906
907 if (!retry) {
908 printk(KERN_ERR "ad1889_aclink_reset: codec is not ready [0x%x]\n",
909 AD1889_READW(dev, AD_AC97_ACIC));
910 return -EBUSY;
911 }
912
913 /* TODO reset AC97 codec */
914 /* TODO set wave/adc pci ctrl status */
915
916 stat = AD1889_READW(dev, AD_AC97_ACIC);
917 stat |= 0x0004; /* Audio Stream Output Enable */
918 AD1889_WRITEW(dev, AD_AC97_ACIC, stat);
919 return 0;
920 }
921
922 /************************* PCI interfaces ****************************** */
923 /* PCI device table */
924 static struct pci_device_id ad1889_id_tbl[] = {
925 { PCI_VENDOR_ID_ANALOG_DEVICES, PCI_DEVICE_ID_AD1889JS, PCI_ANY_ID,
926 PCI_ANY_ID, 0, 0, (unsigned long)DEVNAME },
927 { },
928 };
929 MODULE_DEVICE_TABLE(pci, ad1889_id_tbl);
930
931 static irqreturn_t ad1889_interrupt(int irq, void *dev_id)
932 {
933 u32 stat;
934 ad1889_dev_t *dev = (ad1889_dev_t *)dev_id;
935
936 stat = AD1889_READL(dev, AD_DMA_DISR);
937
938 /* clear ISR */
939 AD1889_WRITEL(dev, AD_DMA_DISR, stat);
940
941 if (stat & 0x8) { /* WAVI */
942 DBG("WAV interrupt\n");
943 dev->stats.wav_intrs++;
944 if (dev->state[AD_WAV_STATE].dmabuf.ready) {
945 ad1889_stop_wav(&dev->state[AD_WAV_STATE]); /* clean up */
946 ad1889_start_wav(&dev->state[AD_WAV_STATE]); /* start new */
947 }
948 }
949
950 if ((stat & 0x2) && dev->state[AD_ADC_STATE].dmabuf.ready) { /* ADCI */
951 DBG("ADC interrupt\n");
952 dev->stats.adc_intrs++;
953 }
954 if(stat)
955 return IRQ_HANDLED;
956 return IRQ_NONE;
957 }
958
959 static void ad1889_initcfg(ad1889_dev_t *dev)
960 {
961 u16 tmp16;
962 u32 tmp32;
963
964 /* make sure the interrupt bits are setup the way we want */
965 tmp32 = AD1889_READL(dev, AD_DMA_WAVCTRL);
966 tmp32 &= ~0xff; /* flat dma, no sg, mask out the intr bits */
967 tmp32 |= 0x6; /* intr on count, loop */
968 AD1889_WRITEL(dev, AD_DMA_WAVCTRL, tmp32);
969
970 /* unmute... */
971 tmp16 = AD1889_READW(dev, AD_DS_WADA);
972 tmp16 &= ~0x8080;
973 AD1889_WRITEW(dev, AD_DS_WADA, tmp16);
974 }
975
976 static int __devinit ad1889_probe(struct pci_dev *pcidev, const struct pci_device_id *ent)
977 {
978 int err;
979 ad1889_dev_t *dev;
980 unsigned long bar;
981 struct proc_dir_entry *proc_root = NULL;
982
983 if ((err = pci_enable_device(pcidev)) != 0) {
984 printk(KERN_ERR DEVNAME ": pci_enable_device failed\n");
985 return err;
986 }
987
988 pci_set_master(pcidev);
989 if ((dev = ad1889_alloc_dev(pcidev)) == NULL) {
990 printk(KERN_ERR DEVNAME ": cannot allocate memory for device\n");
991 return -ENOMEM;
992 }
993 pci_set_drvdata(pcidev, dev);
994 bar = pci_resource_start(pcidev, 0);
995
996 if (!(pci_resource_flags(pcidev, 0) & IORESOURCE_MEM)) {
997 printk(KERN_ERR DEVNAME ": memory region not assigned\n");
998 goto out1;
999 }
1000
1001 if (pci_request_region(pcidev, 0, DEVNAME)) {
1002 printk(KERN_ERR DEVNAME ": unable to request memory region\n");
1003 goto out1;
1004 }
1005
1006 dev->regbase = ioremap_nocache(bar, AD_DS_IOMEMSIZE);
1007 if (!dev->regbase) {
1008 printk(KERN_ERR DEVNAME ": unable to remap iomem\n");
1009 goto out2;
1010 }
1011
1012 if (request_irq(pcidev->irq, ad1889_interrupt, IRQF_SHARED, DEVNAME, dev) != 0) {
1013 printk(KERN_ERR DEVNAME ": unable to request interrupt\n");
1014 goto out3;
1015 }
1016
1017 printk(KERN_INFO DEVNAME ": %s at %p IRQ %d\n",
1018 (char *)ent->driver_data, dev->regbase, pcidev->irq);
1019
1020 if (ad1889_aclink_reset(pcidev) != 0)
1021 goto out4;
1022
1023 /* register /dev/dsp */
1024 if ((dev->dev_audio = register_sound_dsp(&ad1889_fops, -1)) < 0) {
1025 printk(KERN_ERR DEVNAME ": cannot register /dev/dsp\n");
1026 goto out4;
1027 }
1028
1029 if ((err = ad1889_ac97_init(dev, 0)) != 0)
1030 goto out5;
1031
1032 /* XXX: cleanups */
1033 if (((proc_root = proc_mkdir("driver/ad1889", NULL)) == NULL) ||
1034 create_proc_read_entry("ac97", S_IFREG|S_IRUGO, proc_root, ac97_read_proc, dev->ac97_codec) == NULL ||
1035 create_proc_read_entry("info", S_IFREG|S_IRUGO, proc_root, ad1889_read_proc, dev) == NULL)
1036 goto out5;
1037
1038 ad1889_initcfg(dev);
1039
1040 //DBG(DEVNAME ": Driver initialization done!\n");
1041
1042 ad1889_dev = dev;
1043
1044 return 0;
1045
1046 out5:
1047 unregister_sound_dsp(dev->dev_audio);
1048 out4:
1049 free_irq(pcidev->irq, dev);
1050 out3:
1051 iounmap(dev->regbase);
1052 out2:
1053 pci_release_region(pcidev, 0);
1054 out1:
1055 ad1889_free_dev(dev);
1056 pci_set_drvdata(pcidev, NULL);
1057
1058 return -ENODEV;
1059 }
1060
1061 static void __devexit ad1889_remove(struct pci_dev *pcidev)
1062 {
1063 ad1889_dev_t *dev = pci_get_drvdata(pcidev);
1064
1065 if (dev == NULL) return;
1066
1067 unregister_sound_mixer(dev->ac97_codec->dev_mixer);
1068 unregister_sound_dsp(dev->dev_audio);
1069 free_irq(pcidev->irq, dev);
1070 iounmap(dev->regbase);
1071 pci_release_region(pcidev, 0);
1072
1073 /* any hw programming needed? */
1074 ad1889_free_dev(dev);
1075 pci_set_drvdata(pcidev, NULL);
1076 }
1077
1078 MODULE_AUTHOR("Randolph Chung");
1079 MODULE_DESCRIPTION("Analog Devices AD1889 PCI Audio");
1080 MODULE_LICENSE("GPL");
1081
1082 static struct pci_driver ad1889_driver = {
1083 .name = DEVNAME,
1084 .id_table = ad1889_id_tbl,
1085 .probe = ad1889_probe,
1086 .remove = __devexit_p(ad1889_remove),
1087 };
1088
1089 static int __init ad1889_init_module(void)
1090 {
1091 return pci_register_driver(&ad1889_driver);
1092 }
1093
1094 static void ad1889_exit_module(void)
1095 {
1096 pci_unregister_driver(&ad1889_driver);
1097 return;
1098 }
1099
1100 module_init(ad1889_init_module);
1101 module_exit(ad1889_exit_module);
Linux with added FPC-III support