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