[linux.git] / sound / oss / v_midi.c

/*
 * sound/oss/v_midi.c
 *
 * The low level driver for the Sound Blaster DS chips.
 *
 *
 * Copyright (C) by Hannu Savolainen 1993-1996
 *
 * USS/Lite for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
 * Version 2 (June 1991). See the "COPYING" file distributed with this software
 * for more info.
 * ??
 *
 * Changes
 *	Alan Cox		Modularisation, changed memory allocations
 *	Christoph Hellwig	Adapted to module_init/module_exit
 *
 * Status
 *	Untested
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include "sound_config.h"

#include "v_midi.h"

static vmidi_devc *v_devc[2] = { NULL, NULL};
static int midi1,midi2;
static void *midi_mem = NULL;

/*
 * The DSP channel can be used either for input or output. Variable
 * 'sb_irq_mode' will be set when the program calls read or write first time
 * after open. Current version doesn't support mode changes without closing
 * and reopening the device. Support for this feature may be implemented in a
 * future version of this driver.
 */


static int v_midi_open (int dev, int mode,
	      void            (*input) (int dev, unsigned char data),
	      void            (*output) (int dev)
)
{
	vmidi_devc *devc = midi_devs[dev]->devc;
	unsigned long flags;

	if (devc == NULL)
		return -(ENXIO);

	spin_lock_irqsave(&devc->lock,flags);
	if (devc->opened)
	{
		spin_unlock_irqrestore(&devc->lock,flags);
		return -(EBUSY);
	}
	devc->opened = 1;
	spin_unlock_irqrestore(&devc->lock,flags);

	devc->intr_active = 1;

	if (mode & OPEN_READ)
	{
		devc->input_opened = 1;
		devc->midi_input_intr = input;
	}

	return 0;
}

static void v_midi_close (int dev)
{
	vmidi_devc *devc = midi_devs[dev]->devc;
	unsigned long flags;

	if (devc == NULL)
		return;

	spin_lock_irqsave(&devc->lock,flags);
	devc->intr_active = 0;
	devc->input_opened = 0;
	devc->opened = 0;
	spin_unlock_irqrestore(&devc->lock,flags);
}

static int v_midi_out (int dev, unsigned char midi_byte)
{
	vmidi_devc *devc = midi_devs[dev]->devc;
	vmidi_devc *pdevc;

	if (devc == NULL)
		return -ENXIO;

	pdevc = midi_devs[devc->pair_mididev]->devc;
	if (pdevc->input_opened > 0){
		if (MIDIbuf_avail(pdevc->my_mididev) > 500)
			return 0;
		pdevc->midi_input_intr (pdevc->my_mididev, midi_byte);
	}
	return 1;
}

static inline int v_midi_start_read (int dev)
{
	return 0;
}

static int v_midi_end_read (int dev)
{
	vmidi_devc *devc = midi_devs[dev]->devc;
	if (devc == NULL)
		return -ENXIO;

	devc->intr_active = 0;
	return 0;
}

/* why -EPERM and not -EINVAL?? */

static inline int v_midi_ioctl (int dev, unsigned cmd, void __user *arg)
{
	return -EPERM;
}


#define MIDI_SYNTH_NAME	"Loopback MIDI"
#define MIDI_SYNTH_CAPS	SYNTH_CAP_INPUT

#include "midi_synth.h"

static struct midi_operations v_midi_operations =
{
	.owner		= THIS_MODULE,
	.info		= {"Loopback MIDI Port 1", 0, 0, SNDCARD_VMIDI},
	.converter	= &std_midi_synth,
	.in_info	= {0},
	.open		= v_midi_open,
	.close		= v_midi_close,
	.ioctl		= v_midi_ioctl,
	.outputc	= v_midi_out,
	.start_read	= v_midi_start_read,
	.end_read	= v_midi_end_read,
};

static struct midi_operations v_midi_operations2 =
{
	.owner		= THIS_MODULE,
	.info		= {"Loopback MIDI Port 2", 0, 0, SNDCARD_VMIDI},
	.converter	= &std_midi_synth,
	.in_info	= {0},
	.open		= v_midi_open,
	.close		= v_midi_close,
	.ioctl		= v_midi_ioctl,
	.outputc	= v_midi_out,
	.start_read	= v_midi_start_read,
	.end_read	= v_midi_end_read,
};

/*
 *	We kmalloc just one of these - it makes life simpler and the code
 *	cleaner and the memory handling far more efficient
 */
 
struct vmidi_memory
{
	/* Must be first */
	struct midi_operations m_ops[2];
	struct synth_operations s_ops[2];
	struct vmidi_devc v_ops[2];
};

