sound.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493
  1. /*
  2. * Advanced Linux Sound Architecture
  3. * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  4. *
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19. *
  20. */
  21. #include <linux/init.h>
  22. #include <linux/slab.h>
  23. #include <linux/time.h>
  24. #include <linux/device.h>
  25. #include <linux/module.h>
  26. #include <sound/core.h>
  27. #include <sound/minors.h>
  28. #include <sound/info.h>
  29. #include <sound/control.h>
  30. #include <sound/initval.h>
  31. #include <linux/kmod.h>
  32. #include <linux/mutex.h>
  33. static int major = CONFIG_SND_MAJOR;
  34. int snd_major;
  35. EXPORT_SYMBOL(snd_major);
  36. static int cards_limit = 1;
  37. MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  38. MODULE_DESCRIPTION("Advanced Linux Sound Architecture driver for soundcards.");
  39. MODULE_LICENSE("GPL");
  40. module_param(major, int, 0444);
  41. MODULE_PARM_DESC(major, "Major # for sound driver.");
  42. module_param(cards_limit, int, 0444);
  43. MODULE_PARM_DESC(cards_limit, "Count of auto-loadable soundcards.");
  44. MODULE_ALIAS_CHARDEV_MAJOR(CONFIG_SND_MAJOR);
  45. /* this one holds the actual max. card number currently available.
  46. * as default, it's identical with cards_limit option. when more
  47. * modules are loaded manually, this limit number increases, too.
  48. */
  49. int snd_ecards_limit;
  50. EXPORT_SYMBOL(snd_ecards_limit);
  51. static struct snd_minor *snd_minors[SNDRV_OS_MINORS];
  52. static DEFINE_MUTEX(sound_mutex);
  53. #ifdef CONFIG_MODULES
  54. /**
  55. * snd_request_card - try to load the card module
  56. * @card: the card number
  57. *
  58. * Tries to load the module "snd-card-X" for the given card number
  59. * via request_module. Returns immediately if already loaded.
  60. */
  61. void snd_request_card(int card)
  62. {
  63. if (snd_card_locked(card))
  64. return;
  65. if (card < 0 || card >= cards_limit)
  66. return;
  67. request_module("snd-card-%i", card);
  68. }
  69. EXPORT_SYMBOL(snd_request_card);
  70. static void snd_request_other(int minor)
  71. {
  72. char *str;
  73. switch (minor) {
  74. case SNDRV_MINOR_SEQUENCER: str = "snd-seq"; break;
  75. case SNDRV_MINOR_TIMER: str = "snd-timer"; break;
  76. default: return;
  77. }
  78. request_module(str);
  79. }
  80. #endif /* modular kernel */
  81. /**
  82. * snd_lookup_minor_data - get user data of a registered device
  83. * @minor: the minor number
  84. * @type: device type (SNDRV_DEVICE_TYPE_XXX)
  85. *
  86. * Checks that a minor device with the specified type is registered, and returns
  87. * its user data pointer.
  88. *
  89. * This function increments the reference counter of the card instance
  90. * if an associated instance with the given minor number and type is found.
  91. * The caller must call snd_card_unref() appropriately later.
  92. *
  93. * Return: The user data pointer if the specified device is found. %NULL
  94. * otherwise.
  95. */
  96. void *snd_lookup_minor_data(unsigned int minor, int type)
  97. {
  98. struct snd_minor *mreg;
  99. void *private_data;
  100. if (minor >= ARRAY_SIZE(snd_minors))
  101. return NULL;
  102. mutex_lock(&sound_mutex);
  103. mreg = snd_minors[minor];
  104. if (mreg && mreg->type == type) {
  105. private_data = mreg->private_data;
  106. if (private_data && mreg->card_ptr)
  107. atomic_inc(&mreg->card_ptr->refcount);
  108. } else
  109. private_data = NULL;
  110. mutex_unlock(&sound_mutex);
  111. return private_data;
  112. }
  113. EXPORT_SYMBOL(snd_lookup_minor_data);
  114. #ifdef CONFIG_MODULES
  115. static struct snd_minor *autoload_device(unsigned int minor)
  116. {
  117. int dev;
  118. mutex_unlock(&sound_mutex); /* release lock temporarily */
  119. dev = SNDRV_MINOR_DEVICE(minor);
  120. if (dev == SNDRV_MINOR_CONTROL) {
  121. /* /dev/aloadC? */
  122. int card = SNDRV_MINOR_CARD(minor);
  123. if (snd_cards[card] == NULL)
  124. snd_request_card(card);
  125. } else if (dev == SNDRV_MINOR_GLOBAL) {
  126. /* /dev/aloadSEQ */
  127. snd_request_other(minor);
  128. }
  129. mutex_lock(&sound_mutex); /* reacuire lock */
  130. return snd_minors[minor];
  131. }
  132. #else /* !CONFIG_MODULES */
  133. #define autoload_device(minor) NULL
  134. #endif /* CONFIG_MODULES */
  135. static int snd_open(struct inode *inode, struct file *file)
  136. {
  137. unsigned int minor = iminor(inode);
  138. struct snd_minor *mptr = NULL;
  139. const struct file_operations *old_fops;
  140. int err = 0;
  141. if (minor >= ARRAY_SIZE(snd_minors))
  142. return -ENODEV;
  143. mutex_lock(&sound_mutex);
  144. mptr = snd_minors[minor];
  145. if (mptr == NULL) {
  146. mptr = autoload_device(minor);
  147. if (!mptr) {
  148. mutex_unlock(&sound_mutex);
  149. return -ENODEV;
  150. }
  151. }
  152. old_fops = file->f_op;
  153. file->f_op = fops_get(mptr->f_ops);
  154. if (file->f_op == NULL) {
  155. file->f_op = old_fops;
  156. err = -ENODEV;
  157. }
  158. mutex_unlock(&sound_mutex);
  159. if (err < 0)
  160. return err;
  161. if (file->f_op->open) {
  162. err = file->f_op->open(inode, file);
  163. if (err) {
  164. fops_put(file->f_op);
  165. file->f_op = fops_get(old_fops);
  166. }
  167. }
  168. fops_put(old_fops);
  169. return err;
  170. }
  171. static const struct file_operations snd_fops =
  172. {
  173. .owner = THIS_MODULE,
  174. .open = snd_open,
  175. .llseek = noop_llseek,
  176. };
  177. #ifdef CONFIG_SND_DYNAMIC_MINORS
  178. static int snd_find_free_minor(int type)
  179. {
  180. int minor;
  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. for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {
  187. /* skip static minors still used for module auto loading */
  188. if (SNDRV_MINOR_DEVICE(minor) == SNDRV_MINOR_CONTROL)
  189. continue;
  190. if (minor == SNDRV_MINOR_SEQUENCER ||
  191. minor == SNDRV_MINOR_TIMER)
  192. continue;
  193. if (!snd_minors[minor])
  194. return minor;
  195. }
  196. return -EBUSY;
  197. }
  198. #else
  199. static int snd_kernel_minor(int type, struct snd_card *card, int dev)
  200. {
  201. int minor;
  202. switch (type) {
  203. case SNDRV_DEVICE_TYPE_SEQUENCER:
  204. case SNDRV_DEVICE_TYPE_TIMER:
  205. minor = type;
  206. break;
  207. case SNDRV_DEVICE_TYPE_CONTROL:
  208. if (snd_BUG_ON(!card))
  209. return -EINVAL;
  210. minor = SNDRV_MINOR(card->number, type);
  211. break;
  212. case SNDRV_DEVICE_TYPE_HWDEP:
  213. case SNDRV_DEVICE_TYPE_RAWMIDI:
  214. case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
  215. case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
  216. case SNDRV_DEVICE_TYPE_COMPRESS:
  217. if (snd_BUG_ON(!card))
  218. return -EINVAL;
  219. minor = SNDRV_MINOR(card->number, type + dev);
  220. break;
  221. default:
  222. return -EINVAL;
  223. }
  224. if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OS_MINORS))
  225. return -EINVAL;
  226. return minor;
  227. }
  228. #endif
  229. /**
  230. * snd_register_device_for_dev - Register the ALSA device file for the card
  231. * @type: the device type, SNDRV_DEVICE_TYPE_XXX
  232. * @card: the card instance
  233. * @dev: the device index
  234. * @f_ops: the file operations
  235. * @private_data: user pointer for f_ops->open()
  236. * @name: the device file name
  237. * @device: the &struct device to link this new device to
  238. *
  239. * Registers an ALSA device file for the given card.
  240. * The operators have to be set in reg parameter.
  241. *
  242. * Return: Zero if successful, or a negative error code on failure.
  243. */
  244. int snd_register_device_for_dev(int type, struct snd_card *card, int dev,
  245. const struct file_operations *f_ops,
  246. void *private_data,
  247. const char *name, struct device *device)
  248. {
  249. int minor;
  250. struct snd_minor *preg;
  251. if (snd_BUG_ON(!name))
  252. return -EINVAL;
  253. preg = kmalloc(sizeof *preg, GFP_KERNEL);
  254. if (preg == NULL)
  255. return -ENOMEM;
  256. preg->type = type;
  257. preg->card = card ? card->number : -1;
  258. preg->device = dev;
  259. preg->f_ops = f_ops;
  260. preg->private_data = private_data;
  261. preg->card_ptr = card;
  262. mutex_lock(&sound_mutex);
  263. #ifdef CONFIG_SND_DYNAMIC_MINORS
  264. minor = snd_find_free_minor(type);
  265. #else
  266. minor = snd_kernel_minor(type, card, dev);
  267. if (minor >= 0 && snd_minors[minor])
  268. minor = -EBUSY;
  269. #endif
  270. if (minor < 0) {
  271. mutex_unlock(&sound_mutex);
  272. kfree(preg);
  273. return minor;
  274. }
  275. snd_minors[minor] = preg;
  276. preg->dev = device_create(sound_class, device, MKDEV(major, minor),
  277. private_data, "%s", name);
  278. if (IS_ERR(preg->dev)) {
  279. snd_minors[minor] = NULL;
  280. mutex_unlock(&sound_mutex);
  281. minor = PTR_ERR(preg->dev);
  282. kfree(preg);
  283. return minor;
  284. }
  285. mutex_unlock(&sound_mutex);
  286. return 0;
  287. }
  288. EXPORT_SYMBOL(snd_register_device_for_dev);
  289. /* find the matching minor record
  290. * return the index of snd_minor, or -1 if not found
  291. */
  292. static int find_snd_minor(int type, struct snd_card *card, int dev)
  293. {
  294. int cardnum, minor;
  295. struct snd_minor *mptr;
  296. cardnum = card ? card->number : -1;
  297. for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor)
  298. if ((mptr = snd_minors[minor]) != NULL &&
  299. mptr->type == type &&
  300. mptr->card == cardnum &&
  301. mptr->device == dev)
  302. return minor;
  303. return -1;
  304. }
  305. /**
  306. * snd_unregister_device - unregister the device on the given card
  307. * @type: the device type, SNDRV_DEVICE_TYPE_XXX
  308. * @card: the card instance
  309. * @dev: the device index
  310. *
  311. * Unregisters the device file already registered via
  312. * snd_register_device().
  313. *
  314. * Return: Zero if successful, or a negative error code on failure.
  315. */
  316. int snd_unregister_device(int type, struct snd_card *card, int dev)
  317. {
  318. int minor;
  319. mutex_lock(&sound_mutex);
  320. minor = find_snd_minor(type, card, dev);
  321. if (minor < 0) {
  322. mutex_unlock(&sound_mutex);
  323. return -EINVAL;
  324. }
  325. device_destroy(sound_class, MKDEV(major, minor));
  326. kfree(snd_minors[minor]);
  327. snd_minors[minor] = NULL;
  328. mutex_unlock(&sound_mutex);
  329. return 0;
  330. }
  331. EXPORT_SYMBOL(snd_unregister_device);
  332. int snd_add_device_sysfs_file(int type, struct snd_card *card, int dev,
  333. struct device_attribute *attr)
  334. {
  335. int minor, ret = -EINVAL;
  336. struct device *d;
  337. mutex_lock(&sound_mutex);
  338. minor = find_snd_minor(type, card, dev);
  339. if (minor >= 0 && (d = snd_minors[minor]->dev) != NULL)
  340. ret = device_create_file(d, attr);
  341. mutex_unlock(&sound_mutex);
  342. return ret;
  343. }
  344. EXPORT_SYMBOL(snd_add_device_sysfs_file);
  345. #ifdef CONFIG_PROC_FS
  346. /*
  347. * INFO PART
  348. */
  349. static struct snd_info_entry *snd_minor_info_entry;
  350. static const char *snd_device_type_name(int type)
  351. {
  352. switch (type) {
  353. case SNDRV_DEVICE_TYPE_CONTROL:
  354. return "control";
  355. case SNDRV_DEVICE_TYPE_HWDEP:
  356. return "hardware dependent";
  357. case SNDRV_DEVICE_TYPE_RAWMIDI:
  358. return "raw midi";
  359. case SNDRV_DEVICE_TYPE_PCM_PLAYBACK:
  360. return "digital audio playback";
  361. case SNDRV_DEVICE_TYPE_PCM_CAPTURE:
  362. return "digital audio capture";
  363. case SNDRV_DEVICE_TYPE_SEQUENCER:
  364. return "sequencer";
  365. case SNDRV_DEVICE_TYPE_TIMER:
  366. return "timer";
  367. default:
  368. return "?";
  369. }
  370. }
  371. static void snd_minor_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
  372. {
  373. int minor;
  374. struct snd_minor *mptr;
  375. mutex_lock(&sound_mutex);
  376. for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) {
  377. if (!(mptr = snd_minors[minor]))
  378. continue;
  379. if (mptr->card >= 0) {
  380. if (mptr->device >= 0)
  381. snd_iprintf(buffer, "%3i: [%2i-%2i]: %s\n",
  382. minor, mptr->card, mptr->device,
  383. snd_device_type_name(mptr->type));
  384. else
  385. snd_iprintf(buffer, "%3i: [%2i] : %s\n",
  386. minor, mptr->card,
  387. snd_device_type_name(mptr->type));
  388. } else
  389. snd_iprintf(buffer, "%3i: : %s\n", minor,
  390. snd_device_type_name(mptr->type));
  391. }
  392. mutex_unlock(&sound_mutex);
  393. }
  394. int __init snd_minor_info_init(void)
  395. {
  396. struct snd_info_entry *entry;
  397. entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL);
  398. if (entry) {
  399. entry->c.text.read = snd_minor_info_read;
  400. if (snd_info_register(entry) < 0) {
  401. snd_info_free_entry(entry);
  402. entry = NULL;
  403. }
  404. }
  405. snd_minor_info_entry = entry;
  406. return 0;
  407. }
  408. int __exit snd_minor_info_done(void)
  409. {
  410. snd_info_free_entry(snd_minor_info_entry);
  411. return 0;
  412. }
  413. #endif /* CONFIG_PROC_FS */
  414. /*
  415. * INIT PART
  416. */
  417. static int __init alsa_sound_init(void)
  418. {
  419. snd_major = major;
  420. snd_ecards_limit = cards_limit;
  421. if (register_chrdev(major, "alsa", &snd_fops)) {
  422. snd_printk(KERN_ERR "unable to register native major device number %d\n", major);
  423. return -EIO;
  424. }
  425. if (snd_info_init() < 0) {
  426. unregister_chrdev(major, "alsa");
  427. return -ENOMEM;
  428. }
  429. snd_info_minor_register();
  430. #ifndef MODULE
  431. printk(KERN_INFO "Advanced Linux Sound Architecture Driver Initialized.\n");
  432. #endif
  433. return 0;
  434. }
  435. static void __exit alsa_sound_exit(void)
  436. {
  437. snd_info_minor_unregister();
  438. snd_info_done();
  439. unregister_chrdev(major, "alsa");
  440. }
  441. subsys_initcall(alsa_sound_init);
  442. module_exit(alsa_sound_exit);