1 /****************************************************************************
2
3 Copyright Echo Digital Audio Corporation (c) 1998 - 2004
4 All rights reserved
5 www.echoaudio.com
6
7 This file is part of Echo Digital Audio's generic driver library.
8
9 Echo Digital Audio's generic driver library is free software;
10 you can redistribute it and/or modify it under the terms of
11 the GNU General Public License as published by the Free Software
12 Foundation.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
22 MA 02111-1307, USA.
23
24 *************************************************************************
25
26 Translation from C++ and adaptation for use in ALSA-Driver
27 were made by Giuliano Pochini <pochini@shiny.it>
28
29 ****************************************************************************/
30
31
32 /******************************************************************************
33 MIDI lowlevel code
34 ******************************************************************************/
35
36 /* Start and stop Midi input */
enable_midi_input(struct echoaudio * chip,char enable)37 static int enable_midi_input(struct echoaudio *chip, char enable)
38 {
39 dev_dbg(chip->card->dev, "enable_midi_input(%d)\n", enable);
40
41 if (wait_handshake(chip))
42 return -EIO;
43
44 if (enable) {
45 chip->mtc_state = MIDI_IN_STATE_NORMAL;
46 chip->comm_page->flags |=
47 cpu_to_le32(DSP_FLAG_MIDI_INPUT);
48 } else
49 chip->comm_page->flags &=
50 ~cpu_to_le32(DSP_FLAG_MIDI_INPUT);
51
52 clear_handshake(chip);
53 return send_vector(chip, DSP_VC_UPDATE_FLAGS);
54 }
55
56
57
58 /* Send a buffer full of MIDI data to the DSP
59 Returns how many actually written or < 0 on error */
write_midi(struct echoaudio * chip,u8 * data,int bytes)60 static int write_midi(struct echoaudio *chip, u8 *data, int bytes)
61 {
62 if (snd_BUG_ON(bytes <= 0 || bytes >= MIDI_OUT_BUFFER_SIZE))
63 return -EINVAL;
64
65 if (wait_handshake(chip))
66 return -EIO;
67
68 /* HF4 indicates that it is safe to write MIDI output data */
69 if (! (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_REG_HF4))
70 return 0;
71
72 chip->comm_page->midi_output[0] = bytes;
73 memcpy(&chip->comm_page->midi_output[1], data, bytes);
74 chip->comm_page->midi_out_free_count = 0;
75 clear_handshake(chip);
76 send_vector(chip, DSP_VC_MIDI_WRITE);
77 dev_dbg(chip->card->dev, "write_midi: %d\n", bytes);
78 return bytes;
79 }
80
81
82
83 /* Run the state machine for MIDI input data
84 MIDI time code sync isn't supported by this code right now, but you still need
85 this state machine to parse the incoming MIDI data stream. Every time the DSP
86 sees a 0xF1 byte come in, it adds the DSP sample position to the MIDI data
87 stream. The DSP sample position is represented as a 32 bit unsigned value,
88 with the high 16 bits first, followed by the low 16 bits. Since these aren't
89 real MIDI bytes, the following logic is needed to skip them. */
mtc_process_data(struct echoaudio * chip,short midi_byte)90 static inline int mtc_process_data(struct echoaudio *chip, short midi_byte)
91 {
92 switch (chip->mtc_state) {
93 case MIDI_IN_STATE_NORMAL:
94 if (midi_byte == 0xF1)
95 chip->mtc_state = MIDI_IN_STATE_TS_HIGH;
96 break;
97 case MIDI_IN_STATE_TS_HIGH:
98 chip->mtc_state = MIDI_IN_STATE_TS_LOW;
99 return MIDI_IN_SKIP_DATA;
100 break;
101 case MIDI_IN_STATE_TS_LOW:
102 chip->mtc_state = MIDI_IN_STATE_F1_DATA;
103 return MIDI_IN_SKIP_DATA;
104 break;
105 case MIDI_IN_STATE_F1_DATA:
106 chip->mtc_state = MIDI_IN_STATE_NORMAL;
107 break;
108 }
109 return 0;
110 }
111
112
113
114 /* This function is called from the IRQ handler and it reads the midi data
115 from the DSP's buffer. It returns the number of bytes received. */
midi_service_irq(struct echoaudio * chip)116 static int midi_service_irq(struct echoaudio *chip)
117 {
118 short int count, midi_byte, i, received;
119
120 /* The count is at index 0, followed by actual data */
121 count = le16_to_cpu(chip->comm_page->midi_input[0]);
122
123 if (snd_BUG_ON(count >= MIDI_IN_BUFFER_SIZE))
124 return 0;
125
126 /* Get the MIDI data from the comm page */
127 received = 0;
128 for (i = 1; i <= count; i++) {
129 /* Get the MIDI byte */
130 midi_byte = le16_to_cpu(chip->comm_page->midi_input[i]);
131
132 /* Parse the incoming MIDI stream. The incoming MIDI data
133 consists of MIDI bytes and timestamps for the MIDI time code
134 0xF1 bytes. mtc_process_data() is a little state machine that
135 parses the stream. If you get MIDI_IN_SKIP_DATA back, then
136 this is a timestamp byte, not a MIDI byte, so don't store it
137 in the MIDI input buffer. */
138 if (mtc_process_data(chip, midi_byte) == MIDI_IN_SKIP_DATA)
139 continue;
140
141 chip->midi_buffer[received++] = (u8)midi_byte;
142 }
143
144 return received;
145 }
146
147
148
149
150 /******************************************************************************
151 MIDI interface
152 ******************************************************************************/
153
snd_echo_midi_input_open(struct snd_rawmidi_substream * substream)154 static int snd_echo_midi_input_open(struct snd_rawmidi_substream *substream)
155 {
156 struct echoaudio *chip = substream->rmidi->private_data;
157
158 chip->midi_in = substream;
159 return 0;
160 }
161
162
163
snd_echo_midi_input_trigger(struct snd_rawmidi_substream * substream,int up)164 static void snd_echo_midi_input_trigger(struct snd_rawmidi_substream *substream,
165 int up)
166 {
167 struct echoaudio *chip = substream->rmidi->private_data;
168
169 if (up != chip->midi_input_enabled) {
170 spin_lock_irq(&chip->lock);
171 enable_midi_input(chip, up);
172 spin_unlock_irq(&chip->lock);
173 chip->midi_input_enabled = up;
174 }
175 }
176
177
178
snd_echo_midi_input_close(struct snd_rawmidi_substream * substream)179 static int snd_echo_midi_input_close(struct snd_rawmidi_substream *substream)
180 {
181 struct echoaudio *chip = substream->rmidi->private_data;
182
183 chip->midi_in = NULL;
184 return 0;
185 }
186
187
188
snd_echo_midi_output_open(struct snd_rawmidi_substream * substream)189 static int snd_echo_midi_output_open(struct snd_rawmidi_substream *substream)
190 {
191 struct echoaudio *chip = substream->rmidi->private_data;
192
193 chip->tinuse = 0;
194 chip->midi_full = 0;
195 chip->midi_out = substream;
196 return 0;
197 }
198
199
200
snd_echo_midi_output_write(struct timer_list * t)201 static void snd_echo_midi_output_write(struct timer_list *t)
202 {
203 struct echoaudio *chip = from_timer(chip, t, timer);
204 unsigned long flags;
205 int bytes, sent, time;
206 unsigned char buf[MIDI_OUT_BUFFER_SIZE - 1];
207
208 /* No interrupts are involved: we have to check at regular intervals
209 if the card's output buffer has room for new data. */
210 sent = 0;
211 spin_lock_irqsave(&chip->lock, flags);
212 chip->midi_full = 0;
213 if (!snd_rawmidi_transmit_empty(chip->midi_out)) {
214 bytes = snd_rawmidi_transmit_peek(chip->midi_out, buf,
215 MIDI_OUT_BUFFER_SIZE - 1);
216 dev_dbg(chip->card->dev, "Try to send %d bytes...\n", bytes);
217 sent = write_midi(chip, buf, bytes);
218 if (sent < 0) {
219 dev_err(chip->card->dev,
220 "write_midi() error %d\n", sent);
221 /* retry later */
222 sent = 9000;
223 chip->midi_full = 1;
224 } else if (sent > 0) {
225 dev_dbg(chip->card->dev, "%d bytes sent\n", sent);
226 snd_rawmidi_transmit_ack(chip->midi_out, sent);
227 } else {
228 /* Buffer is full. DSP's internal buffer is 64 (128 ?)
229 bytes long. Let's wait until half of them are sent */
230 dev_dbg(chip->card->dev, "Full\n");
231 sent = 32;
232 chip->midi_full = 1;
233 }
234 }
235
236 /* We restart the timer only if there is some data left to send */
237 if (!snd_rawmidi_transmit_empty(chip->midi_out) && chip->tinuse) {
238 /* The timer will expire slightly after the data has been
239 sent */
240 time = (sent << 3) / 25 + 1; /* 8/25=0.32ms to send a byte */
241 mod_timer(&chip->timer, jiffies + (time * HZ + 999) / 1000);
242 dev_dbg(chip->card->dev,
243 "Timer armed(%d)\n", ((time * HZ + 999) / 1000));
244 }
245 spin_unlock_irqrestore(&chip->lock, flags);
246 }
247
248
249
snd_echo_midi_output_trigger(struct snd_rawmidi_substream * substream,int up)250 static void snd_echo_midi_output_trigger(struct snd_rawmidi_substream *substream,
251 int up)
252 {
253 struct echoaudio *chip = substream->rmidi->private_data;
254
255 dev_dbg(chip->card->dev, "snd_echo_midi_output_trigger(%d)\n", up);
256 spin_lock_irq(&chip->lock);
257 if (up) {
258 if (!chip->tinuse) {
259 timer_setup(&chip->timer, snd_echo_midi_output_write,
260 0);
261 chip->tinuse = 1;
262 }
263 } else {
264 if (chip->tinuse) {
265 chip->tinuse = 0;
266 spin_unlock_irq(&chip->lock);
267 del_timer_sync(&chip->timer);
268 dev_dbg(chip->card->dev, "Timer removed\n");
269 return;
270 }
271 }
272 spin_unlock_irq(&chip->lock);
273
274 if (up && !chip->midi_full)
275 snd_echo_midi_output_write(&chip->timer);
276 }
277
278
279
snd_echo_midi_output_close(struct snd_rawmidi_substream * substream)280 static int snd_echo_midi_output_close(struct snd_rawmidi_substream *substream)
281 {
282 struct echoaudio *chip = substream->rmidi->private_data;
283
284 chip->midi_out = NULL;
285 return 0;
286 }
287
288
289
290 static const struct snd_rawmidi_ops snd_echo_midi_input = {
291 .open = snd_echo_midi_input_open,
292 .close = snd_echo_midi_input_close,
293 .trigger = snd_echo_midi_input_trigger,
294 };
295
296 static const struct snd_rawmidi_ops snd_echo_midi_output = {
297 .open = snd_echo_midi_output_open,
298 .close = snd_echo_midi_output_close,
299 .trigger = snd_echo_midi_output_trigger,
300 };
301
302
303
304 /* <--snd_echo_probe() */
snd_echo_midi_create(struct snd_card * card,struct echoaudio * chip)305 static int snd_echo_midi_create(struct snd_card *card,
306 struct echoaudio *chip)
307 {
308 int err;
309
310 err = snd_rawmidi_new(card, card->shortname, 0, 1, 1, &chip->rmidi);
311 if (err < 0)
312 return err;
313
314 strcpy(chip->rmidi->name, card->shortname);
315 chip->rmidi->private_data = chip;
316
317 snd_rawmidi_set_ops(chip->rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
318 &snd_echo_midi_input);
319 snd_rawmidi_set_ops(chip->rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
320 &snd_echo_midi_output);
321
322 chip->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
323 SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
324 return 0;
325 }
326