Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
midi.c
Go to the documentation of this file.
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 <[email protected]>
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 |=
48  } else
49  chip->comm_page->flags &=
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  DE_MID(("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) {
94  if (midi_byte == 0xF1)
95  chip->mtc_state = MIDI_IN_STATE_TS_HIGH;
96  break;
98  chip->mtc_state = MIDI_IN_STATE_TS_LOW;
99  return MIDI_IN_SKIP_DATA;
100  break;
102  chip->mtc_state = MIDI_IN_STATE_F1_DATA;
103  return MIDI_IN_SKIP_DATA;
104  break;
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  i = 1;
128  received = 0;
129  for (i = 1; i <= count; i++) {
130  /* Get the MIDI byte */
131  midi_byte = le16_to_cpu(chip->comm_page->midi_input[i]);
132 
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)
140  continue;
141 
142  chip->midi_buffer[received++] = (u8)midi_byte;
143  }
144 
145  return received;
146 }
147 
148 
149 
150 
151 /******************************************************************************
152  MIDI interface
153 ******************************************************************************/
154 
155 static int snd_echo_midi_input_open(struct snd_rawmidi_substream *substream)
156 {
157  struct echoaudio *chip = substream->rmidi->private_data;
158 
159  chip->midi_in = substream;
160  DE_MID(("rawmidi_iopen\n"));
161  return 0;
162 }
163 
164 
165 
166 static void snd_echo_midi_input_trigger(struct snd_rawmidi_substream *substream,
167  int up)
168 {
169  struct echoaudio *chip = substream->rmidi->private_data;
170 
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;
176  }
177 }
178 
179 
180 
181 static int snd_echo_midi_input_close(struct snd_rawmidi_substream *substream)
182 {
183  struct echoaudio *chip = substream->rmidi->private_data;
184 
185  chip->midi_in = NULL;
186  DE_MID(("rawmidi_iclose\n"));
187  return 0;
188 }
189 
190 
191 
192 static int snd_echo_midi_output_open(struct snd_rawmidi_substream *substream)
193 {
194  struct echoaudio *chip = substream->rmidi->private_data;
195 
196  chip->tinuse = 0;
197  chip->midi_full = 0;
198  chip->midi_out = substream;
199  DE_MID(("rawmidi_oopen\n"));
200  return 0;
201 }
202 
203 
204 
205 static void snd_echo_midi_output_write(unsigned long data)
206 {
207  struct echoaudio *chip = (struct echoaudio *)data;
208  unsigned long flags;
209  int bytes, sent, time;
210  unsigned char buf[MIDI_OUT_BUFFER_SIZE - 1];
211 
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. */
215  sent = bytes = 0;
216  spin_lock_irqsave(&chip->lock, flags);
217  chip->midi_full = 0;
218  if (!snd_rawmidi_transmit_empty(chip->midi_out)) {
219  bytes = snd_rawmidi_transmit_peek(chip->midi_out, buf,
221  DE_MID(("Try to send %d bytes...\n", bytes));
222  sent = write_midi(chip, buf, bytes);
223  if (sent < 0) {
224  snd_printk(KERN_ERR "write_midi() error %d\n", sent);
225  /* retry later */
226  sent = 9000;
227  chip->midi_full = 1;
228  } else if (sent > 0) {
229  DE_MID(("%d bytes sent\n", sent));
230  snd_rawmidi_transmit_ack(chip->midi_out, sent);
231  } else {
232  /* Buffer is full. DSP's internal buffer is 64 (128 ?)
233  bytes long. Let's wait until half of them are sent */
234  DE_MID(("Full\n"));
235  sent = 32;
236  chip->midi_full = 1;
237  }
238  }
239 
240  /* We restart the timer only if there is some data left to send */
241  if (!snd_rawmidi_transmit_empty(chip->midi_out) && chip->tinuse) {
242  /* The timer will expire slightly after the data has been
243  sent */
244  time = (sent << 3) / 25 + 1; /* 8/25=0.32ms to send a byte */
245  mod_timer(&chip->timer, jiffies + (time * HZ + 999) / 1000);
246  DE_MID(("Timer armed(%d)\n", ((time * HZ + 999) / 1000)));
247  }
248  spin_unlock_irqrestore(&chip->lock, flags);
249 }
250 
251 
252 
253 static void snd_echo_midi_output_trigger(struct snd_rawmidi_substream *substream,
254  int up)
255 {
256  struct echoaudio *chip = substream->rmidi->private_data;
257 
258  DE_MID(("snd_echo_midi_output_trigger(%d)\n", up));
259  spin_lock_irq(&chip->lock);
260  if (up) {
261  if (!chip->tinuse) {
262  init_timer(&chip->timer);
263  chip->timer.function = snd_echo_midi_output_write;
264  chip->timer.data = (unsigned long)chip;
265  chip->tinuse = 1;
266  }
267  } else {
268  if (chip->tinuse) {
269  chip->tinuse = 0;
270  spin_unlock_irq(&chip->lock);
271  del_timer_sync(&chip->timer);
272  DE_MID(("Timer removed\n"));
273  return;
274  }
275  }
276  spin_unlock_irq(&chip->lock);
277 
278  if (up && !chip->midi_full)
279  snd_echo_midi_output_write((unsigned long)chip);
280 }
281 
282 
283 
284 static int snd_echo_midi_output_close(struct snd_rawmidi_substream *substream)
285 {
286  struct echoaudio *chip = substream->rmidi->private_data;
287 
288  chip->midi_out = NULL;
289  DE_MID(("rawmidi_oclose\n"));
290  return 0;
291 }
292 
293 
294 
295 static struct snd_rawmidi_ops snd_echo_midi_input = {
296  .open = snd_echo_midi_input_open,
297  .close = snd_echo_midi_input_close,
298  .trigger = snd_echo_midi_input_trigger,
299 };
300 
301 static struct snd_rawmidi_ops snd_echo_midi_output = {
302  .open = snd_echo_midi_output_open,
303  .close = snd_echo_midi_output_close,
304  .trigger = snd_echo_midi_output_trigger,
305 };
306 
307 
308 
309 /* <--snd_echo_probe() */
310 static int __devinit snd_echo_midi_create(struct snd_card *card,
311  struct echoaudio *chip)
312 {
313  int err;
314 
315  if ((err = snd_rawmidi_new(card, card->shortname, 0, 1, 1,
316  &chip->rmidi)) < 0)
317  return err;
318 
319  strcpy(chip->rmidi->name, card->shortname);
320  chip->rmidi->private_data = chip;
321 
323  &snd_echo_midi_input);
325  &snd_echo_midi_output);
326 
327  chip->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
329  DE_INIT(("MIDI ok\n"));
330  return 0;
331 }