sound/pci/emu10k1/emumpu401.c

   1 /*
   2  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
   3  *  Routines for control of EMU10K1 MPU-401 in UART mode
   4  *
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19  *
  20  */
  21
  22 #include <sound/driver.h>
  23 #include <linux/time.h>
  24 #include <linux/init.h>
  25 #include <sound/core.h>
  26 #include <sound/emu10k1.h>
  27
  28 #define EMU10K1_MIDI_MODE_INPUT         (1<<0)
  29 #define EMU10K1_MIDI_MODE_OUTPUT        (1<<1)
  30
  31 static inline unsigned char mpu401_read(struct snd_emu10k1 *emu,
  32                                         struct snd_emu10k1_midi *mpu, int idx)
  33 {
  34         if (emu->audigy)
  35                 return (unsigned char)snd_emu10k1_ptr_read(emu, mpu->port + idx, 0);
  36         else
  37                 return inb(emu->port + mpu->port + idx);
  38 }
  39
  40 static inline void mpu401_write(struct snd_emu10k1 *emu,
  41                                 struct snd_emu10k1_midi *mpu, int data, int idx)
  42 {
  43         if (emu->audigy)
  44                 snd_emu10k1_ptr_write(emu, mpu->port + idx, 0, data);
  45         else
  46                 outb(data, emu->port + mpu->port + idx);
  47 }
  48
  49 #define mpu401_write_data(emu, mpu, data)       mpu401_write(emu, mpu, data, 0)
  50 #define mpu401_write_cmd(emu, mpu, data)        mpu401_write(emu, mpu, data, 1)
  51 #define mpu401_read_data(emu, mpu)              mpu401_read(emu, mpu, 0)
  52 #define mpu401_read_stat(emu, mpu)              mpu401_read(emu, mpu, 1)
  53
  54 #define mpu401_input_avail(emu,mpu)     (!(mpu401_read_stat(emu,mpu) & 0x80))
  55 #define mpu401_output_ready(emu,mpu)    (!(mpu401_read_stat(emu,mpu) & 0x40))
  56
  57 #define MPU401_RESET            0xff
  58 #define MPU401_ENTER_UART       0x3f
  59 #define MPU401_ACK              0xfe
  60
  61 static void mpu401_clear_rx(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *mpu)
  62 {
  63         int timeout = 100000;
  64         for (; timeout > 0 && mpu401_input_avail(emu, mpu); timeout--)
  65                 mpu401_read_data(emu, mpu);
  66 #ifdef CONFIG_SND_DEBUG
  67         if (timeout <= 0)
  68                 snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n", mpu401_read_stat(emu, mpu));
  69 #endif
  70 }
  71
  72 /*
  73
  74  */
  75
  76 static void do_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, unsigned int status)
  77 {
  78         unsigned char byte;
  79
  80         if (midi->rmidi == NULL) {
  81                 snd_emu10k1_intr_disable(emu, midi->tx_enable | midi->rx_enable);
  82                 return;
  83         }
  84
  85         spin_lock(&midi->input_lock);
  86         if ((status & midi->ipr_rx) && mpu401_input_avail(emu, midi)) {
  87                 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
  88                         mpu401_clear_rx(emu, midi);
  89                 } else {
  90                         byte = mpu401_read_data(emu, midi);
  91                         if (midi->substream_input)
  92                                 snd_rawmidi_receive(midi->substream_input, &byte, 1);
  93                 }
  94         }
  95         spin_unlock(&midi->input_lock);
  96
  97         spin_lock(&midi->output_lock);
  98         if ((status & midi->ipr_tx) && mpu401_output_ready(emu, midi)) {
  99                 if (midi->substream_output &&
 100                     snd_rawmidi_transmit(midi->substream_output, &byte, 1) == 1) {
 101                         mpu401_write_data(emu, midi, byte);
 102                 } else {
 103                         snd_emu10k1_intr_disable(emu, midi->tx_enable);
 104                 }
 105         }
 106         spin_unlock(&midi->output_lock);
 107 }
 108
 109 static void snd_emu10k1_midi_interrupt(struct snd_emu10k1 *emu, unsigned int status)
 110 {
 111         do_emu10k1_midi_interrupt(emu, &emu->midi, status);
 112 }
 113
 114 static void snd_emu10k1_midi_interrupt2(struct snd_emu10k1 *emu, unsigned int status)
 115 {
 116         do_emu10k1_midi_interrupt(emu, &emu->midi2, status);
 117 }
 118
 119 static void snd_emu10k1_midi_cmd(struct snd_emu10k1 * emu, struct snd_emu10k1_midi *midi, unsigned char cmd, int ack)
 120 {
 121         unsigned long flags;
 122         int timeout, ok;
 123
 124         spin_lock_irqsave(&midi->input_lock, flags);
 125         mpu401_write_data(emu, midi, 0x00);
 126         /* mpu401_clear_rx(emu, midi); */
 127
 128         mpu401_write_cmd(emu, midi, cmd);
 129         if (ack) {
 130                 ok = 0;
 131                 timeout = 10000;
 132                 while (!ok && timeout-- > 0) {
 133                         if (mpu401_input_avail(emu, midi)) {
 134                                 if (mpu401_read_data(emu, midi) == MPU401_ACK)
 135                                         ok = 1;
 136                         }
 137                 }
 138                 if (!ok && mpu401_read_data(emu, midi) == MPU401_ACK)
 139                         ok = 1;
 140         } else {
 141                 ok = 1;
 142         }
 143         spin_unlock_irqrestore(&midi->input_lock, flags);
 144         if (!ok)
 145                 snd_printk(KERN_ERR "midi_cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)!!!\n",
 146                            cmd, emu->port,
 147                            mpu401_read_stat(emu, midi),
 148                            mpu401_read_data(emu, midi));
 149 }
 150
 151 static int snd_emu10k1_midi_input_open(struct snd_rawmidi_substream *substream)
 152 {
 153         struct snd_emu10k1 *emu;
 154         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
 155         unsigned long flags;
 156
 157         emu = midi->emu;
 158         snd_assert(emu, return -ENXIO);
 159         spin_lock_irqsave(&midi->open_lock, flags);
 160         midi->midi_mode |= EMU10K1_MIDI_MODE_INPUT;
 161         midi->substream_input = substream;
 162         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
 163                 spin_unlock_irqrestore(&midi->open_lock, flags);
 164                 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1);
 165                 snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1);
 166         } else {
 167                 spin_unlock_irqrestore(&midi->open_lock, flags);
 168         }
 169         return 0;
 170 }
 171
 172 static int snd_emu10k1_midi_output_open(struct snd_rawmidi_substream *substream)
 173 {
 174         struct snd_emu10k1 *emu;
 175         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
 176         unsigned long flags;
 177
 178         emu = midi->emu;
 179         snd_assert(emu, return -ENXIO);
 180         spin_lock_irqsave(&midi->open_lock, flags);
 181         midi->midi_mode |= EMU10K1_MIDI_MODE_OUTPUT;
 182         midi->substream_output = substream;
 183         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
 184                 spin_unlock_irqrestore(&midi->open_lock, flags);
 185                 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 1);
 186                 snd_emu10k1_midi_cmd(emu, midi, MPU401_ENTER_UART, 1);
 187         } else {
 188                 spin_unlock_irqrestore(&midi->open_lock, flags);
 189         }
 190         return 0;
 191 }
 192
 193 static int snd_emu10k1_midi_input_close(struct snd_rawmidi_substream *substream)
 194 {
 195         struct snd_emu10k1 *emu;
 196         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
 197         unsigned long flags;
 198
 199         emu = midi->emu;
 200         snd_assert(emu, return -ENXIO);
 201         spin_lock_irqsave(&midi->open_lock, flags);
 202         snd_emu10k1_intr_disable(emu, midi->rx_enable);
 203         midi->midi_mode &= ~EMU10K1_MIDI_MODE_INPUT;
 204         midi->substream_input = NULL;
 205         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT)) {
 206                 spin_unlock_irqrestore(&midi->open_lock, flags);
 207                 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
 208         } else {
 209                 spin_unlock_irqrestore(&midi->open_lock, flags);
 210         }
 211         return 0;
 212 }
 213
 214 static int snd_emu10k1_midi_output_close(struct snd_rawmidi_substream *substream)
 215 {
 216         struct snd_emu10k1 *emu;
 217         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
 218         unsigned long flags;
 219
 220         emu = midi->emu;
 221         snd_assert(emu, return -ENXIO);
 222         spin_lock_irqsave(&midi->open_lock, flags);
 223         snd_emu10k1_intr_disable(emu, midi->tx_enable);
 224         midi->midi_mode &= ~EMU10K1_MIDI_MODE_OUTPUT;
 225         midi->substream_output = NULL;
 226         if (!(midi->midi_mode & EMU10K1_MIDI_MODE_INPUT)) {
 227                 spin_unlock_irqrestore(&midi->open_lock, flags);
 228                 snd_emu10k1_midi_cmd(emu, midi, MPU401_RESET, 0);
 229         } else {
 230                 spin_unlock_irqrestore(&midi->open_lock, flags);
 231         }
 232         return 0;
 233 }
 234
 235 static void snd_emu10k1_midi_input_trigger(struct snd_rawmidi_substream *substream, int up)
 236 {
 237         struct snd_emu10k1 *emu;
 238         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
 239         emu = midi->emu;
 240         snd_assert(emu, return);
 241
 242         if (up)
 243                 snd_emu10k1_intr_enable(emu, midi->rx_enable);
 244         else
 245                 snd_emu10k1_intr_disable(emu, midi->rx_enable);
 246 }
 247
 248 static void snd_emu10k1_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
 249 {
 250         struct snd_emu10k1 *emu;
 251         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)substream->rmidi->private_data;
 252         unsigned long flags;
 253
 254         emu = midi->emu;
 255         snd_assert(emu, return);
 256
 257         if (up) {
 258                 int max = 4;
 259                 unsigned char byte;
 260
 261                 /* try to send some amount of bytes here before interrupts */
 262                 spin_lock_irqsave(&midi->output_lock, flags);
 263                 while (max > 0) {
 264                         if (mpu401_output_ready(emu, midi)) {
 265                                 if (!(midi->midi_mode & EMU10K1_MIDI_MODE_OUTPUT) ||
 266                                     snd_rawmidi_transmit(substream, &byte, 1) != 1) {
 267                                         /* no more data */
 268                                         spin_unlock_irqrestore(&midi->output_lock, flags);
 269                                         return;
 270                                 }
 271                                 mpu401_write_data(emu, midi, byte);
 272                                 max--;
 273                         } else {
 274                                 break;
 275                         }
 276                 }
 277                 spin_unlock_irqrestore(&midi->output_lock, flags);
 278                 snd_emu10k1_intr_enable(emu, midi->tx_enable);
 279         } else {
 280                 snd_emu10k1_intr_disable(emu, midi->tx_enable);
 281         }
 282 }
 283
 284 /*
 285
 286  */
 287
 288 static struct snd_rawmidi_ops snd_emu10k1_midi_output =
 289 {
 290         .open =         snd_emu10k1_midi_output_open,
 291         .close =        snd_emu10k1_midi_output_close,
 292         .trigger =      snd_emu10k1_midi_output_trigger,
 293 };
 294
 295 static struct snd_rawmidi_ops snd_emu10k1_midi_input =
 296 {
 297         .open =         snd_emu10k1_midi_input_open,
 298         .close =        snd_emu10k1_midi_input_close,
 299         .trigger =      snd_emu10k1_midi_input_trigger,
 300 };
 301
 302 static void snd_emu10k1_midi_free(struct snd_rawmidi *rmidi)
 303 {
 304         struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)rmidi->private_data;
 305         midi->interrupt = NULL;
 306         midi->rmidi = NULL;
 307 }
 308
 309 static int __devinit emu10k1_midi_init(struct snd_emu10k1 *emu, struct snd_emu10k1_midi *midi, int device, char *name)
 310 {
 311         struct snd_rawmidi *rmidi;
 312         int err;
 313
 314         if ((err = snd_rawmidi_new(emu->card, name, device, 1, 1, &rmidi)) < 0)
 315                 return err;
 316         midi->emu = emu;
 317         spin_lock_init(&midi->open_lock);
 318         spin_lock_init(&midi->input_lock);
 319         spin_lock_init(&midi->output_lock);
 320         strcpy(rmidi->name, name);
 321         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_emu10k1_midi_output);
 322         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_emu10k1_midi_input);
 323         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
 324                              SNDRV_RAWMIDI_INFO_INPUT |
 325                              SNDRV_RAWMIDI_INFO_DUPLEX;
 326         rmidi->private_data = midi;
 327         rmidi->private_free = snd_emu10k1_midi_free;
 328         midi->rmidi = rmidi;
 329         return 0;
 330 }
 331
 332 int __devinit snd_emu10k1_midi(struct snd_emu10k1 *emu)
 333 {
 334         struct snd_emu10k1_midi *midi = &emu->midi;
 335         int err;
 336
 337         if ((err = emu10k1_midi_init(emu, midi, 0, "EMU10K1 MPU-401 (UART)")) < 0)
 338                 return err;
 339
 340         midi->tx_enable = INTE_MIDITXENABLE;
 341         midi->rx_enable = INTE_MIDIRXENABLE;
 342         midi->port = MUDATA;
 343         midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
 344         midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
 345         midi->interrupt = snd_emu10k1_midi_interrupt;
 346         return 0;
 347 }
 348
 349 int __devinit snd_emu10k1_audigy_midi(struct snd_emu10k1 *emu)
 350 {
 351         struct snd_emu10k1_midi *midi;
 352         int err;
 353
 354         midi = &emu->midi;
 355         if ((err = emu10k1_midi_init(emu, midi, 0, "Audigy MPU-401 (UART)")) < 0)
 356                 return err;
 357
 358         midi->tx_enable = INTE_MIDITXENABLE;
 359         midi->rx_enable = INTE_MIDIRXENABLE;
 360         midi->port = A_MUDATA1;
 361         midi->ipr_tx = IPR_MIDITRANSBUFEMPTY;
 362         midi->ipr_rx = IPR_MIDIRECVBUFEMPTY;
 363         midi->interrupt = snd_emu10k1_midi_interrupt;
 364
 365         midi = &emu->midi2;
 366         if ((err = emu10k1_midi_init(emu, midi, 1, "Audigy MPU-401 #2")) < 0)
 367                 return err;
 368
 369         midi->tx_enable = INTE_A_MIDITXENABLE2;
 370         midi->rx_enable = INTE_A_MIDIRXENABLE2;
 371         midi->port = A_MUDATA2;
 372         midi->ipr_tx = IPR_A_MIDITRANSBUFEMPTY2;
 373         midi->ipr_rx = IPR_A_MIDIRECVBUFEMPTY2;
 374         midi->interrupt = snd_emu10k1_midi_interrupt2;
 375         return 0;
 376 }