2 * OSS compatible sequencer driver
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 "seq_oss_midi.h"
24 #include "seq_oss_readq.h"
25 #include "seq_oss_timer.h"
26 #include "seq_oss_event.h"
27 #include <sound/seq_midi_event.h>
28 #include "../seq_lock.h"
29 #include <linux/init.h>
35 #define SNDRV_SEQ_OSS_MAX_MIDI_NAME 30
38 * definition of midi device record
40 struct seq_oss_midi_t {
41 int seq_device; /* device number */
42 int client; /* sequencer client number */
43 int port; /* sequencer port number */
44 unsigned int flags; /* port capability */
45 int opened; /* flag for opening */
46 unsigned char name[SNDRV_SEQ_OSS_MAX_MIDI_NAME];
47 snd_midi_event_t *coder; /* MIDI event coder */
48 seq_oss_devinfo_t *devinfo; /* assigned OSSseq device */
49 snd_use_lock_t use_lock;
56 static int max_midi_devs;
57 static seq_oss_midi_t *midi_devs[SNDRV_SEQ_OSS_MAX_MIDI_DEVS];
59 static spinlock_t register_lock = SPIN_LOCK_UNLOCKED;
64 static seq_oss_midi_t *get_mdev(int dev);
65 static seq_oss_midi_t *get_mididev(seq_oss_devinfo_t *dp, int dev);
66 static int send_synth_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int dev);
67 static int send_midi_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, seq_oss_midi_t *mdev);
70 * look up the existing ports
71 * this looks a very exhausting job.
74 snd_seq_oss_midi_lookup_ports(int client)
76 snd_seq_system_info_t sysinfo;
77 snd_seq_client_info_t clinfo;
78 snd_seq_port_info_t pinfo;
81 rc = snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_SYSTEM_INFO, &sysinfo);
85 memset(&clinfo, 0, sizeof(clinfo));
86 memset(&pinfo, 0, sizeof(pinfo));
88 while (snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT, &clinfo) == 0) {
89 if (clinfo.client == client)
90 continue; /* ignore myself */
91 pinfo.addr.client = clinfo.client;
93 while (snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT, &pinfo) == 0)
94 snd_seq_oss_midi_check_new_port(&pinfo);
102 static seq_oss_midi_t *
105 seq_oss_midi_t *mdev;
108 spin_lock_irqsave(®ister_lock, flags);
109 mdev = midi_devs[dev];
111 snd_use_lock_use(&mdev->use_lock);
112 spin_unlock_irqrestore(®ister_lock, flags);
117 * look for the identical slot
119 static seq_oss_midi_t *
120 find_slot(int client, int port)
123 seq_oss_midi_t *mdev;
126 spin_lock_irqsave(®ister_lock, flags);
127 for (i = 0; i < max_midi_devs; i++) {
129 if (mdev && mdev->client == client && mdev->port == port) {
131 snd_use_lock_use(&mdev->use_lock);
132 spin_unlock_irqrestore(®ister_lock, flags);
136 spin_unlock_irqrestore(®ister_lock, flags);
141 #define PERM_WRITE (SNDRV_SEQ_PORT_CAP_WRITE|SNDRV_SEQ_PORT_CAP_SUBS_WRITE)
142 #define PERM_READ (SNDRV_SEQ_PORT_CAP_READ|SNDRV_SEQ_PORT_CAP_SUBS_READ)
144 * register a new port if it doesn't exist yet
147 snd_seq_oss_midi_check_new_port(snd_seq_port_info_t *pinfo)
150 seq_oss_midi_t *mdev;
153 debug_printk(("check for MIDI client %d port %d\n", pinfo->addr.client, pinfo->addr.port));
154 /* the port must include generic midi */
155 if (! (pinfo->type & SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC))
157 /* either read or write subscribable */
158 if ((pinfo->capability & PERM_WRITE) != PERM_WRITE &&
159 (pinfo->capability & PERM_READ) != PERM_READ)
163 * look for the identical slot
165 if ((mdev = find_slot(pinfo->addr.client, pinfo->addr.port)) != NULL) {
167 snd_use_lock_free(&mdev->use_lock);
172 * allocate midi info record
174 if ((mdev = snd_kcalloc(sizeof(*mdev), GFP_KERNEL)) == NULL) {
175 snd_printk(KERN_ERR "can't malloc midi info\n");
179 /* copy the port information */
180 mdev->client = pinfo->addr.client;
181 mdev->port = pinfo->addr.port;
182 mdev->flags = pinfo->capability;
184 snd_use_lock_init(&mdev->use_lock);
186 /* copy and truncate the name of synth device */
187 strlcpy(mdev->name, pinfo->name, sizeof(mdev->name));
189 /* create MIDI coder */
190 if (snd_midi_event_new(MAX_MIDI_EVENT_BUF, &mdev->coder) < 0) {
191 snd_printk(KERN_ERR "can't malloc midi coder\n");
195 /* OSS sequencer adds running status to all sequences */
196 snd_midi_event_no_status(mdev->coder, 1);
199 * look for en empty slot
201 spin_lock_irqsave(®ister_lock, flags);
202 for (i = 0; i < max_midi_devs; i++) {
203 if (midi_devs[i] == NULL)
206 if (i >= max_midi_devs) {
207 if (max_midi_devs >= SNDRV_SEQ_OSS_MAX_MIDI_DEVS) {
208 spin_unlock_irqrestore(®ister_lock, flags);
209 snd_midi_event_free(mdev->coder);
215 mdev->seq_device = i;
216 midi_devs[mdev->seq_device] = mdev;
217 spin_unlock_irqrestore(®ister_lock, flags);
223 * release the midi device if it was registered
226 snd_seq_oss_midi_check_exit_port(int client, int port)
228 seq_oss_midi_t *mdev;
232 if ((mdev = find_slot(client, port)) != NULL) {
233 spin_lock_irqsave(®ister_lock, flags);
234 midi_devs[mdev->seq_device] = NULL;
235 spin_unlock_irqrestore(®ister_lock, flags);
236 snd_use_lock_free(&mdev->use_lock);
237 snd_use_lock_sync(&mdev->use_lock);
239 snd_midi_event_free(mdev->coder);
242 spin_lock_irqsave(®ister_lock, flags);
243 for (index = max_midi_devs - 1; index >= 0; index--) {
244 if (midi_devs[index])
247 max_midi_devs = index + 1;
248 spin_unlock_irqrestore(®ister_lock, flags);
254 * release the midi device if it was registered
257 snd_seq_oss_midi_clear_all(void)
260 seq_oss_midi_t *mdev;
263 spin_lock_irqsave(®ister_lock, flags);
264 for (i = 0; i < max_midi_devs; i++) {
265 if ((mdev = midi_devs[i]) != NULL) {
267 snd_midi_event_free(mdev->coder);
273 spin_unlock_irqrestore(®ister_lock, flags);
281 snd_seq_oss_midi_setup(seq_oss_devinfo_t *dp)
283 dp->max_mididev = max_midi_devs;
287 * clean up midi tables
290 snd_seq_oss_midi_cleanup(seq_oss_devinfo_t *dp)
293 for (i = 0; i < dp->max_mididev; i++)
294 snd_seq_oss_midi_close(dp, i);
300 * open all midi devices. ignore errors.
303 snd_seq_oss_midi_open_all(seq_oss_devinfo_t *dp, int file_mode)
306 for (i = 0; i < dp->max_mididev; i++)
307 snd_seq_oss_midi_open(dp, i, file_mode);
312 * get the midi device information
314 static seq_oss_midi_t *
315 get_mididev(seq_oss_devinfo_t *dp, int dev)
317 if (dev < 0 || dev >= dp->max_mididev)
319 return get_mdev(dev);
324 * open the midi device if not opened yet
327 snd_seq_oss_midi_open(seq_oss_devinfo_t *dp, int dev, int fmode)
330 seq_oss_midi_t *mdev;
331 snd_seq_port_subscribe_t subs;
333 if ((mdev = get_mididev(dp, dev)) == NULL)
337 if (mdev->opened && mdev->devinfo != dp) {
338 snd_use_lock_free(&mdev->use_lock);
343 if (is_write_mode(fmode))
345 if (is_read_mode(fmode))
349 snd_use_lock_free(&mdev->use_lock);
353 /* already opened? */
354 if ((mdev->opened & perm) == perm) {
355 snd_use_lock_free(&mdev->use_lock);
359 perm &= ~mdev->opened;
361 memset(&subs, 0, sizeof(subs));
363 if (perm & PERM_WRITE) {
364 subs.sender = dp->addr;
365 subs.dest.client = mdev->client;
366 subs.dest.port = mdev->port;
367 if (snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs) >= 0)
368 mdev->opened |= PERM_WRITE;
370 if (perm & PERM_READ) {
371 subs.sender.client = mdev->client;
372 subs.sender.port = mdev->port;
373 subs.dest = dp->addr;
374 subs.flags = SNDRV_SEQ_PORT_SUBS_TIMESTAMP;
375 subs.queue = dp->queue; /* queue for timestamps */
376 if (snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs) >= 0)
377 mdev->opened |= PERM_READ;
380 if (! mdev->opened) {
381 snd_use_lock_free(&mdev->use_lock);
386 snd_use_lock_free(&mdev->use_lock);
391 * close the midi device if already opened
394 snd_seq_oss_midi_close(seq_oss_devinfo_t *dp, int dev)
396 seq_oss_midi_t *mdev;
397 snd_seq_port_subscribe_t subs;
399 if ((mdev = get_mididev(dp, dev)) == NULL)
401 if (! mdev->opened || mdev->devinfo != dp) {
402 snd_use_lock_free(&mdev->use_lock);
406 debug_printk(("closing client %d port %d mode %d\n", mdev->client, mdev->port, mdev->opened));
407 memset(&subs, 0, sizeof(subs));
408 if (mdev->opened & PERM_WRITE) {
409 subs.sender = dp->addr;
410 subs.dest.client = mdev->client;
411 subs.dest.port = mdev->port;
412 snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, &subs);
414 if (mdev->opened & PERM_READ) {
415 subs.sender.client = mdev->client;
416 subs.sender.port = mdev->port;
417 subs.dest = dp->addr;
418 snd_seq_kernel_client_ctl(dp->cseq, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, &subs);
422 mdev->devinfo = NULL;
424 snd_use_lock_free(&mdev->use_lock);
429 * change seq capability flags to file mode flags
432 snd_seq_oss_midi_filemode(seq_oss_devinfo_t *dp, int dev)
434 seq_oss_midi_t *mdev;
437 if ((mdev = get_mididev(dp, dev)) == NULL)
441 if (mdev->opened & PERM_WRITE)
442 mode |= SNDRV_SEQ_OSS_FILE_WRITE;
443 if (mdev->opened & PERM_READ)
444 mode |= SNDRV_SEQ_OSS_FILE_READ;
446 snd_use_lock_free(&mdev->use_lock);
451 * reset the midi device and close it:
452 * so far, only close the device.
455 snd_seq_oss_midi_reset(seq_oss_devinfo_t *dp, int dev)
457 seq_oss_midi_t *mdev;
459 if ((mdev = get_mididev(dp, dev)) == NULL)
461 if (! mdev->opened) {
462 snd_use_lock_free(&mdev->use_lock);
466 if (mdev->opened & PERM_WRITE) {
470 debug_printk(("resetting client %d port %d\n", mdev->client, mdev->port));
471 memset(&ev, 0, sizeof(ev));
472 ev.dest.client = mdev->client;
473 ev.dest.port = mdev->port;
474 ev.queue = dp->queue;
475 ev.source.port = dp->port;
476 if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_SYNTH) {
477 ev.type = SNDRV_SEQ_EVENT_SENSING;
478 snd_seq_oss_dispatch(dp, &ev, 0, 0); /* active sensing */
480 for (c = 0; c < 16; c++) {
481 ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
482 ev.data.control.channel = c;
483 ev.data.control.param = 123;
484 snd_seq_oss_dispatch(dp, &ev, 0, 0); /* all notes off */
485 if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC) {
486 ev.data.control.param = 121;
487 snd_seq_oss_dispatch(dp, &ev, 0, 0); /* reset all controllers */
488 ev.type = SNDRV_SEQ_EVENT_PITCHBEND;
489 ev.data.control.value = 0;
490 snd_seq_oss_dispatch(dp, &ev, 0, 0); /* bender off */
494 // snd_seq_oss_midi_close(dp, dev);
495 snd_use_lock_free(&mdev->use_lock);
500 * get client/port of the specified MIDI device
503 snd_seq_oss_midi_get_addr(seq_oss_devinfo_t *dp, int dev, snd_seq_addr_t *addr)
505 seq_oss_midi_t *mdev;
507 if ((mdev = get_mididev(dp, dev)) == NULL)
509 addr->client = mdev->client;
510 addr->port = mdev->port;
511 snd_use_lock_free(&mdev->use_lock);
516 * input callback - this can be atomic
519 snd_seq_oss_midi_input(snd_seq_event_t *ev, int direct, void *private_data)
521 seq_oss_devinfo_t *dp = (seq_oss_devinfo_t *)private_data;
522 seq_oss_midi_t *mdev;
525 if (dp->readq == NULL)
527 if ((mdev = find_slot(ev->source.client, ev->source.port)) == NULL)
529 if (! (mdev->opened & PERM_READ)) {
530 snd_use_lock_free(&mdev->use_lock);
534 if (dp->seq_mode == SNDRV_SEQ_OSS_MODE_MUSIC)
535 rc = send_synth_event(dp, ev, mdev->seq_device);
537 rc = send_midi_event(dp, ev, mdev);
539 snd_use_lock_free(&mdev->use_lock);
544 * convert ALSA sequencer event to OSS synth event
547 send_synth_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, int dev)
551 memset(&ossev, 0, sizeof(ossev));
554 case SNDRV_SEQ_EVENT_NOTEON:
555 ossev.v.cmd = MIDI_NOTEON; break;
556 case SNDRV_SEQ_EVENT_NOTEOFF:
557 ossev.v.cmd = MIDI_NOTEOFF; break;
558 case SNDRV_SEQ_EVENT_KEYPRESS:
559 ossev.v.cmd = MIDI_KEY_PRESSURE; break;
560 case SNDRV_SEQ_EVENT_CONTROLLER:
561 ossev.l.cmd = MIDI_CTL_CHANGE; break;
562 case SNDRV_SEQ_EVENT_PGMCHANGE:
563 ossev.l.cmd = MIDI_PGM_CHANGE; break;
564 case SNDRV_SEQ_EVENT_CHANPRESS:
565 ossev.l.cmd = MIDI_CHN_PRESSURE; break;
566 case SNDRV_SEQ_EVENT_PITCHBEND:
567 ossev.l.cmd = MIDI_PITCH_BEND; break;
569 return 0; /* not supported */
575 case SNDRV_SEQ_EVENT_NOTEON:
576 case SNDRV_SEQ_EVENT_NOTEOFF:
577 case SNDRV_SEQ_EVENT_KEYPRESS:
578 ossev.v.code = EV_CHN_VOICE;
579 ossev.v.note = ev->data.note.note;
580 ossev.v.parm = ev->data.note.velocity;
581 ossev.v.chn = ev->data.note.channel;
583 case SNDRV_SEQ_EVENT_CONTROLLER:
584 case SNDRV_SEQ_EVENT_PGMCHANGE:
585 case SNDRV_SEQ_EVENT_CHANPRESS:
586 ossev.l.code = EV_CHN_COMMON;
587 ossev.l.p1 = ev->data.control.param;
588 ossev.l.val = ev->data.control.value;
589 ossev.l.chn = ev->data.control.channel;
591 case SNDRV_SEQ_EVENT_PITCHBEND:
592 ossev.l.code = EV_CHN_COMMON;
593 ossev.l.val = ev->data.control.value + 8192;
594 ossev.l.chn = ev->data.control.channel;
598 snd_seq_oss_readq_put_timestamp(dp->readq, ev->time.tick, dp->seq_mode);
599 snd_seq_oss_readq_put_event(dp->readq, &ossev);
605 * decode event and send MIDI bytes to read queue
608 send_midi_event(seq_oss_devinfo_t *dp, snd_seq_event_t *ev, seq_oss_midi_t *mdev)
613 snd_seq_oss_readq_put_timestamp(dp->readq, ev->time.tick, dp->seq_mode);
614 if (!dp->timer->running)
615 len = snd_seq_oss_timer_start(dp->timer);
616 if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {
617 if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) == SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
618 snd_seq_oss_readq_puts(dp->readq, mdev->seq_device,
619 ev->data.ext.ptr, ev->data.ext.len);
621 len = snd_midi_event_decode(mdev->coder, msg, sizeof(msg), ev);
623 snd_seq_oss_readq_puts(dp->readq, mdev->seq_device, msg, len);
632 * return 0 : enqueued
633 * non-zero : invalid - ignored
636 snd_seq_oss_midi_putc(seq_oss_devinfo_t *dp, int dev, unsigned char c, snd_seq_event_t *ev)
638 seq_oss_midi_t *mdev;
640 if ((mdev = get_mididev(dp, dev)) == NULL)
642 if (snd_midi_event_encode_byte(mdev->coder, c, ev) > 0) {
643 snd_seq_oss_fill_addr(dp, ev, mdev->client, mdev->port);
644 snd_use_lock_free(&mdev->use_lock);
647 snd_use_lock_free(&mdev->use_lock);
652 * create OSS compatible midi_info record
655 snd_seq_oss_midi_make_info(seq_oss_devinfo_t *dp, int dev, struct midi_info *inf)
657 seq_oss_midi_t *mdev;
659 if ((mdev = get_mididev(dp, dev)) == NULL)
662 inf->dev_type = 0; /* FIXME: ?? */
663 inf->capabilities = 0; /* FIXME: ?? */
664 strlcpy(inf->name, mdev->name, sizeof(inf->name));
665 snd_use_lock_free(&mdev->use_lock);
676 val &= PERM_READ|PERM_WRITE;
677 if (val == (PERM_READ|PERM_WRITE))
679 else if (val == PERM_READ)
681 else if (val == PERM_WRITE)
688 snd_seq_oss_midi_info_read(snd_info_buffer_t *buf)
691 seq_oss_midi_t *mdev;
693 snd_iprintf(buf, "\nNumber of MIDI devices: %d\n", max_midi_devs);
694 for (i = 0; i < max_midi_devs; i++) {
695 snd_iprintf(buf, "\nmidi %d: ", i);
698 snd_iprintf(buf, "*empty*\n");
701 snd_iprintf(buf, "[%s] ALSA port %d:%d\n", mdev->name,
702 mdev->client, mdev->port);
703 snd_iprintf(buf, " capability %s / opened %s\n",
704 capmode_str(mdev->flags),
705 capmode_str(mdev->opened));
706 snd_use_lock_free(&mdev->use_lock);