static void __init attach_v_midi (struct address_info *hw_config)
{
	struct vmidi_memory *m;
	/* printk("Attaching v_midi device.....\n"); */

	midi1 = sound_alloc_mididev();
	if (midi1 == -1)
	{
		printk(KERN_ERR "v_midi: Too many midi devices detected\n");
		return;
	}
	
	m = kmalloc(sizeof(struct vmidi_memory), GFP_KERNEL);
	if (m == NULL)
	{
		printk(KERN_WARNING "Loopback MIDI: Failed to allocate memory\n");
		sound_unload_mididev(midi1);
		return;
	}
	
	midi_mem = m;
	
	midi_devs[midi1] = &m->m_ops[0];
	

	midi2 = sound_alloc_mididev();
	if (midi2 == -1)
	{
		printk (KERN_ERR "v_midi: Too many midi devices detected\n");
		kfree(m);
		sound_unload_mididev(midi1);
		return;
	}

	midi_devs[midi2] = &m->m_ops[1];

	/* printk("VMIDI1: %d   VMIDI2: %d\n",midi1,midi2); */

	/* for MIDI-1 */
	v_devc[0] = &m->v_ops[0];
	memcpy ((char *) midi_devs[midi1], (char *) &v_midi_operations,
		sizeof (struct midi_operations));

	v_devc[0]->my_mididev = midi1;
	v_devc[0]->pair_mididev = midi2;
	v_devc[0]->opened = v_devc[0]->input_opened = 0;
	v_devc[0]->intr_active = 0;
	v_devc[0]->midi_input_intr = NULL;
	spin_lock_init(&v_devc[0]->lock);

	midi_devs[midi1]->devc = v_devc[0];

	midi_devs[midi1]->converter = &m->s_ops[0];
	std_midi_synth.midi_dev = midi1;
	memcpy ((char *) midi_devs[midi1]->converter, (char *) &std_midi_synth,
		sizeof (struct synth_operations));
	midi_devs[midi1]->converter->id = "V_MIDI 1";

	/* for MIDI-2 */
	v_devc[1] = &m->v_ops[1];

	memcpy ((char *) midi_devs[midi2], (char *) &v_midi_operations2,
		sizeof (struct midi_operations));

	v_devc[1]->my_mididev = midi2;
	v_devc[1]->pair_mididev = midi1;
	v_devc[1]->opened = v_devc[1]->input_opened = 0;
	v_devc[1]->intr_active = 0;
	v_devc[1]->midi_input_intr = NULL;
	spin_lock_init(&v_devc[1]->lock);

	midi_devs[midi2]->devc = v_devc[1];
	midi_devs[midi2]->converter = &m->s_ops[1];

	std_midi_synth.midi_dev = midi2;
	memcpy ((char *) midi_devs[midi2]->converter, (char *) &std_midi_synth,
		sizeof (struct synth_operations));
	midi_devs[midi2]->converter->id = "V_MIDI 2";

	sequencer_init();
	/* printk("Attached v_midi device\n"); */
}

static inline int __init probe_v_midi(struct address_info *hw_config)
{
	return(1);	/* always OK */
}


static void __exit unload_v_midi(struct address_info *hw_config)
{
	sound_unload_mididev(midi1);
	sound_unload_mididev(midi2);
	kfree(midi_mem);
}

static struct address_info cfg; /* dummy */

static int __init init_vmidi(void)
{
	printk("MIDI Loopback device driver\n");
	if (!probe_v_midi(&cfg))
		return -ENODEV;
	attach_v_midi(&cfg);

	return 0;
}

static void __exit cleanup_vmidi(void)
{
	unload_v_midi(&cfg);
}

module_init(init_vmidi);
module_exit(cleanup_vmidi);
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4	1	/*
f30c2269	2	* sound/oss/v_midi.c
1da177e4 LT	3	*
	4	* The low level driver for the Sound Blaster DS chips.
	5	*
	6	*
	7	* Copyright (C) by Hannu Savolainen 1993-1996
	8	*
	9	* USS/Lite for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
	10	* Version 2 (June 1991). See the "COPYING" file distributed with this software
	11	* for more info.
	12	* ??
	13	*
	14	* Changes
	15	* Alan Cox Modularisation, changed memory allocations
	16	* Christoph Hellwig Adapted to module_init/module_exit
	17	*
	18	* Status
	19	* Untested
	20	*/
	21
	22	#include <linux/init.h>
	23	#include <linux/module.h>
