| // SPDX-License-Identifier: GPL-2.0-or-later |
| /* |
| * Copyright (c) by Jaroslav Kysela <perex@perex.cz> |
| * Routines for the GF1 MIDI interface - like UART 6850 |
| */ |
| |
| #include <linux/delay.h> |
| #include <linux/interrupt.h> |
| #include <linux/time.h> |
| #include <sound/core.h> |
| #include <sound/gus.h> |
| |
| static void snd_gf1_interrupt_midi_in(struct snd_gus_card * gus) |
| { |
| int count; |
| unsigned char stat, byte; |
| __always_unused unsigned char data; |
| 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++; |
| } |
| } |
| } |
| |
| static void snd_gf1_interrupt_midi_out(struct snd_gus_card * gus) |
| { |
| char byte; |
| unsigned long flags; |
| |
| /* try unlock output */ |
| if (snd_gf1_uart_stat(gus) & 0x01) |
| snd_gf1_interrupt_midi_in(gus); |
| |
| spin_lock_irqsave(&gus->uart_cmd_lock, flags); |
| if (snd_gf1_uart_stat(gus) & 0x02) { /* Tx FIFO free? */ |
| if (snd_rawmidi_transmit(gus->midi_substream_output, &byte, 1) != 1) { /* no other bytes or error */ |
| snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd & ~0x20); /* disable Tx interrupt */ |
| } else { |
| snd_gf1_uart_put(gus, byte); |
| } |
| } |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| } |
| |
| static void snd_gf1_uart_reset(struct snd_gus_card * gus, int close) |
| { |
| snd_gf1_uart_cmd(gus, 0x03); /* reset */ |
| if (!close && gus->uart_enable) { |
| udelay(160); |
| snd_gf1_uart_cmd(gus, 0x00); /* normal operations */ |
| } |
| } |
| |
| static int snd_gf1_uart_output_open(struct snd_rawmidi_substream *substream) |
| { |
| unsigned long flags; |
| struct snd_gus_card *gus; |
| |
| gus = substream->rmidi->private_data; |
| spin_lock_irqsave(&gus->uart_cmd_lock, flags); |
| if (!(gus->gf1.uart_cmd & 0x80)) { /* input active? */ |
| snd_gf1_uart_reset(gus, 0); |
| } |
| gus->gf1.interrupt_handler_midi_out = snd_gf1_interrupt_midi_out; |
| gus->midi_substream_output = substream; |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| #if 0 |
| snd_printk(KERN_DEBUG "write init - cmd = 0x%x, stat = 0x%x\n", gus->gf1.uart_cmd, snd_gf1_uart_stat(gus)); |
| #endif |
| return 0; |
| } |
| |
| static int snd_gf1_uart_input_open(struct snd_rawmidi_substream *substream) |
| { |
| unsigned long flags; |
| struct snd_gus_card *gus; |
| int i; |
| |
| gus = substream->rmidi->private_data; |
| spin_lock_irqsave(&gus->uart_cmd_lock, flags); |
| if (gus->gf1.interrupt_handler_midi_out != snd_gf1_interrupt_midi_out) { |
| snd_gf1_uart_reset(gus, 0); |
| } |
| gus->gf1.interrupt_handler_midi_in = snd_gf1_interrupt_midi_in; |
| gus->midi_substream_input = substream; |
| if (gus->uart_enable) { |
| for (i = 0; i < 1000 && (snd_gf1_uart_stat(gus) & 0x01); i++) |
| snd_gf1_uart_get(gus); /* clean Rx */ |
| if (i >= 1000) |
| snd_printk(KERN_ERR "gus midi uart init read - cleanup error\n"); |
| } |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| #if 0 |
| snd_printk(KERN_DEBUG |
| "read init - enable = %i, cmd = 0x%x, stat = 0x%x\n", |
| gus->uart_enable, gus->gf1.uart_cmd, snd_gf1_uart_stat(gus)); |
| snd_printk(KERN_DEBUG |
| "[0x%x] reg (ctrl/status) = 0x%x, reg (data) = 0x%x " |
| "(page = 0x%x)\n", |
| gus->gf1.port + 0x100, inb(gus->gf1.port + 0x100), |
| inb(gus->gf1.port + 0x101), inb(gus->gf1.port + 0x102)); |
| #endif |
| return 0; |
| } |
| |
| static int snd_gf1_uart_output_close(struct snd_rawmidi_substream *substream) |
| { |
| unsigned long flags; |
| struct snd_gus_card *gus; |
| |
| gus = substream->rmidi->private_data; |
| spin_lock_irqsave(&gus->uart_cmd_lock, flags); |
| if (gus->gf1.interrupt_handler_midi_in != snd_gf1_interrupt_midi_in) |
| snd_gf1_uart_reset(gus, 1); |
| snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_MIDI_OUT); |
| gus->midi_substream_output = NULL; |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| return 0; |
| } |
| |
| static int snd_gf1_uart_input_close(struct snd_rawmidi_substream *substream) |
| { |
| unsigned long flags; |
| struct snd_gus_card *gus; |
| |
| gus = substream->rmidi->private_data; |
| spin_lock_irqsave(&gus->uart_cmd_lock, flags); |
| if (gus->gf1.interrupt_handler_midi_out != snd_gf1_interrupt_midi_out) |
| snd_gf1_uart_reset(gus, 1); |
| snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_MIDI_IN); |
| gus->midi_substream_input = NULL; |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| return 0; |
| } |
| |
| static void snd_gf1_uart_input_trigger(struct snd_rawmidi_substream *substream, int up) |
| { |
| struct snd_gus_card *gus; |
| unsigned long flags; |
| |
| gus = substream->rmidi->private_data; |
| |
| spin_lock_irqsave(&gus->uart_cmd_lock, flags); |
| if (up) { |
| if ((gus->gf1.uart_cmd & 0x80) == 0) |
| snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd | 0x80); /* enable Rx interrupts */ |
| } else { |
| if (gus->gf1.uart_cmd & 0x80) |
| snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd & ~0x80); /* disable Rx interrupts */ |
| } |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| } |
| |
| static void snd_gf1_uart_output_trigger(struct snd_rawmidi_substream *substream, int up) |
| { |
| unsigned long flags; |
| struct snd_gus_card *gus; |
| char byte; |
| int timeout; |
| |
| gus = substream->rmidi->private_data; |
| |
| spin_lock_irqsave(&gus->uart_cmd_lock, flags); |
| if (up) { |
| if ((gus->gf1.uart_cmd & 0x20) == 0) { |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| /* wait for empty Rx - Tx is probably unlocked */ |
| timeout = 10000; |
| while (timeout-- > 0 && snd_gf1_uart_stat(gus) & 0x01); |
| /* Tx FIFO free? */ |
| spin_lock_irqsave(&gus->uart_cmd_lock, flags); |
| if (gus->gf1.uart_cmd & 0x20) { |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| return; |
| } |
| if (snd_gf1_uart_stat(gus) & 0x02) { |
| if (snd_rawmidi_transmit(substream, &byte, 1) != 1) { |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| return; |
| } |
| snd_gf1_uart_put(gus, byte); |
| } |
| snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd | 0x20); /* enable Tx interrupt */ |
| } |
| } else { |
| if (gus->gf1.uart_cmd & 0x20) |
| snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd & ~0x20); |
| } |
| spin_unlock_irqrestore(&gus->uart_cmd_lock, flags); |
| } |
| |
| static const struct snd_rawmidi_ops snd_gf1_uart_output = |
| { |
| .open = snd_gf1_uart_output_open, |
| .close = snd_gf1_uart_output_close, |
| .trigger = snd_gf1_uart_output_trigger, |
| }; |
| |
| static const struct snd_rawmidi_ops snd_gf1_uart_input = |
| { |
| .open = snd_gf1_uart_input_open, |
| .close = snd_gf1_uart_input_close, |
| .trigger = snd_gf1_uart_input_trigger, |
| }; |
| |
| int snd_gf1_rawmidi_new(struct snd_gus_card *gus, int device) |
| { |
| struct snd_rawmidi *rmidi; |
| int err; |
| |
| err = snd_rawmidi_new(gus->card, "GF1", device, 1, 1, &rmidi); |
| if (err < 0) |
| return err; |
| strcpy(rmidi->name, gus->interwave ? "AMD InterWave" : "GF1"); |
| snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_gf1_uart_output); |
| snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_gf1_uart_input); |
| rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; |
| rmidi->private_data = gus; |
| gus->midi_uart = rmidi; |
| return err; |
| } |