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 && (err = mpu->open_input(mpu)) < 0)
 275                 return err;
 276         if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode)) {
 277                 if (snd_mpu401_do_reset(mpu) < 0)
 278                         goto error_out;
 279         }
 280         mpu->substream_input = substream;
 281         set_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
 282         return 0;
 283
 284 error_out:
 285         if (mpu->open_input && mpu->close_input)
 286                 mpu->close_input(mpu);
 287         return -EIO;
 288 }
 289
 290 static int snd_mpu401_uart_output_open(struct snd_rawmidi_substream *substream)
 291 {
 292         struct snd_mpu401 *mpu;
 293         int err;
 294
 295         mpu = substream->rmidi->private_data;
 296         if (mpu->open_output && (err = mpu->open_output(mpu)) < 0)
 297                 return err;
 298         if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode)) {
 299                 if (snd_mpu401_do_reset(mpu) < 0)
 300                         goto error_out;
 301         }
 302         mpu->substream_output = substream;
 303         set_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
 304         return 0;
 305
 306 error_out:
 307         if (mpu->open_output && mpu->close_output)
 308                 mpu->close_output(mpu);
 309         return -EIO;
 310 }
 311
 312 static int snd_mpu401_uart_input_close(struct snd_rawmidi_substream *substream)
 313 {
 314         struct snd_mpu401 *mpu;
 315         int err = 0;
 316
 317         mpu = substream->rmidi->private_data;
 318         clear_bit(MPU401_MODE_BIT_INPUT, &mpu->mode);
 319         mpu->substream_input = NULL;
 320         if (! test_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode))
 321                 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
 322         if (mpu->close_input)
 323                 mpu->close_input(mpu);
 324         if (err)
 325                 return -EIO;
 326         return 0;
 327 }
 328
 329 static int snd_mpu401_uart_output_close(struct snd_rawmidi_substream *substream)
 330 {
 331         struct snd_mpu401 *mpu;
 332         int err = 0;
 333
 334         mpu = substream->rmidi->private_data;
 335         clear_bit(MPU401_MODE_BIT_OUTPUT, &mpu->mode);
 336         mpu->substream_output = NULL;
 337         if (! test_bit(MPU401_MODE_BIT_INPUT, &mpu->mode))
 338                 err = snd_mpu401_uart_cmd(mpu, MPU401_RESET, 0);
 339         if (mpu->close_output)
 340                 mpu->close_output(mpu);
 341         if (err)
 342                 return -EIO;
 343         return 0;
 344 }
 345
 346 /*
 347  * trigger input callback
 348  */
 349 static void
 350 snd_mpu401_uart_input_trigger(struct snd_rawmidi_substream *substream, int up)
 351 {
 352         unsigned long flags;
 353         struct snd_mpu401 *mpu;
 354         int max = 64;
 355
 356         mpu = substream->rmidi->private_data;
 357         if (up) {
 358                 if (! test_and_set_bit(MPU401_MODE_BIT_INPUT_TRIGGER,
 359                                        &mpu->mode)) {
 360                         /* first time - flush FIFO */
 361                         while (max-- > 0)
 362                                 mpu->read(mpu, MPU401D(mpu));
 363                         if (mpu->info_flags & MPU401_INFO_USE_TIMER)
 364                                 snd_mpu401_uart_add_timer(mpu, 1);
 365                 }
 366
 367                 /* read data in advance */
 368                 spin_lock_irqsave(&mpu->input_lock, flags);
 369                 snd_mpu401_uart_input_read(mpu);
 370                 spin_unlock_irqrestore(&mpu->input_lock, flags);
 371         } else {
 372                 if (mpu->info_flags & MPU401_INFO_USE_TIMER)
 373                         snd_mpu401_uart_remove_timer(mpu, 1);
 374                 clear_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode);
 375         }
 376
 377 }
 378
 379 /*
 380  * transfer input pending data
 381  * call with input_lock spinlock held
 382  */
 383 static void snd_mpu401_uart_input_read(struct snd_mpu401 * mpu)
 384 {
 385         int max = 128;
 386         unsigned char byte;
 387
 388         while (max-- > 0) {
 389                 if (! snd_mpu401_input_avail(mpu))
 390                         break; /* input not available */
 391                 byte = mpu->read(mpu, MPU401D(mpu));
 392                 if (test_bit(MPU401_MODE_BIT_INPUT_TRIGGER, &mpu->mode))
 393                         snd_rawmidi_receive(mpu->substream_input, &byte, 1);
 394         }
 395 }
 396
 397 /*
 398  *  Tx FIFO sizes:
 399  *    CS4237B                   - 16 bytes
 400  *    AudioDrive ES1688         - 12 bytes
 401  *    S3 SonicVibes             -  8 bytes
 402  *    SoundBlaster AWE 64       -  2 bytes (ugly hardware)
 403  */
 404
 405 /*
 406  * write output pending bytes
 407  * call with output_lock spinlock held
 408  */
 409 static void snd_mpu401_uart_output_write(struct snd_mpu401 * mpu)
 410 {
 411         unsigned char byte;
 412         int max = 256;
 413
 414         do {
 415                 if (snd_rawmidi_transmit_peek(mpu->substream_output,
 416                                               &byte, 1) == 1) {
 417                         /*
 418                          * Try twice because there is hardware that insists on
 419                          * setting the output busy bit after each write.
 420                          */
 421                         if (!snd_mpu401_output_ready(mpu) &&
 422                             !snd_mpu401_output_ready(mpu))
 423                                 break;  /* Tx FIFO full - try again later */
 424                         mpu->write(mpu, byte, MPU401D(mpu));
 425                         snd_rawmidi_transmit_ack(mpu->substream_output, 1);
 426                 } else {
 427                         snd_mpu401_uart_remove_timer (mpu, 0);
 428                         break;  /* no other data - leave the tx loop */
 429                 }
 430         } while (--max > 0);
 431 }
 432
 433 /*
 434  * output trigger callback
 435  */
 436 static void
 437 snd_mpu401_uart_output_trigger(struct snd_rawmidi_substream *substream, int up)
 438 {
 439         unsigned long flags;
 440         struct snd_mpu401 *mpu;
 441
 442         mpu = substream->rmidi->private_data;
 443         if (up) {
 444                 set_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
 445
 446                 /* try to add the timer at each output trigger,
 447                  * since the output timer might have been removed in
 448                  * snd_mpu401_uart_output_write().
 449                  */
 450                 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
 451                         snd_mpu401_uart_add_timer(mpu, 0);
 452
 453                 /* output pending data */
 454                 spin_lock_irqsave(&mpu->output_lock, flags);
 455                 snd_mpu401_uart_output_write(mpu);
 456                 spin_unlock_irqrestore(&mpu->output_lock, flags);
 457         } else {
 458                 if (! (mpu->info_flags & MPU401_INFO_TX_IRQ))
 459                         snd_mpu401_uart_remove_timer(mpu, 0);
 460                 clear_bit(MPU401_MODE_BIT_OUTPUT_TRIGGER, &mpu->mode);
 461         }
 462 }
 463
 464 /*
 465
 466  */
 467
 468 static const struct snd_rawmidi_ops snd_mpu401_uart_output =
 469 {
 470         .open =         snd_mpu401_uart_output_open,
 471         .close =        snd_mpu401_uart_output_close,
 472         .trigger =      snd_mpu401_uart_output_trigger,
 473 };
 474
 475 static const struct snd_rawmidi_ops snd_mpu401_uart_input =
 476 {
 477         .open =         snd_mpu401_uart_input_open,
 478         .close =        snd_mpu401_uart_input_close,
 479         .trigger =      snd_mpu401_uart_input_trigger,
 480 };
 481
 482 static void snd_mpu401_uart_free(struct snd_rawmidi *rmidi)
 483 {
 484         struct snd_mpu401 *mpu = rmidi->private_data;
 485         if (mpu->irq >= 0)
 486                 free_irq(mpu->irq, (void *) mpu);
 487         release_and_free_resource(mpu->res);
 488         kfree(mpu);
 489 }
 490
 491 /**
 492  * snd_mpu401_uart_new - create an MPU401-UART instance
 493  * @card: the card instance
 494  * @device: the device index, zero-based
 495  * @hardware: the hardware type, MPU401_HW_XXXX
 496  * @port: the base address of MPU401 port
 497  * @info_flags: bitflags MPU401_INFO_XXX
 498  * @irq: the ISA irq number, -1 if not to be allocated
 499  * @rrawmidi: the pointer to store the new rawmidi instance
 500  *
 501  * Creates a new MPU-401 instance.
 502  *
 503  * Note that the rawmidi instance is returned on the rrawmidi argument,
 504  * not the mpu401 instance itself.  To access to the mpu401 instance,
 505  * cast from rawmidi->private_data (with struct snd_mpu401 magic-cast).
 506  *
 507  * Return: Zero if successful, or a negative error code.
 508  */
 509 int snd_mpu401_uart_new(struct snd_card *card, int device,
 510                         unsigned short hardware,
 511                         unsigned long port,
 512                         unsigned int info_flags,
 513                         int irq,
 514                         struct snd_rawmidi ** rrawmidi)
 515 {
 516         struct snd_mpu401 *mpu;
 517         struct snd_rawmidi *rmidi;
 518         int in_enable, out_enable;
 519         int err;
 520
 521         if (rrawmidi)
 522                 *rrawmidi = NULL;
 523         if (! (info_flags & (MPU401_INFO_INPUT | MPU401_INFO_OUTPUT)))
 524                 info_flags |= MPU401_INFO_INPUT | MPU401_INFO_OUTPUT;
 525         in_enable = (info_flags & MPU401_INFO_INPUT) ? 1 : 0;
 526         out_enable = (info_flags & MPU401_INFO_OUTPUT) ? 1 : 0;
 527         if ((err = snd_rawmidi_new(card, "MPU-401U", device,
 528                                    out_enable, in_enable, &rmidi)) < 0)
 529                 return err;
 530         mpu = kzalloc(sizeof(*mpu), GFP_KERNEL);
 531         if (!mpu) {
 532                 err = -ENOMEM;
 533                 goto free_device;
 534         }
 535         rmidi->private_data = mpu;
 536         rmidi->private_free = snd_mpu401_uart_free;
 537         spin_lock_init(&mpu->input_lock);
 538         spin_lock_init(&mpu->output_lock);
 539         spin_lock_init(&mpu->timer_lock);
 540         mpu->hardware = hardware;
 541         mpu->irq = -1;
 542         if (! (info_flags & MPU401_INFO_INTEGRATED)) {
 543                 int res_size = hardware == MPU401_HW_PC98II ? 4 : 2;
 544                 mpu->res = request_region(port, res_size, "MPU401 UART");
 545                 if (!mpu->res) {
 546                         snd_printk(KERN_ERR "mpu401_uart: "
 547                                    "unable to grab port 0x%lx size %d\n",
 548                                    port, res_size);
 549                         err = -EBUSY;
 550                         goto free_device;
 551                 }
 552         }
 553         if (info_flags & MPU401_INFO_MMIO) {
 554                 mpu->write = mpu401_write_mmio;
 555                 mpu->read = mpu401_read_mmio;
 556         } else {
 557                 mpu->write = mpu401_write_port;
 558                 mpu->read = mpu401_read_port;
 559         }
 560         mpu->port = port;
 561         if (hardware == MPU401_HW_PC98II)
 562                 mpu->cport = port + 2;
 563         else
 564                 mpu->cport = port + 1;
 565         if (irq >= 0) {
 566                 if (request_irq(irq, snd_mpu401_uart_interrupt, 0,
 567                                 "MPU401 UART", (void *) mpu)) {
 568                         snd_printk(KERN_ERR "mpu401_uart: "
 569                                    "unable to grab IRQ %d\n", irq);
 570                         err = -EBUSY;
 571                         goto free_device;
 572                 }
 573         }
 574         if (irq < 0 && !(info_flags & MPU401_INFO_IRQ_HOOK))
 575                 info_flags |= MPU401_INFO_USE_TIMER;
 576         mpu->info_flags = info_flags;
 577         mpu->irq = irq;
 578         if (card->shortname[0])
 579                 snprintf(rmidi->name, sizeof(rmidi->name), "%s MIDI",
 580                          card->shortname);
 581         else
 582                 sprintf(rmidi->name, "MPU-401 MIDI %d-%d",card->number, device);
 583         if (out_enable) {
 584                 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
 585                                     &snd_mpu401_uart_output);
 586                 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
 587         }
 588         if (in_enable) {
 589                 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
 590                                     &snd_mpu401_uart_input);
 591                 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
 592                 if (out_enable)
 593                         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
 594         }
 595         mpu->rmidi = rmidi;
 596         if (rrawmidi)
 597                 *rrawmidi = rmidi;
 598         return 0;
 599 free_device:
 600         snd_device_free(card, rmidi);
 601         return err;
 602 }
 603
 604 EXPORT_SYMBOL(snd_mpu401_uart_new);