WSL2-Linux-Kernel/sound/oss/pas2_midi.c

/*
 * sound/oss/pas2_midi.c
 *
 * The low level driver for the PAS Midi Interface.
 */
/*
 * 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.
 *
 * Bartlomiej Zolnierkiewicz	: Added __init to pas_init_mixer()
 */

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

#include "pas2.h"

extern spinlock_t pas_lock;

static int      midi_busy, input_opened;
static int      my_dev;

int pas2_mididev=-1;

static unsigned char tmp_queue[256];
static volatile int qlen;
static volatile unsigned char qhead, qtail;

static void     (*midi_input_intr) (int dev, unsigned char data);

static int pas_midi_open(int dev, int mode,
	      void            (*input) (int dev, unsigned char data),
	      void            (*output) (int dev)
)
{
	int             err;
	unsigned long   flags;
	unsigned char   ctrl;


	if (midi_busy)
		return -EBUSY;

	/*
	 * Reset input and output FIFO pointers
	 */
	pas_write(0x20 | 0x40,
		  0x178b);

	spin_lock_irqsave(&pas_lock, flags);

	if ((err = pas_set_intr(0x10)) < 0)
	{
		spin_unlock_irqrestore(&pas_lock, flags);
		return err;
	}
	/*
	 * Enable input available and output FIFO empty interrupts
	 */

	ctrl = 0;
	input_opened = 0;
	midi_input_intr = input;

	if (mode == OPEN_READ || mode == OPEN_READWRITE)
	{
		ctrl |= 0x04;	/* Enable input */
		input_opened = 1;
	}
	if (mode == OPEN_WRITE || mode == OPEN_READWRITE)
	{
		ctrl |= 0x08 | 0x10;	/* Enable output */
	}
	pas_write(ctrl, 0x178b);

	/*
	 * Acknowledge any pending interrupts
	 */

	pas_write(0xff, 0x1B88);

	spin_unlock_irqrestore(&pas_lock, flags);

	midi_busy = 1;
	qlen = qhead = qtail = 0;
	return 0;
}

static void pas_midi_close(int dev)
{

	/*
	 * Reset FIFO pointers, disable intrs
	 */
	pas_write(0x20 | 0x40, 0x178b);

	pas_remove_intr(0x10);
	midi_busy = 0;
}

static int dump_to_midi(unsigned char midi_byte)
{
	int fifo_space, x;

	fifo_space = ((x = pas_read(0x1B89)) >> 4) & 0x0f;

	/*
	 * The MIDI FIFO space register and it's documentation is nonunderstandable.
	 * There seem to be no way to differentiate between buffer full and buffer
	 * empty situations. For this reason we don't never write the buffer
	 * completely full. In this way we can assume that 0 (or is it 15)
	 * means that the buffer is empty.
	 */

	if (fifo_space < 2 && fifo_space != 0)	/* Full (almost) */
		return 0;	/* Ask upper layers to retry after some time */

	pas_write(midi_byte, 0x178A);

	return 1;
}

static int pas_midi_out(int dev, unsigned char midi_byte)
{

	unsigned long flags;

	/*
	 * Drain the local queue first
	 */

	spin_lock_irqsave(&pas_lock, flags);

	while (qlen && dump_to_midi(tmp_queue[qhead]))
	{
		qlen--;
		qhead++;
	}

	spin_unlock_irqrestore(&pas_lock, flags);

	/*
	 *	Output the byte if the local queue is empty.
	 */

	if (!qlen)
		if (dump_to_midi(midi_byte))
			return 1;

	/*
	 *	Put to the local queue
	 */

	if (qlen >= 256)
		return 0;	/* Local queue full */

	spin_lock_irqsave(&pas_lock, flags);

	tmp_queue[qtail] = midi_byte;
	qlen++;
	qtail++;

	spin_unlock_irqrestore(&pas_lock, flags);

	return 1;
}

static int pas_midi_start_read(int dev)
{
	return 0;
}

static int pas_midi_end_read(int dev)
{
	return 0;
}

static void pas_midi_kick(int dev)
{
}

static int pas_buffer_status(int dev)
{
	return qlen;
}

#define MIDI_SYNTH_NAME	"Pro Audio Spectrum Midi"
#define MIDI_SYNTH_CAPS	SYNTH_CAP_INPUT
#include "midi_synth.h"

static struct midi_operations pas_midi_operations =
{
	.owner		= THIS_MODULE,
	.info		= {"Pro Audio Spectrum", 0, 0, SNDCARD_PAS},
	.converter	= &std_midi_synth,
	.in_info	= {0},
	.open		= pas_midi_open,
	.close		= pas_midi_close,
	.outputc	= pas_midi_out,
	.start_read	= pas_midi_start_read,
	.end_read	= pas_midi_end_read,
	.kick		= pas_midi_kick,
	.buffer_status	= pas_buffer_status,
};

void __init pas_midi_init(void)
{
	int dev = sound_alloc_mididev();

	if (dev == -1)
	{
		printk(KERN_WARNING "pas_midi_init: Too many midi devices detected\n");
		return;
	}
	std_midi_synth.midi_dev = my_dev = dev;
	midi_devs[dev] = &pas_midi_operations;
	pas2_mididev = dev;
	sequencer_init();
}

void pas_midi_interrupt(void)
{
	unsigned char   stat;
	int             i, incount;

	stat = pas_read(0x1B88);

	if (stat & 0x04)	/* Input data available */
	{
		incount = pas_read(0x1B89) & 0x0f;	/* Input FIFO size */
		if (!incount)
			incount = 16;

		for (i = 0; i < incount; i++)
			if (input_opened)
			{
				midi_input_intr(my_dev, pas_read(0x178A));
			} else
				pas_read(0x178A);	/* Flush */
	}
	if (stat & (0x08 | 0x10))
	{
		spin_lock(&pas_lock);/* called in irq context */

		while (qlen && dump_to_midi(tmp_queue[qhead]))
		{
			qlen--;
			qhead++;
		}

		spin_unlock(&pas_lock);
	}
	if (stat & 0x40)
	{
		printk(KERN_WARNING "MIDI output overrun %x,%x\n", pas_read(0x1B89), stat);
	}
	pas_write(stat, 0x1B88);	/* Acknowledge interrupts */
}