sound/drivers/portman2x4.c

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