[linux-2.6] / sound / oss / midibuf.c

/*
 * sound/midibuf.c
 *
 * Device file manager for /dev/midi#
 */
/*
 * Copyright (C) by Hannu Savolainen 1993-1997
 *
 * OSS/Free 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.
 */
/*
 * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
 */
#include <linux/stddef.h>
#include <linux/kmod.h>
#include <linux/spinlock.h>
#define MIDIBUF_C

#include "sound_config.h"


/*
 * Don't make MAX_QUEUE_SIZE larger than 4000
 */

#define MAX_QUEUE_SIZE	4000

static wait_queue_head_t midi_sleeper[MAX_MIDI_DEV];
static wait_queue_head_t input_sleeper[MAX_MIDI_DEV];

struct midi_buf
{
	int len, head, tail;
	unsigned char queue[MAX_QUEUE_SIZE];
};

struct midi_parms
{
	long prech_timeout;	/*
				 * Timeout before the first ch
				 */
};

static struct midi_buf *midi_out_buf[MAX_MIDI_DEV] = {NULL};
static struct midi_buf *midi_in_buf[MAX_MIDI_DEV] = {NULL};
static struct midi_parms parms[MAX_MIDI_DEV];

static void midi_poll(unsigned long dummy);


static DEFINE_TIMER(poll_timer, midi_poll, 0, 0);

static volatile int open_devs;
static DEFINE_SPINLOCK(lock);

#define DATA_AVAIL(q) (q->len)
#define SPACE_AVAIL(q) (MAX_QUEUE_SIZE - q->len)

#define QUEUE_BYTE(q, data) \
	if (SPACE_AVAIL(q)) \
	{ \
	  unsigned long flags; \
	  spin_lock_irqsave(&lock, flags); \
	  q->queue[q->tail] = (data); \
	  q->len++; q->tail = (q->tail+1) % MAX_QUEUE_SIZE; \
	  spin_unlock_irqrestore(&lock, flags); \
	}

#define REMOVE_BYTE(q, data) \
	if (DATA_AVAIL(q)) \
	{ \
	  unsigned long flags; \
	  spin_lock_irqsave(&lock, flags); \
	  data = q->queue[q->head]; \
	  q->len--; q->head = (q->head+1) % MAX_QUEUE_SIZE; \
	  spin_unlock_irqrestore(&lock, flags); \
	}

static void drain_midi_queue(int dev)
{

	/*
	 * Give the Midi driver time to drain its output queues
	 */

	if (midi_devs[dev]->buffer_status != NULL)
		while (!signal_pending(current) && midi_devs[dev]->buffer_status(dev)) 
			interruptible_sleep_on_timeout(&midi_sleeper[dev],
						       HZ/10);
}

static void midi_input_intr(int dev, unsigned char data)
{
	if (midi_in_buf[dev] == NULL)
		return;

	if (data == 0xfe)	/*
				 * Active sensing
				 */
		return;		/*
				 * Ignore
				 */

	if (SPACE_AVAIL(midi_in_buf[dev])) {
		QUEUE_BYTE(midi_in_buf[dev], data);
		wake_up(&input_sleeper[dev]);
	}
}

static void midi_output_intr(int dev)
{
	/*
	 * Currently NOP
	 */
}

static void midi_poll(unsigned long dummy)
{
	unsigned long   flags;
	int             dev;

	spin_lock_irqsave(&lock, flags);
	if (open_devs)
	{
		for (dev = 0; dev < num_midis; dev++)
			if (midi_devs[dev] != NULL && midi_out_buf[dev] != NULL)
			{
				int ok = 1;

				while (DATA_AVAIL(midi_out_buf[dev]) && ok)
				{
					int c = midi_out_buf[dev]->queue[midi_out_buf[dev]->head];

					spin_unlock_irqrestore(&lock,flags);/* Give some time to others */
					ok = midi_devs[dev]->outputc(dev, c);
					spin_lock_irqsave(&lock, flags);
					midi_out_buf[dev]->head = (midi_out_buf[dev]->head + 1) % MAX_QUEUE_SIZE;
					midi_out_buf[dev]->len--;
				}

				if (DATA_AVAIL(midi_out_buf[dev]) < 100)
					wake_up(&midi_sleeper[dev]);
			}
		poll_timer.expires = (1) + jiffies;
		add_timer(&poll_timer);
		/*
		 * Come back later
		 */
	}
	spin_unlock_irqrestore(&lock, flags);
}

