sound/drivers/mpu401/mpu401_uart.c

   1 /*
   2  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
   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. Also, if irq < 0, then
   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 <sound/driver.h>
  32 #include <asm/io.h>
  33 #include <linux/delay.h>
  34 #include <linux/init.h>
  35 #include <linux/slab.h>
  36 #include <linux/ioport.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 <perex@suse.cz>");
  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)     (!(mpu->read(mpu, MPU401C(mpu)) & 0x80))
  54 #define snd_mpu401_output_ready(mpu)    (!(mpu->read(mpu, MPU401C(mpu)) & 0x40))
  55
  56 #define MPU401_RESET            0xff
  57 #define MPU401_ENTER_UART       0x3f
  58 #define MPU401_ACK              0xfe
  59
  60 /* Build in lowlevel io */
  61 static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr)
  62 {
  63         outb(data, addr);
  64 }
  65
  66 static unsigned char mpu401_read_port(struct snd_mpu401 *mpu, unsigned long addr)
  67 {
  68         return inb(addr);
  69 }
  70
  71 static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data, unsigned long addr)
  72 {
  73         writeb(data, (void __iomem *)addr);
  74 }
  75
  76 static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu, unsigned long addr)
  77 {
  78         return readb((void __iomem *)addr);
  79 }
  80 /*  */
  81
  82 static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
  83 {
  84         int timeout = 100000;
  85         for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--)
  86                 mpu->read(mpu, MPU401D(mpu));
  87 #ifdef CONFIG_SND_DEBUG
  88         if (timeout <= 0)
  89                 snd_printk("cmd: clear rx timeout (status = 0x%x)\n", mpu->read(mpu, MPU401C(mpu)));
  90 #endif
  91 }
  92
  93 static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
  94 {
  95         spin_lock(&mpu->input_lock);
  96         if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
  97                 snd_mpu401_uart_input_read(mpu);
  98         } else {
  99                 snd_mpu401_uart_clear_rx(mpu);
 100         }
 101         spin_unlock(&mpu->input_lock);
 102         /* ok. for better Tx performance try do some output when input is done */
 103         if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
 104             test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) {
 105                 spin_lock(&mpu->output_lock);
 106                 snd_mpu401_uart_output_write(mpu);
 107                 spin_unlock(&mpu->output_lock);
 108         }
 109 }
 110
 111 /**
 112  * snd_mpu401_uart_interrupt - generic MPU401-UART interrupt handler
 113  * @irq: the irq number
 114  * @dev_id: mpu401 instance
 115  * @regs: the reigster
 116  *
 117  * Processes the interrupt for MPU401-UART i/o.
 118  */
 119 irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 120 {
 121         struct snd_mpu401 *mpu = dev_id;
 122
 123         if (mpu == NULL)
 124                 return IRQ_NONE;
 125         _snd_mpu401_uart_interrupt(mpu);
 126         return IRQ_HANDLED;
 127 }
 128
 129 /*
 130  * timer callback
 131  * reprogram the timer and call the interrupt job
 132  */
 133 static void snd_mpu401_uart_timer(unsigned long data)
 134 {
 135         struct snd_mpu401 *mpu = (struct snd_mpu401 *)data;
 136         unsigned long flags;
 137
 138         spin_lock_irqsave(&mpu->timer_lock, flags);
 139         /*mpu->mode |= MPU401_MODE_TIMER;*/
 140         mpu->timer.expires = 1 + jiffies;
 141         add_timer(&mpu->timer);
 142         spin_unlock_irqrestore(&mpu->timer_lock, flags);
 143         if (mpu->rmidi)
 144                 _snd_mpu401_uart_interrupt(mpu);
 145 }
 146
 147 /*
 148  * initialize the timer callback if not programmed yet
 149  */
 150 static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
 151 {
 152         unsigned long flags;
 153
 154         spin_lock_irqsave (&mpu->timer_lock, flags);
 155         if (mpu->timer_invoked == 0) {
 156                 init_timer(&mpu->timer);
 157                 mpu->timer.data = (unsigned long)mpu;
 158                 mpu->timer.function = snd_mpu401_uart_timer;
 159                 mpu->timer.expires = 1 + jiffies;
 160                 add_timer(&mpu->timer);
 161         }
 162         mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER : MPU401_MODE_OUTPUT_TIMER;
 163         spin_unlock_irqrestore (&mpu->timer_lock, flags);
 164 }
 165
 166 /*
 167  * remove the timer callback if still active
 168  */
 169 static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
 170 {
 171         unsigned long flags;
 172
 173         spin_lock_irqsave (&mpu->timer_lock, flags);
 174         if (mpu->timer_invoked) {
 175                 mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER : ~MPU401_MODE_OUTPUT_TIMER;
 176                 if (! mpu->timer_invoked)
 177                         del_timer(&mpu->timer);
 178         }
 179         spin_unlock_irqrestore (&mpu->timer_lock, flags);
 180 }
 181
 182 /*
 183
 184  */
 185
 186 static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
 187                 int ack)
 188 {
 189         unsigned long flags;
 190         int timeout, ok;
 191
 192         spin_lock_irqsave(&mpu->input_lock, flags);
 193         if (mpu->hardware != MPU401_HW_TRID4DWAVE) {
 194                 mpu->write(mpu, 0x00, MPU401D(mpu));
 195                 /*snd_mpu401_uart_clear_rx(mpu);*/
 196         }
 197         /* ok. standard MPU-401 initialization */
 198         if (mpu->hardware != MPU401_HW_SB) {
 199                 for (timeout = 1000; timeout > 0 && !snd_mpu401_output_ready(mpu); timeout--)
 200                         udelay(10);
 201 #ifdef CONFIG_SND_DEBUG
 202                 if (!timeout)
 203                         snd_printk("cmd: tx timeout (status = 0x%x)\n", mpu->read(mpu, MPU401C(mpu)));
 204 #endif
 205         }
 206         mpu->write(mpu, cmd, MPU401C(mpu));
 207         if (ack) {
 208                 ok = 0;
 209                 timeout = 10000;
 210                 while (!ok && timeout-- > 0) {
 211                         if (snd_mpu401_input_avail(mpu)) {
 212                                 if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
 213                                         ok = 1;
 214                         }
 215                 }
 216                 if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
 217                         ok = 1;
 218         } else {
 219                 ok = 1;
 220         }
 221         spin_unlock_irqrestore(&mpu->input_lock, flags);
 222         if (!ok) {
 223                 snd_printk("cmd: 0x%x failed at 0x%lx (status = 0x%x, data = 0x%x)\n", cmd, mpu->port, mpu->read(mpu, MPU401C(mpu)), mpu->read(mpu, MPU401D(mpu)));
 224                 return 1;
 225         }
 226         return 0;
 227 }
 228
 229 /*
 230  * input/output open/close - protected by open_mutex in rawmidi.c
 231  */
 232 static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream)
 233 {
 234         struct snd_mpu401 *mpu;
 235         int err;
 236
 237         mpu = substream->rmidi->private_data;
 238         if (mpu->open_input && (err = mpu->open_input(mpu)) < 0)
 239                 return err;
 240         if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) {
 241                 if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
 242                         goto error_out;
 243                 if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 1))
 244                         goto error_out;
 245         }
 246         mpu->substream_input = substream;
 247         set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
 248         return 0;
 249
 250 error_out:
 251         if (mpu->open_input && mpu->close_input)
 252                 mpu->close_input(mpu);
 253         return -EIO;
 254 }
 255
 256 static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
 257 {
 258         struct snd_mpu401 *mpu;
 259         int err;
 260
 261         mpu = substream->rmidi->private_data;
 262         if (mpu->open_output && (err = mpu->open_output(mpu)) < 0)
 263                 return err;
 264         if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
 265                 if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
 266                         goto error_out;
 267                 if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 1))
 268                         goto error_out;
 269         }
 270         mpu->substream_output = substream;
 271         set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
 272         return 0;
 273
 274 error_out:
 275         if (mpu->open_output && mpu->close_output)
 276                 mpu->close_output(mpu);
 277         return -EIO;
 278 }
 279
 280 static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
 281 {
 282         struct snd_mpu401 *mpu;
 283         int err = 0;
 284
 285         mpu = substream->rmidi->private_data;
 286         clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
 287         mpu->substream_input = NULL;
 288         if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode))
 289                 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
 290         if (mpu->close_input)
 291                 mpu->close_input(mpu);
 292         if (err)
 293                 return -EIO;
 294         return 0;
 295 }
 296
 297 static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
 298 {
 299         struct snd_mpu401 *mpu;
 300         int err = 0;
 301
 302         mpu = substream->rmidi->private_data;
 303         clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
 304         mpu->substream_output = NULL;
 305         if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
 306                 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
 307         if (mpu->close_output)
 308                 mpu->close_output(mpu);
 309         if (err)
 310                 return -EIO;
 311         return 0;
 312 }
 313
 314 /*
 315  * trigger input callback
 316  */
 317 static void snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
 318 {
 319         unsigned long flags;
 320         struct snd_mpu401 *mpu;
 321         int max = 64;
 322
 323         mpu = substream->rmidi->private_data;
 324         if (up) {
 325                 if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode)) {
 326                         /* first time - flush FIFO */
 327                         while (max-- > 0)
 328                                 mpu->read(mpu, MPU401D(mpu));
 329                         if (mpu->irq < 0)
 330                                 snd_mpu401_uart_add_timer(mpu, 1);
 331                 }
 332
 333                 /* read data in advance */
 334                 spin_lock_irqsave(&mpu->input_lock, flags);
 335                 snd_mpu401_uart_input_read(mpu);
 336                 spin_unlock_irqrestore(&mpu->input_lock, flags);
 337         } else {
 338                 if (mpu->irq < 0)
 339                         snd_mpu401_uart_remove_timer(mpu, 1);
 340                 clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode);
 341         }
 342
 343 }
 344
 345 /*
 346  * transfer input pending data
 347  * call with input_lock spinlock held
 348  */
 349 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
 350 {
 351         int max = 128;
 352         unsigned char byte;
 353
 354         while (max-- > 0) {
 355                 if (snd_mpu401_input_avail(mpu)) {
 356                         byte = mpu->read(mpu, MPU401D(mpu));
 357                         if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
 358                                 snd_rawmidi_receive(mpu->substream_input, &byte, 1);
 359                 } else {
 360                         break; /* input not available */
 361                 }
 362         }
 363 }
 364
 365 /*
 366  *  Tx FIFO sizes:
 367  *    CS4237B                   - 16 bytes
 368  *    AudioDrive ES1688         - 12 bytes
 369  *    S3 SonicVibes             -  8 bytes
 370  *    SoundBlaster AWE 64       -  2 bytes (ugly hardware)
 371  */
 372
 373 /*
 374  * write output pending bytes
 375  * call with output_lock spinlock held
 376  */
 377 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
 378 {
 379         unsigned char byte;
 380         int max = 256, timeout;
 381
 382         do {
 383                 if (snd_rawmidi_transmit_peek(mpu->substream_output, &byte, 1) == 1) {
 384                         for (timeout = 100; timeout > 0; timeout--) {
 385                                 if (snd_mpu401_output_ready(mpu)) {
 386                                         mpu->write(mpu, byte, MPU401D(mpu));
 387                                         snd_rawmidi_transmit_ack(mpu->substream_output, 1);
 388                                         break;
 389                                 }
 390                         }
 391                         if (timeout == 0)
 392                                 break;  /* Tx FIFO full - try again later */
 393                 } else {
 394                         snd_mpu401_uart_remove_timer (mpu, 0);
 395                         break;  /* no other data - leave the tx loop */
 396                 }
 397         } while (--max > 0);
 398 }
 399
 400 /*
 401  * output trigger callback
 402  */
 403 static void snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
 404 {
 405         unsigned long flags;
 406         struct snd_mpu401 *mpu;
 407
 408         mpu = substream->rmidi->private_data;
 409         if (up) {
 410                 set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
 411
 412                 /* try to add the timer at each output trigger,
 413                  * since the output timer might have been removed in
 414                  * snd_mpu401_uart_output_write().
 415                  */
 416                 snd_mpu401_uart_add_timer(mpu, 0);
 417
 418                 /* output pending data */
 419                 spin_lock_irqsave(&mpu->output_lock, flags);
 420                 snd_mpu401_uart_output_write(mpu);
 421                 spin_unlock_irqrestore(&mpu->output_lock, flags);
 422         } else {
 423                 snd_mpu401_uart_remove_timer(mpu, 0);
 424                 clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
 425         }
 426 }
 427
 428 /*
 429
 430  */
 431
 432 static struct snd_rawmidi_ops snd_mpu401_uart_output =
 433 {
 434         .open =         snd_mpu401_uart_output_open,
 435         .close =        snd_mpu401_uart_output_close,
 436         .trigger =      snd_mpu401_uart_output_trigger,
 437 };
 438
 439 static struct snd_rawmidi_ops snd_mpu401_uart_input =
 440 {
 441         .open =         snd_mpu401_uart_input_open,
 442         .close =        snd_mpu401_uart_input_close,
 443         .trigger =      snd_mpu401_uart_input_trigger,
 444 };
 445
 446 static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
 447 {
 448         struct snd_mpu401 *mpu = rmidi->private_data;
 449         if (mpu->irq_flags && mpu->irq >= 0)
 450                 free_irq(mpu->irq, (void *) mpu);
 451         release_and_free_resource(mpu->res);
 452         kfree(mpu);
 453 }
 454
 455 /**
 456  * snd_mpu401_uart_new - create an MPU401-UART instance
 457  * @card: the card instance
 458  * @device: the device index, zero-based
 459  * @hardware: the hardware type, MPU401_HW_XXXX
 460  * @port: the base address of MPU401 port
 461  * @integrated: non-zero if the port was already reserved by the chip
 462  * @irq: the irq number, -1 if no interrupt for mpu
 463  * @irq_flags: the irq request flags (SA_XXX), 0 if irq was already reserved.
 464  * @rrawmidi: the pointer to store the new rawmidi instance
 465  *
 466  * Creates a new MPU-401 instance.
 467  *
 468  * Note that the rawmidi instance is returned on the rrawmidi argument,
 469  * not the mpu401 instance itself.  To access to the mpu401 instance,
 470  * cast from rawmidi->private_data (with struct snd_mpu401 magic-cast).
 471  *
 472  * Returns zero if successful, or a negative error code.
 473  */
 474 int snd_mpu401_uart_new(struct snd_card *card, int device,
 475                         unsigned short hardware,
 476                         unsigned long port, int integrated,
 477                         int irq, int irq_flags,
 478                         struct snd_rawmidi ** rrawmidi)
 479 {
 480         struct snd_mpu401 *mpu;
 481         struct snd_rawmidi *rmidi;
 482         int err;
 483
 484         if (rrawmidi)
 485                 *rrawmidi = NULL;
 486         if ((err = snd_rawmidi_new(card, "MPU-401U", device, 1, 1, &rmidi)) < 0)
 487                 return err;
 488         mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
 489         if (mpu == NULL) {
 490                 snd_printk(KERN_ERR "mpu401_uart: cannot allocate\n");
 491                 snd_device_free(card, rmidi);
 492                 return -ENOMEM;
 493         }
 494         rmidi->private_data = mpu;
 495         rmidi->private_free = snd_mpu401_uart_free;
 496         spin_lock_init(&mpu->input_lock);
 497         spin_lock_init(&mpu->output_lock);
 498         spin_lock_init(&mpu->timer_lock);
 499         mpu->hardware = hardware;
 500         if (!integrated) {
 501                 int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
 502                 if ((mpu->res = request_region(port, res_size, "MPU401 UART")) == NULL) {
 503                         snd_printk(KERN_ERR "mpu401_uart: unable to grab port 0x%lx size %d\n", port, res_size);
 504                         snd_device_free(card, rmidi);
 505                         return -EBUSY;
 506                 }
 507         }
 508         switch (hardware) {
 509         case MPU401_HW_AUREAL:
 510                 mpu->write = mpu401_write_mmio;
 511                 mpu->read = mpu401_read_mmio;
 512                 break;
 513         default:
 514                 mpu->write = mpu401_write_port;
 515                 mpu->read = mpu401_read_port;
 516                 break;
 517         }
 518         mpu->port = port;
 519         if (hardware == MPU401_HW_PC98II)
 520                 mpu->cport = port + 2;
 521         else
 522                 mpu->cport = port + 1;
 523         if (irq >= 0 && irq_flags) {
 524                 if (request_irq(irq, snd_mpu401_uart_interrupt, irq_flags, "MPU401 UART", (void *) mpu)) {
 525                         snd_printk(KERN_ERR "mpu401_uart: unable to grab IRQ %d\n", irq);
 526                         snd_device_free(card, rmidi);
 527                         return -EBUSY;
 528                 }
 529         }
 530         mpu->irq = irq;
 531         mpu->irq_flags = irq_flags;
 532         if (card->shortname[0])
 533                 snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI", card->shortname);
 534         else
 535                 sprintf(rmidi->name, "MPU-401 MIDI %d-%d", card->number, device);
 536         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_mpu401_uart_output);
 537         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_mpu401_uart_input);
 538         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
 539                              SNDRV_RAWMIDI_INFO_INPUT |
 540                              SNDRV_RAWMIDI_INFO_DUPLEX;
 541         mpu->rmidi = rmidi;
 542         if (rrawmidi)
 543                 *rrawmidi = rmidi;
 544         return 0;
 545 }
 546
 547 EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
 548 EXPORT_SYMBOL(snd_mpu401_uart_new);
 549
 550 /*
 551  *  INIT part
 552  */
 553
 554 static int __init alsa_mpu401_uart_init(void)
 555 {
 556         return 0;
 557 }
 558
 559 static void __exit alsa_mpu401_uart_exit(void)
 560 {
 561 }
 562
 563 module_init(alsa_mpu401_uart_init)
 564 module_exit(alsa_mpu401_uart_exit)