4 * Device file manager for /dev/midi#
7 * Copyright (C) by Hannu Savolainen 1993-1997
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
14 * Thomas Sailer : ioctl code reworked (vmalloc/vfree removed)
16 #include <linux/stddef.h>
17 #include <linux/kmod.h>
18 #include <linux/spinlock.h>
19 #include <linux/sched/signal.h>
23 #include "sound_config.h"
27 * Don't make MAX_QUEUE_SIZE larger than 4000
30 #define MAX_QUEUE_SIZE 4000
32 static wait_queue_head_t midi_sleeper[MAX_MIDI_DEV];
33 static wait_queue_head_t input_sleeper[MAX_MIDI_DEV];
38 unsigned char queue[MAX_QUEUE_SIZE];
43 long prech_timeout; /*
44 * Timeout before the first ch
48 static struct midi_buf *midi_out_buf[MAX_MIDI_DEV] = {NULL};
49 static struct midi_buf *midi_in_buf[MAX_MIDI_DEV] = {NULL};
50 static struct midi_parms parms[MAX_MIDI_DEV];
52 static void midi_poll(unsigned long dummy);
55 static DEFINE_TIMER(poll_timer, midi_poll, 0, 0);
57 static volatile int open_devs;
58 static DEFINE_SPINLOCK(lock);
60 #define DATA_AVAIL(q) (q->len)
61 #define SPACE_AVAIL(q) (MAX_QUEUE_SIZE - q->len)
63 #define QUEUE_BYTE(q, data) \
66 unsigned long flags; \
67 spin_lock_irqsave(&lock, flags); \
68 q->queue[q->tail] = (data); \
69 q->len++; q->tail = (q->tail+1) % MAX_QUEUE_SIZE; \
70 spin_unlock_irqrestore(&lock, flags); \
73 #define REMOVE_BYTE(q, data) \
76 unsigned long flags; \
77 spin_lock_irqsave(&lock, flags); \
78 data = q->queue[q->head]; \
79 q->len--; q->head = (q->head+1) % MAX_QUEUE_SIZE; \
80 spin_unlock_irqrestore(&lock, flags); \
83 static void drain_midi_queue(int dev)
87 * Give the Midi driver time to drain its output queues
90 if (midi_devs[dev]->buffer_status != NULL)
91 wait_event_interruptible_timeout(midi_sleeper[dev],
92 !midi_devs[dev]->buffer_status(dev), HZ/10);
95 static void midi_input_intr(int dev, unsigned char data)
97 if (midi_in_buf[dev] == NULL)
107 if (SPACE_AVAIL(midi_in_buf[dev])) {
108 QUEUE_BYTE(midi_in_buf[dev], data);
109 wake_up(&input_sleeper[dev]);
113 static void midi_output_intr(int dev)
120 static void midi_poll(unsigned long dummy)
125 spin_lock_irqsave(&lock, flags);
128 for (dev = 0; dev < num_midis; dev++)
129 if (midi_devs[dev] != NULL && midi_out_buf[dev] != NULL)
131 while (DATA_AVAIL(midi_out_buf[dev]))
134 int c = midi_out_buf[dev]->queue[midi_out_buf[dev]->head];
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);
141 midi_out_buf[dev]->head = (midi_out_buf[dev]->head + 1) % MAX_QUEUE_SIZE;
142 midi_out_buf[dev]->len--;
145 if (DATA_AVAIL(midi_out_buf[dev]) < 100)
146 wake_up(&midi_sleeper[dev]);
148 poll_timer.expires = (1) + jiffies;
149 add_timer(&poll_timer);
154 spin_unlock_irqrestore(&lock, flags);
157 int MIDIbuf_open(int dev, struct file *file)
162 mode = translate_mode(file);
164 if (num_midis > MAX_MIDI_DEV)
166 printk(KERN_ERR "midi: Too many midi interfaces\n");
167 num_midis = MAX_MIDI_DEV;
169 if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
172 * Interrupts disabled. Be careful
175 module_put(midi_devs[dev]->owner);
177 if ((err = midi_devs[dev]->open(dev, mode,
178 midi_input_intr, midi_output_intr)) < 0)
181 parms[dev].prech_timeout = MAX_SCHEDULE_TIMEOUT;
182 midi_in_buf[dev] = vmalloc(sizeof(struct midi_buf));
184 if (midi_in_buf[dev] == NULL)
186 printk(KERN_WARNING "midi: Can't allocate buffer\n");
187 midi_devs[dev]->close(dev);
190 midi_in_buf[dev]->len = midi_in_buf[dev]->head = midi_in_buf[dev]->tail = 0;
192 midi_out_buf[dev] = vmalloc(sizeof(struct midi_buf));
194 if (midi_out_buf[dev] == NULL)
196 printk(KERN_WARNING "midi: Can't allocate buffer\n");
197 midi_devs[dev]->close(dev);
198 vfree(midi_in_buf[dev]);
199 midi_in_buf[dev] = NULL;
202 midi_out_buf[dev]->len = midi_out_buf[dev]->head = midi_out_buf[dev]->tail = 0;
205 init_waitqueue_head(&midi_sleeper[dev]);
206 init_waitqueue_head(&input_sleeper[dev]);
208 if (open_devs < 2) /* This was first open */
210 poll_timer.expires = 1 + jiffies;
211 add_timer(&poll_timer); /* Start polling */
216 void MIDIbuf_release(int dev, struct file *file)
221 mode = translate_mode(file);
223 if (dev < 0 || dev >= num_midis || midi_devs[dev] == NULL)
227 * Wait until the queue is empty
230 if (mode != OPEN_READ)
232 midi_devs[dev]->outputc(dev, 0xfe); /*
233 * Active sensing to shut the
237 wait_event_interruptible(midi_sleeper[dev],
238 !DATA_AVAIL(midi_out_buf[dev]));
243 drain_midi_queue(dev); /*
244 * Ensure the output queues are empty
248 midi_devs[dev]->close(dev);
252 del_timer_sync(&poll_timer);
253 vfree(midi_in_buf[dev]);
254 vfree(midi_out_buf[dev]);
255 midi_in_buf[dev] = NULL;
256 midi_out_buf[dev] = NULL;
258 module_put(midi_devs[dev]->owner);
261 int MIDIbuf_write(int dev, struct file *file, const char __user *buf, int count)
264 unsigned char tmp_data;
275 n = SPACE_AVAIL(midi_out_buf[dev]);
281 if (file->f_flags & O_NONBLOCK) {
286 if (wait_event_interruptible(midi_sleeper[dev],
287 SPACE_AVAIL(midi_out_buf[dev])))
292 n = SPACE_AVAIL(midi_out_buf[dev]);
297 for (i = 0; i < n; i++)
299 /* BROKE BROKE BROKE - CAN'T DO THIS WITH CLI !! */
300 /* yes, think the same, so I removed the cli() brackets
301 QUEUE_BYTE is protected against interrupts */
302 if (copy_from_user((char *) &tmp_data, &(buf)[c], 1)) {
306 QUEUE_BYTE(midi_out_buf[dev], tmp_data);
315 int MIDIbuf_read(int dev, struct file *file, char __user *buf, int count)
318 unsigned char tmp_data;
322 if (!DATA_AVAIL(midi_in_buf[dev])) { /*
325 if (file->f_flags & O_NONBLOCK) {
329 wait_event_interruptible_timeout(input_sleeper[dev],
330 DATA_AVAIL(midi_in_buf[dev]),
331 parms[dev].prech_timeout);
333 if (signal_pending(current))
334 c = -EINTR; /* The user is getting restless */
336 if (c == 0 && DATA_AVAIL(midi_in_buf[dev])) /*
340 n = DATA_AVAIL(midi_in_buf[dev]);
348 REMOVE_BYTE(midi_in_buf[dev], tmp_data);
349 fixit = (char *) &tmp_data;
350 /* BROKE BROKE BROKE */
351 /* yes removed the cli() brackets again
352 should q->len,tail&head be atomic_t? */
353 if (copy_to_user(&(buf)[c], fixit, 1)) {
364 int MIDIbuf_ioctl(int dev, struct file *file,
365 unsigned int cmd, void __user *arg)
371 if (((cmd >> 8) & 0xff) == 'C')
373 if (midi_devs[dev]->coproc) /* Coprocessor ioctl */
374 return midi_devs[dev]->coproc->ioctl(midi_devs[dev]->coproc->devc, cmd, arg, 0);
375 /* printk("/dev/midi%d: No coprocessor for this device\n", dev);*/
382 case SNDCTL_MIDI_PRETIME:
383 if (get_user(val, (int __user *)arg))
387 val = (HZ * val) / 10;
388 parms[dev].prech_timeout = val;
389 return put_user(val, (int __user *)arg);
392 if (!midi_devs[dev]->ioctl)
394 return midi_devs[dev]->ioctl(dev, cmd, arg);
399 /* No kernel lock - fine */
400 unsigned int MIDIbuf_poll(int dev, struct file *file, poll_table * wait)
402 unsigned int mask = 0;
407 poll_wait(file, &input_sleeper[dev], wait);
408 if (DATA_AVAIL(midi_in_buf[dev]))
409 mask |= POLLIN | POLLRDNORM;
412 poll_wait(file, &midi_sleeper[dev], wait);
413 if (!SPACE_AVAIL(midi_out_buf[dev]))
414 mask |= POLLOUT | POLLWRNORM;
420 int MIDIbuf_avail(int dev)
422 if (midi_in_buf[dev])
423 return DATA_AVAIL (midi_in_buf[dev]);
426 EXPORT_SYMBOL(MIDIbuf_avail);