int MIDIbuf_open(int dev, struct file *file)
{
	int mode, err;

	dev = dev >> 4;
	mode = translate_mode(file);

	if (num_midis > MAX_MIDI_DEV)
	{
		printk(KERN_ERR "midi: Too many midi interfaces\n");
		num_midis = MAX_MIDI_DEV;
	}
	if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
		  return -ENXIO;
	/*
	 *    Interrupts disabled. Be careful
	 */

	module_put(midi_devs[dev]->owner);

	if ((err = midi_devs[dev]->open(dev, mode,
				 midi_input_intr, midi_output_intr)) < 0)
		return err;

	parms[dev].prech_timeout = MAX_SCHEDULE_TIMEOUT;
	midi_in_buf[dev] = (struct midi_buf *) vmalloc(sizeof(struct midi_buf));

	if (midi_in_buf[dev] == NULL)
	{
		printk(KERN_WARNING "midi: Can't allocate buffer\n");
		midi_devs[dev]->close(dev);
		return -EIO;
	}
	midi_in_buf[dev]->len = midi_in_buf[dev]->head = midi_in_buf[dev]->tail = 0;

	midi_out_buf[dev] = (struct midi_buf *) vmalloc(sizeof(struct midi_buf));

	if (midi_out_buf[dev] == NULL)
	{
		printk(KERN_WARNING "midi: Can't allocate buffer\n");
		midi_devs[dev]->close(dev);
		vfree(midi_in_buf[dev]);
		midi_in_buf[dev] = NULL;
		return -EIO;
	}
	midi_out_buf[dev]->len = midi_out_buf[dev]->head = midi_out_buf[dev]->tail = 0;
	open_devs++;

	init_waitqueue_head(&midi_sleeper[dev]);
	init_waitqueue_head(&input_sleeper[dev]);

	if (open_devs < 2)	/* This was first open */
	{
		poll_timer.expires = 1 + jiffies;
		add_timer(&poll_timer);	/* Start polling */
	}
	return err;
}

void MIDIbuf_release(int dev, struct file *file)
{
	int mode;

	dev = dev >> 4;
	mode = translate_mode(file);

	if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
		return;

	/*
	 * Wait until the queue is empty
	 */

	if (mode != OPEN_READ)
	{
		midi_devs[dev]->outputc(dev, 0xfe);	/*
							   * Active sensing to shut the
							   * devices
							 */

		while (!signal_pending(current) && DATA_AVAIL(midi_out_buf[dev]))
			  interruptible_sleep_on(&midi_sleeper[dev]);
		/*
		 *	Sync
		 */

		drain_midi_queue(dev);	/*
					 * Ensure the output queues are empty
					 */
	}

	midi_devs[dev]->close(dev);

	open_devs--;
	if (open_devs == 0)
		del_timer_sync(&poll_timer);
	vfree(midi_in_buf[dev]);
	vfree(midi_out_buf[dev]);
	midi_in_buf[dev] = NULL;
	midi_out_buf[dev] = NULL;

	module_put(midi_devs[dev]->owner);
}

int MIDIbuf_write(int dev, struct file *file, const char __user *buf, int count)
{
	int c, n, i;
	unsigned char tmp_data;

	dev = dev >> 4;

	if (!count)
		return 0;

	c = 0;

	while (c < count)
	{
		n = SPACE_AVAIL(midi_out_buf[dev]);

		if (n == 0) {	/*
				 * No space just now.
				 */

			if (file->f_flags & O_NONBLOCK) {
				c = -EAGAIN;
				goto out;
			}

			interruptible_sleep_on(&midi_sleeper[dev]);
			if (signal_pending(current)) 
			{
				c = -EINTR;
				goto out;
			}
			n = SPACE_AVAIL(midi_out_buf[dev]);
		}
		if (n > (count - c))
			n = count - c;

		for (i = 0; i < n; i++)
		{
			/* BROKE BROKE BROKE - CANT DO THIS WITH CLI !! */
			/* yes, think the same, so I removed the cli() brackets 
				QUEUE_BYTE is protected against interrupts */
			if (copy_from_user((char *) &tmp_data, &(buf)[c], 1)) {
				c = -EFAULT;
				goto out;
			}
			QUEUE_BYTE(midi_out_buf[dev], tmp_data);
			c++;
		}
	}
out:
	return c;
}