5a0e3ad6	24	#include <linux/slab.h>
1da177e4 LT	25	#include <linux/spinlock.h>
	26	#include "sound_config.h"
	27
	28	#include "v_midi.h"
	29
	30	static vmidi_devc *v_devc[2] = { NULL, NULL};
	31	static int midi1,midi2;
	32	static void *midi_mem = NULL;
	33
	34	/*
	35	* The DSP channel can be used either for input or output. Variable
	36	* 'sb_irq_mode' will be set when the program calls read or write first time
	37	* after open. Current version doesn't support mode changes without closing
	38	* and reopening the device. Support for this feature may be implemented in a
	39	* future version of this driver.
	40	*/
	41
	42
1da177e4 LT	43	static int v_midi_open (int dev, int mode,
	44	void (*input) (int dev, unsigned char data),
	45	void (*output) (int dev)
	46	)
	47	{
	48	vmidi_devc *devc = midi_devs[dev]->devc;
	49	unsigned long flags;
	50
	51	if (devc == NULL)
	52	return -(ENXIO);
	53
	54	spin_lock_irqsave(&devc->lock,flags);
	55	if (devc->opened)
	56	{
	57	spin_unlock_irqrestore(&devc->lock,flags);
	58	return -(EBUSY);
	59	}
	60	devc->opened = 1;
	61	spin_unlock_irqrestore(&devc->lock,flags);
	62
	63	devc->intr_active = 1;
	64
	65	if (mode & OPEN_READ)
	66	{
	67	devc->input_opened = 1;
	68	devc->midi_input_intr = input;
	69	}
	70
	71	return 0;
	72	}
	73
	74	static void v_midi_close (int dev)
	75	{
	76	vmidi_devc *devc = midi_devs[dev]->devc;
	77	unsigned long flags;
	78
	79	if (devc == NULL)
	80	return;
	81
	82	spin_lock_irqsave(&devc->lock,flags);
	83	devc->intr_active = 0;
	84	devc->input_opened = 0;
	85	devc->opened = 0;
	86	spin_unlock_irqrestore(&devc->lock,flags);
	87	}
	88
	89	static int v_midi_out (int dev, unsigned char midi_byte)
	90	{
	91	vmidi_devc *devc = midi_devs[dev]->devc;
	92	vmidi_devc *pdevc;
	93
	94	if (devc == NULL)
	95	return -ENXIO;
	96
	97	pdevc = midi_devs[devc->pair_mididev]->devc;
	98	if (pdevc->input_opened > 0){
	99	if (MIDIbuf_avail(pdevc->my_mididev) > 500)
	100	return 0;
	101	pdevc->midi_input_intr (pdevc->my_mididev, midi_byte);
	102	}
	103	return 1;
	104	}
	105
	106	static inline int v_midi_start_read (int dev)
