Changeset 305 for GPL/branches/uniaud-2.0/alsa-kernel/drivers/mtpav.c

Timestamp:

Mar 24, 2008, 2:43:42 AM (17 years ago)

Author:

Paul Smedley

Message:

Update source to ALSA 1.0.16 level

File:

• GPL/branches/uniaud-2.0/alsa-kernel/drivers/mtpav.c (modified) (33 diffs)

GPL/branches/uniaud-2.0/alsa-kernel/drivers/mtpav.c

@@ -2 +2 @@
  *      MOTU Midi Timepiece ALSA Main routines
  *      Copyright by Michael T. Mayers (c) Jan 09, 2000
- *      mail: tweakoz@pacbell.net
+ *      mail: michael@tweakoz.com
  *      Thanks to John Galbraith
  *
@@ -17 +17 @@
  *      You should have received a copy of the GNU General Public License
  *      along with this program; if not, write to the Free Software
- *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
  *
@@ -45 +45 @@
  *      - Recoded & debugged
  *      - Added timer interrupt for midi outputs
- *      - snd_hwports is between 1 and 8, which specifies the number of hardware ports.
+ *      - hwports is between 1 and 8, which specifies the number of hardware ports.
  *        The three global ports, computer, adat and broadcast ports, are created
  *        always after h/w and remote ports.
@@ -51 +51 @@
  */
 
-#define SNDRV_MAIN_OBJECT_FILE
-#include <sound/driver.h>
-#define SNDRV_GET_ID
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/ioport.h>
+#include <linux/moduleparam.h>
+#include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
+#include <linux/delay.h>
+
+#include <asm/io.h>
 
 /*
  *      globals
  */
-EXPORT_NO_SYMBOLS;
+MODULE_AUTHOR("Michael T. Mayers");
 MODULE_DESCRIPTION("MOTU MidiTimePiece AV multiport MIDI");
-MODULE_CLASSES("{sound}");
-MODULE_DEVICES("{{MOTU,MidiTimePiece AV multiport MIDI}}");
+MODULE_LICENSE("GPL");
+MODULE_SUPPORTED_DEVICE("{{MOTU,MidiTimePiece AV multiport MIDI}}");
 
 // io resources
@@ -70 +78 @@
 #define MTPAV_MAX_PORTS         8
 
-static int snd_index = SNDRV_DEFAULT_IDX1;
-static char *snd_id = SNDRV_DEFAULT_STR1;
-static long snd_port = MTPAV_IOBASE;    /* 0x378, 0x278 */
-static int snd_irq = MTPAV_IRQ;         /* 7, 5 */
-static int snd_hwports = MTPAV_MAX_PORTS;       /* use hardware ports 1-8 */
-
-MODULE_PARM(snd_index, "i");
-MODULE_PARM_DESC(snd_index, "Index value for MotuMTPAV MIDI.");
-MODULE_PARM_SYNTAX(snd_index, SNDRV_INDEX_DESC);
-MODULE_PARM(snd_id, "s");
-MODULE_PARM_DESC(snd_id, "ID string for MotuMTPAV MIDI.");
-MODULE_PARM_SYNTAX(snd_id, SNDRV_ID_DESC);
-MODULE_PARM(snd_port, "l");
-MODULE_PARM_DESC(snd_port, "Parallel port # for MotuMTPAV MIDI.");
-MODULE_PARM_SYNTAX(snd_port, "allows:{{0x378},{0x278}},dialog:list");
-MODULE_PARM(snd_irq, "i");
-MODULE_PARM_DESC(snd_irq, "Parallel IRQ # for MotuMTPAV MIDI.");
-MODULE_PARM_SYNTAX(snd_irq,  "allows:{{7},{5}},dialog:list");
-MODULE_PARM(snd_hwports, "i");
-MODULE_PARM_DESC(snd_hwports, "Hardware ports # for MotuMTPAV MIDI.");
-MODULE_PARM_SYNTAX(snd_hwports, "allows:{{1,8}},dialog:list");
+static int index = SNDRV_DEFAULT_IDX1;
+static char *id = SNDRV_DEFAULT_STR1;
+static long port = MTPAV_IOBASE;        /* 0x378, 0x278 */
+static int irq = MTPAV_IRQ;             /* 7, 5 */
+static int hwports = MTPAV_MAX_PORTS;   /* use hardware ports 1-8 */
+
+module_param(index, int, 0444);
+MODULE_PARM_DESC(index, "Index value for MotuMTPAV MIDI.");
+module_param(id, charp, 0444);
+MODULE_PARM_DESC(id, "ID string for MotuMTPAV MIDI.");
+module_param(port, long, 0444);
+MODULE_PARM_DESC(port, "Parallel port # for MotuMTPAV MIDI.");
+module_param(irq, int, 0444);
+MODULE_PARM_DESC(irq, "Parallel IRQ # for MotuMTPAV MIDI.");
+module_param(hwports, int, 0444);
+MODULE_PARM_DESC(hwports, "Hardware ports # for MotuMTPAV MIDI.");
+
+static struct platform_device *device;
 
 /*
  *      defines
  */