int MIDIbuf_read(int dev, struct file *file, char __user *buf, int count)
{
	int n, c = 0;
	unsigned char tmp_data;

	dev = dev >> 4;

	if (!DATA_AVAIL(midi_in_buf[dev])) {	/*
						 * No data yet, wait
						 */
 		if (file->f_flags & O_NONBLOCK) {
 			c = -EAGAIN;
			goto out;
 		}
		interruptible_sleep_on_timeout(&input_sleeper[dev],
					       parms[dev].prech_timeout);

		if (signal_pending(current))
			c = -EINTR;	/* The user is getting restless */
	}
	if (c == 0 && DATA_AVAIL(midi_in_buf[dev]))	/*
							 * Got some bytes
							 */
	{
		n = DATA_AVAIL(midi_in_buf[dev]);
		if (n > count)
			n = count;
		c = 0;

		while (c < n)
		{
			char *fixit;
			REMOVE_BYTE(midi_in_buf[dev], tmp_data);
			fixit = (char *) &tmp_data;
			/* BROKE BROKE BROKE */
			/* yes removed the cli() brackets again
			 should q->len,tail&head be atomic_t? */
			if (copy_to_user(&(buf)[c], fixit, 1)) {
				c = -EFAULT;
				goto out;
			}
			c++;
		}
	}
out:
	return c;
}

int MIDIbuf_ioctl(int dev, struct file *file,
		  unsigned int cmd, void __user *arg)
{
	int val;

	dev = dev >> 4;
	
	if (((cmd >> 8) & 0xff) == 'C') 
	{
		if (midi_devs[dev]->coproc)	/* Coprocessor ioctl */
			return midi_devs[dev]->coproc->ioctl(midi_devs[dev]->coproc->devc, cmd, arg, 0);
/*		printk("/dev/midi%d: No coprocessor for this device\n", dev);*/
		return -ENXIO;
	}
	else
	{
		switch (cmd) 
		{
			case SNDCTL_MIDI_PRETIME:
				if (get_user(val, (int __user *)arg))
					return -EFAULT;
				if (val < 0)
					val = 0;
				val = (HZ * val) / 10;
				parms[dev].prech_timeout = val;
				return put_user(val, (int __user *)arg);
			
			default:
				if (!midi_devs[dev]->ioctl)
					return -EINVAL;
				return midi_devs[dev]->ioctl(dev, cmd, arg);
		}
	}
}

/* No kernel lock - fine */
unsigned int MIDIbuf_poll(int dev, struct file *file, poll_table * wait)
{
	unsigned int mask = 0;

	dev = dev >> 4;

	/* input */
	poll_wait(file, &input_sleeper[dev], wait);
	if (DATA_AVAIL(midi_in_buf[dev]))
		mask |= POLLIN | POLLRDNORM;

	/* output */
	poll_wait(file, &midi_sleeper[dev], wait);
	if (!SPACE_AVAIL(midi_out_buf[dev]))
		mask |= POLLOUT | POLLWRNORM;
	
	return mask;
}


void MIDIbuf_init(void)
{
	/* drag in midi_syms.o */
	{
		extern char midi_syms_symbol;
		midi_syms_symbol = 0;
	}
}

