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>
32
33 /*
34 * common variables
35 */
36 static int maxqlen = SNDRV_SEQ_OSS_MAX_QLEN;
37 module_param(maxqlen, int, 0444);
38 MODULE_PARM_DESC(maxqlen, "maximum queue length");
39
40 static int system_client = -1; /* ALSA sequencer client number */
41 static int system_port = -1;
42
43 static int num_clients;
44 static seq_oss_devinfo_t *client_table[SNDRV_SEQ_OSS_MAX_CLIENTS];
45
46
47 /*
48 * prototypes
49 */
50 static int receive_announce(snd_seq_event_t *ev, int direct, void *private, int atomic, int hop);
51 static int translate_mode(struct file *file);
52 static int create_port(seq_oss_devinfo_t *dp);
53 static int delete_port(seq_oss_devinfo_t *dp);
54 static int alloc_seq_queue(seq_oss_devinfo_t *dp);
55 static int delete_seq_queue(int queue);
56 static void free_devinfo(void *private);
57
58 #define call_ctl(type,rec) snd_seq_kernel_client_ctl(system_client, type, rec)
59
60
61 /*
62 * create sequencer client for OSS sequencer
63 */
64 int __init
65 snd_seq_oss_create_client(void)
66 {
67 int rc;
68 snd_seq_client_callback_t callback;
69 snd_seq_client_info_t info;
70 snd_seq_port_info_t port;
71 snd_seq_port_callback_t port_callback;
72
73 /* create ALSA client */
74 memset(&callback, 0, sizeof(callback));
75
76 callback.private_data = NULL;
77 callback.allow_input = 1;
78 callback.allow_output = 1;
79
80 rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS, &callback);
81 if (rc < 0)
82 return rc;
83
84 system_client = rc;
85 debug_printk(("new client = %d\n", rc));
86
87 /* set client information */
88 memset(&info, 0, sizeof(info));
89 info.client = system_client;
90 info.type = KERNEL_CLIENT;
91 strcpy(info.name, "OSS sequencer");
92
93 rc = call_ctl(SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &info);
94
95 /* look up midi devices */
96 snd_seq_oss_midi_lookup_ports(system_client);
97
98 /* create annoucement receiver port */
99 memset(&port, 0, sizeof(port));
100 strcpy(port.name, "Receiver");
101 port.addr.client = system_client;
102 port.capability = SNDRV_SEQ_PORT_CAP_WRITE; /* receive only */
103 port.type = 0;
104
105 memset(&port_callback, 0, sizeof(port_callback));
106 /* don't set port_callback.owner here. otherwise the module counter
107 * is incremented and we can no longer release the module..
108 */
109 port_callback.event_input = receive_announce;
110 port.kernel = &port_callback;
111
112 call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, &port);
113 if ((system_port = port.addr.port) >= 0) {
114 snd_seq_port_subscribe_t subs;
115
116 memset(&subs, 0, sizeof(subs));
117 subs.sender.client = SNDRV_SEQ_CLIENT_SYSTEM;
118 subs.sender.port = SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE;
119 subs.dest.client = system_client;
120 subs.dest.port = system_port;
121 call_ctl(SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs);
122 }
123
124
125 return 0;
126 }
127
128
129 /*
130 * receive annoucement from system port, and check the midi device
131 */
132 static int
133 receive_announce(snd_seq_event_t *ev, int direct, void *private, int atomic, int hop)
134 {
135 snd_seq_port_info_t pinfo;
136
137 if (atomic)
138 return 0; /* it must not happen */
139
140 switch (ev->type) {
141 case SNDRV_SEQ_EVENT_PORT_START:
142 case SNDRV_SEQ_EVENT_PORT_CHANGE:
143 if (ev->data.addr.client == system_client)
144 break; /* ignore myself */
145 memset(&pinfo, 0, sizeof(pinfo));
146 pinfo.addr = ev->data.addr;
147 if (call_ctl(SNDRV_SEQ_IOCTL_GET_PORT_INFO, &pinfo) >= 0)
148 snd_seq_oss_midi_check_new_port(&pinfo);
149 break;
150
151 case SNDRV_SEQ_EVENT_PORT_EXIT:
152 if (ev->data.addr.client == system_client)
153 break; /* ignore myself */
154 snd_seq_oss_midi_check_exit_port(ev->data.addr.client,
155 ev->data.addr.port);
156 break;
157 }
158 return 0;
159 }
160
161
162 /*
163 * delete OSS sequencer client
164 */
165 int
166 snd_seq_oss_delete_client(void)
167 {
168 if (system_client >= 0)
169 snd_seq_delete_kernel_client(system_client);
170
171 snd_seq_oss_midi_clear_all();
172
173 return 0;
174 }
175
176
177 /*
178 * open sequencer device
179 */
180 int
181 snd_seq_oss_open(struct file *file, int level)
182 {
183 int i, rc;
184 seq_oss_devinfo_t *dp;
185
186 if ((dp = kcalloc(1, sizeof(*dp), GFP_KERNEL)) == NULL) {
187 snd_printk(KERN_ERR "can't malloc device info\n");
188 return -ENOMEM;
189 }
190 debug_printk(("oss_open: dp = %p\n", dp));
191
192 for (i = 0; i < SNDRV_SEQ_OSS_MAX_CLIENTS; i++) {
193 if (client_table[i] == NULL)
194 break;
195 }
196 if (i >= SNDRV_SEQ_OSS_MAX_CLIENTS) {
197 snd_printk(KERN_ERR "too many applications\n");
198 kfree(dp);
199 return -ENOMEM;
200 }
201
202 dp->index = i;
203 dp->cseq = system_client;
204 dp->port = -1;
205 dp->queue = -1;
206 dp->readq = NULL;
207 dp->writeq = NULL;
208
209 /* look up synth and midi devices */
210 snd_seq_oss_synth_setup(dp);
211 snd_seq_oss_midi_setup(dp);
212
213 if (dp->synth_opened == 0 && dp->max_mididev == 0) {
214 /* snd_printk(KERN_ERR "no device found\n"); */
215 rc = -ENODEV;
216 goto _error;
217 }
218
219 /* create port */
220 debug_printk(("create new port\n"));
221 if ((rc = create_port(dp)) < 0) {
222 snd_printk(KERN_ERR "can't create port\n");
223 goto _error;
224 }
225
226 /* allocate queue */
227 debug_printk(("allocate queue\n"));
228 if ((rc = alloc_seq_queue(dp)) < 0)
229 goto _error;
230
231 /* set address */
232 dp->addr.client = dp->cseq;
233 dp->addr.port = dp->port;
234 /*dp->addr.queue = dp->queue;*/
235 /*dp->addr.channel = 0;*/
236
237 dp->seq_mode = level;
238
239 /* set up file mode */
240 dp->file_mode = translate_mode(file);
241
242 /* initialize read queue */
243 debug_printk(("initialize read queue\n"));
244 if (is_read_mode(dp->file_mode)) {
245 if ((dp->readq = snd_seq_oss_readq_new(dp, maxqlen)) == NULL) {
246 rc = -ENOMEM;
247 goto _error;
248 }
249 }
250
251 /* initialize write queue */
252 debug_printk(("initialize write queue\n"));
253 if (is_write_mode(dp->file_mode)) {
254 dp->writeq = snd_seq_oss_writeq_new(dp, maxqlen);
255 if (dp->writeq == NULL) {
256 rc = -ENOMEM;
257 goto _error;
258 }
259 }
260
261 /* initialize timer */
262 debug_printk(("initialize timer\n"));
263 if ((dp->timer = snd_seq_oss_timer_new(dp)) == NULL) {
264 snd_printk(KERN_ERR "can't alloc timer\n");
265 rc = -ENOMEM;
266 goto _error;
267 }
268 debug_printk(("timer initialized\n"));
269
270 /* set private data pointer */
271 file->private_data = dp;
272
273 /* set up for mode2 */
274 if (level == SNDRV_SEQ_OSS_MODE_MUSIC)
275 snd_seq_oss_synth_setup_midi(dp);
276 else if (is_read_mode(dp->file_mode))
277 snd_seq_oss_midi_open_all(dp, SNDRV_SEQ_OSS_FILE_READ);
278
279 client_table[dp->index] = dp;
280 num_clients++;
281
282 debug_printk(("open done\n"));
283 return 0;
284
285 _error:
286 snd_seq_oss_synth_cleanup(dp);
287 snd_seq_oss_midi_cleanup(dp);
288 i = dp->queue;
289 delete_port(dp);
290 delete_seq_queue(i);
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
316 create_port(seq_oss_devinfo_t *dp)
317 {
318 int rc;
319 snd_seq_port_info_t port;
320 snd_seq_port_callback_t callback;
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
351 delete_port(seq_oss_devinfo_t *dp)
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
364 alloc_seq_queue(seq_oss_devinfo_t *dp)
365 {
366 snd_seq_queue_info_t qinfo;
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 {
385 snd_seq_queue_info_t qinfo;
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 {
405 seq_oss_devinfo_t *dp = (seq_oss_devinfo_t *)private;
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
424 snd_seq_oss_release(seq_oss_devinfo_t *dp)
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
453 snd_seq_oss_drain_write(seq_oss_devinfo_t *dp)
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
470 snd_seq_oss_reset(seq_oss_devinfo_t *dp)
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
495 /*
496 * misc. functions for proc interface
497 */
498 char *
499 enabled_str(int bool)
500 {
501 return bool ? "enabled" : "disabled";
502 }
503
504 static char *
505 filemode_str(int val)
506 {
507 static char *str[] = {
508 "none", "read", "write", "read/write",
509 };
510 return str[val & SNDRV_SEQ_OSS_FILE_ACMODE];
511 }
512
513
514 /*
515 * proc interface
516 */
517 void
518 snd_seq_oss_system_info_read(snd_info_buffer_t *buf)
519 {
520 int i;
521 seq_oss_devinfo_t *dp;
522
523 snd_iprintf(buf, "ALSA client number %d\n", system_client);
524 snd_iprintf(buf, "ALSA receiver port %d\n", system_port);
525
526 snd_iprintf(buf, "\nNumber of applications: %d\n", num_clients);
527 for (i = 0; i < num_clients; i++) {
528 snd_iprintf(buf, "\nApplication %d: ", i);
529 if ((dp = client_table[i]) == NULL) {
530 snd_iprintf(buf, "*empty*\n");
531 continue;
532 }
533 snd_iprintf(buf, "port %d : queue %d\n", dp->port, dp->queue);
534 snd_iprintf(buf, " sequencer mode = %s : file open mode = %s\n",
535 (dp->seq_mode ? "music" : "synth"),
536 filemode_str(dp->file_mode));
537 if (dp->seq_mode)
538 snd_iprintf(buf, " timer tempo = %d, timebase = %d\n",
539 dp->timer->oss_tempo, dp->timer->oss_timebase);
540 snd_iprintf(buf, " max queue length %d\n", maxqlen);
541 if (is_read_mode(dp->file_mode) && dp->readq)
542 snd_seq_oss_readq_info_read(dp->readq, buf);
543 }
544 }
545
546
|
This page was automatically generated by the
LXR engine.
|