1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Advanced Linux Sound Architecture
4 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
7 #include <linux/init.h>
8 #include <linux/slab.h>
9 #include <linux/time.h>
10 #include <linux/device.h>
11 #include <linux/module.h>
12 #include <linux/debugfs.h>
13 #include <sound/core.h>
14 #include <sound/minors.h>
15 #include <sound/info.h>
16 #include <sound/control.h>
17 #include <sound/initval.h>
18 #include <linux/kmod.h>
19 #include <linux/mutex.h>
21 static int major
= CONFIG_SND_MAJOR
;
23 EXPORT_SYMBOL(snd_major
);
25 static int cards_limit
= 1;
27 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
28 MODULE_DESCRIPTION("Advanced Linux Sound Architecture driver for soundcards.");
29 MODULE_LICENSE("GPL");
30 module_param(major
, int, 0444);
31 MODULE_PARM_DESC(major
, "Major # for sound driver.");
32 module_param(cards_limit
, int, 0444);
33 MODULE_PARM_DESC(cards_limit
, "Count of auto-loadable soundcards.");
34 MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR
);
36 /* this one holds the actual max. card number currently available.
37 * as default, it's identical with cards_limit option. when more
38 * modules are loaded manually, this limit number increases, too.
41 EXPORT_SYMBOL(snd_ecards_limit
);
43 #ifdef CONFIG_SND_DEBUG
44 struct dentry
*sound_debugfs_root
;
45 EXPORT_SYMBOL_GPL(sound_debugfs_root
);
48 static struct snd_minor
*snd_minors
[SNDRV_OS_MINORS
];
49 static DEFINE_MUTEX(sound_mutex
);
54 * snd_request_card - try to load the card module
55 * @card: the card number
57 * Tries to load the module "snd-card-X" for the given card number
58 * via request_module. Returns immediately if already loaded.
60 void snd_request_card(int card
)
62 if (snd_card_locked(card
))
64 if (card
< 0 || card
>= cards_limit
)
66 request_module("snd-card-%i", card
);
68 EXPORT_SYMBOL(snd_request_card
);
70 static void snd_request_other(int minor
)
75 case SNDRV_MINOR_SEQUENCER
: str
= "snd-seq"; break;
76 case SNDRV_MINOR_TIMER
: str
= "snd-timer"; break;
82 #endif /* modular kernel */
85 * snd_lookup_minor_data - get user data of a registered device
86 * @minor: the minor number
87 * @type: device type (SNDRV_DEVICE_TYPE_XXX)
89 * Checks that a minor device with the specified type is registered, and returns
90 * its user data pointer.
92 * This function increments the reference counter of the card instance
93 * if an associated instance with the given minor number and type is found.
94 * The caller must call snd_card_unref() appropriately later.
96 * Return: The user data pointer if the specified device is found. %NULL
99 void *snd_lookup_minor_data(unsigned int minor
, int type
)
101 struct snd_minor
*mreg
;
104 if (minor
>= ARRAY_SIZE(snd_minors
))
106 mutex_lock(&sound_mutex
);
107 mreg
= snd_minors
[minor
];
108 if (mreg
&& mreg
->type
== type
) {
109 private_data
= mreg
->private_data
;
110 if (private_data
&& mreg
->card_ptr
)
111 get_device(&mreg
->card_ptr
->card_dev
);
114 mutex_unlock(&sound_mutex
);
117 EXPORT_SYMBOL(snd_lookup_minor_data
);
119 #ifdef CONFIG_MODULES
120 static struct snd_minor
*autoload_device(unsigned int minor
)
123 mutex_unlock(&sound_mutex
); /* release lock temporarily */
124 dev
= SNDRV_MINOR_DEVICE(minor
);
125 if (dev
== SNDRV_MINOR_CONTROL
) {
127 int card
= SNDRV_MINOR_CARD(minor
);
128 struct snd_card
*ref
= snd_card_ref(card
);
130 snd_request_card(card
);
133 } else if (dev
== SNDRV_MINOR_GLOBAL
) {
135 snd_request_other(minor
);
137 mutex_lock(&sound_mutex
); /* reacuire lock */
138 return snd_minors
[minor
];
140 #else /* !CONFIG_MODULES */
141 #define autoload_device(minor) NULL
142 #endif /* CONFIG_MODULES */
144 static int snd_open(struct inode
*inode
, struct file
*file
)
146 unsigned int minor
= iminor(inode
);
147 struct snd_minor
*mptr
= NULL
;
148 const struct file_operations
*new_fops
;
151 if (minor
>= ARRAY_SIZE(snd_minors
))
153 mutex_lock(&sound_mutex
);
154 mptr
= snd_minors
[minor
];
156 mptr
= autoload_device(minor
);
158 mutex_unlock(&sound_mutex
);
162 new_fops
= fops_get(mptr
->f_ops
);
163 mutex_unlock(&sound_mutex
);
166 replace_fops(file
, new_fops
);
168 if (file
->f_op
->open
)
169 err
= file
->f_op
->open(inode
, file
);
173 static const struct file_operations snd_fops
=
175 .owner
= THIS_MODULE
,
177 .llseek
= noop_llseek
,
180 #ifdef CONFIG_SND_DYNAMIC_MINORS
181 static int snd_find_free_minor(int type
, struct snd_card
*card
, int dev
)
185 /* static minors for module auto loading */
186 if (type
== SNDRV_DEVICE_TYPE_SEQUENCER
)
187 return SNDRV_MINOR_SEQUENCER
;
188 if (type
== SNDRV_DEVICE_TYPE_TIMER
)
189 return SNDRV_MINOR_TIMER
;
191 for (minor
= 0; minor
< ARRAY_SIZE(snd_minors
); ++minor
) {
192 /* skip static minors still used for module auto loading */
193 if (SNDRV_MINOR_DEVICE(minor
) == SNDRV_MINOR_CONTROL
)
195 if (minor
== SNDRV_MINOR_SEQUENCER
||
196 minor
== SNDRV_MINOR_TIMER
)
198 if (!snd_minors
[minor
])
204 static int snd_find_free_minor(int type
, struct snd_card
*card
, int dev
)
209 case SNDRV_DEVICE_TYPE_SEQUENCER
:
210 case SNDRV_DEVICE_TYPE_TIMER
:
213 case SNDRV_DEVICE_TYPE_CONTROL
:
214 if (snd_BUG_ON(!card
))
216 minor
= SNDRV_MINOR(card
->number
, type
);
218 case SNDRV_DEVICE_TYPE_HWDEP
:
219 case SNDRV_DEVICE_TYPE_RAWMIDI
:
220 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK
:
221 case SNDRV_DEVICE_TYPE_PCM_CAPTURE
:
222 case SNDRV_DEVICE_TYPE_COMPRESS
:
223 if (snd_BUG_ON(!card
))
225 minor
= SNDRV_MINOR(card
->number
, type
+ dev
);
230 if (snd_BUG_ON(minor
< 0 || minor
>= SNDRV_OS_MINORS
))
232 if (snd_minors
[minor
])
239 * snd_register_device - Register the ALSA device file for the card
240 * @type: the device type, SNDRV_DEVICE_TYPE_XXX
241 * @card: the card instance
242 * @dev: the device index
243 * @f_ops: the file operations
244 * @private_data: user pointer for f_ops->open()
245 * @device: the device to register
247 * Registers an ALSA device file for the given card.
248 * The operators have to be set in reg parameter.
250 * Return: Zero if successful, or a negative error code on failure.
252 int snd_register_device(int type
, struct snd_card
*card
, int dev
,
253 const struct file_operations
*f_ops
,
254 void *private_data
, struct device
*device
)
258 struct snd_minor
*preg
;
260 if (snd_BUG_ON(!device
))
263 preg
= kmalloc(sizeof *preg
, GFP_KERNEL
);
267 preg
->card
= card
? card
->number
: -1;
270 preg
->private_data
= private_data
;
271 preg
->card_ptr
= card
;
272 mutex_lock(&sound_mutex
);
273 minor
= snd_find_free_minor(type
, card
, dev
);
280 device
->devt
= MKDEV(major
, minor
);
281 err
= device_add(device
);
285 snd_minors
[minor
] = preg
;
287 mutex_unlock(&sound_mutex
);
292 EXPORT_SYMBOL(snd_register_device
);
295 * snd_unregister_device - unregister the device on the given card
296 * @dev: the device instance
298 * Unregisters the device file already registered via
299 * snd_register_device().
301 * Return: Zero if successful, or a negative error code on failure.
303 int snd_unregister_device(struct device
*dev
)
306 struct snd_minor
*preg
;
308 mutex_lock(&sound_mutex
);
309 for (minor
= 0; minor
< ARRAY_SIZE(snd_minors
); ++minor
) {
310 preg
= snd_minors
[minor
];
311 if (preg
&& preg
->dev
== dev
) {
312 snd_minors
[minor
] = NULL
;
318 mutex_unlock(&sound_mutex
);
319 if (minor
>= ARRAY_SIZE(snd_minors
))
323 EXPORT_SYMBOL(snd_unregister_device
);
325 #ifdef CONFIG_SND_PROC_FS
329 static const char *snd_device_type_name(int type
)
332 case SNDRV_DEVICE_TYPE_CONTROL
:
334 case SNDRV_DEVICE_TYPE_HWDEP
:
335 return "hardware dependent";
336 case SNDRV_DEVICE_TYPE_RAWMIDI
:
338 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK
:
339 return "digital audio playback";
340 case SNDRV_DEVICE_TYPE_PCM_CAPTURE
:
341 return "digital audio capture";
342 case SNDRV_DEVICE_TYPE_SEQUENCER
:
344 case SNDRV_DEVICE_TYPE_TIMER
:
346 case SNDRV_DEVICE_TYPE_COMPRESS
:
353 static void snd_minor_info_read(struct snd_info_entry
*entry
, struct snd_info_buffer
*buffer
)
356 struct snd_minor
*mptr
;
358 mutex_lock(&sound_mutex
);
359 for (minor
= 0; minor
< SNDRV_OS_MINORS
; ++minor
) {
360 mptr
= snd_minors
[minor
];
363 if (mptr
->card
>= 0) {
364 if (mptr
->device
>= 0)
365 snd_iprintf(buffer
, "%3i: [%2i-%2i]: %s\n",
366 minor
, mptr
->card
, mptr
->device
,
367 snd_device_type_name(mptr
->type
));
369 snd_iprintf(buffer
, "%3i: [%2i] : %s\n",
371 snd_device_type_name(mptr
->type
));
373 snd_iprintf(buffer
, "%3i: : %s\n", minor
,
374 snd_device_type_name(mptr
->type
));
376 mutex_unlock(&sound_mutex
);
379 int __init
snd_minor_info_init(void)
381 struct snd_info_entry
*entry
;
383 entry
= snd_info_create_module_entry(THIS_MODULE
, "devices", NULL
);
386 entry
->c
.text
.read
= snd_minor_info_read
;
387 return snd_info_register(entry
); /* freed in error path */
389 #endif /* CONFIG_SND_PROC_FS */
395 static int __init
alsa_sound_init(void)
398 snd_ecards_limit
= cards_limit
;
399 if (register_chrdev(major
, "alsa", &snd_fops
)) {
400 pr_err("ALSA core: unable to register native major device number %d\n", major
);
403 if (snd_info_init() < 0) {
404 unregister_chrdev(major
, "alsa");
408 #ifdef CONFIG_SND_DEBUG
409 sound_debugfs_root
= debugfs_create_dir("sound", NULL
);
412 pr_info("Advanced Linux Sound Architecture Driver Initialized.\n");
417 static void __exit
alsa_sound_exit(void)
419 #ifdef CONFIG_SND_DEBUG
420 debugfs_remove(sound_debugfs_root
);
423 unregister_chrdev(major
, "alsa");
426 subsys_initcall(alsa_sound_init
);
427 module_exit(alsa_sound_exit
);