]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * OSS compatible sequencer driver | |
3 | * | |
4 | * registration of device and proc | |
5 | * | |
6 | * Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; either version 2 of the License, or | |
11 | * (at your option) any later version. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, | |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | * GNU General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
21 | */ | |
22 | ||
1da177e4 | 23 | #include <linux/init.h> |
1da177e4 | 24 | #include <linux/moduleparam.h> |
1a60d4c5 | 25 | #include <linux/mutex.h> |
1da177e4 LT |
26 | #include <sound/core.h> |
27 | #include <sound/minors.h> | |
28 | #include <sound/initval.h> | |
29 | #include "seq_oss_device.h" | |
30 | #include "seq_oss_synth.h" | |
31 | ||
32 | /* | |
33 | * module option | |
34 | */ | |
35 | MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); | |
36 | MODULE_DESCRIPTION("OSS-compatible sequencer module"); | |
37 | MODULE_LICENSE("GPL"); | |
38 | /* Takashi says this is really only for sound-service-0-, but this is OK. */ | |
39 | MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_SEQUENCER); | |
40 | MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MUSIC); | |
41 | ||
42 | #ifdef SNDRV_SEQ_OSS_DEBUG | |
43 | module_param(seq_oss_debug, int, 0644); | |
44 | MODULE_PARM_DESC(seq_oss_debug, "debug option"); | |
45 | int seq_oss_debug = 0; | |
46 | #endif | |
47 | ||
48 | ||
49 | /* | |
50 | * prototypes | |
51 | */ | |
52 | static int register_device(void); | |
53 | static void unregister_device(void); | |
04f141a8 | 54 | #ifdef CONFIG_PROC_FS |
1da177e4 LT |
55 | static int register_proc(void); |
56 | static void unregister_proc(void); | |
04f141a8 TI |
57 | #else |
58 | static inline int register_proc(void) { return 0; } | |
59 | static inline void unregister_proc(void) {} | |
60 | #endif | |
1da177e4 LT |
61 | |
62 | static int odev_open(struct inode *inode, struct file *file); | |
63 | static int odev_release(struct inode *inode, struct file *file); | |
64 | static ssize_t odev_read(struct file *file, char __user *buf, size_t count, loff_t *offset); | |
65 | static ssize_t odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offset); | |
66 | static long odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg); | |
67 | static unsigned int odev_poll(struct file *file, poll_table * wait); | |
1da177e4 LT |
68 | |
69 | ||
70 | /* | |
71 | * module interface | |
72 | */ | |
73 | ||
74 | static int __init alsa_seq_oss_init(void) | |
75 | { | |
76 | int rc; | |
080dece3 | 77 | static struct snd_seq_dev_ops ops = { |
1da177e4 LT |
78 | snd_seq_oss_synth_register, |
79 | snd_seq_oss_synth_unregister, | |
80 | }; | |
81 | ||
82 | snd_seq_autoload_lock(); | |
83 | if ((rc = register_device()) < 0) | |
84 | goto error; | |
85 | if ((rc = register_proc()) < 0) { | |
86 | unregister_device(); | |
87 | goto error; | |
88 | } | |
89 | if ((rc = snd_seq_oss_create_client()) < 0) { | |
90 | unregister_proc(); | |
91 | unregister_device(); | |
92 | goto error; | |
93 | } | |
94 | ||
95 | if ((rc = snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OSS, &ops, | |
080dece3 | 96 | sizeof(struct snd_seq_oss_reg))) < 0) { |
1da177e4 LT |
97 | snd_seq_oss_delete_client(); |
98 | unregister_proc(); | |
99 | unregister_device(); | |
100 | goto error; | |
101 | } | |
102 | ||
103 | /* success */ | |
104 | snd_seq_oss_synth_init(); | |
105 | ||
106 | error: | |
107 | snd_seq_autoload_unlock(); | |
108 | return rc; | |
109 | } | |
110 | ||
111 | static void __exit alsa_seq_oss_exit(void) | |
112 | { | |
113 | snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_OSS); | |
114 | snd_seq_oss_delete_client(); | |
115 | unregister_proc(); | |
116 | unregister_device(); | |
117 | } | |
118 | ||
119 | module_init(alsa_seq_oss_init) | |
120 | module_exit(alsa_seq_oss_exit) | |
121 | ||
122 | /* | |
123 | * ALSA minor device interface | |
124 | */ | |
125 | ||
1a60d4c5 | 126 | static DEFINE_MUTEX(register_mutex); |
1da177e4 LT |
127 | |
128 | static int | |
129 | odev_open(struct inode *inode, struct file *file) | |
130 | { | |
131 | int level, rc; | |
132 | ||
133 | if (iminor(inode) == SNDRV_MINOR_OSS_MUSIC) | |
134 | level = SNDRV_SEQ_OSS_MODE_MUSIC; | |
135 | else | |
136 | level = SNDRV_SEQ_OSS_MODE_SYNTH; | |
137 | ||
1a60d4c5 | 138 | mutex_lock(®ister_mutex); |
1da177e4 | 139 | rc = snd_seq_oss_open(file, level); |
1a60d4c5 | 140 | mutex_unlock(®ister_mutex); |
1da177e4 LT |
141 | |
142 | return rc; | |
143 | } | |
144 | ||
145 | static int | |
146 | odev_release(struct inode *inode, struct file *file) | |
147 | { | |
080dece3 | 148 | struct seq_oss_devinfo *dp; |
1da177e4 LT |
149 | |
150 | if ((dp = file->private_data) == NULL) | |
151 | return 0; | |
152 | ||
153 | snd_seq_oss_drain_write(dp); | |
154 | ||
1a60d4c5 | 155 | mutex_lock(®ister_mutex); |
1da177e4 | 156 | snd_seq_oss_release(dp); |
1a60d4c5 | 157 | mutex_unlock(®ister_mutex); |
1da177e4 LT |
158 | |
159 | return 0; | |
160 | } | |
161 | ||
162 | static ssize_t | |
163 | odev_read(struct file *file, char __user *buf, size_t count, loff_t *offset) | |
164 | { | |
080dece3 | 165 | struct seq_oss_devinfo *dp; |
1da177e4 | 166 | dp = file->private_data; |
7eaa943c TI |
167 | if (snd_BUG_ON(!dp)) |
168 | return -ENXIO; | |
1da177e4 LT |
169 | return snd_seq_oss_read(dp, buf, count); |
170 | } | |
171 | ||
172 | ||
173 | static ssize_t | |
174 | odev_write(struct file *file, const char __user *buf, size_t count, loff_t *offset) | |
175 | { | |
080dece3 | 176 | struct seq_oss_devinfo *dp; |
1da177e4 | 177 | dp = file->private_data; |
7eaa943c TI |
178 | if (snd_BUG_ON(!dp)) |
179 | return -ENXIO; | |
1da177e4 LT |
180 | return snd_seq_oss_write(dp, buf, count, file); |
181 | } | |
182 | ||
183 | static long | |
184 | odev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | |
185 | { | |
080dece3 | 186 | struct seq_oss_devinfo *dp; |
1da177e4 | 187 | dp = file->private_data; |
7eaa943c TI |
188 | if (snd_BUG_ON(!dp)) |
189 | return -ENXIO; | |
1da177e4 LT |
190 | return snd_seq_oss_ioctl(dp, cmd, arg); |
191 | } | |
192 | ||
193 | #ifdef CONFIG_COMPAT | |
194 | #define odev_ioctl_compat odev_ioctl | |
195 | #else | |
196 | #define odev_ioctl_compat NULL | |
197 | #endif | |
198 | ||
199 | static unsigned int | |
200 | odev_poll(struct file *file, poll_table * wait) | |
201 | { | |
080dece3 | 202 | struct seq_oss_devinfo *dp; |
1da177e4 | 203 | dp = file->private_data; |
7eaa943c TI |
204 | if (snd_BUG_ON(!dp)) |
205 | return -ENXIO; | |
1da177e4 LT |
206 | return snd_seq_oss_poll(dp, file, wait); |
207 | } | |
208 | ||
209 | /* | |
210 | * registration of sequencer minor device | |
211 | */ | |
212 | ||
9c2e08c5 | 213 | static const struct file_operations seq_oss_f_ops = |
1da177e4 LT |
214 | { |
215 | .owner = THIS_MODULE, | |
216 | .read = odev_read, | |
217 | .write = odev_write, | |
218 | .open = odev_open, | |
219 | .release = odev_release, | |
220 | .poll = odev_poll, | |
221 | .unlocked_ioctl = odev_ioctl, | |
222 | .compat_ioctl = odev_ioctl_compat, | |
6038f373 | 223 | .llseek = noop_llseek, |
1da177e4 LT |
224 | }; |
225 | ||
1da177e4 LT |
226 | static int __init |
227 | register_device(void) | |
228 | { | |
229 | int rc; | |
230 | ||
1a60d4c5 | 231 | mutex_lock(®ister_mutex); |
1da177e4 LT |
232 | if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, |
233 | NULL, 0, | |
f87135f5 | 234 | &seq_oss_f_ops, NULL, |
1da177e4 LT |
235 | SNDRV_SEQ_OSS_DEVNAME)) < 0) { |
236 | snd_printk(KERN_ERR "can't register device seq\n"); | |
1a60d4c5 | 237 | mutex_unlock(®ister_mutex); |
1da177e4 LT |
238 | return rc; |
239 | } | |
240 | if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC, | |
241 | NULL, 0, | |
f87135f5 | 242 | &seq_oss_f_ops, NULL, |
1da177e4 LT |
243 | SNDRV_SEQ_OSS_DEVNAME)) < 0) { |
244 | snd_printk(KERN_ERR "can't register device music\n"); | |
245 | snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0); | |
1a60d4c5 | 246 | mutex_unlock(®ister_mutex); |
1da177e4 LT |
247 | return rc; |
248 | } | |
249 | debug_printk(("device registered\n")); | |
1a60d4c5 | 250 | mutex_unlock(®ister_mutex); |
1da177e4 LT |
251 | return 0; |
252 | } | |
253 | ||
254 | static void | |
255 | unregister_device(void) | |
256 | { | |
1a60d4c5 | 257 | mutex_lock(®ister_mutex); |
1da177e4 LT |
258 | debug_printk(("device unregistered\n")); |
259 | if (snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC, NULL, 0) < 0) | |
260 | snd_printk(KERN_ERR "error unregister device music\n"); | |
261 | if (snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, NULL, 0) < 0) | |
262 | snd_printk(KERN_ERR "error unregister device seq\n"); | |
1a60d4c5 | 263 | mutex_unlock(®ister_mutex); |
1da177e4 LT |
264 | } |
265 | ||
266 | /* | |
267 | * /proc interface | |
268 | */ | |
269 | ||
270 | #ifdef CONFIG_PROC_FS | |
271 | ||
080dece3 | 272 | static struct snd_info_entry *info_entry; |
1da177e4 LT |
273 | |
274 | static void | |
080dece3 | 275 | info_read(struct snd_info_entry *entry, struct snd_info_buffer *buf) |
1da177e4 | 276 | { |
1a60d4c5 | 277 | mutex_lock(®ister_mutex); |
1da177e4 LT |
278 | snd_iprintf(buf, "OSS sequencer emulation version %s\n", SNDRV_SEQ_OSS_VERSION_STR); |
279 | snd_seq_oss_system_info_read(buf); | |
280 | snd_seq_oss_synth_info_read(buf); | |
281 | snd_seq_oss_midi_info_read(buf); | |
1a60d4c5 | 282 | mutex_unlock(®ister_mutex); |
1da177e4 LT |
283 | } |
284 | ||
1da177e4 LT |
285 | |
286 | static int __init | |
287 | register_proc(void) | |
288 | { | |
080dece3 | 289 | struct snd_info_entry *entry; |
1da177e4 LT |
290 | |
291 | entry = snd_info_create_module_entry(THIS_MODULE, SNDRV_SEQ_OSS_PROCNAME, snd_seq_root); | |
292 | if (entry == NULL) | |
293 | return -ENOMEM; | |
294 | ||
295 | entry->content = SNDRV_INFO_CONTENT_TEXT; | |
296 | entry->private_data = NULL; | |
1da177e4 LT |
297 | entry->c.text.read = info_read; |
298 | if (snd_info_register(entry) < 0) { | |
299 | snd_info_free_entry(entry); | |
300 | return -ENOMEM; | |
301 | } | |
302 | info_entry = entry; | |
1da177e4 LT |
303 | return 0; |
304 | } | |
305 | ||
306 | static void | |
307 | unregister_proc(void) | |
308 | { | |
746d4a02 | 309 | snd_info_free_entry(info_entry); |
1da177e4 | 310 | info_entry = NULL; |
1da177e4 | 311 | } |
04f141a8 | 312 | #endif /* CONFIG_PROC_FS */ |