irqreturn_t snd_sb8dsp_midi_interrupt(sb_t * chip)
{
snd_rawmidi_t *rmidi;
int max = 64;
char byte;
if (chip == NULL || (rmidi = chip->rmidi) == NULL) {
inb(SBP(chip, DATA_AVAIL)); /* ack interrupt */
return IRQ_NONE;
}
while (max-- > 0) {
spin_lock(&chip->midi_input_lock);
if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
byte = inb(SBP(chip, READ));
if (chip->open & SB_OPEN_MIDI_INPUT_TRIGGER) {
spin_unlock(&chip->midi_input_lock);
snd_rawmidi_receive(chip->midi_substream_input, &byte, 1);
} else {
spin_unlock(&chip->midi_input_lock);
}
} else {
spin_unlock(&chip->midi_input_lock);
}
}
return IRQ_HANDLED;
}
static void ca_midi_interrupt(struct snd_ca_midi *midi, unsigned int status)
{
unsigned char byte;
if (midi->rmidi == NULL) {
midi->interrupt_disable(midi,midi->tx_enable | midi->rx_enable);
return;
}
spin_lock(&midi->input_lock);
if ((status & midi->ipr_rx) && ca_midi_input_avail(midi)) {
if (!(midi->midi_mode & CA_MIDI_MODE_INPUT)) {
ca_midi_clear_rx(midi);
} else {
byte = ca_midi_read_data(midi);
if(midi->substream_input)
snd_rawmidi_receive(midi->substream_input, &byte, 1);
}
}
spin_unlock(&midi->input_lock);
spin_lock(&midi->output_lock);
if ((status & midi->ipr_tx) && ca_midi_output_ready(midi)) {
if (midi->substream_output &&
snd_rawmidi_transmit(midi->substream_output, &byte, 1) == 1) {
ca_midi_write_data(midi, byte);
} else {
midi->interrupt_disable(midi,midi->tx_enable);
}
}
spin_unlock(&midi->output_lock);
}
static void do_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, unsigned int status)
{
unsigned char byte;
if (midi->rmidi == NULL) {
snd_emu10k1_intr_disable(emu, midi->tx_enable | midi->rx_enable);
return;
}
spin_lock(&midi->input_lock);
if ((status & midi->ipr_rx) && mpu401_input_avail(emu, midi)) {
if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
mpu401_clear_rx(emu, midi);
} else {
byte = mpu401_read_data(emu, midi);
if (midi->substream_input)
snd_rawmidi_receive(midi->substream_input, &byte, 1);
}
}
spin_unlock(&midi->input_lock);
spin_lock(&midi->output_lock);
if ((status & midi->ipr_tx) && mpu401_output_ready(emu, midi)) {
if (midi->substream_output &&
snd_rawmidi_transmit(midi->substream_output, &byte, 1) == 1) {
mpu401_write_data(emu, midi, byte);
} else {
snd_emu10k1_intr_disable(emu, midi->tx_enable);
}
}
spin_unlock(&midi->output_lock);
}
static void snd_gf1_interrupt_midi_in(snd_gus_card_t * gus)
{
int count;
unsigned char stat, data, byte;
unsigned long flags;
count = 10;
while (count) {
spin_lock_irqsave(&gus->uart_cmd_lock, flags);
stat = snd_gf1_uart_stat(gus);
if (!(stat & 0x01)) { /* data in Rx FIFO? */
spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
count--;
continue;
}
count = 100; /* arm counter to new value */
data = snd_gf1_uart_get(gus);
if (!(gus->gf1.uart_cmd & 0x80)) {
spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
continue;
}
if (stat & 0x10) { /* framing error */
gus->gf1.uart_framing++;
spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
continue;
}
byte = snd_gf1_uart_get(gus);
spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
snd_rawmidi_receive(gus->midi_substream_input, &byte, 1);
if (stat & 0x20) {
gus->gf1.uart_overrun++;
}
}
}
void snd_msndmidi_input_read(void *mpuv)
{
unsigned long flags;
struct snd_msndmidi *mpu = mpuv;
void *pwMIDQData = mpu->dev->mappedbase + MIDQ_DATA_BUFF;
spin_lock_irqsave(&mpu->input_lock, flags);
while (readw(mpu->dev->MIDQ + JQS_wTail) !=
readw(mpu->dev->MIDQ + JQS_wHead)) {
u16 wTmp, val;
val = readw(pwMIDQData + 2 * readw(mpu->dev->MIDQ + JQS_wHead));
if (test_bit(MSNDMIDI_MODE_BIT_INPUT_TRIGGER,
&mpu->mode))
snd_rawmidi_receive(mpu->substream_input,
(unsigned char *)&val, 1);
wTmp = readw(mpu->dev->MIDQ + JQS_wHead) + 1;
if (wTmp > readw(mpu->dev->MIDQ + JQS_wSize))
writew(0, mpu->dev->MIDQ + JQS_wHead);
else
writew(wTmp, mpu->dev->MIDQ + JQS_wHead);
}
spin_unlock_irqrestore(&mpu->input_lock, flags);
}
/*
Pass data received via USB to MIDI.
*/
void line6_midi_receive(struct usb_line6 *line6, unsigned char *data,
int length)
{
if (line6->line6midi->substream_receive)
snd_rawmidi_receive(line6->line6midi->substream_receive,
data, length);
}
static void snd_hdjmp3_flush_analogs(struct snd_hdjmidi_out_endpoint* out_ep)
{
int control_num;
int midi_message_to_send;
struct snd_hdjmidi_in_endpoint* in_ep;
struct hdjmidi_in_port* in_port;
if (out_ep->endpoint_number >= MIDI_MAX_ENDPOINTS) {
snd_printk(KERN_INFO"%s(): endpoint number too high:%d, max:%d",
__FUNCTION__,
out_ep->endpoint_number,
MIDI_MAX_ENDPOINTS-1);
return;
}
in_ep = out_ep->umidi->endpoints[out_ep->endpoint_number].in;
if (in_ep==NULL || in_ep->controller_state==NULL) {
return;
}
in_port = &in_ep->ports[0]; /* only 1 port */
if (in_port==NULL) {
return;
}
for(control_num = 0; control_num < DJ_MP3_NUM_INPUT_CONTROLS ; control_num++) {
if (in_ep->controller_state->control_details[control_num].type==TYPE_LINEAR) {
midi_message_to_send = atomic_read(&in_ep->controller_state->control_details[control_num].value);
if (midi_message_to_send &&
test_bit(in_port->substream->number, &in_ep->umidi->input_triggered)) {
snd_rawmidi_receive(in_port->substream,
(unsigned char*)&midi_message_to_send,
3);
}
}
}
}
static void bcd2000_midi_handle_input(struct bcd2000 *bcd2k,
const unsigned char *buf, unsigned int buf_len)
{
unsigned int payload_length, tocopy;
struct snd_rawmidi_substream *midi_receive_substream;
midi_receive_substream = ACCESS_ONCE(bcd2k->midi_receive_substream);
if (!midi_receive_substream)
return;
bcd2000_dump_buffer(PREFIX "received from device: ", buf, buf_len);
if (buf_len < 2)
return;
payload_length = buf[0];
/* ignore packets without payload */
if (payload_length == 0)
return;
tocopy = min(payload_length, buf_len-1);
bcd2000_dump_buffer(PREFIX "sending to userspace: ",
&buf[1], tocopy);
snd_rawmidi_receive(midi_receive_substream,
&buf[1], tocopy);
}
irqreturn_t snd_sb8dsp_midi_interrupt(struct snd_sb *chip)
{
struct snd_rawmidi *rmidi;
int max = 64;
char byte;
if (!chip)
return IRQ_NONE;
rmidi = chip->rmidi;
if (!rmidi) {
inb(SBP(chip, DATA_AVAIL)); /* ack interrupt */
return IRQ_NONE;
}
spin_lock(&chip->midi_input_lock);
while (max-- > 0) {
if (inb(SBP(chip, DATA_AVAIL)) & 0x80) {
byte = inb(SBP(chip, READ));
if (chip->open & SB_OPEN_MIDI_INPUT_TRIGGER) {
snd_rawmidi_receive(chip->midi_substream_input, &byte, 1);
}
}
}
spin_unlock(&chip->midi_input_lock);
return IRQ_HANDLED;
}
void snd_usb_caiaq_midi_handle_input(struct snd_usb_caiaqdev *dev,
int port, const char *buf, int len)
{
if (!dev->midi_receive_substream)
return;
snd_rawmidi_receive(dev->midi_receive_substream, buf, len);
}
static void usb6fire_midi_in_received(
struct midi_runtime *rt, u8 *data, int length)
{
unsigned long flags;
spin_lock_irqsave(&rt->in_lock, flags);
if (rt->in)
snd_rawmidi_receive(rt->in, data, length);
spin_unlock_irqrestore(&rt->in_lock, flags);
}
static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
{
int max = 128;
unsigned char byte;
while (max-- > 0) {
if (! snd_mpu401_input_avail(mpu))
break;
byte = mpu->read(mpu, MPU401D(mpu));
if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
snd_rawmidi_receive(mpu->substream_input, &byte, 1);
}
}
/*
* Receives a chunk of MIDI data.
*/
static void snd_usbmidi_input_data(snd_usb_midi_in_endpoint_t* ep, int portidx,
uint8_t* data, int length)
{
usbmidi_in_port_t* port = &ep->ports[portidx];
if (!port->substream) {
snd_printd("unexpected port %d!\n", portidx);
return;
}
if (!test_bit(port->substream->number, &ep->umidi->input_triggered))
return;
snd_rawmidi_receive(port->substream, data, length);
}
static void ff800_handle_midi_msg(struct snd_ff *ff, __le32 *buf, size_t length)
{
int i;
for (i = 0; i < length / 4; i++) {
u8 byte = le32_to_cpu(buf[i]) & 0xff;
struct snd_rawmidi_substream *substream;
substream = READ_ONCE(ff->tx_midi_substreams[0]);
if (substream)
snd_rawmidi_receive(substream, &byte, 1);
}
}
/*
* Receives a chunk of MIDI data.
*/
static void gmidi_read_data(struct usb_ep *ep, int cable,
uint8_t *data, int length)
{
struct gmidi_device *dev = ep->driver_data;
/* cable is ignored, because for now we only have one. */
if (!dev->out_substream) {
/* Nobody is listening - throw it on the floor. */
return;
}
if (!test_bit(dev->out_substream->number, &dev->out_triggered)) {
return;
}
snd_rawmidi_receive(dev->out_substream, data, length);
}
/*
* transfer input pending data
* call with input_lock spinlock held
*/
static void snd_mpu401_uart_input_read(mpu401_t * mpu)
{
int max = 128;
unsigned char byte;
while (max-- > 0) {
if (snd_mpu401_input_avail(mpu)) {
byte = mpu->read(mpu, MPU401D(mpu));
if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
snd_rawmidi_receive(mpu->substream_input, &byte, 1);
} else {
break; /* input not available */
}
}
}
/*
* Receives a USB MIDI packet.
*/
static void snd_usbmidi_input_packet(snd_usb_midi_in_endpoint_t* ep,
uint8_t packet[4])
{
int cable = packet[0] >> 4;
usbmidi_in_port_t* port = &ep->ports[cable];
if (!port->substream) {
snd_printd("unexpected port %d!\n", cable);
return;
}
if (!port->substream->runtime ||
!port->substream->runtime->trigger)
return;
snd_rawmidi_receive(port->substream, &packet[1],
snd_usbmidi_cin_length[packet[0] & 0x0f]);
}
static void read_midi_messages(struct amdtp_stream *s,
__be32 *buffer, unsigned int frames)
{
struct amdtp_am824 *p = s->protocol;
unsigned int f, port;
int len;
u8 *b;
for (f = 0; f < frames; f++) {
port = (s->data_block_counter + f) % 8;
b = (u8 *)&buffer[p->midi_position];
len = b[0] - 0x80;
if ((1 <= len) && (len <= 3) && (p->midi[port]))
snd_rawmidi_receive(p->midi[port], b + 1, len);
buffer += s->data_block_quadlets;
}
}
/* This loop should be called with interrupts disabled
* We don't want to interrupt this,
* as we're already handling an interupt
*/
static void snd_uart16550_io_loop(snd_uart16550_t * uart)
{
unsigned char c, status;
/* Read Loop */
while ((status = inb(uart->base + UART_LSR)) & UART_LSR_DR) {
/* while receive data ready */
c = inb(uart->base + UART_RX);
if (uart->filemode & SERIAL_MODE_INPUT_OPEN) {
snd_rawmidi_receive(uart->midi_input, &c, 1);
}
if (status & UART_LSR_OE)
snd_printk("%s: Overrun on device at 0x%lx\n",
uart->rmidi->name, uart->base);
}
/* no need of check SERIAL_MODE_OUTPUT_OPEN because if not,
buffer is never filled. */
/* Check write status */
if (status & UART_LSR_THRE) {
uart->fifo_count = 0;
}
if (uart->adaptor == SNDRV_SERIAL_MS124W_SA) {
/* Can't use FIFO, must send only when CTS is true */
status = inb(uart->base + UART_MSR);
if (uart->fifo_count == 0 && (status & UART_MSR_CTS)
&& uart->buff_in_count > 0)
snd_uart16550_buffer_output(uart);
} else {
/* Write loop */
while (uart->fifo_count < uart->fifo_limit /* Can we write ? */
&& uart->buff_in_count > 0) /* Do we want to? */
snd_uart16550_buffer_output(uart);
}
if (uart->irq < 0 && uart->buff_in_count > 0)
snd_uart16550_add_timer(uart);
}
/* This loop should be called with interrupts disabled
* We don't want to interrupt this,
* as we're already handling an interrupt
*/
static void snd_uart16550_io_loop(snd_uart16550_t * uart)
{
unsigned char c, status;
int substream;
/* recall previous stream */
substream = uart->prev_in;
/* Read Loop */
while ((status = inb(uart->base + UART_LSR)) & UART_LSR_DR) {
/* while receive data ready */
c = inb(uart->base + UART_RX);
/* keep track of last status byte */
if (c & 0x80) {
uart->rstatus = c;
}
/* handle stream switch */
if (uart->adaptor == SNDRV_SERIAL_GENERIC) {
if (uart->rstatus == 0xf5) {
if (c <= SNDRV_SERIAL_MAX_INS && c > 0)
substream = c - 1;
if (c != 0xf5)
uart->rstatus = 0; /* prevent future bytes from being interpreted as streams */
}
else if ((uart->filemode & SERIAL_MODE_INPUT_OPEN) && (uart->midi_input[substream] != NULL)) {
snd_rawmidi_receive(uart->midi_input[substream], &c, 1);
}
} else if ((uart->filemode & SERIAL_MODE_INPUT_OPEN) && (uart->midi_input[substream] != NULL)) {
snd_rawmidi_receive(uart->midi_input[substream], &c, 1);
}
if (status & UART_LSR_OE)
snd_printk("%s: Overrun on device at 0x%lx\n",
uart->rmidi->name, uart->base);
}
/* remember the last stream */
uart->prev_in = substream;
/* no need of check SERIAL_MODE_OUTPUT_OPEN because if not,
buffer is never filled. */
/* Check write status */
if (status & UART_LSR_THRE) {
uart->fifo_count = 0;
}
if (uart->adaptor == SNDRV_SERIAL_MS124W_SA
|| uart->adaptor == SNDRV_SERIAL_GENERIC) {
/* Can't use FIFO, must send only when CTS is true */
status = inb(uart->base + UART_MSR);
while( (uart->fifo_count == 0) && (status & UART_MSR_CTS) &&
(uart->buff_in_count > 0) ) {
snd_uart16550_buffer_output(uart);
status = inb( uart->base + UART_MSR );
}
} else {
/* Write loop */
while (uart->fifo_count < uart->fifo_limit /* Can we write ? */
&& uart->buff_in_count > 0) /* Do we want to? */
snd_uart16550_buffer_output(uart);
}
if (uart->irq < 0 && uart->buff_in_count > 0)
snd_uart16550_add_timer(uart);
}