2 * OSS compatible sequencer driver
4 * open/close and reset interface
6 * Copyright (C) 1998-1999 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 "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/export.h>
32 #include <linux/moduleparam.h>
33 #include <linux/slab.h>
34 #include <linux/workqueue.h>
39 static int maxqlen
= SNDRV_SEQ_OSS_MAX_QLEN
;
40 module_param(maxqlen
, int, 0444);
41 MODULE_PARM_DESC(maxqlen
, "maximum queue length");
43 static int system_client
= -1; /* ALSA sequencer client number */
44 static int system_port
= -1;
46 static int num_clients
;
47 static struct seq_oss_devinfo
*client_table
[SNDRV_SEQ_OSS_MAX_CLIENTS
];
53 static int receive_announce(struct snd_seq_event
*ev
, int direct
, void *private, int atomic
, int hop
);
54 static int translate_mode(struct file
*file
);
55 static int create_port(struct seq_oss_devinfo
*dp
);
56 static int delete_port(struct seq_oss_devinfo
*dp
);
57 static int alloc_seq_queue(struct seq_oss_devinfo
*dp
);
58 static int delete_seq_queue(int queue
);
59 static void free_devinfo(void *private);
61 #define call_ctl(type,rec) snd_seq_kernel_client_ctl(system_client, type, rec)
64 /* call snd_seq_oss_midi_lookup_ports() asynchronously */
65 static void async_call_lookup_ports(struct work_struct
*work
)
67 snd_seq_oss_midi_lookup_ports(system_client
);
70 static DECLARE_WORK(async_lookup_work
, async_call_lookup_ports
);
73 * create sequencer client for OSS sequencer
76 snd_seq_oss_create_client(void)
79 struct snd_seq_port_info
*port
;
80 struct snd_seq_port_callback port_callback
;
82 port
= kmalloc(sizeof(*port
), GFP_KERNEL
);
88 /* create ALSA client */
89 rc
= snd_seq_create_kernel_client(NULL
, SNDRV_SEQ_CLIENT_OSS
,
95 debug_printk(("new client = %d\n", rc
));
97 /* create annoucement receiver port */
98 memset(port
, 0, sizeof(*port
));
99 strcpy(port
->name
, "Receiver");
100 port
->addr
.client
= system_client
;
101 port
->capability
= SNDRV_SEQ_PORT_CAP_WRITE
; /* receive only */
104 memset(&port_callback
, 0, sizeof(port_callback
));
105 /* don't set port_callback.owner here. otherwise the module counter
106 * is incremented and we can no longer release the module..
108 port_callback
.event_input
= receive_announce
;
109 port
->kernel
= &port_callback
;
111 call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT
, port
);
112 if ((system_port
= port
->addr
.port
) >= 0) {
113 struct snd_seq_port_subscribe subs
;
115 memset(&subs
, 0, sizeof(subs
));
116 subs
.sender
.client
= SNDRV_SEQ_CLIENT_SYSTEM
;
117 subs
.sender
.port
= SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE
;
118 subs
.dest
.client
= system_client
;
119 subs
.dest
.port
= system_port
;
120 call_ctl(SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT
, &subs
);
124 /* look up midi devices */
125 schedule_work(&async_lookup_work
);
134 * receive annoucement from system port, and check the midi device
137 receive_announce(struct snd_seq_event
*ev
, int direct
, void *private, int atomic
, int hop
)
139 struct snd_seq_port_info pinfo
;
142 return 0; /* it must not happen */
145 case SNDRV_SEQ_EVENT_PORT_START
:
146 case SNDRV_SEQ_EVENT_PORT_CHANGE
:
147 if (ev
->data
.addr
.client
== system_client
)
148 break; /* ignore myself */
149 memset(&pinfo
, 0, sizeof(pinfo
));
150 pinfo
.addr
= ev
->data
.addr
;
151 if (call_ctl(SNDRV_SEQ_IOCTL_GET_PORT_INFO
, &pinfo
) >= 0)
152 snd_seq_oss_midi_check_new_port(&pinfo
);
155 case SNDRV_SEQ_EVENT_PORT_EXIT
:
156 if (ev
->data
.addr
.client
== system_client
)
157 break; /* ignore myself */
158 snd_seq_oss_midi_check_exit_port(ev
->data
.addr
.client
,
167 * delete OSS sequencer client
170 snd_seq_oss_delete_client(void)
172 cancel_work_sync(&async_lookup_work
);
173 if (system_client
>= 0)
174 snd_seq_delete_kernel_client(system_client
);
176 snd_seq_oss_midi_clear_all();
183 * open sequencer device
186 snd_seq_oss_open(struct file
*file
, int level
)
189 struct seq_oss_devinfo
*dp
;
191 dp
= kzalloc(sizeof(*dp
), GFP_KERNEL
);
193 snd_printk(KERN_ERR
"can't malloc device info\n");
196 debug_printk(("oss_open: dp = %p\n", dp
));
198 dp
->cseq
= system_client
;
202 for (i
= 0; i
< SNDRV_SEQ_OSS_MAX_CLIENTS
; i
++) {
203 if (client_table
[i
] == NULL
)
208 if (i
>= SNDRV_SEQ_OSS_MAX_CLIENTS
) {
209 snd_printk(KERN_ERR
"too many applications\n");
214 /* look up synth and midi devices */
215 snd_seq_oss_synth_setup(dp
);
216 snd_seq_oss_midi_setup(dp
);
218 if (dp
->synth_opened
== 0 && dp
->max_mididev
== 0) {
219 /* snd_printk(KERN_ERR "no device found\n"); */
225 debug_printk(("create new port\n"));
226 rc
= create_port(dp
);
228 snd_printk(KERN_ERR
"can't create port\n");
233 debug_printk(("allocate queue\n"));
234 rc
= alloc_seq_queue(dp
);
239 dp
->addr
.client
= dp
->cseq
;
240 dp
->addr
.port
= dp
->port
;
241 /*dp->addr.queue = dp->queue;*/
242 /*dp->addr.channel = 0;*/
244 dp
->seq_mode
= level
;
246 /* set up file mode */
247 dp
->file_mode
= translate_mode(file
);
249 /* initialize read queue */
250 debug_printk(("initialize read queue\n"));
251 if (is_read_mode(dp
->file_mode
)) {
252 dp
->readq
= snd_seq_oss_readq_new(dp
, maxqlen
);
259 /* initialize write queue */
260 debug_printk(("initialize write queue\n"));
261 if (is_write_mode(dp
->file_mode
)) {
262 dp
->writeq
= snd_seq_oss_writeq_new(dp
, maxqlen
);
269 /* initialize timer */
270 debug_printk(("initialize timer\n"));
271 dp
->timer
= snd_seq_oss_timer_new(dp
);
273 snd_printk(KERN_ERR
"can't alloc timer\n");
277 debug_printk(("timer initialized\n"));
279 /* set private data pointer */
280 file
->private_data
= dp
;
282 /* set up for mode2 */
283 if (level
== SNDRV_SEQ_OSS_MODE_MUSIC
)
284 snd_seq_oss_synth_setup_midi(dp
);
285 else if (is_read_mode(dp
->file_mode
))
286 snd_seq_oss_midi_open_all(dp
, SNDRV_SEQ_OSS_FILE_READ
);
288 client_table
[dp
->index
] = dp
;
291 debug_printk(("open done\n"));
295 snd_seq_oss_synth_cleanup(dp
);
296 snd_seq_oss_midi_cleanup(dp
);
297 delete_seq_queue(dp
->queue
);
304 * translate file flags to private mode
307 translate_mode(struct file
*file
)
310 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
)
311 file_mode
|= SNDRV_SEQ_OSS_FILE_WRITE
;
312 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
)
313 file_mode
|= SNDRV_SEQ_OSS_FILE_READ
;
314 if (file
->f_flags
& O_NONBLOCK
)
315 file_mode
|= SNDRV_SEQ_OSS_FILE_NONBLOCK
;
321 * create sequencer port
324 create_port(struct seq_oss_devinfo
*dp
)
327 struct snd_seq_port_info port
;
328 struct snd_seq_port_callback callback
;
330 memset(&port
, 0, sizeof(port
));
331 port
.addr
.client
= dp
->cseq
;
332 sprintf(port
.name
, "Sequencer-%d", dp
->index
);
333 port
.capability
= SNDRV_SEQ_PORT_CAP_READ
|SNDRV_SEQ_PORT_CAP_WRITE
; /* no subscription */
334 port
.type
= SNDRV_SEQ_PORT_TYPE_SPECIFIC
;
335 port
.midi_channels
= 128;
336 port
.synth_voices
= 128;
338 memset(&callback
, 0, sizeof(callback
));
339 callback
.owner
= THIS_MODULE
;
340 callback
.private_data
= dp
;
341 callback
.event_input
= snd_seq_oss_event_input
;
342 callback
.private_free
= free_devinfo
;
343 port
.kernel
= &callback
;
345 rc
= call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT
, &port
);
349 dp
->port
= port
.addr
.port
;
350 debug_printk(("new port = %d\n", port
.addr
.port
));
359 delete_port(struct seq_oss_devinfo
*dp
)
366 debug_printk(("delete_port %i\n", dp
->port
));
367 return snd_seq_event_port_detach(dp
->cseq
, dp
->port
);
374 alloc_seq_queue(struct seq_oss_devinfo
*dp
)
376 struct snd_seq_queue_info qinfo
;
379 memset(&qinfo
, 0, sizeof(qinfo
));
380 qinfo
.owner
= system_client
;
382 strcpy(qinfo
.name
, "OSS Sequencer Emulation");
383 if ((rc
= call_ctl(SNDRV_SEQ_IOCTL_CREATE_QUEUE
, &qinfo
)) < 0)
385 dp
->queue
= qinfo
.queue
;
393 delete_seq_queue(int queue
)
395 struct snd_seq_queue_info qinfo
;
400 memset(&qinfo
, 0, sizeof(qinfo
));
402 rc
= call_ctl(SNDRV_SEQ_IOCTL_DELETE_QUEUE
, &qinfo
);
404 printk(KERN_ERR
"seq-oss: unable to delete queue %d (%d)\n", queue
, rc
);
410 * free device informations - private_free callback of port
413 free_devinfo(void *private)
415 struct seq_oss_devinfo
*dp
= (struct seq_oss_devinfo
*)private;
418 snd_seq_oss_timer_delete(dp
->timer
);
421 snd_seq_oss_writeq_delete(dp
->writeq
);
424 snd_seq_oss_readq_delete(dp
->readq
);
431 * close sequencer device
434 snd_seq_oss_release(struct seq_oss_devinfo
*dp
)
438 client_table
[dp
->index
] = NULL
;
441 debug_printk(("resetting..\n"));
442 snd_seq_oss_reset(dp
);
444 debug_printk(("cleaning up..\n"));
445 snd_seq_oss_synth_cleanup(dp
);
446 snd_seq_oss_midi_cleanup(dp
);
449 debug_printk(("releasing resource..\n"));
453 delete_seq_queue(queue
);
455 debug_printk(("release done\n"));
460 * Wait until the queue is empty (if we don't have nonblock)
463 snd_seq_oss_drain_write(struct seq_oss_devinfo
*dp
)
465 if (! dp
->timer
->running
)
467 if (is_write_mode(dp
->file_mode
) && !is_nonblock_mode(dp
->file_mode
) &&
469 debug_printk(("syncing..\n"));
470 while (snd_seq_oss_writeq_sync(dp
->writeq
))
477 * reset sequencer devices
480 snd_seq_oss_reset(struct seq_oss_devinfo
*dp
)
484 /* reset all synth devices */
485 for (i
= 0; i
< dp
->max_synthdev
; i
++)
486 snd_seq_oss_synth_reset(dp
, i
);
488 /* reset all midi devices */
489 if (dp
->seq_mode
!= SNDRV_SEQ_OSS_MODE_MUSIC
) {
490 for (i
= 0; i
< dp
->max_mididev
; i
++)
491 snd_seq_oss_midi_reset(dp
, i
);
496 snd_seq_oss_readq_clear(dp
->readq
);
498 snd_seq_oss_writeq_clear(dp
->writeq
);
501 snd_seq_oss_timer_stop(dp
->timer
);
505 #ifdef CONFIG_PROC_FS
507 * misc. functions for proc interface
510 enabled_str(int bool)
512 return bool ? "enabled" : "disabled";
516 filemode_str(int val
)
518 static char *str
[] = {
519 "none", "read", "write", "read/write",
521 return str
[val
& SNDRV_SEQ_OSS_FILE_ACMODE
];
529 snd_seq_oss_system_info_read(struct snd_info_buffer
*buf
)
532 struct seq_oss_devinfo
*dp
;
534 snd_iprintf(buf
, "ALSA client number %d\n", system_client
);
535 snd_iprintf(buf
, "ALSA receiver port %d\n", system_port
);
537 snd_iprintf(buf
, "\nNumber of applications: %d\n", num_clients
);
538 for (i
= 0; i
< num_clients
; i
++) {
539 snd_iprintf(buf
, "\nApplication %d: ", i
);
540 if ((dp
= client_table
[i
]) == NULL
) {
541 snd_iprintf(buf
, "*empty*\n");
544 snd_iprintf(buf
, "port %d : queue %d\n", dp
->port
, dp
->queue
);
545 snd_iprintf(buf
, " sequencer mode = %s : file open mode = %s\n",
546 (dp
->seq_mode
? "music" : "synth"),
547 filemode_str(dp
->file_mode
));
549 snd_iprintf(buf
, " timer tempo = %d, timebase = %d\n",
550 dp
->timer
->oss_tempo
, dp
->timer
->oss_timebase
);
551 snd_iprintf(buf
, " max queue length %d\n", maxqlen
);
552 if (is_read_mode(dp
->file_mode
) && dp
->readq
)
553 snd_seq_oss_readq_info_read(dp
->readq
, buf
);
556 #endif /* CONFIG_PROC_FS */