1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Advanced Linux Sound Architecture 4 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 5 */ 6 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> 20 21 static int major = CONFIG_SND_MAJOR; 22 int snd_major; 23 EXPORT_SYMBOL(snd_major); 24 25 static int cards_limit = 1; 26 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); 35 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. 39 */ 40 int snd_ecards_limit; 41 EXPORT_SYMBOL(snd_ecards_limit); 42 43 #ifdef CONFIG_SND_DEBUG 44 struct dentry *sound_debugfs_root; 45 EXPORT_SYMBOL_GPL(sound_debugfs_root); 46 #endif 47 48 static struct snd_minor *snd_minors[SNDRV_OS_MINORS]; 49 static DEFINE_MUTEX(sound_mutex); 50 51 #ifdef CONFIG_MODULES 52 53 /** 54 * snd_request_card - try to load the card module 55 * @card: the card number 56 * 57 * Tries to load the module "snd-card-X" for the given card number 58 * via request_module. Returns immediately if already loaded. 59 */ 60 void snd_request_card(int card) 61 { 62 if (snd_card_locked(card)) 63 return; 64 if (card < 0 || card >= cards_limit) 65 return; 66 request_module("snd-card-%i", card); 67 } 68 EXPORT_SYMBOL(snd_request_card); 69 70 static void snd_request_other(int minor) 71 { 72 char *str; 73 74 switch (minor) { 75 case SNDRV_MINOR_SEQUENCER: str = "snd-seq"; break; 76 case SNDRV_MINOR_TIMER: str = "snd-timer"; break; 77 default: return; 78 } 79 request_module(str); 80 } 81 82 #endif /* modular kernel */ 83 84 /** 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) 88 * 89 * Checks that a minor device with the specified type is registered, and returns 90 * its user data pointer. 91 * 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. 95 * 96 * Return: The user data pointer if the specified device is found. %NULL 97 * otherwise. 98 */ 99 void *snd_lookup_minor_data(unsigned int minor, int type) 100 { 101 struct snd_minor *mreg; 102 void *private_data; 103 104 if (minor >= ARRAY_SIZE(snd_minors)) 105 return NULL; 106 guard(mutex)(&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); 112 } else 113 private_data = NULL; 114 return private_data; 115 } 116 EXPORT_SYMBOL(snd_lookup_minor_data); 117 118 #ifdef CONFIG_MODULES 119 static struct snd_minor *autoload_device(unsigned int minor) 120 { 121 int dev; 122 mutex_unlock(&sound_mutex); /* release lock temporarily */ 123 dev = SNDRV_MINOR_DEVICE(minor); 124 if (dev == SNDRV_MINOR_CONTROL) { 125 /* /dev/aloadC? */ 126 int card = SNDRV_MINOR_CARD(minor); 127 struct snd_card *ref = snd_card_ref(card); 128 if (!ref) 129 snd_request_card(card); 130 else 131 snd_card_unref(ref); 132 } else if (dev == SNDRV_MINOR_GLOBAL) { 133 /* /dev/aloadSEQ */ 134 snd_request_other(minor); 135 } 136 mutex_lock(&sound_mutex); /* reacquire lock */ 137 return snd_minors[minor]; 138 } 139 #else /* !CONFIG_MODULES */ 140 #define autoload_device(minor) NULL 141 #endif /* CONFIG_MODULES */ 142 143 static int snd_open(struct inode *inode, struct file *file) 144 { 145 unsigned int minor = iminor(inode); 146 struct snd_minor *mptr = NULL; 147 const struct file_operations *new_fops; 148 int err = 0; 149 150 if (minor >= ARRAY_SIZE(snd_minors)) 151 return -ENODEV; 152 scoped_guard(mutex, &sound_mutex) { 153 mptr = snd_minors[minor]; 154 if (mptr == NULL) { 155 mptr = autoload_device(minor); 156 if (!mptr) 157 return -ENODEV; 158 } 159 new_fops = fops_get(mptr->f_ops); 160 } 161 if (!new_fops) 162 return -ENODEV; 163 replace_fops(file, new_fops); 164 165 if (file->f_op->open) 166 err = file->f_op->open(inode, file); 167 return err; 168 } 169 170 static const struct file_operations snd_fops = { 171 .owner = THIS_MODULE, 172 .open = snd_open, 173 .llseek = noop_llseek, 174 }; 175 176 #ifdef CONFIG_SND_DYNAMIC_MINORS 177 static int snd_find_free_minor(int type, struct snd_card *card, int dev) 178 { 179 int minor; 180 181 /* static minors for module auto loading */ 182 if (type == SNDRV_DEVICE_TYPE_SEQUENCER) 183 return SNDRV_MINOR_SEQUENCER; 184 if (type == SNDRV_DEVICE_TYPE_TIMER) 185 return SNDRV_MINOR_TIMER; 186 187 for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { 188 /* skip static minors still used for module auto loading */ 189 if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL) 190 continue; 191 if (minor == SNDRV_MINOR_SEQUENCER || 192 minor == SNDRV_MINOR_TIMER) 193 continue; 194 if (!snd_minors[minor]) 195 return minor; 196 } 197 return -EBUSY; 198 } 199 #else 200 static int snd_find_free_minor(int type, struct snd_card *card, int dev) 201 { 202 int minor; 203 204 switch (type) { 205 case SNDRV_DEVICE_TYPE_SEQUENCER: 206 case SNDRV_DEVICE_TYPE_TIMER: 207 minor = type; 208 break; 209 case SNDRV_DEVICE_TYPE_CONTROL: 210 if (snd_BUG_ON(!card)) 211 return -EINVAL; 212 minor = SNDRV_MINOR(card->number, type); 213 break; 214 case SNDRV_DEVICE_TYPE_HWDEP: 215 case SNDRV_DEVICE_TYPE_RAWMIDI: 216 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK: 217 case SNDRV_DEVICE_TYPE_PCM_CAPTURE: 218 if (snd_BUG_ON(!card)) 219 return -EINVAL; 220 minor = SNDRV_MINOR(card->number, type + dev); 221 break; 222 case SNDRV_DEVICE_TYPE_COMPRESS: 223 if (snd_BUG_ON(!card)) 224 return -EINVAL; 225 if (dev < 0 || 226 dev >= SNDRV_MINOR_HWDEP - SNDRV_MINOR_COMPRESS) 227 return -EINVAL; 228 minor = SNDRV_MINOR(card->number, type + dev); 229 break; 230 default: 231 return -EINVAL; 232 } 233 if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OS_MINORS)) 234 return -EINVAL; 235 if (snd_minors[minor]) 236 return -EBUSY; 237 return minor; 238 } 239 #endif 240 241 /** 242 * snd_register_device - Register the ALSA device file for the card 243 * @type: the device type, SNDRV_DEVICE_TYPE_XXX 244 * @card: the card instance 245 * @dev: the device index 246 * @f_ops: the file operations 247 * @private_data: user pointer for f_ops->open() 248 * @device: the device to register 249 * 250 * Registers an ALSA device file for the given card. 251 * The operators have to be set in reg parameter. 252 * 253 * Return: Zero if successful, or a negative error code on failure. 254 */ 255 int snd_register_device(int type, struct snd_card *card, int dev, 256 const struct file_operations *f_ops, 257 void *private_data, struct device *device) 258 { 259 int minor; 260 int err = 0; 261 struct snd_minor *preg; 262 263 if (snd_BUG_ON(!device)) 264 return -EINVAL; 265 266 preg = kmalloc_obj(*preg); 267 if (preg == NULL) 268 return -ENOMEM; 269 preg->type = type; 270 preg->card = card ? card->number : -1; 271 preg->device = dev; 272 preg->f_ops = f_ops; 273 preg->private_data = private_data; 274 preg->card_ptr = card; 275 guard(mutex)(&sound_mutex); 276 minor = snd_find_free_minor(type, card, dev); 277 if (minor < 0) { 278 err = minor; 279 goto error; 280 } 281 282 preg->dev = device; 283 device->devt = MKDEV(major, minor); 284 err = device_add(device); 285 if (err < 0) 286 goto error; 287 288 snd_minors[minor] = preg; 289 error: 290 if (err < 0) 291 kfree(preg); 292 return err; 293 } 294 EXPORT_SYMBOL(snd_register_device); 295 296 /** 297 * snd_unregister_device - unregister the device on the given card 298 * @dev: the device instance 299 * 300 * Unregisters the device file already registered via 301 * snd_register_device(). 302 * 303 * Return: Zero if successful, or a negative error code on failure. 304 */ 305 int snd_unregister_device(struct device *dev) 306 { 307 int minor; 308 struct snd_minor *preg; 309 310 guard(mutex)(&sound_mutex); 311 for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { 312 preg = snd_minors[minor]; 313 if (preg && preg->dev == dev) { 314 snd_minors[minor] = NULL; 315 device_del(dev); 316 kfree(preg); 317 break; 318 } 319 } 320 if (minor >= ARRAY_SIZE(snd_minors)) 321 return -ENOENT; 322 return 0; 323 } 324 EXPORT_SYMBOL(snd_unregister_device); 325 326 #ifdef CONFIG_SND_PROC_FS 327 /* 328 * INFO PART 329 */ 330 static const char *snd_device_type_name(int type) 331 { 332 switch (type) { 333 case SNDRV_DEVICE_TYPE_CONTROL: 334 return "control"; 335 case SNDRV_DEVICE_TYPE_HWDEP: 336 return "hardware dependent"; 337 case SNDRV_DEVICE_TYPE_RAWMIDI: 338 return "raw midi"; 339 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK: 340 return "digital audio playback"; 341 case SNDRV_DEVICE_TYPE_PCM_CAPTURE: 342 return "digital audio capture"; 343 case SNDRV_DEVICE_TYPE_SEQUENCER: 344 return "sequencer"; 345 case SNDRV_DEVICE_TYPE_TIMER: 346 return "timer"; 347 case SNDRV_DEVICE_TYPE_COMPRESS: 348 return "compress"; 349 default: 350 return "?"; 351 } 352 } 353 354 static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) 355 { 356 int minor; 357 struct snd_minor *mptr; 358 359 guard(mutex)(&sound_mutex); 360 for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { 361 mptr = snd_minors[minor]; 362 if (!mptr) 363 continue; 364 if (mptr->card >= 0) { 365 if (mptr->device >= 0) 366 snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n", 367 minor, mptr->card, mptr->device, 368 snd_device_type_name(mptr->type)); 369 else 370 snd_iprintf(buffer, "%3i: [%2i] : %s\n", 371 minor, mptr->card, 372 snd_device_type_name(mptr->type)); 373 } else 374 snd_iprintf(buffer, "%3i: : %s\n", minor, 375 snd_device_type_name(mptr->type)); 376 } 377 } 378 379 int __init snd_minor_info_init(void) 380 { 381 struct snd_info_entry *entry; 382 383 entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL); 384 if (!entry) 385 return -ENOMEM; 386 entry->c.text.read = snd_minor_info_read; 387 return snd_info_register(entry); /* freed in error path */ 388 } 389 #endif /* CONFIG_SND_PROC_FS */ 390 391 /* 392 * INIT PART 393 */ 394 395 static int __init alsa_sound_init(void) 396 { 397 int err; 398 399 snd_major = major; 400 snd_ecards_limit = cards_limit; 401 402 err = register_chrdev(major, "alsa", &snd_fops); 403 if (err < 0) { 404 pr_err("ALSA core: unable to register native major device number %d\n", major); 405 return err; 406 } 407 408 err = snd_info_init(); 409 if (err < 0) { 410 unregister_chrdev(major, "alsa"); 411 return err; 412 } 413 414 #ifdef CONFIG_SND_DEBUG 415 sound_debugfs_root = debugfs_create_dir("sound", NULL); 416 #endif 417 #ifndef MODULE 418 pr_info("Advanced Linux Sound Architecture Driver Initialized.\n"); 419 #endif 420 return 0; 421 } 422 423 static void __exit alsa_sound_exit(void) 424 { 425 #ifdef CONFIG_SND_DEBUG 426 debugfs_remove(sound_debugfs_root); 427 #endif 428 snd_info_done(); 429 unregister_chrdev(major, "alsa"); 430 } 431 432 subsys_initcall(alsa_sound_init); 433 module_exit(alsa_sound_exit); 434