?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: arch/x86/mm/init_32.c cleanup
[wrt350n-kernel.git] / sound / oss / btaudio.c
blob4d5cf05b8922605421a09a9716c957782c771635
1 /*
2 btaudio - bt878 audio dma driver for linux 2.4.x
3
4 (c) 2000-2002 Gerd Knorr <kraxel@bytesex.org>
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 */
21
22 #include <linux/module.h>
23 #include <linux/errno.h>
24 #include <linux/pci.h>
25 #include <linux/sched.h>
26 #include <linux/signal.h>
27 #include <linux/types.h>
28 #include <linux/interrupt.h>
29 #include <linux/init.h>
30 #include <linux/poll.h>
31 #include <linux/sound.h>
32 #include <linux/soundcard.h>
33 #include <linux/slab.h>
34 #include <linux/kdev_t.h>
35 #include <linux/mutex.h>
36
37 #include <asm/uaccess.h>
38 #include <asm/io.h>
39
40
41 /* mmio access */
42 #define btwrite(dat,adr) writel((dat), (bta->mmio+(adr)))
43 #define btread(adr) readl(bta->mmio+(adr))
44
45 #define btand(dat,adr) btwrite((dat) & btread(adr), adr)
46 #define btor(dat,adr) btwrite((dat) | btread(adr), adr)
47 #define btaor(dat,mask,adr) btwrite((dat) | ((mask) & btread(adr)), adr)
48
49 /* registers (shifted because bta->mmio is long) */
50 #define REG_INT_STAT (0x100 >> 2)
51 #define REG_INT_MASK (0x104 >> 2)
52 #define REG_GPIO_DMA_CTL (0x10c >> 2)
53 #define REG_PACKET_LEN (0x110 >> 2)
54 #define REG_RISC_STRT_ADD (0x114 >> 2)
55 #define REG_RISC_COUNT (0x120 >> 2)
56
57 /* IRQ bits - REG_INT_(STAT|MASK) */
58 #define IRQ_SCERR (1 << 19)
59 #define IRQ_OCERR (1 << 18)
60 #define IRQ_PABORT (1 << 17)
61 #define IRQ_RIPERR (1 << 16)
62 #define IRQ_PPERR (1 << 15)
63 #define IRQ_FDSR (1 << 14)
64 #define IRQ_FTRGT (1 << 13)
65 #define IRQ_FBUS (1 << 12)
66 #define IRQ_RISCI (1 << 11)
67 #define IRQ_OFLOW (1 << 3)
68
69 #define IRQ_BTAUDIO (IRQ_SCERR | IRQ_OCERR | IRQ_PABORT | IRQ_RIPERR |\
70 IRQ_PPERR | IRQ_FDSR | IRQ_FTRGT | IRQ_FBUS |\
71 IRQ_RISCI)
72
73 /* REG_GPIO_DMA_CTL bits */
74 #define DMA_CTL_A_PWRDN (1 << 26)
75 #define DMA_CTL_DA_SBR (1 << 14)
76 #define DMA_CTL_DA_ES2 (1 << 13)
77 #define DMA_CTL_ACAP_EN (1 << 4)
78 #define DMA_CTL_RISC_EN (1 << 1)
79 #define DMA_CTL_FIFO_EN (1 << 0)
80
81 /* RISC instructions */
82 #define RISC_WRITE (0x01 << 28)
83 #define RISC_JUMP (0x07 << 28)
84 #define RISC_SYNC (0x08 << 28)
85
86 /* RISC bits */
87 #define RISC_WR_SOL (1 << 27)
88 #define RISC_WR_EOL (1 << 26)
89 #define RISC_IRQ (1 << 24)
90 #define RISC_SYNC_RESYNC (1 << 15)
91 #define RISC_SYNC_FM1 0x06
92 #define RISC_SYNC_VRO 0x0c
93
94 #define HWBASE_AD (448000)
95
96 /* -------------------------------------------------------------- */
97
98 struct btaudio {
99 /* linked list */
100 struct btaudio *next;
101
102 /* device info */
103 int dsp_digital;
104 int dsp_analog;
105 int mixer_dev;
106 struct pci_dev *pci;
107 unsigned int irq;
108 unsigned long mem;
109 unsigned long __iomem *mmio;
110
111 /* locking */
112 int users;
113 struct mutex lock;
114
115 /* risc instructions */
116 unsigned int risc_size;
117 unsigned long *risc_cpu;
118 dma_addr_t risc_dma;
119
120 /* audio data */
121 unsigned int buf_size;
122 unsigned char *buf_cpu;
123 dma_addr_t buf_dma;
124
125 /* buffer setup */
126 int line_bytes;
127 int line_count;
128 int block_bytes;
129 int block_count;
130
131 /* read fifo management */
132 int recording;
133 int dma_block;
134 int read_offset;
135 int read_count;
136 wait_queue_head_t readq;
137
138 /* settings */
139 int gain[3];
140 int source;
141 int bits;
142 int decimation;
143 int mixcount;
144 int sampleshift;
145 int channels;
146 int analog;
147 int rate;
148 };
149
150 struct cardinfo {
151 char *name;
152 int rate;
153 };
154
155 static struct btaudio *btaudios;
156 static unsigned int debug;
157 static unsigned int irq_debug;
158
159 /* -------------------------------------------------------------- */
160
161 #define BUF_DEFAULT 128*1024
162 #define BUF_MIN 8192
163
164 static int alloc_buffer(struct btaudio *bta)
165 {
166 if (NULL == bta->buf_cpu) {
167 for (bta->buf_size = BUF_DEFAULT; bta->buf_size >= BUF_MIN;
168 bta->buf_size = bta->buf_size >> 1) {
169 bta->buf_cpu = pci_alloc_consistent
170 (bta->pci, bta->buf_size, &bta->buf_dma);
171 if (NULL != bta->buf_cpu)
172 break;
173 }
174 if (NULL == bta->buf_cpu)
175 return -ENOMEM;
176 memset(bta->buf_cpu,0,bta->buf_size);
177 }
178 if (NULL == bta->risc_cpu) {
179 bta->risc_size = PAGE_SIZE;
180 bta->risc_cpu = pci_alloc_consistent
181 (bta->pci, bta->risc_size, &bta->risc_dma);
182 if (NULL == bta->risc_cpu) {
183 pci_free_consistent(bta->pci, bta->buf_size, bta->buf_cpu, bta->buf_dma);
184 bta->buf_cpu = NULL;
185 return -ENOMEM;
186 }
187 }
188 return 0;
189 }
190
191 static void free_buffer(struct btaudio *bta)
192 {
193 if (NULL != bta->buf_cpu) {
194 pci_free_consistent(bta->pci, bta->buf_size,
195 bta->buf_cpu, bta->buf_dma);
196 bta->buf_cpu = NULL;
197 }
198 if (NULL != bta->risc_cpu) {
199 pci_free_consistent(bta->pci, bta->risc_size,
200 bta->risc_cpu, bta->risc_dma);
201 bta->risc_cpu = NULL;
202 }
203 }
204
205 static int make_risc(struct btaudio *bta)
206 {
207 int rp, bp, line, block;
208 unsigned long risc;
209
210 bta->block_bytes = bta->buf_size >> 4;
211 bta->block_count = 1 << 4;
212 bta->line_bytes = bta->block_bytes;
213 bta->line_count = bta->block_count;
214 while (bta->line_bytes > 4095) {
215 bta->line_bytes >>= 1;
216 bta->line_count <<= 1;
217 }
218 if (bta->line_count > 255)
219 return -EINVAL;
220 if (debug)
221 printk(KERN_DEBUG
222 "btaudio: bufsize=%d - bs=%d bc=%d - ls=%d, lc=%d\n",
223 bta->buf_size,bta->block_bytes,bta->block_count,
224 bta->line_bytes,bta->line_count);
225 rp = 0; bp = 0;
226 block = 0;
227 bta->risc_cpu[rp++] = cpu_to_le32(RISC_SYNC|RISC_SYNC_FM1);
228 bta->risc_cpu[rp++] = cpu_to_le32(0);
229 for (line = 0; line < bta->line_count; line++) {
230 risc = RISC_WRITE | RISC_WR_SOL | RISC_WR_EOL;
231 risc |= bta->line_bytes;
232 if (0 == (bp & (bta->block_bytes-1))) {
233 risc |= RISC_IRQ;
234 risc |= (block & 0x0f) << 16;
235 risc |= (~block & 0x0f) << 20;
236 block++;
237 }
238 bta->risc_cpu[rp++] = cpu_to_le32(risc);
239 bta->risc_cpu[rp++] = cpu_to_le32(bta->buf_dma + bp);
240 bp += bta->line_bytes;
241 }
242 bta->risc_cpu[rp++] = cpu_to_le32(RISC_SYNC|RISC_SYNC_VRO);
243 bta->risc_cpu[rp++] = cpu_to_le32(0);
244 bta->risc_cpu[rp++] = cpu_to_le32(RISC_JUMP);
245 bta->risc_cpu[rp++] = cpu_to_le32(bta->risc_dma);
246 return 0;
247 }
248
249 static int start_recording(struct btaudio *bta)
250 {
251 int ret;
252
253 if (0 != (ret = alloc_buffer(bta)))
254 return ret;
255 if (0 != (ret = make_risc(bta)))
256 return ret;
257
258 btwrite(bta->risc_dma, REG_RISC_STRT_ADD);
259 btwrite((bta->line_count << 16) | bta->line_bytes,
260 REG_PACKET_LEN);
261 btwrite(IRQ_BTAUDIO, REG_INT_MASK);
262 if (bta->analog) {
263 btwrite(DMA_CTL_ACAP_EN |
264 DMA_CTL_RISC_EN |
265 DMA_CTL_FIFO_EN |
266 DMA_CTL_DA_ES2 |
267 ((bta->bits == 8) ? DMA_CTL_DA_SBR : 0) |
268 (bta->gain[bta->source] << 28) |
269 (bta->source << 24) |
270 (bta->decimation << 8),
271 REG_GPIO_DMA_CTL);
272 } else {
273 btwrite(DMA_CTL_ACAP_EN |
274 DMA_CTL_RISC_EN |
275 DMA_CTL_FIFO_EN |
276 DMA_CTL_DA_ES2 |
277 DMA_CTL_A_PWRDN |
278 (1 << 6) |
279 ((bta->bits == 8) ? DMA_CTL_DA_SBR : 0) |
280 (bta->gain[bta->source] << 28) |
281 (bta->source << 24) |
282 (bta->decimation << 8),
283 REG_GPIO_DMA_CTL);
284 }
285 bta->dma_block = 0;
286 bta->read_offset = 0;
287 bta->read_count = 0;
288 bta->recording = 1;
289 if (debug)
290 printk(KERN_DEBUG "btaudio: recording started\n");
291 return 0;
292 }
293
294 static void stop_recording(struct btaudio *bta)
295 {
296 btand(~15, REG_GPIO_DMA_CTL);
297 bta->recording = 0;
298 if (debug)
299 printk(KERN_DEBUG "btaudio: recording stopped\n");
300 }
301
302
303 /* -------------------------------------------------------------- */
304
305 static int btaudio_mixer_open(struct inode *inode, struct file *file)
306 {
307 int minor = iminor(inode);
308 struct btaudio *bta;
309
310 for (bta = btaudios; bta != NULL; bta = bta->next)
311 if (bta->mixer_dev == minor)
312 break;
313 if (NULL == bta)
314 return -ENODEV;
315
316 if (debug)
317 printk("btaudio: open mixer [%d]\n",minor);
318 file->private_data = bta;
319 return 0;
320 }
321
322 static int btaudio_mixer_release(struct inode *inode, struct file *file)
323 {
324 return 0;
325 }
326
327 static int btaudio_mixer_ioctl(struct inode *inode, struct file *file,
328 unsigned int cmd, unsigned long arg)
329 {
330 struct btaudio *bta = file->private_data;
331 int ret,val=0,i=0;
332 void __user *argp = (void __user *)arg;
333
334 if (cmd == SOUND_MIXER_INFO) {
335 mixer_info info;
336 memset(&info,0,sizeof(info));
337 strlcpy(info.id,"bt878",sizeof(info.id));
338 strlcpy(info.name,"Brooktree Bt878 audio",sizeof(info.name));
339 info.modify_counter = bta->mixcount;
340 if (copy_to_user(argp, &info, sizeof(info)))
341 return -EFAULT;
342 return 0;
343 }
344 if (cmd == SOUND_OLD_MIXER_INFO) {
345 _old_mixer_info info;
346 memset(&info,0,sizeof(info));
347 strlcpy(info.id, "bt878", sizeof(info.id));
348 strlcpy(info.name,"Brooktree Bt878 audio",sizeof(info.name));
349 if (copy_to_user(argp, &info, sizeof(info)))
350 return -EFAULT;
351 return 0;
352 }
353 if (cmd == OSS_GETVERSION)
354 return put_user(SOUND_VERSION, (int __user *)argp);
355
356 /* read */
357 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
358 if (get_user(val, (int __user *)argp))
359 return -EFAULT;
360
361 switch (cmd) {
362 case MIXER_READ(SOUND_MIXER_CAPS):
363 ret = SOUND_CAP_EXCL_INPUT;
364 break;
365 case MIXER_READ(SOUND_MIXER_STEREODEVS):
366 ret = 0;
367 break;
368 case MIXER_READ(SOUND_MIXER_RECMASK):
369 case MIXER_READ(SOUND_MIXER_DEVMASK):
370 ret = SOUND_MASK_LINE1|SOUND_MASK_LINE2|SOUND_MASK_LINE3;
371 break;
372
373 case MIXER_WRITE(SOUND_MIXER_RECSRC):
374 if (val & SOUND_MASK_LINE1 && bta->source != 0)
375 bta->source = 0;
376 else if (val & SOUND_MASK_LINE2 && bta->source != 1)
377 bta->source = 1;
378 else if (val & SOUND_MASK_LINE3 && bta->source != 2)
379 bta->source = 2;
380 btaor((bta->gain[bta->source] << 28) |
381 (bta->source << 24),
382 0x0cffffff, REG_GPIO_DMA_CTL);
383 case MIXER_READ(SOUND_MIXER_RECSRC):
384 switch (bta->source) {
385 case 0: ret = SOUND_MASK_LINE1; break;
386 case 1: ret = SOUND_MASK_LINE2; break;
387 case 2: ret = SOUND_MASK_LINE3; break;
388 default: ret = 0;
389 }
390 break;
391
392 case MIXER_WRITE(SOUND_MIXER_LINE1):
393 case MIXER_WRITE(SOUND_MIXER_LINE2):
394 case MIXER_WRITE(SOUND_MIXER_LINE3):
395 if (MIXER_WRITE(SOUND_MIXER_LINE1) == cmd)
396 i = 0;
397 if (MIXER_WRITE(SOUND_MIXER_LINE2) == cmd)
398 i = 1;
399 if (MIXER_WRITE(SOUND_MIXER_LINE3) == cmd)
400 i = 2;
401 bta->gain[i] = (val & 0xff) * 15 / 100;
402 if (bta->gain[i] > 15) bta->gain[i] = 15;
403 if (bta->gain[i] < 0) bta->gain[i] = 0;
404 if (i == bta->source)
405 btaor((bta->gain[bta->source]<<28),
406 0x0fffffff, REG_GPIO_DMA_CTL);
407 ret = bta->gain[i] * 100 / 15;
408 ret |= ret << 8;
409 break;
410
411 case MIXER_READ(SOUND_MIXER_LINE1):
412 case MIXER_READ(SOUND_MIXER_LINE2):
413 case MIXER_READ(SOUND_MIXER_LINE3):
414 if (MIXER_READ(SOUND_MIXER_LINE1) == cmd)
415 i = 0;
416 if (MIXER_READ(SOUND_MIXER_LINE2) == cmd)
417 i = 1;
418 if (MIXER_READ(SOUND_MIXER_LINE3) == cmd)
419 i = 2;
420 ret = bta->gain[i] * 100 / 15;
421 ret |= ret << 8;
422 break;
423
424 default:
425 return -EINVAL;
426 }
427 if (put_user(ret, (int __user *)argp))
428 return -EFAULT;
429 return 0;
430 }
431
432 static const struct file_operations btaudio_mixer_fops = {
433 .owner = THIS_MODULE,
434 .llseek = no_llseek,
435 .open = btaudio_mixer_open,
436 .release = btaudio_mixer_release,
437 .ioctl = btaudio_mixer_ioctl,
438 };
439
440 /* -------------------------------------------------------------- */
441
442 static int btaudio_dsp_open(struct inode *inode, struct file *file,
443 struct btaudio *bta, int analog)
444 {
445 mutex_lock(&bta->lock);
446 if (bta->users)
447 goto busy;
448 bta->users++;
449 file->private_data = bta;
450
451 bta->analog = analog;
452 bta->dma_block = 0;
453 bta->read_offset = 0;
454 bta->read_count = 0;
455 bta->sampleshift = 0;
456
457 mutex_unlock(&bta->lock);
458 return 0;
459
460 busy:
461 mutex_unlock(&bta->lock);
462 return -EBUSY;
463 }
464
465 static int btaudio_dsp_open_digital(struct inode *inode, struct file *file)
466 {
467 int minor = iminor(inode);
468 struct btaudio *bta;
469
470 for (bta = btaudios; bta != NULL; bta = bta->next)
471 if (bta->dsp_digital == minor)
472 break;
473 if (NULL == bta)
474 return -ENODEV;
475
476 if (debug)
477 printk("btaudio: open digital dsp [%d]\n",minor);
478 return btaudio_dsp_open(inode,file,bta,0);
479 }
480
481 static int btaudio_dsp_open_analog(struct inode *inode, struct file *file)
482 {
483 int minor = iminor(inode);
484 struct btaudio *bta;
485
486 for (bta = btaudios; bta != NULL; bta = bta->next)
487 if (bta->dsp_analog == minor)
488 break;
489 if (NULL == bta)
490 return -ENODEV;
491
492 if (debug)
493 printk("btaudio: open analog dsp [%d]\n",minor);
494 return btaudio_dsp_open(inode,file,bta,1);
495 }
496
497 static int btaudio_dsp_release(struct inode *inode, struct file *file)
498 {
499 struct btaudio *bta = file->private_data;
500
501 mutex_lock(&bta->lock);
502 if (bta->recording)
503 stop_recording(bta);
504 bta->users--;
505 mutex_unlock(&bta->lock);
506 return 0;
507 }
508
509 static ssize_t btaudio_dsp_read(struct file *file, char __user *buffer,
510 size_t swcount, loff_t *ppos)
511 {
512 struct btaudio *bta = file->private_data;
513 int hwcount = swcount << bta->sampleshift;
514 int nsrc, ndst, err, ret = 0;
515 DECLARE_WAITQUEUE(wait, current);
516
517 add_wait_queue(&bta->readq, &wait);
518 mutex_lock(&bta->lock);
519 while (swcount > 0) {
520 if (0 == bta->read_count) {
521 if (!bta->recording) {
522 if (0 != (err = start_recording(bta))) {
523 if (0 == ret)
524 ret = err;
525 break;
526 }
527 }
528 if (file->f_flags & O_NONBLOCK) {
529 if (0 == ret)
530 ret = -EAGAIN;
531 break;
532 }
533 mutex_unlock(&bta->lock);
534 current->state = TASK_INTERRUPTIBLE;
535 schedule();
536 mutex_lock(&bta->lock);
537 if(signal_pending(current)) {
538 if (0 == ret)
539 ret = -EINTR;
540 break;
541 }
542 }
543 nsrc = (bta->read_count < hwcount) ? bta->read_count : hwcount;
544 if (nsrc > bta->buf_size - bta->read_offset)
545 nsrc = bta->buf_size - bta->read_offset;
546 ndst = nsrc >> bta->sampleshift;
547
548 if ((bta->analog && 0 == bta->sampleshift) ||
549 (!bta->analog && 2 == bta->channels)) {
550 /* just copy */
551 if (copy_to_user(buffer + ret, bta->buf_cpu + bta->read_offset, nsrc)) {
552 if (0 == ret)
553 ret = -EFAULT;
554 break;
555 }
556
557 } else if (!bta->analog) {
558 /* stereo => mono (digital audio) */
559 __s16 *src = (__s16*)(bta->buf_cpu + bta->read_offset);
560 __s16 __user *dst = (__s16 __user *)(buffer + ret);
561 __s16 avg;
562 int n = ndst>>1;
563 if (!access_ok(VERIFY_WRITE, dst, ndst)) {
564 if (0 == ret)
565 ret = -EFAULT;
566 break;
567 }
568 for (; n; n--, dst++) {
569 avg = (__s16)le16_to_cpu(*src) / 2; src++;
570 avg += (__s16)le16_to_cpu(*src) / 2; src++;
571 __put_user(cpu_to_le16(avg),dst);
572 }
573
574 } else if (8 == bta->bits) {
575 /* copy + byte downsampling (audio A/D) */
576 __u8 *src = bta->buf_cpu + bta->read_offset;
577 __u8 __user *dst = buffer + ret;
578 int n = ndst;
579 if (!access_ok(VERIFY_WRITE, dst, ndst)) {
580 if (0 == ret)
581 ret = -EFAULT;
582 break;
583 }
584 for (; n; n--, src += (1 << bta->sampleshift), dst++)
585 __put_user(*src, dst);
586
587 } else {
588 /* copy + word downsampling (audio A/D) */
589 __u16 *src = (__u16*)(bta->buf_cpu + bta->read_offset);
590 __u16 __user *dst = (__u16 __user *)(buffer + ret);
591 int n = ndst>>1;
592 if (!access_ok(VERIFY_WRITE,dst,ndst)) {
593 if (0 == ret)
594 ret = -EFAULT;
595 break;
596 }
597 for (; n; n--, src += (1 << bta->sampleshift), dst++)
598 __put_user(*src, dst);
599 }
600
601 ret += ndst;
602 swcount -= ndst;
603 hwcount -= nsrc;
604 bta->read_count -= nsrc;
605 bta->read_offset += nsrc;
606 if (bta->read_offset == bta->buf_size)
607 bta->read_offset = 0;
608 }
609 mutex_unlock(&bta->lock);
610 remove_wait_queue(&bta->readq, &wait);
611 current->state = TASK_RUNNING;
612 return ret;
613 }
614
615 static ssize_t btaudio_dsp_write(struct file *file, const char __user *buffer,
616 size_t count, loff_t *ppos)
617 {
618 return -EINVAL;
619 }
620
621 static int btaudio_dsp_ioctl(struct inode *inode, struct file *file,
622 unsigned int cmd, unsigned long arg)
623 {
624 struct btaudio *bta = file->private_data;
625 int s, i, ret, val = 0;
626 void __user *argp = (void __user *)arg;
627 int __user *p = argp;
628
629 switch (cmd) {
630 case OSS_GETVERSION:
631 return put_user(SOUND_VERSION, p);
632 case SNDCTL_DSP_GETCAPS:
633 return 0;
634
635 case SNDCTL_DSP_SPEED:
636 if (get_user(val, p))
637 return -EFAULT;
638 if (bta->analog) {
639 for (s = 0; s < 16; s++)
640 if (val << s >= HWBASE_AD*4/15)
641 break;
642 for (i = 15; i >= 5; i--)
643 if (val << s <= HWBASE_AD*4/i)
644 break;
645 bta->sampleshift = s;
646 bta->decimation = i;
647 if (debug)
648 printk(KERN_DEBUG "btaudio: rate: req=%d "
649 "dec=%d shift=%d hwrate=%d swrate=%d\n",
650 val,i,s,(HWBASE_AD*4/i),(HWBASE_AD*4/i)>>s);
651 } else {
652 bta->sampleshift = (bta->channels == 2) ? 0 : 1;
653 bta->decimation = 0;
654 }
655 if (bta->recording) {
656 mutex_lock(&bta->lock);
657 stop_recording(bta);
658 start_recording(bta);
659 mutex_unlock(&bta->lock);
660 }
661 /* fall through */
662 case SOUND_PCM_READ_RATE:
663 if (bta->analog) {
664 return put_user(HWBASE_AD*4/bta->decimation>>bta->sampleshift, p);
665 } else {
666 return put_user(bta->rate, p);
667 }
668
669 case SNDCTL_DSP_STEREO:
670 if (!bta->analog) {
671 if (get_user(val, p))
672 return -EFAULT;
673 bta->channels = (val > 0) ? 2 : 1;
674 bta->sampleshift = (bta->channels == 2) ? 0 : 1;
675 if (debug)
676 printk(KERN_INFO
677 "btaudio: stereo=%d channels=%d\n",
678 val,bta->channels);
679 } else {
680 if (val == 1)
681 return -EFAULT;
682 else {
683 bta->channels = 1;
684 if (debug)
685 printk(KERN_INFO
686 "btaudio: stereo=0 channels=1\n");
687 }
688 }
689 return put_user((bta->channels)-1, p);
690
691 case SNDCTL_DSP_CHANNELS:
692 if (!bta->analog) {
693 if (get_user(val, p))
694 return -EFAULT;
695 bta->channels = (val > 1) ? 2 : 1;
696 bta->sampleshift = (bta->channels == 2) ? 0 : 1;
697 if (debug)
698 printk(KERN_DEBUG
699 "btaudio: val=%d channels=%d\n",
700 val,bta->channels);
701 }
702 /* fall through */
703 case SOUND_PCM_READ_CHANNELS:
704 return put_user(bta->channels, p);
705
706 case SNDCTL_DSP_GETFMTS: /* Returns a mask */
707 if (bta->analog)
708 return put_user(AFMT_S16_LE|AFMT_S8, p);
709 else
710 return put_user(AFMT_S16_LE, p);
711
712 case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
713 if (get_user(val, p))
714 return -EFAULT;
715 if (val != AFMT_QUERY) {
716 if (bta->analog)
717 bta->bits = (val == AFMT_S8) ? 8 : 16;
718 else
719 bta->bits = 16;
720 if (bta->recording) {
721 mutex_lock(&bta->lock);
722 stop_recording(bta);
723 start_recording(bta);
724 mutex_unlock(&bta->lock);
725 }
726 }
727 if (debug)
728 printk(KERN_DEBUG "btaudio: fmt: bits=%d\n",bta->bits);
729 return put_user((bta->bits==16) ? AFMT_S16_LE : AFMT_S8,
730 p);
731 break;
732 case SOUND_PCM_READ_BITS:
733 return put_user(bta->bits, p);
734
735 case SNDCTL_DSP_NONBLOCK:
736 file->f_flags |= O_NONBLOCK;
737 return 0;
738
739 case SNDCTL_DSP_RESET:
740 if (bta->recording) {
741 mutex_lock(&bta->lock);
742 stop_recording(bta);
743 mutex_unlock(&bta->lock);
744 }
745 return 0;
746 case SNDCTL_DSP_GETBLKSIZE:
747 if (!bta->recording) {
748 if (0 != (ret = alloc_buffer(bta)))
749 return ret;
750 if (0 != (ret = make_risc(bta)))
751 return ret;
752 }
753 return put_user(bta->block_bytes>>bta->sampleshift,p);
754
755 case SNDCTL_DSP_SYNC:
756 /* NOP */
757 return 0;
758 case SNDCTL_DSP_GETISPACE:
759 {
760 audio_buf_info info;
761 if (!bta->recording)
762 return -EINVAL;
763 info.fragsize = bta->block_bytes>>bta->sampleshift;
764 info.fragstotal = bta->block_count;
765 info.bytes = bta->read_count;
766 info.fragments = info.bytes / info.fragsize;
767 if (debug)
768 printk(KERN_DEBUG "btaudio: SNDCTL_DSP_GETISPACE "
769 "returns %d/%d/%d/%d\n",
770 info.fragsize, info.fragstotal,
771 info.bytes, info.fragments);
772 if (copy_to_user(argp, &info, sizeof(info)))
773 return -EFAULT;
774 return 0;
775 }
776 #if 0 /* TODO */
777 case SNDCTL_DSP_GETTRIGGER:
778 case SNDCTL_DSP_SETTRIGGER:
779 case SNDCTL_DSP_SETFRAGMENT:
780 #endif
781 default:
782 return -EINVAL;
783 }
784 }
785
786 static unsigned int btaudio_dsp_poll(struct file *file, struct poll_table_struct *wait)
787 {
788 struct btaudio *bta = file->private_data;
789 unsigned int mask = 0;
790
791 poll_wait(file, &bta->readq, wait);
792
793 if (0 != bta->read_count)
794 mask |= (POLLIN | POLLRDNORM);
795
796 return mask;
797 }
798
799 static const struct file_operations btaudio_digital_dsp_fops = {
800 .owner = THIS_MODULE,
801 .llseek = no_llseek,
802 .open = btaudio_dsp_open_digital,
803 .release = btaudio_dsp_release,
804 .read = btaudio_dsp_read,
805 .write = btaudio_dsp_write,
806 .ioctl = btaudio_dsp_ioctl,
807 .poll = btaudio_dsp_poll,
808 };
809
810 static const struct file_operations btaudio_analog_dsp_fops = {
811 .owner = THIS_MODULE,
812 .llseek = no_llseek,
813 .open = btaudio_dsp_open_analog,
814 .release = btaudio_dsp_release,
815 .read = btaudio_dsp_read,
816 .write = btaudio_dsp_write,
817 .ioctl = btaudio_dsp_ioctl,
818 .poll = btaudio_dsp_poll,
819 };
820
821 /* -------------------------------------------------------------- */
822
823 static char *irq_name[] = { "", "", "", "OFLOW", "", "", "", "", "", "", "",
824 "RISCI", "FBUS", "FTRGT", "FDSR", "PPERR",
825 "RIPERR", "PABORT", "OCERR", "SCERR" };
826
827 static irqreturn_t btaudio_irq(int irq, void *dev_id)
828 {
829 int count = 0;
830 u32 stat,astat;
831 struct btaudio *bta = dev_id;
832 int handled = 0;
833
834 for (;;) {
835 count++;
836 stat = btread(REG_INT_STAT);
837 astat = stat & btread(REG_INT_MASK);
838 if (!astat)
839 return IRQ_RETVAL(handled);
840 handled = 1;
841 btwrite(astat,REG_INT_STAT);
842
843 if (irq_debug) {
844 int i;
845 printk(KERN_DEBUG "btaudio: irq loop=%d risc=%x, bits:",
846 count, stat>>28);
847 for (i = 0; i < (sizeof(irq_name)/sizeof(char*)); i++) {
848 if (stat & (1 << i))
849 printk(" %s",irq_name[i]);
850 if (astat & (1 << i))
851 printk("*");
852 }
853 printk("\n");
854 }
855 if (stat & IRQ_RISCI) {
856 int blocks;
857 blocks = (stat >> 28) - bta->dma_block;
858 if (blocks < 0)
859 blocks += bta->block_count;
860 bta->dma_block = stat >> 28;
861 if (bta->read_count + 2*bta->block_bytes > bta->buf_size) {
862 stop_recording(bta);
863 printk(KERN_INFO "btaudio: buffer overrun\n");
864 }
865 if (blocks > 0) {
866 bta->read_count += blocks * bta->block_bytes;
867 wake_up_interruptible(&bta->readq);
868 }
869 }
870 if (count > 10) {
871 printk(KERN_WARNING
872 "btaudio: Oops - irq mask cleared\n");
873 btwrite(0, REG_INT_MASK);
874 }
875 }
876 return IRQ_NONE;
877 }
878
879 /* -------------------------------------------------------------- */
880
881 static unsigned int dsp1 = -1;
882 static unsigned int dsp2 = -1;
883 static unsigned int mixer = -1;
884 static int latency = -1;
885 static int digital = 1;
886 static int analog = 1;
887 static int rate;
888
889 #define BTA_OSPREY200 1
890
891 static struct cardinfo cards[] = {
892 [0] = {
893 .name = "default",
894 .rate = 32000,
895 },
896 [BTA_OSPREY200] = {
897 .name = "Osprey 200",
898 .rate = 44100,
899 },
900 };
901
902 static int __devinit btaudio_probe(struct pci_dev *pci_dev,
903 const struct pci_device_id *pci_id)
904 {
905 struct btaudio *bta;
906 struct cardinfo *card = &cards[pci_id->driver_data];
907 unsigned char revision,lat;
908 int rc = -EBUSY;
909
910 if (pci_enable_device(pci_dev))
911 return -EIO;
912 if (!request_mem_region(pci_resource_start(pci_dev,0),
913 pci_resource_len(pci_dev,0),
914 "btaudio")) {
915 return -EBUSY;
916 }
917
918 bta = kzalloc(sizeof(*bta),GFP_ATOMIC);
919 if (!bta) {
920 rc = -ENOMEM;
921 goto fail0;
922 }
923
924 bta->pci = pci_dev;
925 bta->irq = pci_dev->irq;
926 bta->mem = pci_resource_start(pci_dev,0);
927 bta->mmio = ioremap(pci_resource_start(pci_dev,0),
928 pci_resource_len(pci_dev,0));
929
930 bta->source = 1;
931 bta->bits = 8;
932 bta->channels = 1;
933 if (bta->analog) {
934 bta->decimation = 15;
935 } else {
936 bta->decimation = 0;
937 bta->sampleshift = 1;
938 }
939
940 /* sample rate */
941 bta->rate = card->rate;
942 if (rate)
943 bta->rate = rate;
944
945 mutex_init(&bta->lock);
946 init_waitqueue_head(&bta->readq);
947
948 if (-1 != latency) {
949 printk(KERN_INFO "btaudio: setting pci latency timer to %d\n",
950 latency);
951 pci_write_config_byte(pci_dev, PCI_LATENCY_TIMER, latency);
952 }
953 pci_read_config_byte(pci_dev, PCI_CLASS_REVISION, &revision);
954 pci_read_config_byte(pci_dev, PCI_LATENCY_TIMER, &lat);
955 printk(KERN_INFO "btaudio: Bt%x (rev %d) at %02x:%02x.%x, ",
956 pci_dev->device,revision,pci_dev->bus->number,
957 PCI_SLOT(pci_dev->devfn),PCI_FUNC(pci_dev->devfn));
958 printk("irq: %d, latency: %d, mmio: 0x%lx\n",
959 bta->irq, lat, bta->mem);
960 printk("btaudio: using card config \"%s\"\n", card->name);
961
962 /* init hw */
963 btwrite(0, REG_GPIO_DMA_CTL);
964 btwrite(0, REG_INT_MASK);
965 btwrite(~0U, REG_INT_STAT);
966 pci_set_master(pci_dev);
967
968 if ((rc = request_irq(bta->irq, btaudio_irq, IRQF_SHARED|IRQF_DISABLED,
969 "btaudio",(void *)bta)) < 0) {
970 printk(KERN_WARNING
971 "btaudio: can't request irq (rc=%d)\n",rc);
972 goto fail1;
973 }
974
975 /* register devices */
976 if (digital) {
977 rc = bta->dsp_digital =
978 register_sound_dsp(&btaudio_digital_dsp_fops,dsp1);
979 if (rc < 0) {
980 printk(KERN_WARNING
981 "btaudio: can't register digital dsp (rc=%d)\n",rc);
982 goto fail2;
983 }
984 printk(KERN_INFO "btaudio: registered device dsp%d [digital]\n",
985 bta->dsp_digital >> 4);
986 }
987 if (analog) {
988 rc = bta->dsp_analog =
989 register_sound_dsp(&btaudio_analog_dsp_fops,dsp2);
990 if (rc < 0) {
991 printk(KERN_WARNING
992 "btaudio: can't register analog dsp (rc=%d)\n",rc);
993 goto fail3;
994 }
995 printk(KERN_INFO "btaudio: registered device dsp%d [analog]\n",
996 bta->dsp_analog >> 4);
997 rc = bta->mixer_dev = register_sound_mixer(&btaudio_mixer_fops,mixer);
998 if (rc < 0) {
999 printk(KERN_WARNING
1000 "btaudio: can't register mixer (rc=%d)\n",rc);
1001 goto fail4;
1002 }
1003 printk(KERN_INFO "btaudio: registered device mixer%d\n",
1004 bta->mixer_dev >> 4);
1005 }
1006
1007 /* hook into linked list */
1008 bta->next = btaudios;
1009 btaudios = bta;
1010
1011 pci_set_drvdata(pci_dev,bta);
1012 return 0;
1013
1014 fail4:
1015 unregister_sound_dsp(bta->dsp_analog);
1016 fail3:
1017 if (digital)
1018 unregister_sound_dsp(bta->dsp_digital);
1019 fail2:
1020 free_irq(bta->irq,bta);
1021 fail1:
1022 iounmap(bta->mmio);
1023 kfree(bta);
1024 fail0:
1025 release_mem_region(pci_resource_start(pci_dev,0),
1026 pci_resource_len(pci_dev,0));
1027 return rc;
1028 }
1029
1030 static void __devexit btaudio_remove(struct pci_dev *pci_dev)
1031 {
1032 struct btaudio *bta = pci_get_drvdata(pci_dev);
1033 struct btaudio *walk;
1034
1035 /* turn off all DMA / IRQs */
1036 btand(~15, REG_GPIO_DMA_CTL);
1037 btwrite(0, REG_INT_MASK);
1038 btwrite(~0U, REG_INT_STAT);
1039
1040 /* unregister devices */
1041 if (digital) {
1042 unregister_sound_dsp(bta->dsp_digital);
1043 }
1044 if (analog) {
1045 unregister_sound_dsp(bta->dsp_analog);
1046 unregister_sound_mixer(bta->mixer_dev);
1047 }
1048
1049 /* free resources */
1050 free_buffer(bta);
1051 free_irq(bta->irq,bta);
1052 release_mem_region(pci_resource_start(pci_dev,0),
1053 pci_resource_len(pci_dev,0));
1054 iounmap(bta->mmio);
1055
1056 /* remove from linked list */
1057 if (bta == btaudios) {
1058 btaudios = NULL;
1059 } else {
1060 for (walk = btaudios; walk->next != bta; walk = walk->next)
1061 ; /* if (NULL == walk->next) BUG(); */
1062 walk->next = bta->next;
1063 }
1064
1065 pci_set_drvdata(pci_dev, NULL);
1066 kfree(bta);
1067 return;
1068 }
1069
1070 /* -------------------------------------------------------------- */
1071
1072 static struct pci_device_id btaudio_pci_tbl[] = {
1073 {
1074 .vendor = PCI_VENDOR_ID_BROOKTREE,
1075 .device = 0x0878,
1076 .subvendor = 0x0070,
1077 .subdevice = 0xff01,
1078 .driver_data = BTA_OSPREY200,
1079 },{
1080 .vendor = PCI_VENDOR_ID_BROOKTREE,
1081 .device = 0x0878,
1082 .subvendor = PCI_ANY_ID,
1083 .subdevice = PCI_ANY_ID,
1084 },{
1085 .vendor = PCI_VENDOR_ID_BROOKTREE,
1086 .device = 0x0878,
1087 .subvendor = PCI_ANY_ID,
1088 .subdevice = PCI_ANY_ID,
1089 },{
1090 /* --- end of list --- */
1091 }
1092 };
1093
1094 static struct pci_driver btaudio_pci_driver = {
1095 .name = "btaudio",
1096 .id_table = btaudio_pci_tbl,
1097 .probe = btaudio_probe,
1098 .remove = __devexit_p(btaudio_remove),
1099 };
1100
1101 static int btaudio_init_module(void)
1102 {
1103 printk(KERN_INFO "btaudio: driver version 0.7 loaded [%s%s%s]\n",
1104 digital ? "digital" : "",
1105 analog && digital ? "+" : "",
1106 analog ? "analog" : "");
1107 return pci_register_driver(&btaudio_pci_driver);
1108 }
1109
1110 static void btaudio_cleanup_module(void)
1111 {
1112 pci_unregister_driver(&btaudio_pci_driver);
1113 return;
1114 }
1115
1116 module_init(btaudio_init_module);
1117 module_exit(btaudio_cleanup_module);
1118
1119 module_param(dsp1, int, S_IRUGO);
1120 module_param(dsp2, int, S_IRUGO);
1121 module_param(mixer, int, S_IRUGO);
1122 module_param(debug, int, S_IRUGO | S_IWUSR);
1123 module_param(irq_debug, int, S_IRUGO | S_IWUSR);
1124 module_param(digital, int, S_IRUGO);
1125 module_param(analog, int, S_IRUGO);
1126 module_param(rate, int, S_IRUGO);
1127 module_param(latency, int, S_IRUGO);
1128 MODULE_PARM_DESC(latency,"pci latency timer");
1129
1130 MODULE_DEVICE_TABLE(pci, btaudio_pci_tbl);
1131 MODULE_DESCRIPTION("bt878 audio dma driver");
1132 MODULE_AUTHOR("Gerd Knorr");
1133 MODULE_LICENSE("GPL");
1134
1135 /*
1136 * Local variables:
1137 * c-basic-offset: 8
1138 * End:
1139 */
WRT350N Kernel Patches