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