?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.1.89-4
[davej-history.git] / drivers / sound / soundcard.c
blobe23e5486e2a857a370f7965476d8b5db2ea1fc9f
1 /*
2 * linux/drivers/sound/soundcard.c
3 *
4 * Soundcard driver for Linux
5 */
6 /*
7 * Copyright (C) by Hannu Savolainen 1993-1997
8 *
9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
11 * for more info.
12 */
13 /*
14 * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
15 * integrated sound_switch.c
16 * Stefan Reinauer : integrated /proc/sound (equals to /dev/sndstat,
17 * which should disappear in the near future)
18 */
19 #include <linux/config.h>
20
21
22 #include "sound_config.h"
23 #include <linux/types.h>
24 #include <linux/errno.h>
25 #include <linux/signal.h>
26 #include <linux/fcntl.h>
27 #include <linux/ctype.h>
28 #include <linux/stddef.h>
29 #include <linux/kerneld.h>
30 #ifdef __KERNEL__
31 #include <asm/io.h>
32 #include <asm/segment.h>
33 #include <linux/wait.h>
34 #include <linux/malloc.h>
35 #include <linux/ioport.h>
36 #endif /* __KERNEL__ */
37 #include <linux/delay.h>
38 #include <linux/proc_fs.h>
39
40 #define SOUND_CORE
41
42 #include "soundmodule.h"
43
44 #include <linux/major.h>
45 #ifdef MODULE
46 #define modular 1
47 #else
48 #define modular 0
49 #endif
50
51 static int chrdev_registered = 0;
52 static int sound_major = SOUND_MAJOR;
53
54 static int is_unloading = 0;
55
56 /*
57 * Table for permanently allocated memory (used when unloading the module)
58 */
59 caddr_t sound_mem_blocks[1024];
60 int sound_mem_sizes[1024];
61 int sound_nblocks = 0;
62
63 static int soundcard_configured = 0;
64
65 static char dma_alloc_map[8] =
66 {0};
67
68 #define DMA_MAP_UNAVAIL 0
69 #define DMA_MAP_FREE 1
70 #define DMA_MAP_BUSY 2
71
72
73 static int in_use = 0; /* Total # of open devices */
74 unsigned long seq_time = 0; /* Time for /dev/sequencer */
75
76 /*
77 * Table for configurable mixer volume handling
78 */
79 static mixer_vol_table mixer_vols[MAX_MIXER_DEV];
80 static int num_mixer_volumes = 0;
81
82
83 int *load_mixer_volumes(char *name, int *levels, int present)
84 {
85 int i, n;
86
87 for (i = 0; i < num_mixer_volumes; i++)
88 if (strcmp(name, mixer_vols[i].name) == 0)
89 {
90 if (present)
91 mixer_vols[i].num = i;
92 return mixer_vols[i].levels;
93 }
94 if (num_mixer_volumes >= MAX_MIXER_DEV)
95 {
96 printk("Sound: Too many mixers (%s)\n", name);
97 return levels;
98 }
99 n = num_mixer_volumes++;
100
101 strcpy(mixer_vols[n].name, name);
102
103 if (present)
104 mixer_vols[n].num = n;
105 else
106 mixer_vols[n].num = -1;
107
108 for (i = 0; i < 32; i++)
109 mixer_vols[n].levels[i] = levels[i];
110 return mixer_vols[n].levels;
111 }
112
113 static int set_mixer_levels(caddr_t arg)
114 {
115 /* mixer_vol_table is 174 bytes, so IMHO no reason to not allocate it on the stack */
116 mixer_vol_table buf;
117
118 if (__copy_from_user(&buf, arg, sizeof(buf)))
119 return -EFAULT;
120 load_mixer_volumes(buf.name, buf.levels, 0);
121 if (__copy_to_user(arg, &buf, sizeof(buf)))
122 return -EFAULT;
123 return 0;
124 }
125
126 static int get_mixer_levels(caddr_t arg)
127 {
128 int n;
129
130 if (__get_user(n, (int *)(&(((mixer_vol_table *)arg)->num))))
131 return -EFAULT;
132 if (n < 0 || n >= num_mixer_volumes)
133 return -EINVAL;
134 if (__copy_to_user(arg, &mixer_vols[n], sizeof(mixer_vol_table)))
135 return -EFAULT;
136 return 0;
137 }
138
139 static int sound_proc_get_info(char *buffer, char **start, off_t offset, int length, int inout)
140 {
141 int len, i, drv;
142 off_t pos = 0;
143 off_t begin = 0;
144
145 #ifdef MODULE
146 #define MODULEPROCSTRING "Driver loaded as a module"
147 #else
148 #define MODULEPROCSTRING "Driver compiled into kernel"
149 #endif
150
151 len = sprintf(buffer, "OSS/Free:" SOUND_VERSION_STRING "\n"
152 "Load type: " MODULEPROCSTRING "\n"
153 "Kernel: %s %s %s %s %s\n"
154 "Config options: %x\n\nInstalled drivers: \n",
155 system_utsname.sysname, system_utsname.nodename, system_utsname.release,
156 system_utsname.version, system_utsname.machine, SELECTED_SOUND_OPTIONS);
157
158 for (i = 0; (i < num_sound_drivers) && (pos <= offset + length); i++) {
159 if (!sound_drivers[i].card_type)
160 continue;
161 len += sprintf(buffer + len, "Type %d: %s\n",
162 sound_drivers[i].card_type, sound_drivers[i].name);
163 pos = begin + len;
164 if (pos < offset) {
165 len = 0;
166 begin = pos;
167 }
168 }
169 len += sprintf(buffer + len, "\nCard config: \n");
170
171 for (i = 0; (i < num_sound_cards) && (pos <= offset + length); i++) {
172 if (!snd_installed_cards[i].card_type)
173 continue;
174 if (!snd_installed_cards[i].enabled)
175 len += sprintf(buffer + len, "(");
176 if ((drv = snd_find_driver(snd_installed_cards[i].card_type)) != -1)
177 len += sprintf(buffer + len, "%s", sound_drivers[drv].name);
178 if (snd_installed_cards[i].config.io_base)
179 len += sprintf(buffer + len, " at 0x%x", snd_installed_cards[i].config.io_base);
180 if (snd_installed_cards[i].config.irq != 0)
181 len += sprintf(buffer + len, " irq %d", abs(snd_installed_cards[i].config.irq));
182 if (snd_installed_cards[i].config.dma != -1) {
183 len += sprintf(buffer + len, " drq %d", snd_installed_cards[i].config.dma);
184 if (snd_installed_cards[i].config.dma2 != -1)
185 len += sprintf(buffer + len, ",%d", snd_installed_cards[i].config.dma2);
186 }
187 if (!snd_installed_cards[i].enabled)
188 len += sprintf(buffer + len, ")");
189 len += sprintf(buffer + len, "\n");
190 pos = begin + len;
191 if (pos < offset) {
192 len = 0;
193 begin = pos;
194 }
195 }
196 if (!sound_started)
197 len += sprintf(buffer + len, "\n\n***** Sound driver not started *****\n\n");
198 #ifndef CONFIG_AUDIO
199 len += sprintf(buffer + len, "\nAudio devices: NOT ENABLED IN CONFIG\n");
200 #else
201 len += sprintf(buffer + len, "\nAudio devices:\n");
202 for (i = 0; (i < num_audiodevs) && (pos <= offset + length); i++) {
203 if (audio_devs[i] == NULL)
204 continue;
205 len += sprintf(buffer + len, "%d: %s%s\n", i, audio_devs[i]->name,
206 audio_devs[i]->flags & DMA_DUPLEX ? " (DUPLEX)" : "");
207 pos = begin + len;
208 if (pos < offset) {
209 len = 0;
210 begin = pos;
211 }
212 }
213 #endif
214
215 #ifndef CONFIG_SEQUENCER
216 len += sprintf(buffer + len, "\nSynth devices: NOT ENABLED IN CONFIG\n");
217 #else
218 len += sprintf(buffer + len, "\nSynth devices:\n");
219 for (i = 0; (i < num_synths) && (pos <= offset + length); i++) {
220 if (synth_devs[i] == NULL)
221 continue;
222 len += sprintf(buffer + len, "%d: %s\n", i, synth_devs[i]->info->name);
223 pos = begin + len;
224 if (pos < offset) {
225 len = 0;
226 begin = pos;
227 }
228 }
229 #endif
230
231 #ifndef CONFIG_MIDI
232 len += sprintf(buffer + len, "\nMidi devices: NOT ENABLED IN CONFIG\n");
233 #else
234 len += sprintf(buffer + len, "\nMidi devices:\n");
235 for (i = 0; (i < num_midis) && (pos <= offset + length); i++) {
236 if (midi_devs[i] == NULL)
237 continue;
238 len += sprintf(buffer + len, "%d: %s\n", i, midi_devs[i]->info.name);
239 pos = begin + len;
240 if (pos < offset) {
241 len = 0;
242 begin = pos;
243 }
244 }
245 #endif
246
247 #ifdef CONFIG_SEQUENCER
248 len += sprintf(buffer + len, "\nTimers:\n");
249
250 for (i = 0; (i < num_sound_timers) && (pos <= offset + length); i++) {
251 if (sound_timer_devs[i] == NULL)
252 continue;
253 len += sprintf(buffer + len, "%d: %s\n", i, sound_timer_devs[i]->info.name);
254 pos = begin + len;
255 if (pos < offset) {
256 len = 0;
257 begin = pos;
258 }
259 }
260 #endif
261
262 len += sprintf(buffer + len, "\nMixers:\n");
263 for (i = 0; (i < num_mixers) && (pos <= offset + length); i++) {
264 if (mixer_devs[i] == NULL)
265 continue;
266 len += sprintf(buffer + len, "%d: %s\n", i, mixer_devs[i]->name);
267 pos = begin + len;
268 if (pos < offset) {
269 len = 0;
270 begin = pos;
271 }
272 }
273 *start = buffer + (offset - begin);
274 len -= (offset - begin);
275 if (len > length)
276 len = length;
277 return len;
278 }
279
280 static struct proc_dir_entry proc_root_sound = {
281 PROC_SOUND, 5, "sound",
282 S_IFREG | S_IRUGO, 1, 0, 0,
283 0, NULL, sound_proc_get_info
284 };
285
286 #ifndef MIN
287 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
288 #endif
289
290 /* 4K page size but our output routines use some slack for overruns */
291 #define PROC_BLOCK_SIZE (3*1024)
292
293 /*
294 * basically copied from fs/proc/generic.c:proc_file_read
295 * should be removed sometime in the future together with /dev/sndstat
296 * (a symlink /dev/sndstat -> /proc/sound will do as well)
297 */
298 static ssize_t sndstat_file_read(struct file * file, char * buf, size_t nbytes, loff_t *ppos)
299 {
300 char *page;
301 ssize_t retval=0;
302 int eof=0;
303 ssize_t n, count;
304 char *start;
305
306 if (!(page = (char*) __get_free_page(GFP_KERNEL)))
307 return -ENOMEM;
308
309 while ((nbytes > 0) && !eof)
310 {
311 count = MIN(PROC_BLOCK_SIZE, nbytes);
312
313 start = NULL;
314 n = sound_proc_get_info(page, &start, *ppos, count, 0);
315 if (n < count)
316 eof = 1;
317
318 if (!start) {
319 /*
320 * For proc files that are less than 4k
321 */
322 start = page + *ppos;
323 n -= *ppos;
324 if (n <= 0)
325 break;
326 if (n > count)
327 n = count;
328 }
329 if (n == 0)
330 break; /* End of file */
331 if (n < 0) {
332 if (retval == 0)
333 retval = n;
334 break;
335 }
336
337 n -= copy_to_user(buf, start, n); /* BUG ??? */
338 if (n == 0) {
339 if (retval == 0)
340 retval = -EFAULT;
341 break;
342 }
343
344 *ppos += n; /* Move down the file */
345 nbytes -= n;
346 buf += n;
347 retval += n;
348 }
349 free_page((unsigned long) page);
350 return retval;
351 }
352
353
354 static ssize_t sound_read(struct file *file, char *buf, size_t count, loff_t *ppos)
355 {
356 int dev = MINOR(file->f_dentry->d_inode->i_rdev);
357
358 DEB(printk("sound_read(dev=%d, count=%d)\n", dev, count));
359 switch (dev & 0x0f) {
360 case SND_DEV_STATUS:
361 return sndstat_file_read(file, buf, count, ppos);
362
363 #ifdef CONFIG_AUDIO
364 case SND_DEV_DSP:
365 case SND_DEV_DSP16:
366 case SND_DEV_AUDIO:
367 return audio_read(dev, file, buf, count);
368 #endif
369
370 #ifdef CONFIG_SEQUENCER
371 case SND_DEV_SEQ:
372 case SND_DEV_SEQ2:
373 return sequencer_read(dev, file, buf, count);
374 #endif
375
376 #ifdef CONFIG_MIDI
377 case SND_DEV_MIDIN:
378 return MIDIbuf_read(dev, file, buf, count);
379 #endif
380
381 default:;
382 }
383 return -EINVAL;
384 }
385
386 static ssize_t sound_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
387 {
388 int dev = MINOR(file->f_dentry->d_inode->i_rdev);
389
390 DEB(printk("sound_write(dev=%d, count=%d)\n", dev, count));
391 switch (dev & 0x0f) {
392 #ifdef CONFIG_SEQUENCER
393 case SND_DEV_SEQ:
394 case SND_DEV_SEQ2:
395 return sequencer_write(dev, file, buf, count);
396 #endif
397
398 #ifdef CONFIG_AUDIO
399 case SND_DEV_DSP:
400 case SND_DEV_DSP16:
401 case SND_DEV_AUDIO:
402 return audio_write(dev, file, buf, count);
403 #endif
404
405 #ifdef CONFIG_MIDI
406 case SND_DEV_MIDIN:
407 return MIDIbuf_write(dev, file, buf, count);
408 #endif
409 }
410 return -EINVAL;
411 }
412
413 static long long sound_lseek(struct file *file, long long offset, int orig)
414 {
415 return -ESPIPE;
416 }
417
418 static int sound_open(struct inode *inode, struct file *file)
419 {
420 int dev, retval;
421
422 if (is_unloading) {
423 /* printk(KERN_ERR "Sound: Driver partially removed. Can't open device\n");*/
424 return -EBUSY;
425 }
426 dev = MINOR(inode->i_rdev);
427 if (!soundcard_configured && dev != SND_DEV_CTL && dev != SND_DEV_STATUS) {
428 /* printk("SoundCard Error: The soundcard system has not been configured\n");*/
429 return -ENXIO;
430 }
431 DEB(printk("sound_open(dev=%d)\n", dev));
432 if ((dev >= SND_NDEVS) || (dev < 0)) {
433 printk(KERN_ERR "Invalid minor device %d\n", dev);
434 return -ENXIO;
435 }
436 switch (dev & 0x0f) {
437 case SND_DEV_STATUS:
438 break;
439
440 case SND_DEV_CTL:
441 dev >>= 4;
442 #ifdef CONFIG_KERNELD
443 if (dev >= 0 && dev < MAX_MIXER_DEV && mixer_devs[dev] == NULL) {
444 char modname[20];
445 sprintf(modname, "mixer%d", dev);
446 request_module(modname);
447 }
448 #endif
449 if (dev && (dev >= num_mixers || mixer_devs[dev] == NULL))
450 return -ENXIO;
451 break;
452
453 #ifdef CONFIG_SEQUENCER
454 case SND_DEV_SEQ:
455 case SND_DEV_SEQ2:
456 if ((retval = sequencer_open(dev, file)) < 0)
457 return retval;
458 break;
459 #endif
460
461 #ifdef CONFIG_MIDI
462 case SND_DEV_MIDIN:
463 if ((retval = MIDIbuf_open(dev, file)) < 0)
464 return retval;
465 break;
466 #endif
467
468 #ifdef CONFIG_AUDIO
469 case SND_DEV_DSP:
470 case SND_DEV_DSP16:
471 case SND_DEV_AUDIO:
472 if ((retval = audio_open(dev, file)) < 0)
473 return retval;
474 break;
475 #endif
476
477 default:
478 printk(KERN_ERR "Invalid minor device %d\n", dev);
479 return -ENXIO;
480 }
481 in_use++;
482 #ifdef MODULE
483 SOUND_INC_USE_COUNT;
484 #endif
485 return 0;
486 }
487
488 static int sound_release(struct inode *inode, struct file *file)
489 {
490 int dev = MINOR(inode->i_rdev);
491
492 DEB(printk("sound_release(dev=%d)\n", dev));
493 switch (dev & 0x0f) {
494 case SND_DEV_STATUS:
495 case SND_DEV_CTL:
496 break;
497
498 #ifdef CONFIG_SEQUENCER
499 case SND_DEV_SEQ:
500 case SND_DEV_SEQ2:
501 sequencer_release(dev, file);
502 break;
503 #endif
504
505 #ifdef CONFIG_MIDI
506 case SND_DEV_MIDIN:
507 MIDIbuf_release(dev, file);
508 break;
509 #endif
510
511 #ifdef CONFIG_AUDIO
512 case SND_DEV_DSP:
513 case SND_DEV_DSP16:
514 case SND_DEV_AUDIO:
515 audio_release(dev, file);
516 break;
517 #endif
518
519 default:
520 printk(KERN_ERR "Sound error: Releasing unknown device 0x%02x\n", dev);
521 }
522 in_use--;
523 #ifdef MODULE
524 SOUND_DEC_USE_COUNT;
525 #endif
526 return 0;
527 }
528
529 static int get_mixer_info(int dev, caddr_t arg)
530 {
531 mixer_info info;
532
533 strncpy(info.id, mixer_devs[dev]->id, sizeof(info.id));
534 strncpy(info.name, mixer_devs[dev]->name, sizeof(info.name));
535 info.name[sizeof(info.name)-1] = 0;
536 info.modify_counter = mixer_devs[dev]->modify_counter;
537 if (__copy_to_user(arg, &info, sizeof(info)))
538 return -EFAULT;
539 return 0;
540 }
541
542 static int get_old_mixer_info(int dev, caddr_t arg)
543 {
544 _old_mixer_info info;
545
546 strncpy(info.id, mixer_devs[dev]->id, sizeof(info.id));
547 strncpy(info.name, mixer_devs[dev]->name, sizeof(info.name));
548 info.name[sizeof(info.name)-1] = 0;
549 if (copy_to_user(arg, &info, sizeof(info)))
550 return -EFAULT;
551 return 0;
552 }
553
554 static int sound_mixer_ioctl(int mixdev, unsigned int cmd, caddr_t arg)
555 {
556 if (mixdev < 0 || mixdev >= MAX_MIXER_DEV)
557 return -ENXIO;
558 #ifdef CONFIG_KERNELD
559 /* Try to load the mixer... */
560 if (mixer_devs[mixdev] == NULL) {
561 char modname[20];
562 sprintf(modname, "mixer%d", mixdev);
563 request_module(modname);
564 }
565 #endif /* CONFIG_KERNELD */
566 if (mixdev >= num_mixers || !mixer_devs[mixdev])
567 return -ENXIO;
568 if (cmd == SOUND_MIXER_INFO)
569 return get_mixer_info(mixdev, arg);
570 if (cmd == SOUND_OLD_MIXER_INFO)
571 return get_old_mixer_info(mixdev, arg);
572 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
573 mixer_devs[mixdev]->modify_counter++;
574 if (!mixer_devs[mixdev]->ioctl)
575 return -EINVAL;
576 return mixer_devs[mixdev]->ioctl(mixdev, cmd, arg);
577 }
578
579 static int sound_ioctl(struct inode *inode, struct file *file,
580 unsigned int cmd, unsigned long arg)
581 {
582 int err, len = 0, dtype;
583 int dev = MINOR(inode->i_rdev);
584
585 if (_SIOC_DIR(cmd) != _SIOC_NONE && _SIOC_DIR(cmd) != 0) {
586 /*
587 * Have to validate the address given by the process.
588 */
589 len = _SIOC_SIZE(cmd);
590 if (len < 1 || len > 65536 || arg == 0)
591 return -EFAULT;
592 if (_SIOC_DIR(cmd) & _SIOC_WRITE)
593 if ((err = verify_area(VERIFY_READ, (void *)arg, len)) < 0)
594 return err;
595 if (_SIOC_DIR(cmd) & _SIOC_READ)
596 if ((err = verify_area(VERIFY_WRITE, (void *)arg, len)) < 0)
597 return err;
598 }
599 DEB(printk("sound_ioctl(dev=%d, cmd=0x%x, arg=0x%x)\n", dev, cmd, arg));
600 if (cmd == OSS_GETVERSION)
601 return __put_user(SOUND_VERSION, (int *)arg);
602
603 if (_IOC_TYPE(cmd) == 'M' && num_mixers > 0 && /* Mixer ioctl */
604 (dev & 0x0f) != SND_DEV_CTL) {
605 dtype = dev & 0x0f;
606 switch (dtype) {
607 #ifdef CONFIG_AUDIO
608 case SND_DEV_DSP:
609 case SND_DEV_DSP16:
610 case SND_DEV_AUDIO:
611 return sound_mixer_ioctl(audio_devs[dev >> 4]->mixer_dev,
612 cmd, (caddr_t)arg);
613 #endif
614
615 default:
616 return sound_mixer_ioctl(dev >> 4, cmd, (caddr_t)arg);
617 }
618 }
619 switch (dev & 0x0f) {
620 case SND_DEV_CTL:
621 if (cmd == SOUND_MIXER_GETLEVELS)
622 return get_mixer_levels((caddr_t)arg);
623 if (cmd == SOUND_MIXER_SETLEVELS)
624 return set_mixer_levels((caddr_t)arg);
625 return sound_mixer_ioctl(dev >> 4, cmd, (caddr_t)arg);
626
627 #ifdef CONFIG_SEQUENCER
628 case SND_DEV_SEQ:
629 case SND_DEV_SEQ2:
630 return sequencer_ioctl(dev, file, cmd, (caddr_t)arg);
631 #endif
632
633 #ifdef CONFIG_AUDIO
634 case SND_DEV_DSP:
635 case SND_DEV_DSP16:
636 case SND_DEV_AUDIO:
637 return audio_ioctl(dev, file, cmd, (caddr_t)arg);
638 break;
639 #endif
640
641 #ifdef CONFIG_MIDI
642 case SND_DEV_MIDIN:
643 return MIDIbuf_ioctl(dev, file, cmd, (caddr_t)arg);
644 break;
645 #endif
646
647 }
648 return -EINVAL;
649 }
650
651 static unsigned int sound_poll(struct file *file, poll_table * wait)
652 {
653 struct inode *inode = file->f_dentry->d_inode;
654 int dev = MINOR(inode->i_rdev);
655
656 DEB(printk("sound_poll(dev=%d)\n", dev));
657 switch (dev & 0x0f) {
658 #if defined(CONFIG_SEQUENCER) || defined(MODULE)
659 case SND_DEV_SEQ:
660 case SND_DEV_SEQ2:
661 return sequencer_poll(dev, file, wait);
662 #endif
663
664 #if defined(CONFIG_MIDI)
665 case SND_DEV_MIDIN:
666 return MIDIbuf_poll(dev, file, wait);
667 #endif
668
669 #if defined(CONFIG_AUDIO) || defined(MODULE)
670 case SND_DEV_DSP:
671 case SND_DEV_DSP16:
672 case SND_DEV_AUDIO:
673 return DMAbuf_poll(file, dev >> 4, wait);
674 #endif
675 }
676 return 0;
677 }
678
679 static int sound_mmap(struct file *file, struct vm_area_struct *vma)
680 {
681 int dev_class;
682 unsigned long size;
683 struct dma_buffparms *dmap = NULL;
684 int dev = MINOR(file->f_dentry->d_inode->i_rdev);
685
686 dev_class = dev & 0x0f;
687 dev >>= 4;
688
689 if (dev_class != SND_DEV_DSP && dev_class != SND_DEV_DSP16 && dev_class != SND_DEV_AUDIO)
690 {
691 /* printk("Sound: mmap() not supported for other than audio devices\n");*/
692 return -EINVAL;
693 }
694 if (vma->vm_flags & VM_WRITE) /* Map write and read/write to the output buf */
695 dmap = audio_devs[dev]->dmap_out;
696 else if (vma->vm_flags & VM_READ)
697 dmap = audio_devs[dev]->dmap_in;
698 else
699 {
700 /* printk("Sound: Undefined mmap() access\n");*/
701 return -EINVAL;
702 }
703
704 if (dmap == NULL)
705 {
706 /* printk("Sound: mmap() error. dmap == NULL\n");*/
707 return -EIO;
708 }
709 if (dmap->raw_buf == NULL)
710 {
711 /* printk("Sound: mmap() called when raw_buf == NULL\n");*/
712 return -EIO;
713 }
714 if (dmap->mapping_flags)
715 {
716 /* printk("Sound: mmap() called twice for the same DMA buffer\n");*/
717 return -EIO;
718 }
719 if (vma->vm_offset != 0)
720 {
721 /* printk("Sound: mmap() offset must be 0.\n");*/
722 return -EINVAL;
723 }
724 size = vma->vm_end - vma->vm_start;
725
726 if (size != dmap->bytes_in_use)
727 {
728 printk(KERN_WARNING "Sound: mmap() size = %ld. Should be %d\n", size, dmap->bytes_in_use);
729 }
730 if (remap_page_range(vma->vm_start, virt_to_phys(dmap->raw_buf),
731 vma->vm_end - vma->vm_start,
732 vma->vm_page_prot))
733 return -EAGAIN;
734
735 vma->vm_file = file;
736 file->f_count++;
737
738 dmap->mapping_flags |= DMA_MAP_MAPPED;
739
740 memset(dmap->raw_buf,
741 dmap->neutral_byte,
742 dmap->bytes_in_use);
743 return 0;
744 }
745
746 static struct file_operations sound_fops =
747 {
748 sound_lseek,
749 sound_read,
750 sound_write,
751 NULL, /* sound_readdir */
752 sound_poll,
753 sound_ioctl,
754 sound_mmap,
755 sound_open,
756 sound_release
757 };
758
759 #ifdef MODULE
760 static void
761 #else
762 void
763 #endif
764 soundcard_init(void)
765 {
766 #ifndef MODULE
767 register_chrdev(sound_major, "sound", &sound_fops);
768 chrdev_registered = 1;
769 #endif
770
771 soundcard_configured = 1;
772
773 sndtable_init(); /* Initialize call tables and detect cards */
774
775
776 #ifdef FIXME
777 if (sndtable_get_cardcount() == 0)
778 return; /* No cards detected */
779 #endif
780
781 #if defined(CONFIG_AUDIO)
782 if (num_audiodevs || modular) /* Audio devices present */
783 {
784 audio_init_devices();
785 }
786 #endif
787
788
789 }
790
791 static unsigned int irqs = 0;
792
793 #ifdef MODULE
794 static void
795 free_all_irqs(void)
796 {
797 int i;
798
799 for (i = 0; i < 31; i++)
800 {
801 if (irqs & (1ul << i))
802 {
803 printk(KERN_WARNING "Sound warning: IRQ%d was left allocated - fixed.\n", i);
804 snd_release_irq(i);
805 }
806 }
807 irqs = 0;
808 }
809
810 char kernel_version[] = UTS_RELEASE;
811
812 #endif
813
814 static int sound[20] =
815 {0};
816
817 int init_module(void)
818 {
819 int err;
820 int ints[21];
821 int i;
822
823 /*
824 * "sound=" command line handling by Harald Milz.
825 */
826 i = 0;
827 while (i < 20 && sound[i])
828 ints[i + 1] = sound[i++];
829 ints[0] = i;
830
831 if (i)
832 sound_setup("sound=", ints);
833
834 err = register_chrdev(sound_major, "sound", &sound_fops);
835 if (err)
836 {
837 printk(KERN_ERR "sound: driver already loaded/included in kernel\n");
838 return err;
839 }
840 chrdev_registered = 1;
841 soundcard_init();
842
843 if (sound_nblocks >= 1024)
844 printk(KERN_ERR "Sound warning: Deallocation table was too small.\n");
845
846 if (proc_register(&proc_root, &proc_root_sound))
847 printk(KERN_ERR "sound: registering /proc/sound failed\n");
848 return 0;
849 }
850
851 #ifdef MODULE
852
853
854 void cleanup_module(void)
855 {
856 int i;
857
858 if (MOD_IN_USE)
859 {
860 return;
861 }
862 if (proc_unregister(&proc_root, PROC_SOUND))
863 printk(KERN_ERR "sound: unregistering /proc/sound failed\n");
864 if (chrdev_registered)
865 unregister_chrdev(sound_major, "sound");
866
867 #if defined(CONFIG_SEQUENCER) || defined(MODULE)
868 sound_stop_timer();
869 #endif
870
871 #ifdef CONFIG_LOWLEVEL_SOUND
872 {
873 extern void sound_unload_lowlevel_drivers(void);
874
875 sound_unload_lowlevel_drivers();
876 }
877 #endif
878 sound_unload_drivers();
879 free_all_irqs(); /* If something was left allocated by accident */
880 sequencer_unload();
881
882 for (i = 0; i < 8; i++)
883 {
884 if (dma_alloc_map[i] != DMA_MAP_UNAVAIL)
885 {
886 printk(KERN_ERR "Sound: Hmm, DMA%d was left allocated - fixed\n", i);
887 sound_free_dma(i);
888 }
889 }
890 for (i = 0; i < sound_nblocks; i++)
891 {
892 vfree(sound_mem_blocks[i]);
893 }
894
895 }
896 #endif
897
898 int snd_set_irq_handler(int interrupt_level, void (*iproc) (int, void *, struct pt_regs *), char *name, int *osp)
899 {
900 int retcode;
901 unsigned long flags;
902
903 save_flags(flags);
904 cli();
905 retcode = request_irq(interrupt_level, iproc, 0, name, NULL);
906
907 if (retcode < 0)
908 {
909 printk(KERN_ERR "Sound: IRQ%d already in use\n", interrupt_level);
910 }
911 else
912 irqs |= (1ul << interrupt_level);
913
914 restore_flags(flags);
915 return retcode;
916 }
917
918 void snd_release_irq(int vect)
919 {
920 if (!(irqs & (1ul << vect)))
921 return;
922
923 irqs &= ~(1ul << vect);
924 free_irq(vect, NULL);
925 }
926
927 int sound_alloc_dma(int chn, char *deviceID)
928 {
929 int err;
930
931 if ((err = request_dma(chn, deviceID)) != 0)
932 return err;
933
934 dma_alloc_map[chn] = DMA_MAP_FREE;
935
936 return 0;
937 }
938
939 int sound_open_dma(int chn, char *deviceID)
940 {
941 unsigned long flags;
942
943 if (chn < 0 || chn > 7 || chn == 4)
944 {
945 printk(KERN_ERR "sound_open_dma: Invalid DMA channel %d\n", chn);
946 return 1;
947 }
948 save_flags(flags);
949 cli();
950
951 if (dma_alloc_map[chn] != DMA_MAP_FREE)
952 {
953 printk("sound_open_dma: DMA channel %d busy or not allocated (%d)\n", chn, dma_alloc_map[chn]);
954 restore_flags(flags);
955 return 1;
956 }
957 dma_alloc_map[chn] = DMA_MAP_BUSY;
958 restore_flags(flags);
959 return 0;
960 }
961
962 void sound_free_dma(int chn)
963 {
964 if (dma_alloc_map[chn] == DMA_MAP_UNAVAIL)
965 {
966 /* printk( "sound_free_dma: Bad access to DMA channel %d\n", chn); */
967 return;
968 }
969 free_dma(chn);
970 dma_alloc_map[chn] = DMA_MAP_UNAVAIL;
971 }
972
973 void sound_close_dma(int chn)
974 {
975 unsigned long flags;
976
977 save_flags(flags);
978 cli();
979
980 if (dma_alloc_map[chn] != DMA_MAP_BUSY)
981 {
982 printk(KERN_ERR "sound_close_dma: Bad access to DMA channel %d\n", chn);
983 restore_flags(flags);
984 return;
985 }
986 dma_alloc_map[chn] = DMA_MAP_FREE;
987 restore_flags(flags);
988 }
989
990 #if defined(CONFIG_SEQUENCER) || defined(MODULE)
991
992 static void do_sequencer_timer(unsigned long dummy)
993 {
994 sequencer_timer(0);
995 }
996
997
998 static struct timer_list seq_timer =
999 {NULL, NULL, 0, 0, do_sequencer_timer};
1000
1001 void request_sound_timer(int count)
1002 {
1003 extern unsigned long seq_time;
1004
1005 if (count < 0)
1006 {
1007 seq_timer.expires = (-count) + jiffies;
1008 add_timer(&seq_timer);
1009 return;
1010 }
1011 count += seq_time;
1012
1013 count -= jiffies;
1014
1015 if (count < 1)
1016 count = 1;
1017
1018 seq_timer.expires = (count) + jiffies;
1019 add_timer(&seq_timer);
1020 }
1021
1022 void sound_stop_timer(void)
1023 {
1024 del_timer(&seq_timer);;
1025 }
1026 #endif
1027
1028 void conf_printf(char *name, struct address_info *hw_config)
1029 {
1030 if (!trace_init)
1031 return;
1032
1033 printk("<%s> at 0x%03x", name, hw_config->io_base);
1034
1035 if (hw_config->irq)
1036 printk(" irq %d", (hw_config->irq > 0) ? hw_config->irq : -hw_config->irq);
1037
1038 if (hw_config->dma != -1 || hw_config->dma2 != -1)
1039 {
1040 printk(" dma %d", hw_config->dma);
1041 if (hw_config->dma2 != -1)
1042 printk(",%d", hw_config->dma2);
1043 }
1044 printk("\n");
1045 }
1046
1047 void conf_printf2(char *name, int base, int irq, int dma, int dma2)
1048 {
1049 if (!trace_init)
1050 return;
1051
1052 printk("<%s> at 0x%03x", name, base);
1053
1054 if (irq)
1055 printk(" irq %d", (irq > 0) ? irq : -irq);
1056
1057 if (dma != -1 || dma2 != -1)
1058 {
1059 printk(" dma %d", dma);
1060 if (dma2 != -1)
1061 printk(",%d", dma2);
1062 }
1063 printk("\n");
1064 }
1065
1066 /*
1067 * Module and lock management
1068 */
1069
1070 struct notifier_block *sound_locker=(struct notifier_block *)0;
1071 static int lock_depth = 0;
1072
1073 #define SOUND_INC_USE_COUNT do { notifier_call_chain(&sound_locker, 1, 0); lock_depth++; } while(0);
1074 #define SOUND_DEC_USE_COUNT do { notifier_call_chain(&sound_locker, 0, 0); lock_depth--; } while(0);
1075
1076 /*
1077 * When a sound module is registered we need to bring it to the current
1078 * lock level...
1079 */
1080
1081 void sound_notifier_chain_register(struct notifier_block *bl)
1082 {
1083 int ct=0;
1084
1085 notifier_chain_register(&sound_locker, bl);
1086 /*
1087 * Normalise the lock count by calling the entry directly. We
1088 * have to call the module as it owns its own use counter
1089 */
1090 while(ct<lock_depth)
1091 {
1092 bl->notifier_call(bl, 1, 0);
1093 ct++;
1094 }
1095 }
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux