conn rcv_lock converted to spinlock, struct cor_sock created, kernel_packet skb_clone...
[cor_2_6_31.git] / sound / sound_core.c
bloba41f8b127f49cceb1432183c4943482d6f61997f
1 /*
2 * Sound core. This file is composed of two parts. sound_class
3 * which is common to both OSS and ALSA and OSS sound core which
4 * is used OSS or emulation of it.
5 */
7 /*
8 * First, the common part.
9 */
10 #include <linux/module.h>
11 #include <linux/device.h>
12 #include <linux/err.h>
13 #include <linux/kdev_t.h>
14 #include <linux/major.h>
15 #include <sound/core.h>
17 #ifdef CONFIG_SOUND_OSS_CORE
18 static int __init init_oss_soundcore(void);
19 static void cleanup_oss_soundcore(void);
20 #else
21 static inline int init_oss_soundcore(void) { return 0; }
22 static inline void cleanup_oss_soundcore(void) { }
23 #endif
25 struct class *sound_class;
26 EXPORT_SYMBOL(sound_class);
28 MODULE_DESCRIPTION("Core sound module");
29 MODULE_AUTHOR("Alan Cox");
30 MODULE_LICENSE("GPL");
32 static char *sound_nodename(struct device *dev)
34 if (MAJOR(dev->devt) == SOUND_MAJOR)
35 return NULL;
36 return kasprintf(GFP_KERNEL, "snd/%s", dev_name(dev));
39 static int __init init_soundcore(void)
41 int rc;
43 rc = init_oss_soundcore();
44 if (rc)
45 return rc;
47 sound_class = class_create(THIS_MODULE, "sound");
48 if (IS_ERR(sound_class)) {
49 cleanup_oss_soundcore();
50 return PTR_ERR(sound_class);
53 sound_class->nodename = sound_nodename;
55 return 0;
58 static void __exit cleanup_soundcore(void)
60 cleanup_oss_soundcore();
61 class_destroy(sound_class);
64 module_init(init_soundcore);
65 module_exit(cleanup_soundcore);
68 #ifdef CONFIG_SOUND_OSS_CORE
70 * OSS sound core handling. Breaks out sound functions to submodules
72 * Author: Alan Cox <alan@lxorguk.ukuu.org.uk>
74 * Fixes:
77 * This program is free software; you can redistribute it and/or
78 * modify it under the terms of the GNU General Public License
79 * as published by the Free Software Foundation; either version
80 * 2 of the License, or (at your option) any later version.
82 * --------------------
84 * Top level handler for the sound subsystem. Various devices can
85 * plug into this. The fact they don't all go via OSS doesn't mean
86 * they don't have to implement the OSS API. There is a lot of logic
87 * to keeping much of the OSS weight out of the code in a compatibility
88 * module, but it's up to the driver to rember to load it...
90 * The code provides a set of functions for registration of devices
91 * by type. This is done rather than providing a single call so that
92 * we can hide any future changes in the internals (eg when we go to
93 * 32bit dev_t) from the modules and their interface.
95 * Secondly we need to allocate the dsp, dsp16 and audio devices as
96 * one. Thus we misuse the chains a bit to simplify this.
98 * Thirdly to make it more fun and for 2.3.x and above we do all
99 * of this using fine grained locking.
101 * FIXME: we have to resolve modules and fine grained load/unload
102 * locking at some point in 2.3.x.
105 #include <linux/init.h>
106 #include <linux/slab.h>
107 #include <linux/smp_lock.h>
108 #include <linux/types.h>
109 #include <linux/kernel.h>
110 #include <linux/sound.h>
111 #include <linux/kmod.h>
113 #define SOUND_STEP 16
115 struct sound_unit
117 int unit_minor;
118 const struct file_operations *unit_fops;
119 struct sound_unit *next;
120 char name[32];
123 #ifdef CONFIG_SOUND_MSNDCLAS
124 extern int msnd_classic_init(void);
125 #endif
126 #ifdef CONFIG_SOUND_MSNDPIN
127 extern int msnd_pinnacle_init(void);
128 #endif
131 * Low level list operator. Scan the ordered list, find a hole and
132 * join into it. Called with the lock asserted
135 static int __sound_insert_unit(struct sound_unit * s, struct sound_unit **list, const struct file_operations *fops, int index, int low, int top)
137 int n=low;
139 if (index < 0) { /* first free */
141 while (*list && (*list)->unit_minor<n)
142 list=&((*list)->next);
144 while(n<top)
146 /* Found a hole ? */
147 if(*list==NULL || (*list)->unit_minor>n)
148 break;
149 list=&((*list)->next);
150 n+=SOUND_STEP;
153 if(n>=top)
154 return -ENOENT;
155 } else {
156 n = low+(index*16);
157 while (*list) {
158 if ((*list)->unit_minor==n)
159 return -EBUSY;
160 if ((*list)->unit_minor>n)
161 break;
162 list=&((*list)->next);
167 * Fill it in
170 s->unit_minor=n;
171 s->unit_fops=fops;
174 * Link it
177 s->next=*list;
178 *list=s;
181 return n;
185 * Remove a node from the chain. Called with the lock asserted
188 static struct sound_unit *__sound_remove_unit(struct sound_unit **list, int unit)
190 while(*list)
192 struct sound_unit *p=*list;
193 if(p->unit_minor==unit)
195 *list=p->next;
196 return p;
198 list=&(p->next);
200 printk(KERN_ERR "Sound device %d went missing!\n", unit);
201 return NULL;
205 * This lock guards the sound loader list.
208 static DEFINE_SPINLOCK(sound_loader_lock);
211 * Allocate the controlling structure and add it to the sound driver
212 * list. Acquires locks as needed
215 static int sound_insert_unit(struct sound_unit **list, const struct file_operations *fops, int index, int low, int top, const char *name, umode_t mode, struct device *dev)
217 struct sound_unit *s = kmalloc(sizeof(*s), GFP_KERNEL);
218 int r;
220 if (!s)
221 return -ENOMEM;
223 spin_lock(&sound_loader_lock);
224 r = __sound_insert_unit(s, list, fops, index, low, top);
225 spin_unlock(&sound_loader_lock);
227 if (r < 0)
228 goto fail;
229 else if (r < SOUND_STEP)
230 sprintf(s->name, "sound/%s", name);
231 else
232 sprintf(s->name, "sound/%s%d", name, r / SOUND_STEP);
234 device_create(sound_class, dev, MKDEV(SOUND_MAJOR, s->unit_minor),
235 NULL, s->name+6);
236 return r;
238 fail:
239 kfree(s);
240 return r;
244 * Remove a unit. Acquires locks as needed. The drivers MUST have
245 * completed the removal before their file operations become
246 * invalid.
249 static void sound_remove_unit(struct sound_unit **list, int unit)
251 struct sound_unit *p;
253 spin_lock(&sound_loader_lock);
254 p = __sound_remove_unit(list, unit);
255 spin_unlock(&sound_loader_lock);
256 if (p) {
257 device_destroy(sound_class, MKDEV(SOUND_MAJOR, p->unit_minor));
258 kfree(p);
263 * Allocations
265 * 0 *16 Mixers
266 * 1 *8 Sequencers
267 * 2 *16 Midi
268 * 3 *16 DSP
269 * 4 *16 SunDSP
270 * 5 *16 DSP16
271 * 6 -- sndstat (obsolete)
272 * 7 *16 unused
273 * 8 -- alternate sequencer (see above)
274 * 9 *16 raw synthesizer access
275 * 10 *16 unused
276 * 11 *16 unused
277 * 12 *16 unused
278 * 13 *16 unused
279 * 14 *16 unused
280 * 15 *16 unused
283 static struct sound_unit *chains[SOUND_STEP];
286 * register_sound_special_device - register a special sound node
287 * @fops: File operations for the driver
288 * @unit: Unit number to allocate
289 * @dev: device pointer
291 * Allocate a special sound device by minor number from the sound
292 * subsystem. The allocated number is returned on succes. On failure
293 * a negative error code is returned.
296 int register_sound_special_device(const struct file_operations *fops, int unit,
297 struct device *dev)
299 const int chain = unit % SOUND_STEP;
300 int max_unit = 128 + chain;
301 const char *name;
302 char _name[16];
304 switch (chain) {
305 case 0:
306 name = "mixer";
307 break;
308 case 1:
309 name = "sequencer";
310 if (unit >= SOUND_STEP)
311 goto __unknown;
312 max_unit = unit + 1;
313 break;
314 case 2:
315 name = "midi";
316 break;
317 case 3:
318 name = "dsp";
319 break;
320 case 4:
321 name = "audio";
322 break;
323 case 8:
324 name = "sequencer2";
325 if (unit >= SOUND_STEP)
326 goto __unknown;
327 max_unit = unit + 1;
328 break;
329 case 9:
330 name = "dmmidi";
331 break;
332 case 10:
333 name = "dmfm";
334 break;
335 case 12:
336 name = "adsp";
337 break;
338 case 13:
339 name = "amidi";
340 break;
341 case 14:
342 name = "admmidi";
343 break;
344 default:
346 __unknown:
347 sprintf(_name, "unknown%d", chain);
348 if (unit >= SOUND_STEP)
349 strcat(_name, "-");
350 name = _name;
352 break;
354 return sound_insert_unit(&chains[chain], fops, -1, unit, max_unit,
355 name, S_IRUSR | S_IWUSR, dev);
358 EXPORT_SYMBOL(register_sound_special_device);
360 int register_sound_special(const struct file_operations *fops, int unit)
362 return register_sound_special_device(fops, unit, NULL);
365 EXPORT_SYMBOL(register_sound_special);
368 * register_sound_mixer - register a mixer device
369 * @fops: File operations for the driver
370 * @dev: Unit number to allocate
372 * Allocate a mixer device. Unit is the number of the mixer requested.
373 * Pass -1 to request the next free mixer unit. On success the allocated
374 * number is returned, on failure a negative error code is returned.
377 int register_sound_mixer(const struct file_operations *fops, int dev)
379 return sound_insert_unit(&chains[0], fops, dev, 0, 128,
380 "mixer", S_IRUSR | S_IWUSR, NULL);
383 EXPORT_SYMBOL(register_sound_mixer);
386 * register_sound_midi - register a midi device
387 * @fops: File operations for the driver
388 * @dev: Unit number to allocate
390 * Allocate a midi device. Unit is the number of the midi device requested.
391 * Pass -1 to request the next free midi unit. On success the allocated
392 * number is returned, on failure a negative error code is returned.
395 int register_sound_midi(const struct file_operations *fops, int dev)
397 return sound_insert_unit(&chains[2], fops, dev, 2, 130,
398 "midi", S_IRUSR | S_IWUSR, NULL);
401 EXPORT_SYMBOL(register_sound_midi);
404 * DSP's are registered as a triple. Register only one and cheat
405 * in open - see below.
409 * register_sound_dsp - register a DSP device
410 * @fops: File operations for the driver
411 * @dev: Unit number to allocate
413 * Allocate a DSP device. Unit is the number of the DSP requested.
414 * Pass -1 to request the next free DSP unit. On success the allocated
415 * number is returned, on failure a negative error code is returned.
417 * This function allocates both the audio and dsp device entries together
418 * and will always allocate them as a matching pair - eg dsp3/audio3
421 int register_sound_dsp(const struct file_operations *fops, int dev)
423 return sound_insert_unit(&chains[3], fops, dev, 3, 131,
424 "dsp", S_IWUSR | S_IRUSR, NULL);
427 EXPORT_SYMBOL(register_sound_dsp);
430 * unregister_sound_special - unregister a special sound device
431 * @unit: unit number to allocate
433 * Release a sound device that was allocated with
434 * register_sound_special(). The unit passed is the return value from
435 * the register function.
439 void unregister_sound_special(int unit)
441 sound_remove_unit(&chains[unit % SOUND_STEP], unit);
444 EXPORT_SYMBOL(unregister_sound_special);
447 * unregister_sound_mixer - unregister a mixer
448 * @unit: unit number to allocate
450 * Release a sound device that was allocated with register_sound_mixer().
451 * The unit passed is the return value from the register function.
454 void unregister_sound_mixer(int unit)
456 sound_remove_unit(&chains[0], unit);
459 EXPORT_SYMBOL(unregister_sound_mixer);
462 * unregister_sound_midi - unregister a midi device
463 * @unit: unit number to allocate
465 * Release a sound device that was allocated with register_sound_midi().
466 * The unit passed is the return value from the register function.
469 void unregister_sound_midi(int unit)
471 sound_remove_unit(&chains[2], unit);
474 EXPORT_SYMBOL(unregister_sound_midi);
477 * unregister_sound_dsp - unregister a DSP device
478 * @unit: unit number to allocate
480 * Release a sound device that was allocated with register_sound_dsp().
481 * The unit passed is the return value from the register function.
483 * Both of the allocated units are released together automatically.
486 void unregister_sound_dsp(int unit)
488 sound_remove_unit(&chains[3], unit);
492 EXPORT_SYMBOL(unregister_sound_dsp);
495 * Now our file operations
498 static int soundcore_open(struct inode *, struct file *);
500 static const struct file_operations soundcore_fops=
502 /* We must have an owner or the module locking fails */
503 .owner = THIS_MODULE,
504 .open = soundcore_open,
507 static struct sound_unit *__look_for_unit(int chain, int unit)
509 struct sound_unit *s;
511 s=chains[chain];
512 while(s && s->unit_minor <= unit)
514 if(s->unit_minor==unit)
515 return s;
516 s=s->next;
518 return NULL;
521 static int soundcore_open(struct inode *inode, struct file *file)
523 int chain;
524 int unit = iminor(inode);
525 struct sound_unit *s;
526 const struct file_operations *new_fops = NULL;
528 lock_kernel ();
530 chain=unit&0x0F;
531 if(chain==4 || chain==5) /* dsp/audio/dsp16 */
533 unit&=0xF0;
534 unit|=3;
535 chain=3;
538 spin_lock(&sound_loader_lock);
539 s = __look_for_unit(chain, unit);
540 if (s)
541 new_fops = fops_get(s->unit_fops);
542 if (!new_fops) {
543 spin_unlock(&sound_loader_lock);
545 * Please, don't change this order or code.
546 * For ALSA slot means soundcard and OSS emulation code
547 * comes as add-on modules which aren't depend on
548 * ALSA toplevel modules for soundcards, thus we need
549 * load them at first. [Jaroslav Kysela <perex@jcu.cz>]
551 request_module("sound-slot-%i", unit>>4);
552 request_module("sound-service-%i-%i", unit>>4, chain);
553 spin_lock(&sound_loader_lock);
554 s = __look_for_unit(chain, unit);
555 if (s)
556 new_fops = fops_get(s->unit_fops);
558 if (new_fops) {
560 * We rely upon the fact that we can't be unloaded while the
561 * subdriver is there, so if ->open() is successful we can
562 * safely drop the reference counter and if it is not we can
563 * revert to old ->f_op. Ugly, indeed, but that's the cost of
564 * switching ->f_op in the first place.
566 int err = 0;
567 const struct file_operations *old_fops = file->f_op;
568 file->f_op = new_fops;
569 spin_unlock(&sound_loader_lock);
570 if(file->f_op->open)
571 err = file->f_op->open(inode,file);
572 if (err) {
573 fops_put(file->f_op);
574 file->f_op = fops_get(old_fops);
576 fops_put(old_fops);
577 unlock_kernel();
578 return err;
580 spin_unlock(&sound_loader_lock);
581 unlock_kernel();
582 return -ENODEV;
585 MODULE_ALIAS_CHARDEV_MAJOR(SOUND_MAJOR);
587 static void cleanup_oss_soundcore(void)
589 /* We have nothing to really do here - we know the lists must be
590 empty */
591 unregister_chrdev(SOUND_MAJOR, "sound");
594 static int __init init_oss_soundcore(void)
596 if (register_chrdev(SOUND_MAJOR, "sound", &soundcore_fops)==-1) {
597 printk(KERN_ERR "soundcore: sound device already in use.\n");
598 return -EBUSY;
601 return 0;
604 #endif /* CONFIG_SOUND_OSS_CORE */