1 /****************************************************************************
3 Copyright Echo Digital Audio Corporation (c) 1998 - 2004
7 This file is part of Echo Digital Audio's generic driver library.
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
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.
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,
24 *************************************************************************
26 Translation from C++ and adaptation for use in ALSA-Driver
27 were made by Giuliano Pochini <pochini@shiny.it>
29 ****************************************************************************/
32 /******************************************************************************
34 ******************************************************************************/
36 /* Start and stop Midi input */
37 static int enable_midi_input(struct echoaudio
*chip
, char enable
)
39 DE_MID(("enable_midi_input(%d)\n", enable
));
41 if (wait_handshake(chip
))
45 chip
->mtc_state
= MIDI_IN_STATE_NORMAL
;
46 chip
->comm_page
->flags
|=
47 cpu_to_le32(DSP_FLAG_MIDI_INPUT
);
49 chip
->comm_page
->flags
&=
50 ~cpu_to_le32(DSP_FLAG_MIDI_INPUT
);
52 clear_handshake(chip
);
53 return send_vector(chip
, DSP_VC_UPDATE_FLAGS
);
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
)
62 if (snd_BUG_ON(bytes
<= 0 || bytes
>= MIDI_OUT_BUFFER_SIZE
))
65 if (wait_handshake(chip
))
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
))
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 DE_MID(("write_midi: %d\n", bytes
));
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
)
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
;
97 case MIDI_IN_STATE_TS_HIGH
:
98 chip
->mtc_state
= MIDI_IN_STATE_TS_LOW
;
99 return MIDI_IN_SKIP_DATA
;
101 case MIDI_IN_STATE_TS_LOW
:
102 chip
->mtc_state
= MIDI_IN_STATE_F1_DATA
;
103 return MIDI_IN_SKIP_DATA
;
105 case MIDI_IN_STATE_F1_DATA
:
106 chip
->mtc_state
= MIDI_IN_STATE_NORMAL
;
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
)
118 short int count
, midi_byte
, i
, received
;
120 /* The count is at index 0, followed by actual data */
121 count
= le16_to_cpu(chip
->comm_page
->midi_input
[0]);
123 if (snd_BUG_ON(count
>= MIDI_IN_BUFFER_SIZE
))
126 /* Get the MIDI data from the comm page */
129 for (i
= 1; i
<= count
; i
++) {
130 /* Get the MIDI byte */
131 midi_byte
= le16_to_cpu(chip
->comm_page
->midi_input
[i
]);
133 /* Parse the incoming MIDI stream. The incoming MIDI data
134 consists of MIDI bytes and timestamps for the MIDI time code
135 0xF1 bytes. mtc_process_data() is a little state machine that
136 parses the stream. If you get MIDI_IN_SKIP_DATA back, then
137 this is a timestamp byte, not a MIDI byte, so don't store it
138 in the MIDI input buffer. */
139 if (mtc_process_data(chip
, midi_byte
) == MIDI_IN_SKIP_DATA
)
142 chip
->midi_buffer
[received
++] = (u8
)midi_byte
;
151 /******************************************************************************
153 ******************************************************************************/
155 static int snd_echo_midi_input_open(struct snd_rawmidi_substream
*substream
)
157 struct echoaudio
*chip
= substream
->rmidi
->private_data
;
159 chip
->midi_in
= substream
;
160 DE_MID(("rawmidi_iopen\n"));
166 static void snd_echo_midi_input_trigger(struct snd_rawmidi_substream
*substream
,
169 struct echoaudio
*chip
= substream
->rmidi
->private_data
;
171 if (up
!= chip
->midi_input_enabled
) {
172 spin_lock_irq(&chip
->lock
);
173 enable_midi_input(chip
, up
);
174 spin_unlock_irq(&chip
->lock
);
175 chip
->midi_input_enabled
= up
;
181 static int snd_echo_midi_input_close(struct snd_rawmidi_substream
*substream
)
183 struct echoaudio
*chip
= substream
->rmidi
->private_data
;
185 chip
->midi_in
= NULL
;
186 DE_MID(("rawmidi_iclose\n"));
192 static int snd_echo_midi_output_open(struct snd_rawmidi_substream
*substream
)
194 struct echoaudio
*chip
= substream
->rmidi
->private_data
;
198 chip
->midi_out
= substream
;
199 DE_MID(("rawmidi_oopen\n"));
205 static void snd_echo_midi_output_write(unsigned long data
)
207 struct echoaudio
*chip
= (struct echoaudio
*)data
;
209 int bytes
, sent
, time
;
210 unsigned char buf
[MIDI_OUT_BUFFER_SIZE
- 1];
212 DE_MID(("snd_echo_midi_output_write\n"));
213 /* No interrupts are involved: we have to check at regular intervals
214 if the card's output buffer has room for new data. */
216 spin_lock_irqsave(&chip
->lock
, flags
);
218 if (!snd_rawmidi_transmit_empty(chip
->midi_out
)) {
219 bytes
= snd_rawmidi_transmit_peek(chip
->midi_out
, buf
,
220 MIDI_OUT_BUFFER_SIZE
- 1);
221 DE_MID(("Try to send %d bytes...\n", bytes
));
222 sent
= write_midi(chip
, buf
, bytes
);
224 dev_err(chip
->card
->dev
,
225 "write_midi() error %d\n", sent
);
229 } else if (sent
> 0) {
230 DE_MID(("%d bytes sent\n", sent
));
231 snd_rawmidi_transmit_ack(chip
->midi_out
, sent
);
233 /* Buffer is full. DSP's internal buffer is 64 (128 ?)
234 bytes long. Let's wait until half of them are sent */
241 /* We restart the timer only if there is some data left to send */
242 if (!snd_rawmidi_transmit_empty(chip
->midi_out
) && chip
->tinuse
) {
243 /* The timer will expire slightly after the data has been
245 time
= (sent
<< 3) / 25 + 1; /* 8/25=0.32ms to send a byte */
246 mod_timer(&chip
->timer
, jiffies
+ (time
* HZ
+ 999) / 1000);
247 DE_MID(("Timer armed(%d)\n", ((time
* HZ
+ 999) / 1000)));
249 spin_unlock_irqrestore(&chip
->lock
, flags
);
254 static void snd_echo_midi_output_trigger(struct snd_rawmidi_substream
*substream
,
257 struct echoaudio
*chip
= substream
->rmidi
->private_data
;
259 DE_MID(("snd_echo_midi_output_trigger(%d)\n", up
));
260 spin_lock_irq(&chip
->lock
);
263 init_timer(&chip
->timer
);
264 chip
->timer
.function
= snd_echo_midi_output_write
;
265 chip
->timer
.data
= (unsigned long)chip
;
271 spin_unlock_irq(&chip
->lock
);
272 del_timer_sync(&chip
->timer
);
273 DE_MID(("Timer removed\n"));
277 spin_unlock_irq(&chip
->lock
);
279 if (up
&& !chip
->midi_full
)
280 snd_echo_midi_output_write((unsigned long)chip
);
285 static int snd_echo_midi_output_close(struct snd_rawmidi_substream
*substream
)
287 struct echoaudio
*chip
= substream
->rmidi
->private_data
;
289 chip
->midi_out
= NULL
;
290 DE_MID(("rawmidi_oclose\n"));
296 static struct snd_rawmidi_ops snd_echo_midi_input
= {
297 .open
= snd_echo_midi_input_open
,
298 .close
= snd_echo_midi_input_close
,
299 .trigger
= snd_echo_midi_input_trigger
,
302 static struct snd_rawmidi_ops snd_echo_midi_output
= {
303 .open
= snd_echo_midi_output_open
,
304 .close
= snd_echo_midi_output_close
,
305 .trigger
= snd_echo_midi_output_trigger
,
310 /* <--snd_echo_probe() */
311 static int snd_echo_midi_create(struct snd_card
*card
,
312 struct echoaudio
*chip
)
316 if ((err
= snd_rawmidi_new(card
, card
->shortname
, 0, 1, 1,
320 strcpy(chip
->rmidi
->name
, card
->shortname
);
321 chip
->rmidi
->private_data
= chip
;
323 snd_rawmidi_set_ops(chip
->rmidi
, SNDRV_RAWMIDI_STREAM_INPUT
,
324 &snd_echo_midi_input
);
325 snd_rawmidi_set_ops(chip
->rmidi
, SNDRV_RAWMIDI_STREAM_OUTPUT
,
326 &snd_echo_midi_output
);
328 chip
->rmidi
->info_flags
|= SNDRV_RAWMIDI_INFO_OUTPUT
|
329 SNDRV_RAWMIDI_INFO_INPUT
| SNDRV_RAWMIDI_INFO_DUPLEX
;
330 DE_INIT(("MIDI ok\n"));