drm/hdcp: update content protection property with uevent
[sfrench/cifs-2.6.git] / sound / sound_core.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *      Sound core.  This file is composed of two parts.  sound_class
4  *      which is common to both OSS and ALSA and OSS sound core which
5  *      is used OSS or emulation of it.
6  */
7
8 /*
9  * First, the common part.
10  */
11 #include <linux/module.h>
12 #include <linux/device.h>
13 #include <linux/err.h>
14 #include <linux/kdev_t.h>
15 #include <linux/major.h>
16 #include <sound/core.h>
17
18 #ifdef CONFIG_SOUND_OSS_CORE
19 static int __init init_oss_soundcore(void);
20 static void cleanup_oss_soundcore(void);
21 #else
22 static inline int init_oss_soundcore(void)      { return 0; }
23 static inline void cleanup_oss_soundcore(void)  { }
24 #endif
25
26 struct class *sound_class;
27 EXPORT_SYMBOL(sound_class);
28
29 MODULE_DESCRIPTION("Core sound module");
30 MODULE_AUTHOR("Alan Cox");
31 MODULE_LICENSE("GPL");
32
33 static char *sound_devnode(struct device *dev, umode_t *mode)
34 {
35         if (MAJOR(dev->devt) == SOUND_MAJOR)
36                 return NULL;
37         return kasprintf(GFP_KERNEL, "snd/%s", dev_name(dev));
38 }
39
40 static int __init init_soundcore(void)
41 {
42         int rc;
43
44         rc = init_oss_soundcore();
45         if (rc)
46                 return rc;
47
48         sound_class = class_create(THIS_MODULE, "sound");
49         if (IS_ERR(sound_class)) {
50                 cleanup_oss_soundcore();
51                 return PTR_ERR(sound_class);
52         }
53
54         sound_class->devnode = sound_devnode;
55
56         return 0;
57 }
58
59 static void __exit cleanup_soundcore(void)
60 {
61         cleanup_oss_soundcore();
62         class_destroy(sound_class);
63 }
64
65 subsys_initcall(init_soundcore);
66 module_exit(cleanup_soundcore);
67
68
69 #ifdef CONFIG_SOUND_OSS_CORE
70 /*
71  *      OSS sound core handling. Breaks out sound functions to submodules
72  *      
73  *      Author:         Alan Cox <alan@lxorguk.ukuu.org.uk>
74  *
75  *      Fixes:
76  *
77  *                         --------------------
78  * 
79  *      Top level handler for the sound subsystem. Various devices can
80  *      plug into this. The fact they don't all go via OSS doesn't mean 
81  *      they don't have to implement the OSS API. There is a lot of logic
82  *      to keeping much of the OSS weight out of the code in a compatibility
83  *      module, but it's up to the driver to rember to load it...
84  *
85  *      The code provides a set of functions for registration of devices
86  *      by type. This is done rather than providing a single call so that
87  *      we can hide any future changes in the internals (eg when we go to
88  *      32bit dev_t) from the modules and their interface.
89  *
90  *      Secondly we need to allocate the dsp, dsp16 and audio devices as
91  *      one. Thus we misuse the chains a bit to simplify this.
92  *
93  *      Thirdly to make it more fun and for 2.3.x and above we do all
94  *      of this using fine grained locking.
95  *
96  *      FIXME: we have to resolve modules and fine grained load/unload
97  *      locking at some point in 2.3.x.
98  */
99
100 #include <linux/init.h>
101 #include <linux/slab.h>
102 #include <linux/types.h>
103 #include <linux/kernel.h>
104 #include <linux/sound.h>
105 #include <linux/kmod.h>
106
107 #define SOUND_STEP 16
108
109 struct sound_unit
110 {
111         int unit_minor;
112         const struct file_operations *unit_fops;
113         struct sound_unit *next;
114         char name[32];
115 };
116
117 /*
118  * By default, OSS sound_core claims full legacy minor range (0-255)
119  * of SOUND_MAJOR to trap open attempts to any sound minor and
120  * requests modules using custom sound-slot/service-* module aliases.
121  * The only benefit of doing this is allowing use of custom module
122  * aliases instead of the standard char-major-* ones.  This behavior
123  * prevents alternative OSS implementation and is scheduled to be
124  * removed.
125  *
126  * CONFIG_SOUND_OSS_CORE_PRECLAIM and soundcore.preclaim_oss kernel
127  * parameter are added to allow distros and developers to try and
128  * switch to alternative implementations without needing to rebuild
129  * the kernel in the meantime.  If preclaim_oss is non-zero, the
130  * kernel will behave the same as before.  All SOUND_MAJOR minors are
131  * preclaimed and the custom module aliases along with standard chrdev
132  * ones are emitted if a missing device is opened.  If preclaim_oss is
133  * zero, sound_core only grabs what's actually in use and for missing
134  * devices only the standard chrdev aliases are requested.
135  *
136  * All these clutters are scheduled to be removed along with
137  * sound-slot/service-* module aliases.
138  */
139 #ifdef CONFIG_SOUND_OSS_CORE_PRECLAIM
140 static int preclaim_oss = 1;
141 #else
142 static int preclaim_oss = 0;
143 #endif
144
145 module_param(preclaim_oss, int, 0444);
146
147 static int soundcore_open(struct inode *, struct file *);
148
149 static const struct file_operations soundcore_fops =
150 {
151         /* We must have an owner or the module locking fails */
152         .owner  = THIS_MODULE,
153         .open   = soundcore_open,
154         .llseek = noop_llseek,
155 };
156
157 /*
158  *      Low level list operator. Scan the ordered list, find a hole and
159  *      join into it. Called with the lock asserted
160  */
161
162 static int __sound_insert_unit(struct sound_unit * s, struct sound_unit **list, const struct file_operations *fops, int index, int low, int top)
163 {
164         int n=low;
165
166         if (index < 0) {        /* first free */
167
168                 while (*list && (*list)->unit_minor<n)
169                         list=&((*list)->next);
170
171                 while(n<top)
172                 {
173                         /* Found a hole ? */
174                         if(*list==NULL || (*list)->unit_minor>n)
175                                 break;
176                         list=&((*list)->next);
177                         n+=SOUND_STEP;
178                 }
179
180                 if(n>=top)
181                         return -ENOENT;
182         } else {
183                 n = low+(index*16);
184                 while (*list) {
185                         if ((*list)->unit_minor==n)
186                                 return -EBUSY;
187                         if ((*list)->unit_minor>n)
188                                 break;
189                         list=&((*list)->next);
190                 }
191         }       
192                 
193         /*
194          *      Fill it in
195          */
196          
197         s->unit_minor=n;
198         s->unit_fops=fops;
199         
200         /*
201          *      Link it
202          */
203          
204         s->next=*list;
205         *list=s;
206         
207         
208         return n;
209 }
210
211 /*
212  *      Remove a node from the chain. Called with the lock asserted
213  */
214  
215 static struct sound_unit *__sound_remove_unit(struct sound_unit **list, int unit)
216 {
217         while(*list)
218         {
219                 struct sound_unit *p=*list;
220                 if(p->unit_minor==unit)
221                 {
222                         *list=p->next;
223                         return p;
224                 }
225                 list=&(p->next);
226         }
227         printk(KERN_ERR "Sound device %d went missing!\n", unit);
228         return NULL;
229 }
230
231 /*
232  *      This lock guards the sound loader list.
233  */
234
235 static DEFINE_SPINLOCK(sound_loader_lock);
236
237 /*
238  *      Allocate the controlling structure and add it to the sound driver
239  *      list. Acquires locks as needed
240  */
241
242 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)
243 {
244         struct sound_unit *s = kmalloc(sizeof(*s), GFP_KERNEL);
245         int r;
246
247         if (!s)
248                 return -ENOMEM;
249
250         spin_lock(&sound_loader_lock);
251 retry:
252         r = __sound_insert_unit(s, list, fops, index, low, top);
253         spin_unlock(&sound_loader_lock);
254         
255         if (r < 0)
256                 goto fail;
257         else if (r < SOUND_STEP)
258                 sprintf(s->name, "sound/%s", name);
259         else
260                 sprintf(s->name, "sound/%s%d", name, r / SOUND_STEP);
261
262         if (!preclaim_oss) {
263                 /*
264                  * Something else might have grabbed the minor.  If
265                  * first free slot is requested, rescan with @low set
266                  * to the next unit; otherwise, -EBUSY.
267                  */
268                 r = __register_chrdev(SOUND_MAJOR, s->unit_minor, 1, s->name,
269                                       &soundcore_fops);
270                 if (r < 0) {
271                         spin_lock(&sound_loader_lock);
272                         __sound_remove_unit(list, s->unit_minor);
273                         if (index < 0) {
274                                 low = s->unit_minor + SOUND_STEP;
275                                 goto retry;
276                         }
277                         spin_unlock(&sound_loader_lock);
278                         return -EBUSY;
279                 }
280         }
281
282         device_create(sound_class, dev, MKDEV(SOUND_MAJOR, s->unit_minor),
283                       NULL, "%s", s->name+6);
284         return s->unit_minor;
285
286 fail:
287         kfree(s);
288         return r;
289 }
290
291 /*
292  *      Remove a unit. Acquires locks as needed. The drivers MUST have
293  *      completed the removal before their file operations become
294  *      invalid.
295  */
296         
297 static void sound_remove_unit(struct sound_unit **list, int unit)
298 {
299         struct sound_unit *p;
300
301         spin_lock(&sound_loader_lock);
302         p = __sound_remove_unit(list, unit);
303         spin_unlock(&sound_loader_lock);
304         if (p) {
305                 if (!preclaim_oss)
306                         __unregister_chrdev(SOUND_MAJOR, p->unit_minor, 1,
307                                             p->name);
308                 device_destroy(sound_class, MKDEV(SOUND_MAJOR, p->unit_minor));
309                 kfree(p);
310         }
311 }
312
313 /*
314  *      Allocations
315  *
316  *      0       *16             Mixers
317  *      1       *8              Sequencers
318  *      2       *16             Midi
319  *      3       *16             DSP
320  *      4       *16             SunDSP
321  *      5       *16             DSP16
322  *      6       --              sndstat (obsolete)
323  *      7       *16             unused
324  *      8       --              alternate sequencer (see above)
325  *      9       *16             raw synthesizer access
326  *      10      *16             unused
327  *      11      *16             unused
328  *      12      *16             unused
329  *      13      *16             unused
330  *      14      *16             unused
331  *      15      *16             unused
332  */
333
334 static struct sound_unit *chains[SOUND_STEP];
335
336 /**
337  *      register_sound_special_device - register a special sound node
338  *      @fops: File operations for the driver
339  *      @unit: Unit number to allocate
340  *      @dev: device pointer
341  *
342  *      Allocate a special sound device by minor number from the sound
343  *      subsystem.
344  *
345  *      Return: The allocated number is returned on success. On failure,
346  *      a negative error code is returned.
347  */
348  
349 int register_sound_special_device(const struct file_operations *fops, int unit,
350                                   struct device *dev)
351 {
352         const int chain = unit % SOUND_STEP;
353         int max_unit = 256;
354         const char *name;
355         char _name[16];
356
357         switch (chain) {
358             case 0:
359                 name = "mixer";
360                 break;
361             case 1:
362                 name = "sequencer";
363                 if (unit >= SOUND_STEP)
364                         goto __unknown;
365                 max_unit = unit + 1;
366                 break;
367             case 2:
368                 name = "midi";
369                 break;
370             case 3:
371                 name = "dsp";
372                 break;
373             case 4:
374                 name = "audio";
375                 break;
376             case 5:
377                 name = "dspW";
378                 break;
379             case 8:
380                 name = "sequencer2";
381                 if (unit >= SOUND_STEP)
382                         goto __unknown;
383                 max_unit = unit + 1;
384                 break;
385             case 9:
386                 name = "dmmidi";
387                 break;
388             case 10:
389                 name = "dmfm";
390                 break;
391             case 12:
392                 name = "adsp";
393                 break;
394             case 13:
395                 name = "amidi";
396                 break;
397             case 14:
398                 name = "admmidi";
399                 break;
400             default:
401                 {
402                     __unknown:
403                         sprintf(_name, "unknown%d", chain);
404                         if (unit >= SOUND_STEP)
405                                 strcat(_name, "-");
406                         name = _name;
407                 }
408                 break;
409         }
410         return sound_insert_unit(&chains[chain], fops, -1, unit, max_unit,
411                                  name, 0600, dev);
412 }
413  
414 EXPORT_SYMBOL(register_sound_special_device);
415
416 int register_sound_special(const struct file_operations *fops, int unit)
417 {
418         return register_sound_special_device(fops, unit, NULL);
419 }
420
421 EXPORT_SYMBOL(register_sound_special);
422
423 /**
424  *      register_sound_mixer - register a mixer device
425  *      @fops: File operations for the driver
426  *      @dev: Unit number to allocate
427  *
428  *      Allocate a mixer device. Unit is the number of the mixer requested.
429  *      Pass -1 to request the next free mixer unit.
430  *
431  *      Return: On success, the allocated number is returned. On failure,
432  *      a negative error code is returned.
433  */
434
435 int register_sound_mixer(const struct file_operations *fops, int dev)
436 {
437         return sound_insert_unit(&chains[0], fops, dev, 0, 128,
438                                  "mixer", 0600, NULL);
439 }
440
441 EXPORT_SYMBOL(register_sound_mixer);
442
443 /*
444  *      DSP's are registered as a triple. Register only one and cheat
445  *      in open - see below.
446  */
447  
448 /**
449  *      register_sound_dsp - register a DSP device
450  *      @fops: File operations for the driver
451  *      @dev: Unit number to allocate
452  *
453  *      Allocate a DSP device. Unit is the number of the DSP requested.
454  *      Pass -1 to request the next free DSP unit.
455  *
456  *      This function allocates both the audio and dsp device entries together
457  *      and will always allocate them as a matching pair - eg dsp3/audio3
458  *
459  *      Return: On success, the allocated number is returned. On failure,
460  *      a negative error code is returned.
461  */
462
463 int register_sound_dsp(const struct file_operations *fops, int dev)
464 {
465         return sound_insert_unit(&chains[3], fops, dev, 3, 131,
466                                  "dsp", 0600, NULL);
467 }
468
469 EXPORT_SYMBOL(register_sound_dsp);
470
471 /**
472  *      unregister_sound_special - unregister a special sound device
473  *      @unit: unit number to allocate
474  *
475  *      Release a sound device that was allocated with
476  *      register_sound_special(). The unit passed is the return value from
477  *      the register function.
478  */
479
480
481 void unregister_sound_special(int unit)
482 {
483         sound_remove_unit(&chains[unit % SOUND_STEP], unit);
484 }
485  
486 EXPORT_SYMBOL(unregister_sound_special);
487
488 /**
489  *      unregister_sound_mixer - unregister a mixer
490  *      @unit: unit number to allocate
491  *
492  *      Release a sound device that was allocated with register_sound_mixer().
493  *      The unit passed is the return value from the register function.
494  */
495
496 void unregister_sound_mixer(int unit)
497 {
498         sound_remove_unit(&chains[0], unit);
499 }
500
501 EXPORT_SYMBOL(unregister_sound_mixer);
502
503 /**
504  *      unregister_sound_dsp - unregister a DSP device
505  *      @unit: unit number to allocate
506  *
507  *      Release a sound device that was allocated with register_sound_dsp().
508  *      The unit passed is the return value from the register function.
509  *
510  *      Both of the allocated units are released together automatically.
511  */
512
513 void unregister_sound_dsp(int unit)
514 {
515         sound_remove_unit(&chains[3], unit);
516 }
517
518
519 EXPORT_SYMBOL(unregister_sound_dsp);
520
521 static struct sound_unit *__look_for_unit(int chain, int unit)
522 {
523         struct sound_unit *s;
524         
525         s=chains[chain];
526         while(s && s->unit_minor <= unit)
527         {
528                 if(s->unit_minor==unit)
529                         return s;
530                 s=s->next;
531         }
532         return NULL;
533 }
534
535 static int soundcore_open(struct inode *inode, struct file *file)
536 {
537         int chain;
538         int unit = iminor(inode);
539         struct sound_unit *s;
540         const struct file_operations *new_fops = NULL;
541
542         chain=unit&0x0F;
543         if(chain==4 || chain==5)        /* dsp/audio/dsp16 */
544         {
545                 unit&=0xF0;
546                 unit|=3;
547                 chain=3;
548         }
549         
550         spin_lock(&sound_loader_lock);
551         s = __look_for_unit(chain, unit);
552         if (s)
553                 new_fops = fops_get(s->unit_fops);
554         if (preclaim_oss && !new_fops) {
555                 spin_unlock(&sound_loader_lock);
556
557                 /*
558                  *  Please, don't change this order or code.
559                  *  For ALSA slot means soundcard and OSS emulation code
560                  *  comes as add-on modules which aren't depend on
561                  *  ALSA toplevel modules for soundcards, thus we need
562                  *  load them at first.   [Jaroslav Kysela <perex@jcu.cz>]
563                  */
564                 request_module("sound-slot-%i", unit>>4);
565                 request_module("sound-service-%i-%i", unit>>4, chain);
566
567                 /*
568                  * sound-slot/service-* module aliases are scheduled
569                  * for removal in favor of the standard char-major-*
570                  * module aliases.  For the time being, generate both
571                  * the legacy and standard module aliases to ease
572                  * transition.
573                  */
574                 if (request_module("char-major-%d-%d", SOUND_MAJOR, unit) > 0)
575                         request_module("char-major-%d", SOUND_MAJOR);
576
577                 spin_lock(&sound_loader_lock);
578                 s = __look_for_unit(chain, unit);
579                 if (s)
580                         new_fops = fops_get(s->unit_fops);
581         }
582         spin_unlock(&sound_loader_lock);
583         if (new_fops) {
584                 /*
585                  * We rely upon the fact that we can't be unloaded while the
586                  * subdriver is there.
587                  */
588                 int err = 0;
589                 replace_fops(file, new_fops);
590
591                 if (file->f_op->open)
592                         err = file->f_op->open(inode,file);
593
594                 return err;
595         }
596         return -ENODEV;
597 }
598
599 MODULE_ALIAS_CHARDEV_MAJOR(SOUND_MAJOR);
600
601 static void cleanup_oss_soundcore(void)
602 {
603         /* We have nothing to really do here - we know the lists must be
604            empty */
605         unregister_chrdev(SOUND_MAJOR, "sound");
606 }
607
608 static int __init init_oss_soundcore(void)
609 {
610         if (preclaim_oss &&
611             register_chrdev(SOUND_MAJOR, "sound", &soundcore_fops) < 0) {
612                 printk(KERN_ERR "soundcore: sound device already in use.\n");
613                 return -EBUSY;
614         }
615
616         return 0;
617 }
618
619 #endif /* CONFIG_SOUND_OSS_CORE */