sound/drivers/portman2x4.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Driver for Midiman Portman2x4 parallel port midi interface
   4  *
   5  *   Copyright (c) by Levent Guendogdu <levon@feature-it.com>
   6  *
   7  * ChangeLog
   8  * Jan 24 2007 Matthias Koenig <mkoenig@suse.de>
   9  *      - cleanup and rewrite
  10  * Sep 30 2004 Tobias Gehrig <tobias@gehrig.tk>
  11  *      - source code cleanup
  12  * Sep 03 2004 Tobias Gehrig <tobias@gehrig.tk>
  13  *      - fixed compilation problem with alsa 1.0.6a (removed MODULE_CLASSES,
  14  *        MODULE_PARM_SYNTAX and changed MODULE_DEVICES to
  15  *        MODULE_SUPPORTED_DEVICE)
  16  * Mar 24 2004 Tobias Gehrig <tobias@gehrig.tk>
  17  *      - added 2.6 kernel support
  18  * Mar 18 2004 Tobias Gehrig <tobias@gehrig.tk>
  19  *      - added parport_unregister_driver to the startup routine if the driver fails to detect a portman
  20  *      - added support for all 4 output ports in portman_putmidi
  21  * Mar 17 2004 Tobias Gehrig <tobias@gehrig.tk>
  22  *      - added checks for opened input device in interrupt handler
  23  * Feb 20 2004 Tobias Gehrig <tobias@gehrig.tk>
  24  *      - ported from alsa 0.5 to 1.0
  25  */
  26
  27 #include <linux/init.h>
  28 #include <linux/platform_device.h>
  29 #include <linux/parport.h>
  30 #include <linux/spinlock.h>
  31 #include <linux/delay.h>
  32 #include <linux/slab.h>
  33 #include <linux/module.h>
  34 #include <sound/core.h>
  35 #include <sound/initval.h>
  36 #include <sound/rawmidi.h>
  37 #include <sound/control.h>
  38
  39 #define CARD_NAME "Portman 2x4"
  40 #define DRIVER_NAME "portman"
  41 #define PLATFORM_DRIVER "snd_portman2x4"
  42
  43 static int index[SNDRV_CARDS]  = SNDRV_DEFAULT_IDX;
  44 static char *id[SNDRV_CARDS]   = SNDRV_DEFAULT_STR;
  45 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  46
  47 static struct platform_device *platform_devices[SNDRV_CARDS];
  48 static int device_count;
  49
  50 module_param_array(index, int, NULL, 0444);
  51 MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard.");
  52 module_param_array(id, charp, NULL, 0444);
  53 MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard.");
  54 module_param_array(enable, bool, NULL, 0444);
  55 MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard.");
  56
  57 MODULE_AUTHOR("Levent Guendogdu, Tobias Gehrig, Matthias Koenig");
  58 MODULE_DESCRIPTION("Midiman Portman2x4");
  59 MODULE_LICENSE("GPL");
  60
  61 /*********************************************************************
  62  * Chip specific
  63  *********************************************************************/
  64 #define PORTMAN_NUM_INPUT_PORTS 2
  65 #define PORTMAN_NUM_OUTPUT_PORTS 4
  66
  67 struct portman {
  68         spinlock_t reg_lock;
  69         struct snd_card *card;
  70         struct snd_rawmidi *rmidi;
  71         struct pardevice *pardev;
  72         int open_count;
  73         int mode[PORTMAN_NUM_INPUT_PORTS];
  74         struct snd_rawmidi_substream *midi_input[PORTMAN_NUM_INPUT_PORTS];
  75 };
  76
  77 static int portman_free(struct portman *pm)
  78 {
  79         kfree(pm);
  80         return 0;
  81 }
  82
  83 static int portman_create(struct snd_card *card,
  84                           struct pardevice *pardev,
  85                           struct portman **rchip)
  86 {
  87         struct portman *pm;
  88
  89         *rchip = NULL;
  90
  91         pm = kzalloc(sizeof(struct portman), GFP_KERNEL);
  92         if (pm == NULL)
  93                 return -ENOMEM;
  94
  95         /* Init chip specific data */
  96         spin_lock_init(&pm->reg_lock);
  97         pm->card = card;
  98         pm->pardev = pardev;
  99
 100         *rchip = pm;
 101
 102         return 0;
 103 }
 104
 105 /*********************************************************************
 106  * HW related constants
 107  *********************************************************************/
 108
 109 /* Standard PC parallel port status register equates. */
 110 #define PP_STAT_BSY     0x80    /* Busy status.  Inverted. */
 111 #define PP_STAT_ACK     0x40    /* Acknowledge.  Non-Inverted. */
 112 #define PP_STAT_POUT    0x20    /* Paper Out.    Non-Inverted. */
 113 #define PP_STAT_SEL     0x10    /* Select.       Non-Inverted. */
 114 #define PP_STAT_ERR     0x08    /* Error.        Non-Inverted. */
 115
 116 /* Standard PC parallel port command register equates. */
 117 #define PP_CMD_IEN      0x10    /* IRQ Enable.   Non-Inverted. */
 118 #define PP_CMD_SELI     0x08    /* Select Input. Inverted. */
 119 #define PP_CMD_INIT     0x04    /* Init Printer. Non-Inverted. */
 120 #define PP_CMD_FEED     0x02    /* Auto Feed.    Inverted. */
 121 #define PP_CMD_STB      0x01    /* Strobe.       Inverted. */
 122
 123 /* Parallel Port Command Register as implemented by PCP2x4. */
 124 #define INT_EN          PP_CMD_IEN      /* Interrupt enable. */
 125 #define STROBE          PP_CMD_STB      /* Command strobe. */
 126
 127 /* The parallel port command register field (b1..b3) selects the
 128  * various "registers" within the PC/P 2x4.  These are the internal
 129  * address of these "registers" that must be written to the parallel
 130  * port command register.
 131  */
 132 #define RXDATA0         (0 << 1)        /* PCP RxData channel 0. */
 133 #define RXDATA1         (1 << 1)        /* PCP RxData channel 1. */
 134 #define GEN_CTL         (2 << 1)        /* PCP General Control Register. */
 135 #define SYNC_CTL        (3 << 1)        /* PCP Sync Control Register. */
 136 #define TXDATA0         (4 << 1)        /* PCP TxData channel 0. */
 137 #define TXDATA1         (5 << 1)        /* PCP TxData channel 1. */
 138 #define TXDATA2         (6 << 1)        /* PCP TxData channel 2. */
 139 #define TXDATA3         (7 << 1)        /* PCP TxData channel 3. */
 140
 141 /* Parallel Port Status Register as implemented by PCP2x4. */
 142 #define ESTB            PP_STAT_POUT    /* Echoed strobe. */
 143 #define INT_REQ         PP_STAT_ACK     /* Input data int request. */
 144 #define BUSY            PP_STAT_ERR     /* Interface Busy. */
 145
 146 /* Parallel Port Status Register BUSY and SELECT lines are multiplexed
 147  * between several functions.  Depending on which 2x4 "register" is
 148  * currently selected (b1..b3), the BUSY and SELECT lines are
 149  * assigned as follows:
 150  *
 151  *   SELECT LINE:                                                    A3 A2 A1
 152  *                                                                   --------
 153  */
 154 #define RXAVAIL         PP_STAT_SEL     /* Rx Available, channel 0.   0 0 0 */
 155 //  RXAVAIL1    PP_STAT_SEL             /* Rx Available, channel 1.   0 0 1 */
 156 #define SYNC_STAT       PP_STAT_SEL     /* Reserved - Sync Status.    0 1 0 */
 157 //                                      /* Reserved.                  0 1 1 */
 158 #define TXEMPTY         PP_STAT_SEL     /* Tx Empty, channel 0.       1 0 0 */
 159 //      TXEMPTY1        PP_STAT_SEL     /* Tx Empty, channel 1.       1 0 1 */
 160 //  TXEMPTY2    PP_STAT_SEL             /* Tx Empty, channel 2.       1 1 0 */
 161 //  TXEMPTY3    PP_STAT_SEL             /* Tx Empty, channel 3.       1 1 1 */
 162
 163 /*   BUSY LINE:                                                      A3 A2 A1
 164  *                                                                   --------
 165  */
 166 #define RXDATA          PP_STAT_BSY     /* Rx Input Data, channel 0.  0 0 0 */
 167 //      RXDATA1         PP_STAT_BSY     /* Rx Input Data, channel 1.  0 0 1 */
 168 #define SYNC_DATA       PP_STAT_BSY     /* Reserved - Sync Data.      0 1 0 */
 169                                         /* Reserved.                  0 1 1 */
 170 #define DATA_ECHO       PP_STAT_BSY     /* Parallel Port Data Echo.   1 0 0 */
 171 #define A0_ECHO         PP_STAT_BSY     /* Address 0 Echo.            1 0 1 */
 172 #define A1_ECHO         PP_STAT_BSY     /* Address 1 Echo.            1 1 0 */
 173 #define A2_ECHO         PP_STAT_BSY     /* Address 2 Echo.            1 1 1 */
 174
 175 #define PORTMAN2X4_MODE_INPUT_TRIGGERED  0x01
 176
 177 /*********************************************************************
 178  * Hardware specific functions
 179  *********************************************************************/
 180 static inline void portman_write_command(struct portman *pm, u8 value)
 181 {
 182         parport_write_control(pm->pardev->port, value);
 183 }
 184
 185 static inline u8 portman_read_command(struct portman *pm)
 186 {
 187         return parport_read_control(pm->pardev->port);
 188 }
 189
 190 static inline u8 portman_read_status(struct portman *pm)
 191 {
 192         return parport_read_status(pm->pardev->port);
 193 }
 194
 195 static inline u8 portman_read_data(struct portman *pm)
 196 {
 197         return parport_read_data(pm->pardev->port);
 198 }
 199
 200 static inline void portman_write_data(struct portman *pm, u8 value)
 201 {
 202         parport_write_data(pm->pardev->port, value);
 203 }
 204
 205 static void portman_write_midi(struct portman *pm,
 206                                int port, u8 mididata)
 207 {
 208         int command = ((port + 4) << 1);
 209
 210         /* Get entering data byte and port number in BL and BH respectively.
 211          * Set up Tx Channel address field for use with PP Cmd Register.
 212          * Store address field in BH register.
 213          * Inputs:      AH = Output port number (0..3).
 214          *              AL = Data byte.
 215          *    command = TXDATA0 | INT_EN;
 216          * Align port num with address field (b1...b3),
 217          * set address for TXDatax, Strobe=0
 218          */
 219         command |= INT_EN;
 220
 221         /* Disable interrupts so that the process is not interrupted, then
 222          * write the address associated with the current Tx channel to the
 223          * PP Command Reg.  Do not set the Strobe signal yet.
 224          */
 225
 226         do {
 227                 portman_write_command(pm, command);
 228
 229                 /* While the address lines settle, write parallel output data to
 230                  * PP Data Reg.  This has no effect until Strobe signal is asserted.
 231                  */
 232
 233                 portman_write_data(pm, mididata);
 234
 235                 /* If PCP channel's TxEmpty is set (TxEmpty is read through the PP
 236                  * Status Register), then go write data.  Else go back and wait.
 237                  */
 238         } while ((portman_read_status(pm) & TXEMPTY) != TXEMPTY);
 239
 240         /* TxEmpty is set.  Maintain PC/P destination address and assert
 241          * Strobe through the PP Command Reg.  This will Strobe data into
 242          * the PC/P transmitter and set the PC/P BUSY signal.
 243          */
 244
 245         portman_write_command(pm, command | STROBE);
 246
 247         /* Wait for strobe line to settle and echo back through hardware.
 248          * Once it has echoed back, assume that the address and data lines
 249          * have settled!
 250          */
 251
 252         while ((portman_read_status(pm) & ESTB) == 0)
 253                 cpu_relax();
 254
 255         /* Release strobe and immediately re-allow interrupts. */
 256         portman_write_command(pm, command);
 257
 258         while ((portman_read_status(pm) & ESTB) == ESTB)
 259                 cpu_relax();
 260
 261         /* PC/P BUSY is now set.  We must wait until BUSY resets itself.
 262          * We'll reenable ints while we're waiting.
 263          */
 264
 265         while ((portman_read_status(pm) & BUSY) == BUSY)
 266                 cpu_relax();
 267
 268         /* Data sent. */
 269 }
 270
 271
 272 /*
 273  *  Read MIDI byte from port
 274  *  Attempt to read input byte from specified hardware input port (0..).
 275  *  Return -1 if no data
 276  */
 277 static int portman_read_midi(struct portman *pm, int port)
 278 {
 279         unsigned char midi_data = 0;
 280         unsigned char cmdout;   /* Saved address+IE bit. */
 281
 282         /* Make sure clocking edge is down before starting... */
 283         portman_write_data(pm, 0);      /* Make sure edge is down. */
 284
 285         /* Set destination address to PCP. */
 286         cmdout = (port << 1) | INT_EN;  /* Address + IE + No Strobe. */
 287         portman_write_command(pm, cmdout);
 288
 289         while ((portman_read_status(pm) & ESTB) == ESTB)
 290                 cpu_relax();    /* Wait for strobe echo. */
 291
 292         /* After the address lines settle, check multiplexed RxAvail signal.
 293          * If data is available, read it.
 294          */
 295         if ((portman_read_status(pm) & RXAVAIL) == 0)
 296                 return -1;      /* No data. */
 297
 298         /* Set the Strobe signal to enable the Rx clocking circuitry. */
 299         portman_write_command(pm, cmdout | STROBE);     /* Write address+IE+Strobe. */
 300
 301         while ((portman_read_status(pm) & ESTB) == 0)
 302                 cpu_relax(); /* Wait for strobe echo. */
 303
 304         /* The first data bit (msb) is already sitting on the input line. */
 305         midi_data = (portman_read_status(pm) & 128);
 306         portman_write_data(pm, 1);      /* Cause rising edge, which shifts data. */
 307
 308         /* Data bit 6. */
 309         portman_write_data(pm, 0);      /* Cause falling edge while data settles. */
 310         midi_data |= (portman_read_status(pm) >> 1) & 64;
 311         portman_write_data(pm, 1);      /* Cause rising edge, which shifts data. */
 312
 313         /* Data bit 5. */
 314         portman_write_data(pm, 0);      /* Cause falling edge while data settles. */
 315         midi_data |= (portman_read_status(pm) >> 2) & 32;
 316         portman_write_data(pm, 1);      /* Cause rising edge, which shifts data. */
 317
 318         /* Data bit 4. */
 319         portman_write_data(pm, 0);      /* Cause falling edge while data settles. */
 320         midi_data |= (portman_read_status(pm) >> 3) & 16;
 321         portman_write_data(pm, 1);      /* Cause rising edge, which shifts data. */
 322
 323         /* Data bit 3. */
 324         portman_write_data(pm, 0);      /* Cause falling edge while data settles. */
 325         midi_data |= (portman_read_status(pm) >> 4) & 8;
 326         portman_write_data(pm, 1);      /* Cause rising edge, which shifts data. */
 327
 328         /* Data bit 2. */
 329         portman_write_data(pm, 0);      /* Cause falling edge while data settles. */
 330         midi_data |= (portman_read_status(pm) >> 5) & 4;
 331         portman_write_data(pm, 1);      /* Cause rising edge, which shifts data. */
 332
 333         /* Data bit 1. */
 334         portman_write_data(pm, 0);      /* Cause falling edge while data settles. */
 335         midi_data |= (portman_read_status(pm) >> 6) & 2;
 336         portman_write_data(pm, 1);      /* Cause rising edge, which shifts data. */
 337
 338         /* Data bit 0. */
 339         portman_write_data(pm, 0);      /* Cause falling edge while data settles. */
 340         midi_data |= (portman_read_status(pm) >> 7) & 1;
 341         portman_write_data(pm, 1);      /* Cause rising edge, which shifts data. */
 342         portman_write_data(pm, 0);      /* Return data clock low. */
 343
 344
 345         /* De-assert Strobe and return data. */
 346         portman_write_command(pm, cmdout);      /* Output saved address+IE. */
 347
 348         /* Wait for strobe echo. */
 349         while ((portman_read_status(pm) & ESTB) == ESTB)
 350                 cpu_relax();
 351
 352         return (midi_data & 255);       /* Shift back and return value. */
 353 }
 354
 355 /*
 356  *  Checks if any input data on the given channel is available
 357  *  Checks RxAvail
 358  */
 359 static int portman_data_avail(struct portman *pm, int channel)
 360 {
 361         int command = INT_EN;
 362         switch (channel) {
 363         case 0:
 364                 command |= RXDATA0;
 365                 break;
 366         case 1:
 367                 command |= RXDATA1;
 368                 break;
 369         }
 370         /* Write hardware (assumme STROBE=0) */
 371         portman_write_command(pm, command);
 372         /* Check multiplexed RxAvail signal */
 373         if ((portman_read_status(pm) & RXAVAIL) == RXAVAIL)
 374                 return 1;       /* Data available */
 375
 376         /* No Data available */
 377         return 0;
 378 }
 379
 380
 381 /*
 382  *  Flushes any input
 383  */
 384 static void portman_flush_input(struct portman *pm, unsigned char port)
 385 {
 386         /* Local variable for counting things */
 387         unsigned int i = 0;
 388         unsigned char command = 0;
 389
 390         switch (port) {
 391         case 0:
 392                 command = RXDATA0;
 393                 break;
 394         case 1:
 395                 command = RXDATA1;
 396                 break;
 397         default:
 398                 snd_printk(KERN_WARNING
 399                            "portman_flush_input() Won't flush port %i\n",
 400                            port);
 401                 return;
 402         }
 403
 404         /* Set address for specified channel in port and allow to settle. */
 405         portman_write_command(pm, command);
 406
 407         /* Assert the Strobe and wait for echo back. */
 408         portman_write_command(pm, command | STROBE);
 409
 410         /* Wait for ESTB */
 411         while ((portman_read_status(pm) & ESTB) == 0)
 412                 cpu_relax();
 413
 414         /* Output clock cycles to the Rx circuitry. */
 415         portman_write_data(pm, 0);
 416
 417         /* Flush 250 bits... */
 418         for (i = 0; i < 250; i++) {
 419                 portman_write_data(pm, 1);
 420                 portman_write_data(pm, 0);
 421         }
 422
 423         /* Deassert the Strobe signal of the port and wait for it to settle. */
 424         portman_write_command(pm, command | INT_EN);
 425
 426         /* Wait for settling */
 427         while ((portman_read_status(pm) & ESTB) == ESTB)
 428                 cpu_relax();
 429 }
 430
 431 static int portman_probe(struct parport *p)
 432 {
 433         /* Initialize the parallel port data register.  Will set Rx clocks
 434          * low in case we happen to be addressing the Rx ports at this time.
 435          */
 436         /* 1 */
 437         parport_write_data(p, 0);
 438
 439         /* Initialize the parallel port command register, thus initializing
 440          * hardware handshake lines to midi box:
 441          *
 442          *                                  Strobe = 0
 443          *                                  Interrupt Enable = 0
 444          */
 445         /* 2 */
 446         parport_write_control(p, 0);
 447
 448         /* Check if Portman PC/P 2x4 is out there. */
 449         /* 3 */
 450         parport_write_control(p, RXDATA0);      /* Write Strobe=0 to command reg. */
 451
 452         /* Check for ESTB to be clear */
 453         /* 4 */
 454         if ((parport_read_status(p) & ESTB) == ESTB)
 455                 return 1;       /* CODE 1 - Strobe Failure. */
 456
 457         /* Set for RXDATA0 where no damage will be done. */
 458         /* 5 */
 459         parport_write_control(p, RXDATA0 | STROBE);     /* Write Strobe=1 to command reg. */
 460
 461         /* 6 */
 462         if ((parport_read_status(p) & ESTB) != ESTB)
 463                 return 1;       /* CODE 1 - Strobe Failure. */
 464
 465         /* 7 */
 466         parport_write_control(p, 0);    /* Reset Strobe=0. */
 467
 468         /* Check if Tx circuitry is functioning properly.  If initialized
 469          * unit TxEmpty is false, send out char and see if it goes true.
 470          */
 471         /* 8 */
 472         parport_write_control(p, TXDATA0);      /* Tx channel 0, strobe off. */
 473
 474         /* If PCP channel's TxEmpty is set (TxEmpty is read through the PP
 475          * Status Register), then go write data.  Else go back and wait.
 476          */
 477         /* 9 */
 478         if ((parport_read_status(p) & TXEMPTY) == 0)
 479                 return 2;
 480
 481         /* Return OK status. */
 482         return 0;
 483 }
 484
 485 static int portman_device_init(struct portman *pm)
 486 {
 487         portman_flush_input(pm, 0);
 488         portman_flush_input(pm, 1);
 489
 490         return 0;
 491 }
 492
 493 /*********************************************************************
 494  * Rawmidi
 495  *********************************************************************/
 496 static int snd_portman_midi_open(struct snd_rawmidi_substream *substream)
 497 {
 498         return 0;
 499 }
 500
 501 static int snd_portman_midi_close(struct snd_rawmidi_substream *substream)
 502 {
 503         return 0;
 504 }
 505
 506 static void snd_portman_midi_input_trigger(struct snd_rawmidi_substream *substream,
 507                                            int up)
 508 {
 509         struct portman *pm = substream->rmidi->private_data;
 510         unsigned long flags;
 511
 512         spin_lock_irqsave(&pm->reg_lock, flags);
 513         if (up)
 514                 pm->mode[substream->number] |= PORTMAN2X4_MODE_INPUT_TRIGGERED;
 515         else
 516                 pm->mode[substream->number] &= ~PORTMAN2X4_MODE_INPUT_TRIGGERED;
 517         spin_unlock_irqrestore(&pm->reg_lock, flags);
 518 }
 519
 520 static void snd_portman_midi_output_trigger(struct snd_rawmidi_substream *substream,
 521                                             int up)
 522 {
 523         struct portman *pm = substream->rmidi->private_data;
 524         unsigned long flags;
 525         unsigned char byte;
 526
 527         spin_lock_irqsave(&pm->reg_lock, flags);
 528         if (up) {
 529                 while ((snd_rawmidi_transmit(substream, &byte, 1) == 1))
 530                         portman_write_midi(pm, substream->number, byte);
 531         }
 532         spin_unlock_irqrestore(&pm->reg_lock, flags);
 533 }
 534
 535 static const struct snd_rawmidi_ops snd_portman_midi_output = {
 536         .open =         snd_portman_midi_open,
 537         .close =        snd_portman_midi_close,
 538         .trigger =      snd_portman_midi_output_trigger,
 539 };
 540
 541 static const struct snd_rawmidi_ops snd_portman_midi_input = {
 542         .open =         snd_portman_midi_open,
 543         .close =        snd_portman_midi_close,
 544         .trigger =      snd_portman_midi_input_trigger,
 545 };
 546
 547 /* Create and initialize the rawmidi component */
 548 static int snd_portman_rawmidi_create(struct snd_card *card)
 549 {
 550         struct portman *pm = card->private_data;
 551         struct snd_rawmidi *rmidi;
 552         struct snd_rawmidi_substream *substream;
 553         int err;
 554
 555         err = snd_rawmidi_new(card, CARD_NAME, 0,
 556                               PORTMAN_NUM_OUTPUT_PORTS,
 557                               PORTMAN_NUM_INPUT_PORTS,
 558                               &rmidi);
 559         if (err < 0)
 560                 return err;
 561
 562         rmidi->private_data = pm;
 563         strcpy(rmidi->name, CARD_NAME);
 564         rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
 565                             SNDRV_RAWMIDI_INFO_INPUT |
 566                             SNDRV_RAWMIDI_INFO_DUPLEX;
 567
 568         pm->rmidi = rmidi;
 569
 570         /* register rawmidi ops */
 571         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
 572                             &snd_portman_midi_output);
 573         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
 574                             &snd_portman_midi_input);
 575
 576         /* name substreams */
 577         /* output */
 578         list_for_each_entry(substream,
 579                             &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams,
 580                             list) {
 581                 sprintf(substream->name,
 582                         "Portman2x4 %d", substream->number+1);
 583         }
 584         /* input */
 585         list_for_each_entry(substream,
 586                             &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams,
 587                             list) {
 588                 pm->midi_input[substream->number] = substream;
 589                 sprintf(substream->name,
 590                         "Portman2x4 %d", substream->number+1);
 591         }
 592
 593         return err;
 594 }
 595
 596 /*********************************************************************
 597  * parport stuff
 598  *********************************************************************/
 599 static void snd_portman_interrupt(void *userdata)
 600 {
 601         unsigned char midivalue = 0;
 602         struct portman *pm = ((struct snd_card*)userdata)->private_data;
 603
 604         spin_lock(&pm->reg_lock);
 605
 606         /* While any input data is waiting */
 607         while ((portman_read_status(pm) & INT_REQ) == INT_REQ) {
 608                 /* If data available on channel 0,
 609                    read it and stuff it into the queue. */
 610                 if (portman_data_avail(pm, 0)) {
 611                         /* Read Midi */
 612                         midivalue = portman_read_midi(pm, 0);
 613                         /* put midi into queue... */
 614                         if (pm->mode[0] & PORTMAN2X4_MODE_INPUT_TRIGGERED)
 615                                 snd_rawmidi_receive(pm->midi_input[0],
 616                                                     &midivalue, 1);
 617
 618                 }
 619                 /* If data available on channel 1,
 620                    read it and stuff it into the queue. */
 621                 if (portman_data_avail(pm, 1)) {
 622                         /* Read Midi */
 623                         midivalue = portman_read_midi(pm, 1);
 624                         /* put midi into queue... */
 625                         if (pm->mode[1] & PORTMAN2X4_MODE_INPUT_TRIGGERED)
 626                                 snd_rawmidi_receive(pm->midi_input[1],
 627                                                     &midivalue, 1);
 628                 }
 629
 630         }
 631
 632         spin_unlock(&pm->reg_lock);
 633 }
 634
 635 static void snd_portman_attach(struct parport *p)
 636 {
 637         struct platform_device *device;
 638
 639         device = platform_device_alloc(PLATFORM_DRIVER, device_count);
 640         if (!device)
 641                 return;
 642
 643         /* Temporary assignment to forward the parport */
 644         platform_set_drvdata(device, p);
 645
 646         if (platform_device_add(device) < 0) {
 647                 platform_device_put(device);
 648                 return;
 649         }
 650
 651         /* Since we dont get the return value of probe
 652          * We need to check if device probing succeeded or not */
 653         if (!platform_get_drvdata(device)) {
 654                 platform_device_unregister(device);
 655                 return;
 656         }
 657
 658         /* register device in global table */
 659         platform_devices[device_count] = device;
 660         device_count++;
 661 }
 662
 663 static void snd_portman_detach(struct parport *p)
 664 {
 665         /* nothing to do here */
 666 }
 667
 668 static int snd_portman_dev_probe(struct pardevice *pardev)
 669 {
 670         if (strcmp(pardev->name, DRIVER_NAME))
 671                 return -ENODEV;
 672
 673         return 0;
 674 }
 675
 676 static struct parport_driver portman_parport_driver = {
 677         .name           = "portman2x4",
 678         .probe          = snd_portman_dev_probe,
 679         .match_port     = snd_portman_attach,
 680         .detach         = snd_portman_detach,
 681         .devmodel       = true,
 682 };
 683
 684 /*********************************************************************
 685  * platform stuff
 686  *********************************************************************/
 687 static void snd_portman_card_private_free(struct snd_card *card)
 688 {
 689         struct portman *pm = card->private_data;
 690         struct pardevice *pardev = pm->pardev;
 691
 692         if (pardev) {
 693                 parport_release(pardev);
 694                 parport_unregister_device(pardev);
 695         }
 696
 697         portman_free(pm);
 698 }
 699
 700 static int snd_portman_probe(struct platform_device *pdev)
 701 {
 702         struct pardevice *pardev;
 703         struct parport *p;
 704         int dev = pdev->id;
 705         struct snd_card *card = NULL;
 706         struct portman *pm = NULL;
 707         int err;
 708         struct pardev_cb portman_cb = {
 709                 .preempt = NULL,
 710                 .wakeup = NULL,
 711                 .irq_func = snd_portman_interrupt,      /* ISR */
 712                 .flags = PARPORT_DEV_EXCL,              /* flags */
 713         };
 714
 715         p = platform_get_drvdata(pdev);
 716         platform_set_drvdata(pdev, NULL);
 717
 718         if (dev >= SNDRV_CARDS)
 719                 return -ENODEV;
 720         if (!enable[dev])
 721                 return -ENOENT;
 722
 723         err = snd_card_new(&pdev->dev, index[dev], id[dev], THIS_MODULE,
 724                            0, &card);
 725         if (err < 0) {
 726                 snd_printd("Cannot create card\n");
 727                 return err;
 728         }
 729         strcpy(card->driver, DRIVER_NAME);
 730         strcpy(card->shortname, CARD_NAME);
 731         sprintf(card->longname,  "%s at 0x%lx, irq %i",
 732                 card->shortname, p->base, p->irq);
 733
 734         portman_cb.private = card;                         /* private */
 735         pardev = parport_register_dev_model(p,             /* port */
 736                                             DRIVER_NAME,   /* name */
 737                                             &portman_cb,   /* callbacks */
 738                                             pdev->id);     /* device number */
 739         if (pardev == NULL) {
 740                 snd_printd("Cannot register pardevice\n");
 741                 err = -EIO;
 742                 goto __err;
 743         }
 744
 745         /* claim parport */
 746         if (parport_claim(pardev)) {
 747                 snd_printd("Cannot claim parport 0x%lx\n", pardev->port->base);
 748                 err = -EIO;
 749                 goto free_pardev;
 750         }
 751
 752         if ((err = portman_create(card, pardev, &pm)) < 0) {
 753                 snd_printd("Cannot create main component\n");
 754                 goto release_pardev;
 755         }
 756         card->private_data = pm;
 757         card->private_free = snd_portman_card_private_free;
 758
 759         err = portman_probe(p);
 760         if (err) {
 761                 err = -EIO;
 762                 goto __err;
 763         }
 764
 765         if ((err = snd_portman_rawmidi_create(card)) < 0) {
 766                 snd_printd("Creating Rawmidi component failed\n");
 767                 goto __err;
 768         }
 769
 770         /* init device */
 771         if ((err = portman_device_init(pm)) < 0)
 772                 goto __err;
 773
 774         platform_set_drvdata(pdev, card);
 775
 776         /* At this point card will be usable */
 777         if ((err = snd_card_register(card)) < 0) {
 778                 snd_printd("Cannot register card\n");
 779                 goto __err;
 780         }
 781
 782         snd_printk(KERN_INFO "Portman 2x4 on 0x%lx\n", p->base);
 783         return 0;
 784
 785 release_pardev:
 786         parport_release(pardev);
 787 free_pardev:
 788         parport_unregister_device(pardev);
 789 __err:
 790         snd_card_free(card);
 791         return err;
 792 }
 793
 794 static int snd_portman_remove(struct platform_device *pdev)
 795 {
 796         struct snd_card *card = platform_get_drvdata(pdev);
 797
 798         if (card)
 799                 snd_card_free(card);
 800
 801         return 0;
 802 }
 803
 804
 805 static struct platform_driver snd_portman_driver = {
 806         .probe  = snd_portman_probe,
 807         .remove = snd_portman_remove,
 808         .driver = {
 809                 .name = PLATFORM_DRIVER,
 810         }
 811 };
 812
 813 /*********************************************************************
 814  * module init stuff
 815  *********************************************************************/
 816 static void snd_portman_unregister_all(void)
 817 {
 818         int i;
 819
 820         for (i = 0; i < SNDRV_CARDS; ++i) {
 821                 if (platform_devices[i]) {
 822                         platform_device_unregister(platform_devices[i]);
 823                         platform_devices[i] = NULL;
 824                 }
 825         }
 826         platform_driver_unregister(&snd_portman_driver);
 827         parport_unregister_driver(&portman_parport_driver);
 828 }
 829
 830 static int __init snd_portman_module_init(void)
 831 {
 832         int err;
 833
 834         if ((err = platform_driver_register(&snd_portman_driver)) < 0)
 835                 return err;
 836
 837         if (parport_register_driver(&portman_parport_driver) != 0) {
 838                 platform_driver_unregister(&snd_portman_driver);
 839                 return -EIO;
 840         }
 841
 842         if (device_count == 0) {
 843                 snd_portman_unregister_all();
 844                 return -ENODEV;
 845         }
 846
 847         return 0;
 848 }
 849
 850 static void __exit snd_portman_module_exit(void)
 851 {
 852         snd_portman_unregister_all();
 853 }
 854
 855 module_init(snd_portman_module_init);
 856 module_exit(snd_portman_module_exit);