]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * OSS compatible sequencer driver | |
3 | * | |
4 | * open/close and reset interface | |
5 | * | |
6 | * Copyright (C) 1998-1999 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 "seq_oss_device.h" | |
24 | #include "seq_oss_synth.h" | |
25 | #include "seq_oss_midi.h" | |
26 | #include "seq_oss_writeq.h" | |
27 | #include "seq_oss_readq.h" | |
28 | #include "seq_oss_timer.h" | |
29 | #include "seq_oss_event.h" | |
30 | #include <linux/init.h> | |
31 | #include <linux/moduleparam.h> | |
5a0e3ad6 | 32 | #include <linux/slab.h> |
1da177e4 LT |
33 | |
34 | /* | |
35 | * common variables | |
36 | */ | |
37 | static int maxqlen = SNDRV_SEQ_OSS_MAX_QLEN; | |
38 | module_param(maxqlen, int, 0444); | |
39 | MODULE_PARM_DESC(maxqlen, "maximum queue length"); | |
40 | ||
41 | static int system_client = -1; /* ALSA sequencer client number */ | |
42 | static int system_port = -1; | |
43 | ||
44 | static int num_clients; | |
080dece3 | 45 | static struct seq_oss_devinfo *client_table[SNDRV_SEQ_OSS_MAX_CLIENTS]; |
1da177e4 LT |
46 | |
47 | ||
48 | /* | |
49 | * prototypes | |
50 | */ | |
080dece3 | 51 | static int receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop); |
1da177e4 | 52 | static int translate_mode(struct file *file); |
080dece3 TI |
53 | static int create_port(struct seq_oss_devinfo *dp); |
54 | static int delete_port(struct seq_oss_devinfo *dp); | |
55 | static int alloc_seq_queue(struct seq_oss_devinfo *dp); | |
1da177e4 LT |
56 | static int delete_seq_queue(int queue); |
57 | static void free_devinfo(void *private); | |
58 | ||
59 | #define call_ctl(type,rec) snd_seq_kernel_client_ctl(system_client, type, rec) | |
60 | ||
61 | ||
62 | /* | |
63 | * create sequencer client for OSS sequencer | |
64 | */ | |
65 | int __init | |
66 | snd_seq_oss_create_client(void) | |
67 | { | |
68 | int rc; | |
080dece3 TI |
69 | struct snd_seq_port_info *port; |
70 | struct snd_seq_port_callback port_callback; | |
1da177e4 | 71 | |
1da177e4 | 72 | port = kmalloc(sizeof(*port), GFP_KERNEL); |
7b6d9245 | 73 | if (!port) { |
1da177e4 LT |
74 | rc = -ENOMEM; |
75 | goto __error; | |
76 | } | |
77 | ||
78 | /* create ALSA client */ | |
7b6d9245 CL |
79 | rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS, |
80 | "OSS sequencer"); | |
1da177e4 LT |
81 | if (rc < 0) |
82 | goto __error; | |
83 | ||
84 | system_client = rc; | |
85 | debug_printk(("new client = %d\n", rc)); | |
86 | ||
1da177e4 LT |
87 | /* look up midi devices */ |
88 | snd_seq_oss_midi_lookup_ports(system_client); | |
89 | ||
90 | /* create annoucement receiver port */ | |
91 | memset(port, 0, sizeof(*port)); | |
92 | strcpy(port->name, "Receiver"); | |
93 | port->addr.client = system_client; | |
94 | port->capability = SNDRV_SEQ_PORT_CAP_WRITE; /* receive only */ | |
95 | port->type = 0; | |
96 | ||
97 | memset(&port_callback, 0, sizeof(port_callback)); | |
98 | /* don't set port_callback.owner here. otherwise the module counter | |
99 | * is incremented and we can no longer release the module.. | |
100 | */ | |
101 | port_callback.event_input = receive_announce; | |
102 | port->kernel = &port_callback; | |
103 | ||
104 | call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, port); | |
105 | if ((system_port = port->addr.port) >= 0) { | |
080dece3 | 106 | struct snd_seq_port_subscribe subs; |
1da177e4 LT |
107 | |
108 | memset(&subs, 0, sizeof(subs)); | |
109 | subs.sender.client = SNDRV_SEQ_CLIENT_SYSTEM; | |
110 | subs.sender.port = SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE; | |
111 | subs.dest.client = system_client; | |
112 | subs.dest.port = system_port; | |
113 | call_ctl(SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs); | |
114 | } | |
115 | rc = 0; | |
116 | ||
117 | __error: | |
118 | kfree(port); | |
1da177e4 LT |
119 | return rc; |
120 | } | |
121 | ||
122 | ||
123 | /* | |
124 | * receive annoucement from system port, and check the midi device | |
125 | */ | |
126 | static int | |
080dece3 | 127 | receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop) |
1da177e4 | 128 | { |
080dece3 | 129 | struct snd_seq_port_info pinfo; |
1da177e4 LT |
130 | |
131 | if (atomic) | |
132 | return 0; /* it must not happen */ | |
133 | ||
134 | switch (ev->type) { | |
135 | case SNDRV_SEQ_EVENT_PORT_START: | |
136 | case SNDRV_SEQ_EVENT_PORT_CHANGE: | |
137 | if (ev->data.addr.client == system_client) | |
138 | break; /* ignore myself */ | |
139 | memset(&pinfo, 0, sizeof(pinfo)); | |
140 | pinfo.addr = ev->data.addr; | |
141 | if (call_ctl(SNDRV_SEQ_IOCTL_GET_PORT_INFO, &pinfo) >= 0) | |
142 | snd_seq_oss_midi_check_new_port(&pinfo); | |
143 | break; | |
144 | ||
145 | case SNDRV_SEQ_EVENT_PORT_EXIT: | |
146 | if (ev->data.addr.client == system_client) | |
147 | break; /* ignore myself */ | |
148 | snd_seq_oss_midi_check_exit_port(ev->data.addr.client, | |
149 | ev->data.addr.port); | |
150 | break; | |
151 | } | |
152 | return 0; | |
153 | } | |
154 | ||
155 | ||
156 | /* | |
157 | * delete OSS sequencer client | |
158 | */ | |
159 | int | |
160 | snd_seq_oss_delete_client(void) | |
161 | { | |
162 | if (system_client >= 0) | |
163 | snd_seq_delete_kernel_client(system_client); | |
164 | ||
165 | snd_seq_oss_midi_clear_all(); | |
166 | ||
167 | return 0; | |
168 | } | |
169 | ||
170 | ||
171 | /* | |
172 | * open sequencer device | |
173 | */ | |
174 | int | |
175 | snd_seq_oss_open(struct file *file, int level) | |
176 | { | |
177 | int i, rc; | |
080dece3 | 178 | struct seq_oss_devinfo *dp; |
1da177e4 | 179 | |
7034632d ET |
180 | dp = kzalloc(sizeof(*dp), GFP_KERNEL); |
181 | if (!dp) { | |
1da177e4 LT |
182 | snd_printk(KERN_ERR "can't malloc device info\n"); |
183 | return -ENOMEM; | |
184 | } | |
185 | debug_printk(("oss_open: dp = %p\n", dp)); | |
186 | ||
7034632d ET |
187 | dp->cseq = system_client; |
188 | dp->port = -1; | |
189 | dp->queue = -1; | |
190 | ||
1da177e4 LT |
191 | for (i = 0; i < SNDRV_SEQ_OSS_MAX_CLIENTS; i++) { |
192 | if (client_table[i] == NULL) | |
193 | break; | |
194 | } | |
7034632d ET |
195 | |
196 | dp->index = i; | |
1da177e4 LT |
197 | if (i >= SNDRV_SEQ_OSS_MAX_CLIENTS) { |
198 | snd_printk(KERN_ERR "too many applications\n"); | |
7034632d ET |
199 | rc = -ENOMEM; |
200 | goto _error; | |
1da177e4 LT |
201 | } |
202 | ||
1da177e4 LT |
203 | /* look up synth and midi devices */ |
204 | snd_seq_oss_synth_setup(dp); | |
205 | snd_seq_oss_midi_setup(dp); | |
206 | ||
207 | if (dp->synth_opened == 0 && dp->max_mididev == 0) { | |
208 | /* snd_printk(KERN_ERR "no device found\n"); */ | |
209 | rc = -ENODEV; | |
210 | goto _error; | |
211 | } | |
212 | ||
213 | /* create port */ | |
214 | debug_printk(("create new port\n")); | |
7034632d ET |
215 | rc = create_port(dp); |
216 | if (rc < 0) { | |
1da177e4 LT |
217 | snd_printk(KERN_ERR "can't create port\n"); |
218 | goto _error; | |
219 | } | |
220 | ||
221 | /* allocate queue */ | |
222 | debug_printk(("allocate queue\n")); | |
7034632d ET |
223 | rc = alloc_seq_queue(dp); |
224 | if (rc < 0) | |
1da177e4 LT |
225 | goto _error; |
226 | ||
227 | /* set address */ | |
228 | dp->addr.client = dp->cseq; | |
229 | dp->addr.port = dp->port; | |
230 | /*dp->addr.queue = dp->queue;*/ | |
231 | /*dp->addr.channel = 0;*/ | |
232 | ||
233 | dp->seq_mode = level; | |
234 | ||
235 | /* set up file mode */ | |
236 | dp->file_mode = translate_mode(file); | |
237 | ||
238 | /* initialize read queue */ | |
239 | debug_printk(("initialize read queue\n")); | |
240 | if (is_read_mode(dp->file_mode)) { | |
7034632d ET |
241 | dp->readq = snd_seq_oss_readq_new(dp, maxqlen); |
242 | if (!dp->readq) { | |
1da177e4 LT |
243 | rc = -ENOMEM; |
244 | goto _error; | |
245 | } | |
246 | } | |
247 | ||
248 | /* initialize write queue */ | |
249 | debug_printk(("initialize write queue\n")); | |
250 | if (is_write_mode(dp->file_mode)) { | |
251 | dp->writeq = snd_seq_oss_writeq_new(dp, maxqlen); | |
7034632d | 252 | if (!dp->writeq) { |
1da177e4 LT |
253 | rc = -ENOMEM; |
254 | goto _error; | |
255 | } | |
256 | } | |
257 | ||
258 | /* initialize timer */ | |
259 | debug_printk(("initialize timer\n")); | |
7034632d ET |
260 | dp->timer = snd_seq_oss_timer_new(dp); |
261 | if (!dp->timer) { | |
1da177e4 LT |
262 | snd_printk(KERN_ERR "can't alloc timer\n"); |
263 | rc = -ENOMEM; | |
264 | goto _error; | |
265 | } | |
266 | debug_printk(("timer initialized\n")); | |
267 | ||
268 | /* set private data pointer */ | |
269 | file->private_data = dp; | |
270 | ||
271 | /* set up for mode2 */ | |
272 | if (level == SNDRV_SEQ_OSS_MODE_MUSIC) | |
273 | snd_seq_oss_synth_setup_midi(dp); | |
274 | else if (is_read_mode(dp->file_mode)) | |
275 | snd_seq_oss_midi_open_all(dp, SNDRV_SEQ_OSS_FILE_READ); | |
276 | ||
277 | client_table[dp->index] = dp; | |
278 | num_clients++; | |
279 | ||
280 | debug_printk(("open done\n")); | |
281 | return 0; | |
282 | ||
283 | _error: | |
7034632d ET |
284 | snd_seq_oss_writeq_delete(dp->writeq); |
285 | snd_seq_oss_readq_delete(dp->readq); | |
1da177e4 LT |
286 | snd_seq_oss_synth_cleanup(dp); |
287 | snd_seq_oss_midi_cleanup(dp); | |
1da177e4 | 288 | delete_port(dp); |
7034632d ET |
289 | delete_seq_queue(dp->queue); |
290 | kfree(dp); | |
1da177e4 LT |
291 | |
292 | return rc; | |
293 | } | |
294 | ||
295 | /* | |
296 | * translate file flags to private mode | |
297 | */ | |
298 | static int | |
299 | translate_mode(struct file *file) | |
300 | { | |
301 | int file_mode = 0; | |
302 | if ((file->f_flags & O_ACCMODE) != O_RDONLY) | |
303 | file_mode |= SNDRV_SEQ_OSS_FILE_WRITE; | |
304 | if ((file->f_flags & O_ACCMODE) != O_WRONLY) | |
305 | file_mode |= SNDRV_SEQ_OSS_FILE_READ; | |
306 | if (file->f_flags & O_NONBLOCK) | |
307 | file_mode |= SNDRV_SEQ_OSS_FILE_NONBLOCK; | |
308 | return file_mode; | |
309 | } | |
310 | ||
311 | ||
312 | /* | |
313 | * create sequencer port | |
314 | */ | |
315 | static int | |
080dece3 | 316 | create_port(struct seq_oss_devinfo *dp) |
1da177e4 LT |
317 | { |
318 | int rc; | |
080dece3 TI |
319 | struct snd_seq_port_info port; |
320 | struct snd_seq_port_callback callback; | |
1da177e4 LT |
321 | |
322 | memset(&port, 0, sizeof(port)); | |
323 | port.addr.client = dp->cseq; | |
324 | sprintf(port.name, "Sequencer-%d", dp->index); | |
325 | port.capability = SNDRV_SEQ_PORT_CAP_READ|SNDRV_SEQ_PORT_CAP_WRITE; /* no subscription */ | |
326 | port.type = SNDRV_SEQ_PORT_TYPE_SPECIFIC; | |
327 | port.midi_channels = 128; | |
328 | port.synth_voices = 128; | |
329 | ||
330 | memset(&callback, 0, sizeof(callback)); | |
331 | callback.owner = THIS_MODULE; | |
332 | callback.private_data = dp; | |
333 | callback.event_input = snd_seq_oss_event_input; | |
334 | callback.private_free = free_devinfo; | |
335 | port.kernel = &callback; | |
336 | ||
337 | rc = call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, &port); | |
338 | if (rc < 0) | |
339 | return rc; | |
340 | ||
341 | dp->port = port.addr.port; | |
342 | debug_printk(("new port = %d\n", port.addr.port)); | |
343 | ||
344 | return 0; | |
345 | } | |
346 | ||
347 | /* | |
348 | * delete ALSA port | |
349 | */ | |
350 | static int | |
080dece3 | 351 | delete_port(struct seq_oss_devinfo *dp) |
1da177e4 LT |
352 | { |
353 | if (dp->port < 0) | |
354 | return 0; | |
355 | ||
356 | debug_printk(("delete_port %i\n", dp->port)); | |
357 | return snd_seq_event_port_detach(dp->cseq, dp->port); | |
358 | } | |
359 | ||
360 | /* | |
361 | * allocate a queue | |
362 | */ | |
363 | static int | |
080dece3 | 364 | alloc_seq_queue(struct seq_oss_devinfo *dp) |
1da177e4 | 365 | { |
080dece3 | 366 | struct snd_seq_queue_info qinfo; |
1da177e4 LT |
367 | int rc; |
368 | ||
369 | memset(&qinfo, 0, sizeof(qinfo)); | |
370 | qinfo.owner = system_client; | |
371 | qinfo.locked = 1; | |
372 | strcpy(qinfo.name, "OSS Sequencer Emulation"); | |
373 | if ((rc = call_ctl(SNDRV_SEQ_IOCTL_CREATE_QUEUE, &qinfo)) < 0) | |
374 | return rc; | |
375 | dp->queue = qinfo.queue; | |
376 | return 0; | |
377 | } | |
378 | ||
379 | /* | |
380 | * release queue | |
381 | */ | |
382 | static int | |
383 | delete_seq_queue(int queue) | |
384 | { | |
080dece3 | 385 | struct snd_seq_queue_info qinfo; |
1da177e4 LT |
386 | int rc; |
387 | ||
388 | if (queue < 0) | |
389 | return 0; | |
390 | memset(&qinfo, 0, sizeof(qinfo)); | |
391 | qinfo.queue = queue; | |
392 | rc = call_ctl(SNDRV_SEQ_IOCTL_DELETE_QUEUE, &qinfo); | |
393 | if (rc < 0) | |
394 | printk(KERN_ERR "seq-oss: unable to delete queue %d (%d)\n", queue, rc); | |
395 | return rc; | |
396 | } | |
397 | ||
398 | ||
399 | /* | |
400 | * free device informations - private_free callback of port | |
401 | */ | |
402 | static void | |
403 | free_devinfo(void *private) | |
404 | { | |
080dece3 | 405 | struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private; |
1da177e4 LT |
406 | |
407 | if (dp->timer) | |
408 | snd_seq_oss_timer_delete(dp->timer); | |
409 | ||
410 | if (dp->writeq) | |
411 | snd_seq_oss_writeq_delete(dp->writeq); | |
412 | ||
413 | if (dp->readq) | |
414 | snd_seq_oss_readq_delete(dp->readq); | |
415 | ||
416 | kfree(dp); | |
417 | } | |
418 | ||
419 | ||
420 | /* | |
421 | * close sequencer device | |
422 | */ | |
423 | void | |
080dece3 | 424 | snd_seq_oss_release(struct seq_oss_devinfo *dp) |
1da177e4 LT |
425 | { |
426 | int queue; | |
427 | ||
428 | client_table[dp->index] = NULL; | |
429 | num_clients--; | |
430 | ||
431 | debug_printk(("resetting..\n")); | |
432 | snd_seq_oss_reset(dp); | |
433 | ||
434 | debug_printk(("cleaning up..\n")); | |
435 | snd_seq_oss_synth_cleanup(dp); | |
436 | snd_seq_oss_midi_cleanup(dp); | |
437 | ||
438 | /* clear slot */ | |
439 | debug_printk(("releasing resource..\n")); | |
440 | queue = dp->queue; | |
441 | if (dp->port >= 0) | |
442 | delete_port(dp); | |
443 | delete_seq_queue(queue); | |
444 | ||
445 | debug_printk(("release done\n")); | |
446 | } | |
447 | ||
448 | ||
449 | /* | |
450 | * Wait until the queue is empty (if we don't have nonblock) | |
451 | */ | |
452 | void | |
080dece3 | 453 | snd_seq_oss_drain_write(struct seq_oss_devinfo *dp) |
1da177e4 LT |
454 | { |
455 | if (! dp->timer->running) | |
456 | return; | |
457 | if (is_write_mode(dp->file_mode) && !is_nonblock_mode(dp->file_mode) && | |
458 | dp->writeq) { | |
459 | debug_printk(("syncing..\n")); | |
460 | while (snd_seq_oss_writeq_sync(dp->writeq)) | |
461 | ; | |
462 | } | |
463 | } | |
464 | ||
465 | ||
466 | /* | |
467 | * reset sequencer devices | |
468 | */ | |
469 | void | |
080dece3 | 470 | snd_seq_oss_reset(struct seq_oss_devinfo *dp) |
1da177e4 LT |
471 | { |
472 | int i; | |
473 | ||
474 | /* reset all synth devices */ | |
475 | for (i = 0; i < dp->max_synthdev; i++) | |
476 | snd_seq_oss_synth_reset(dp, i); | |
477 | ||
478 | /* reset all midi devices */ | |
479 | if (dp->seq_mode != SNDRV_SEQ_OSS_MODE_MUSIC) { | |
480 | for (i = 0; i < dp->max_mididev; i++) | |
481 | snd_seq_oss_midi_reset(dp, i); | |
482 | } | |
483 | ||
484 | /* remove queues */ | |
485 | if (dp->readq) | |
486 | snd_seq_oss_readq_clear(dp->readq); | |
487 | if (dp->writeq) | |
488 | snd_seq_oss_writeq_clear(dp->writeq); | |
489 | ||
490 | /* reset timer */ | |
491 | snd_seq_oss_timer_stop(dp->timer); | |
492 | } | |
493 | ||
494 | ||
04f141a8 | 495 | #ifdef CONFIG_PROC_FS |
1da177e4 LT |
496 | /* |
497 | * misc. functions for proc interface | |
498 | */ | |
499 | char * | |
500 | enabled_str(int bool) | |
501 | { | |
502 | return bool ? "enabled" : "disabled"; | |
503 | } | |
504 | ||
505 | static char * | |
506 | filemode_str(int val) | |
507 | { | |
508 | static char *str[] = { | |
509 | "none", "read", "write", "read/write", | |
510 | }; | |
511 | return str[val & SNDRV_SEQ_OSS_FILE_ACMODE]; | |
512 | } | |
513 | ||
514 | ||
515 | /* | |
516 | * proc interface | |
517 | */ | |
518 | void | |
080dece3 | 519 | snd_seq_oss_system_info_read(struct snd_info_buffer *buf) |
1da177e4 LT |
520 | { |
521 | int i; | |
080dece3 | 522 | struct seq_oss_devinfo *dp; |
1da177e4 LT |
523 | |
524 | snd_iprintf(buf, "ALSA client number %d\n", system_client); | |
525 | snd_iprintf(buf, "ALSA receiver port %d\n", system_port); | |
526 | ||
527 | snd_iprintf(buf, "\nNumber of applications: %d\n", num_clients); | |
528 | for (i = 0; i < num_clients; i++) { | |
529 | snd_iprintf(buf, "\nApplication %d: ", i); | |
530 | if ((dp = client_table[i]) == NULL) { | |
531 | snd_iprintf(buf, "*empty*\n"); | |
532 | continue; | |
533 | } | |
534 | snd_iprintf(buf, "port %d : queue %d\n", dp->port, dp->queue); | |
535 | snd_iprintf(buf, " sequencer mode = %s : file open mode = %s\n", | |
536 | (dp->seq_mode ? "music" : "synth"), | |
537 | filemode_str(dp->file_mode)); | |
538 | if (dp->seq_mode) | |
539 | snd_iprintf(buf, " timer tempo = %d, timebase = %d\n", | |
540 | dp->timer->oss_tempo, dp->timer->oss_timebase); | |
541 | snd_iprintf(buf, " max queue length %d\n", maxqlen); | |
542 | if (is_read_mode(dp->file_mode) && dp->readq) | |
543 | snd_seq_oss_readq_info_read(dp->readq, buf); | |
544 | } | |
545 | } | |
04f141a8 | 546 | #endif /* CONFIG_PROC_FS */ |