int MIDIbuf_avail(int dev)
{
	if (midi_in_buf[dev])
		return DATA_AVAIL (midi_in_buf[dev]);
	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* sound/midibuf.c
	3	*
	4	* Device file manager for /dev/midi#
	5	*/
	6	/*
	7	* Copyright (C) by Hannu Savolainen 1993-1997
	8	*
	9	* OSS/Free 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	* Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
	15	*/
	16	#include <linux/stddef.h>
	17	#include <linux/kmod.h>
	18	#include <linux/spinlock.h>
	19	#define MIDIBUF_C
	20
	21	#include "sound_config.h"
	22
	23
	24	/*
	25	* Don't make MAX_QUEUE_SIZE larger than 4000
	26	*/
	27
	28	#define MAX_QUEUE_SIZE 4000
	29
	30	static wait_queue_head_t midi_sleeper[MAX_MIDI_DEV];
	31	static wait_queue_head_t input_sleeper[MAX_MIDI_DEV];
	32
	33	struct midi_buf
	34	{
	35	int len, head, tail;
	36	unsigned char queue[MAX_QUEUE_SIZE];
	37	};
	38
	39	struct midi_parms
	40	{
	41	long prech_timeout; /*
	42	* Timeout before the first ch
	43	*/
	44	};
	45
	46	static struct midi_buf *midi_out_buf[MAX_MIDI_DEV] = {NULL};
	47	static struct midi_buf *midi_in_buf[MAX_MIDI_DEV] = {NULL};
	48	static struct midi_parms parms[MAX_MIDI_DEV];
	49
	50	static void midi_poll(unsigned long dummy);
	51
	52
8d06afab	53	static DEFINE_TIMER(poll_timer, midi_poll, 0, 0);
1da177e4 LT	54
	55	static volatile int open_devs;
	56	static DEFINE_SPINLOCK(lock);
	57
	58	#define DATA_AVAIL(q) (q->len)
	59	#define SPACE_AVAIL(q) (MAX_QUEUE_SIZE - q->len)
	60
	61	#define QUEUE_BYTE(q, data) \
	62	if (SPACE_AVAIL(q)) \
	63	{ \
	64	unsigned long flags; \
	65	spin_lock_irqsave(&lock, flags); \
	66	q->queue[q->tail] = (data); \
	67	q->len++; q->tail = (q->tail+1) % MAX_QUEUE_SIZE; \
	68	spin_unlock_irqrestore(&lock, flags); \
	69	}
	70
	71	#define REMOVE_BYTE(q, data) \
	72	if (DATA_AVAIL(q)) \
	73	{ \
	74	unsigned long flags; \
	75	spin_lock_irqsave(&lock, flags); \
	76	data = q->queue[q->head]; \
	77	q->len--; q->head = (q->head+1) % MAX_QUEUE_SIZE; \
	78	spin_unlock_irqrestore(&lock, flags); \
	79	}
	80
	81	static void drain_midi_queue(int dev)
	82	{
	83
	84	/*
	85	* Give the Midi driver time to drain its output queues
	86	*/
	87
	88	if (midi_devs[dev]->buffer_status != NULL)
	89	while (!signal_pending(current) && midi_devs[dev]->buffer_status(dev))
	90	interruptible_sleep_on_timeout(&midi_sleeper[dev],
	91	HZ/10);
	92	}
	93
	94	static void midi_input_intr(int dev, unsigned char data)
	95	{
	96	if (midi_in_buf[dev] == NULL)
	97	return;
	98
	99	if (data == 0xfe) /*
	100	* Active sensing
	101	*/
	102	return; /*
	103	* Ignore
	104	*/
	105
	106	if (SPACE_AVAIL(midi_in_buf[dev])) {
	107	QUEUE_BYTE(midi_in_buf[dev], data);
	108	wake_up(&input_sleeper[dev]);
	109	}
	110	}
	111
	112	static void midi_output_intr(int dev)
	113	{
	114	/*
	115	* Currently NOP
	116	*/
	117	}
118
119	static void midi_poll(unsigned long dummy)
120	{
121	unsigned long flags;
122	int dev;
123
124	spin_lock_irqsave(&lock, flags);
125	if (open_devs)
126	{
127	for (dev = 0; dev < num_midis; dev++)
128	if (midi_devs[dev] != NULL && midi_out_buf[dev] != NULL)
129	{
130	int ok = 1;
131
132	while (DATA_AVAIL(midi_out_buf[dev]) && ok)
133	{
134	int c = midi_out_buf[dev]->queue[midi_out_buf[dev]->head];
135
136	spin_unlock_irqrestore(&lock,flags);/* Give some time to others */
137	ok = midi_devs[dev]->outputc(dev, c);
138	spin_lock_irqsave(&lock, flags);
139	midi_out_buf[dev]->head = (midi_out_buf[dev]->head + 1) % MAX_QUEUE_SIZE;
140	midi_out_buf[dev]->len--;
141	}
142
143	if (DATA_AVAIL(midi_out_buf[dev]) < 100)
144	wake_up(&midi_sleeper[dev]);
145	}
146	poll_timer.expires = (1) + jiffies;
147	add_timer(&poll_timer);
148	/*
149	* Come back later
150	*/
151	}
152	spin_unlock_irqrestore(&lock, flags);
153	}
154
155	int MIDIbuf_open(int dev, struct file *file)
156	{
157	int mode, err;
158
159	dev = dev >> 4;
160	mode = translate_mode(file);
161
162	if (num_midis > MAX_MIDI_DEV)
163	{
164	printk(KERN_ERR "midi: Too many midi interfaces\n");
165	num_midis = MAX_MIDI_DEV;
166	}
167	if (dev < 0 \|\| dev >= num_midis \|\| midi_devs[dev] == NULL)
168	return -ENXIO;
169	/*
170	* Interrupts disabled. Be careful
171	*/
172
173	module_put(midi_devs[dev]->owner);
174
175	if ((err = midi_devs[dev]->open(dev, mode,
176	midi_input_intr, midi_output_intr)) < 0)
177	return err;
178
179	parms[dev].prech_timeout = MAX_SCHEDULE_TIMEOUT;
180	midi_in_buf[dev] = (struct midi_buf *) vmalloc(sizeof(struct midi_buf));
181
182	if (midi_in_buf[dev] == NULL)
183	{
184	printk(KERN_WARNING "midi: Can't allocate buffer\n");
185	midi_devs[dev]->close(dev);
186	return -EIO;
187	}
188	midi_in_buf[dev]->len = midi_in_buf[dev]->head = midi_in_buf[dev]->tail = 0;
189
190	midi_out_buf[dev] = (struct midi_buf *) vmalloc(sizeof(struct midi_buf));
191
192	if (midi_out_buf[dev] == NULL)
193	{
194	printk(KERN_WARNING "midi: Can't allocate buffer\n");
195	midi_devs[dev]->close(dev);
196	vfree(midi_in_buf[dev]);
197	midi_in_buf[dev] = NULL;
198	return -EIO;
199	}
200	midi_out_buf[dev]->len = midi_out_buf[dev]->head = midi_out_buf[dev]->tail = 0;
201	open_devs++;
202
203	init_waitqueue_head(&midi_sleeper[dev]);
204	init_waitqueue_head(&input_sleeper[dev]);
205
206	if (open_devs < 2) /* This was first open */
207	{
208	poll_timer.expires = 1 + jiffies;
209	add_timer(&poll_timer); /* Start polling */
210	}
211	return err;
212	}
213
214	void MIDIbuf_release(int dev, struct file *file)
215	{
216	int mode;
217
218	dev = dev >> 4;
219	mode = translate_mode(file);
220
221	if (dev < 0 \|\| dev >= num_midis \|\| midi_devs[dev] == NULL)
222	return;
223
224	/*
225	* Wait until the queue is empty
226	*/
227
228	if (mode != OPEN_READ)
229	{
230	midi_devs[dev]->outputc(dev, 0xfe); /*
231	* Active sensing to shut the
232	* devices
233	*/
234
235	while (!signal_pending(current) && DATA_AVAIL(midi_out_buf[dev]))
236	interruptible_sleep_on(&midi_sleeper[dev]);
237	/*
238	* Sync
239	*/
240
241	drain_midi_queue(dev); /*
242	* Ensure the output queues are empty
243	*/
244	}
245
246	midi_devs[dev]->close(dev);
247
248	open_devs--;
249	if (open_devs == 0)
250	del_timer_sync(&poll_timer);
251	vfree(midi_in_buf[dev]);
252	vfree(midi_out_buf[dev]);
253	midi_in_buf[dev] = NULL;
254	midi_out_buf[dev] = NULL;
255
256	module_put(midi_devs[dev]->owner);
257	}
258
259	int MIDIbuf_write(int dev, struct file file, const char __user buf, int count)
260	{
261	int c, n, i;
262	unsigned char tmp_data;
263
264	dev = dev >> 4;
265
266	if (!count)
267	return 0;
268
269	c = 0;
270
271	while (c < count)
272	{
273	n = SPACE_AVAIL(midi_out_buf[dev]);
274
275	if (n == 0) { /*
276	* No space just now.
277	*/
278
279	if (file->f_flags & O_NONBLOCK) {
280	c = -EAGAIN;
281	goto out;
282	}
283
284	interruptible_sleep_on(&midi_sleeper[dev]);
285	if (signal_pending(current))
286	{
287	c = -EINTR;
288	goto out;
289	}
290	n = SPACE_AVAIL(midi_out_buf[dev]);
291	}
292	if (n > (count - c))
293	n = count - c;
294
295	for (i = 0; i < n; i++)
296	{
297	/* BROKE BROKE BROKE - CANT DO THIS WITH CLI !! */
298	/* yes, think the same, so I removed the cli() brackets
299	QUEUE_BYTE is protected against interrupts */
300	if (copy_from_user((char *) &tmp_data, &(buf)[c], 1)) {
301	c = -EFAULT;
302	goto out;
303	}
304	QUEUE_BYTE(midi_out_buf[dev], tmp_data);
305	c++;
306	}
307	}
308	out:
309	return c;
310	}
311
312
313	int MIDIbuf_read(int dev, struct file file, char __user buf, int count)
314	{
315	int n, c = 0;
316	unsigned char tmp_data;
317
318	dev = dev >> 4;
319
320	if (!DATA_AVAIL(midi_in_buf[dev])) { /*
321	* No data yet, wait
322	*/
323	if (file->f_flags & O_NONBLOCK) {
324	c = -EAGAIN;
325	goto out;
326	}
327	interruptible_sleep_on_timeout(&input_sleeper[dev],
328	parms[dev].prech_timeout);
329
330	if (signal_pending(current))
331	c = -EINTR; /* The user is getting restless */
332	}
333	if (c == 0 && DATA_AVAIL(midi_in_buf[dev])) /*
334	* Got some bytes
335	*/
336	{
337	n = DATA_AVAIL(midi_in_buf[dev]);
338	if (n > count)
339	n = count;
340	c = 0;
341
342	while (c < n)
343	{
344	char *fixit;
345	REMOVE_BYTE(midi_in_buf[dev], tmp_data);
346	fixit = (char *) &tmp_data;
347	/* BROKE BROKE BROKE */
348	/* yes removed the cli() brackets again
349	should q->len,tail&head be atomic_t? */
350	if (copy_to_user(&(buf)[c], fixit, 1)) {
351	c = -EFAULT;
352	goto out;
353	}
354	c++;
355	}
356	}
357	out:
358	return c;
359	}
360
361	int MIDIbuf_ioctl(int dev, struct file *file,
362	unsigned int cmd, void __user *arg)
363	{
364	int val;
365
366	dev = dev >> 4;
367
368	if (((cmd >> 8) & 0xff) == 'C')
369	{
370	if (midi_devs[dev]->coproc) /* Coprocessor ioctl */
371	return midi_devs[dev]->coproc->ioctl(midi_devs[dev]->coproc->devc, cmd, arg, 0);
372	/* printk("/dev/midi%d: No coprocessor for this device\n", dev);*/
373	return -ENXIO;
374	}
375	else
376	{
377	switch (cmd)
378	{
379	case SNDCTL_MIDI_PRETIME:
380	if (get_user(val, (int __user *)arg))
381	return -EFAULT;
382	if (val < 0)
383	val = 0;
384	val = (HZ * val) / 10;
385	parms[dev].prech_timeout = val;
386	return put_user(val, (int __user *)arg);
387
388	default:
389	if (!midi_devs[dev]->ioctl)
390	return -EINVAL;
391	return midi_devs[dev]->ioctl(dev, cmd, arg);
392	}
393	}
394	}
395
396	/* No kernel lock - fine */
397	unsigned int MIDIbuf_poll(int dev, struct file file, poll_table wait)
398	{
399	unsigned int mask = 0;
400
401	dev = dev >> 4;
402
403	/* input */
404	poll_wait(file, &input_sleeper[dev], wait);
405	if (DATA_AVAIL(midi_in_buf[dev]))
406	mask \|= POLLIN \| POLLRDNORM;
407
408	/* output */
409	poll_wait(file, &midi_sleeper[dev], wait);
410	if (!SPACE_AVAIL(midi_out_buf[dev]))
411	mask \|= POLLOUT \| POLLWRNORM;
412
413	return mask;
414	}
415
416
417	void MIDIbuf_init(void)
418	{
419	/* drag in midi_syms.o */
420	{
421	extern char midi_syms_symbol;
422	midi_syms_symbol = 0;
423	}
424	}
425
426	int MIDIbuf_avail(int dev)
427	{
428	if (midi_in_buf[dev])
429	return DATA_AVAIL (midi_in_buf[dev]);
430	return 0;
431	}