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 23 #include <linux/init.h> 24 #include <linux/module.h> 25 #include <linux/mutex.h> 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); 54 #ifdef CONFIG_PROC_FS 55 static int register_proc(void); 56 static void unregister_proc(void); 57 #else 58 static inline int register_proc(void) { return 0; } 59 static inline void unregister_proc(void) {} 60 #endif 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); 68 69 70 /* 71 * module interface 72 */ 73 74 static int __init alsa_seq_oss_init(void) 75 { 76 int rc; 77 static struct snd_seq_dev_ops ops = { 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, 96 sizeof(struct snd_seq_oss_reg))) < 0) { 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 126 static DEFINE_MUTEX(register_mutex); 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 138 mutex_lock(®ister_mutex); 139 rc = snd_seq_oss_open(file, level); 140 mutex_unlock(®ister_mutex); 141 142 return rc; 143 } 144 145 static int 146 odev_release(struct inode *inode, struct file *file) 147 { 148 struct seq_oss_devinfo *dp; 149 150 if ((dp = file->private_data) == NULL) 151 return 0; 152 153 snd_seq_oss_drain_write(dp); 154 155 mutex_lock(®ister_mutex); 156 snd_seq_oss_release(dp); 157 mutex_unlock(®ister_mutex); 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 { 165 struct seq_oss_devinfo *dp; 166 dp = file->private_data; 167 if (snd_BUG_ON(!dp)) 168 return -ENXIO; 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 { 176 struct seq_oss_devinfo *dp; 177 dp = file->private_data; 178 if (snd_BUG_ON(!dp)) 179 return -ENXIO; 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 { 186 struct seq_oss_devinfo *dp; 187 dp = file->private_data; 188 if (snd_BUG_ON(!dp)) 189 return -ENXIO; 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 { 202 struct seq_oss_devinfo *dp; 203 dp = file->private_data; 204 if (snd_BUG_ON(!dp)) 205 return -ENXIO; 206 return snd_seq_oss_poll(dp, file, wait); 207 } 208 209 /* 210 * registration of sequencer minor device 211 */ 212 213 static const struct file_operations seq_oss_f_ops = 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, 223 .llseek = noop_llseek, 224 }; 225 226 static int __init 227 register_device(void) 228 { 229 int rc; 230 231 mutex_lock(®ister_mutex); 232 if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_SEQUENCER, 233 NULL, 0, 234 &seq_oss_f_ops, NULL, 235 SNDRV_SEQ_OSS_DEVNAME)) < 0) { 236 snd_printk(KERN_ERR "can't register device seq\n"); 237 mutex_unlock(®ister_mutex); 238 return rc; 239 } 240 if ((rc = snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MUSIC, 241 NULL, 0, 242 &seq_oss_f_ops, NULL, 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); 246 mutex_unlock(®ister_mutex); 247 return rc; 248 } 249 debug_printk(("device registered\n")); 250 mutex_unlock(®ister_mutex); 251 return 0; 252 } 253 254 static void 255 unregister_device(void) 256 { 257 mutex_lock(®ister_mutex); 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"); 263 mutex_unlock(®ister_mutex); 264 } 265 266 /* 267 * /proc interface 268 */ 269 270 #ifdef CONFIG_PROC_FS 271 272 static struct snd_info_entry *info_entry; 273 274 static void 275 info_read(struct snd_info_entry *entry, struct snd_info_buffer *buf) 276 { 277 mutex_lock(®ister_mutex); 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); 282 mutex_unlock(®ister_mutex); 283 } 284 285 286 static int __init 287 register_proc(void) 288 { 289 struct snd_info_entry *entry; 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; 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; 303 return 0; 304 } 305 306 static void 307 unregister_proc(void) 308 { 309 snd_info_free_entry(info_entry); 310 info_entry = NULL; 311 } 312 #endif /* CONFIG_PROC_FS */ 313