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 <[email protected]>
   6  *
   7  * ChangeLog
   8  * Jan 24 2007 Matthias Koenig <[email protected]>
   9  *      - cleanup and rewrite
  10  * Sep 30 2004 Tobias Gehrig <[email protected]>
  11  *      - source code cleanup
  12  * Sep 03 2004 Tobias Gehrig <[email protected]>
  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 <[email protected]>
  17  *      - added 2.6 kernel support
  18  * Mar 18 2004 Tobias Gehrig <[email protected]>
  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 <[email protected]>
  22  *      - added checks for opened input device in interrupt handler
  23  * Feb 20 2004 Tobias Gehrig <[email protected]>
  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                 dev_warn(pm->card->dev, "%s Won't flush port %i\n",
 389                          __func__, port);
 390                 return;
 391         }
 392
 393         /* Set address for specified channel in port and allow to settle. */
 394         portman_write_command(pm, command);
 395
 396         /* Assert the Strobe and wait for echo back. */
 397         portman_write_command(pm, command | STROBE);
 398
 399         /* Wait for ESTB */
 400         while ((portman_read_status(pm) & ESTB) == 0)
 401                 cpu_relax();
 402
 403         /* Output clock cycles to the Rx circuitry. */
 404         portman_write_data(pm, 0);
 405
 406         /* Flush 250 bits... */
 407         for (i = 0; i < 250; i++) {
 408                 portman_write_data(pm, 1);
 409                 portman_write_data(pm, 0);
 410         }
 411
 412         /* Deassert the Strobe signal of the port and wait for it to settle. */
 413         portman_write_command(pm, command | INT_EN);
 414
 415         /* Wait for settling */
 416         while ((portman_read_status(pm) & ESTB) == ESTB)
 417                 cpu_relax();
 418 }
 419
 420 static int portman_probe(struct parport *p)
 421 {
 422         /* Initialize the parallel port data register.  Will set Rx clocks
 423          * low in case we happen to be addressing the Rx ports at this time.
 424          */
 425         /* 1 */
 426         parport_write_data(p, 0);
 427
 428         /* Initialize the parallel port command register, thus initializing
 429          * hardware handshake lines to midi box:
 430          *
 431          *                                  Strobe = 0
 432          *                                  Interrupt Enable = 0
 433          */
 434         /* 2 */
 435         parport_write_control(p, 0);
 436
 437         /* Check if Portman PC/P 2x4 is out there. */
 438         /* 3 */
 439         parport_write_control(p, RXDATA0);      /* Write Strobe=0 to command reg. */
 440
 441         /* Check for ESTB to be clear */
 442         /* 4 */
 443         if ((parport_read_status(p) & ESTB) == ESTB)
 444                 return 1;       /* CODE 1 - Strobe Failure. */
 445
 446         /* Set for RXDATA0 where no damage will be done. */
 447         /* 5 */
 448         parport_write_control(p, RXDATA0 | STROBE);     /* Write Strobe=1 to command reg. */
 449
 450         /* 6 */
 451         if ((parport_read_status(p) & ESTB) != ESTB)
 452                 return 1;       /* CODE 1 - Strobe Failure. */
 453
 454         /* 7 */
 455         parport_write_control(p, 0);    /* Reset Strobe=0. */
 456
 457         /* Check if Tx circuitry is functioning properly.  If initialized
 458          * unit TxEmpty is false, send out char and see if it goes true.
 459          */
 460         /* 8 */
 461         parport_write_control(p, TXDATA0);      /* Tx channel 0, strobe off. */
 462
 463         /* If PCP channel's TxEmpty is set (TxEmpty is read through the PP
 464          * Status Register), then go write data.  Else go back and wait.
 465          */
 466         /* 9 */
 467         if ((parport_read_status(p) & TXEMPTY) == 0)
 468                 return 2;
 469
 470         /* Return OK status. */
 471         return 0;
 472 }
 473
 474 static int portman_device_init(struct portman *pm)
 475 {
 476         portman_flush_input(pm, 0);
 477         portman_flush_input(pm, 1);
 478
 479         return 0;
 480 }
 481
 482 /*********************************************************************
 483  * Rawmidi
 484  *********************************************************************/
 485 static int snd_portman_midi_open(struct snd_rawmidi_substream *substream)
 486 {
 487         return 0;
 488 }
 489
 490 static int snd_portman_midi_close(struct snd_rawmidi_substream *substream)
 491 {
 492         return 0;
 493 }
 494
 495 static void snd_portman_midi_input_trigger(struct snd_rawmidi_substream *substream,
 496                                            int up)
 497 {
 498         struct portman *pm = substream->rmidi->private_data;
 499         unsigned long flags;
 500
 501         spin_lock_irqsave(&pm->reg_lock, flags);
 502         if (up)
 503                 pm->mode[substream->number] |= PORTMAN2X4_MODE_INPUT_TRIGGERED;
 504         else
 505                 pm->mode[substream->number] &= ~PORTMAN2X4_MODE_INPUT_TRIGGERED;
 506         spin_unlock_irqrestore(&pm->reg_lock, flags);
 507 }
 508
 509 static void snd_portman_midi_output_trigger(struct snd_rawmidi_substream *substream,
 510                                             int up)
 511 {
 512         struct portman *pm = substream->rmidi->private_data;
 513         unsigned long flags;
 514         unsigned char byte;
 515
 516         spin_lock_irqsave(&pm->reg_lock, flags);
 517         if (up) {
 518                 while ((snd_rawmidi_transmit(substream, &byte, 1) == 1))
 519                         portman_write_midi(pm, substream->number, byte);
 520         }
 521         spin_unlock_irqrestore(&pm->reg_lock, flags);
 522 }
 523
 524 static const struct snd_rawmidi_ops snd_portman_midi_output = {
 525         .open =         snd_portman_midi_open,
 526         .close =        snd_portman_midi_close,
 527         .trigger =      snd_portman_midi_output_trigger,
 528 };
 529
 530 static const struct snd_rawmidi_ops snd_portman_midi_input = {
 531         .open =         snd_portman_midi_open,
 532         .close =        snd_portman_midi_close,
 533         .trigger =      snd_portman_midi_input_trigger,
 534 };
 535
 536 /* Create and initialize the rawmidi component */
 537 static int snd_portman_rawmidi_create(struct snd_card *card)
 538 {
 539         struct portman *pm = card->private_data;
 540         struct snd_rawmidi *rmidi;
 541         struct snd_rawmidi_substream *substream;
 542         int err;
 543
 544         err = snd_rawmidi_new(card, CARD_NAME, 0,
 545                               PORTMAN_NUM_OUTPUT_PORTS,
 546                               PORTMAN_NUM_INPUT_PORTS,
 547                               &rmidi);
 548         if (err < 0)
 549                 return err;
 550
 551         rmidi->private_data = pm;
 552         strcpy(rmidi->name, CARD_NAME);
 553         rmidi->info_flags = SNDRV_RAWMIDI_INFO_OUTPUT |
 554                             SNDRV_RAWMIDI_INFO_INPUT |
 555                             SNDRV_RAWMIDI_INFO_DUPLEX;
 556
 557         pm->rmidi = rmidi;
 558
 559         /* register rawmidi ops */
 560         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
 561                             &snd_portman_midi_output);
 562         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
 563                             &snd_portman_midi_input);
 564
 565         /* name substreams */
 566         /* output */
 567         list_for_each_entry(substream,
 568                             &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams,
 569                             list) {
 570                 sprintf(substream->name,
 571                         "Portman2x4 %d", substream->number+1);
 572         }
 573         /* input */
 574         list_for_each_entry(substream,
 575                             &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams,
 576                             list) {
 577                 pm->midi_input[substream->number] = substream;
 578                 sprintf(substream->name,
 579                         "Portman2x4 %d", substream->number+1);
 580         }
 581
 582         return err;
 583 }
 584
 585 /*********************************************************************
 586  * parport stuff
 587  *********************************************************************/
 588 static void snd_portman_interrupt(void *userdata)
 589 {
 590         unsigned char midivalue = 0;
 591         struct portman *pm = ((struct snd_card*)userdata)->private_data;
 592
 593         spin_lock(&pm->reg_lock);
 594
 595         /* While any input data is waiting */
 596         while ((portman_read_status(pm) & INT_REQ) == INT_REQ) {
 597                 /* If data available on channel 0,
 598                    read it and stuff it into the queue. */
 599                 if (portman_data_avail(pm, 0)) {
 600                         /* Read Midi */
 601                         midivalue = portman_read_midi(pm, 0);
 602                         /* put midi into queue... */
 603                         if (pm->mode[0] & PORTMAN2X4_MODE_INPUT_TRIGGERED)
 604                                 snd_rawmidi_receive(pm->midi_input[0],
 605                                                     &midivalue, 1);
 606
 607                 }
 608                 /* If data available on channel 1,
 609                    read it and stuff it into the queue. */
 610                 if (portman_data_avail(pm, 1)) {
 611                         /* Read Midi */
 612                         midivalue = portman_read_midi(pm, 1);
 613                         /* put midi into queue... */
 614                         if (pm->mode[1] & PORTMAN2X4_MODE_INPUT_TRIGGERED)
 615                                 snd_rawmidi_receive(pm->midi_input[1],
 616                                                     &midivalue, 1);
 617                 }
 618
 619         }
 620
 621         spin_unlock(&pm->reg_lock);
 622 }
 623
 624 static void snd_portman_attach(struct parport *p)
 625 {
 626         struct platform_device *device;
 627
 628         device = platform_device_alloc(PLATFORM_DRIVER, device_count);
 629         if (!device)
 630                 return;
 631
 632         /* Temporary assignment to forward the parport */
 633         platform_set_drvdata(device, p);
 634
 635         if (platform_device_add(device) < 0) {
 636                 platform_device_put(device);
 637                 return;
 638         }
 639
 640         /* Since we dont get the return value of probe
 641          * We need to check if device probing succeeded or not */
 642         if (!platform_get_drvdata(device)) {
 643                 platform_device_unregister(device);
 644                 return;
 645         }
 646
 647         /* register device in global table */
 648         platform_devices[device_count] = device;
 649         device_count++;
 650 }
 651
 652 static void snd_portman_detach(struct parport *p)
 653 {
 654         /* nothing to do here */
 655 }
 656
 657 static int snd_portman_dev_probe(struct pardevice *pardev)
 658 {
 659         if (strcmp(pardev->name, DRIVER_NAME))
 660                 return -ENODEV;
 661
 662         return 0;
 663 }
 664
 665 static struct parport_driver portman_parport_driver = {
 666         .name           = "portman2x4",
 667         .probe          = snd_portman_dev_probe,
 668         .match_port     = snd_portman_attach,
 669         .detach         = snd_portman_detach,
 670 };
 671
 672 /*********************************************************************
 673  * platform stuff
 674  *********************************************************************/
 675 static void snd_portman_card_private_free(struct snd_card *card)
 676 {
 677         struct portman *pm = card->private_data;
 678         struct pardevice *pardev = pm->pardev;
 679
 680         if (pardev) {
 681                 parport_release(pardev);
 682                 parport_unregister_device(pardev);
 683         }
 684
 685         portman_free(pm);
 686 }
 687
 688 static int snd_portman_probe(struct platform_device *pdev)
 689 {
 690         struct pardevice *pardev;
 691         struct parport *p;
 692         int dev = pdev->id;
 693         struct snd_card *card = NULL;
 694         struct portman *pm = NULL;
 695         int err;
 696         struct pardev_cb portman_cb = {
 697                 .preempt = NULL,
 698                 .wakeup = NULL,
 699                 .irq_func = snd_portman_interrupt,      /* ISR */
 700                 .flags = PARPORT_DEV_EXCL,              /* flags */
 701         };
 702
 703         p = platform_get_drvdata(pdev);
 704         platform_set_drvdata(pdev, NULL);
 705
 706         if (dev >= SNDRV_CARDS)
 707                 return -ENODEV;
 708         if (!enable[dev])
 709                 return -ENOENT;
 710
 711         err = snd_card_new(&pdev->dev, index[dev], id[dev], THIS_MODULE,
 712                            0, &card);
 713         if (err < 0) {
 714                 dev_dbg(&pdev->dev, "Cannot create card\n");
 715                 return err;
 716         }
 717         strcpy(card->driver, DRIVER_NAME);
 718         strcpy(card->shortname, CARD_NAME);
 719         sprintf(card->longname,  "%s at 0x%lx, irq %i",
 720                 card->shortname, p->base, p->irq);
 721
 722         portman_cb.private = card;                         /* private */
 723         pardev = parport_register_dev_model(p,             /* port */
 724                                             DRIVER_NAME,   /* name */
 725                                             &portman_cb,   /* callbacks */
 726                                             pdev->id);     /* device number */
 727         if (pardev == NULL) {
 728                 dev_dbg(card->dev, "Cannot register pardevice\n");
 729                 err = -EIO;
 730                 goto __err;
 731         }
 732
 733         /* claim parport */
 734         if (parport_claim(pardev)) {
 735                 dev_dbg(card->dev, "Cannot claim parport 0x%lx\n", pardev->port->base);
 736                 err = -EIO;
 737                 goto free_pardev;
 738         }
 739
 740         err = portman_create(card, pardev, &pm);
 741         if (err < 0) {
 742                 dev_dbg(card->dev, "Cannot create main component\n");
 743                 goto release_pardev;
 744         }
 745         card->private_data = pm;
 746         card->private_free = snd_portman_card_private_free;
 747
 748         err = portman_probe(p);
 749         if (err) {
 750                 err = -EIO;
 751                 goto __err;
 752         }
 753
 754         err = snd_portman_rawmidi_create(card);
 755         if (err < 0) {
 756                 dev_dbg(card->dev, "Creating Rawmidi component failed\n");
 757                 goto __err;
 758         }
 759
 760         /* init device */
 761         err = portman_device_init(pm);
 762         if (err < 0)
 763                 goto __err;
 764
 765         platform_set_drvdata(pdev, card);
 766
 767         /* At this point card will be usable */
 768         err = snd_card_register(card);
 769         if (err < 0) {
 770                 dev_dbg(card->dev, "Cannot register card\n");
 771                 goto __err;
 772         }
 773
 774         dev_info(card->dev, "Portman 2x4 on 0x%lx\n", p->base);
 775         return 0;
 776
 777 release_pardev:
 778         parport_release(pardev);
 779 free_pardev:
 780         parport_unregister_device(pardev);
 781 __err:
 782         snd_card_free(card);
 783         return err;
 784 }
 785
 786 static void snd_portman_remove(struct platform_device *pdev)
 787 {
 788         struct snd_card *card = platform_get_drvdata(pdev);
 789
 790         if (card)
 791                 snd_card_free(card);
 792 }
 793
 794
 795 static struct platform_driver snd_portman_driver = {
 796         .probe  = snd_portman_probe,
 797         .remove = snd_portman_remove,
 798         .driver = {
 799                 .name = PLATFORM_DRIVER,
 800         }
 801 };
 802
 803 /*********************************************************************
 804  * module init stuff
 805  *********************************************************************/
 806 static void snd_portman_unregister_all(void)
 807 {
 808         int i;
 809
 810         for (i = 0; i < SNDRV_CARDS; ++i) {
 811                 if (platform_devices[i]) {
 812                         platform_device_unregister(platform_devices[i]);
 813                         platform_devices[i] = NULL;
 814                 }
 815         }
 816         platform_driver_unregister(&snd_portman_driver);
 817         parport_unregister_driver(&portman_parport_driver);
 818 }
 819
 820 static int __init snd_portman_module_init(void)
 821 {
 822         int err;
 823
 824         err = platform_driver_register(&snd_portman_driver);
 825         if (err < 0)
 826                 return err;
 827
 828         if (parport_register_driver(&portman_parport_driver) != 0) {
 829                 platform_driver_unregister(&snd_portman_driver);
 830                 return -EIO;
 831         }
 832
 833         if (device_count == 0) {
 834                 snd_portman_unregister_all();
 835                 return -ENODEV;
 836         }
 837
 838         return 0;
 839 }
 840
 841 static void __exit snd_portman_module_exit(void)
 842 {
 843         snd_portman_unregister_all();
 844 }
 845
 846 module_init(snd_portman_module_init);
 847 module_exit(snd_portman_module_exit);