Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mpu401_uart.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) by Jaroslav Kysela <[email protected]>
3  * Routines for control of MPU-401 in UART mode
4  *
5  * MPU-401 supports UART mode which is not capable generate transmit
6  * interrupts thus output is done via polling. Without interrupt,
7  * input is done also via polling. Do not expect good performance.
8  *
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23  *
24  * 13-03-2003:
25  * Added support for different kind of hardware I/O. Build in choices
26  * are port and mmio. For other kind of I/O, set mpu->read and
27  * mpu->write to your own I/O functions.
28  *
29  */
30 
31 #include <asm/io.h>
32 #include <linux/delay.h>
33 #include <linux/init.h>
34 #include <linux/slab.h>
35 #include <linux/ioport.h>
36 #include <linux/module.h>
37 #include <linux/interrupt.h>
38 #include <linux/errno.h>
39 #include <sound/core.h>
40 #include <sound/mpu401.h>
41 
42 MODULE_AUTHOR("Jaroslav Kysela <[email protected]>");
43 MODULE_DESCRIPTION("Routines for control of MPU-401 in UART mode");
44 MODULE_LICENSE("GPL");
45 
46 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu);
47 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu);
48 
49 /*
50 
51  */
52 
53 #define snd_mpu401_input_avail(mpu) \
54  (!(mpu->read(mpu, MPU401C(mpu)) & MPU401_RX_EMPTY))
55 #define snd_mpu401_output_ready(mpu) \
56  (!(mpu->read(mpu, MPU401C(mpu)) & MPU401_TX_FULL))
57 
58 /* Build in lowlevel io */
59 static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data,
60  unsigned long addr)
61 {
62  outb(data, addr);
63 }
64 
65 static unsigned char mpu401_read_port(struct snd_mpu401 *mpu,
66  unsigned long addr)
67 {
68  return inb(addr);
69 }
70 
71 static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data,
72  unsigned long addr)
73 {
74  writeb(data, (void __iomem *)addr);
75 }
76 
77 static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu,
78  unsigned long addr)
79 {
80  return readb((void __iomem *)addr);
81 }
82 /* */
83 
84 static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
85 {
86  int timeout = 100000;
87  for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--)
88  mpu->read(mpu, MPU401D(mpu));
89 #ifdef CONFIG_SND_DEBUG
90  if (timeout <= 0)
91  snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n",
92  mpu->read(mpu, MPU401C(mpu)));
93 #endif
94 }
95 
96 static void uart_interrupt_tx(struct snd_mpu401 *mpu)
97 {
98  unsigned long flags;
99 
100  if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
102  spin_lock_irqsave(&mpu->output_lock, flags);
103  snd_mpu401_uart_output_write(mpu);
104  spin_unlock_irqrestore(&mpu->output_lock, flags);
105  }
106 }
107 
108 static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
109 {
110  unsigned long flags;
111 
112  if (mpu->info_flags & MPU401_INFO_INPUT) {
113  spin_lock_irqsave(&mpu->input_lock, flags);
114  if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
115  snd_mpu401_uart_input_read(mpu);
116  else
117  snd_mpu401_uart_clear_rx(mpu);
118  spin_unlock_irqrestore(&mpu->input_lock, flags);
119  }
120  if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
121  /* ok. for better Tx performance try do some output
122  when input is done */
123  uart_interrupt_tx(mpu);
124 }
125 
134 {
135  struct snd_mpu401 *mpu = dev_id;
136 
137  if (mpu == NULL)
138  return IRQ_NONE;
139  _snd_mpu401_uart_interrupt(mpu);
140  return IRQ_HANDLED;
141 }
142 
144 
153 {
154  struct snd_mpu401 *mpu = dev_id;
155 
156  if (mpu == NULL)
157  return IRQ_NONE;
158  uart_interrupt_tx(mpu);
159  return IRQ_HANDLED;
160 }
161 
163 
164 /*
165  * timer callback
166  * reprogram the timer and call the interrupt job
167  */
168 static void snd_mpu401_uart_timer(unsigned long data)
169 {
170  struct snd_mpu401 *mpu = (struct snd_mpu401 *)data;
171  unsigned long flags;
172 
173  spin_lock_irqsave(&mpu->timer_lock, flags);
174  /*mpu->mode |= MPU401_MODE_TIMER;*/
175  mpu->timer.expires = 1 + jiffies;
176  add_timer(&mpu->timer);
177  spin_unlock_irqrestore(&mpu->timer_lock, flags);
178  if (mpu->rmidi)
179  _snd_mpu401_uart_interrupt(mpu);
180 }
181 
182 /*
183  * initialize the timer callback if not programmed yet
184  */
185 static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
186 {
187  unsigned long flags;
188 
189  spin_lock_irqsave (&mpu->timer_lock, flags);
190  if (mpu->timer_invoked == 0) {
191  init_timer(&mpu->timer);
192  mpu->timer.data = (unsigned long)mpu;
193  mpu->timer.function = snd_mpu401_uart_timer;
194  mpu->timer.expires = 1 + jiffies;
195  add_timer(&mpu->timer);
196  }
197  mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER :
199  spin_unlock_irqrestore (&mpu->timer_lock, flags);
200 }
201 
202 /*
203  * remove the timer callback if still active
204  */
205 static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
206 {
207  unsigned long flags;
208 
209  spin_lock_irqsave (&mpu->timer_lock, flags);
210  if (mpu->timer_invoked) {
211  mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER :
213  if (! mpu->timer_invoked)
214  del_timer(&mpu->timer);
215  }
216  spin_unlock_irqrestore (&mpu->timer_lock, flags);
217 }
218 
219 /*
220  * send a UART command
221  * return zero if successful, non-zero for some errors
222  */
223 
224 static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
225  int ack)
226 {
227  unsigned long flags;
228  int timeout, ok;
229 
230  spin_lock_irqsave(&mpu->input_lock, flags);
231  if (mpu->hardware != MPU401_HW_TRID4DWAVE) {
232  mpu->write(mpu, 0x00, MPU401D(mpu));
233  /*snd_mpu401_uart_clear_rx(mpu);*/
234  }
235  /* ok. standard MPU-401 initialization */
236  if (mpu->hardware != MPU401_HW_SB) {
237  for (timeout = 1000; timeout > 0 &&
238  !snd_mpu401_output_ready(mpu); timeout--)
239  udelay(10);
240 #ifdef CONFIG_SND_DEBUG
241  if (!timeout)
242  snd_printk(KERN_ERR "cmd: tx timeout (status = 0x%x)\n",
243  mpu->read(mpu, MPU401C(mpu)));
244 #endif
245  }
246  mpu->write(mpu, cmd, MPU401C(mpu));
247  if (ack && !(mpu->info_flags & MPU401_INFO_NO_ACK)) {
248  ok = 0;
249  timeout = 10000;
250  while (!ok && timeout-- > 0) {
251  if (snd_mpu401_input_avail(mpu)) {
252  if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
253  ok = 1;
254  }
255  }
256  if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
257  ok = 1;
258  } else
259  ok = 1;
260  spin_unlock_irqrestore(&mpu->input_lock, flags);
261  if (!ok) {
262  snd_printk(KERN_ERR "cmd: 0x%x failed at 0x%lx "
263  "(status = 0x%x, data = 0x%x)\n", cmd, mpu->port,
264  mpu->read(mpu, MPU401C(mpu)),
265  mpu->read(mpu, MPU401D(mpu)));
266  return 1;
267  }
268  return 0;
269 }
270 
271 static int snd_mpu401_do_reset(struct snd_mpu401 *mpu)
272 {
273  if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
274  return -EIO;
275  if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 0))
276  return -EIO;
277  return 0;
278 }
279 
280 /*
281  * input/output open/close - protected by open_mutex in rawmidi.c
282  */
283 static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream)
284 {
285  struct snd_mpu401 *mpu;
286  int err;
287 
288  mpu = substream->rmidi->private_data;
289  if (mpu->open_input && (err = mpu->open_input(mpu)) < 0)
290  return err;
291  if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) {
292  if (snd_mpu401_do_reset(mpu) < 0)
293  goto error_out;
294  }
295  mpu->substream_input = substream;
297  return 0;
298 
299 error_out:
300  if (mpu->open_input && mpu->close_input)
301  mpu->close_input(mpu);
302  return -EIO;
303 }
304 
305 static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
306 {
307  struct snd_mpu401 *mpu;
308  int err;
309 
310  mpu = substream->rmidi->private_data;
311  if (mpu->open_output && (err = mpu->open_output(mpu)) < 0)
312  return err;
313  if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
314  if (snd_mpu401_do_reset(mpu) < 0)
315  goto error_out;
316  }
317  mpu->substream_output = substream;
319  return 0;
320 
321 error_out:
322  if (mpu->open_output && mpu->close_output)
323  mpu->close_output(mpu);
324  return -EIO;
325 }
326 
327 static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
328 {
329  struct snd_mpu401 *mpu;
330  int err = 0;
331 
332  mpu = substream->rmidi->private_data;
334  mpu->substream_input = NULL;
335  if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode))
336  err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
337  if (mpu->close_input)
338  mpu->close_input(mpu);
339  if (err)
340  return -EIO;
341  return 0;
342 }
343 
344 static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
345 {
346  struct snd_mpu401 *mpu;
347  int err = 0;
348 
349  mpu = substream->rmidi->private_data;
351  mpu->substream_output = NULL;
352  if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
353  err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
354  if (mpu->close_output)
355  mpu->close_output(mpu);
356  if (err)
357  return -EIO;
358  return 0;
359 }
360 
361 /*
362  * trigger input callback
363  */
364 static void
365 snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
366 {
367  unsigned long flags;
368  struct snd_mpu401 *mpu;
369  int max = 64;
370 
371  mpu = substream->rmidi->private_data;
372  if (up) {
374  &mpu->mode)) {
375  /* first time - flush FIFO */
376  while (max-- > 0)
377  mpu->read(mpu, MPU401D(mpu));
379  snd_mpu401_uart_add_timer(mpu, 1);
380  }
381 
382  /* read data in advance */
383  spin_lock_irqsave(&mpu->input_lock, flags);
384  snd_mpu401_uart_input_read(mpu);
385  spin_unlock_irqrestore(&mpu->input_lock, flags);
386  } else {
388  snd_mpu401_uart_remove_timer(mpu, 1);
390  }
391 
392 }
393 
394 /*
395  * transfer input pending data
396  * call with input_lock spinlock held
397  */
398 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
399 {
400  int max = 128;
401  unsigned char byte;
402 
403  while (max-- > 0) {
404  if (! snd_mpu401_input_avail(mpu))
405  break; /* input not available */
406  byte = mpu->read(mpu, MPU401D(mpu));
408  snd_rawmidi_receive(mpu->substream_input, &byte, 1);
409  }
410 }
411 
412 /*
413  * Tx FIFO sizes:
414  * CS4237B - 16 bytes
415  * AudioDrive ES1688 - 12 bytes
416  * S3 SonicVibes - 8 bytes
417  * SoundBlaster AWE 64 - 2 bytes (ugly hardware)
418  */
419 
420 /*
421  * write output pending bytes
422  * call with output_lock spinlock held
423  */
424 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
425 {
426  unsigned char byte;
427  int max = 256;
428 
429  do {
431  &byte, 1) == 1) {
432  /*
433  * Try twice because there is hardware that insists on
434  * setting the output busy bit after each write.
435  */
436  if (!snd_mpu401_output_ready(mpu) &&
438  break; /* Tx FIFO full - try again later */
439  mpu->write(mpu, byte, MPU401D(mpu));
441  } else {
442  snd_mpu401_uart_remove_timer (mpu, 0);
443  break; /* no other data - leave the tx loop */
444  }
445  } while (--max > 0);
446 }
447 
448 /*
449  * output trigger callback
450  */
451 static void
452 snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
453 {
454  unsigned long flags;
455  struct snd_mpu401 *mpu;
456 
457  mpu = substream->rmidi->private_data;
458  if (up) {
460 
461  /* try to add the timer at each output trigger,
462  * since the output timer might have been removed in
463  * snd_mpu401_uart_output_write().
464  */
465  if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
466  snd_mpu401_uart_add_timer(mpu, 0);
467 
468  /* output pending data */
469  spin_lock_irqsave(&mpu->output_lock, flags);
470  snd_mpu401_uart_output_write(mpu);
471  spin_unlock_irqrestore(&mpu->output_lock, flags);
472  } else {
473  if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
474  snd_mpu401_uart_remove_timer(mpu, 0);
476  }
477 }
478 
479 /*
480 
481  */
482 
483 static struct snd_rawmidi_ops snd_mpu401_uart_output =
484 {
485  .open = snd_mpu401_uart_output_open,
486  .close = snd_mpu401_uart_output_close,
487  .trigger = snd_mpu401_uart_output_trigger,
488 };
489 
490 static struct snd_rawmidi_ops snd_mpu401_uart_input =
491 {
492  .open = snd_mpu401_uart_input_open,
493  .close = snd_mpu401_uart_input_close,
494  .trigger = snd_mpu401_uart_input_trigger,
495 };
496 
497 static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
498 {
499  struct snd_mpu401 *mpu = rmidi->private_data;
500  if (mpu->irq >= 0)
501  free_irq(mpu->irq, (void *) mpu);
503  kfree(mpu);
504 }
505 
525  unsigned short hardware,
526  unsigned long port,
527  unsigned int info_flags,
528  int irq,
529  struct snd_rawmidi ** rrawmidi)
530 {
531  struct snd_mpu401 *mpu;
532  struct snd_rawmidi *rmidi;
533  int in_enable, out_enable;
534  int err;
535 
536  if (rrawmidi)
537  *rrawmidi = NULL;
538  if (! (info_flags & (MPU401_INFO_INPUT | MPU401_INFO_OUTPUT)))
539  info_flags |= MPU401_INFO_INPUT | MPU401_INFO_OUTPUT;
540  in_enable = (info_flags & MPU401_INFO_INPUT) ? 1 : 0;
541  out_enable = (info_flags & MPU401_INFO_OUTPUT) ? 1 : 0;
542  if ((err = snd_rawmidi_new(card, "MPU-401U", device,
543  out_enable, in_enable, &rmidi)) < 0)
544  return err;
545  mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
546  if (mpu == NULL) {
547  snd_printk(KERN_ERR "mpu401_uart: cannot allocate\n");
548  snd_device_free(card, rmidi);
549  return -ENOMEM;
550  }
551  rmidi->private_data = mpu;
552  rmidi->private_free = snd_mpu401_uart_free;
553  spin_lock_init(&mpu->input_lock);
555  spin_lock_init(&mpu->timer_lock);
556  mpu->hardware = hardware;
557  mpu->irq = -1;
558  if (! (info_flags & MPU401_INFO_INTEGRATED)) {
559  int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
560  mpu->res = request_region(port, res_size, "MPU401 UART");
561  if (mpu->res == NULL) {
562  snd_printk(KERN_ERR "mpu401_uart: "
563  "unable to grab port 0x%lx size %d\n",
564  port, res_size);
565  snd_device_free(card, rmidi);
566  return -EBUSY;
567  }
568  }
569  if (info_flags & MPU401_INFO_MMIO) {
570  mpu->write = mpu401_write_mmio;
571  mpu->read = mpu401_read_mmio;
572  } else {
573  mpu->write = mpu401_write_port;
574  mpu->read = mpu401_read_port;
575  }
576  mpu->port = port;
577  if (hardware == MPU401_HW_PC98II)
578  mpu->cport = port + 2;
579  else
580  mpu->cport = port + 1;
581  if (irq >= 0) {
583  "MPU401 UART", (void *) mpu)) {
584  snd_printk(KERN_ERR "mpu401_uart: "
585  "unable to grab IRQ %d\n", irq);
586  snd_device_free(card, rmidi);
587  return -EBUSY;
588  }
589  }
590  if (irq < 0 && !(info_flags & MPU401_INFO_IRQ_HOOK))
591  info_flags |= MPU401_INFO_USE_TIMER;
592  mpu->info_flags = info_flags;
593  mpu->irq = irq;
594  if (card->shortname[0])
595  snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI",
596  card->shortname);
597  else
598  sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device);
599  if (out_enable) {
601  &snd_mpu401_uart_output);
603  }
604  if (in_enable) {
606  &snd_mpu401_uart_input);
608  if (out_enable)
610  }
611  mpu->rmidi = rmidi;
612  if (rrawmidi)
613  *rrawmidi = rmidi;
614  return 0;
615 }
616 
618 
619 /*
620  * INIT part
621  */
622 
623 static int __init alsa_mpu401_uart_init(void)
624 {
625  return 0;
626 }
627 
628 static void __exit alsa_mpu401_uart_exit(void)
629 {
630 }
631 
632 module_init(alsa_mpu401_uart_init)
633 module_exit(alsa_mpu401_uart_exit)