107	{
108	return 0;
109	}
110
111	static int v_midi_end_read (int dev)
112	{
113	vmidi_devc *devc = midi_devs[dev]->devc;
114	if (devc == NULL)
115	return -ENXIO;
116
117	devc->intr_active = 0;
118	return 0;
119	}
120
121	/* why -EPERM and not -EINVAL?? */
122
123	static inline int v_midi_ioctl (int dev, unsigned cmd, void __user *arg)
124	{
125	return -EPERM;
126	}
127
128
129	#define MIDI_SYNTH_NAME "Loopback MIDI"
130	#define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
131
132	#include "midi_synth.h"
133
134	static struct midi_operations v_midi_operations =
135	{
136	.owner = THIS_MODULE,
137	.info = {"Loopback MIDI Port 1", 0, 0, SNDCARD_VMIDI},
138	.converter = &std_midi_synth,
139	.in_info = {0},
140	.open = v_midi_open,
141	.close = v_midi_close,
142	.ioctl = v_midi_ioctl,
143	.outputc = v_midi_out,
144	.start_read = v_midi_start_read,
145	.end_read = v_midi_end_read,
146	};
147
148	static struct midi_operations v_midi_operations2 =
149	{
150	.owner = THIS_MODULE,
151	.info = {"Loopback MIDI Port 2", 0, 0, SNDCARD_VMIDI},
152	.converter = &std_midi_synth,
153	.in_info = {0},
154	.open = v_midi_open,
155	.close = v_midi_close,
156	.ioctl = v_midi_ioctl,
157	.outputc = v_midi_out,
158	.start_read = v_midi_start_read,
159	.end_read = v_midi_end_read,
160	};
161
162	/*
163	* We kmalloc just one of these - it makes life simpler and the code
164	* cleaner and the memory handling far more efficient
165	*/
166
167	struct vmidi_memory
168	{
169	/* Must be first */
170	struct midi_operations m_ops[2];
171	struct synth_operations s_ops[2];
172	struct vmidi_devc v_ops[2];
173	};
174
175	static void __init attach_v_midi (struct address_info *hw_config)
176	{
177	struct vmidi_memory *m;
178	/* printk("Attaching v_midi device.....\n"); */
179
180	midi1 = sound_alloc_mididev();
181	if (midi1 == -1)
182	{
183	printk(KERN_ERR "v_midi: Too many midi devices detected\n");
184	return;
185	}
186
5cbded58	187	m = kmalloc(sizeof(struct vmidi_memory), GFP_KERNEL);
1da177e4 LT	188	if (m == NULL)
	189	{
	190	printk(KERN_WARNING "Loopback MIDI: Failed to allocate memory\n");
	191	sound_unload_mididev(midi1);
	192	return;
	193	}
	194
	195	midi_mem = m;
	196
	197	midi_devs[midi1] = &m->m_ops[0];
	198
	199
	200	midi2 = sound_alloc_mididev();
	201	if (midi2 == -1)
	202	{
	203	printk (KERN_ERR "v_midi: Too many midi devices detected\n");
	204	kfree(m);
	205	sound_unload_mididev(midi1);
	206	return;
	207	}
	208
	209	midi_devs[midi2] = &m->m_ops[1];
	210
	211	/* printk("VMIDI1: %d VMIDI2: %d\n",midi1,midi2); */
	212
	213	/* for MIDI-1 */
	214	v_devc[0] = &m->v_ops[0];
	215	memcpy ((char ) midi_devs[midi1], (char ) &v_midi_operations,
	216	sizeof (struct midi_operations));
	217
	218	v_devc[0]->my_mididev = midi1;
	219	v_devc[0]->pair_mididev = midi2;
	220	v_devc[0]->opened = v_devc[0]->input_opened = 0;
	221	v_devc[0]->intr_active = 0;
	222	v_devc[0]->midi_input_intr = NULL;
	223	spin_lock_init(&v_devc[0]->lock);
	224
	225	midi_devs[midi1]->devc = v_devc[0];
	226
	227	midi_devs[midi1]->converter = &m->s_ops[0];
	228	std_midi_synth.midi_dev = midi1;
	229	memcpy ((char ) midi_devs[midi1]->converter, (char ) &std_midi_synth,
	230	sizeof (struct synth_operations));
	231	midi_devs[midi1]->converter->id = "V_MIDI 1";
	232
	233	/* for MIDI-2 */
	234	v_devc[1] = &m->v_ops[1];
	235
	236	memcpy ((char ) midi_devs[midi2], (char ) &v_midi_operations2,
	237	sizeof (struct midi_operations));
	238
	239	v_devc[1]->my_mididev = midi2;
	240	v_devc[1]->pair_mididev = midi1;
	241	v_devc[1]->opened = v_devc[1]->input_opened = 0;
	242	v_devc[1]->intr_active = 0;
	243	v_devc[1]->midi_input_intr = NULL;
	244	spin_lock_init(&v_devc[1]->lock);
	245
	246	midi_devs[midi2]->devc = v_devc[1];
	247	midi_devs[midi2]->converter = &m->s_ops[1];
	248
	249	std_midi_synth.midi_dev = midi2;
	250	memcpy ((char ) midi_devs[midi2]->converter, (char ) &std_midi_synth,
	251	sizeof (struct synth_operations));
252	midi_devs[midi2]->converter->id = "V_MIDI 2";
253
254	sequencer_init();
255	/* printk("Attached v_midi device\n"); */
256	}
257
258	static inline int __init probe_v_midi(struct address_info *hw_config)
259	{
260	return(1); /* always OK */
261	}
262
263
264	static void __exit unload_v_midi(struct address_info *hw_config)
265	{
266	sound_unload_mididev(midi1);
267	sound_unload_mididev(midi2);
268	kfree(midi_mem);
269	}
270
271	static struct address_info cfg; /* dummy */
272
273	static int __init init_vmidi(void)
274	{
275	printk("MIDI Loopback device driver\n");
276	if (!probe_v_midi(&cfg))
277	return -ENODEV;
278	attach_v_midi(&cfg);
279
280	return 0;
281	}
282
283	static void __exit cleanup_vmidi(void)
284	{
285	unload_v_midi(&cfg);
286	}
287
288	module_init(init_vmidi);
289	module_exit(cleanup_vmidi);
290	MODULE_LICENSE("GPL");