sound/drivers/mpu401/mpu401_uart.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   4  *  Routines for control of MPU-401 in UART mode
   5  *
   6  *  MPU-401 supports UART mode which is not capable generate transmit
   7  *  interrupts thus output is done via polling. Without interrupt,
   8  *  input is done also via polling. Do not expect good performance.
   9  *
  10  *   13-03-2003:
  11  *      Added support for different kind of hardware I/O. Build in choices
  12  *      are port and mmio. For other kind of I/O, set mpu->read and
  13  *      mpu->write to your own I/O functions.
  14  */
  15
  16 #include <linux/io.h>
  17 #include <linux/delay.h>
  18 #include <linux/init.h>
  19 #include <linux/slab.h>
  20 #include <linux/ioport.h>
  21 #include <linux/module.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/errno.h>
  24 #include <sound/core.h>
  25 #include <sound/mpu401.h>
  26
  27 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
  28 MODULE_DESCRIPTION("Routines for control of MPU-401 in UART mode");
  29 MODULE_LICENSE("GPL");
  30
  31 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu);
  32 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu);
  33
  34 /*
  35
  36  */
  37
  38 #define snd_mpu401_input_avail(mpu) \
  39         (!(mpu->read(mpu, MPU401C(mpu)) & MPU401_RX_EMPTY))
  40 #define snd_mpu401_output_ready(mpu) \
  41         (!(mpu->read(mpu, MPU401C(mpu)) & MPU401_TX_FULL))
  42
  43 /* Build in lowlevel io */
  44 static void mpu401_write_port(struct snd_mpu401 *mpu, unsigned char data,
  45                               unsigned long addr)
  46 {
  47         outb(data, addr);
  48 }
  49
  50 static unsigned char mpu401_read_port(struct snd_mpu401 *mpu,
  51                                       unsigned long addr)
  52 {
  53         return inb(addr);
  54 }
  55
  56 static void mpu401_write_mmio(struct snd_mpu401 *mpu, unsigned char data,
  57                               unsigned long addr)
  58 {
  59         writeb(data, (void __iomem *)addr);
  60 }
  61
  62 static unsigned char mpu401_read_mmio(struct snd_mpu401 *mpu,
  63                                       unsigned long addr)
  64 {
  65         return readb((void __iomem *)addr);
  66 }
  67 /*  */
  68
  69 static void snd_mpu401_uart_clear_rx(struct snd_mpu401 *mpu)
  70 {
  71         int timeout = 100000;
  72         for (; timeout > 0 && snd_mpu401_input_avail(mpu); timeout--)
  73                 mpu->read(mpu, MPU401D(mpu));
  74 #ifdef CONFIG_SND_DEBUG
  75         if (timeout <= 0)
  76                 snd_printk(KERN_ERR "cmd: clear rx timeout (status = 0x%x)\n",
  77                            mpu->read(mpu, MPU401C(mpu)));
  78 #endif
  79 }
  80
  81 static void uart_interrupt_tx(struct snd_mpu401 *mpu)
  82 {
  83         unsigned long flags;
  84
  85         if (test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode) &&
  86             test_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode)) {
  87                 spin_lock_irqsave(&mpu->output_lock, flags);
  88                 snd_mpu401_uart_output_write(mpu);
  89                 spin_unlock_irqrestore(&mpu->output_lock, flags);
  90         }
  91 }
  92
  93 static void _snd_mpu401_uart_interrupt(struct snd_mpu401 *mpu)
  94 {
  95         unsigned long flags;
  96
  97         if (mpu->info_flags & MPU401_INFO_INPUT) {
  98                 spin_lock_irqsave(&mpu->input_lock, flags);
  99                 if (test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
 100                         snd_mpu401_uart_input_read(mpu);
 101                 else
 102                         snd_mpu401_uart_clear_rx(mpu);
 103                 spin_unlock_irqrestore(&mpu->input_lock, flags);
 104         }
 105         if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
 106                 /* ok. for better Tx performance try do some output
 107                    when input is done */
 108                 uart_interrupt_tx(mpu);
 109 }
 110
 111 /**
 112  * snd_mpu401_uart_interrupt - generic MPU401-UART interrupt handler
 113  * @irq: the irq number
 114  * @dev_id: mpu401 instance
 115  *
 116  * Processes the interrupt for MPU401-UART i/o.
 117  *
 118  * Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
 119  */
 120 irqreturn_t snd_mpu401_uart_interrupt(int irq, void *dev_id)
 121 {
 122         struct snd_mpu401 *mpu = dev_id;
 123
 124         if (!mpu)
 125                 return IRQ_NONE;
 126         _snd_mpu401_uart_interrupt(mpu);
 127         return IRQ_HANDLED;
 128 }
 129
 130 EXPORT_SYMBOL(snd_mpu401_uart_interrupt);
 131
 132 /**
 133  * snd_mpu401_uart_interrupt_tx - generic MPU401-UART transmit irq handler
 134  * @irq: the irq number
 135  * @dev_id: mpu401 instance
 136  *
 137  * Processes the interrupt for MPU401-UART output.
 138  *
 139  * Return: %IRQ_HANDLED if the interrupt was handled. %IRQ_NONE otherwise.
 140  */
 141 irqreturn_t snd_mpu401_uart_interrupt_tx(int irq, void *dev_id)
 142 {
 143         struct snd_mpu401 *mpu = dev_id;
 144
 145         if (!mpu)
 146                 return IRQ_NONE;
 147         uart_interrupt_tx(mpu);
 148         return IRQ_HANDLED;
 149 }
 150
 151 EXPORT_SYMBOL(snd_mpu401_uart_interrupt_tx);
 152
 153 /*
 154  * timer callback
 155  * reprogram the timer and call the interrupt job
 156  */
 157 static void snd_mpu401_uart_timer(struct timer_list *t)
 158 {
 159         struct snd_mpu401 *mpu = from_timer(mpu, t, timer);
 160         unsigned long flags;
 161
 162         spin_lock_irqsave(&mpu->timer_lock, flags);
 163         /*mpu->mode |= MPU401_MODE_TIMER;*/
 164         mod_timer(&mpu->timer,  1 + jiffies);
 165         spin_unlock_irqrestore(&mpu->timer_lock, flags);
 166         if (mpu->rmidi)
 167                 _snd_mpu401_uart_interrupt(mpu);
 168 }
 169
 170 /*
 171  * initialize the timer callback if not programmed yet
 172  */
 173 static void snd_mpu401_uart_add_timer (struct snd_mpu401 *mpu, int input)
 174 {
 175         unsigned long flags;
 176
 177         spin_lock_irqsave (&mpu->timer_lock, flags);
 178         if (mpu->timer_invoked == 0) {
 179                 timer_setup(&mpu->timer, snd_mpu401_uart_timer, 0);
 180                 mod_timer(&mpu->timer, 1 + jiffies);
 181         }
 182         mpu->timer_invoked |= input ? MPU401_MODE_INPUT_TIMER :
 183                 MPU401_MODE_OUTPUT_TIMER;
 184         spin_unlock_irqrestore (&mpu->timer_lock, flags);
 185 }
 186
 187 /*
 188  * remove the timer callback if still active
 189  */
 190 static void snd_mpu401_uart_remove_timer (struct snd_mpu401 *mpu, int input)
 191 {
 192         unsigned long flags;
 193
 194         spin_lock_irqsave (&mpu->timer_lock, flags);
 195         if (mpu->timer_invoked) {
 196                 mpu->timer_invoked &= input ? ~MPU401_MODE_INPUT_TIMER :
 197                         ~MPU401_MODE_OUTPUT_TIMER;
 198                 if (! mpu->timer_invoked)
 199                         del_timer(&mpu->timer);
 200         }
 201         spin_unlock_irqrestore (&mpu->timer_lock, flags);
 202 }
 203
 204 /*
 205  * send a UART command
 206  * return zero if successful, non-zero for some errors
 207  */
 208
 209 static int snd_mpu401_uart_cmd(struct snd_mpu401 * mpu, unsigned char cmd,
 210                                int ack)
 211 {
 212         unsigned long flags;
 213         int timeout, ok;
 214
 215         spin_lock_irqsave(&mpu->input_lock, flags);
 216         if (mpu->hardware != MPU401_HW_TRID4DWAVE) {
 217                 mpu->write(mpu, 0x00, MPU401D(mpu));
 218                 /*snd_mpu401_uart_clear_rx(mpu);*/
 219         }
 220         /* ok. standard MPU-401 initialization */
 221         if (mpu->hardware != MPU401_HW_SB) {
 222                 for (timeout = 1000; timeout > 0 &&
 223                              !snd_mpu401_output_ready(mpu); timeout--)
 224                         udelay(10);
 225 #ifdef CONFIG_SND_DEBUG
 226                 if (!timeout)
 227                         snd_printk(KERN_ERR "cmd: tx timeout (status = 0x%x)\n",
 228                                    mpu->read(mpu, MPU401C(mpu)));
 229 #endif
 230         }
 231         mpu->write(mpu, cmd, MPU401C(mpu));
 232         if (ack && !(mpu->info_flags & MPU401_INFO_NO_ACK)) {
 233                 ok = 0;
 234                 timeout = 10000;
 235                 while (!ok && timeout-- > 0) {
 236                         if (snd_mpu401_input_avail(mpu)) {
 237                                 if (mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
 238                                         ok = 1;
 239                         }
 240                 }
 241                 if (!ok && mpu->read(mpu, MPU401D(mpu)) == MPU401_ACK)
 242                         ok = 1;
 243         } else
 244                 ok = 1;
 245         spin_unlock_irqrestore(&mpu->input_lock, flags);
 246         if (!ok) {
 247                 snd_printk(KERN_ERR "cmd: 0x%x failed at 0x%lx "
 248                            "(status = 0x%x, data = 0x%x)\n", cmd, mpu->port,
 249                            mpu->read(mpu, MPU401C(mpu)),
 250                            mpu->read(mpu, MPU401D(mpu)));
 251                 return 1;
 252         }
 253         return 0;
 254 }
 255
 256 static int snd_mpu401_do_reset(struct snd_mpu401 *mpu)
 257 {
 258         if (snd_mpu401_uart_cmd(mpu, MPU401_RESET, 1))
 259                 return -EIO;
 260         if (snd_mpu401_uart_cmd(mpu, MPU401_ENTER_UART, 0))
 261                 return -EIO;
 262         return 0;
 263 }
 264
 265 /*
 266  * input/output open/close - protected by open_mutex in rawmidi.c
 267  */
 268 static int snd_mpu401_uart_input_open(struct snd_rawmidi_substream *substream)
 269 {
 270         struct snd_mpu401 *mpu;
 271         int err;
 272
 273         mpu = substream->rmidi->private_data;
 274         if (mpu->open_input) {
 275                 err = mpu->open_input(mpu);
 276                 if (err < 0)
 277                         return err;
 278         }
 279         if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) {
 280                 if (snd_mpu401_do_reset(mpu) < 0)
 281                         goto error_out;
 282         }
 283         mpu->substream_input = substream;
 284         set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
 285         return 0;
 286
 287 error_out:
 288         if (mpu->open_input && mpu->close_input)
 289                 mpu->close_input(mpu);
 290         return -EIO;
 291 }
 292
 293 static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
 294 {
 295         struct snd_mpu401 *mpu;
 296         int err;
 297
 298         mpu = substream->rmidi->private_data;
 299         if (mpu->open_output) {
 300                 err = mpu->open_output(mpu);
 301                 if (err < 0)
 302                         return err;
 303         }
 304         if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
 305                 if (snd_mpu401_do_reset(mpu) < 0)
 306                         goto error_out;
 307         }
 308         mpu->substream_output = substream;
 309         set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
 310         return 0;
 311
 312 error_out:
 313         if (mpu->open_output && mpu->close_output)
 314                 mpu->close_output(mpu);
 315         return -EIO;
 316 }
 317
 318 static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
 319 {
 320         struct snd_mpu401 *mpu;
 321         int err = 0;
 322
 323         mpu = substream->rmidi->private_data;
 324         clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
 325         mpu->substream_input = NULL;
 326         if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode))
 327                 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
 328         if (mpu->close_input)
 329                 mpu->close_input(mpu);
 330         if (err)
 331                 return -EIO;
 332         return 0;
 333 }
 334
 335 static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
 336 {
 337         struct snd_mpu401 *mpu;
 338         int err = 0;
 339
 340         mpu = substream->rmidi->private_data;
 341         clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
 342         mpu->substream_output = NULL;
 343         if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
 344                 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
 345         if (mpu->close_output)
 346                 mpu->close_output(mpu);
 347         if (err)
 348                 return -EIO;
 349         return 0;
 350 }
 351
 352 /*
 353  * trigger input callback
 354  */
 355 static void
 356 snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
 357 {
 358         unsigned long flags;
 359         struct snd_mpu401 *mpu;
 360         int max = 64;
 361
 362         mpu = substream->rmidi->private_data;
 363         if (up) {
 364                 if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER,
 365                                        &mpu->mode)) {
 366                         /* first time - flush FIFO */
 367                         while (max-- > 0)
 368                                 mpu->read(mpu, MPU401D(mpu));
 369                         if (mpu->info_flags & MPU401_INFO_USE_TIMER)
 370                                 snd_mpu401_uart_add_timer(mpu, 1);
 371                 }
 372
 373                 /* read data in advance */
 374                 spin_lock_irqsave(&mpu->input_lock, flags);
 375                 snd_mpu401_uart_input_read(mpu);
 376                 spin_unlock_irqrestore(&mpu->input_lock, flags);
 377         } else {
 378                 if (mpu->info_flags & MPU401_INFO_USE_TIMER)
 379                         snd_mpu401_uart_remove_timer(mpu, 1);
 380                 clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode);
 381         }
 382
 383 }
 384
 385 /*
 386  * transfer input pending data
 387  * call with input_lock spinlock held
 388  */
 389 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
 390 {
 391         int max = 128;
 392         unsigned char byte;
 393
 394         while (max-- > 0) {
 395                 if (! snd_mpu401_input_avail(mpu))
 396                         break; /* input not available */
 397                 byte = mpu->read(mpu, MPU401D(mpu));
 398                 if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
 399                         snd_rawmidi_receive(mpu->substream_input, &byte, 1);
 400         }
 401 }
 402
 403 /*
 404  *  Tx FIFO sizes:
 405  *    CS4237B                   - 16 bytes
 406  *    AudioDrive ES1688         - 12 bytes
 407  *    S3 SonicVibes             -  8 bytes
 408  *    SoundBlaster AWE 64       -  2 bytes (ugly hardware)
 409  */
 410
 411 /*
 412  * write output pending bytes
 413  * call with output_lock spinlock held
 414  */
 415 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
 416 {
 417         unsigned char byte;
 418         int max = 256;
 419
 420         do {
 421                 if (snd_rawmidi_transmit_peek(mpu->substream_output,
 422                                               &byte, 1) == 1) {
 423                         /*
 424                          * Try twice because there is hardware that insists on
 425                          * setting the output busy bit after each write.
 426                          */
 427                         if (!snd_mpu401_output_ready(mpu) &&
 428                             !snd_mpu401_output_ready(mpu))
 429                                 break;  /* Tx FIFO full - try again later */
 430                         mpu->write(mpu, byte, MPU401D(mpu));
 431                         snd_rawmidi_transmit_ack(mpu->substream_output, 1);
 432                 } else {
 433                         snd_mpu401_uart_remove_timer (mpu, 0);
 434                         break;  /* no other data - leave the tx loop */
 435                 }
 436         } while (--max > 0);
 437 }
 438
 439 /*
 440  * output trigger callback
 441  */
 442 static void
 443 snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
 444 {
 445         unsigned long flags;
 446         struct snd_mpu401 *mpu;
 447
 448         mpu = substream->rmidi->private_data;
 449         if (up) {
 450                 set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
 451
 452                 /* try to add the timer at each output trigger,
 453                  * since the output timer might have been removed in
 454                  * snd_mpu401_uart_output_write().
 455                  */
 456                 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
 457                         snd_mpu401_uart_add_timer(mpu, 0);
 458
 459                 /* output pending data */
 460                 spin_lock_irqsave(&mpu->output_lock, flags);
 461                 snd_mpu401_uart_output_write(mpu);
 462                 spin_unlock_irqrestore(&mpu->output_lock, flags);
 463         } else {
 464                 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
 465                         snd_mpu401_uart_remove_timer(mpu, 0);
 466                 clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
 467         }
 468 }
 469
 470 /*
 471
 472  */
 473
 474 static const struct snd_rawmidi_ops snd_mpu401_uart_output =
 475 {
 476         .open =         snd_mpu401_uart_output_open,
 477         .close =        snd_mpu401_uart_output_close,
 478         .trigger =      snd_mpu401_uart_output_trigger,
 479 };
 480
 481 static const struct snd_rawmidi_ops snd_mpu401_uart_input =
 482 {
 483         .open =         snd_mpu401_uart_input_open,
 484         .close =        snd_mpu401_uart_input_close,
 485         .trigger =      snd_mpu401_uart_input_trigger,
 486 };
 487
 488 static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
 489 {
 490         struct snd_mpu401 *mpu = rmidi->private_data;
 491         if (mpu->irq >= 0)
 492                 free_irq(mpu->irq, (void *) mpu);
 493         release_and_free_resource(mpu->res);
 494         kfree(mpu);
 495 }
 496
 497 /**
 498  * snd_mpu401_uart_new - create an MPU401-UART instance
 499  * @card: the card instance
 500  * @device: the device index, zero-based
 501  * @hardware: the hardware type, MPU401_HW_XXXX
 502  * @port: the base address of MPU401 port
 503  * @info_flags: bitflags MPU401_INFO_XXX
 504  * @irq: the ISA irq number, -1 if not to be allocated
 505  * @rrawmidi: the pointer to store the new rawmidi instance
 506  *
 507  * Creates a new MPU-401 instance.
 508  *
 509  * Note that the rawmidi instance is returned on the rrawmidi argument,
 510  * not the mpu401 instance itself.  To access to the mpu401 instance,
 511  * cast from rawmidi->private_data (with struct snd_mpu401 magic-cast).
 512  *
 513  * Return: Zero if successful, or a negative error code.
 514  */
 515 int snd_mpu401_uart_new(struct snd_card *card, int device,
 516                         unsigned short hardware,
 517                         unsigned long port,
 518                         unsigned int info_flags,
 519                         int irq,
 520                         struct snd_rawmidi ** rrawmidi)
 521 {
 522         struct snd_mpu401 *mpu;
 523         struct snd_rawmidi *rmidi;
 524         int in_enable, out_enable;
 525         int err;
 526
 527         if (rrawmidi)
 528                 *rrawmidi = NULL;
 529         if (! (info_flags & (MPU401_INFO_INPUT | MPU401_INFO_OUTPUT)))
 530                 info_flags |= MPU401_INFO_INPUT | MPU401_INFO_OUTPUT;
 531         in_enable = (info_flags & MPU401_INFO_INPUT) ? 1 : 0;
 532         out_enable = (info_flags & MPU401_INFO_OUTPUT) ? 1 : 0;
 533         err = snd_rawmidi_new(card, "MPU-401U", device,
 534                               out_enable, in_enable, &rmidi);
 535         if (err < 0)
 536                 return err;
 537         mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
 538         if (!mpu) {
 539                 err = -ENOMEM;
 540                 goto free_device;
 541         }
 542         rmidi->private_data = mpu;
 543         rmidi->private_free = snd_mpu401_uart_free;
 544         spin_lock_init(&mpu->input_lock);
 545         spin_lock_init(&mpu->output_lock);
 546         spin_lock_init(&mpu->timer_lock);
 547         mpu->hardware = hardware;
 548         mpu->irq = -1;
 549         if (! (info_flags & MPU401_INFO_INTEGRATED)) {
 550                 int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
 551                 mpu->res = request_region(port, res_size, "MPU401 UART");
 552                 if (!mpu->res) {
 553                         snd_printk(KERN_ERR "mpu401_uart: "
 554                                    "unable to grab port 0x%lx size %d\n",
 555                                    port, res_size);
 556                         err = -EBUSY;
 557                         goto free_device;
 558                 }
 559         }
 560         if (info_flags & MPU401_INFO_MMIO) {
 561                 mpu->write = mpu401_write_mmio;
 562                 mpu->read = mpu401_read_mmio;
 563         } else {
 564                 mpu->write = mpu401_write_port;
 565                 mpu->read = mpu401_read_port;
 566         }
 567         mpu->port = port;
 568         if (hardware == MPU401_HW_PC98II)
 569                 mpu->cport = port + 2;
 570         else
 571                 mpu->cport = port + 1;
 572         if (irq >= 0) {
 573                 if (request_irq(irq, snd_mpu401_uart_interrupt, 0,
 574                                 "MPU401 UART", (void *) mpu)) {
 575                         snd_printk(KERN_ERR "mpu401_uart: "
 576                                    "unable to grab IRQ %d\n", irq);
 577                         err = -EBUSY;
 578                         goto free_device;
 579                 }
 580         }
 581         if (irq < 0 && !(info_flags & MPU401_INFO_IRQ_HOOK))
 582                 info_flags |= MPU401_INFO_USE_TIMER;
 583         mpu->info_flags = info_flags;
 584         mpu->irq = irq;
 585         if (card->shortname[0])
 586                 snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI",
 587                          card->shortname);
 588         else
 589                 sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device);
 590         if (out_enable) {
 591                 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
 592                                     &snd_mpu401_uart_output);
 593                 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
 594         }
 595         if (in_enable) {
 596                 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
 597                                     &snd_mpu401_uart_input);
 598                 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
 599                 if (out_enable)
 600                         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
 601         }
 602         mpu->rmidi = rmidi;
 603         if (rrawmidi)
 604                 *rrawmidi = rmidi;
 605         return 0;
 606 free_device:
 607         snd_device_free(card, rmidi);
 608         return err;
 609 }
 610
 611 EXPORT_SYMBOL(snd_mpu401_uart_new);