~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/isa/gus/gus_uart.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  3  *  Routines for the GF1 MIDI interface - like UART 6850
  4  *
  5  *
  6  *   This program is free software; you can redistribute it and/or modify
  7  *   it under the terms of the GNU General Public License as published by
  8  *   the Free Software Foundation; either version 2 of the License, or
  9  *   (at your option) any later version.
 10  *
 11  *   This program is distributed in the hope that it will be useful,
 12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14  *   GNU General Public License for more details.
 15  *
 16  *   You should have received a copy of the GNU General Public License
 17  *   along with this program; if not, write to the Free Software
 18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 19  *
 20  */
 21 
 22 #include <linux/delay.h>
 23 #include <linux/interrupt.h>
 24 #include <linux/time.h>
 25 #include <sound/core.h>
 26 #include <sound/gus.h>
 27 
 28 static void snd_gf1_interrupt_midi_in(struct snd_gus_card * gus)
 29 {
 30         int count;
 31         unsigned char stat, data, byte;
 32         unsigned long flags;
 33 
 34         count = 10;
 35         while (count) {
 36                 spin_lock_irqsave(&gus->uart_cmd_lock, flags);
 37                 stat = snd_gf1_uart_stat(gus);
 38                 if (!(stat & 0x01)) {   /* data in Rx FIFO? */
 39                         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
 40                         count--;
 41                         continue;
 42                 }
 43                 count = 100;    /* arm counter to new value */
 44                 data = snd_gf1_uart_get(gus);
 45                 if (!(gus->gf1.uart_cmd & 0x80)) {
 46                         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
 47                         continue;
 48                 }                       
 49                 if (stat & 0x10) {      /* framing error */
 50                         gus->gf1.uart_framing++;
 51                         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
 52                         continue;
 53                 }
 54                 byte = snd_gf1_uart_get(gus);
 55                 spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
 56                 snd_rawmidi_receive(gus->midi_substream_input, &byte, 1);
 57                 if (stat & 0x20) {
 58                         gus->gf1.uart_overrun++;
 59                 }
 60         }
 61 }
 62 
 63 static void snd_gf1_interrupt_midi_out(struct snd_gus_card * gus)
 64 {
 65         char byte;
 66         unsigned long flags;
 67 
 68         /* try unlock output */
 69         if (snd_gf1_uart_stat(gus) & 0x01)
 70                 snd_gf1_interrupt_midi_in(gus);
 71 
 72         spin_lock_irqsave(&gus->uart_cmd_lock, flags);
 73         if (snd_gf1_uart_stat(gus) & 0x02) {    /* Tx FIFO free? */
 74                 if (snd_rawmidi_transmit(gus->midi_substream_output, &byte, 1) != 1) {  /* no other bytes or error */
 75                         snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd & ~0x20); /* disable Tx interrupt */
 76                 } else {
 77                         snd_gf1_uart_put(gus, byte);
 78                 }
 79         }
 80         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
 81 }
 82 
 83 static void snd_gf1_uart_reset(struct snd_gus_card * gus, int close)
 84 {
 85         snd_gf1_uart_cmd(gus, 0x03);    /* reset */
 86         if (!close && gus->uart_enable) {
 87                 udelay(160);
 88                 snd_gf1_uart_cmd(gus, 0x00);    /* normal operations */
 89         }
 90 }
 91 
 92 static int snd_gf1_uart_output_open(struct snd_rawmidi_substream *substream)
 93 {
 94         unsigned long flags;
 95         struct snd_gus_card *gus;
 96 
 97         gus = substream->rmidi->private_data;
 98         spin_lock_irqsave(&gus->uart_cmd_lock, flags);
 99         if (!(gus->gf1.uart_cmd & 0x80)) {      /* input active? */
100                 snd_gf1_uart_reset(gus, 0);
101         }
102         gus->gf1.interrupt_handler_midi_out = snd_gf1_interrupt_midi_out;
103         gus->midi_substream_output = substream;
104         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
105 #if 0
106         snd_printk(KERN_DEBUG "write init - cmd = 0x%x, stat = 0x%x\n", gus->gf1.uart_cmd, snd_gf1_uart_stat(gus));
107 #endif
108         return 0;
109 }
110 
111 static int snd_gf1_uart_input_open(struct snd_rawmidi_substream *substream)
112 {
113         unsigned long flags;
114         struct snd_gus_card *gus;
115         int i;
116 
117         gus = substream->rmidi->private_data;
118         spin_lock_irqsave(&gus->uart_cmd_lock, flags);
119         if (gus->gf1.interrupt_handler_midi_out != snd_gf1_interrupt_midi_out) {
120                 snd_gf1_uart_reset(gus, 0);
121         }
122         gus->gf1.interrupt_handler_midi_in = snd_gf1_interrupt_midi_in;
123         gus->midi_substream_input = substream;
124         if (gus->uart_enable) {
125                 for (i = 0; i < 1000 && (snd_gf1_uart_stat(gus) & 0x01); i++)
126                         snd_gf1_uart_get(gus);  /* clean Rx */
127                 if (i >= 1000)
128                         snd_printk(KERN_ERR "gus midi uart init read - cleanup error\n");
129         }
130         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
131 #if 0
132         snd_printk(KERN_DEBUG
133                    "read init - enable = %i, cmd = 0x%x, stat = 0x%x\n",
134                    gus->uart_enable, gus->gf1.uart_cmd, snd_gf1_uart_stat(gus));
135         snd_printk(KERN_DEBUG
136                    "[0x%x] reg (ctrl/status) = 0x%x, reg (data) = 0x%x "
137                    "(page = 0x%x)\n",
138                    gus->gf1.port + 0x100, inb(gus->gf1.port + 0x100),
139                    inb(gus->gf1.port + 0x101), inb(gus->gf1.port + 0x102));
140 #endif
141         return 0;
142 }
143 
144 static int snd_gf1_uart_output_close(struct snd_rawmidi_substream *substream)
145 {
146         unsigned long flags;
147         struct snd_gus_card *gus;
148 
149         gus = substream->rmidi->private_data;
150         spin_lock_irqsave(&gus->uart_cmd_lock, flags);
151         if (gus->gf1.interrupt_handler_midi_in != snd_gf1_interrupt_midi_in)
152                 snd_gf1_uart_reset(gus, 1);
153         snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_MIDI_OUT);
154         gus->midi_substream_output = NULL;
155         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
156         return 0;
157 }
158 
159 static int snd_gf1_uart_input_close(struct snd_rawmidi_substream *substream)
160 {
161         unsigned long flags;
162         struct snd_gus_card *gus;
163 
164         gus = substream->rmidi->private_data;
165         spin_lock_irqsave(&gus->uart_cmd_lock, flags);
166         if (gus->gf1.interrupt_handler_midi_out != snd_gf1_interrupt_midi_out)
167                 snd_gf1_uart_reset(gus, 1);
168         snd_gf1_set_default_handlers(gus, SNDRV_GF1_HANDLER_MIDI_IN);
169         gus->midi_substream_input = NULL;
170         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
171         return 0;
172 }
173 
174 static void snd_gf1_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
175 {
176         struct snd_gus_card *gus;
177         unsigned long flags;
178 
179         gus = substream->rmidi->private_data;
180 
181         spin_lock_irqsave(&gus->uart_cmd_lock, flags);
182         if (up) {
183                 if ((gus->gf1.uart_cmd & 0x80) == 0)
184                         snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd | 0x80); /* enable Rx interrupts */
185         } else {
186                 if (gus->gf1.uart_cmd & 0x80)
187                         snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd & ~0x80); /* disable Rx interrupts */
188         }
189         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
190 }
191 
192 static void snd_gf1_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
193 {
194         unsigned long flags;
195         struct snd_gus_card *gus;
196         char byte;
197         int timeout;
198 
199         gus = substream->rmidi->private_data;
200 
201         spin_lock_irqsave(&gus->uart_cmd_lock, flags);
202         if (up) {
203                 if ((gus->gf1.uart_cmd & 0x20) == 0) {
204                         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
205                         /* wait for empty Rx - Tx is probably unlocked */
206                         timeout = 10000;
207                         while (timeout-- > 0 && snd_gf1_uart_stat(gus) & 0x01);
208                         /* Tx FIFO free? */
209                         spin_lock_irqsave(&gus->uart_cmd_lock, flags);
210                         if (gus->gf1.uart_cmd & 0x20) {
211                                 spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
212                                 return;
213                         }
214                         if (snd_gf1_uart_stat(gus) & 0x02) {
215                                 if (snd_rawmidi_transmit(substream, &byte, 1) != 1) {
216                                         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
217                                         return;
218                                 }
219                                 snd_gf1_uart_put(gus, byte);
220                         }
221                         snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd | 0x20);        /* enable Tx interrupt */
222                 }
223         } else {
224                 if (gus->gf1.uart_cmd & 0x20)
225                         snd_gf1_uart_cmd(gus, gus->gf1.uart_cmd & ~0x20);
226         }
227         spin_unlock_irqrestore(&gus->uart_cmd_lock, flags);
228 }
229 
230 static struct snd_rawmidi_ops snd_gf1_uart_output =
231 {
232         .open =         snd_gf1_uart_output_open,
233         .close =        snd_gf1_uart_output_close,
234         .trigger =      snd_gf1_uart_output_trigger,
235 };
236 
237 static struct snd_rawmidi_ops snd_gf1_uart_input =
238 {
239         .open =         snd_gf1_uart_input_open,
240         .close =        snd_gf1_uart_input_close,
241         .trigger =      snd_gf1_uart_input_trigger,
242 };
243 
244 int snd_gf1_rawmidi_new(struct snd_gus_card *gus, int device)
245 {
246         struct snd_rawmidi *rmidi;
247         int err;
248 
249         if ((err = snd_rawmidi_new(gus->card, "GF1", device, 1, 1, &rmidi)) < 0)
250                 return err;
251         strcpy(rmidi->name, gus->interwave ? "AMD InterWave" : "GF1");
252         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_gf1_uart_output);
253         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_gf1_uart_input);
254         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
255         rmidi->private_data = gus;
256         gus->midi_uart = rmidi;
257         return err;
258 }
259 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp