sound/pci/echoaudio/midi.c

   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 }