sound.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411
  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. #include <linux/init.h>
  7. #include <linux/slab.h>
  8. #include <linux/time.h>
  9. #include <linux/device.h>
  10. #include <linux/module.h>
  11. #include <sound/core.h>
  12. #include <sound/minors.h>
  13. #include <sound/info.h>
  14. #include <sound/control.h>
  15. #include <sound/initval.h>
  16. #include <linux/kmod.h>
  17. #include <linux/mutex.h>
  18. static int major = CONFIG_SND_MAJOR;
  19. int snd_major;
  20. EXPORT_SYMBOL(snd_major);
  21. static int cards_limit = 1;
  22. MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  23. MODULE_DESCRIPTION("Advanced Linux Sound Architecture driver for soundcards.");
  24. MODULE_LICENSE("GPL");
  25. module_param(major, int, 0444);
  26. MODULE_PARM_DESC(major, "Major # for sound driver.");
  27. module_param(cards_limit, int, 0444);
  28. MODULE_PARM_DESC(cards_limit, "Count of auto-loadable soundcards.");
  29. MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR);
  30. /* this one holds the actual max. card number currently available.
  31. * as default, it's identical with cards_limit option. when more
  32. * modules are loaded manually, this limit number increases, too.
  33. */
  34. int snd_ecards_limit;
  35. EXPORT_SYMBOL(snd_ecards_limit);
  36. static struct snd_minor *snd_minors[SNDRV_OS_MINORS];
  37. static DEFINE_MUTEX(sound_mutex);
  38. #ifdef CONFIG_MODULES
  39. /**
  40. * snd_request_card - try to load the card module
  41. * @card: the card number
  42. *
  43. * Tries to load the module "snd-card-X" for the given card number
  44. * via request_module. Returns immediately if already loaded.
  45. */
  46. void snd_request_card(int card)
  47. {
  48. if (snd_card_locked(card))
  49. return;
  50. if (card < 0 || card >= cards_limit)
  51. return;
  52. request_module("snd-card-%i", card);
  53. }
  54. EXPORT_SYMBOL(snd_request_card);
  55. static void snd_request_other(int minor)
  56. {
  57. char *str;
  58. switch (minor) {
  59. case SNDRV_MINOR_SEQUENCER: str = "snd-seq"; break;
  60. case SNDRV_MINOR_TIMER: str = "snd-timer"; break;
  61. default: return;
  62. }
  63. request_module(str);
  64. }
  65. #endif /* modular kernel */
  66. /**
  67. * snd_lookup_minor_data - get user data of a registered device
  68. * @minor: the minor number
  69. * @type: device type (SNDRV_DEVICE_TYPE_XXX)
  70. *
  71. * Checks that a minor device with the specified type is registered, and returns
  72. * its user data pointer.
  73. *
  74. * This function increments the reference counter of the card instance
  75. * if an associated instance with the given minor number and type is found.
  76. * The caller must call snd_card_unref() appropriately later.
  77. *
  78. * Return: The user data pointer if the specified device is found. %NULL
  79. * otherwise.
  80. */
  81. void *snd_lookup_minor_data(unsigned int minor, int type)
  82. {
  83. struct snd_minor *mreg;
  84. void *private_data;
  85. if (minor >= ARRAY_SIZE(snd_minors))
  86. return NULL;
  87. mutex_lock(&sound_mutex);
  88. mreg = snd_minors[minor];
  89. if (mreg && mreg->type == type) {
  90. private_data = mreg->private_data;
  91. if (private_data && mreg->card_ptr)
  92. get_device(&mreg->card_ptr->card_dev);
  93. } else
  94. private_data = NULL;
  95. mutex_unlock(&sound_mutex);
  96. return private_data;
  97. }
  98. EXPORT_SYMBOL(snd_lookup_minor_data);
  99. #ifdef CONFIG_MODULES
  100. static struct snd_minor *autoload_device(unsigned int minor)
  101. {
  102. int dev;
  103. mutex_unlock(&sound_mutex); /* release lock temporarily */
  104. dev = SNDRV_MINOR_DEVICE(minor);
  105. if (dev == SNDRV_MINOR_CONTROL) {
  106. /* /dev/aloadC? */
  107. int card = SNDRV_MINOR_CARD(minor);
  108. struct snd_card *ref = snd_card_ref(card);
  109. if (!ref)
  110. snd_request_card(card);
  111. else
  112. snd_card_unref(ref);
  113. } else if (dev == SNDRV_MINOR_GLOBAL) {
  114. /* /dev/aloadSEQ */
  115. snd_request_other(minor);
  116. }
  117. mutex_lock(&sound_mutex); /* reacuire lock */
  118. return snd_minors[minor];
  119. }
  120. #else /* !CONFIG_MODULES */
  121. #define autoload_device(minor) NULL
  122. #endif /* CONFIG_MODULES */
  123. static int snd_open(struct inode *inode, struct file *file)
  124. {
  125. unsigned int minor = iminor(inode);
  126. struct snd_minor *mptr = NULL;
  127. const struct file_operations *new_fops;
  128. int err = 0;
  129. if (minor >= ARRAY_SIZE(snd_minors))
  130. return -ENODEV;
  131. mutex_lock(&sound_mutex);
  132. mptr = snd_minors[minor];
  133. if (mptr == NULL) {
  134. mptr = autoload_device(minor);
  135. if (!mptr) {
  136. mutex_unlock(&sound_mutex);
  137. return -ENODEV;
  138. }
  139. }
  140. new_fops = fops_get(mptr->f_ops);
  141. mutex_unlock(&sound_mutex);
  142. if (!new_fops)
  143. return -ENODEV;
  144. replace_fops(file, new_fops);
  145. if (file->f_op->open)
  146. err = file->f_op->open(inode, file);
  147. return err;
  148. }
  149. static const struct file_operations snd_fops =
  150. {
  151. .owner = THIS_MODULE,
  152. .open = snd_open,
  153. .llseek = noop_llseek,
  154. };
  155. #ifdef CONFIG_SND_DYNAMIC_MINORS
  156. static int snd_find_free_minor(int type, struct snd_card *card, int dev)
  157. {
  158. int minor;
  159. /* static minors for module auto loading */
  160. if (type == SNDRV_DEVICE_TYPE_SEQUENCER)
  161. return SNDRV_MINOR_SEQUENCER;
  162. if (type == SNDRV_DEVICE_TYPE_TIMER)
  163. return SNDRV_MINOR_TIMER;
  164. for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {
  165. /* skip static minors still used for module auto loading */
  166. if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL)
  167. continue;
  168. if (minor == SNDRV_MINOR_SEQUENCER ||
  169. minor == SNDRV_MINOR_TIMER)
  170. continue;
  171. if (!snd_minors[minor])
  172. return minor;
  173. }
  174. return -EBUSY;
  175. }
  176. #else
  177. static int snd_find_free_minor(int type, struct snd_card *card, int dev)
  178. {
  179. int minor;
  180. switch (type) {
  181. case SNDRV_DEVICE_TYPE_SEQUENCER:
  182. case SNDRV_DEVICE_TYPE_TIMER:
  183. minor = type;
  184. break;
  185. case SNDRV_DEVICE_TYPE_CONTROL:
  186. if (snd_BUG_ON(!card))
  187. return -EINVAL;
  188. minor = SNDRV_MINOR(card->number, type);
  189. break;
  190. case SNDRV_DEVICE_TYPE_HWDEP:
  191. case SNDRV_DEVICE_TYPE_RAWMIDI:
  192. case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
  193. case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
  194. case SNDRV_DEVICE_TYPE_COMPRESS:
  195. if (snd_BUG_ON(!card))
  196. return -EINVAL;
  197. minor = SNDRV_MINOR(card->number, type + dev);
  198. break;
  199. default:
  200. return -EINVAL;
  201. }
  202. if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OS_MINORS))
  203. return -EINVAL;
  204. if (snd_minors[minor])
  205. return -EBUSY;
  206. return minor;
  207. }
  208. #endif
  209. /**
  210. * snd_register_device - Register the ALSA device file for the card
  211. * @type: the device type, SNDRV_DEVICE_TYPE_XXX
  212. * @card: the card instance
  213. * @dev: the device index
  214. * @f_ops: the file operations
  215. * @private_data: user pointer for f_ops->open()
  216. * @device: the device to register
  217. *
  218. * Registers an ALSA device file for the given card.
  219. * The operators have to be set in reg parameter.
  220. *
  221. * Return: Zero if successful, or a negative error code on failure.
  222. */
  223. int snd_register_device(int type, struct snd_card *card, int dev,
  224. const struct file_operations *f_ops,
  225. void *private_data, struct device *device)
  226. {
  227. int minor;
  228. int err = 0;
  229. struct snd_minor *preg;
  230. if (snd_BUG_ON(!device))
  231. return -EINVAL;
  232. preg = kmalloc(sizeof *preg, GFP_KERNEL);
  233. if (preg == NULL)
  234. return -ENOMEM;
  235. preg->type = type;
  236. preg->card = card ? card->number : -1;
  237. preg->device = dev;
  238. preg->f_ops = f_ops;
  239. preg->private_data = private_data;
  240. preg->card_ptr = card;
  241. mutex_lock(&sound_mutex);
  242. minor = snd_find_free_minor(type, card, dev);
  243. if (minor < 0) {
  244. err = minor;
  245. goto error;
  246. }
  247. preg->dev = device;
  248. device->devt = MKDEV(major, minor);
  249. err = device_add(device);
  250. if (err < 0)
  251. goto error;
  252. snd_minors[minor] = preg;
  253. error:
  254. mutex_unlock(&sound_mutex);
  255. if (err < 0)
  256. kfree(preg);
  257. return err;
  258. }
  259. EXPORT_SYMBOL(snd_register_device);
  260. /**
  261. * snd_unregister_device - unregister the device on the given card
  262. * @dev: the device instance
  263. *
  264. * Unregisters the device file already registered via
  265. * snd_register_device().
  266. *
  267. * Return: Zero if successful, or a negative error code on failure.
  268. */
  269. int snd_unregister_device(struct device *dev)
  270. {
  271. int minor;
  272. struct snd_minor *preg;
  273. mutex_lock(&sound_mutex);
  274. for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {
  275. preg = snd_minors[minor];
  276. if (preg && preg->dev == dev) {
  277. snd_minors[minor] = NULL;
  278. device_del(dev);
  279. kfree(preg);
  280. break;
  281. }
  282. }
  283. mutex_unlock(&sound_mutex);
  284. if (minor >= ARRAY_SIZE(snd_minors))
  285. return -ENOENT;
  286. return 0;
  287. }
  288. EXPORT_SYMBOL(snd_unregister_device);
  289. #ifdef CONFIG_SND_PROC_FS
  290. /*
  291. * INFO PART
  292. */
  293. static const char *snd_device_type_name(int type)
  294. {
  295. switch (type) {
  296. case SNDRV_DEVICE_TYPE_CONTROL:
  297. return "control";
  298. case SNDRV_DEVICE_TYPE_HWDEP:
  299. return "hardware dependent";
  300. case SNDRV_DEVICE_TYPE_RAWMIDI:
  301. return "raw midi";
  302. case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
  303. return "digital audio playback";
  304. case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
  305. return "digital audio capture";
  306. case SNDRV_DEVICE_TYPE_SEQUENCER:
  307. return "sequencer";
  308. case SNDRV_DEVICE_TYPE_TIMER:
  309. return "timer";
  310. default:
  311. return "?";
  312. }
  313. }
  314. static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
  315. {
  316. int minor;
  317. struct snd_minor *mptr;
  318. mutex_lock(&sound_mutex);
  319. for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) {
  320. if (!(mptr = snd_minors[minor]))
  321. continue;
  322. if (mptr->card >= 0) {
  323. if (mptr->device >= 0)
  324. snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n",
  325. minor, mptr->card, mptr->device,
  326. snd_device_type_name(mptr->type));
  327. else
  328. snd_iprintf(buffer, "%3i: [%2i] : %s\n",
  329. minor, mptr->card,
  330. snd_device_type_name(mptr->type));
  331. } else
  332. snd_iprintf(buffer, "%3i: : %s\n", minor,
  333. snd_device_type_name(mptr->type));
  334. }
  335. mutex_unlock(&sound_mutex);
  336. }
  337. int __init snd_minor_info_init(void)
  338. {
  339. struct snd_info_entry *entry;
  340. entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL);
  341. if (!entry)
  342. return -ENOMEM;
  343. entry->c.text.read = snd_minor_info_read;
  344. return snd_info_register(entry); /* freed in error path */
  345. }
  346. #endif /* CONFIG_SND_PROC_FS */
  347. /*
  348. * INIT PART
  349. */
  350. static int __init alsa_sound_init(void)
  351. {
  352. snd_major = major;
  353. snd_ecards_limit = cards_limit;
  354. if (register_chrdev(major, "alsa", &snd_fops)) {
  355. pr_err("ALSA core: unable to register native major device number %d\n", major);
  356. return -EIO;
  357. }
  358. if (snd_info_init() < 0) {
  359. unregister_chrdev(major, "alsa");
  360. return -ENOMEM;
  361. }
  362. #ifndef MODULE
  363. pr_info("Advanced Linux Sound Architecture Driver Initialized.\n");
  364. #endif
  365. return 0;
  366. }
  367. static void __exit alsa_sound_exit(void)
  368. {
  369. snd_info_done();
  370. unregister_chrdev(major, "alsa");
  371. }
  372. subsys_initcall(alsa_sound_init);
  373. module_exit(alsa_sound_exit);