Commit | Line | Data |
---|---|---|
dd7b254d GP |
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 */ | |
37 | static int enable_midi_input(struct echoaudio *chip, char enable) | |
38 | { | |
b5b4a41b | 39 | dev_dbg(chip->card->dev, "enable_midi_input(%d)\n", enable); |
dd7b254d GP |
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 |= | |
e930e995 | 47 | cpu_to_le32(DSP_FLAG_MIDI_INPUT); |
dd7b254d GP |
48 | } else |
49 | chip->comm_page->flags &= | |
e930e995 | 50 | ~cpu_to_le32(DSP_FLAG_MIDI_INPUT); |
dd7b254d GP |
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 */ | |
60 | static int write_midi(struct echoaudio *chip, u8 *data, int bytes) | |
61 | { | |
da3cec35 TI |
62 | if (snd_BUG_ON(bytes <= 0 || bytes >= MIDI_OUT_BUFFER_SIZE)) |
63 | return -EINVAL; | |
dd7b254d GP |
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); | |
b5b4a41b | 77 | dev_dbg(chip->card->dev, "write_midi: %d\n", bytes); |
dd7b254d GP |
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. */ | |
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. */ | |
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 | ||
da3cec35 TI |
123 | if (snd_BUG_ON(count >= MIDI_IN_BUFFER_SIZE)) |
124 | return 0; | |
dd7b254d GP |
125 | |
126 | /* Get the MIDI data from the comm page */ | |
dd7b254d GP |
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 | ||
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; | |
dd7b254d GP |
159 | return 0; |
160 | } | |
161 | ||
162 | ||
163 | ||
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 | ||
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; | |
dd7b254d GP |
184 | return 0; |
185 | } | |
186 | ||
187 | ||
188 | ||
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; | |
dd7b254d GP |
196 | return 0; |
197 | } | |
198 | ||
199 | ||
200 | ||
7211ec63 | 201 | static void snd_echo_midi_output_write(struct timer_list *t) |
dd7b254d | 202 | { |
7211ec63 | 203 | struct echoaudio *chip = from_timer(chip, t, timer); |
dd7b254d GP |
204 | unsigned long flags; |
205 | int bytes, sent, time; | |
206 | unsigned char buf[MIDI_OUT_BUFFER_SIZE - 1]; | |
207 | ||
dd7b254d GP |
208 | /* No interrupts are involved: we have to check at regular intervals |
209 | if the card's output buffer has room for new data. */ | |
3cffb26f | 210 | sent = 0; |
dd7b254d GP |
211 | spin_lock_irqsave(&chip->lock, flags); |
212 | chip->midi_full = 0; | |
5929546a | 213 | if (!snd_rawmidi_transmit_empty(chip->midi_out)) { |
dd7b254d GP |
214 | bytes = snd_rawmidi_transmit_peek(chip->midi_out, buf, |
215 | MIDI_OUT_BUFFER_SIZE - 1); | |
b5b4a41b | 216 | dev_dbg(chip->card->dev, "Try to send %d bytes...\n", bytes); |
dd7b254d GP |
217 | sent = write_midi(chip, buf, bytes); |
218 | if (sent < 0) { | |
ece7a36d TI |
219 | dev_err(chip->card->dev, |
220 | "write_midi() error %d\n", sent); | |
dd7b254d GP |
221 | /* retry later */ |
222 | sent = 9000; | |
223 | chip->midi_full = 1; | |
224 | } else if (sent > 0) { | |
b5b4a41b | 225 | dev_dbg(chip->card->dev, "%d bytes sent\n", sent); |
dd7b254d GP |
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 */ | |
b5b4a41b | 230 | dev_dbg(chip->card->dev, "Full\n"); |
dd7b254d GP |
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); | |
b5b4a41b SM |
242 | dev_dbg(chip->card->dev, |
243 | "Timer armed(%d)\n", ((time * HZ + 999) / 1000)); | |
dd7b254d GP |
244 | } |
245 | spin_unlock_irqrestore(&chip->lock, flags); | |
246 | } | |
247 | ||
248 | ||
249 | ||
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 | ||
b5b4a41b | 255 | dev_dbg(chip->card->dev, "snd_echo_midi_output_trigger(%d)\n", up); |
dd7b254d GP |
256 | spin_lock_irq(&chip->lock); |
257 | if (up) { | |
258 | if (!chip->tinuse) { | |
7211ec63 KC |
259 | timer_setup(&chip->timer, snd_echo_midi_output_write, |
260 | 0); | |
dd7b254d GP |
261 | chip->tinuse = 1; |
262 | } | |
263 | } else { | |
264 | if (chip->tinuse) { | |
dd7b254d | 265 | chip->tinuse = 0; |
5929546a GP |
266 | spin_unlock_irq(&chip->lock); |
267 | del_timer_sync(&chip->timer); | |
b5b4a41b | 268 | dev_dbg(chip->card->dev, "Timer removed\n"); |
5929546a | 269 | return; |
dd7b254d GP |
270 | } |
271 | } | |
272 | spin_unlock_irq(&chip->lock); | |
273 | ||
274 | if (up && !chip->midi_full) | |
7211ec63 | 275 | snd_echo_midi_output_write(&chip->timer); |
dd7b254d GP |
276 | } |
277 | ||
278 | ||
279 | ||
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; | |
dd7b254d GP |
285 | return 0; |
286 | } | |
287 | ||
288 | ||
289 | ||
485885b9 | 290 | static const struct snd_rawmidi_ops snd_echo_midi_input = { |
dd7b254d GP |
291 | .open = snd_echo_midi_input_open, |
292 | .close = snd_echo_midi_input_close, | |
293 | .trigger = snd_echo_midi_input_trigger, | |
294 | }; | |
295 | ||
485885b9 | 296 | static const struct snd_rawmidi_ops snd_echo_midi_output = { |
dd7b254d GP |
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() */ | |
e23e7a14 BP |
305 | static int snd_echo_midi_create(struct snd_card *card, |
306 | struct echoaudio *chip) | |
dd7b254d GP |
307 | { |
308 | int err; | |
309 | ||
549717fc TI |
310 | err = snd_rawmidi_new(card, card->shortname, 0, 1, 1, &chip->rmidi); |
311 | if (err < 0) | |
dd7b254d GP |
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; | |
dd7b254d GP |
324 | return 0; |
325 | } |