2 * OSS compatible sequencer driver
4 * registration of device and proc
6 * Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de>
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.
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.
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
23 #include <sound/driver.h>
24 #include <linux/init.h>
25 #include <linux/moduleparam.h>
26 #include <linux/mutex.h>
27 #include <sound/core.h>
28 #include <sound/minors.h>
29 #include <sound/initval.h>
30 #include "seq_oss_device.h"
31 #include "seq_oss_synth.h"
36 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
37 MODULE_DESCRIPTION("OSS-compatible sequencer module");
38 MODULE_LICENSE("GPL");
39 /* Takashi says this is really only for sound-service-0-, but this is OK. */
40 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_SEQUENCER
);
41 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MUSIC
);
43 #ifdef SNDRV_SEQ_OSS_DEBUG
44 module_param(seq_oss_debug
, int, 0644);
45 MODULE_PARM_DESC(seq_oss_debug
, "debug option");
46 int seq_oss_debug
= 0;
53 static int register_device(void);
54 static void unregister_device(void);
56 static int register_proc(void);
57 static void unregister_proc(void);
59 static inline int register_proc(void) { return 0; }
60 static inline void unregister_proc(void) {}
63 static int odev_open(struct inode
*inode
, struct file
*file
);
64 static int odev_release(struct inode
*inode
, struct file
*file
);
65 static ssize_t
odev_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*offset
);
66 static ssize_t
odev_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*offset
);
67 static long odev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
);
68 static unsigned int odev_poll(struct file
*file
, poll_table
* wait
);
75 static int __init
alsa_seq_oss_init(void)
78 static struct snd_seq_dev_ops ops
= {
79 snd_seq_oss_synth_register
,
80 snd_seq_oss_synth_unregister
,
83 snd_seq_autoload_lock();
84 if ((rc
= register_device()) < 0)
86 if ((rc
= register_proc()) < 0) {
90 if ((rc
= snd_seq_oss_create_client()) < 0) {
96 if ((rc
= snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OSS
, &ops
,
97 sizeof(struct snd_seq_oss_reg
))) < 0) {
98 snd_seq_oss_delete_client();
105 snd_seq_oss_synth_init();
108 snd_seq_autoload_unlock();
112 static void __exit
alsa_seq_oss_exit(void)
114 snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_OSS
);
115 snd_seq_oss_delete_client();
120 module_init(alsa_seq_oss_init
)
121 module_exit(alsa_seq_oss_exit
)
124 * ALSA minor device interface
127 static DEFINE_MUTEX(register_mutex
);
130 odev_open(struct inode
*inode
, struct file
*file
)
134 if (iminor(inode
) == SNDRV_MINOR_OSS_MUSIC
)
135 level
= SNDRV_SEQ_OSS_MODE_MUSIC
;
137 level
= SNDRV_SEQ_OSS_MODE_SYNTH
;
139 mutex_lock(®ister_mutex
);
140 rc
= snd_seq_oss_open(file
, level
);
141 mutex_unlock(®ister_mutex
);
147 odev_release(struct inode
*inode
, struct file
*file
)
149 struct seq_oss_devinfo
*dp
;
151 if ((dp
= file
->private_data
) == NULL
)
154 snd_seq_oss_drain_write(dp
);
156 mutex_lock(®ister_mutex
);
157 snd_seq_oss_release(dp
);
158 mutex_unlock(®ister_mutex
);
164 odev_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*offset
)
166 struct seq_oss_devinfo
*dp
;
167 dp
= file
->private_data
;
168 snd_assert(dp
!= NULL
, return -EIO
);
169 return snd_seq_oss_read(dp
, buf
, count
);
174 odev_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*offset
)
176 struct seq_oss_devinfo
*dp
;
177 dp
= file
->private_data
;
178 snd_assert(dp
!= NULL
, return -EIO
);
179 return snd_seq_oss_write(dp
, buf
, count
, file
);
183 odev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
185 struct seq_oss_devinfo
*dp
;
186 dp
= file
->private_data
;
187 snd_assert(dp
!= NULL
, return -EIO
);
188 return snd_seq_oss_ioctl(dp
, cmd
, arg
);
192 #define odev_ioctl_compat odev_ioctl
194 #define odev_ioctl_compat NULL
198 odev_poll(struct file
*file
, poll_table
* wait
)
200 struct seq_oss_devinfo
*dp
;
201 dp
= file
->private_data
;
202 snd_assert(dp
!= NULL
, return 0);
203 return snd_seq_oss_poll(dp
, file
, wait
);
207 * registration of sequencer minor device
210 static const struct file_operations seq_oss_f_ops
=
212 .owner
= THIS_MODULE
,
216 .release
= odev_release
,
218 .unlocked_ioctl
= odev_ioctl
,
219 .compat_ioctl
= odev_ioctl_compat
,
223 register_device(void)
227 mutex_lock(®ister_mutex
);
228 if ((rc
= snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER
,
230 &seq_oss_f_ops
, NULL
,
231 SNDRV_SEQ_OSS_DEVNAME
)) < 0) {
232 snd_printk(KERN_ERR
"can't register device seq\n");
233 mutex_unlock(®ister_mutex
);
236 if ((rc
= snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC
,
238 &seq_oss_f_ops
, NULL
,
239 SNDRV_SEQ_OSS_DEVNAME
)) < 0) {
240 snd_printk(KERN_ERR
"can't register device music\n");
241 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER
, NULL
, 0);
242 mutex_unlock(®ister_mutex
);
245 debug_printk(("device registered\n"));
246 mutex_unlock(®ister_mutex
);
251 unregister_device(void)
253 mutex_lock(®ister_mutex
);
254 debug_printk(("device unregistered\n"));
255 if (snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC
, NULL
, 0) < 0)
256 snd_printk(KERN_ERR
"error unregister device music\n");
257 if (snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER
, NULL
, 0) < 0)
258 snd_printk(KERN_ERR
"error unregister device seq\n");
259 mutex_unlock(®ister_mutex
);
266 #ifdef CONFIG_PROC_FS
268 static struct snd_info_entry
*info_entry
;
271 info_read(struct snd_info_entry
*entry
, struct snd_info_buffer
*buf
)
273 mutex_lock(®ister_mutex
);
274 snd_iprintf(buf
, "OSS sequencer emulation version %s\n", SNDRV_SEQ_OSS_VERSION_STR
);
275 snd_seq_oss_system_info_read(buf
);
276 snd_seq_oss_synth_info_read(buf
);
277 snd_seq_oss_midi_info_read(buf
);
278 mutex_unlock(®ister_mutex
);
285 struct snd_info_entry
*entry
;
287 entry
= snd_info_create_module_entry(THIS_MODULE
, SNDRV_SEQ_OSS_PROCNAME
, snd_seq_root
);
291 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
292 entry
->private_data
= NULL
;
293 entry
->c
.text
.read
= info_read
;
294 if (snd_info_register(entry
) < 0) {
295 snd_info_free_entry(entry
);
303 unregister_proc(void)
305 snd_info_free_entry(info_entry
);
308 #endif /* CONFIG_PROC_FS */