2 * OSS compatible sequencer driver
4 * synth device handlers
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_synth.h"
24 #include "seq_oss_midi.h"
25 #include "../seq_lock.h"
26 #include <linux/init.h>
27 #include <linux/module.h>
28 #include <linux/slab.h>
33 #define SNDRV_SEQ_OSS_MAX_SYNTH_NAME 30
34 #define MAX_SYSEX_BUFLEN 128
38 * definition of synth info records
42 struct seq_oss_synth_sysex
{
45 unsigned char buf
[MAX_SYSEX_BUFLEN
];
49 struct seq_oss_synth
{
57 char name
[SNDRV_SEQ_OSS_MAX_SYNTH_NAME
];
58 struct snd_seq_oss_callback oper
;
63 snd_use_lock_t use_lock
;
70 static int max_synth_devs
;
71 static struct seq_oss_synth
*synth_devs
[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS
];
72 static struct seq_oss_synth midi_synth_dev
= {
74 .synth_type
= SYNTH_TYPE_MIDI
,
80 static DEFINE_SPINLOCK(register_lock
);
85 static struct seq_oss_synth
*get_synthdev(struct seq_oss_devinfo
*dp
, int dev
);
86 static void reset_channels(struct seq_oss_synthinfo
*info
);
89 * global initialization
92 snd_seq_oss_synth_init(void)
94 snd_use_lock_init(&midi_synth_dev
.use_lock
);
98 * registration of the synth device
101 snd_seq_oss_synth_probe(struct device
*_dev
)
103 struct snd_seq_device
*dev
= to_seq_dev(_dev
);
105 struct seq_oss_synth
*rec
;
106 struct snd_seq_oss_reg
*reg
= SNDRV_SEQ_DEVICE_ARGPTR(dev
);
109 rec
= kzalloc(sizeof(*rec
), GFP_KERNEL
);
112 rec
->seq_device
= -1;
113 rec
->synth_type
= reg
->type
;
114 rec
->synth_subtype
= reg
->subtype
;
115 rec
->nr_voices
= reg
->nvoices
;
116 rec
->oper
= reg
->oper
;
117 rec
->private_data
= reg
->private_data
;
119 snd_use_lock_init(&rec
->use_lock
);
121 /* copy and truncate the name of synth device */
122 strlcpy(rec
->name
, dev
->name
, sizeof(rec
->name
));
125 spin_lock_irqsave(®ister_lock
, flags
);
126 for (i
= 0; i
< max_synth_devs
; i
++) {
127 if (synth_devs
[i
] == NULL
)
130 if (i
>= max_synth_devs
) {
131 if (max_synth_devs
>= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS
) {
132 spin_unlock_irqrestore(®ister_lock
, flags
);
133 pr_err("ALSA: seq_oss: no more synth slot\n");
141 spin_unlock_irqrestore(®ister_lock
, flags
);
142 dev
->driver_data
= rec
;
143 #ifdef SNDRV_OSS_INFO_DEV_SYNTH
145 snd_oss_info_register(SNDRV_OSS_INFO_DEV_SYNTH
, i
, rec
->name
);
152 snd_seq_oss_synth_remove(struct device
*_dev
)
154 struct snd_seq_device
*dev
= to_seq_dev(_dev
);
156 struct seq_oss_synth
*rec
= dev
->driver_data
;
159 spin_lock_irqsave(®ister_lock
, flags
);
160 for (index
= 0; index
< max_synth_devs
; index
++) {
161 if (synth_devs
[index
] == rec
)
164 if (index
>= max_synth_devs
) {
165 spin_unlock_irqrestore(®ister_lock
, flags
);
166 pr_err("ALSA: seq_oss: can't unregister synth\n");
169 synth_devs
[index
] = NULL
;
170 if (index
== max_synth_devs
- 1) {
171 for (index
--; index
>= 0; index
--) {
172 if (synth_devs
[index
])
175 max_synth_devs
= index
+ 1;
177 spin_unlock_irqrestore(®ister_lock
, flags
);
178 #ifdef SNDRV_OSS_INFO_DEV_SYNTH
179 if (rec
->seq_device
< SNDRV_CARDS
)
180 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_SYNTH
, rec
->seq_device
);
183 snd_use_lock_sync(&rec
->use_lock
);
192 static struct seq_oss_synth
*
195 struct seq_oss_synth
*rec
;
198 spin_lock_irqsave(®ister_lock
, flags
);
199 rec
= synth_devs
[dev
];
201 snd_use_lock_use(&rec
->use_lock
);
202 spin_unlock_irqrestore(®ister_lock
, flags
);
208 * set up synth tables
212 snd_seq_oss_synth_setup(struct seq_oss_devinfo
*dp
)
215 struct seq_oss_synth
*rec
;
216 struct seq_oss_synthinfo
*info
;
218 dp
->max_synthdev
= max_synth_devs
;
219 dp
->synth_opened
= 0;
220 memset(dp
->synths
, 0, sizeof(dp
->synths
));
221 for (i
= 0; i
< dp
->max_synthdev
; i
++) {
225 if (rec
->oper
.open
== NULL
|| rec
->oper
.close
== NULL
) {
226 snd_use_lock_free(&rec
->use_lock
);
229 info
= &dp
->synths
[i
];
230 info
->arg
.app_index
= dp
->port
;
231 info
->arg
.file_mode
= dp
->file_mode
;
232 info
->arg
.seq_mode
= dp
->seq_mode
;
233 if (dp
->seq_mode
== SNDRV_SEQ_OSS_MODE_SYNTH
)
234 info
->arg
.event_passing
= SNDRV_SEQ_OSS_PROCESS_EVENTS
;
236 info
->arg
.event_passing
= SNDRV_SEQ_OSS_PASS_EVENTS
;
238 if (!try_module_get(rec
->oper
.owner
)) {
239 snd_use_lock_free(&rec
->use_lock
);
242 if (rec
->oper
.open(&info
->arg
, rec
->private_data
) < 0) {
243 module_put(rec
->oper
.owner
);
244 snd_use_lock_free(&rec
->use_lock
);
247 info
->nr_voices
= rec
->nr_voices
;
248 if (info
->nr_voices
> 0) {
249 info
->ch
= kcalloc(info
->nr_voices
, sizeof(struct seq_oss_chinfo
), GFP_KERNEL
);
251 rec
->oper
.close(&info
->arg
);
252 module_put(rec
->oper
.owner
);
253 snd_use_lock_free(&rec
->use_lock
);
256 reset_channels(info
);
261 snd_use_lock_free(&rec
->use_lock
);
267 * set up synth tables for MIDI emulation - /dev/music mode only
271 snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo
*dp
)
275 if (dp
->max_synthdev
>= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS
)
278 for (i
= 0; i
< dp
->max_mididev
; i
++) {
279 struct seq_oss_synthinfo
*info
;
280 info
= &dp
->synths
[dp
->max_synthdev
];
281 if (snd_seq_oss_midi_open(dp
, i
, dp
->file_mode
) < 0)
283 info
->arg
.app_index
= dp
->port
;
284 info
->arg
.file_mode
= dp
->file_mode
;
285 info
->arg
.seq_mode
= dp
->seq_mode
;
286 info
->arg
.private_data
= info
;
288 info
->midi_mapped
= i
;
289 info
->arg
.event_passing
= SNDRV_SEQ_OSS_PASS_EVENTS
;
290 snd_seq_oss_midi_get_addr(dp
, i
, &info
->arg
.addr
);
292 midi_synth_dev
.opened
++;
294 if (dp
->max_synthdev
>= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS
)
301 * clean up synth tables
305 snd_seq_oss_synth_cleanup(struct seq_oss_devinfo
*dp
)
308 struct seq_oss_synth
*rec
;
309 struct seq_oss_synthinfo
*info
;
311 if (snd_BUG_ON(dp
->max_synthdev
> SNDRV_SEQ_OSS_MAX_SYNTH_DEVS
))
313 for (i
= 0; i
< dp
->max_synthdev
; i
++) {
314 info
= &dp
->synths
[i
];
318 if (midi_synth_dev
.opened
> 0) {
319 snd_seq_oss_midi_close(dp
, info
->midi_mapped
);
320 midi_synth_dev
.opened
--;
326 if (rec
->opened
> 0) {
327 rec
->oper
.close(&info
->arg
);
328 module_put(rec
->oper
.owner
);
331 snd_use_lock_free(&rec
->use_lock
);
338 dp
->synth_opened
= 0;
339 dp
->max_synthdev
= 0;
343 * check if the specified device is MIDI mapped device
346 is_midi_dev(struct seq_oss_devinfo
*dp
, int dev
)
348 if (dev
< 0 || dev
>= dp
->max_synthdev
)
350 if (dp
->synths
[dev
].is_midi
)
356 * return synth device information pointer
358 static struct seq_oss_synth
*
359 get_synthdev(struct seq_oss_devinfo
*dp
, int dev
)
361 struct seq_oss_synth
*rec
;
362 if (dev
< 0 || dev
>= dp
->max_synthdev
)
364 if (! dp
->synths
[dev
].opened
)
366 if (dp
->synths
[dev
].is_midi
) {
367 rec
= &midi_synth_dev
;
368 snd_use_lock_use(&rec
->use_lock
);
375 snd_use_lock_free(&rec
->use_lock
);
383 * reset note and velocity on each channel.
386 reset_channels(struct seq_oss_synthinfo
*info
)
389 if (info
->ch
== NULL
|| ! info
->nr_voices
)
391 for (i
= 0; i
< info
->nr_voices
; i
++) {
392 info
->ch
[i
].note
= -1;
399 * reset synth device:
400 * call reset callback. if no callback is defined, send a heartbeat
401 * event to the corresponding port.
404 snd_seq_oss_synth_reset(struct seq_oss_devinfo
*dp
, int dev
)
406 struct seq_oss_synth
*rec
;
407 struct seq_oss_synthinfo
*info
;
409 if (snd_BUG_ON(dev
< 0 || dev
>= dp
->max_synthdev
))
411 info
= &dp
->synths
[dev
];
415 info
->sysex
->len
= 0; /* reset sysex */
416 reset_channels(info
);
418 if (midi_synth_dev
.opened
<= 0)
420 snd_seq_oss_midi_reset(dp
, info
->midi_mapped
);
421 /* reopen the device */
422 snd_seq_oss_midi_close(dp
, dev
);
423 if (snd_seq_oss_midi_open(dp
, info
->midi_mapped
,
424 dp
->file_mode
) < 0) {
425 midi_synth_dev
.opened
--;
438 if (rec
->oper
.reset
) {
439 rec
->oper
.reset(&info
->arg
);
441 struct snd_seq_event ev
;
442 memset(&ev
, 0, sizeof(ev
));
443 snd_seq_oss_fill_addr(dp
, &ev
, info
->arg
.addr
.client
,
444 info
->arg
.addr
.port
);
445 ev
.type
= SNDRV_SEQ_EVENT_RESET
;
446 snd_seq_oss_dispatch(dp
, &ev
, 0, 0);
448 snd_use_lock_free(&rec
->use_lock
);
453 * load a patch record:
454 * call load_patch callback function
457 snd_seq_oss_synth_load_patch(struct seq_oss_devinfo
*dp
, int dev
, int fmt
,
458 const char __user
*buf
, int p
, int c
)
460 struct seq_oss_synth
*rec
;
463 if (dev
< 0 || dev
>= dp
->max_synthdev
)
466 if (is_midi_dev(dp
, dev
))
468 if ((rec
= get_synthdev(dp
, dev
)) == NULL
)
471 if (rec
->oper
.load_patch
== NULL
)
474 rc
= rec
->oper
.load_patch(&dp
->synths
[dev
].arg
, fmt
, buf
, p
, c
);
475 snd_use_lock_free(&rec
->use_lock
);
480 * check if the device is valid synth device
483 snd_seq_oss_synth_is_valid(struct seq_oss_devinfo
*dp
, int dev
)
485 struct seq_oss_synth
*rec
;
486 rec
= get_synthdev(dp
, dev
);
488 snd_use_lock_free(&rec
->use_lock
);
496 * receive OSS 6 byte sysex packet:
497 * the full sysex message will be sent if it reaches to the end of data
501 snd_seq_oss_synth_sysex(struct seq_oss_devinfo
*dp
, int dev
, unsigned char *buf
, struct snd_seq_event
*ev
)
505 struct seq_oss_synth_sysex
*sysex
;
507 if (! snd_seq_oss_synth_is_valid(dp
, dev
))
510 sysex
= dp
->synths
[dev
].sysex
;
512 sysex
= kzalloc(sizeof(*sysex
), GFP_KERNEL
);
515 dp
->synths
[dev
].sysex
= sysex
;
519 dest
= sysex
->buf
+ sysex
->len
;
520 /* copy 6 byte packet to the buffer */
521 for (i
= 0; i
< 6; i
++) {
522 if (buf
[i
] == 0xff) {
528 if (sysex
->len
>= MAX_SYSEX_BUFLEN
) {
535 if (sysex
->len
&& send
) {
539 return -EINVAL
; /* skip */
541 /* copy the data to event record and send it */
542 ev
->flags
= SNDRV_SEQ_EVENT_LENGTH_VARIABLE
;
543 if (snd_seq_oss_synth_addr(dp
, dev
, ev
))
545 ev
->data
.ext
.len
= sysex
->len
;
546 ev
->data
.ext
.ptr
= sysex
->buf
;
551 return -EINVAL
; /* skip */
555 * fill the event source/destination addresses
558 snd_seq_oss_synth_addr(struct seq_oss_devinfo
*dp
, int dev
, struct snd_seq_event
*ev
)
560 if (! snd_seq_oss_synth_is_valid(dp
, dev
))
562 snd_seq_oss_fill_addr(dp
, ev
, dp
->synths
[dev
].arg
.addr
.client
,
563 dp
->synths
[dev
].arg
.addr
.port
);
569 * OSS compatible ioctl
572 snd_seq_oss_synth_ioctl(struct seq_oss_devinfo
*dp
, int dev
, unsigned int cmd
, unsigned long addr
)
574 struct seq_oss_synth
*rec
;
577 if (is_midi_dev(dp
, dev
))
579 if ((rec
= get_synthdev(dp
, dev
)) == NULL
)
581 if (rec
->oper
.ioctl
== NULL
)
584 rc
= rec
->oper
.ioctl(&dp
->synths
[dev
].arg
, cmd
, addr
);
585 snd_use_lock_free(&rec
->use_lock
);
591 * send OSS raw events - SEQ_PRIVATE and SEQ_VOLUME
594 snd_seq_oss_synth_raw_event(struct seq_oss_devinfo
*dp
, int dev
, unsigned char *data
, struct snd_seq_event
*ev
)
596 if (! snd_seq_oss_synth_is_valid(dp
, dev
) || is_midi_dev(dp
, dev
))
598 ev
->type
= SNDRV_SEQ_EVENT_OSS
;
599 memcpy(ev
->data
.raw8
.d
, data
, 8);
600 return snd_seq_oss_synth_addr(dp
, dev
, ev
);
605 * create OSS compatible synth_info record
608 snd_seq_oss_synth_make_info(struct seq_oss_devinfo
*dp
, int dev
, struct synth_info
*inf
)
610 struct seq_oss_synth
*rec
;
612 if (dev
< 0 || dev
>= dp
->max_synthdev
)
615 if (dp
->synths
[dev
].is_midi
) {
616 struct midi_info minf
;
617 snd_seq_oss_midi_make_info(dp
, dp
->synths
[dev
].midi_mapped
, &minf
);
618 inf
->synth_type
= SYNTH_TYPE_MIDI
;
619 inf
->synth_subtype
= 0;
622 strlcpy(inf
->name
, minf
.name
, sizeof(inf
->name
));
624 if ((rec
= get_synthdev(dp
, dev
)) == NULL
)
626 inf
->synth_type
= rec
->synth_type
;
627 inf
->synth_subtype
= rec
->synth_subtype
;
628 inf
->nr_voices
= rec
->nr_voices
;
630 strlcpy(inf
->name
, rec
->name
, sizeof(inf
->name
));
631 snd_use_lock_free(&rec
->use_lock
);
637 #ifdef CONFIG_SND_PROC_FS
642 snd_seq_oss_synth_info_read(struct snd_info_buffer
*buf
)
645 struct seq_oss_synth
*rec
;
647 snd_iprintf(buf
, "\nNumber of synth devices: %d\n", max_synth_devs
);
648 for (i
= 0; i
< max_synth_devs
; i
++) {
649 snd_iprintf(buf
, "\nsynth %d: ", i
);
652 snd_iprintf(buf
, "*empty*\n");
655 snd_iprintf(buf
, "[%s]\n", rec
->name
);
656 snd_iprintf(buf
, " type 0x%x : subtype 0x%x : voices %d\n",
657 rec
->synth_type
, rec
->synth_subtype
,
659 snd_iprintf(buf
, " capabilities : ioctl %s / load_patch %s\n",
660 enabled_str((long)rec
->oper
.ioctl
),
661 enabled_str((long)rec
->oper
.load_patch
));
662 snd_use_lock_free(&rec
->use_lock
);
665 #endif /* CONFIG_SND_PROC_FS */