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 { 39 DE_MID(("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 __constant_cpu_to_le32(DSP_FLAG_MIDI_INPUT); 48 } else 49 chip->comm_page->flags &= 50 ~__constant_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 */ 60 static int write_midi(struct echoaudio *chip, u8 *data, int bytes) 61 { 62 snd_assert(bytes > 0 && bytes < MIDI_OUT_BUFFER_SIZE, return -EINVAL); 63 64 if (wait_handshake(chip)) 65 return -EIO; 66 67 /* HF4 indicates that it is safe to write MIDI output data */ 68 if (! (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_REG_HF4)) 69 return 0; 70 71 chip->comm_page->midi_output[0] = bytes; 72 memcpy(&chip->comm_page->midi_output[1], data, bytes); 73 chip->comm_page->midi_out_free_count = 0; 74 clear_handshake(chip); 75 send_vector(chip, DSP_VC_MIDI_WRITE); 76 DE_MID(("write_midi: %d\n", bytes)); 77 return bytes; 78 } 79 80 81 82 /* Run the state machine for MIDI input data 83 MIDI time code sync isn't supported by this code right now, but you still need 84 this state machine to parse the incoming MIDI data stream. Every time the DSP 85 sees a 0xF1 byte come in, it adds the DSP sample position to the MIDI data 86 stream. The DSP sample position is represented as a 32 bit unsigned value, 87 with the high 16 bits first, followed by the low 16 bits. Since these aren't 88 real MIDI bytes, the following logic is needed to skip them. */ 89 static inline int mtc_process_data(struct echoaudio *chip, short midi_byte) 90 { 91 switch (chip->mtc_state) { 92 case MIDI_IN_STATE_NORMAL: 93 if (midi_byte == 0xF1) 94 chip->mtc_state = MIDI_IN_STATE_TS_HIGH; 95 break; 96 case MIDI_IN_STATE_TS_HIGH: 97 chip->mtc_state = MIDI_IN_STATE_TS_LOW; 98 return MIDI_IN_SKIP_DATA; 99 break; 100 case MIDI_IN_STATE_TS_LOW: 101 chip->mtc_state = MIDI_IN_STATE_F1_DATA; 102 return MIDI_IN_SKIP_DATA; 103 break; 104 case MIDI_IN_STATE_F1_DATA: 105 chip->mtc_state = MIDI_IN_STATE_NORMAL; 106 break; 107 } 108 return 0; 109 } 110 111 112 113 /* This function is called from the IRQ handler and it reads the midi data 114 from the DSP's buffer. It returns the number of bytes received. */ 115 static int midi_service_irq(struct echoaudio *chip) 116 { 117 short int count, midi_byte, i, received; 118 119 /* The count is at index 0, followed by actual data */ 120 count = le16_to_cpu(chip->comm_page->midi_input[0]); 121 122 snd_assert(count < MIDI_IN_BUFFER_SIZE, return 0); 123 124 /* Get the MIDI data from the comm page */ 125 i = 1; 126 received = 0; 127 for (i = 1; i <= count; i++) { 128 /* Get the MIDI byte */ 129 midi_byte = le16_to_cpu(chip->comm_page->midi_input[i]); 130 131 /* Parse the incoming MIDI stream. The incoming MIDI data 132 consists of MIDI bytes and timestamps for the MIDI time code 133 0xF1 bytes. mtc_process_data() is a little state machine that 134 parses the stream. If you get MIDI_IN_SKIP_DATA back, then 135 this is a timestamp byte, not a MIDI byte, so don't store it 136 in the MIDI input buffer. */ 137 if (mtc_process_data(chip, midi_byte) == MIDI_IN_SKIP_DATA) 138 continue; 139 140 chip->midi_buffer[received++] = (u8)midi_byte; 141 } 142 143 return received; 144 } 145 146 147 148 149 /****************************************************************************** 150 MIDI interface 151 ******************************************************************************/ 152 153 static int snd_echo_midi_input_open(struct snd_rawmidi_substream *substream) 154 { 155 struct echoaudio *chip = substream->rmidi->private_data; 156 157 chip->midi_in = substream; 158 DE_MID(("rawmidi_iopen\n")); 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; 184 DE_MID(("rawmidi_iclose\n")); 185 return 0; 186 } 187 188 189 190 static int snd_echo_midi_output_open(struct snd_rawmidi_substream *substream) 191 { 192 struct echoaudio *chip = substream->rmidi->private_data; 193 194 chip->tinuse = 0; 195 chip->midi_full = 0; 196 chip->midi_out = substream; 197 DE_MID(("rawmidi_oopen\n")); 198 return 0; 199 } 200 201 202 203 static void snd_echo_midi_output_write(unsigned long data) 204 { 205 struct echoaudio *chip = (struct echoaudio *)data; 206 unsigned long flags; 207 int bytes, sent, time; 208 unsigned char buf[MIDI_OUT_BUFFER_SIZE - 1]; 209 210 DE_MID(("snd_echo_midi_output_write\n")); 211 /* No interrupts are involved: we have to check at regular intervals 212 if the card's output buffer has room for new data. */ 213 sent = bytes = 0; 214 spin_lock_irqsave(&chip->lock, flags); 215 chip->midi_full = 0; 216 if (!snd_rawmidi_transmit_empty(chip->midi_out)) { 217 bytes = snd_rawmidi_transmit_peek(chip->midi_out, buf, 218 MIDI_OUT_BUFFER_SIZE - 1); 219 DE_MID(("Try to send %d bytes...\n", bytes)); 220 sent = write_midi(chip, buf, bytes); 221 if (sent < 0) { 222 snd_printk(KERN_ERR "write_midi() error %d\n", sent); 223 /* retry later */ 224 sent = 9000; 225 chip->midi_full = 1; 226 } else if (sent > 0) { 227 DE_MID(("%d bytes sent\n", sent)); 228 snd_rawmidi_transmit_ack(chip->midi_out, sent); 229 } else { 230 /* Buffer is full. DSP's internal buffer is 64 (128 ?) 231 bytes long. Let's wait until half of them are sent */ 232 DE_MID(("Full\n")); 233 sent = 32; 234 chip->midi_full = 1; 235 } 236 } 237 238 /* We restart the timer only if there is some data left to send */ 239 if (!snd_rawmidi_transmit_empty(chip->midi_out) && chip->tinuse) { 240 /* The timer will expire slightly after the data has been 241 sent */ 242 time = (sent << 3) / 25 + 1; /* 8/25=0.32ms to send a byte */ 243 mod_timer(&chip->timer, jiffies + (time * HZ + 999) / 1000); 244 DE_MID(("Timer armed(%d)\n", ((time * HZ + 999) / 1000))); 245 } 246 spin_unlock_irqrestore(&chip->lock, flags); 247 } 248 249 250 251 static void snd_echo_midi_output_trigger(struct snd_rawmidi_substream *substream, 252 int up) 253 { 254 struct echoaudio *chip = substream->rmidi->private_data; 255 256 DE_MID(("snd_echo_midi_output_trigger(%d)\n", up)); 257 spin_lock_irq(&chip->lock); 258 if (up) { 259 if (!chip->tinuse) { 260 init_timer(&chip->timer); 261 chip->timer.function = snd_echo_midi_output_write; 262 chip->timer.data = (unsigned long)chip; 263 chip->tinuse = 1; 264 } 265 } else { 266 if (chip->tinuse) { 267 chip->tinuse = 0; 268 spin_unlock_irq(&chip->lock); 269 del_timer_sync(&chip->timer); 270 DE_MID(("Timer removed\n")); 271 return; 272 } 273 } 274 spin_unlock_irq(&chip->lock); 275 276 if (up && !chip->midi_full) 277 snd_echo_midi_output_write((unsigned long)chip); 278 } 279 280 281 282 static int snd_echo_midi_output_close(struct snd_rawmidi_substream *substream) 283 { 284 struct echoaudio *chip = substream->rmidi->private_data; 285 286 chip->midi_out = NULL; 287 DE_MID(("rawmidi_oclose\n")); 288 return 0; 289 } 290 291 292 293 static struct snd_rawmidi_ops snd_echo_midi_input = { 294 .open = snd_echo_midi_input_open, 295 .close = snd_echo_midi_input_close, 296 .trigger = snd_echo_midi_input_trigger, 297 }; 298 299 static struct snd_rawmidi_ops snd_echo_midi_output = { 300 .open = snd_echo_midi_output_open, 301 .close = snd_echo_midi_output_close, 302 .trigger = snd_echo_midi_output_trigger, 303 }; 304 305 306 307 /* <--snd_echo_probe() */ 308 static int __devinit snd_echo_midi_create(struct snd_card *card, 309 struct echoaudio *chip) 310 { 311 int err; 312 313 if ((err = snd_rawmidi_new(card, card->shortname, 0, 1, 1, 314 &chip->rmidi)) < 0) 315 return err; 316 317 strcpy(chip->rmidi->name, card->shortname); 318 chip->rmidi->private_data = chip; 319 320 snd_rawmidi_set_ops(chip->rmidi, SNDRV_RAWMIDI_STREAM_INPUT, 321 &snd_echo_midi_input); 322 snd_rawmidi_set_ops(chip->rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, 323 &snd_echo_midi_output); 324 325 chip->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | 326 SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; 327 DE_INIT(("MIDI ok\n")); 328 return 0; 329 } 330