-//#define USE_FAKE_MTP //       dont actually read/write to MTP device (for debugging without an actual unit) (does not work yet)
+//#define USE_FAKE_MTP //       don't actually read/write to MTP device (for debugging without an actual unit) (does not work yet)
 
 // parallel port usage masks
@@ -124 +129 @@
  */
 
-typedef struct mtpav_port {
+struct mtpav_port {
         u8 number;
         u8 hwport;
         u8 mode;
-        snd_rawmidi_substream_t *input;
-        snd_rawmidi_substream_t *output;
-} mtpav_port_t;
-
-typedef struct mtpav {
-        snd_card_t *card;
+        u8 running_status;
+        struct snd_rawmidi_substream *input;
+        struct snd_rawmidi_substream *output;
+};
+
+struct mtpav {
+        struct snd_card *card;
         unsigned long port;
         struct resource *res_port;
@@ -141 +147 @@
         int istimer;                    /* number of accesses to timer interrupts */
         struct timer_list timer;        /* timer interrupts for outputs */
-        snd_rawmidi_t *rmidi;
+        struct snd_rawmidi *rmidi;
         int num_ports;          /* number of hw ports (1-8) */
-        mtpav_port_t ports[NUMPORTS];   /* all ports including computer, adat and bc */
+        struct mtpav_port ports[NUMPORTS];      /* all ports including computer, adat and bc */
 
         u32 inmidiport;         /* selected input midi port */
@@ -149 +155 @@
 
         u32 outmidihwport;      /* selected output midi hw port */
-} mtpav_t;
-
-
-/*
- * global instance
- * hey, we handle at most only one card..
- */
-static mtpav_t *mtp_card;
+};
+
 
 /*
@@ -181 +181 @@
 
 
-static int translate_subdevice_to_hwport(mtpav_t *chip, int subdev)
+static int translate_subdevice_to_hwport(struct mtpav *chip, int subdev)
 {
         if (subdev < 0)
@@ -196 +196 @@
 }
 
-static int translate_hwport_to_subdevice(mtpav_t *chip, int hwport)
-{
-        int port;
+static int translate_hwport_to_subdevice(struct mtpav *chip, int hwport)
+{
+        int p;
         if (hwport <= 0x00) /* all ports */
                 return chip->num_ports + MTPAV_PIDX_BROADCAST;
         else if (hwport <= 0x08) { /* single port */
-                port = hwport - 1;
-                if (port >= chip->num_ports)
-                        port = 0;
-                return port;
+                p = hwport - 1;
+                if (p >= chip->num_ports)
+                        p = 0;
+                return p;
         } else if (hwport <= 0x10) { /* remote port */
-                port = hwport - 0x09 + chip->num_ports;
-                if (port >= chip->num_ports * 2)
-                        port = chip->num_ports;
-                return port;
+                p = hwport - 0x09 + chip->num_ports;
+                if (p >= chip->num_ports * 2)
+                        p = chip->num_ports;
+                return p;
         } else if (hwport == 0x11)  /* computer port */
                 return chip->num_ports + MTPAV_PIDX_COMPUTER;
@@ -221 +221 @@
  */
 
