linux/sound/drivers/portman2x4.c
<<
>>
Prefs
   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
  54static int index[SNDRV_CARDS]  = SNDRV_DEFAULT_IDX;
  55static char *id[SNDRV_CARDS]   = SNDRV_DEFAULT_STR;
  56static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  57
  58static struct platform_device *platform_devices[SNDRV_CARDS]; 
  59static int device_count;
  60
  61module_param_array(index, int, NULL, S_IRUGO);
  62MODULE_PARM_DESC(index, "Index value for " CARD_NAME " soundcard.");
  63module_param_array(id, charp, NULL, S_IRUGO);
  64MODULE_PARM_DESC(id, "ID string for " CARD_NAME " soundcard.");
  65module_param_array(enable, bool, NULL, S_IRUGO);
  66MODULE_PARM_DESC(enable, "Enable " CARD_NAME " soundcard.");
  67
  68MODULE_AUTHOR("Levent Guendogdu, Tobias Gehrig, Matthias Koenig");
  69MODULE_DESCRIPTION("Midiman Portman2x4");
  70MODULE_LICENSE("GPL");
  71MODULE_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
  79struct 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
  91static int portman_free(struct portman *pm)
  92{
  93        kfree(pm);
  94        return 0;
  95}
  96
  97static 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 *********************************************************************/
 194static inline void portman_write_command(struct portman *pm, u8 value)
 195{
 196        parport_write_control(pm->pardev->port, value);
 197}
 198
 199static inline u8 portman_read_command(struct portman *pm)
 200{
 201        return parport_read_control(pm->pardev->port);
 202}
 203
 204static inline u8 portman_read_status(struct portman *pm)
 205{
 206        return parport_read_status(pm->pardev->port);
 207}
 208
 209static inline u8 portman_read_data(struct portman *pm)
 210{
 211        return parport_read_data(pm->pardev->port);
 212}
 213
 214static inline void portman_write_data(struct portman *pm, u8 value)
 215{
 216        parport_write_data(pm->pardev->port, value);
 217}
 218
 219static 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 */
 291static 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 */
 373static 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 */
 398static 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
 445static 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
 499static 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 *********************************************************************/
 510static int snd_portman_midi_open(struct snd_rawmidi_substream *substream)
 511{
 512        return 0;
 513}
 514
 515static int snd_portman_midi_close(struct snd_rawmidi_substream *substream)
 516{
 517        return 0;
 518}
 519
 520static 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
 534static 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
 549static 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
 555static 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 */
 562static 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 *********************************************************************/
 613static 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
 649static 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
 673static 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
 701static void snd_portman_detach(struct parport *p)
 702{
 703        /* nothing to do here */
 704}
 705
 706static 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 *********************************************************************/
 715static 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
 729static 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        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
 750        if (err < 0) {
 751                snd_printd("Cannot create card\n");
 752                return err;
 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
 815static 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
 826static 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 *********************************************************************/
 837static 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
 851static 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
 871static void __exit snd_portman_module_exit(void)
 872{
 873        snd_portman_unregister_all();
 874}
 875
 876module_init(snd_portman_module_init);
 877module_exit(snd_portman_module_exit);
 878