drivers/sound/uart401.c

   1 /*
   2  * sound/uart401.c
   3  *
   4  * MPU-401 UART driver (formerly uart401_midi.c)
   5  */
   6 /*
   7  * Copyright (C) by Hannu Savolainen 1993-1997
   8  *
   9  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11  * for more info.
  12  */
  13 #include <linux/config.h>
  14 #include <linux/module.h>
  15
  16 #include "sound_config.h"
  17 #include "soundmodule.h"
  18
  19 #if (defined(CONFIG_UART401)||defined(CONFIG_MIDI)) || defined(MODULE)
  20
  21 typedef struct uart401_devc
  22   {
  23           int             base;
  24           int             irq;
  25           int            *osp;
  26           void            (*midi_input_intr) (int dev, unsigned char data);
  27           int             opened, disabled;
  28           volatile unsigned char input_byte;
  29           int             my_dev;
  30           int             share_irq;
  31   }
  32 uart401_devc;
  33
  34 static uart401_devc *detected_devc = NULL;
  35 static uart401_devc *irq2devc[16] =
  36 {NULL};
  37
  38 #define DATAPORT   (devc->base)
  39 #define COMDPORT   (devc->base+1)
  40 #define STATPORT   (devc->base+1)
  41
  42 static int
  43 uart401_status(uart401_devc * devc)
  44 {
  45         return inb(STATPORT);
  46 }
  47 #define input_avail(devc) (!(uart401_status(devc)&INPUT_AVAIL))
  48 #define output_ready(devc)      (!(uart401_status(devc)&OUTPUT_READY))
  49 static void
  50 uart401_cmd(uart401_devc * devc, unsigned char cmd)
  51 {
  52         outb((cmd), COMDPORT);
  53 }
  54 static int
  55 uart401_read(uart401_devc * devc)
  56 {
  57         return inb(DATAPORT);
  58 }
  59 static void
  60 uart401_write(uart401_devc * devc, unsigned char byte)
  61 {
  62         outb((byte), DATAPORT);
  63 }
  64
  65 #define OUTPUT_READY    0x40
  66 #define INPUT_AVAIL     0x80
  67 #define MPU_ACK         0xFE
  68 #define MPU_RESET       0xFF
  69 #define UART_MODE_ON    0x3F
  70
  71 static int      reset_uart401(uart401_devc * devc);
  72 static void     enter_uart_mode(uart401_devc * devc);
  73
  74 static void
  75 uart401_input_loop(uart401_devc * devc)
  76 {
  77         while (input_avail(devc))
  78           {
  79                   unsigned char   c = uart401_read(devc);
  80
  81                   if (c == MPU_ACK)
  82                           devc->input_byte = c;
  83                   else if (devc->opened & OPEN_READ && devc->midi_input_intr)
  84                           devc->midi_input_intr(devc->my_dev, c);
  85           }
  86 }
  87
  88 void
  89 uart401intr(int irq, void *dev_id, struct pt_regs *dummy)
  90 {
  91         uart401_devc   *devc;
  92
  93         if (irq < 1 || irq > 15)
  94                 return;
  95
  96         devc = irq2devc[irq];
  97
  98         if (devc == NULL)
  99                 return;
 100
 101         if (input_avail(devc))
 102                 uart401_input_loop(devc);
 103 }
 104
 105 static int
 106 uart401_open(int dev, int mode,
 107              void            (*input) (int dev, unsigned char data),
 108              void            (*output) (int dev)
 109 )
 110 {
 111         uart401_devc   *devc = (uart401_devc *) midi_devs[dev]->devc;
 112
 113         if (devc->opened)
 114           {
 115                   return -EBUSY;
 116           }
 117         while (input_avail(devc))
 118                 uart401_read(devc);
 119
 120         devc->midi_input_intr = input;
 121         devc->opened = mode;
 122         enter_uart_mode(devc);
 123         devc->disabled = 0;
 124
 125         return 0;
 126 }
 127
 128 static void
 129 uart401_close(int dev)
 130 {
 131         uart401_devc   *devc = (uart401_devc *) midi_devs[dev]->devc;
 132
 133         reset_uart401(devc);
 134         devc->opened = 0;
 135 }
 136
 137 static int
 138 uart401_out(int dev, unsigned char midi_byte)
 139 {
 140         int             timeout;
 141         unsigned long   flags;
 142         uart401_devc   *devc = (uart401_devc *) midi_devs[dev]->devc;
 143
 144         if (devc->disabled)
 145                 return 1;
 146         /*
 147          * Test for input since pending input seems to block the output.
 148          */
 149
 150         save_flags(flags);
 151         cli();
 152
 153         if (input_avail(devc))
 154                 uart401_input_loop(devc);
 155
 156         restore_flags(flags);
 157
 158         /*
 159          * Sometimes it takes about 13000 loops before the output becomes ready
 160          * (After reset). Normally it takes just about 10 loops.
 161          */
 162
 163         for (timeout = 30000; timeout > 0 && !output_ready(devc); timeout--);
 164
 165         if (!output_ready(devc))
 166           {
 167                   printk("MPU-401: Timeout - Device not responding\n");
 168                   devc->disabled = 1;
 169                   reset_uart401(devc);
 170                   enter_uart_mode(devc);
 171                   return 1;
 172           }
 173         uart401_write(devc, midi_byte);
 174         return 1;
 175 }
 176
 177 static int
 178 uart401_start_read(int dev)
 179 {
 180         return 0;
 181 }
 182
 183 static int
 184 uart401_end_read(int dev)
 185 {
 186         return 0;
 187 }
 188
 189 static void
 190 uart401_kick(int dev)
 191 {
 192 }
 193
 194 static int
 195 uart401_buffer_status(int dev)
 196 {
 197         return 0;
 198 }
 199
 200 #define MIDI_SYNTH_NAME "MPU-401 UART"
 201 #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
 202 #include "midi_synth.h"
 203
 204 static struct midi_operations uart401_operations =
 205 {
 206         {"MPU-401 (UART) MIDI", 0, 0, SNDCARD_MPU401},
 207         &std_midi_synth,
 208         {0},
 209         uart401_open,
 210         uart401_close,
 211         NULL, /* ioctl */
 212         uart401_out,
 213         uart401_start_read,
 214         uart401_end_read,
 215         uart401_kick,
 216         NULL,
 217         uart401_buffer_status,
 218         NULL
 219 };
 220
 221 static void
 222 enter_uart_mode(uart401_devc * devc)
 223 {
 224         int             ok, timeout;
 225         unsigned long   flags;
 226
 227         save_flags(flags);
 228         cli();
 229         for (timeout = 30000; timeout > 0 && !output_ready(devc); timeout--);
 230
 231         devc->input_byte = 0;
 232         uart401_cmd(devc, UART_MODE_ON);
 233
 234         ok = 0;
 235         for (timeout = 50000; timeout > 0 && !ok; timeout--)
 236                 if (devc->input_byte == MPU_ACK)
 237                         ok = 1;
 238                 else if (input_avail(devc))
 239                         if (uart401_read(devc) == MPU_ACK)
 240                                 ok = 1;
 241
 242         restore_flags(flags);
 243 }
 244
 245 void
 246 attach_uart401(struct address_info *hw_config)
 247 {
 248         uart401_devc   *devc;
 249         char           *name = "MPU-401 (UART) MIDI";
 250
 251         if (hw_config->name)
 252                 name = hw_config->name;
 253
 254         if (detected_devc == NULL)
 255                 return;
 256
 257
 258         devc = (uart401_devc *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(uart401_devc)));
 259         sound_mem_sizes[sound_nblocks] = sizeof(uart401_devc);
 260         if (sound_nblocks < 1024)
 261                 sound_nblocks++;;
 262         if (devc == NULL)
 263           {
 264                   printk(KERN_WARNING "uart401: Can't allocate memory\n");
 265                   return;
 266           }
 267         memcpy((char *) devc, (char *) detected_devc, sizeof(uart401_devc));
 268         detected_devc = NULL;
 269
 270         devc->irq = hw_config->irq;
 271         if (devc->irq < 0)
 272           {
 273                   devc->share_irq = 1;
 274                   devc->irq *= -1;
 275         } else
 276                 devc->share_irq = 0;
 277
 278         if (devc->irq < 1 || devc->irq > 15)
 279                 return;
 280
 281         if (!devc->share_irq)
 282                 if (snd_set_irq_handler(devc->irq, uart401intr, "MPU-401 UART", devc->osp) < 0)
 283                   {
 284                           printk(KERN_WARNING "uart401: Failed to allocate IRQ%d\n", devc->irq);
 285                           devc->share_irq = 1;
 286                   }
 287         irq2devc[devc->irq] = devc;
 288         devc->my_dev = sound_alloc_mididev();
 289
 290         request_region(hw_config->io_base, 4, "MPU-401 UART");
 291         enter_uart_mode(devc);
 292
 293         if (devc->my_dev == -1)
 294           {
 295                   printk(KERN_INFO "uart401: Too many midi devices detected\n");
 296                   return;
 297           }
 298         conf_printf(name, hw_config);
 299
 300         std_midi_synth.midi_dev = devc->my_dev;
 301
 302
 303         midi_devs[devc->my_dev] = (struct midi_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct midi_operations)));
 304         sound_mem_sizes[sound_nblocks] = sizeof(struct midi_operations);
 305
 306         if (sound_nblocks < 1024)
 307                 sound_nblocks++;;
 308         if (midi_devs[devc->my_dev] == NULL)
 309           {
 310                   printk("uart401: Failed to allocate memory\n");
 311                   sound_unload_mididev(devc->my_dev);
 312                   return;
 313           }
 314         memcpy((char *) midi_devs[devc->my_dev], (char *) &uart401_operations,
 315                sizeof(struct midi_operations));
 316
 317         midi_devs[devc->my_dev]->devc = devc;
 318
 319
 320         midi_devs[devc->my_dev]->converter = (struct synth_operations *) (sound_mem_blocks[sound_nblocks] = vmalloc(sizeof(struct synth_operations)));
 321         sound_mem_sizes[sound_nblocks] = sizeof(struct synth_operations);
 322
 323         if (sound_nblocks < 1024)
 324                 sound_nblocks++;
 325
 326         if (midi_devs[devc->my_dev]->converter == NULL)
 327           {
 328                   printk(KERN_WARNING "uart401: Failed to allocate memory\n");
 329                   sound_unload_mididev(devc->my_dev);
 330                   return;
 331           }
 332         memcpy((char *) midi_devs[devc->my_dev]->converter, (char *) &std_midi_synth,
 333                sizeof(struct synth_operations));
 334
 335         strcpy(midi_devs[devc->my_dev]->info.name, name);
 336         midi_devs[devc->my_dev]->converter->id = "UART401";
 337         hw_config->slots[4] = devc->my_dev;
 338         sequencer_init();
 339         devc->opened = 0;
 340 }
 341
 342 static int
 343 reset_uart401(uart401_devc * devc)
 344 {
 345         int             ok, timeout, n;
 346
 347         /*
 348          * Send the RESET command. Try again if no success at the first time.
 349          */
 350
 351         ok = 0;
 352
 353         for (n = 0; n < 2 && !ok; n++)
 354           {
 355                   for (timeout = 30000; timeout > 0 && !output_ready(devc); timeout--);
 356
 357                   devc->input_byte = 0;
 358                   uart401_cmd(devc, MPU_RESET);
 359
 360                   /*
 361                    * Wait at least 25 msec. This method is not accurate so let's make the
 362                    * loop bit longer. Cannot sleep since this is called during boot.
 363                    */
 364
 365                   for (timeout = 50000; timeout > 0 && !ok; timeout--)
 366                           if (devc->input_byte == MPU_ACK)      /* Interrupt */
 367                                   ok = 1;
 368                           else if (input_avail(devc))
 369                                   if (uart401_read(devc) == MPU_ACK)
 370                                           ok = 1;
 371
 372           }
 373
 374
 375         if (ok)
 376           {
 377                   DEB(printk("Reset UART401 OK\n"));
 378         } else
 379                 DDB(printk("Reset UART401 failed - No hardware detected.\n"));
 380
 381         if (ok)
 382                 uart401_input_loop(devc);       /*
 383                                                  * Flush input before enabling interrupts
 384                                                  */
 385
 386         return ok;
 387 }
 388
 389 int
 390 probe_uart401(struct address_info *hw_config)
 391 {
 392         int             ok = 0;
 393         unsigned long   flags;
 394
 395         static uart401_devc hw_info;
 396         uart401_devc   *devc = &hw_info;
 397
 398         DDB(printk("Entered probe_uart401()\n"));
 399
 400         detected_devc = NULL;
 401
 402         if (check_region(hw_config->io_base, 4))
 403                 return 0;
 404
 405         devc->base = hw_config->io_base;
 406         devc->irq = hw_config->irq;
 407         devc->osp = hw_config->osp;
 408         devc->midi_input_intr = NULL;
 409         devc->opened = 0;
 410         devc->input_byte = 0;
 411         devc->my_dev = 0;
 412         devc->share_irq = 0;
 413
 414         save_flags(flags);
 415         cli();
 416         ok = reset_uart401(devc);
 417         restore_flags(flags);
 418
 419         if (ok)
 420                 detected_devc = devc;
 421
 422         return ok;
 423 }
 424
 425 void
 426 unload_uart401(struct address_info *hw_config)
 427 {
 428         uart401_devc   *devc;
 429
 430         int             irq = hw_config->irq;
 431
 432         if (irq < 0)
 433           {
 434                   irq *= -1;
 435           }
 436         if (irq < 1 || irq > 15)
 437                 return;
 438
 439         devc = irq2devc[irq];
 440         if (devc == NULL)
 441                 return;
 442
 443         reset_uart401(devc);
 444         release_region(hw_config->io_base, 4);
 445
 446         if (!devc->share_irq)
 447                 snd_release_irq(devc->irq);
 448
 449         if (devc)
 450                 devc = NULL;
 451         sound_unload_mididev(hw_config->slots[4]);
 452 }
 453
 454 #ifdef MODULE
 455
 456 int             io = -1;
 457 int             irq = -1;
 458
 459 MODULE_PARM(io, "i");
 460 MODULE_PARM(irq, "i");
 461 struct address_info hw;
 462
 463 int
 464 init_module(void)
 465 {
 466         /* Can be loaded either for module use or to provide functions
 467            to others */
 468         if (io != -1 && irq != -1)
 469           {
 470                   printk("MPU-401 UART driver Copyright (C) Hannu Savolainen 1993-1997");
 471                   hw.irq = irq;
 472                   hw.io_base = io;
 473                   if (probe_uart401(&hw) == 0)
 474                           return -ENODEV;
 475                   attach_uart401(&hw);
 476           }
 477         SOUND_LOCK;
 478         return 0;
 479 }
 480
 481 void
 482 cleanup_module(void)
 483 {
 484         if (io != -1 && irq != -1)
 485           {
 486                   unload_uart401(&hw);
 487           }
 488         /*  FREE SYMTAB */
 489         SOUND_LOCK_END;
 490 }
 491
 492 #else
 493
 494 #endif
 495
 496 #endif
 497
 498 EXPORT_SYMBOL(attach_uart401);
 499 EXPORT_SYMBOL(probe_uart401);
 500 EXPORT_SYMBOL(unload_uart401);
 501 EXPORT_SYMBOL(uart401intr);