1/*
2 * OSS compatible sequencer driver
3 *
4 * synth device handlers
5 *
6 * Copyright (C) 1998,99 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_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>
29
30/*
31 * constants
32 */
33#define SNDRV_SEQ_OSS_MAX_SYNTH_NAME	30
34#define MAX_SYSEX_BUFLEN		128
35
36
37/*
38 * definition of synth info records
39 */
40
41/* sysex buffer */
42struct seq_oss_synth_sysex {
43	int len;
44	int skip;
45	unsigned char buf[MAX_SYSEX_BUFLEN];
46};
47
48/* synth info */
49struct seq_oss_synth {
50	int seq_device;
51
52	/* for synth_info */
53	int synth_type;
54	int synth_subtype;
55	int nr_voices;
56
57	char name[SNDRV_SEQ_OSS_MAX_SYNTH_NAME];
58	struct snd_seq_oss_callback oper;
59
60	int opened;
61
62	void *private_data;
63	snd_use_lock_t use_lock;
64};
65
66
67/*
68 * device table
69 */
70static int max_synth_devs;
71static struct seq_oss_synth *synth_devs[SNDRV_SEQ_OSS_MAX_SYNTH_DEVS];
72static struct seq_oss_synth midi_synth_dev = {
73	-1, /* seq_device */
74	SYNTH_TYPE_MIDI, /* synth_type */
75	0, /* synth_subtype */
76	16, /* nr_voices */
77	"MIDI", /* name */
78};
79
80static DEFINE_SPINLOCK(register_lock);
81
82/*
83 * prototypes
84 */
85static struct seq_oss_synth *get_synthdev(struct seq_oss_devinfo *dp, int dev);
86static void reset_channels(struct seq_oss_synthinfo *info);
87
88/*
89 * global initialization
90 */
91void __init
92snd_seq_oss_synth_init(void)
93{
94	snd_use_lock_init(&midi_synth_dev.use_lock);
95}
96
97/*
98 * registration of the synth device
99 */
100int
101snd_seq_oss_synth_probe(struct device *_dev)
102{
103	struct snd_seq_device *dev = to_seq_dev(_dev);
104	int i;
105	struct seq_oss_synth *rec;
106	struct snd_seq_oss_reg *reg = SNDRV_SEQ_DEVICE_ARGPTR(dev);
107	unsigned long flags;
108
109	rec = kzalloc(sizeof(*rec), GFP_KERNEL);
110	if (!rec)
111		return -ENOMEM;
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;
118	rec->opened = 0;
119	snd_use_lock_init(&rec->use_lock);
120
121	/* copy and truncate the name of synth device */
122	strlcpy(rec->name, dev->name, sizeof(rec->name));
123
124	/* registration */
125	spin_lock_irqsave(&register_lock, flags);
126	for (i = 0; i < max_synth_devs; i++) {
127		if (synth_devs[i] == NULL)
128			break;
129	}
130	if (i >= max_synth_devs) {
131		if (max_synth_devs >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS) {
132			spin_unlock_irqrestore(&register_lock, flags);
133			pr_err("ALSA: seq_oss: no more synth slot\n");
134			kfree(rec);
135			return -ENOMEM;
136		}
137		max_synth_devs++;
138	}
139	rec->seq_device = i;
140	synth_devs[i] = rec;
141	spin_unlock_irqrestore(&register_lock, flags);
142	dev->driver_data = rec;
143#ifdef SNDRV_OSS_INFO_DEV_SYNTH
144	if (i < SNDRV_CARDS)
145		snd_oss_info_register(SNDRV_OSS_INFO_DEV_SYNTH, i, rec->name);
146#endif
147	return 0;
148}
149
150
151int
152snd_seq_oss_synth_remove(struct device *_dev)
153{
154	struct snd_seq_device *dev = to_seq_dev(_dev);
155	int index;
156	struct seq_oss_synth *rec = dev->driver_data;
157	unsigned long flags;
158
159	spin_lock_irqsave(&register_lock, flags);
160	for (index = 0; index < max_synth_devs; index++) {
161		if (synth_devs[index] == rec)
162			break;
163	}
164	if (index >= max_synth_devs) {
165		spin_unlock_irqrestore(&register_lock, flags);
166		pr_err("ALSA: seq_oss: can't unregister synth\n");
167		return -EINVAL;
168	}
169	synth_devs[index] = NULL;
170	if (index == max_synth_devs - 1) {
171		for (index--; index >= 0; index--) {
172			if (synth_devs[index])
173				break;
174		}
175		max_synth_devs = index + 1;
176	}
177	spin_unlock_irqrestore(&register_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);
181#endif
182
183	snd_use_lock_sync(&rec->use_lock);
184	kfree(rec);
185
186	return 0;
187}
188
189
190/*
191 */
192static struct seq_oss_synth *
193get_sdev(int dev)
194{
195	struct seq_oss_synth *rec;
196	unsigned long flags;
197
198	spin_lock_irqsave(&register_lock, flags);
199	rec = synth_devs[dev];
200	if (rec)
201		snd_use_lock_use(&rec->use_lock);
202	spin_unlock_irqrestore(&register_lock, flags);
203	return rec;
204}
205
206
207/*
208 * set up synth tables
209 */
210
211void
212snd_seq_oss_synth_setup(struct seq_oss_devinfo *dp)
213{
214	int i;
215	struct seq_oss_synth *rec;
216	struct seq_oss_synthinfo *info;
217
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++) {
222		rec = get_sdev(i);
223		if (rec == NULL)
224			continue;
225		if (rec->oper.open == NULL || rec->oper.close == NULL) {
226			snd_use_lock_free(&rec->use_lock);
227			continue;
228		}
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;
235		else
236			info->arg.event_passing = SNDRV_SEQ_OSS_PASS_EVENTS;
237		info->opened = 0;
238		if (!try_module_get(rec->oper.owner)) {
239			snd_use_lock_free(&rec->use_lock);
240			continue;
241		}
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);
245			continue;
246		}
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);
250			if (!info->ch) {
251				rec->oper.close(&info->arg);
252				module_put(rec->oper.owner);
253				snd_use_lock_free(&rec->use_lock);
254				continue;
255			}
256			reset_channels(info);
257		}
258		info->opened++;
259		rec->opened++;
260		dp->synth_opened++;
261		snd_use_lock_free(&rec->use_lock);
262	}
263}
264
265
266/*
267 * set up synth tables for MIDI emulation - /dev/music mode only
268 */
269
270void
271snd_seq_oss_synth_setup_midi(struct seq_oss_devinfo *dp)
272{
273	int i;
274
275	if (dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS)
276		return;
277
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)
282			continue;
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;
287		info->is_midi = 1;
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);
291		info->opened = 1;
292		midi_synth_dev.opened++;
293		dp->max_synthdev++;
294		if (dp->max_synthdev >= SNDRV_SEQ_OSS_MAX_SYNTH_DEVS)
295			break;
296	}
297}
298
299
300/*
301 * clean up synth tables
302 */
303
304void
305snd_seq_oss_synth_cleanup(struct seq_oss_devinfo *dp)
306{
307	int i;
308	struct seq_oss_synth *rec;
309	struct seq_oss_synthinfo *info;
310
311	if (snd_BUG_ON(dp->max_synthdev > SNDRV_SEQ_OSS_MAX_SYNTH_DEVS))
312		return;
313	for (i = 0; i < dp->max_synthdev; i++) {
314		info = &dp->synths[i];
315		if (! info->opened)
316			continue;
317		if (info->is_midi) {
318			if (midi_synth_dev.opened > 0) {
319				snd_seq_oss_midi_close(dp, info->midi_mapped);
320				midi_synth_dev.opened--;
321			}
322		} else {
323			rec = get_sdev(i);
324			if (rec == NULL)
325				continue;
326			if (rec->opened > 0) {
327				rec->oper.close(&info->arg);
328				module_put(rec->oper.owner);
329				rec->opened = 0;
330			}
331			snd_use_lock_free(&rec->use_lock);
332		}
333		kfree(info->sysex);
334		info->sysex = NULL;
335		kfree(info->ch);
336		info->ch = NULL;
337	}
338	dp->synth_opened = 0;
339	dp->max_synthdev = 0;
340}
341
342/*
343 * check if the specified device is MIDI mapped device
344 */
345static int
346is_midi_dev(struct seq_oss_devinfo *dp, int dev)
347{
348	if (dev < 0 || dev >= dp->max_synthdev)
349		return 0;
350	if (dp->synths[dev].is_midi)
351		return 1;
352	return 0;
353}
354
355/*
356 * return synth device information pointer
357 */
358static struct seq_oss_synth *
359get_synthdev(struct seq_oss_devinfo *dp, int dev)
360{
361	struct seq_oss_synth *rec;
362	if (dev < 0 || dev >= dp->max_synthdev)
363		return NULL;
364	if (! dp->synths[dev].opened)
365		return NULL;
366	if (dp->synths[dev].is_midi)
367		return &midi_synth_dev;
368	if ((rec = get_sdev(dev)) == NULL)
369		return NULL;
370	if (! rec->opened) {
371		snd_use_lock_free(&rec->use_lock);
372		return NULL;
373	}
374	return rec;
375}
376
377
378/*
379 * reset note and velocity on each channel.
380 */
381static void
382reset_channels(struct seq_oss_synthinfo *info)
383{
384	int i;
385	if (info->ch == NULL || ! info->nr_voices)
386		return;
387	for (i = 0; i < info->nr_voices; i++) {
388		info->ch[i].note = -1;
389		info->ch[i].vel = 0;
390	}
391}
392
393
394/*
395 * reset synth device:
396 * call reset callback.  if no callback is defined, send a heartbeat
397 * event to the corresponding port.
398 */
399void
400snd_seq_oss_synth_reset(struct seq_oss_devinfo *dp, int dev)
401{
402	struct seq_oss_synth *rec;
403	struct seq_oss_synthinfo *info;
404
405	if (snd_BUG_ON(dev < 0 || dev >= dp->max_synthdev))
406		return;
407	info = &dp->synths[dev];
408	if (! info->opened)
409		return;
410	if (info->sysex)
411		info->sysex->len = 0; /* reset sysex */
412	reset_channels(info);
413	if (info->is_midi) {
414		if (midi_synth_dev.opened <= 0)
415			return;
416		snd_seq_oss_midi_reset(dp, info->midi_mapped);
417		/* reopen the device */
418		snd_seq_oss_midi_close(dp, dev);
419		if (snd_seq_oss_midi_open(dp, info->midi_mapped,
420					  dp->file_mode) < 0) {
421			midi_synth_dev.opened--;
422			info->opened = 0;
423			kfree(info->sysex);
424			info->sysex = NULL;
425			kfree(info->ch);
426			info->ch = NULL;
427		}
428		return;
429	}
430
431	rec = get_sdev(dev);
432	if (rec == NULL)
433		return;
434	if (rec->oper.reset) {
435		rec->oper.reset(&info->arg);
436	} else {
437		struct snd_seq_event ev;
438		memset(&ev, 0, sizeof(ev));
439		snd_seq_oss_fill_addr(dp, &ev, info->arg.addr.client,
440				      info->arg.addr.port);
441		ev.type = SNDRV_SEQ_EVENT_RESET;
442		snd_seq_oss_dispatch(dp, &ev, 0, 0);
443	}
444	snd_use_lock_free(&rec->use_lock);
445}
446
447
448/*
449 * load a patch record:
450 * call load_patch callback function
451 */
452int
453snd_seq_oss_synth_load_patch(struct seq_oss_devinfo *dp, int dev, int fmt,
454			    const char __user *buf, int p, int c)
455{
456	struct seq_oss_synth *rec;
457	int rc;
458
459	if (dev < 0 || dev >= dp->max_synthdev)
460		return -ENXIO;
461
462	if (is_midi_dev(dp, dev))
463		return 0;
464	if ((rec = get_synthdev(dp, dev)) == NULL)
465		return -ENXIO;
466
467	if (rec->oper.load_patch == NULL)
468		rc = -ENXIO;
469	else
470		rc = rec->oper.load_patch(&dp->synths[dev].arg, fmt, buf, p, c);
471	snd_use_lock_free(&rec->use_lock);
472	return rc;
473}
474
475/*
476 * check if the device is valid synth device
477 */
478int
479snd_seq_oss_synth_is_valid(struct seq_oss_devinfo *dp, int dev)
480{
481	struct seq_oss_synth *rec;
482	rec = get_synthdev(dp, dev);
483	if (rec) {
484		snd_use_lock_free(&rec->use_lock);
485		return 1;
486	}
487	return 0;
488}
489
490
491/*
492 * receive OSS 6 byte sysex packet:
493 * the full sysex message will be sent if it reaches to the end of data
494 * (0xff).
495 */
496int
497snd_seq_oss_synth_sysex(struct seq_oss_devinfo *dp, int dev, unsigned char *buf, struct snd_seq_event *ev)
498{
499	int i, send;
500	unsigned char *dest;
501	struct seq_oss_synth_sysex *sysex;
502
503	if (! snd_seq_oss_synth_is_valid(dp, dev))
504		return -ENXIO;
505
506	sysex = dp->synths[dev].sysex;
507	if (sysex == NULL) {
508		sysex = kzalloc(sizeof(*sysex), GFP_KERNEL);
509		if (sysex == NULL)
510			return -ENOMEM;
511		dp->synths[dev].sysex = sysex;
512	}
513
514	send = 0;
515	dest = sysex->buf + sysex->len;
516	/* copy 6 byte packet to the buffer */
517	for (i = 0; i < 6; i++) {
518		if (buf[i] == 0xff) {
519			send = 1;
520			break;
521		}
522		dest[i] = buf[i];
523		sysex->len++;
524		if (sysex->len >= MAX_SYSEX_BUFLEN) {
525			sysex->len = 0;
526			sysex->skip = 1;
527			break;
528		}
529	}
530
531	if (sysex->len && send) {
532		if (sysex->skip) {
533			sysex->skip = 0;
534			sysex->len = 0;
535			return -EINVAL; /* skip */
536		}
537		/* copy the data to event record and send it */
538		ev->flags = SNDRV_SEQ_EVENT_LENGTH_VARIABLE;
539		if (snd_seq_oss_synth_addr(dp, dev, ev))
540			return -EINVAL;
541		ev->data.ext.len = sysex->len;
542		ev->data.ext.ptr = sysex->buf;
543		sysex->len = 0;
544		return 0;
545	}
546
547	return -EINVAL; /* skip */
548}
549
550/*
551 * fill the event source/destination addresses
552 */
553int
554snd_seq_oss_synth_addr(struct seq_oss_devinfo *dp, int dev, struct snd_seq_event *ev)
555{
556	if (! snd_seq_oss_synth_is_valid(dp, dev))
557		return -EINVAL;
558	snd_seq_oss_fill_addr(dp, ev, dp->synths[dev].arg.addr.client,
559			      dp->synths[dev].arg.addr.port);
560	return 0;
561}
562
563
564/*
565 * OSS compatible ioctl
566 */
567int
568snd_seq_oss_synth_ioctl(struct seq_oss_devinfo *dp, int dev, unsigned int cmd, unsigned long addr)
569{
570	struct seq_oss_synth *rec;
571	int rc;
572
573	if (is_midi_dev(dp, dev))
574		return -ENXIO;
575	if ((rec = get_synthdev(dp, dev)) == NULL)
576		return -ENXIO;
577	if (rec->oper.ioctl == NULL)
578		rc = -ENXIO;
579	else
580		rc = rec->oper.ioctl(&dp->synths[dev].arg, cmd, addr);
581	snd_use_lock_free(&rec->use_lock);
582	return rc;
583}
584
585
586/*
587 * send OSS raw events - SEQ_PRIVATE and SEQ_VOLUME
588 */
589int
590snd_seq_oss_synth_raw_event(struct seq_oss_devinfo *dp, int dev, unsigned char *data, struct snd_seq_event *ev)
591{
592	if (! snd_seq_oss_synth_is_valid(dp, dev) || is_midi_dev(dp, dev))
593		return -ENXIO;
594	ev->type = SNDRV_SEQ_EVENT_OSS;
595	memcpy(ev->data.raw8.d, data, 8);
596	return snd_seq_oss_synth_addr(dp, dev, ev);
597}
598
599
600/*
601 * create OSS compatible synth_info record
602 */
603int
604snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_info *inf)
605{
606	struct seq_oss_synth *rec;
607
608	if (dev < 0 || dev >= dp->max_synthdev)
609		return -ENXIO;
610
611	if (dp->synths[dev].is_midi) {
612		struct midi_info minf;
613		snd_seq_oss_midi_make_info(dp, dp->synths[dev].midi_mapped, &minf);
614		inf->synth_type = SYNTH_TYPE_MIDI;
615		inf->synth_subtype = 0;
616		inf->nr_voices = 16;
617		inf->device = dev;
618		strlcpy(inf->name, minf.name, sizeof(inf->name));
619	} else {
620		if ((rec = get_synthdev(dp, dev)) == NULL)
621			return -ENXIO;
622		inf->synth_type = rec->synth_type;
623		inf->synth_subtype = rec->synth_subtype;
624		inf->nr_voices = rec->nr_voices;
625		inf->device = dev;
626		strlcpy(inf->name, rec->name, sizeof(inf->name));
627		snd_use_lock_free(&rec->use_lock);
628	}
629	return 0;
630}
631
632
633#ifdef CONFIG_PROC_FS
634/*
635 * proc interface
636 */
637void
638snd_seq_oss_synth_info_read(struct snd_info_buffer *buf)
639{
640	int i;
641	struct seq_oss_synth *rec;
642
643	snd_iprintf(buf, "\nNumber of synth devices: %d\n", max_synth_devs);
644	for (i = 0; i < max_synth_devs; i++) {
645		snd_iprintf(buf, "\nsynth %d: ", i);
646		rec = get_sdev(i);
647		if (rec == NULL) {
648			snd_iprintf(buf, "*empty*\n");
649			continue;
650		}
651		snd_iprintf(buf, "[%s]\n", rec->name);
652		snd_iprintf(buf, "  type 0x%x : subtype 0x%x : voices %d\n",
653			    rec->synth_type, rec->synth_subtype,
654			    rec->nr_voices);
655		snd_iprintf(buf, "  capabilities : ioctl %s / load_patch %s\n",
656			    enabled_str((long)rec->oper.ioctl),
657			    enabled_str((long)rec->oper.load_patch));
658		snd_use_lock_free(&rec->use_lock);
659	}
660}
661#endif /* CONFIG_PROC_FS */
662