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 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 */ 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. */ 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 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 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 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 guard(spinlock_irq)(&chip->lock); 171 enable_midi_input(chip, up); 172 chip->midi_input_enabled = up; 173 } 174 } 175 176 177 178 static int snd_echo_midi_input_close(struct snd_rawmidi_substream *substream) 179 { 180 struct echoaudio *chip = substream->rmidi->private_data; 181 182 chip->midi_in = NULL; 183 return 0; 184 } 185 186 187 188 static int snd_echo_midi_output_open(struct snd_rawmidi_substream *substream) 189 { 190 struct echoaudio *chip = substream->rmidi->private_data; 191 192 chip->tinuse = 0; 193 chip->midi_full = 0; 194 chip->midi_out = substream; 195 return 0; 196 } 197 198 199 200 static void snd_echo_midi_output_write(struct timer_list *t) 201 { 202 struct echoaudio *chip = timer_container_of(chip, t, timer); 203 int bytes, sent, time; 204 unsigned char buf[MIDI_OUT_BUFFER_SIZE - 1]; 205 206 /* No interrupts are involved: we have to check at regular intervals 207 if the card's output buffer has room for new data. */ 208 sent = 0; 209 guard(spinlock_irqsave)(&chip->lock); 210 chip->midi_full = 0; 211 if (!snd_rawmidi_transmit_empty(chip->midi_out)) { 212 bytes = snd_rawmidi_transmit_peek(chip->midi_out, buf, 213 MIDI_OUT_BUFFER_SIZE - 1); 214 dev_dbg(chip->card->dev, "Try to send %d bytes...\n", bytes); 215 sent = write_midi(chip, buf, bytes); 216 if (sent < 0) { 217 dev_err(chip->card->dev, 218 "write_midi() error %d\n", sent); 219 /* retry later */ 220 sent = 9000; 221 chip->midi_full = 1; 222 } else if (sent > 0) { 223 dev_dbg(chip->card->dev, "%d bytes sent\n", sent); 224 snd_rawmidi_transmit_ack(chip->midi_out, sent); 225 } else { 226 /* Buffer is full. DSP's internal buffer is 64 (128 ?) 227 bytes long. Let's wait until half of them are sent */ 228 dev_dbg(chip->card->dev, "Full\n"); 229 sent = 32; 230 chip->midi_full = 1; 231 } 232 } 233 234 /* We restart the timer only if there is some data left to send */ 235 if (!snd_rawmidi_transmit_empty(chip->midi_out) && chip->tinuse) { 236 /* The timer will expire slightly after the data has been 237 sent */ 238 time = (sent << 3) / 25 + 1; /* 8/25=0.32ms to send a byte */ 239 mod_timer(&chip->timer, jiffies + (time * HZ + 999) / 1000); 240 dev_dbg(chip->card->dev, 241 "Timer armed(%d)\n", ((time * HZ + 999) / 1000)); 242 } 243 } 244 245 246 247 static void snd_echo_midi_output_trigger(struct snd_rawmidi_substream *substream, 248 int up) 249 { 250 struct echoaudio *chip = substream->rmidi->private_data; 251 bool remove_timer = false; 252 253 dev_dbg(chip->card->dev, "snd_echo_midi_output_trigger(%d)\n", up); 254 scoped_guard(spinlock_irq, &chip->lock) { 255 if (up) { 256 if (!chip->tinuse) { 257 timer_setup(&chip->timer, snd_echo_midi_output_write, 258 0); 259 chip->tinuse = 1; 260 } 261 } else { 262 if (chip->tinuse) { 263 chip->tinuse = 0; 264 remove_timer = true; 265 } 266 } 267 } 268 269 if (remove_timer) { 270 timer_delete_sync(&chip->timer); 271 dev_dbg(chip->card->dev, "Timer removed\n"); 272 return; 273 } 274 275 if (up && !chip->midi_full) 276 snd_echo_midi_output_write(&chip->timer); 277 } 278 279 280 281 static int snd_echo_midi_output_close(struct snd_rawmidi_substream *substream) 282 { 283 struct echoaudio *chip = substream->rmidi->private_data; 284 285 chip->midi_out = NULL; 286 return 0; 287 } 288 289 290 291 static const struct snd_rawmidi_ops snd_echo_midi_input = { 292 .open = snd_echo_midi_input_open, 293 .close = snd_echo_midi_input_close, 294 .trigger = snd_echo_midi_input_trigger, 295 }; 296 297 static const struct snd_rawmidi_ops snd_echo_midi_output = { 298 .open = snd_echo_midi_output_open, 299 .close = snd_echo_midi_output_close, 300 .trigger = snd_echo_midi_output_trigger, 301 }; 302 303 304 305 /* <--snd_echo_probe() */ 306 static int snd_echo_midi_create(struct snd_card *card, 307 struct echoaudio *chip) 308 { 309 int err; 310 311 err = snd_rawmidi_new(card, card->shortname, 0, 1, 1, &chip->rmidi); 312 if (err < 0) 313 return err; 314 315 strscpy(chip->rmidi->name, card->shortname); 316 chip->rmidi->private_data = chip; 317 318 snd_rawmidi_set_ops(chip->rmidi, SNDRV_RAWMIDI_STREAM_INPUT, 319 &snd_echo_midi_input); 320 snd_rawmidi_set_ops(chip->rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, 321 &snd_echo_midi_output); 322 323 chip->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | 324 SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; 325 return 0; 326 } 327