-static u8 snd_mtpav_getreg(mtpav_t *chip, u16 reg)
+static u8 snd_mtpav_getreg(struct mtpav *chip, u16 reg)
 {
         u8 rval = 0;
@@ -239 +239 @@
  */
 
-static void snd_mtpav_mputreg(mtpav_t *chip, u16 reg, u8 val)
-{
-        if (reg == DREG) {
-                outb(val, chip->port + DREG);
-        } else if (reg == CREG) {
-                outb(val, chip->port + CREG);
-        }
-}
-
-/*
- */
-
-static void snd_mtpav_wait_rfdhi(mtpav_t *chip)
+static inline void snd_mtpav_mputreg(struct mtpav *chip, u16 reg, u8 val)
+{
+        if (reg == DREG || reg == CREG)
+                outb(val, chip->port + reg);
+}
+
+/*
+ */
+
+static void snd_mtpav_wait_rfdhi(struct mtpav *chip)
 {
         int counts = 10000;
@@ -263 +260 @@
 }
 
-static void snd_mtpav_send_byte(mtpav_t *chip, u8 byte)
+static void snd_mtpav_send_byte(struct mtpav *chip, u8 byte)
 {
         u8 tcbyt;
@@ -289 +286 @@
 
 /* call this with spin lock held */
-static void snd_mtpav_output_port_write(mtpav_port_t *port,
-                                        snd_rawmidi_substream_t *substream)
+static void snd_mtpav_output_port_write(struct mtpav *mtp_card,
+                                        struct mtpav_port *portp,
+                                        struct snd_rawmidi_substream *substream)
 {
         u8 outbyte;
 
+        // Get the outbyte first, so we can emulate running status if
+        // necessary
+        if (snd_rawmidi_transmit(substream, &outbyte, 1) != 1)
+                return;
+
         // send port change command if necessary
 
-        if (port->hwport != mtp_card->outmidihwport) {
-                mtp_card->outmidihwport = port->hwport;
+        if (portp->hwport != mtp_card->outmidihwport) {
+                mtp_card->outmidihwport = portp->hwport;
 
                 snd_mtpav_send_byte(mtp_card, 0xf5);
-                snd_mtpav_send_byte(mtp_card, port->hwport);
-                //snd_printk("new outport: 0x%x\n", (unsigned int) port->hwport);
-
+                snd_mtpav_send_byte(mtp_card, portp->hwport);
+                //snd_printk("new outport: 0x%x\n", (unsigned int) portp->hwport);
+
+                if (!(outbyte & 0x80) && portp->running_status)
+                        snd_mtpav_send_byte(mtp_card, portp->running_status);
         }
 
         // send data
 
-        while (snd_rawmidi_transmit(substream, &outbyte, 1) == 1)
+        do {
+                if (outbyte & 0x80)
+                        portp->running_status = outbyte;
+                
                 snd_mtpav_send_byte(mtp_card, outbyte);
-}
-
-static void snd_mtpav_output_write(snd_rawmidi_substream_t * substream)
-{
-        mtpav_port_t *port = &mtp_card->ports[substream->number];
+        } while (snd_rawmidi_transmit(substream, &outbyte, 1) == 1);
+}
+
+static void snd_mtpav_output_write(struct snd_rawmidi_substream *substream)
+{
+        struct mtpav *mtp_card = substream->rmidi->private_data;
+        struct mtpav_port *portp = &mtp_card->ports[substream->number];
         unsigned long flags;
 
         spin_lock_irqsave(&mtp_card->spinlock, flags);
-        snd_mtpav_output_port_write(port, substream);
+        snd_mtpav_output_port_write(mtp_card, portp, substream);
         spin_unlock_irqrestore(&mtp_card->spinlock, flags);
 }
@@ -326 +336 @@
  */
 
-static void snd_mtpav_portscan(mtpav_t *chip)   // put mtp into smart routing mode
-{
-        u8 port;
-
-        for (port = 0; port < 8; port++) {
+static void snd_mtpav_portscan(struct mtpav *chip)      // put mtp into smart routing mode
+{
+        u8 p;
+
+        for (p = 0; p < 8; p++) {
                 snd_mtpav_send_byte(chip, 0xf5);
-                snd_mtpav_send_byte(chip, port);
+                snd_mtpav_send_byte(chip, p);
                 snd_mtpav_send_byte(chip, 0xfe);
         }
@@ -340 +350 @@
  */
 
-static int snd_mtpav_input_open(snd_rawmidi_substream_t * substream)
-{
-        unsigned long flags;
-        mtpav_port_t *port = &mtp_card->ports[substream->number];
-
-        //printk("mtpav port: %d opened\n", (int) substream->number);
+static int snd_mtpav_input_open(struct snd_rawmidi_substream *substream)
+{
+        struct mtpav *mtp_card = substream->rmidi->private_data;
+        struct mtpav_port *portp = &mtp_card->ports[substream->number];
+        unsigned long flags;
+
         spin_lock_irqsave(&mtp_card->spinlock, flags);
-        port->mode |= MTPAV_MODE_INPUT_OPENED;
-        port->input = substream;
+        portp->mode |= MTPAV_MODE_INPUT_OPENED;
+        portp->input = substream;
         if (mtp_card->share_irq++ == 0)
                 snd_mtpav_mputreg(mtp_card, CREG, (SIGC_INTEN | SIGC_WRITE));   // enable pport interrupts
@@ -358 +368 @@
  */
 
-static int snd_mtpav_input_close(snd_rawmidi_substream_t *substream)
-{
-        unsigned long flags;
-        mtpav_port_t *port = &mtp_card->ports[substream->number];
-
-        //printk("mtpav port: %d closed\n", (int) port);
+static int snd_mtpav_input_close(struct snd_rawmidi_substream *substream)
+{
+        struct mtpav *mtp_card = substream->rmidi->private_data;
+        struct mtpav_port *portp = &mtp_card->ports[substream->number];
+        unsigned long flags;
 
         spin_lock_irqsave(&mtp_card->spinlock, flags);
-
-        port->mode &= (~MTPAV_MODE_INPUT_OPENED);
-        port->input = NULL;
+        portp->mode &= ~MTPAV_MODE_INPUT_OPENED;
+        portp->input = NULL;
         if (--mtp_card->share_irq == 0)
                 snd_mtpav_mputreg(mtp_card, CREG, 0);   // disable pport interrupts
-
         spin_unlock_irqrestore(&mtp_card->spinlock, flags);
         return 0;
@@ -379 +386 @@
  */
 
-static void snd_mtpav_input_trigger(snd_rawmidi_substream_t * substream, int up)
-{
-        unsigned long flags;
-        mtpav_port_t *port = &mtp_card->ports[substream->number];
+static void snd_mtpav_input_trigger(struct snd_rawmidi_substream *substream, int up)
+{
+        struct mtpav *mtp_card = substream->rmidi->private_data;
+        struct mtpav_port *portp = &mtp_card->ports[substream->number];
+        unsigned long flags;
 
         spin_lock_irqsave(&mtp_card->spinlock, flags);
         if (up)
-                port->mode |= MTPAV_MODE_INPUT_TRIGGERED;
+                portp->mode |= MTPAV_MODE_INPUT_TRIGGERED;
         else
-                port->mode &= ~MTPAV_MODE_INPUT_TRIGGERED;
+                portp->mode &= ~MTPAV_MODE_INPUT_TRIGGERED;
         spin_unlock_irqrestore(&mtp_card->spinlock, flags);
 
@@ -400 +408 @@
 static void snd_mtpav_output_timer(unsigned long data)
 {
-        mtpav_t *chip = snd_magic_cast(mtpav_t, (void *)data, return);
+        unsigned long flags;
+        struct mtpav *chip = (struct mtpav *)data;
         int p;
 
-        spin_lock(&chip->spinlock);
+        spin_lock_irqsave(&chip->spinlock, flags);
         /* reprogram timer */
         chip->timer.expires = 1 + jiffies;
@@ -409 +418 @@
         /* process each port */
         for (p = 0; p <= chip->num_ports * 2 + MTPAV_PIDX_BROADCAST; p++) {
-                mtpav_port_t *port = &mtp_card->ports[p];
-                if ((port->mode & MTPAV_MODE_OUTPUT_TRIGGERED) && port->output)
-                        snd_mtpav_output_port_write(port, port->output);
-        }
-        spin_unlock(&chip->spinlock);
-}
-
-static void snd_mtpav_add_output_timer(mtpav_t *chip)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&chip->spinlock, flags);
-        chip->timer.function = snd_mtpav_output_timer;
-        chip->timer.data = (unsigned long) mtp_card;
+                struct mtpav_port *portp = &chip->ports[p];
+                if ((portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED) && portp->output)
+                        snd_mtpav_output_port_write(chip, portp, portp->output);
+        }
+        spin_unlock_irqrestore(&chip->spinlock, flags);
+}
+
+/* spinlock held! */
+static void snd_mtpav_add_output_timer(struct mtpav *chip)
+{
         chip->timer.expires = 1 + jiffies;
         add_timer(&chip->timer);
-        spin_unlock_irqrestore(&chip->spinlock, flags);
-}
-
-static void snd_mtpav_remove_output_timer(mtpav_t *chip)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&chip->spinlock, flags);
+}
+
+/* spinlock held! */
+static void snd_mtpav_remove_output_timer(struct mtpav *chip)
+{
         del_timer(&chip->timer);
-        spin_unlock_irqrestore(&chip->spinlock, flags);
-}
-
-/*
- */
-
-static int snd_mtpav_output_open(snd_rawmidi_substream_t * substream)
-{
-        unsigned long flags;
-        mtpav_port_t *port = &mtp_card->ports[substream->number];
+}
+
+/*
+ */
+
+static int snd_mtpav_output_open(struct snd_rawmidi_substream *substream)
+{
+        struct mtpav *mtp_card = substream->rmidi->private_data;
+        struct mtpav_port *portp = &mtp_card->ports[substream->number];
+        unsigned long flags;
 
         spin_lock_irqsave(&mtp_card->spinlock, flags);
-        port->mode |= MTPAV_MODE_OUTPUT_OPENED;
-        port->output = substream;
+        portp->mode |= MTPAV_MODE_OUTPUT_OPENED;
+        portp->output = substream;
         spin_unlock_irqrestore(&mtp_card->spinlock, flags);
         return 0;
@@ -455 +457 @@
  */
 
-static int snd_mtpav_output_close(snd_rawmidi_substream_t * substream)
-{
-        unsigned long flags;
-        mtpav_port_t *port = &mtp_card->ports[substream->number];
+static int snd_mtpav_output_close(struct snd_rawmidi_substream *substream)
+{
+        struct mtpav *mtp_card = substream->rmidi->private_data;
+        struct mtpav_port *portp = &mtp_card->ports[substream->number];
+        unsigned long flags;
 
         spin_lock_irqsave(&mtp_card->spinlock, flags);
-        port->mode &= (~MTPAV_MODE_OUTPUT_OPENED);
-        port->output = NULL;
+        portp->mode &= ~MTPAV_MODE_OUTPUT_OPENED;
+        portp->output = NULL;
         spin_unlock_irqrestore(&mtp_card->spinlock, flags);
         return 0;
@@ -470 +473 @@
  */
 
-static void snd_mtpav_output_trigger(snd_rawmidi_substream_t * substream, int up)
-{
-        unsigned long flags;
-        mtpav_port_t *port = &mtp_card->ports[substream->number];
+static void snd_mtpav_output_trigger(struct snd_rawmidi_substream *substream, int up)
+{
+        struct mtpav *mtp_card = substream->rmidi->private_data;
+        struct mtpav_port *portp = &mtp_card->ports[substream->number];
+        unsigned long flags;
 
         spin_lock_irqsave(&mtp_card->spinlock, flags);
         if (up) {
-                if (! (port->mode  & MTPAV_MODE_OUTPUT_TRIGGERED)) {
+                if (! (portp->mode & MTPAV_MODE_OUTPUT_TRIGGERED)) {
                         if (mtp_card->istimer++ == 0)
                                 snd_mtpav_add_output_timer(mtp_card);
-                        port->mode |= MTPAV_MODE_OUTPUT_TRIGGERED;
+                        portp->mode |= MTPAV_MODE_OUTPUT_TRIGGERED;
                 }
         } else {
-                port->mode &= ~MTPAV_MODE_OUTPUT_TRIGGERED;
+                portp->mode &= ~MTPAV_MODE_OUTPUT_TRIGGERED;
                 if (--mtp_card->istimer == 0)
                         snd_mtpav_remove_output_timer(mtp_card);
@@ -497 +501 @@
  */
 
-static void snd_mtpav_inmidi_process(mtpav_t *mcrd, u8 inbyte)
-{
-        mtpav_port_t *port;
-
-        if (mcrd->inmidiport > mcrd->num_ports * 2 + MTPAV_PIDX_BROADCAST)
+static void snd_mtpav_inmidi_process(struct mtpav *mcrd, u8 inbyte)
+{
+        struct mtpav_port *portp;
+
+        if ((int)mcrd->inmidiport > mcrd->num_ports * 2 + MTPAV_PIDX_BROADCAST)
                 return;
 
-        port = &mcrd->ports[mcrd->inmidiport];
-        if (port->mode & MTPAV_MODE_INPUT_TRIGGERED)
-                snd_rawmidi_receive(port->input, &inbyte, 1);
-}
-
-static void snd_mtpav_inmidi_h(mtpav_t * mcrd, u8 inbyte)
-{
-#ifndef TARGET_OS2
-        snd_assert(mcrd, return);
-#endif
+        portp = &mcrd->ports[mcrd->inmidiport];
+        if (portp->mode & MTPAV_MODE_INPUT_TRIGGERED)
+                snd_rawmidi_receive(portp->input, &inbyte, 1);
+}
+
+static void snd_mtpav_inmidi_h(struct mtpav *mcrd, u8 inbyte)
+{
         if (inbyte >= 0xf8) {
                 /* real-time midi code */
@@ -531 +532 @@
 }
 
-static void snd_mtpav_read_bytes(mtpav_t * mcrd)
+static void snd_mtpav_read_bytes(struct mtpav *mcrd)
 {
         u8 clrread, setread;
@@ -569 +570 @@
 }
 
-static void snd_mtpav_irqh(int irq, void *dev_id, struct pt_regs *regs)
-{
-        mtpav_t *mcard = snd_magic_cast(mtpav_t, dev_id, return);
-
-        //printk("irqh()\n");
+static irqreturn_t snd_mtpav_irqh(int irq, void *dev_id)
+{
+        struct mtpav *mcard = dev_id;
+
         spin_lock(&mcard->spinlock);
         snd_mtpav_read_bytes(mcard);
         spin_unlock(&mcard->spinlock);
+        return IRQ_HANDLED;
 }
 
@@ -582 +583 @@
  * get ISA resources
  */
-static int snd_mtpav_get_ISA(mtpav_t * mcard)
-{
-        if ((mcard->res_port = request_region(snd_port, 3, "MotuMTPAV MIDI")) == NULL) {
-                snd_printk("MTVAP port 0x%lx is busy\n", snd_port);
+static int __devinit snd_mtpav_get_ISA(struct mtpav * mcard)
+{
+        if ((mcard->res_port = request_region(port, 3, "MotuMTPAV MIDI")) == NULL) {
+                snd_printk("MTVAP port 0x%lx is busy\n", port);
                 return -EBUSY;
         }
-        mcard->port = snd_port;
-        if (request_irq(snd_irq, snd_mtpav_irqh, SA_INTERRUPT, "MOTU MTPAV", (void *)mcard)) {
-                snd_printk("MTVAP IRQ %d busy\n", snd_irq);
+        mcard->port = port;
+        if (request_irq(irq, snd_mtpav_irqh, IRQF_DISABLED, "MOTU MTPAV", mcard)) {
+                snd_printk("MTVAP IRQ %d busy\n", irq);
                 return -EBUSY;
         }
-        mcard->irq = snd_irq;
+        mcard->irq = irq;
         return 0;
 }
@@ -601 +602 @@
  */
 
-#ifdef TARGET_OS2
-static snd_rawmidi_ops_t snd_mtpav_output = {
-        snd_mtpav_output_open,
-        snd_mtpav_output_close,
-        snd_mtpav_output_trigger,
-        0
+static struct snd_rawmidi_ops snd_mtpav_output = {
+        .open =         snd_mtpav_output_open,
+        .close =        snd_mtpav_output_close,
+        .trigger =      snd_mtpav_output_trigger,
 };
 
-static snd_rawmidi_ops_t snd_mtpav_input = {
-        snd_mtpav_input_open,
-        snd_mtpav_input_close,
-        snd_mtpav_input_trigger,
-        0
+static struct snd_rawmidi_ops snd_mtpav_input = {
+        .open =         snd_mtpav_input_open,
+        .close =        snd_mtpav_input_close,
+        .trigger =      snd_mtpav_input_trigger,
 };
-#else
-static snd_rawmidi_ops_t snd_mtpav_output = {
-        open:           snd_mtpav_output_open,
-        close:          snd_mtpav_output_close,
-        trigger:        snd_mtpav_output_trigger,
-};
-
-static snd_rawmidi_ops_t snd_mtpav_input = {
-        open:           snd_mtpav_input_open,
-        close:          snd_mtpav_input_close,
-        trigger:        snd_mtpav_input_trigger,
-};
-#endif
+
 
 /*
@@ -633 +619 @@
  */
 
-static void snd_mtpav_set_name(mtpav_t *chip, snd_rawmidi_substream_t *substream)
+static void __devinit snd_mtpav_set_name(struct mtpav *chip,
+                                      struct snd_rawmidi_substream *substream)
 {
         if (substream->number >= 0 && substream->number < chip->num_ports)
@@ -647 +634 @@
 }
 
-static int snd_mtpav_get_RAWMIDI(mtpav_t * mcard)
-{
-        int rval = 0;
-        snd_rawmidi_t *rawmidi;
-        snd_rawmidi_substream_t *substream;
+static int __devinit snd_mtpav_get_RAWMIDI(struct mtpav *mcard)
+{
+        int rval;
+        struct snd_rawmidi *rawmidi;
+        struct snd_rawmidi_substream *substream;
         struct list_head *list;
 
-        //printk("entering snd_mtpav_get_RAWMIDI\n");
-
-        if (snd_hwports < 1)
-                mcard->num_ports = 1;
-        else if (snd_hwports > 8)
-                mcard->num_ports = 8;
-        else
-                mcard->num_ports = snd_hwports;
+        if (hwports < 1)
+                hwports = 1;
+        else if (hwports > 8)
+                hwports = 8;
+        mcard->num_ports = hwports;
 
         if ((rval = snd_rawmidi_new(mcard->card, "MotuMIDI", 0,
@@ -669 +653 @@
                 return rval;
         rawmidi = mcard->rmidi;
+        rawmidi->private_data = mcard;
 
         list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT].substreams) {
-                substream = list_entry(list, snd_rawmidi_substream_t, list);
+                substream = list_entry(list, struct snd_rawmidi_substream, list);
                 snd_mtpav_set_name(mcard, substream);
                 substream->ops = &snd_mtpav_input;
         }
         list_for_each(list, &rawmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT].substreams) {
-                substream = list_entry(list, snd_rawmidi_substream_t, list);
+                substream = list_entry(list, struct snd_rawmidi_substream, list);
                 snd_mtpav_set_name(mcard, substream);
                 substream->ops = &snd_mtpav_output;
@@ -684 +669 @@
                                SNDRV_RAWMIDI_INFO_DUPLEX;
         sprintf(rawmidi->name, "MTP AV MIDI");
-        //printk("exiting snd_mtpav_get_RAWMIDI() \n");
         return 0;
 }
@@ -691 +675 @@
  */
 
-static mtpav_t *new_mtpav(void)
-{
-        mtpav_t *ncrd = (mtpav_t *) snd_kcalloc(sizeof(mtpav_t), GFP_KERNEL);
-        if (ncrd != NULL) {
-                spin_lock_init(&ncrd->spinlock);
-
-                ncrd->card = NULL;
-                ncrd->irq = -1;
-                ncrd->share_irq = 0;
-
-                ncrd->inmidiport = 0xffffffff;
-                ncrd->inmidistate = 0;
-                ncrd->outmidihwport = 0xffffffff;
-        }
-        return ncrd;
-}
-
-/*
- */
-
-static void free_mtpav(mtpav_t * crd)
-{
+static void snd_mtpav_free(struct snd_card *card)
+{
+        struct mtpav *crd = card->private_data;
         unsigned long flags;
 
@@ -721 +686 @@
         if (crd->irq >= 0)
                 free_irq(crd->irq, (void *)crd);
-        if (crd->res_port)
-                release_resource(crd->res_port);
-        if (crd != NULL)
-                kfree(crd);
-}
-
-/*
- */
-
-static int __init alsa_card_mtpav_init(void)
-{
-        int err = 0;
-        char longname_buffer[80];
-
-        mtp_card = new_mtpav();
-        if (mtp_card == NULL)
+        release_and_free_resource(crd->res_port);
+}
+
+/*
+ */
+static int __devinit snd_mtpav_probe(struct platform_device *dev)
+{
+        struct snd_card *card;
+        int err;
+        struct mtpav *mtp_card;
+
+        card = snd_card_new(index, id, THIS_MODULE, sizeof(*mtp_card));
+        if (! card)
                 return -ENOMEM;
 
-        mtp_card->card = snd_card_new(snd_index, snd_id, THIS_MODULE, 0);
-        if (mtp_card->card == NULL) {
-                free_mtpav(mtp_card);
-                return -ENOMEM;
-        }
+        mtp_card = card->private_data;
+        spin_lock_init(&mtp_card->spinlock);
+        init_timer(&mtp_card->timer);
+        mtp_card->card = card;
+        mtp_card->irq = -1;
+        mtp_card->share_irq = 0;
+        mtp_card->inmidiport = 0xffffffff;
+        mtp_card->inmidistate = 0;
+        mtp_card->outmidihwport = 0xffffffff;
+        init_timer(&mtp_card->timer);
+        mtp_card->timer.function = snd_mtpav_output_timer;
+        mtp_card->timer.data = (unsigned long) mtp_card;
+
+        card->private_free = snd_mtpav_free;
 
         err = snd_mtpav_get_ISA(mtp_card);
-        //printk("snd_mtpav_get_ISA returned: %d\n", err);
         if (err < 0)
                 goto __error;
 
-        strcpy(mtp_card->card->driver, "MTPAV");
-        strcpy(mtp_card->card->shortname, "MTPAV on parallel port");
-        memset(longname_buffer, 0, sizeof(longname_buffer));
-        sprintf(longname_buffer, "MTPAV on parallel port at");
+        strcpy(card->driver, "MTPAV");
+        strcpy(card->shortname, "MTPAV on parallel port");
+        snprintf(card->longname, sizeof(card->longname),
+                 "MTPAV on parallel port at 0x%lx", port);
 
         err = snd_mtpav_get_RAWMIDI(mtp_card);
-        //snd_printk("snd_mtapv_get_RAWMIDI returned: %d\n", err);
         if (err < 0)
                 goto __error;
 
-        err = snd_card_register(mtp_card->card);        // dont snd_card_register until AFTER all cards reources done!
-
-        //printk("snd_card_register returned %d\n", err);
+        snd_mtpav_portscan(mtp_card);
+
+        snd_card_set_dev(card, &dev->dev);
+        err = snd_card_register(mtp_card->card);
         if (err < 0)
                 goto __error;
 
-
-        snd_mtpav_portscan(mtp_card);
-
-        snd_printk("Motu MidiTimePiece on parallel port irq: %d ioport: 0x%lx\n", snd_irq, snd_port);
-
+        platform_set_drvdata(dev, card);
+        printk(KERN_INFO "Motu MidiTimePiece on parallel port irq: %d ioport: 0x%lx\n", irq, port);
         return 0;
 
-      __error:
-        snd_card_free(mtp_card->card);
-        free_mtpav(mtp_card);
+ __error:
+        snd_card_free(card);
         return err;
 }
 
-/*
- */
+static int __devexit snd_mtpav_remove(struct platform_device *devptr)
+{
+        snd_card_free(platform_get_drvdata(devptr));
+        platform_set_drvdata(devptr, NULL);
+        return 0;
+}
+
+#define SND_MTPAV_DRIVER        "snd_mtpav"
+
+static struct platform_driver snd_mtpav_driver = {
+        .probe          = snd_mtpav_probe,
+        .remove         = __devexit_p(snd_mtpav_remove),
+        .driver         = {
+                .name   = SND_MTPAV_DRIVER
+        },
+};
+
+static int __init alsa_card_mtpav_init(void)
+{
+        int err;
+
+        if ((err = platform_driver_register(&snd_mtpav_driver)) < 0)
+                return err;
+
+        device = platform_device_register_simple(SND_MTPAV_DRIVER, -1, NULL, 0);
+        if (!IS_ERR(device)) {
+                if (platform_get_drvdata(device))
+                        return 0;
+                platform_device_unregister(device);
+                err = -ENODEV;
+        } else
+                err = PTR_ERR(device);
+        platform_driver_unregister(&snd_mtpav_driver);
+        return err;
+}
 
 static void __exit alsa_card_mtpav_exit(void)
 {
-        if (mtp_card == NULL)
-                return;
-        if (mtp_card->card)
-                snd_card_free(mtp_card->card);
-        free_mtpav(mtp_card);
-}
-
-/*
- */
+        platform_device_unregister(device);
+        platform_driver_unregister(&snd_mtpav_driver);
+}
 
 module_init(alsa_card_mtpav_init)
 module_exit(alsa_card_mtpav_exit)
-
-#ifndef MODULE
-
-/* format is: snd-card-mtpav=snd_enable,snd_index,snd_id,
-                             snd_port,snd_irq,snd_hwports */
-
-static int __init alsa_card_mtpav_setup(char *str)
-{
-        int __attribute__ ((__unused__)) enable = 1;
-
-        (void)(get_option(&str,&enable) == 2 &&
-               get_option(&str,&snd_index) == 2 &&
-               get_id(&str,&snd_id) == 2 &&
-               get_option(&str,(int *)&snd_port) == 2 &&
-               get_option(&str,&snd_irq) == 2 &&
-               get_option(&str,&snd_hwports) == 2);
-        return 1;
-}
-
-__setup("snd-card-mtpav=", alsa_card_mtpav_setup);
-
-#endif /* ifndef MODULE */