sound_oss.c 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276
  1. /*
  2. * Advanced Linux Sound Architecture
  3. * Copyright (c) by Jaroslav Kysela <perex@suse.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 <sound/driver.h>
  22. #ifdef CONFIG_SND_OSSEMUL
  23. #if !defined(CONFIG_SOUND) && !(defined(MODULE) && defined(CONFIG_SOUND_MODULE))
  24. #error "Enable the OSS soundcore multiplexer (CONFIG_SOUND) in the kernel."
  25. #endif
  26. #include <linux/init.h>
  27. #include <linux/slab.h>
  28. #include <linux/time.h>
  29. #include <sound/core.h>
  30. #include <sound/minors.h>
  31. #include <sound/info.h>
  32. #include <linux/sound.h>
  33. #include <linux/mutex.h>
  34. #define SNDRV_OSS_MINORS 128
  35. static struct snd_minor *snd_oss_minors[SNDRV_OSS_MINORS];
  36. static DEFINE_MUTEX(sound_oss_mutex);
  37. void *snd_lookup_oss_minor_data(unsigned int minor, int type)
  38. {
  39. struct snd_minor *mreg;
  40. void *private_data;
  41. if (minor >= ARRAY_SIZE(snd_oss_minors))
  42. return NULL;
  43. mutex_lock(&sound_oss_mutex);
  44. mreg = snd_oss_minors[minor];
  45. if (mreg && mreg->type == type)
  46. private_data = mreg->private_data;
  47. else
  48. private_data = NULL;
  49. mutex_unlock(&sound_oss_mutex);
  50. return private_data;
  51. }
  52. EXPORT_SYMBOL(snd_lookup_oss_minor_data);
  53. static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev)
  54. {
  55. int minor;
  56. switch (type) {
  57. case SNDRV_OSS_DEVICE_TYPE_MIXER:
  58. snd_assert(card != NULL && dev <= 1, return -EINVAL);
  59. minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIXER1 : SNDRV_MINOR_OSS_MIXER));
  60. break;
  61. case SNDRV_OSS_DEVICE_TYPE_SEQUENCER:
  62. minor = SNDRV_MINOR_OSS_SEQUENCER;
  63. break;
  64. case SNDRV_OSS_DEVICE_TYPE_MUSIC:
  65. minor = SNDRV_MINOR_OSS_MUSIC;
  66. break;
  67. case SNDRV_OSS_DEVICE_TYPE_PCM:
  68. snd_assert(card != NULL && dev <= 1, return -EINVAL);
  69. minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_PCM1 : SNDRV_MINOR_OSS_PCM));
  70. break;
  71. case SNDRV_OSS_DEVICE_TYPE_MIDI:
  72. snd_assert(card != NULL && dev <= 1, return -EINVAL);
  73. minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIDI1 : SNDRV_MINOR_OSS_MIDI));
  74. break;
  75. case SNDRV_OSS_DEVICE_TYPE_DMFM:
  76. minor = SNDRV_MINOR_OSS(card->number, SNDRV_MINOR_OSS_DMFM);
  77. break;
  78. case SNDRV_OSS_DEVICE_TYPE_SNDSTAT:
  79. minor = SNDRV_MINOR_OSS_SNDSTAT;
  80. break;
  81. default:
  82. return -EINVAL;
  83. }
  84. snd_assert(minor >= 0 && minor < SNDRV_OSS_MINORS, return -EINVAL);
  85. return minor;
  86. }
  87. int snd_register_oss_device(int type, struct snd_card *card, int dev,
  88. const struct file_operations *f_ops, void *private_data,
  89. const char *name)
  90. {
  91. int minor = snd_oss_kernel_minor(type, card, dev);
  92. int minor_unit;
  93. struct snd_minor *preg;
  94. int cidx = SNDRV_MINOR_OSS_CARD(minor);
  95. int track2 = -1;
  96. int register1 = -1, register2 = -1;
  97. struct device *carddev = snd_card_get_device_link(card);
  98. if (card && card->number >= 8)
  99. return 0; /* ignore silently */
  100. if (minor < 0)
  101. return minor;
  102. preg = kmalloc(sizeof(struct snd_minor), GFP_KERNEL);
  103. if (preg == NULL)
  104. return -ENOMEM;
  105. preg->type = type;
  106. preg->card = card ? card->number : -1;
  107. preg->device = dev;
  108. preg->f_ops = f_ops;
  109. preg->private_data = private_data;
  110. mutex_lock(&sound_oss_mutex);
  111. snd_oss_minors[minor] = preg;
  112. minor_unit = SNDRV_MINOR_OSS_DEVICE(minor);
  113. switch (minor_unit) {
  114. case SNDRV_MINOR_OSS_PCM:
  115. track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_AUDIO);
  116. break;
  117. case SNDRV_MINOR_OSS_MIDI:
  118. track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI);
  119. break;
  120. case SNDRV_MINOR_OSS_MIDI1:
  121. track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI1);
  122. break;
  123. }
  124. register1 = register_sound_special_device(f_ops, minor, carddev);
  125. if (register1 != minor)
  126. goto __end;
  127. if (track2 >= 0) {
  128. register2 = register_sound_special_device(f_ops, track2,
  129. carddev);
  130. if (register2 != track2)
  131. goto __end;
  132. snd_oss_minors[track2] = preg;
  133. }
  134. mutex_unlock(&sound_oss_mutex);
  135. return 0;
  136. __end:
  137. if (register2 >= 0)
  138. unregister_sound_special(register2);
  139. if (register1 >= 0)
  140. unregister_sound_special(register1);
  141. snd_oss_minors[minor] = NULL;
  142. mutex_unlock(&sound_oss_mutex);
  143. kfree(preg);
  144. return -EBUSY;
  145. }
  146. EXPORT_SYMBOL(snd_register_oss_device);
  147. int snd_unregister_oss_device(int type, struct snd_card *card, int dev)
  148. {
  149. int minor = snd_oss_kernel_minor(type, card, dev);
  150. int cidx = SNDRV_MINOR_OSS_CARD(minor);
  151. int track2 = -1;
  152. struct snd_minor *mptr;
  153. if (card && card->number >= 8)
  154. return 0;
  155. if (minor < 0)
  156. return minor;
  157. mutex_lock(&sound_oss_mutex);
  158. mptr = snd_oss_minors[minor];
  159. if (mptr == NULL) {
  160. mutex_unlock(&sound_oss_mutex);
  161. return -ENOENT;
  162. }
  163. unregister_sound_special(minor);
  164. switch (SNDRV_MINOR_OSS_DEVICE(minor)) {
  165. case SNDRV_MINOR_OSS_PCM:
  166. track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_AUDIO);
  167. break;
  168. case SNDRV_MINOR_OSS_MIDI:
  169. track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI);
  170. break;
  171. case SNDRV_MINOR_OSS_MIDI1:
  172. track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI1);
  173. break;
  174. }
  175. if (track2 >= 0) {
  176. unregister_sound_special(track2);
  177. snd_oss_minors[track2] = NULL;
  178. }
  179. snd_oss_minors[minor] = NULL;
  180. mutex_unlock(&sound_oss_mutex);
  181. kfree(mptr);
  182. return 0;
  183. }
  184. EXPORT_SYMBOL(snd_unregister_oss_device);
  185. /*
  186. * INFO PART
  187. */
  188. #ifdef CONFIG_PROC_FS
  189. static struct snd_info_entry *snd_minor_info_oss_entry;
  190. static const char *snd_oss_device_type_name(int type)
  191. {
  192. switch (type) {
  193. case SNDRV_OSS_DEVICE_TYPE_MIXER:
  194. return "mixer";
  195. case SNDRV_OSS_DEVICE_TYPE_SEQUENCER:
  196. case SNDRV_OSS_DEVICE_TYPE_MUSIC:
  197. return "sequencer";
  198. case SNDRV_OSS_DEVICE_TYPE_PCM:
  199. return "digital audio";
  200. case SNDRV_OSS_DEVICE_TYPE_MIDI:
  201. return "raw midi";
  202. case SNDRV_OSS_DEVICE_TYPE_DMFM:
  203. return "hardware dependent";
  204. default:
  205. return "?";
  206. }
  207. }
  208. static void snd_minor_info_oss_read(struct snd_info_entry *entry,
  209. struct snd_info_buffer *buffer)
  210. {
  211. int minor;
  212. struct snd_minor *mptr;
  213. mutex_lock(&sound_oss_mutex);
  214. for (minor = 0; minor < SNDRV_OSS_MINORS; ++minor) {
  215. if (!(mptr = snd_oss_minors[minor]))
  216. continue;
  217. if (mptr->card >= 0)
  218. snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", minor,
  219. mptr->card, mptr->device,
  220. snd_oss_device_type_name(mptr->type));
  221. else
  222. snd_iprintf(buffer, "%3i: : %s\n", minor,
  223. snd_oss_device_type_name(mptr->type));
  224. }
  225. mutex_unlock(&sound_oss_mutex);
  226. }
  227. int __init snd_minor_info_oss_init(void)
  228. {
  229. struct snd_info_entry *entry;
  230. entry = snd_info_create_module_entry(THIS_MODULE, "devices", snd_oss_root);
  231. if (entry) {
  232. entry->c.text.read = snd_minor_info_oss_read;
  233. if (snd_info_register(entry) < 0) {
  234. snd_info_free_entry(entry);
  235. entry = NULL;
  236. }
  237. }
  238. snd_minor_info_oss_entry = entry;
  239. return 0;
  240. }
  241. int __exit snd_minor_info_oss_done(void)
  242. {
  243. snd_info_free_entry(snd_minor_info_oss_entry);
  244. return 0;
  245. }
  246. #endif /* CONFIG_PROC_FS */
  247. #endif /* CONFIG_SND_OSSEMUL */