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 { 172 .owner = THIS_MODULE, 173 .open = snd_open, 174 .llseek = noop_llseek, 175 }; 176 177 #ifdef CONFIG_SND_DYNAMIC_MINORS 178 static int snd_find_free_minor(int type, struct snd_card *card, int dev) 179 { 180 int minor; 181 182 /* static minors for module auto loading */ 183 if (type == SNDRV_DEVICE_TYPE_SEQUENCER) 184 return SNDRV_MINOR_SEQUENCER; 185 if (type == SNDRV_DEVICE_TYPE_TIMER) 186 return SNDRV_MINOR_TIMER; 187 188 for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { 189 /* skip static minors still used for module auto loading */ 190 if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL) 191 continue; 192 if (minor == SNDRV_MINOR_SEQUENCER || 193 minor == SNDRV_MINOR_TIMER) 194 continue; 195 if (!snd_minors[minor]) 196 return minor; 197 } 198 return -EBUSY; 199 } 200 #else 201 static int snd_find_free_minor(int type, struct snd_card *card, int dev) 202 { 203 int minor; 204 205 switch (type) { 206 case SNDRV_DEVICE_TYPE_SEQUENCER: 207 case SNDRV_DEVICE_TYPE_TIMER: 208 minor = type; 209 break; 210 case SNDRV_DEVICE_TYPE_CONTROL: 211 if (snd_BUG_ON(!card)) 212 return -EINVAL; 213 minor = SNDRV_MINOR(card->number, type); 214 break; 215 case SNDRV_DEVICE_TYPE_HWDEP: 216 case SNDRV_DEVICE_TYPE_RAWMIDI: 217 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK: 218 case SNDRV_DEVICE_TYPE_PCM_CAPTURE: 219 if (snd_BUG_ON(!card)) 220 return -EINVAL; 221 minor = SNDRV_MINOR(card->number, type + dev); 222 break; 223 case SNDRV_DEVICE_TYPE_COMPRESS: 224 if (snd_BUG_ON(!card)) 225 return -EINVAL; 226 if (dev < 0 || 227 dev >= SNDRV_MINOR_HWDEP - SNDRV_MINOR_COMPRESS) 228 return -EINVAL; 229 minor = SNDRV_MINOR(card->number, type + dev); 230 break; 231 default: 232 return -EINVAL; 233 } 234 if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OS_MINORS)) 235 return -EINVAL; 236 if (snd_minors[minor]) 237 return -EBUSY; 238 return minor; 239 } 240 #endif 241 242 /** 243 * snd_register_device - Register the ALSA device file for the card 244 * @type: the device type, SNDRV_DEVICE_TYPE_XXX 245 * @card: the card instance 246 * @dev: the device index 247 * @f_ops: the file operations 248 * @private_data: user pointer for f_ops->open() 249 * @device: the device to register 250 * 251 * Registers an ALSA device file for the given card. 252 * The operators have to be set in reg parameter. 253 * 254 * Return: Zero if successful, or a negative error code on failure. 255 */ 256 int snd_register_device(int type, struct snd_card *card, int dev, 257 const struct file_operations *f_ops, 258 void *private_data, struct device *device) 259 { 260 int minor; 261 int err = 0; 262 struct snd_minor *preg; 263 264 if (snd_BUG_ON(!device)) 265 return -EINVAL; 266 267 preg = kmalloc_obj(*preg); 268 if (preg == NULL) 269 return -ENOMEM; 270 preg->type = type; 271 preg->card = card ? card->number : -1; 272 preg->device = dev; 273 preg->f_ops = f_ops; 274 preg->private_data = private_data; 275 preg->card_ptr = card; 276 guard(mutex)(&sound_mutex); 277 minor = snd_find_free_minor(type, card, dev); 278 if (minor < 0) { 279 err = minor; 280 goto error; 281 } 282 283 preg->dev = device; 284 device->devt = MKDEV(major, minor); 285 err = device_add(device); 286 if (err < 0) 287 goto error; 288 289 snd_minors[minor] = preg; 290 error: 291 if (err < 0) 292 kfree(preg); 293 return err; 294 } 295 EXPORT_SYMBOL(snd_register_device); 296 297 /** 298 * snd_unregister_device - unregister the device on the given card 299 * @dev: the device instance 300 * 301 * Unregisters the device file already registered via 302 * snd_register_device(). 303 * 304 * Return: Zero if successful, or a negative error code on failure. 305 */ 306 int snd_unregister_device(struct device *dev) 307 { 308 int minor; 309 struct snd_minor *preg; 310 311 guard(mutex)(&sound_mutex); 312 for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) { 313 preg = snd_minors[minor]; 314 if (preg && preg->dev == dev) { 315 snd_minors[minor] = NULL; 316 device_del(dev); 317 kfree(preg); 318 break; 319 } 320 } 321 if (minor >= ARRAY_SIZE(snd_minors)) 322 return -ENOENT; 323 return 0; 324 } 325 EXPORT_SYMBOL(snd_unregister_device); 326 327 #ifdef CONFIG_SND_PROC_FS 328 /* 329 * INFO PART 330 */ 331 static const char *snd_device_type_name(int type) 332 { 333 switch (type) { 334 case SNDRV_DEVICE_TYPE_CONTROL: 335 return "control"; 336 case SNDRV_DEVICE_TYPE_HWDEP: 337 return "hardware dependent"; 338 case SNDRV_DEVICE_TYPE_RAWMIDI: 339 return "raw midi"; 340 case SNDRV_DEVICE_TYPE_PCM_PLAYBACK: 341 return "digital audio playback"; 342 case SNDRV_DEVICE_TYPE_PCM_CAPTURE: 343 return "digital audio capture"; 344 case SNDRV_DEVICE_TYPE_SEQUENCER: 345 return "sequencer"; 346 case SNDRV_DEVICE_TYPE_TIMER: 347 return "timer"; 348 case SNDRV_DEVICE_TYPE_COMPRESS: 349 return "compress"; 350 default: 351 return "?"; 352 } 353 } 354 355 static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) 356 { 357 int minor; 358 struct snd_minor *mptr; 359 360 guard(mutex)(&sound_mutex); 361 for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) { 362 mptr = snd_minors[minor]; 363 if (!mptr) 364 continue; 365 if (mptr->card >= 0) { 366 if (mptr->device >= 0) 367 snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n", 368 minor, mptr->card, mptr->device, 369 snd_device_type_name(mptr->type)); 370 else 371 snd_iprintf(buffer, "%3i: [%2i] : %s\n", 372 minor, mptr->card, 373 snd_device_type_name(mptr->type)); 374 } else 375 snd_iprintf(buffer, "%3i: : %s\n", minor, 376 snd_device_type_name(mptr->type)); 377 } 378 } 379 380 int __init snd_minor_info_init(void) 381 { 382 struct snd_info_entry *entry; 383 384 entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL); 385 if (!entry) 386 return -ENOMEM; 387 entry->c.text.read = snd_minor_info_read; 388 return snd_info_register(entry); /* freed in error path */ 389 } 390 #endif /* CONFIG_SND_PROC_FS */ 391 392 /* 393 * INIT PART 394 */ 395 396 static int __init alsa_sound_init(void) 397 { 398 snd_major = major; 399 snd_ecards_limit = cards_limit; 400 if (register_chrdev(major, "alsa", &snd_fops)) { 401 pr_err("ALSA core: unable to register native major device number %d\n", major); 402 return -EIO; 403 } 404 if (snd_info_init() < 0) { 405 unregister_chrdev(major, "alsa"); 406 return -ENOMEM; 407 } 408 409 #ifdef CONFIG_SND_DEBUG 410 sound_debugfs_root = debugfs_create_dir("sound", NULL); 411 #endif 412 #ifndef MODULE 413 pr_info("Advanced Linux Sound Architecture Driver Initialized.\n"); 414 #endif 415 return 0; 416 } 417 418 static void __exit alsa_sound_exit(void) 419 { 420 #ifdef CONFIG_SND_DEBUG 421 debugfs_remove(sound_debugfs_root); 422 #endif 423 snd_info_done(); 424 unregister_chrdev(major, "alsa"); 425 } 426 427 subsys_initcall(alsa_sound_init); 428 module_exit(alsa_sound_exit); 429