root/sound/drivers/portman2x4.c

DEFINITIONS

1. portman_free
2. portman_create
3. portman_write_command
4. portman_read_command
5. portman_read_status
6. portman_read_data
7. portman_write_data
8. portman_write_midi
9. portman_read_midi
10. portman_data_avail
11. portman_flush_input
12. portman_probe
13. portman_device_init
14. snd_portman_midi_open
15. snd_portman_midi_close
16. snd_portman_midi_input_trigger
17. snd_portman_midi_output_trigger
18. snd_portman_rawmidi_create
19. snd_portman_interrupt
20. snd_portman_attach
21. snd_portman_detach
22. snd_portman_dev_probe
23. snd_portman_card_private_free
24. snd_portman_probe
25. snd_portman_remove
26. snd_portman_unregister_all
27. snd_portman_module_init
28. snd_portman_module_exit

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