[ALSA] Add HDSP MADI driver
Takashi Iwai [Fri, 3 Jun 2005 09:25:34 +0000 (11:25 +0200)]
HDSPM driver,PCI drivers,RME9652 driver
Added RME Hammerfall DSP MADI driver by Winfried Ritsch.
(Moved from alsa-driver tree to mainline.)

Signed-off-by: Takashi Iwai <tiwai@suse.de>

include/sound/hdspm.h [new file with mode: 0644]
sound/pci/Kconfig
sound/pci/rme9652/Makefile
sound/pci/rme9652/hdspm.c [new file with mode: 0644]

diff --git a/include/sound/hdspm.h b/include/sound/hdspm.h
new file mode 100644 (file)
index 0000000..c34427c
--- /dev/null
@@ -0,0 +1,131 @@
+#ifndef __SOUND_HDSPM_H                /* -*- linux-c -*- */
+#define __SOUND_HDSPM_H
+/*
+ *   Copyright (C) 2003 Winfried Ritsch (IEM)
+ *   based on hdsp.h from Thomas Charbonnel (thomas@undata.org)
+ *                      
+ *    
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   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.
+ */
+
+/* Maximum channels is 64 even on 56Mode you have 64playbacks to matrix */
+#define HDSPM_MAX_CHANNELS      64
+
+/* -------------------- IOCTL Peak/RMS Meters -------------------- */
+
+typedef struct _snd_hdspm_peak_rms hdspm_peak_rms_t;
+
+/* peam rms level structure like we get from hardware 
+  
+   maybe in future we can memory map it so I just copy it
+   to user on ioctl call now an dont change anything
+   rms are made out of low and high values
+   where (long) ????_rms = (????_rms_l >> 8) + ((????_rms_h & 0xFFFFFF00)<<24)
+   (i asume so from the code)
+*/
+
+struct _snd_hdspm_peak_rms {
+
+       unsigned int level_offset[1024];
+
+       unsigned int input_peak[64];
+       unsigned int playback_peak[64];
+       unsigned int output_peak[64];
+       unsigned int xxx_peak[64];      /* not used */
+
+       unsigned int reserved[256];     /* not used */
+
+       unsigned int input_rms_l[64];
+       unsigned int playback_rms_l[64];
+       unsigned int output_rms_l[64];
+       unsigned int xxx_rms_l[64];     /* not used */
+
+       unsigned int input_rms_h[64];
+       unsigned int playback_rms_h[64];
+       unsigned int output_rms_h[64];
+       unsigned int xxx_rms_h[64];     /* not used */
+};
+
+struct sndrv_hdspm_peak_rms_ioctl {
+       hdspm_peak_rms_t *peak;
+};
+
+/* use indirect access due to the limit of ioctl bit size */
+#define SNDRV_HDSPM_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct sndrv_hdspm_peak_rms_ioctl)
+
+/* ------------ CONFIG block IOCTL ---------------------- */
+
+typedef struct _snd_hdspm_config_info hdspm_config_info_t;
+
+struct _snd_hdspm_config_info {
+       unsigned char pref_sync_ref;
+       unsigned char wordclock_sync_check;
+       unsigned char madi_sync_check;
+       unsigned int system_sample_rate;
+       unsigned int autosync_sample_rate;
+       unsigned char system_clock_mode;
+       unsigned char clock_source;
+       unsigned char autosync_ref;
+       unsigned char line_out;
+       unsigned int passthru;
+       unsigned int analog_out;
+};
+
+#define SNDRV_HDSPM_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, hdspm_config_info_t)
+
+
+/* get Soundcard Version */
+
+typedef struct _snd_hdspm_version hdspm_version_t;
+
+struct _snd_hdspm_version {
+       unsigned short firmware_rev;
+};
+
+#define SNDRV_HDSPM_IOCTL_GET_VERSION _IOR('H', 0x43, hdspm_version_t)
+
+
+/* ------------- get Matrix Mixer IOCTL --------------- */
+
+/* MADI mixer: 64inputs+64playback in 64outputs = 8192 => *4Byte = 32768 Bytes */
+
+/* organisation is 64 channelfader in a continous memory block */
+/* equivalent to hardware definition, maybe for future feature of mmap of them */
+/* each of 64 outputs has 64 infader and 64 outfader: 
+   Ins to Outs mixer[out].in[in], Outstreams to Outs mixer[out].pb[pb] */
+
+#define HDSPM_MIXER_CHANNELS HDSPM_MAX_CHANNELS
+
+typedef struct _snd_hdspm_channelfader snd_hdspm_channelfader_t;
+
+struct _snd_hdspm_channelfader {
+       unsigned int in[HDSPM_MIXER_CHANNELS];
+       unsigned int pb[HDSPM_MIXER_CHANNELS];
+};
+
+typedef struct _snd_hdspm_mixer hdspm_mixer_t;
+
+struct _snd_hdspm_mixer {
+       snd_hdspm_channelfader_t ch[HDSPM_MIXER_CHANNELS];
+};
+
+struct sndrv_hdspm_mixer_ioctl {
+       hdspm_mixer_t *mixer;
+};
+
+/* use indirect access due to the limit of ioctl bit size */
+#define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct sndrv_hdspm_mixer_ioctl)
+
+#endif                         /* __SOUND_HDSPM_H */
index 428efdb..6d7a00f 100644 (file)
@@ -274,6 +274,19 @@ config SND_HDSP
          To compile this driver as a module, choose M here: the module
          will be called snd-hdsp.
 
+config SND_HDSPM
+       tristate "RME Hammerfall DSP MADI"
+       depends on SND
+       select SND_HWDEP
+       select SND_RAWMIDI
+       select SND_PCM
+       help
+         Say Y here to include support for RME Hammerfall DSP MADI
+         soundcards.
+
+         To compile this driver as a module, choose M here: the module
+         will be called snd-hdspm.
+
 config SND_TRIDENT
        tristate "Trident 4D-Wave DX/NX; SiS 7018"
        depends on SND
index 917374c..d2c294e 100644 (file)
@@ -5,7 +5,9 @@
 
 snd-rme9652-objs := rme9652.o
 snd-hdsp-objs := hdsp.o
+snd-hdspm-objs := hdspm.o
 
 # Toplevel Module Dependency
 obj-$(CONFIG_SND_RME9652) += snd-rme9652.o
 obj-$(CONFIG_SND_HDSP) += snd-hdsp.o
+obj-$(CONFIG_SND_HDSPM) +=snd-hdspm.o
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
new file mode 100644 (file)
index 0000000..9e86d0e
--- /dev/null
@@ -0,0 +1,3671 @@
+/*   -*- linux-c -*-
+ *
+ *   ALSA driver for RME Hammerfall DSP MADI audio interface(s)
+ *
+ *      Copyright (c) 2003 Winfried Ritsch (IEM)
+ *      code based on hdsp.c   Paul Davis
+ *                             Marcus Andersson
+ *                             Thomas Charbonnel
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */
+#include <sound/driver.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/moduleparam.h>
+#include <linux/slab.h>
+#include <linux/pci.h>
+#include <asm/io.h>
+
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/pcm.h>
+#include <sound/info.h>
+#include <sound/asoundef.h>
+#include <sound/rawmidi.h>
+#include <sound/hwdep.h>
+#include <sound/initval.h>
+
+#include <sound/hdspm.h>
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;       /* Index 0-MAX */
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;        /* ID for this card */
+static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */
+
+/* Disable precise pointer at start */
+static int precise_ptr[SNDRV_CARDS];
+
+/* Send all playback to line outs */
+static int line_outs_monitor[SNDRV_CARDS];
+
+/* Enable Analog Outs on Channel 63/64 by default */
+static int enable_monitor[SNDRV_CARDS];
+
+module_param_array(index, int, NULL, 0444);
+MODULE_PARM_DESC(index, "Index value for RME HDSPM interface.");
+
+module_param_array(id, charp, NULL, 0444);
+MODULE_PARM_DESC(id, "ID string for RME HDSPM interface.");
+
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(enable, "Enable/disable specific HDSPM soundcards.");
+
+module_param_array(precise_ptr, bool, NULL, 0444);
+MODULE_PARM_DESC(precise_ptr, "Enable precise pointer, or disable.");
+
+module_param_array(line_outs_monitor, bool, NULL, 0444);
+MODULE_PARM_DESC(line_outs_monitor,
+                "Send playback streams to analog outs by default.");
+
+module_param_array(enable_monitor, bool, NULL, 0444);
+MODULE_PARM_DESC(enable_monitor,
+                "Enable Analog Out on Channel 63/64 by default.");
+
+MODULE_AUTHOR
+      ("Winfried Ritsch <ritsch_AT_iem.at>, Paul Davis <paul@linuxaudiosystems.com>, "
+       "Marcus Andersson, Thomas Charbonnel <thomas@undata.org>");
+MODULE_DESCRIPTION("RME HDSPM");
+MODULE_LICENSE("GPL");
+MODULE_SUPPORTED_DEVICE("{{RME HDSPM-MADI}}");
+
+/* --- Write registers. --- 
+  These are defined as byte-offsets from the iobase value.  */
+
+#define HDSPM_controlRegister       64
+#define HDSPM_interruptConfirmation  96
+#define HDSPM_control2Reg           256  /* not in specs ???????? */
+#define HDSPM_midiDataOut0          352  /* just believe in old code */
+#define HDSPM_midiDataOut1          356
+
+/* DMA enable for 64 channels, only Bit 0 is relevant */
+#define HDSPM_outputEnableBase       512  /* 512-767  input  DMA */ 
+#define HDSPM_inputEnableBase        768  /* 768-1023 output DMA */
+
+/* 16 page addresses for each of the 64 channels DMA buffer in and out 
+   (each 64k=16*4k) Buffer must be 4k aligned (which is default i386 ????) */
+#define HDSPM_pageAddressBufferOut       8192
+#define HDSPM_pageAddressBufferIn        (HDSPM_pageAddressBufferOut+64*16*4)
+
+#define HDSPM_MADI_mixerBase    32768  /* 32768-65535 for 2x64x64 Fader */
+
+#define HDSPM_MATRIX_MIXER_SIZE  8192  /* = 2*64*64 * 4 Byte => 32kB */
+
+/* --- Read registers. ---
+   These are defined as byte-offsets from the iobase value */
+#define HDSPM_statusRegister    0
+#define HDSPM_statusRegister2  96
+
+#define HDSPM_midiDataIn0     360
+#define HDSPM_midiDataIn1     364
+
+/* status is data bytes in MIDI-FIFO (0-128) */
+#define HDSPM_midiStatusOut0  384      
+#define HDSPM_midiStatusOut1  388      
+#define HDSPM_midiStatusIn0   392      
+#define HDSPM_midiStatusIn1   396      
+
+
+/* the meters are regular i/o-mapped registers, but offset
+   considerably from the rest. the peak registers are reset
+   when read; the least-significant 4 bits are full-scale counters; 
+   the actual peak value is in the most-significant 24 bits.
+*/
+#define HDSPM_MADI_peakrmsbase         4096    /* 4096-8191 2x64x32Bit Meters */
+
+/* --- Control Register bits --------- */
+#define HDSPM_Start                (1<<0) /* start engine */
+
+#define HDSPM_Latency0             (1<<1) /* buffer size = 2^n */
+#define HDSPM_Latency1             (1<<2) /* where n is defined */
+#define HDSPM_Latency2             (1<<3) /* by Latency{2,1,0} */
+
+#define HDSPM_ClockModeMaster      (1<<4) /* 1=Master, 0=Slave/Autosync */
+
+#define HDSPM_AudioInterruptEnable (1<<5) /* what do you think ? */
+
+#define HDSPM_Frequency0  (1<<6)  /* 0=44.1kHz/88.2kHz 1=48kHz/96kHz */
+#define HDSPM_Frequency1  (1<<7)  /* 0=32kHz/64kHz */
+#define HDSPM_DoubleSpeed (1<<8)  /* 0=normal speed, 1=double speed */
+#define HDSPM_QuadSpeed   (1<<31) /* quad speed bit, not implemented now */
+
+#define HDSPM_TX_64ch     (1<<10) /* Output 64channel MODE=1,
+                                    56channelMODE=0 */
+
+#define HDSPM_AutoInp     (1<<11) /* Auto Input (takeover) == Safe Mode, 
+                                     0=off, 1=on  */
+
+#define HDSPM_InputSelect0 (1<<14) /* Input select 0= optical, 1=coax */
+#define HDSPM_InputSelect1 (1<<15) /* should be 0 */
+
+#define HDSPM_SyncRef0     (1<<16) /* 0=WOrd, 1=MADI */
+#define HDSPM_SyncRef1     (1<<17) /* should be 0 */
+
+#define HDSPM_clr_tms      (1<<19) /* clear track marker, do not use 
+                                      AES additional bits in
+                                     lower 5 Audiodatabits ??? */
+
+#define HDSPM_Midi0InterruptEnable (1<<22)
+#define HDSPM_Midi1InterruptEnable (1<<23)
+
+#define HDSPM_LineOut (1<<24) /* Analog Out on channel 63/64 on=1, mute=0 */
+
+
+/* --- bit helper defines */
+#define HDSPM_LatencyMask    (HDSPM_Latency0|HDSPM_Latency1|HDSPM_Latency2)
+#define HDSPM_FrequencyMask  (HDSPM_Frequency0|HDSPM_Frequency1)
+#define HDSPM_InputMask      (HDSPM_InputSelect0|HDSPM_InputSelect1)
+#define HDSPM_InputOptical   0
+#define HDSPM_InputCoaxial   (HDSPM_InputSelect0)
+#define HDSPM_SyncRefMask    (HDSPM_SyncRef0|HDSPM_SyncRef1)
+#define HDSPM_SyncRef_Word   0
+#define HDSPM_SyncRef_MADI   (HDSPM_SyncRef0)
+
+#define HDSPM_SYNC_FROM_WORD 0 /* Preferred sync reference */
+#define HDSPM_SYNC_FROM_MADI 1 /* choices - used by "pref_sync_ref" */
+
+#define HDSPM_Frequency32KHz    HDSPM_Frequency0
+#define HDSPM_Frequency44_1KHz  HDSPM_Frequency1
+#define HDSPM_Frequency48KHz   (HDSPM_Frequency1|HDSPM_Frequency0)
+#define HDSPM_Frequency64KHz   (HDSPM_DoubleSpeed|HDSPM_Frequency0)
+#define HDSPM_Frequency88_2KHz (HDSPM_DoubleSpeed|HDSPM_Frequency1)
+#define HDSPM_Frequency96KHz   (HDSPM_DoubleSpeed|HDSPM_Frequency1|HDSPM_Frequency0)
+
+/* --- for internal discrimination */
+#define HDSPM_CLOCK_SOURCE_AUTOSYNC          0 /* Sample Clock Sources */
+#define HDSPM_CLOCK_SOURCE_INTERNAL_32KHZ    1
+#define HDSPM_CLOCK_SOURCE_INTERNAL_44_1KHZ  2
+#define HDSPM_CLOCK_SOURCE_INTERNAL_48KHZ    3
+#define HDSPM_CLOCK_SOURCE_INTERNAL_64KHZ    4
+#define HDSPM_CLOCK_SOURCE_INTERNAL_88_2KHZ  5
+#define HDSPM_CLOCK_SOURCE_INTERNAL_96KHZ    6
+#define HDSPM_CLOCK_SOURCE_INTERNAL_128KHZ   7
+#define HDSPM_CLOCK_SOURCE_INTERNAL_176_4KHZ 8
+#define HDSPM_CLOCK_SOURCE_INTERNAL_192KHZ   9
+
+/* Synccheck Status */
+#define HDSPM_SYNC_CHECK_NO_LOCK 0
+#define HDSPM_SYNC_CHECK_LOCK    1
+#define HDSPM_SYNC_CHECK_SYNC   2
+
+/* AutoSync References - used by "autosync_ref" control switch */
+#define HDSPM_AUTOSYNC_FROM_WORD      0
+#define HDSPM_AUTOSYNC_FROM_MADI      1
+#define HDSPM_AUTOSYNC_FROM_NONE      2
+
+/* Possible sources of MADI input */
+#define HDSPM_OPTICAL 0                /* optical   */
+#define HDSPM_COAXIAL 1                /* BNC */
+
+#define hdspm_encode_latency(x)       (((x)<<1) & HDSPM_LatencyMask)
+#define hdspm_decode_latency(x)       (((x) & HDSPM_LatencyMask)>>1)
+
+#define hdspm_encode_in(x) (((x)&0x3)<<14)
+#define hdspm_decode_in(x) (((x)>>14)&0x3)
+
+/* --- control2 register bits --- */
+#define HDSPM_TMS             (1<<0)
+#define HDSPM_TCK             (1<<1)
+#define HDSPM_TDI             (1<<2)
+#define HDSPM_JTAG            (1<<3)
+#define HDSPM_PWDN            (1<<4)
+#define HDSPM_PROGRAM        (1<<5)
+#define HDSPM_CONFIG_MODE_0   (1<<6)
+#define HDSPM_CONFIG_MODE_1   (1<<7)
+/*#define HDSPM_VERSION_BIT     (1<<8) not defined any more*/
+#define HDSPM_BIGENDIAN_MODE  (1<<9)
+#define HDSPM_RD_MULTIPLE     (1<<10)
+
+/* --- Status Register bits --- */
+#define HDSPM_audioIRQPending    (1<<0)        /* IRQ is high and pending */
+#define HDSPM_RX_64ch            (1<<1)        /* Input 64chan. MODE=1, 56chn. MODE=0 */
+#define HDSPM_AB_int             (1<<2)        /* InputChannel Opt=0, Coax=1 (like inp0) */
+#define HDSPM_madiLock           (1<<3)        /* MADI Locked =1, no=0 */
+
+#define HDSPM_BufferPositionMask 0x000FFC0 /* Bit 6..15 : h/w buffer pointer */
+                                           /* since 64byte accurate last 6 bits 
+                                              are not used */
+
+#define HDSPM_madiSync          (1<<18) /* MADI is in sync */
+#define HDSPM_DoubleSpeedStatus (1<<19) /* (input) card in double speed */
+
+#define HDSPM_madiFreq0         (1<<22)        /* system freq 0=error */
+#define HDSPM_madiFreq1         (1<<23)        /* 1=32, 2=44.1 3=48 */
+#define HDSPM_madiFreq2         (1<<24)        /* 4=64, 5=88.2 6=96 */
+#define HDSPM_madiFreq3         (1<<25)        /* 7=128, 8=176.4 9=192 */
+
+#define HDSPM_BufferID          (1<<26)        /* (Double)Buffer ID toggles with Interrupt */
+#define HDSPM_midi0IRQPending   (1<<30)        /* MIDI IRQ is pending  */
+#define HDSPM_midi1IRQPending   (1<<31)        /* and aktiv */
+
+/* --- status bit helpers */
+#define HDSPM_madiFreqMask  (HDSPM_madiFreq0|HDSPM_madiFreq1|HDSPM_madiFreq2|HDSPM_madiFreq3)
+#define HDSPM_madiFreq32    (HDSPM_madiFreq0)
+#define HDSPM_madiFreq44_1  (HDSPM_madiFreq1)
+#define HDSPM_madiFreq48    (HDSPM_madiFreq0|HDSPM_madiFreq1)
+#define HDSPM_madiFreq64    (HDSPM_madiFreq2)
+#define HDSPM_madiFreq88_2  (HDSPM_madiFreq0|HDSPM_madiFreq2)
+#define HDSPM_madiFreq96    (HDSPM_madiFreq1|HDSPM_madiFreq2)
+#define HDSPM_madiFreq128   (HDSPM_madiFreq0|HDSPM_madiFreq1|HDSPM_madiFreq2)
+#define HDSPM_madiFreq176_4 (HDSPM_madiFreq3)
+#define HDSPM_madiFreq192   (HDSPM_madiFreq3|HDSPM_madiFreq0)
+
+/* Status2 Register bits */
+
+#define HDSPM_version0 (1<<0)  /* not realy defined but I guess */
+#define HDSPM_version1 (1<<1)  /* in former cards it was ??? */
+#define HDSPM_version2 (1<<2)
+
+#define HDSPM_wcLock (1<<3)    /* Wordclock is detected and locked */
+#define HDSPM_wcSync (1<<4)    /* Wordclock is in sync with systemclock */
+
+#define HDSPM_wc_freq0 (1<<5)  /* input freq detected via autosync  */
+#define HDSPM_wc_freq1 (1<<6)  /* 001=32, 010==44.1, 011=48, */
+#define HDSPM_wc_freq2 (1<<7)  /* 100=64, 101=88.2, 110=96, */
+/* missing Bit   for               111=128, 1000=176.4, 1001=192 */
+
+#define HDSPM_SelSyncRef0 (1<<8)       /* Sync Source in slave mode */
+#define HDSPM_SelSyncRef1 (1<<9)       /* 000=word, 001=MADI, */
+#define HDSPM_SelSyncRef2 (1<<10)      /* 111=no valid signal */
+
+#define HDSPM_wc_valid (HDSPM_wcLock|HDSPM_wcSync)
+
+#define HDSPM_wcFreqMask  (HDSPM_wc_freq0|HDSPM_wc_freq1|HDSPM_wc_freq2)
+#define HDSPM_wcFreq32    (HDSPM_wc_freq0)
+#define HDSPM_wcFreq44_1  (HDSPM_wc_freq1)
+#define HDSPM_wcFreq48    (HDSPM_wc_freq0|HDSPM_wc_freq1)
+#define HDSPM_wcFreq64    (HDSPM_wc_freq2)
+#define HDSPM_wcFreq88_2  (HDSPM_wc_freq0|HDSPM_wc_freq2)
+#define HDSPM_wcFreq96    (HDSPM_wc_freq1|HDSPM_wc_freq2)
+
+
+#define HDSPM_SelSyncRefMask       (HDSPM_SelSyncRef0|HDSPM_SelSyncRef1|HDSPM_SelSyncRef2)
+#define HDSPM_SelSyncRef_WORD      0
+#define HDSPM_SelSyncRef_MADI      (HDSPM_SelSyncRef0)
+#define HDSPM_SelSyncRef_NVALID    (HDSPM_SelSyncRef0|HDSPM_SelSyncRef1|HDSPM_SelSyncRef2)
+
+/* Mixer Values */
+#define UNITY_GAIN          32768      /* = 65536/2 */
+#define MINUS_INFINITY_GAIN 0
+
+/* PCI info */
+#ifndef PCI_VENDOR_ID_XILINX
+#define PCI_VENDOR_ID_XILINX           0x10ee
+#endif
+#ifndef PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP
+#define PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP 0x3fc5
+#endif
+#ifndef PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP_MADI
+#define PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP_MADI 0x3fc6
+#endif
+
+
+/* Number of channels for different Speed Modes */
+#define MADI_SS_CHANNELS       64
+#define MADI_DS_CHANNELS       32
+#define MADI_QS_CHANNELS       16
+
+/* the size of a substream (1 mono data stream) */
+#define HDSPM_CHANNEL_BUFFER_SAMPLES  (16*1024)
+#define HDSPM_CHANNEL_BUFFER_BYTES    (4*HDSPM_CHANNEL_BUFFER_SAMPLES)
+
+/* the size of the area we need to allocate for DMA transfers. the
+   size is the same regardless of the number of channels, and
+   also the latency to use. 
+   for one direction !!!
+*/
+#define HDSPM_DMA_AREA_BYTES (HDSPM_MAX_CHANNELS * HDSPM_CHANNEL_BUFFER_BYTES)
+#define HDSPM_DMA_AREA_KILOBYTES (HDSPM_DMA_AREA_BYTES/1024)
+
+typedef struct _hdspm hdspm_t;
+typedef struct _hdspm_midi hdspm_midi_t;
+
+struct _hdspm_midi {
+       hdspm_t *hdspm;
+       int id;
+       snd_rawmidi_t *rmidi;
+       snd_rawmidi_substream_t *input;
+       snd_rawmidi_substream_t *output;
+       char istimer;           /* timer in use */
+       struct timer_list timer;
+       spinlock_t lock;
+       int pending;
+};
+
+struct _hdspm {
+        spinlock_t lock;
+        snd_pcm_substream_t *capture_substream;         /* only one playback */
+        snd_pcm_substream_t *playback_substream; /* and/or capture stream */
+
+       char *card_name;             /* for procinfo */
+       unsigned short firmware_rev; /* dont know if relevant */
+
+       int precise_ptr;        /* use precise pointers, to be tested */
+       int monitor_outs;       /* set up monitoring outs init flag */
+
+       u32 control_register;   /* cached value */
+       u32 control2_register;  /* cached value */
+
+       hdspm_midi_t midi[2];
+       struct tasklet_struct midi_tasklet;
+
+       size_t period_bytes;
+       unsigned char ss_channels;      /* channels of card in single speed */
+       unsigned char ds_channels;      /* Double Speed */
+       unsigned char qs_channels;      /* Quad Speed */
+
+       unsigned char *playback_buffer; /* suitably aligned address */
+       unsigned char *capture_buffer;  /* suitably aligned address */
+
+       pid_t capture_pid;      /* process id which uses capture */
+       pid_t playback_pid;     /* process id which uses capture */
+       int running;            /* running status */
+
+       int last_external_sample_rate;  /* samplerate mystic ... */
+       int last_internal_sample_rate;
+       int system_sample_rate;
+
+       char *channel_map;      /* channel map for DS and Quadspeed */
+
+       int dev;                /* Hardware vars... */
+       int irq;
+       unsigned long port;
+       void __iomem *iobase;
+
+       int irq_count;          /* for debug */
+
+       snd_card_t *card;       /* one card */
+       snd_pcm_t *pcm;         /* has one pcm */
+       snd_hwdep_t *hwdep;     /* and a hwdep for additional ioctl */
+       struct pci_dev *pci;    /* and an pci info */
+
+       /* Mixer vars */
+       snd_kcontrol_t *playback_mixer_ctls[HDSPM_MAX_CHANNELS];        /* fast alsa mixer */
+       snd_kcontrol_t *input_mixer_ctls[HDSPM_MAX_CHANNELS];   /* but input to much, so not used */
+       hdspm_mixer_t *mixer;   /* full mixer accessable over mixer ioctl or hwdep-device */
+
+};
+
+/* These tables map the ALSA channels 1..N to the channels that we
+   need to use in order to find the relevant channel buffer. RME
+   refer to this kind of mapping as between "the ADAT channel and
+   the DMA channel." We index it using the logical audio channel,
+   and the value is the DMA channel (i.e. channel buffer number)
+   where the data for that channel can be read/written from/to.
+*/
+
+static char channel_map_madi_ss[HDSPM_MAX_CHANNELS] = {
+   0, 1, 2, 3, 4, 5, 6, 7,
+   8, 9, 10, 11, 12, 13, 14, 15,
+   16, 17, 18, 19, 20, 21, 22, 23,
+   24, 25, 26, 27, 28, 29, 30, 31,
+   32, 33, 34, 35, 36, 37, 38, 39,
+   40, 41, 42, 43, 44, 45, 46, 47,
+   48, 49, 50, 51, 52, 53, 54, 55,
+   56, 57, 58, 59, 60, 61, 62, 63
+};
+
+static char channel_map_madi_ds[HDSPM_MAX_CHANNELS] = {
+  0, 2, 4, 6, 8, 10, 12, 14,
+  16, 18, 20, 22, 24, 26, 28, 30,
+  32, 34, 36, 38, 40, 42, 44, 46,
+  48, 50, 52, 54, 56, 58, 60, 62,
+  -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1,
+  -1, -1, -1, -1, -1, -1, -1, -1
+};
+
+static char channel_map_madi_qs[HDSPM_MAX_CHANNELS] = {
+  0,   4,  8, 12, 16, 20, 24,  28,  
+  32, 36, 40, 44, 48, 52, 56,  60
+  -1, -1, -1, -1, -1, -1, -1, -1,  
+  -1, -1, -1, -1, -1, -1, -1, -1,  
+  -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1
+};
+
+
+static struct pci_device_id snd_hdspm_ids[] = {
+       {
+        .vendor = PCI_VENDOR_ID_XILINX,
+        .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP_MADI,
+        .subvendor = PCI_ANY_ID,
+        .subdevice = PCI_ANY_ID,
+        .class = 0,
+        .class_mask = 0,
+        .driver_data = 0},
+       {0,}
+};
+
+MODULE_DEVICE_TABLE(pci, snd_hdspm_ids);
+
+/* prototypes */
+static int __devinit snd_hdspm_create_alsa_devices(snd_card_t * card,
+                                                  hdspm_t * hdspm);
+static int __devinit snd_hdspm_create_pcm(snd_card_t * card,
+                                         hdspm_t * hdspm);
+
+static inline void snd_hdspm_initialize_midi_flush(hdspm_t * hdspm);
+static int hdspm_update_simple_mixer_controls(hdspm_t * hdspm);
+static int hdspm_autosync_ref(hdspm_t * hdspm);
+static int snd_hdspm_set_defaults(hdspm_t * hdspm);
+static void hdspm_set_sgbuf(hdspm_t * hdspm, struct snd_sg_buf *sgbuf,
+                            unsigned int reg, int channels);
+
+/* Write/read to/from HDSPM with Adresses in Bytes
+   not words but only 32Bit writes are allowed */
+
+static inline void hdspm_write(hdspm_t * hdspm, unsigned int reg,
+                              unsigned int val)
+{
+       writel(val, hdspm->iobase + reg);
+}
+
+static inline unsigned int hdspm_read(hdspm_t * hdspm, unsigned int reg)
+{
+       return readl(hdspm->iobase + reg);
+}
+
+/* for each output channel (chan) I have an Input (in) and Playback (pb) Fader 
+   mixer is write only on hardware so we have to cache him for read 
+   each fader is a u32, but uses only the first 16 bit */
+
+static inline int hdspm_read_in_gain(hdspm_t * hdspm, unsigned int chan,
+                                    unsigned int in)
+{
+       if (chan > HDSPM_MIXER_CHANNELS || in > HDSPM_MIXER_CHANNELS)
+               return 0;
+
+       return hdspm->mixer->ch[chan].in[in];
+}
+
+static inline int hdspm_read_pb_gain(hdspm_t * hdspm, unsigned int chan,
+                                    unsigned int pb)
+{
+       if (chan > HDSPM_MIXER_CHANNELS || pb > HDSPM_MIXER_CHANNELS)
+               return 0;
+       return hdspm->mixer->ch[chan].pb[pb];
+}
+
+static inline int hdspm_write_in_gain(hdspm_t * hdspm, unsigned int chan,
+                                     unsigned int in, unsigned short data)
+{
+       if (chan >= HDSPM_MIXER_CHANNELS || in >= HDSPM_MIXER_CHANNELS)
+               return -1;
+
+       hdspm_write(hdspm,
+                   HDSPM_MADI_mixerBase +
+                   ((in + 128 * chan) * sizeof(u32)),
+                   (hdspm->mixer->ch[chan].in[in] = data & 0xFFFF));
+       return 0;
+}
+
+static inline int hdspm_write_pb_gain(hdspm_t * hdspm, unsigned int chan,
+                                     unsigned int pb, unsigned short data)
+{
+       if (chan >= HDSPM_MIXER_CHANNELS || pb >= HDSPM_MIXER_CHANNELS)
+               return -1;
+
+       hdspm_write(hdspm,
+                   HDSPM_MADI_mixerBase +
+                   ((64 + pb + 128 * chan) * sizeof(u32)),
+                   (hdspm->mixer->ch[chan].pb[pb] = data & 0xFFFF));
+       return 0;
+}
+
+
+/* enable DMA for specific channels, now available for DSP-MADI */
+static inline void snd_hdspm_enable_in(hdspm_t * hdspm, int i, int v)
+{
+       hdspm_write(hdspm, HDSPM_inputEnableBase + (4 * i), v);
+}
+
+static inline void snd_hdspm_enable_out(hdspm_t * hdspm, int i, int v)
+{
+       hdspm_write(hdspm, HDSPM_outputEnableBase + (4 * i), v);
+}
+
+/* check if same process is writing and reading */
+static inline int snd_hdspm_use_is_exclusive(hdspm_t * hdspm)
+{
+       unsigned long flags;
+       int ret = 1;
+
+       spin_lock_irqsave(&hdspm->lock, flags);
+       if ((hdspm->playback_pid != hdspm->capture_pid) &&
+           (hdspm->playback_pid >= 0) && (hdspm->capture_pid >= 0)) {
+               ret = 0;
+       }
+       spin_unlock_irqrestore(&hdspm->lock, flags);
+       return ret;
+}
+
+/* check for external sample rate */
+static inline int hdspm_external_sample_rate(hdspm_t * hdspm)
+{
+       unsigned int status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
+       unsigned int status = hdspm_read(hdspm, HDSPM_statusRegister);
+       unsigned int rate_bits;
+       int rate = 0;
+
+       /* if wordclock has synced freq and wordclock is valid */
+       if ((status2 & HDSPM_wcLock) != 0 &&
+           (status & HDSPM_SelSyncRef0) == 0) {
+
+               rate_bits = status2 & HDSPM_wcFreqMask;
+
+               switch (rate_bits) {
+               case HDSPM_wcFreq32:
+                       rate = 32000;
+                       break;
+               case HDSPM_wcFreq44_1:
+                       rate = 44100;
+                       break;
+               case HDSPM_wcFreq48:
+                       rate = 48000;
+                       break;
+               case HDSPM_wcFreq64:
+                       rate = 64000;
+                       break;
+               case HDSPM_wcFreq88_2:
+                       rate = 88200;
+                       break;
+               case HDSPM_wcFreq96:
+                       rate = 96000;
+                       break;
+                       /* Quadspeed Bit missing ???? */
+               default:
+                       rate = 0;
+                       break;
+               }
+       }
+
+       /* if rate detected and Syncref is Word than have it, word has priority to MADI */
+       if (rate != 0
+           && (status2 & HDSPM_SelSyncRefMask) == HDSPM_SelSyncRef_WORD)
+               return rate;
+
+       /* maby a madi input (which is taken if sel sync is madi) */
+       if (status & HDSPM_madiLock) {
+               rate_bits = status & HDSPM_madiFreqMask;
+
+               switch (rate_bits) {
+               case HDSPM_madiFreq32:
+                       rate = 32000;
+                       break;
+               case HDSPM_madiFreq44_1:
+                       rate = 44100;
+                       break;
+               case HDSPM_madiFreq48:
+                       rate = 48000;
+                       break;
+               case HDSPM_madiFreq64:
+                       rate = 64000;
+                       break;
+               case HDSPM_madiFreq88_2:
+                       rate = 88200;
+                       break;
+               case HDSPM_madiFreq96:
+                       rate = 96000;
+                       break;
+               case HDSPM_madiFreq128:
+                       rate = 128000;
+                       break;
+               case HDSPM_madiFreq176_4:
+                       rate = 176400;
+                       break;
+               case HDSPM_madiFreq192:
+                       rate = 192000;
+                       break;
+               default:
+                       rate = 0;
+                       break;
+               }
+       }
+       return rate;
+}
+
+/* Latency function */
+static inline void hdspm_compute_period_size(hdspm_t * hdspm)
+{
+       hdspm->period_bytes =
+           1 << ((hdspm_decode_latency(hdspm->control_register) + 8));
+}
+
+static snd_pcm_uframes_t hdspm_hw_pointer(hdspm_t * hdspm)
+{
+       int position;
+
+       position = hdspm_read(hdspm, HDSPM_statusRegister);
+
+       if (!hdspm->precise_ptr) {
+               return (position & HDSPM_BufferID) ? (hdspm->period_bytes /
+                                                     4) : 0;
+       }
+
+       /* hwpointer comes in bytes and is 64Bytes accurate (by docu since PCI Burst)
+          i have experimented that it is at most 64 Byte to much for playing 
+          so substraction of 64 byte should be ok for ALSA, but use it only
+          for application where you know what you do since if you come to
+          near with record pointer it can be a disaster */
+
+       position &= HDSPM_BufferPositionMask;
+       position = ((position - 64) % (2 * hdspm->period_bytes)) / 4;
+
+       return position;
+}
+
+
+static inline void hdspm_start_audio(hdspm_t * s)
+{
+       s->control_register |= (HDSPM_AudioInterruptEnable | HDSPM_Start);
+       hdspm_write(s, HDSPM_controlRegister, s->control_register);
+}
+
+static inline void hdspm_stop_audio(hdspm_t * s)
+{
+       s->control_register &= ~(HDSPM_Start | HDSPM_AudioInterruptEnable);
+       hdspm_write(s, HDSPM_controlRegister, s->control_register);
+}
+
+/* should I silence all or only opened ones ? doit all for first even is 4MB*/
+static inline void hdspm_silence_playback(hdspm_t * hdspm)
+{
+       int i;
+       int n = hdspm->period_bytes;
+       void *buf = hdspm->playback_buffer;
+
+       snd_assert(buf != NULL, return);
+
+       for (i = 0; i < HDSPM_MAX_CHANNELS; i++) {
+               memset(buf, 0, n);
+               buf += HDSPM_CHANNEL_BUFFER_BYTES;
+       }
+}
+
+static int hdspm_set_interrupt_interval(hdspm_t * s, unsigned int frames)
+{
+       int n;
+
+       spin_lock_irq(&s->lock);
+
+       frames >>= 7;
+       n = 0;
+       while (frames) {
+               n++;
+               frames >>= 1;
+       }
+       s->control_register &= ~HDSPM_LatencyMask;
+       s->control_register |= hdspm_encode_latency(n);
+
+       hdspm_write(s, HDSPM_controlRegister, s->control_register);
+
+       hdspm_compute_period_size(s);
+
+       spin_unlock_irq(&s->lock);
+
+       return 0;
+}
+
+
+/* dummy set rate lets see what happens */
+static int hdspm_set_rate(hdspm_t * hdspm, int rate, int called_internally)
+{
+       int reject_if_open = 0;
+       int current_rate;
+       int rate_bits;
+       int not_set = 0;
+
+       /* ASSUMPTION: hdspm->lock is either set, or there is no need for
+          it (e.g. during module initialization).
+        */
+
+       if (!(hdspm->control_register & HDSPM_ClockModeMaster)) {
+
+               /* SLAVE --- */ 
+               if (called_internally) {
+
+                 /* request from ctl or card initialization 
+                    just make a warning an remember setting 
+                    for future master mode switching */
+    
+                       snd_printk
+                           (KERN_WARNING "HDSPM: Warning: device is not running as a clock master.\n");
+                       not_set = 1;
+               } else {
+
+                       /* hw_param request while in AutoSync mode */
+                       int external_freq =
+                           hdspm_external_sample_rate(hdspm);
+
+                       if ((hdspm_autosync_ref(hdspm) ==
+                            HDSPM_AUTOSYNC_FROM_NONE)) {
+
+                               snd_printk(KERN_WARNING "HDSPM: Detected no Externel Sync \n");
+                               not_set = 1;
+
+                       } else if (rate != external_freq) {
+
+                               snd_printk
+                                   (KERN_WARNING "HDSPM: Warning: No AutoSync source for requested rate\n");
+                               not_set = 1;
+                       }
+               }
+       }
+
+       current_rate = hdspm->system_sample_rate;
+
+       /* Changing between Singe, Double and Quad speed is not
+          allowed if any substreams are open. This is because such a change
+          causes a shift in the location of the DMA buffers and a reduction
+          in the number of available buffers.
+
+          Note that a similar but essentially insoluble problem exists for
+          externally-driven rate changes. All we can do is to flag rate
+          changes in the read/write routines.  
+        */
+
+       switch (rate) {
+       case 32000:
+               if (current_rate > 48000) {
+                       reject_if_open = 1;
+               }
+               rate_bits = HDSPM_Frequency32KHz;
+               break;
+       case 44100:
+               if (current_rate > 48000) {
+                       reject_if_open = 1;
+               }
+               rate_bits = HDSPM_Frequency44_1KHz;
+               break;
+       case 48000:
+               if (current_rate > 48000) {
+                       reject_if_open = 1;
+               }
+               rate_bits = HDSPM_Frequency48KHz;
+               break;
+       case 64000:
+               if (current_rate <= 48000) {
+                       reject_if_open = 1;
+               }
+               rate_bits = HDSPM_Frequency64KHz;
+               break;
+       case 88200:
+               if (current_rate <= 48000) {
+                       reject_if_open = 1;
+               }
+               rate_bits = HDSPM_Frequency88_2KHz;
+               break;
+       case 96000:
+               if (current_rate <= 48000) {
+                       reject_if_open = 1;
+               }
+               rate_bits = HDSPM_Frequency96KHz;
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       if (reject_if_open
+           && (hdspm->capture_pid >= 0 || hdspm->playback_pid >= 0)) {
+               snd_printk
+                   (KERN_ERR "HDSPM: cannot change between single- and double-speed mode (capture PID = %d, playback PID = %d)\n",
+                    hdspm->capture_pid, hdspm->playback_pid);
+               return -EBUSY;
+       }
+
+       hdspm->control_register &= ~HDSPM_FrequencyMask;
+       hdspm->control_register |= rate_bits;
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+
+       if (rate > 64000)
+               hdspm->channel_map = channel_map_madi_qs;
+       else if (rate > 48000)
+               hdspm->channel_map = channel_map_madi_ds;
+       else 
+               hdspm->channel_map = channel_map_madi_ss;
+
+       hdspm->system_sample_rate = rate;
+
+       if (not_set != 0)
+               return -1;
+
+       return 0;
+}
+
+/* mainly for init to 0 on load */
+static void all_in_all_mixer(hdspm_t * hdspm, int sgain)
+{
+       int i, j;
+       unsigned int gain =
+           (sgain > UNITY_GAIN) ? UNITY_GAIN : (sgain < 0) ? 0 : sgain;
+
+       for (i = 0; i < HDSPM_MIXER_CHANNELS; i++)
+               for (j = 0; j < HDSPM_MIXER_CHANNELS; j++) {
+                       hdspm_write_in_gain(hdspm, i, j, gain);
+                       hdspm_write_pb_gain(hdspm, i, j, gain);
+               }
+}
+
+/*----------------------------------------------------------------------------
+   MIDI
+  ----------------------------------------------------------------------------*/
+
+static inline unsigned char snd_hdspm_midi_read_byte (hdspm_t *hdspm, int id)
+{
+       /* the hardware already does the relevant bit-mask with 0xff */
+       if (id)
+               return hdspm_read(hdspm, HDSPM_midiDataIn1);
+       else
+               return hdspm_read(hdspm, HDSPM_midiDataIn0);
+}
+
+static inline void snd_hdspm_midi_write_byte (hdspm_t *hdspm, int id, int val)
+{
+       /* the hardware already does the relevant bit-mask with 0xff */
+       if (id)
+               return hdspm_write(hdspm, HDSPM_midiDataOut1, val);
+       else
+               return hdspm_write(hdspm, HDSPM_midiDataOut0, val);
+}
+
+static inline int snd_hdspm_midi_input_available (hdspm_t *hdspm, int id)
+{
+       if (id)
+               return (hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xff);
+       else
+               return (hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xff);
+}
+
+static inline int snd_hdspm_midi_output_possible (hdspm_t *hdspm, int id)
+{
+       int fifo_bytes_used;
+
+       if (id)
+               fifo_bytes_used = hdspm_read(hdspm, HDSPM_midiStatusOut1) & 0xff;
+       else
+               fifo_bytes_used = hdspm_read(hdspm, HDSPM_midiStatusOut0) & 0xff;
+
+       if (fifo_bytes_used < 128)
+               return  128 - fifo_bytes_used;
+       else
+               return 0;
+}
+
+static inline void snd_hdspm_flush_midi_input (hdspm_t *hdspm, int id)
+{
+       while (snd_hdspm_midi_input_available (hdspm, id))
+               snd_hdspm_midi_read_byte (hdspm, id);
+}
+
+static int snd_hdspm_midi_output_write (hdspm_midi_t *hmidi)
+{
+       unsigned long flags;
+       int n_pending;
+       int to_write;
+       int i;
+       unsigned char buf[128];
+
+       /* Output is not interrupt driven */
+               
+       spin_lock_irqsave (&hmidi->lock, flags);
+       if (hmidi->output) {
+               if (!snd_rawmidi_transmit_empty (hmidi->output)) {
+                       if ((n_pending = snd_hdspm_midi_output_possible (hmidi->hdspm, hmidi->id)) > 0) {
+                               if (n_pending > (int)sizeof (buf))
+                                       n_pending = sizeof (buf);
+                               
+                               if ((to_write = snd_rawmidi_transmit (hmidi->output, buf, n_pending)) > 0) {
+                                       for (i = 0; i < to_write; ++i) 
+                                               snd_hdspm_midi_write_byte (hmidi->hdspm, hmidi->id, buf[i]);
+                               }
+                       }
+               }
+       }
+       spin_unlock_irqrestore (&hmidi->lock, flags);
+       return 0;
+}
+
+static int snd_hdspm_midi_input_read (hdspm_midi_t *hmidi)
+{
+       unsigned char buf[128]; /* this buffer is designed to match the MIDI input FIFO size */
+       unsigned long flags;
+       int n_pending;
+       int i;
+
+       spin_lock_irqsave (&hmidi->lock, flags);
+       if ((n_pending = snd_hdspm_midi_input_available (hmidi->hdspm, hmidi->id)) > 0) {
+               if (hmidi->input) {
+                       if (n_pending > (int)sizeof (buf)) {
+                               n_pending = sizeof (buf);
+                       }
+                       for (i = 0; i < n_pending; ++i) {
+                               buf[i] = snd_hdspm_midi_read_byte (hmidi->hdspm, hmidi->id);
+                       }
+                       if (n_pending) {
+                               snd_rawmidi_receive (hmidi->input, buf, n_pending);
+                       }
+               } else {
+                       /* flush the MIDI input FIFO */
+                       while (n_pending--) {
+                               snd_hdspm_midi_read_byte (hmidi->hdspm, hmidi->id);
+                       }
+               }
+       }
+       hmidi->pending = 0;
+       if (hmidi->id) {
+               hmidi->hdspm->control_register |= HDSPM_Midi1InterruptEnable;
+       } else {
+               hmidi->hdspm->control_register |= HDSPM_Midi0InterruptEnable;
+       }
+       hdspm_write(hmidi->hdspm, HDSPM_controlRegister, hmidi->hdspm->control_register);
+       spin_unlock_irqrestore (&hmidi->lock, flags);
+       return snd_hdspm_midi_output_write (hmidi);
+}
+
+static void snd_hdspm_midi_input_trigger(snd_rawmidi_substream_t * substream, int up)
+{
+       hdspm_t *hdspm;
+       hdspm_midi_t *hmidi;
+       unsigned long flags;
+       u32 ie;
+
+       hmidi = (hdspm_midi_t *) substream->rmidi->private_data;
+       hdspm = hmidi->hdspm;
+       ie = hmidi->id ? HDSPM_Midi1InterruptEnable : HDSPM_Midi0InterruptEnable;
+       spin_lock_irqsave (&hdspm->lock, flags);
+       if (up) {
+               if (!(hdspm->control_register & ie)) {
+                       snd_hdspm_flush_midi_input (hdspm, hmidi->id);
+                       hdspm->control_register |= ie;
+               }
+       } else {
+               hdspm->control_register &= ~ie;
+       }
+
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+       spin_unlock_irqrestore (&hdspm->lock, flags);
+}
+
+static void snd_hdspm_midi_output_timer(unsigned long data)
+{
+       hdspm_midi_t *hmidi = (hdspm_midi_t *) data;
+       unsigned long flags;
+       
+       snd_hdspm_midi_output_write(hmidi);
+       spin_lock_irqsave (&hmidi->lock, flags);
+
+       /* this does not bump hmidi->istimer, because the
+          kernel automatically removed the timer when it
+          expired, and we are now adding it back, thus
+          leaving istimer wherever it was set before.  
+       */
+
+       if (hmidi->istimer) {
+               hmidi->timer.expires = 1 + jiffies;
+               add_timer(&hmidi->timer);
+       }
+
+       spin_unlock_irqrestore (&hmidi->lock, flags);
+}
+
+static void snd_hdspm_midi_output_trigger(snd_rawmidi_substream_t * substream, int up)
+{
+       hdspm_midi_t *hmidi;
+       unsigned long flags;
+
+       hmidi = (hdspm_midi_t *) substream->rmidi->private_data;
+       spin_lock_irqsave (&hmidi->lock, flags);
+       if (up) {
+               if (!hmidi->istimer) {
+                       init_timer(&hmidi->timer);
+                       hmidi->timer.function = snd_hdspm_midi_output_timer;
+                       hmidi->timer.data = (unsigned long) hmidi;
+                       hmidi->timer.expires = 1 + jiffies;
+                       add_timer(&hmidi->timer);
+                       hmidi->istimer++;
+               }
+       } else {
+               if (hmidi->istimer && --hmidi->istimer <= 0) {
+                       del_timer (&hmidi->timer);
+               }
+       }
+       spin_unlock_irqrestore (&hmidi->lock, flags);
+       if (up)
+               snd_hdspm_midi_output_write(hmidi);
+}
+
+static int snd_hdspm_midi_input_open(snd_rawmidi_substream_t * substream)
+{
+       hdspm_midi_t *hmidi;
+
+       hmidi = (hdspm_midi_t *) substream->rmidi->private_data;
+       spin_lock_irq (&hmidi->lock);
+       snd_hdspm_flush_midi_input (hmidi->hdspm, hmidi->id);
+       hmidi->input = substream;
+       spin_unlock_irq (&hmidi->lock);
+
+       return 0;
+}
+
+static int snd_hdspm_midi_output_open(snd_rawmidi_substream_t * substream)
+{
+       hdspm_midi_t *hmidi;
+
+       hmidi = (hdspm_midi_t *) substream->rmidi->private_data;
+       spin_lock_irq (&hmidi->lock);
+       hmidi->output = substream;
+       spin_unlock_irq (&hmidi->lock);
+
+       return 0;
+}
+
+static int snd_hdspm_midi_input_close(snd_rawmidi_substream_t * substream)
+{
+       hdspm_midi_t *hmidi;
+
+       snd_hdspm_midi_input_trigger (substream, 0);
+
+       hmidi = (hdspm_midi_t *) substream->rmidi->private_data;
+       spin_lock_irq (&hmidi->lock);
+       hmidi->input = NULL;
+       spin_unlock_irq (&hmidi->lock);
+
+       return 0;
+}
+
+static int snd_hdspm_midi_output_close(snd_rawmidi_substream_t * substream)
+{
+       hdspm_midi_t *hmidi;
+
+       snd_hdspm_midi_output_trigger (substream, 0);
+
+       hmidi = (hdspm_midi_t *) substream->rmidi->private_data;
+       spin_lock_irq (&hmidi->lock);
+       hmidi->output = NULL;
+       spin_unlock_irq (&hmidi->lock);
+
+       return 0;
+}
+
+snd_rawmidi_ops_t snd_hdspm_midi_output =
+{
+       .open =         snd_hdspm_midi_output_open,
+       .close =        snd_hdspm_midi_output_close,
+       .trigger =      snd_hdspm_midi_output_trigger,
+};
+
+snd_rawmidi_ops_t snd_hdspm_midi_input =
+{
+       .open =         snd_hdspm_midi_input_open,
+       .close =        snd_hdspm_midi_input_close,
+       .trigger =      snd_hdspm_midi_input_trigger,
+};
+
+static int __devinit snd_hdspm_create_midi (snd_card_t *card, hdspm_t *hdspm, int id)
+{
+       int err;
+       char buf[32];
+
+       hdspm->midi[id].id = id;
+       hdspm->midi[id].rmidi = NULL;
+       hdspm->midi[id].input = NULL;
+       hdspm->midi[id].output = NULL;
+       hdspm->midi[id].hdspm = hdspm;
+       hdspm->midi[id].istimer = 0;
+       hdspm->midi[id].pending = 0;
+       spin_lock_init (&hdspm->midi[id].lock);
+
+       sprintf (buf, "%s MIDI %d", card->shortname, id+1);
+       if ((err = snd_rawmidi_new (card, buf, id, 1, 1, &hdspm->midi[id].rmidi)) < 0)
+               return err;
+
+       sprintf (hdspm->midi[id].rmidi->name, "%s MIDI %d", card->id, id+1);
+       hdspm->midi[id].rmidi->private_data = &hdspm->midi[id];
+
+       snd_rawmidi_set_ops (hdspm->midi[id].rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_hdspm_midi_output);
+       snd_rawmidi_set_ops (hdspm->midi[id].rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_hdspm_midi_input);
+
+       hdspm->midi[id].rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT |
+               SNDRV_RAWMIDI_INFO_INPUT |
+               SNDRV_RAWMIDI_INFO_DUPLEX;
+
+       return 0;
+}
+
+
+static void hdspm_midi_tasklet(unsigned long arg)
+{
+       hdspm_t *hdspm = (hdspm_t *)arg;
+       
+       if (hdspm->midi[0].pending)
+               snd_hdspm_midi_input_read (&hdspm->midi[0]);
+       if (hdspm->midi[1].pending)
+               snd_hdspm_midi_input_read (&hdspm->midi[1]);
+} 
+
+
+/*-----------------------------------------------------------------------------
+  Status Interface
+  ----------------------------------------------------------------------------*/
+
+/* get the system sample rate which is set */
+
+#define HDSPM_SYSTEM_SAMPLE_RATE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdspm_info_system_sample_rate, \
+  .get = snd_hdspm_get_system_sample_rate \
+}
+
+static int snd_hdspm_info_system_sample_rate(snd_kcontrol_t * kcontrol,
+                                            snd_ctl_elem_info_t * uinfo)
+{
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+       uinfo->count = 1;
+       return 0;
+}
+
+static int snd_hdspm_get_system_sample_rate(snd_kcontrol_t * kcontrol,
+                                           snd_ctl_elem_value_t *
+                                           ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       ucontrol->value.enumerated.item[0] = hdspm->system_sample_rate;
+       return 0;
+}
+
+#define HDSPM_AUTOSYNC_SAMPLE_RATE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdspm_info_autosync_sample_rate, \
+  .get = snd_hdspm_get_autosync_sample_rate \
+}
+
+static int snd_hdspm_info_autosync_sample_rate(snd_kcontrol_t * kcontrol,
+                                              snd_ctl_elem_info_t * uinfo)
+{
+       static char *texts[] = { "32000", "44100", "48000",
+               "64000", "88200", "96000",
+               "128000", "176400", "192000",
+               "None"
+       };
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+       uinfo->count = 1;
+       uinfo->value.enumerated.items = 10;
+       if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+               uinfo->value.enumerated.item =
+                   uinfo->value.enumerated.items - 1;
+       strcpy(uinfo->value.enumerated.name,
+              texts[uinfo->value.enumerated.item]);
+       return 0;
+}
+
+static int snd_hdspm_get_autosync_sample_rate(snd_kcontrol_t * kcontrol,
+                                             snd_ctl_elem_value_t *
+                                             ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       switch (hdspm_external_sample_rate(hdspm)) {
+       case 32000:
+               ucontrol->value.enumerated.item[0] = 0;
+               break;
+       case 44100:
+               ucontrol->value.enumerated.item[0] = 1;
+               break;
+       case 48000:
+               ucontrol->value.enumerated.item[0] = 2;
+               break;
+       case 64000:
+               ucontrol->value.enumerated.item[0] = 3;
+               break;
+       case 88200:
+               ucontrol->value.enumerated.item[0] = 4;
+               break;
+       case 96000:
+               ucontrol->value.enumerated.item[0] = 5;
+               break;
+       case 128000:
+               ucontrol->value.enumerated.item[0] = 6;
+               break;
+       case 176400:
+               ucontrol->value.enumerated.item[0] = 7;
+               break;
+       case 192000:
+               ucontrol->value.enumerated.item[0] = 8;
+               break;
+
+       default:
+               ucontrol->value.enumerated.item[0] = 9;
+       }
+       return 0;
+}
+
+#define HDSPM_SYSTEM_CLOCK_MODE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdspm_info_system_clock_mode, \
+  .get = snd_hdspm_get_system_clock_mode, \
+}
+
+
+
+static int hdspm_system_clock_mode(hdspm_t * hdspm)
+{
+        /* Always reflect the hardware info, rme is never wrong !!!! */
+
+       if (hdspm->control_register & HDSPM_ClockModeMaster)
+               return 0;
+       return 1;
+}
+
+static int snd_hdspm_info_system_clock_mode(snd_kcontrol_t * kcontrol,
+                                           snd_ctl_elem_info_t * uinfo)
+{
+       static char *texts[] = { "Master", "Slave" };
+
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+       uinfo->count = 1;
+       uinfo->value.enumerated.items = 2;
+       if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+               uinfo->value.enumerated.item =
+                   uinfo->value.enumerated.items - 1;
+       strcpy(uinfo->value.enumerated.name,
+              texts[uinfo->value.enumerated.item]);
+       return 0;
+}
+
+static int snd_hdspm_get_system_clock_mode(snd_kcontrol_t * kcontrol,
+                                          snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       ucontrol->value.enumerated.item[0] =
+           hdspm_system_clock_mode(hdspm);
+       return 0;
+}
+
+#define HDSPM_CLOCK_SOURCE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdspm_info_clock_source, \
+  .get = snd_hdspm_get_clock_source, \
+  .put = snd_hdspm_put_clock_source \
+}
+
+static int hdspm_clock_source(hdspm_t * hdspm)
+{
+       if (hdspm->control_register & HDSPM_ClockModeMaster) {
+               switch (hdspm->system_sample_rate) {
+               case 32000:
+                       return 1;
+               case 44100:
+                       return 2;
+               case 48000:
+                       return 3;
+               case 64000:
+                       return 4;
+               case 88200:
+                       return 5;
+               case 96000:
+                       return 6;
+               case 128000:
+                       return 7;
+               case 176400:
+                       return 8;
+               case 192000:
+                       return 9;
+               default:
+                       return 3;
+               }
+       } else {
+               return 0;
+       }
+}
+
+static int hdspm_set_clock_source(hdspm_t * hdspm, int mode)
+{
+       int rate;
+       switch (mode) {
+
+       case HDSPM_CLOCK_SOURCE_AUTOSYNC:
+               if (hdspm_external_sample_rate(hdspm) != 0) {
+                       hdspm->control_register &= ~HDSPM_ClockModeMaster;
+                       hdspm_write(hdspm, HDSPM_controlRegister,
+                                   hdspm->control_register);
+                       return 0;
+               }
+               return -1;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_32KHZ:
+               rate = 32000;
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_44_1KHZ:
+               rate = 44100;
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_48KHZ:
+               rate = 48000;
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_64KHZ:
+               rate = 64000;
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_88_2KHZ:
+               rate = 88200;
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_96KHZ:
+               rate = 96000;
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_128KHZ:
+               rate = 128000;
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_176_4KHZ:
+               rate = 176400;
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_192KHZ:
+               rate = 192000;
+               break;
+
+       default:
+               rate = 44100;
+       }
+       hdspm->control_register |= HDSPM_ClockModeMaster;
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+       hdspm_set_rate(hdspm, rate, 1);
+       return 0;
+}
+
+static int snd_hdspm_info_clock_source(snd_kcontrol_t * kcontrol,
+                                      snd_ctl_elem_info_t * uinfo)
+{
+       static char *texts[] = { "AutoSync",
+               "Internal 32.0 kHz", "Internal 44.1 kHz",
+                   "Internal 48.0 kHz",
+               "Internal 64.0 kHz", "Internal 88.2 kHz",
+                   "Internal 96.0 kHz",
+               "Internal 128.0 kHz", "Internal 176.4 kHz",
+                   "Internal 192.0 kHz"
+       };
+
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+       uinfo->count = 1;
+       uinfo->value.enumerated.items = 10;
+
+       if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+               uinfo->value.enumerated.item =
+                   uinfo->value.enumerated.items - 1;
+
+       strcpy(uinfo->value.enumerated.name,
+              texts[uinfo->value.enumerated.item]);
+
+       return 0;
+}
+
+static int snd_hdspm_get_clock_source(snd_kcontrol_t * kcontrol,
+                                     snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       ucontrol->value.enumerated.item[0] = hdspm_clock_source(hdspm);
+       return 0;
+}
+
+static int snd_hdspm_put_clock_source(snd_kcontrol_t * kcontrol,
+                                     snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int change;
+       int val;
+
+       if (!snd_hdspm_use_is_exclusive(hdspm))
+               return -EBUSY;
+       val = ucontrol->value.enumerated.item[0];
+       if (val < 0)
+               val = 0;
+       if (val > 6)
+               val = 6;
+       spin_lock_irq(&hdspm->lock);
+       if (val != hdspm_clock_source(hdspm))
+               change = (hdspm_set_clock_source(hdspm, val) == 0) ? 1 : 0;
+       else
+               change = 0;
+       spin_unlock_irq(&hdspm->lock);
+       return change;
+}
+
+#define HDSPM_PREF_SYNC_REF(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdspm_info_pref_sync_ref, \
+  .get = snd_hdspm_get_pref_sync_ref, \
+  .put = snd_hdspm_put_pref_sync_ref \
+}
+
+static int hdspm_pref_sync_ref(hdspm_t * hdspm)
+{
+       /* Notice that this looks at the requested sync source,
+          not the one actually in use.
+        */
+       switch (hdspm->control_register & HDSPM_SyncRefMask) {
+       case HDSPM_SyncRef_Word:
+               return HDSPM_SYNC_FROM_WORD;
+       case HDSPM_SyncRef_MADI:
+               return HDSPM_SYNC_FROM_MADI;
+       }
+
+       return HDSPM_SYNC_FROM_WORD;
+}
+
+static int hdspm_set_pref_sync_ref(hdspm_t * hdspm, int pref)
+{
+       hdspm->control_register &= ~HDSPM_SyncRefMask;
+
+       switch (pref) {
+       case HDSPM_SYNC_FROM_MADI:
+               hdspm->control_register |= HDSPM_SyncRef_MADI;
+               break;
+       case HDSPM_SYNC_FROM_WORD:
+               hdspm->control_register |= HDSPM_SyncRef_Word;
+               break;
+       default:
+               return -1;
+       }
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+       return 0;
+}
+
+static int snd_hdspm_info_pref_sync_ref(snd_kcontrol_t * kcontrol,
+                                       snd_ctl_elem_info_t * uinfo)
+{
+       static char *texts[] = { "Word", "MADI" };
+
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+       uinfo->count = 1;
+
+       uinfo->value.enumerated.items = 2;
+
+       if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+               uinfo->value.enumerated.item =
+                   uinfo->value.enumerated.items - 1;
+       strcpy(uinfo->value.enumerated.name,
+              texts[uinfo->value.enumerated.item]);
+       return 0;
+}
+
+static int snd_hdspm_get_pref_sync_ref(snd_kcontrol_t * kcontrol,
+                                      snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       ucontrol->value.enumerated.item[0] = hdspm_pref_sync_ref(hdspm);
+       return 0;
+}
+
+static int snd_hdspm_put_pref_sync_ref(snd_kcontrol_t * kcontrol,
+                                      snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int change, max;
+       unsigned int val;
+
+       max = 2;
+
+       if (!snd_hdspm_use_is_exclusive(hdspm))
+               return -EBUSY;
+
+       val = ucontrol->value.enumerated.item[0] % max;
+
+       spin_lock_irq(&hdspm->lock);
+       change = (int) val != hdspm_pref_sync_ref(hdspm);
+       hdspm_set_pref_sync_ref(hdspm, val);
+       spin_unlock_irq(&hdspm->lock);
+       return change;
+}
+
+#define HDSPM_AUTOSYNC_REF(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdspm_info_autosync_ref, \
+  .get = snd_hdspm_get_autosync_ref, \
+}
+
+static int hdspm_autosync_ref(hdspm_t * hdspm)
+{
+       /* This looks at the autosync selected sync reference */
+       unsigned int status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
+
+       switch (status2 & HDSPM_SelSyncRefMask) {
+
+       case HDSPM_SelSyncRef_WORD:
+               return HDSPM_AUTOSYNC_FROM_WORD;
+
+       case HDSPM_SelSyncRef_MADI:
+               return HDSPM_AUTOSYNC_FROM_MADI;
+
+       case HDSPM_SelSyncRef_NVALID:
+               return HDSPM_AUTOSYNC_FROM_NONE;
+
+       default:
+               return 0;
+       }
+
+       return 0;
+}
+
+static int snd_hdspm_info_autosync_ref(snd_kcontrol_t * kcontrol,
+                                      snd_ctl_elem_info_t * uinfo)
+{
+       static char *texts[] = { "WordClock", "MADI", "None" };
+
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+       uinfo->count = 1;
+       uinfo->value.enumerated.items = 3;
+       if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+               uinfo->value.enumerated.item =
+                   uinfo->value.enumerated.items - 1;
+       strcpy(uinfo->value.enumerated.name,
+              texts[uinfo->value.enumerated.item]);
+       return 0;
+}
+
+static int snd_hdspm_get_autosync_ref(snd_kcontrol_t * kcontrol,
+                                     snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       ucontrol->value.enumerated.item[0] = hdspm_pref_sync_ref(hdspm);
+       return 0;
+}
+
+#define HDSPM_LINE_OUT(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdspm_info_line_out, \
+  .get = snd_hdspm_get_line_out, \
+  .put = snd_hdspm_put_line_out \
+}
+
+static int hdspm_line_out(hdspm_t * hdspm)
+{
+       return (hdspm->control_register & HDSPM_LineOut) ? 1 : 0;
+}
+
+
+static int hdspm_set_line_output(hdspm_t * hdspm, int out)
+{
+       if (out)
+               hdspm->control_register |= HDSPM_LineOut;
+       else
+               hdspm->control_register &= ~HDSPM_LineOut;
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+
+       return 0;
+}
+
+static int snd_hdspm_info_line_out(snd_kcontrol_t * kcontrol,
+                                  snd_ctl_elem_info_t * uinfo)
+{
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+       uinfo->count = 1;
+       uinfo->value.integer.min = 0;
+       uinfo->value.integer.max = 1;
+       return 0;
+}
+
+static int snd_hdspm_get_line_out(snd_kcontrol_t * kcontrol,
+                                 snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       spin_lock_irq(&hdspm->lock);
+       ucontrol->value.integer.value[0] = hdspm_line_out(hdspm);
+       spin_unlock_irq(&hdspm->lock);
+       return 0;
+}
+
+static int snd_hdspm_put_line_out(snd_kcontrol_t * kcontrol,
+                                 snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int change;
+       unsigned int val;
+
+       if (!snd_hdspm_use_is_exclusive(hdspm))
+               return -EBUSY;
+       val = ucontrol->value.integer.value[0] & 1;
+       spin_lock_irq(&hdspm->lock);
+       change = (int) val != hdspm_line_out(hdspm);
+       hdspm_set_line_output(hdspm, val);
+       spin_unlock_irq(&hdspm->lock);
+       return change;
+}
+
+#define HDSPM_TX_64(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdspm_info_tx_64, \
+  .get = snd_hdspm_get_tx_64, \
+  .put = snd_hdspm_put_tx_64 \
+}
+
+static int hdspm_tx_64(hdspm_t * hdspm)
+{
+       return (hdspm->control_register & HDSPM_TX_64ch) ? 1 : 0;
+}
+
+static int hdspm_set_tx_64(hdspm_t * hdspm, int out)
+{
+       if (out)
+               hdspm->control_register |= HDSPM_TX_64ch;
+       else
+               hdspm->control_register &= ~HDSPM_TX_64ch;
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+
+       return 0;
+}
+
+static int snd_hdspm_info_tx_64(snd_kcontrol_t * kcontrol,
+                               snd_ctl_elem_info_t * uinfo)
+{
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+       uinfo->count = 1;
+       uinfo->value.integer.min = 0;
+       uinfo->value.integer.max = 1;
+       return 0;
+}
+
+static int snd_hdspm_get_tx_64(snd_kcontrol_t * kcontrol,
+                              snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       spin_lock_irq(&hdspm->lock);
+       ucontrol->value.integer.value[0] = hdspm_tx_64(hdspm);
+       spin_unlock_irq(&hdspm->lock);
+       return 0;
+}
+
+static int snd_hdspm_put_tx_64(snd_kcontrol_t * kcontrol,
+                              snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int change;
+       unsigned int val;
+
+       if (!snd_hdspm_use_is_exclusive(hdspm))
+               return -EBUSY;
+       val = ucontrol->value.integer.value[0] & 1;
+       spin_lock_irq(&hdspm->lock);
+       change = (int) val != hdspm_tx_64(hdspm);
+       hdspm_set_tx_64(hdspm, val);
+       spin_unlock_irq(&hdspm->lock);
+       return change;
+}
+
+#define HDSPM_C_TMS(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdspm_info_c_tms, \
+  .get = snd_hdspm_get_c_tms, \
+  .put = snd_hdspm_put_c_tms \
+}
+
+static int hdspm_c_tms(hdspm_t * hdspm)
+{
+       return (hdspm->control_register & HDSPM_clr_tms) ? 1 : 0;
+}
+
+static int hdspm_set_c_tms(hdspm_t * hdspm, int out)
+{
+       if (out)
+               hdspm->control_register |= HDSPM_clr_tms;
+       else
+               hdspm->control_register &= ~HDSPM_clr_tms;
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+
+       return 0;
+}
+
+static int snd_hdspm_info_c_tms(snd_kcontrol_t * kcontrol,
+                               snd_ctl_elem_info_t * uinfo)
+{
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+       uinfo->count = 1;
+       uinfo->value.integer.min = 0;
+       uinfo->value.integer.max = 1;
+       return 0;
+}
+
+static int snd_hdspm_get_c_tms(snd_kcontrol_t * kcontrol,
+                              snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       spin_lock_irq(&hdspm->lock);
+       ucontrol->value.integer.value[0] = hdspm_c_tms(hdspm);
+       spin_unlock_irq(&hdspm->lock);
+       return 0;
+}
+
+static int snd_hdspm_put_c_tms(snd_kcontrol_t * kcontrol,
+                              snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int change;
+       unsigned int val;
+
+       if (!snd_hdspm_use_is_exclusive(hdspm))
+               return -EBUSY;
+       val = ucontrol->value.integer.value[0] & 1;
+       spin_lock_irq(&hdspm->lock);
+       change = (int) val != hdspm_c_tms(hdspm);
+       hdspm_set_c_tms(hdspm, val);
+       spin_unlock_irq(&hdspm->lock);
+       return change;
+}
+
+#define HDSPM_SAFE_MODE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdspm_info_safe_mode, \
+  .get = snd_hdspm_get_safe_mode, \
+  .put = snd_hdspm_put_safe_mode \
+}
+
+static int hdspm_safe_mode(hdspm_t * hdspm)
+{
+       return (hdspm->control_register & HDSPM_AutoInp) ? 1 : 0;
+}
+
+static int hdspm_set_safe_mode(hdspm_t * hdspm, int out)
+{
+       if (out)
+               hdspm->control_register |= HDSPM_AutoInp;
+       else
+               hdspm->control_register &= ~HDSPM_AutoInp;
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+
+       return 0;
+}
+
+static int snd_hdspm_info_safe_mode(snd_kcontrol_t * kcontrol,
+                                   snd_ctl_elem_info_t * uinfo)
+{
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+       uinfo->count = 1;
+       uinfo->value.integer.min = 0;
+       uinfo->value.integer.max = 1;
+       return 0;
+}
+
+static int snd_hdspm_get_safe_mode(snd_kcontrol_t * kcontrol,
+                                  snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       spin_lock_irq(&hdspm->lock);
+       ucontrol->value.integer.value[0] = hdspm_safe_mode(hdspm);
+       spin_unlock_irq(&hdspm->lock);
+       return 0;
+}
+
+static int snd_hdspm_put_safe_mode(snd_kcontrol_t * kcontrol,
+                                  snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int change;
+       unsigned int val;
+
+       if (!snd_hdspm_use_is_exclusive(hdspm))
+               return -EBUSY;
+       val = ucontrol->value.integer.value[0] & 1;
+       spin_lock_irq(&hdspm->lock);
+       change = (int) val != hdspm_safe_mode(hdspm);
+       hdspm_set_safe_mode(hdspm, val);
+       spin_unlock_irq(&hdspm->lock);
+       return change;
+}
+
+#define HDSPM_INPUT_SELECT(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdspm_info_input_select, \
+  .get = snd_hdspm_get_input_select, \
+  .put = snd_hdspm_put_input_select \
+}
+
+static int hdspm_input_select(hdspm_t * hdspm)
+{
+       return (hdspm->control_register & HDSPM_InputSelect0) ? 1 : 0;
+}
+
+static int hdspm_set_input_select(hdspm_t * hdspm, int out)
+{
+       if (out)
+               hdspm->control_register |= HDSPM_InputSelect0;
+       else
+               hdspm->control_register &= ~HDSPM_InputSelect0;
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+
+       return 0;
+}
+
+static int snd_hdspm_info_input_select(snd_kcontrol_t * kcontrol,
+                                      snd_ctl_elem_info_t * uinfo)
+{
+       static char *texts[] = { "optical", "coaxial" };
+
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+       uinfo->count = 1;
+       uinfo->value.enumerated.items = 2;
+
+       if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+               uinfo->value.enumerated.item =
+                   uinfo->value.enumerated.items - 1;
+       strcpy(uinfo->value.enumerated.name,
+              texts[uinfo->value.enumerated.item]);
+
+       return 0;
+}
+
+static int snd_hdspm_get_input_select(snd_kcontrol_t * kcontrol,
+                                     snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       spin_lock_irq(&hdspm->lock);
+       ucontrol->value.enumerated.item[0] = hdspm_input_select(hdspm);
+       spin_unlock_irq(&hdspm->lock);
+       return 0;
+}
+
+static int snd_hdspm_put_input_select(snd_kcontrol_t * kcontrol,
+                                     snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int change;
+       unsigned int val;
+
+       if (!snd_hdspm_use_is_exclusive(hdspm))
+               return -EBUSY;
+       val = ucontrol->value.integer.value[0] & 1;
+       spin_lock_irq(&hdspm->lock);
+       change = (int) val != hdspm_input_select(hdspm);
+       hdspm_set_input_select(hdspm, val);
+       spin_unlock_irq(&hdspm->lock);
+       return change;
+}
+
+/*           Simple Mixer
+  deprecated since to much faders ???
+  MIXER interface says output (source, destination, value)
+   where source > MAX_channels are playback channels 
+   on MADICARD 
+  - playback mixer matrix: [channelout+64] [output] [value]
+  - input(thru) mixer matrix: [channelin] [output] [value]
+  (better do 2 kontrols for seperation ?)
+*/
+
+#define HDSPM_MIXER(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
+  .info = snd_hdspm_info_mixer, \
+  .get = snd_hdspm_get_mixer, \
+  .put = snd_hdspm_put_mixer \
+}
+
+static int snd_hdspm_info_mixer(snd_kcontrol_t * kcontrol,
+                               snd_ctl_elem_info_t * uinfo)
+{
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+       uinfo->count = 3;
+       uinfo->value.integer.min = 0;
+       uinfo->value.integer.max = 65535;
+       uinfo->value.integer.step = 1;
+       return 0;
+}
+
+static int snd_hdspm_get_mixer(snd_kcontrol_t * kcontrol,
+                              snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int source;
+       int destination;
+
+       source = ucontrol->value.integer.value[0];
+       if (source < 0)
+               source = 0;
+       else if (source >= 2 * HDSPM_MAX_CHANNELS)
+               source = 2 * HDSPM_MAX_CHANNELS - 1;
+
+       destination = ucontrol->value.integer.value[1];
+       if (destination < 0)
+               destination = 0;
+       else if (destination >= HDSPM_MAX_CHANNELS)
+               destination = HDSPM_MAX_CHANNELS - 1;
+
+       spin_lock_irq(&hdspm->lock);
+       if (source >= HDSPM_MAX_CHANNELS)
+               ucontrol->value.integer.value[2] =
+                   hdspm_read_pb_gain(hdspm, destination,
+                                      source - HDSPM_MAX_CHANNELS);
+       else
+               ucontrol->value.integer.value[2] =
+                   hdspm_read_in_gain(hdspm, destination, source);
+
+       spin_unlock_irq(&hdspm->lock);
+
+       return 0;
+}
+
+static int snd_hdspm_put_mixer(snd_kcontrol_t * kcontrol,
+                              snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int change;
+       int source;
+       int destination;
+       int gain;
+
+       if (!snd_hdspm_use_is_exclusive(hdspm))
+               return -EBUSY;
+
+       source = ucontrol->value.integer.value[0];
+       destination = ucontrol->value.integer.value[1];
+
+       if (source < 0 || source >= 2 * HDSPM_MAX_CHANNELS)
+               return -1;
+       if (destination < 0 || destination >= HDSPM_MAX_CHANNELS)
+               return -1;
+
+       gain = ucontrol->value.integer.value[2];
+
+       spin_lock_irq(&hdspm->lock);
+
+       if (source >= HDSPM_MAX_CHANNELS)
+               change = gain != hdspm_read_pb_gain(hdspm, destination,
+                                                   source -
+                                                   HDSPM_MAX_CHANNELS);
+       else
+               change =
+                   gain != hdspm_read_in_gain(hdspm, destination, source);
+
+       if (change) {
+               if (source >= HDSPM_MAX_CHANNELS)
+                       hdspm_write_pb_gain(hdspm, destination,
+                                           source - HDSPM_MAX_CHANNELS,
+                                           gain);
+               else
+                       hdspm_write_in_gain(hdspm, destination, source,
+                                           gain);
+       }
+       spin_unlock_irq(&hdspm->lock);
+
+       return change;
+}
+
+/* The simple mixer control(s) provide gain control for the
+   basic 1:1 mappings of playback streams to output
+   streams. 
+*/
+
+#define HDSPM_PLAYBACK_MIXER \
+{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_WRITE | \
+                SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
+  .info = snd_hdspm_info_playback_mixer, \
+  .get = snd_hdspm_get_playback_mixer, \
+  .put = snd_hdspm_put_playback_mixer \
+}
+
+static int snd_hdspm_info_playback_mixer(snd_kcontrol_t * kcontrol,
+                                        snd_ctl_elem_info_t * uinfo)
+{
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+       uinfo->count = 1;
+       uinfo->value.integer.min = 0;
+       uinfo->value.integer.max = 65536;
+       uinfo->value.integer.step = 1;
+       return 0;
+}
+
+static int snd_hdspm_get_playback_mixer(snd_kcontrol_t * kcontrol,
+                                       snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int channel;
+       int mapped_channel;
+
+       channel = ucontrol->id.index - 1;
+
+       snd_assert(channel >= 0
+                  || channel < HDSPM_MAX_CHANNELS, return -EINVAL);
+
+       if ((mapped_channel = hdspm->channel_map[channel]) < 0)
+               return -EINVAL;
+
+       spin_lock_irq(&hdspm->lock);
+       ucontrol->value.integer.value[0] =
+           hdspm_read_pb_gain(hdspm, mapped_channel, mapped_channel);
+       spin_unlock_irq(&hdspm->lock);
+
+       /*    snd_printdd("get pb mixer index %d, channel %d, mapped_channel %d, value %d\n",
+          ucontrol->id.index,        channel, mapped_channel,  ucontrol->value.integer.value[0]); 
+        */
+
+       return 0;
+}
+
+static int snd_hdspm_put_playback_mixer(snd_kcontrol_t * kcontrol,
+                                       snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+       int change;
+       int channel;
+       int mapped_channel;
+       int gain;
+
+       if (!snd_hdspm_use_is_exclusive(hdspm))
+               return -EBUSY;
+
+       channel = ucontrol->id.index - 1;
+
+       snd_assert(channel >= 0
+                  || channel < HDSPM_MAX_CHANNELS, return -EINVAL);
+
+       if ((mapped_channel = hdspm->channel_map[channel]) < 0)
+               return -EINVAL;
+
+       gain = ucontrol->value.integer.value[0];
+
+       spin_lock_irq(&hdspm->lock);
+       change =
+           gain != hdspm_read_pb_gain(hdspm, mapped_channel,
+                                      mapped_channel);
+       if (change)
+               hdspm_write_pb_gain(hdspm, mapped_channel, mapped_channel,
+                                   gain);
+       spin_unlock_irq(&hdspm->lock);
+       return change;
+}
+
+#define HDSPM_WC_SYNC_CHECK(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
+  .info = snd_hdspm_info_sync_check, \
+  .get = snd_hdspm_get_wc_sync_check \
+}
+
+static int snd_hdspm_info_sync_check(snd_kcontrol_t * kcontrol,
+                                    snd_ctl_elem_info_t * uinfo)
+{
+       static char *texts[] = { "No Lock", "Lock", "Sync" };
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+       uinfo->count = 1;
+       uinfo->value.enumerated.items = 3;
+       if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+               uinfo->value.enumerated.item =
+                   uinfo->value.enumerated.items - 1;
+       strcpy(uinfo->value.enumerated.name,
+              texts[uinfo->value.enumerated.item]);
+       return 0;
+}
+
+static int hdspm_wc_sync_check(hdspm_t * hdspm)
+{
+       int status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
+       if (status2 & HDSPM_wcLock) {
+               if (status2 & HDSPM_wcSync)
+                       return 2;
+               else
+                       return 1;
+       }
+       return 0;
+}
+
+static int snd_hdspm_get_wc_sync_check(snd_kcontrol_t * kcontrol,
+                                      snd_ctl_elem_value_t * ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       ucontrol->value.enumerated.item[0] = hdspm_wc_sync_check(hdspm);
+       return 0;
+}
+
+
+#define HDSPM_MADI_SYNC_CHECK(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
+  .info = snd_hdspm_info_sync_check, \
+  .get = snd_hdspm_get_madisync_sync_check \
+}
+
+static int hdspm_madisync_sync_check(hdspm_t * hdspm)
+{
+       int status = hdspm_read(hdspm, HDSPM_statusRegister);
+       if (status & HDSPM_madiLock) {
+               if (status & HDSPM_madiSync)
+                       return 2;
+               else
+                       return 1;
+       }
+       return 0;
+}
+
+static int snd_hdspm_get_madisync_sync_check(snd_kcontrol_t * kcontrol,
+                                            snd_ctl_elem_value_t *
+                                            ucontrol)
+{
+       hdspm_t *hdspm = snd_kcontrol_chip(kcontrol);
+
+       ucontrol->value.enumerated.item[0] =
+           hdspm_madisync_sync_check(hdspm);
+       return 0;
+}
+
+
+
+
+static snd_kcontrol_new_t snd_hdspm_controls[] = {
+
+       HDSPM_MIXER("Mixer", 0),
+/* 'Sample Clock Source' complies with the alsa control naming scheme */
+       HDSPM_CLOCK_SOURCE("Sample Clock Source", 0),
+
+       HDSPM_SYSTEM_CLOCK_MODE("System Clock Mode", 0),
+       HDSPM_PREF_SYNC_REF("Preferred Sync Reference", 0),
+       HDSPM_AUTOSYNC_REF("AutoSync Reference", 0),
+       HDSPM_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
+/* 'External Rate' complies with the alsa control naming scheme */
+       HDSPM_AUTOSYNC_SAMPLE_RATE("External Rate", 0),
+       HDSPM_WC_SYNC_CHECK("Word Clock Lock Status", 0),
+       HDSPM_MADI_SYNC_CHECK("MADI Sync Lock Status", 0),
+       HDSPM_LINE_OUT("Line Out", 0),
+       HDSPM_TX_64("TX 64 channels mode", 0),
+       HDSPM_C_TMS("Clear Track Marker", 0),
+       HDSPM_SAFE_MODE("Safe Mode", 0),
+       HDSPM_INPUT_SELECT("Input Select", 0),
+};
+
+static snd_kcontrol_new_t snd_hdspm_playback_mixer = HDSPM_PLAYBACK_MIXER;
+
+
+static int hdspm_update_simple_mixer_controls(hdspm_t * hdspm)
+{
+       int i;
+
+       for (i = hdspm->ds_channels; i < hdspm->ss_channels; ++i) {
+               if (hdspm->system_sample_rate > 48000) {
+                       hdspm->playback_mixer_ctls[i]->vd[0].access =
+                           SNDRV_CTL_ELEM_ACCESS_INACTIVE |
+                           SNDRV_CTL_ELEM_ACCESS_READ |
+                           SNDRV_CTL_ELEM_ACCESS_VOLATILE;
+               } else {
+                       hdspm->playback_mixer_ctls[i]->vd[0].access =
+                           SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                           SNDRV_CTL_ELEM_ACCESS_VOLATILE;
+               }
+               snd_ctl_notify(hdspm->card, SNDRV_CTL_EVENT_MASK_VALUE |
+                              SNDRV_CTL_EVENT_MASK_INFO,
+                              &hdspm->playback_mixer_ctls[i]->id);
+       }
+
+       return 0;
+}
+
+
+static int snd_hdspm_create_controls(snd_card_t * card, hdspm_t * hdspm)
+{
+       unsigned int idx, limit;
+       int err;
+       snd_kcontrol_t *kctl;
+
+       /* add control list first */
+
+       for (idx = 0; idx < ARRAY_SIZE(snd_hdspm_controls); idx++) {
+               if ((err =
+                    snd_ctl_add(card, kctl =
+                                snd_ctl_new1(&snd_hdspm_controls[idx],
+                                             hdspm))) < 0) {
+                       return err;
+               }
+       }
+
+       /* Channel playback mixer as default control 
+          Note: the whole matrix would be 128*HDSPM_MIXER_CHANNELS Faders, thats to big for any alsamixer 
+          they are accesible via special IOCTL on hwdep
+          and the mixer 2dimensional mixer control */
+
+       snd_hdspm_playback_mixer.name = "Chn";
+       limit = HDSPM_MAX_CHANNELS;
+
+       /* The index values are one greater than the channel ID so that alsamixer
+          will display them correctly. We want to use the index for fast lookup
+          of the relevant channel, but if we use it at all, most ALSA software
+          does the wrong thing with it ...
+        */
+
+       for (idx = 0; idx < limit; ++idx) {
+               snd_hdspm_playback_mixer.index = idx + 1;
+               if ((err = snd_ctl_add(card,
+                                      kctl =
+                                      snd_ctl_new1
+                                      (&snd_hdspm_playback_mixer,
+                                       hdspm)))) {
+                       return err;
+               }
+               hdspm->playback_mixer_ctls[idx] = kctl;
+       }
+
+       return 0;
+}
+
+/*------------------------------------------------------------
+   /proc interface 
+ ------------------------------------------------------------*/
+
+static void
+snd_hdspm_proc_read(snd_info_entry_t * entry, snd_info_buffer_t * buffer)
+{
+       hdspm_t *hdspm = (hdspm_t *) entry->private_data;
+       unsigned int status;
+       unsigned int status2;
+       char *pref_sync_ref;
+       char *autosync_ref;
+       char *system_clock_mode;
+       char *clock_source;
+       char *insel;
+       char *syncref;
+       int x, x2;
+
+       status = hdspm_read(hdspm, HDSPM_statusRegister);
+       status2 = hdspm_read(hdspm, HDSPM_statusRegister2);
+
+       snd_iprintf(buffer, "%s (Card #%d) Rev.%x Status2first3bits: %x\n",
+                   hdspm->card_name, hdspm->card->number + 1,
+                   hdspm->firmware_rev,
+                   (status2 & HDSPM_version0) |
+                   (status2 & HDSPM_version1) | (status2 &
+                                                 HDSPM_version2));
+
+       snd_iprintf(buffer, "IRQ: %d Registers bus: 0x%lx VM: 0x%lx\n",
+                   hdspm->irq, hdspm->port, (unsigned long)hdspm->iobase);
+
+       snd_iprintf(buffer, "--- System ---\n");
+
+       snd_iprintf(buffer,
+                   "IRQ Pending: Audio=%d, MIDI0=%d, MIDI1=%d, IRQcount=%d\n",
+                   status & HDSPM_audioIRQPending,
+                   (status & HDSPM_midi0IRQPending) ? 1 : 0,
+                   (status & HDSPM_midi1IRQPending) ? 1 : 0,
+                   hdspm->irq_count);
+       snd_iprintf(buffer,
+                   "HW pointer: id = %d, rawptr = %d (%d->%d) estimated= %ld (bytes)\n",
+                   ((status & HDSPM_BufferID) ? 1 : 0),
+                   (status & HDSPM_BufferPositionMask),
+                   (status & HDSPM_BufferPositionMask) % (2 *
+                                                          (int)hdspm->
+                                                          period_bytes),
+                   ((status & HDSPM_BufferPositionMask) -
+                    64) % (2 * (int)hdspm->period_bytes),
+                   (long) hdspm_hw_pointer(hdspm) * 4);
+
+       snd_iprintf(buffer,
+                   "MIDI FIFO: Out1=0x%x, Out2=0x%x, In1=0x%x, In2=0x%x \n",
+                   hdspm_read(hdspm, HDSPM_midiStatusOut0) & 0xFF,
+                   hdspm_read(hdspm, HDSPM_midiStatusOut1) & 0xFF,
+                   hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xFF,
+                   hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xFF);
+       snd_iprintf(buffer,
+                   "Register: ctrl1=0x%x, ctrl2=0x%x, status1=0x%x, status2=0x%x\n",
+                   hdspm->control_register, hdspm->control2_register,
+                   status, status2);
+
+       snd_iprintf(buffer, "--- Settings ---\n");
+
+       x = 1 << (6 +
+                 hdspm_decode_latency(hdspm->
+                                      control_register &
+                                      HDSPM_LatencyMask));
+
+       snd_iprintf(buffer,
+                   "Size (Latency): %d samples (2 periods of %lu bytes)\n",
+                   x, (unsigned long) hdspm->period_bytes);
+
+       snd_iprintf(buffer, "Line out: %s,   Precise Pointer: %s\n",
+                   (hdspm->
+                    control_register & HDSPM_LineOut) ? "on " : "off",
+                   (hdspm->precise_ptr) ? "on" : "off");
+
+       switch (hdspm->control_register & HDSPM_InputMask) {
+       case HDSPM_InputOptical:
+               insel = "Optical";
+               break;
+       case HDSPM_InputCoaxial:
+               insel = "Coaxial";
+               break;
+       default:
+               insel = "Unkown";
+       }
+
+       switch (hdspm->control_register & HDSPM_SyncRefMask) {
+       case HDSPM_SyncRef_Word:
+               syncref = "WordClock";
+               break;
+       case HDSPM_SyncRef_MADI:
+               syncref = "MADI";
+               break;
+       default:
+               syncref = "Unkown";
+       }
+       snd_iprintf(buffer, "Inputsel = %s, SyncRef = %s\n", insel,
+                   syncref);
+
+       snd_iprintf(buffer,
+                   "ClearTrackMarker = %s, Transmit in %s Channel Mode, Auto Input %s\n",
+                   (hdspm->
+                    control_register & HDSPM_clr_tms) ? "on" : "off",
+                   (hdspm->
+                    control_register & HDSPM_TX_64ch) ? "64" : "56",
+                   (hdspm->
+                    control_register & HDSPM_AutoInp) ? "on" : "off");
+
+       switch (hdspm_clock_source(hdspm)) {
+       case HDSPM_CLOCK_SOURCE_AUTOSYNC:
+               clock_source = "AutoSync";
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_32KHZ:
+               clock_source = "Internal 32 kHz";
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_44_1KHZ:
+               clock_source = "Internal 44.1 kHz";
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_48KHZ:
+               clock_source = "Internal 48 kHz";
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_64KHZ:
+               clock_source = "Internal 64 kHz";
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_88_2KHZ:
+               clock_source = "Internal 88.2 kHz";
+               break;
+       case HDSPM_CLOCK_SOURCE_INTERNAL_96KHZ:
+               clock_source = "Internal 96 kHz";
+               break;
+       default:
+               clock_source = "Error";
+       }
+       snd_iprintf(buffer, "Sample Clock Source: %s\n", clock_source);
+       if (!(hdspm->control_register & HDSPM_ClockModeMaster)) {
+               system_clock_mode = "Slave";
+       } else {
+               system_clock_mode = "Master";
+       }
+       snd_iprintf(buffer, "System Clock Mode: %s\n", system_clock_mode);
+
+       switch (hdspm_pref_sync_ref(hdspm)) {
+       case HDSPM_SYNC_FROM_WORD:
+               pref_sync_ref = "Word Clock";
+               break;
+       case HDSPM_SYNC_FROM_MADI:
+               pref_sync_ref = "MADI Sync";
+               break;
+       default:
+               pref_sync_ref = "XXXX Clock";
+               break;
+       }
+       snd_iprintf(buffer, "Preferred Sync Reference: %s\n",
+                   pref_sync_ref);
+
+       snd_iprintf(buffer, "System Clock Frequency: %d\n",
+                   hdspm->system_sample_rate);
+
+
+       snd_iprintf(buffer, "--- Status:\n");
+
+       x = status & HDSPM_madiSync;
+       x2 = status2 & HDSPM_wcSync;
+
+       snd_iprintf(buffer, "Inputs MADI=%s, WordClock=%s\n",
+                   (status & HDSPM_madiLock) ? (x ? "Sync" : "Lock") :
+                   "NoLock",
+                   (status2 & HDSPM_wcLock) ? (x2 ? "Sync" : "Lock") :
+                   "NoLock");
+
+       switch (hdspm_autosync_ref(hdspm)) {
+       case HDSPM_AUTOSYNC_FROM_WORD:
+               autosync_ref = "Word Clock";
+               break;
+       case HDSPM_AUTOSYNC_FROM_MADI:
+               autosync_ref = "MADI Sync";
+               break;
+       case HDSPM_AUTOSYNC_FROM_NONE:
+               autosync_ref = "Input not valid";
+               break;
+       default:
+               autosync_ref = "---";
+               break;
+       }
+       snd_iprintf(buffer,
+                   "AutoSync: Reference= %s, Freq=%d (MADI = %d, Word = %d)\n",
+                   autosync_ref, hdspm_external_sample_rate(hdspm),
+                   (status & HDSPM_madiFreqMask) >> 22,
+                   (status2 & HDSPM_wcFreqMask) >> 5);
+
+       snd_iprintf(buffer, "Input: %s, Mode=%s\n",
+                   (status & HDSPM_AB_int) ? "Coax" : "Optical",
+                   (status & HDSPM_RX_64ch) ? "64 channels" :
+                   "56 channels");
+
+       snd_iprintf(buffer, "\n");
+}
+
+static void __devinit snd_hdspm_proc_init(hdspm_t * hdspm)
+{
+       snd_info_entry_t *entry;
+
+       if (!snd_card_proc_new(hdspm->card, "hdspm", &entry))
+               snd_info_set_text_ops(entry, hdspm, 1024,
+                                     snd_hdspm_proc_read);
+}
+
+/*------------------------------------------------------------
+   hdspm intitialize 
+ ------------------------------------------------------------*/
+
+static int snd_hdspm_set_defaults(hdspm_t * hdspm)
+{
+       unsigned int i;
+
+       /* ASSUMPTION: hdspm->lock is either held, or there is no need to
+          hold it (e.g. during module initalization).
+        */
+
+       /* set defaults:       */
+
+       hdspm->control_register = HDSPM_ClockModeMaster |       /* Master Cloack Mode on */
+           hdspm_encode_latency(7) |   /* latency maximum = 8192 samples */
+           HDSPM_InputCoaxial |        /* Input Coax not Optical */
+           HDSPM_SyncRef_MADI |        /* Madi is syncclock */
+           HDSPM_LineOut |     /* Analog output in */
+           HDSPM_TX_64ch |     /* transmit in 64ch mode */
+           HDSPM_AutoInp;      /* AutoInput chossing (takeover) */
+
+       /* ! HDSPM_Frequency0|HDSPM_Frequency1 = 44.1khz */
+       /* !  HDSPM_DoubleSpeed HDSPM_QuadSpeed = normal speed */
+       /* ! HDSPM_clr_tms = do not clear bits in track marks */
+
+       hdspm_write(hdspm, HDSPM_controlRegister, hdspm->control_register);
+
+#ifdef SNDRV_BIG_ENDIAN
+       hdspm->control2_register = HDSPM_BIGENDIAN_MODE;
+#else
+       hdspm->control2_register = 0;
+#endif
+
+       hdspm_write(hdspm, HDSPM_control2Reg, hdspm->control2_register);
+       hdspm_compute_period_size(hdspm);
+
+       /* silence everything */
+
+       all_in_all_mixer(hdspm, 0 * UNITY_GAIN);
+
+       if (line_outs_monitor[hdspm->dev]) {
+
+               snd_printk(KERN_INFO "HDSPM: sending all playback streams to line outs.\n");
+
+               for (i = 0; i < HDSPM_MIXER_CHANNELS; i++) {
+                       if (hdspm_write_pb_gain(hdspm, i, i, UNITY_GAIN))
+                               return -EIO;
+               }
+       }
+
+       /* set a default rate so that the channel map is set up. */
+       hdspm->channel_map = channel_map_madi_ss;
+       hdspm_set_rate(hdspm, 44100, 1);
+
+       return 0;
+}
+
+
+/*------------------------------------------------------------
+   interupt 
+ ------------------------------------------------------------*/
+
+static irqreturn_t snd_hdspm_interrupt(int irq, void *dev_id,
+                                      struct pt_regs *regs)
+{
+       hdspm_t *hdspm = (hdspm_t *) dev_id;
+       unsigned int status;
+       int audio;
+       int midi0;
+       int midi1;
+       unsigned int midi0status;
+       unsigned int midi1status;
+       int schedule = 0;
+
+       status = hdspm_read(hdspm, HDSPM_statusRegister);
+
+       audio = status & HDSPM_audioIRQPending;
+       midi0 = status & HDSPM_midi0IRQPending;
+       midi1 = status & HDSPM_midi1IRQPending;
+
+       if (!audio && !midi0 && !midi1)
+               return IRQ_NONE;
+
+       hdspm_write(hdspm, HDSPM_interruptConfirmation, 0);
+       hdspm->irq_count++;
+
+       midi0status = hdspm_read(hdspm, HDSPM_midiStatusIn0) & 0xff;
+       midi1status = hdspm_read(hdspm, HDSPM_midiStatusIn1) & 0xff;
+
+       if (audio) {
+
+               if (hdspm->capture_substream)
+                       snd_pcm_period_elapsed(hdspm->pcm->
+                                              streams
+                                              [SNDRV_PCM_STREAM_CAPTURE].
+                                              substream);
+
+               if (hdspm->playback_substream)
+                       snd_pcm_period_elapsed(hdspm->pcm->
+                                              streams
+                                              [SNDRV_PCM_STREAM_PLAYBACK].
+                                              substream);
+       }
+
+       if (midi0 && midi0status) {
+               /* we disable interrupts for this input until processing is done */
+               hdspm->control_register &= ~HDSPM_Midi0InterruptEnable;
+               hdspm_write(hdspm, HDSPM_controlRegister,
+                           hdspm->control_register);
+               hdspm->midi[0].pending = 1;
+               schedule = 1;
+       }
+       if (midi1 && midi1status) {
+               /* we disable interrupts for this input until processing is done */
+               hdspm->control_register &= ~HDSPM_Midi1InterruptEnable;
+               hdspm_write(hdspm, HDSPM_controlRegister,
+                           hdspm->control_register);
+               hdspm->midi[1].pending = 1;
+               schedule = 1;
+       }
+       if (schedule)
+               tasklet_hi_schedule(&hdspm->midi_tasklet);
+       return IRQ_HANDLED;
+}
+
+/*------------------------------------------------------------
+   pcm interface 
+  ------------------------------------------------------------*/
+
+
+static snd_pcm_uframes_t snd_hdspm_hw_pointer(snd_pcm_substream_t *
+                                             substream)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       return hdspm_hw_pointer(hdspm);
+}
+
+static char *hdspm_channel_buffer_location(hdspm_t * hdspm,
+                                          int stream, int channel)
+{
+       int mapped_channel;
+
+       snd_assert(channel >= 0
+                  || channel < HDSPM_MAX_CHANNELS, return NULL);
+
+       if ((mapped_channel = hdspm->channel_map[channel]) < 0)
+               return NULL;
+
+       if (stream == SNDRV_PCM_STREAM_CAPTURE) {
+               return hdspm->capture_buffer +
+                   mapped_channel * HDSPM_CHANNEL_BUFFER_BYTES;
+       } else {
+               return hdspm->playback_buffer +
+                   mapped_channel * HDSPM_CHANNEL_BUFFER_BYTES;
+       }
+}
+
+
+/* dont know why need it ??? */
+static int snd_hdspm_playback_copy(snd_pcm_substream_t * substream,
+                                  int channel, snd_pcm_uframes_t pos,
+                                  void __user *src, snd_pcm_uframes_t count)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       char *channel_buf;
+
+       snd_assert(pos + count <= HDSPM_CHANNEL_BUFFER_BYTES / 4,
+                  return -EINVAL);
+
+       channel_buf = hdspm_channel_buffer_location(hdspm,
+                                                   substream->pstr->
+                                                   stream, channel);
+
+       snd_assert(channel_buf != NULL, return -EIO);
+
+       return copy_from_user(channel_buf + pos * 4, src, count * 4);
+}
+
+static int snd_hdspm_capture_copy(snd_pcm_substream_t * substream,
+                                 int channel, snd_pcm_uframes_t pos,
+                                 void __user *dst, snd_pcm_uframes_t count)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       char *channel_buf;
+
+       snd_assert(pos + count <= HDSPM_CHANNEL_BUFFER_BYTES / 4,
+                  return -EINVAL);
+
+       channel_buf = hdspm_channel_buffer_location(hdspm,
+                                                   substream->pstr->
+                                                   stream, channel);
+       snd_assert(channel_buf != NULL, return -EIO);
+       return copy_to_user(dst, channel_buf + pos * 4, count * 4);
+}
+
+static int snd_hdspm_hw_silence(snd_pcm_substream_t * substream,
+                               int channel, snd_pcm_uframes_t pos,
+                               snd_pcm_uframes_t count)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       char *channel_buf;
+
+       channel_buf =
+           hdspm_channel_buffer_location(hdspm, substream->pstr->stream,
+                                         channel);
+       snd_assert(channel_buf != NULL, return -EIO);
+       memset(channel_buf + pos * 4, 0, count * 4);
+       return 0;
+}
+
+static int snd_hdspm_reset(snd_pcm_substream_t * substream)
+{
+       snd_pcm_runtime_t *runtime = substream->runtime;
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       snd_pcm_substream_t *other;
+
+       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+               other = hdspm->capture_substream;
+       else
+               other = hdspm->playback_substream;
+
+       if (hdspm->running)
+               runtime->status->hw_ptr = hdspm_hw_pointer(hdspm);
+       else
+               runtime->status->hw_ptr = 0;
+       if (other) {
+               struct list_head *pos;
+               snd_pcm_substream_t *s;
+               snd_pcm_runtime_t *oruntime = other->runtime;
+               snd_pcm_group_for_each(pos, substream) {
+                       s = snd_pcm_group_substream_entry(pos);
+                       if (s == other) {
+                               oruntime->status->hw_ptr =
+                                   runtime->status->hw_ptr;
+                               break;
+                       }
+               }
+       }
+       return 0;
+}
+
+static int snd_hdspm_hw_params(snd_pcm_substream_t * substream,
+                              snd_pcm_hw_params_t * params)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       int err;
+       int i;
+       pid_t this_pid;
+       pid_t other_pid;
+       struct snd_sg_buf *sgbuf;
+
+
+       spin_lock_irq(&hdspm->lock);
+
+       if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+               this_pid = hdspm->playback_pid;
+               other_pid = hdspm->capture_pid;
+       } else {
+               this_pid = hdspm->capture_pid;
+               other_pid = hdspm->playback_pid;
+       }
+
+       if ((other_pid > 0) && (this_pid != other_pid)) {
+
+               /* The other stream is open, and not by the same
+                  task as this one. Make sure that the parameters
+                  that matter are the same.
+                */
+
+               if (params_rate(params) != hdspm->system_sample_rate) {
+                       spin_unlock_irq(&hdspm->lock);
+                       _snd_pcm_hw_param_setempty(params,
+                                                  SNDRV_PCM_HW_PARAM_RATE);
+                       return -EBUSY;
+               }
+
+               if (params_period_size(params) != hdspm->period_bytes / 4) {
+                       spin_unlock_irq(&hdspm->lock);
+                       _snd_pcm_hw_param_setempty(params,
+                                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
+                       return -EBUSY;
+               }
+
+       }
+       /* We're fine. */
+       spin_unlock_irq(&hdspm->lock);
+
+       /* how to make sure that the rate matches an externally-set one ?   */
+
+       spin_lock_irq(&hdspm->lock);
+       if ((err = hdspm_set_rate(hdspm, params_rate(params), 0)) < 0) {
+               spin_unlock_irq(&hdspm->lock);
+               _snd_pcm_hw_param_setempty(params,
+                                          SNDRV_PCM_HW_PARAM_RATE);
+               return err;
+       }
+       spin_unlock_irq(&hdspm->lock);
+
+       if ((err =
+            hdspm_set_interrupt_interval(hdspm,
+                                         params_period_size(params))) <
+           0) {
+               _snd_pcm_hw_param_setempty(params,
+                                          SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
+               return err;
+       }
+
+       /* Memory allocation, takashi's method, dont know if we should spinlock  */
+       /* malloc all buffer even if not enabled to get sure */
+       /* malloc only needed bytes */
+       err =
+           snd_pcm_lib_malloc_pages(substream,
+                                    HDSPM_CHANNEL_BUFFER_BYTES *
+                                    params_channels(params));
+       if (err < 0)
+               return err;
+
+       sgbuf = snd_pcm_substream_sgbuf(substream);
+
+       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+
+               hdspm_set_sgbuf(hdspm, sgbuf, HDSPM_pageAddressBufferOut,
+                               params_channels(params));
+
+               for (i = 0; i < params_channels(params); ++i)
+                       snd_hdspm_enable_out(hdspm, i, 1);
+
+               hdspm->playback_buffer =
+                   (unsigned char *) substream->runtime->dma_area;
+       } else {
+               hdspm_set_sgbuf(hdspm, sgbuf, HDSPM_pageAddressBufferIn,
+                               params_channels(params));
+
+               for (i = 0; i < params_channels(params); ++i)
+                       snd_hdspm_enable_in(hdspm, i, 1);
+
+               hdspm->capture_buffer =
+                   (unsigned char *) substream->runtime->dma_area;
+       }
+       return 0;
+}
+
+static int snd_hdspm_hw_free(snd_pcm_substream_t * substream)
+{
+       int i;
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+
+       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+
+               /* params_channels(params) should be enough, 
+                  but to get sure in case of error */
+               for (i = 0; i < HDSPM_MAX_CHANNELS; ++i)
+                       snd_hdspm_enable_out(hdspm, i, 0);
+
+               hdspm->playback_buffer = NULL;
+       } else {
+               for (i = 0; i < HDSPM_MAX_CHANNELS; ++i)
+                       snd_hdspm_enable_in(hdspm, i, 0);
+
+               hdspm->capture_buffer = NULL;
+
+       }
+
+       snd_pcm_lib_free_pages(substream);
+
+       return 0;
+}
+
+static int snd_hdspm_channel_info(snd_pcm_substream_t * substream,
+                                 snd_pcm_channel_info_t * info)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       int mapped_channel;
+
+       snd_assert(info->channel < HDSPM_MAX_CHANNELS, return -EINVAL);
+
+       if ((mapped_channel = hdspm->channel_map[info->channel]) < 0)
+               return -EINVAL;
+
+       info->offset = mapped_channel * HDSPM_CHANNEL_BUFFER_BYTES;
+       info->first = 0;
+       info->step = 32;
+       return 0;
+}
+
+static int snd_hdspm_ioctl(snd_pcm_substream_t * substream,
+                          unsigned int cmd, void *arg)
+{
+       switch (cmd) {
+       case SNDRV_PCM_IOCTL1_RESET:
+               {
+                       return snd_hdspm_reset(substream);
+               }
+
+       case SNDRV_PCM_IOCTL1_CHANNEL_INFO:
+               {
+                       snd_pcm_channel_info_t *info = arg;
+                       return snd_hdspm_channel_info(substream, info);
+               }
+       default:
+               break;
+       }
+
+       return snd_pcm_lib_ioctl(substream, cmd, arg);
+}
+
+static int snd_hdspm_trigger(snd_pcm_substream_t * substream, int cmd)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       snd_pcm_substream_t *other;
+       int running;
+
+       spin_lock(&hdspm->lock);
+       running = hdspm->running;
+       switch (cmd) {
+       case SNDRV_PCM_TRIGGER_START:
+               running |= 1 << substream->stream;
+               break;
+       case SNDRV_PCM_TRIGGER_STOP:
+               running &= ~(1 << substream->stream);
+               break;
+       default:
+               snd_BUG();
+               spin_unlock(&hdspm->lock);
+               return -EINVAL;
+       }
+       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+               other = hdspm->capture_substream;
+       else
+               other = hdspm->playback_substream;
+
+       if (other) {
+               struct list_head *pos;
+               snd_pcm_substream_t *s;
+               snd_pcm_group_for_each(pos, substream) {
+                       s = snd_pcm_group_substream_entry(pos);
+                       if (s == other) {
+                               snd_pcm_trigger_done(s, substream);
+                               if (cmd == SNDRV_PCM_TRIGGER_START)
+                                       running |= 1 << s->stream;
+                               else
+                                       running &= ~(1 << s->stream);
+                               goto _ok;
+                       }
+               }
+               if (cmd == SNDRV_PCM_TRIGGER_START) {
+                       if (!(running & (1 << SNDRV_PCM_STREAM_PLAYBACK))
+                           && substream->stream ==
+                           SNDRV_PCM_STREAM_CAPTURE)
+                               hdspm_silence_playback(hdspm);
+               } else {
+                       if (running &&
+                           substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                               hdspm_silence_playback(hdspm);
+               }
+       } else {
+               if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
+                       hdspm_silence_playback(hdspm);
+       }
+      _ok:
+       snd_pcm_trigger_done(substream, substream);
+       if (!hdspm->running && running)
+               hdspm_start_audio(hdspm);
+       else if (hdspm->running && !running)
+               hdspm_stop_audio(hdspm);
+       hdspm->running = running;
+       spin_unlock(&hdspm->lock);
+
+       return 0;
+}
+
+static int snd_hdspm_prepare(snd_pcm_substream_t * substream)
+{
+       return 0;
+}
+
+static unsigned int period_sizes[] =
+    { 64, 128, 256, 512, 1024, 2048, 4096, 8192 };
+
+static snd_pcm_hardware_t snd_hdspm_playback_subinfo = {
+       .info = (SNDRV_PCM_INFO_MMAP |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_NONINTERLEAVED |
+                SNDRV_PCM_INFO_SYNC_START | SNDRV_PCM_INFO_DOUBLE),
+       .formats = SNDRV_PCM_FMTBIT_S32_LE,
+       .rates = (SNDRV_PCM_RATE_32000 |
+                 SNDRV_PCM_RATE_44100 |
+                 SNDRV_PCM_RATE_48000 |
+                 SNDRV_PCM_RATE_64000 |
+                 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000),
+       .rate_min = 32000,
+       .rate_max = 96000,
+       .channels_min = 1,
+       .channels_max = HDSPM_MAX_CHANNELS,
+       .buffer_bytes_max =
+           HDSPM_CHANNEL_BUFFER_BYTES * HDSPM_MAX_CHANNELS,
+       .period_bytes_min = (64 * 4),
+       .period_bytes_max = (8192 * 4) * HDSPM_MAX_CHANNELS,
+       .periods_min = 2,
+       .periods_max = 2,
+       .fifo_size = 0
+};
+
+static snd_pcm_hardware_t snd_hdspm_capture_subinfo = {
+       .info = (SNDRV_PCM_INFO_MMAP |
+                SNDRV_PCM_INFO_MMAP_VALID |
+                SNDRV_PCM_INFO_NONINTERLEAVED |
+                SNDRV_PCM_INFO_SYNC_START),
+       .formats = SNDRV_PCM_FMTBIT_S32_LE,
+       .rates = (SNDRV_PCM_RATE_32000 |
+                 SNDRV_PCM_RATE_44100 |
+                 SNDRV_PCM_RATE_48000 |
+                 SNDRV_PCM_RATE_64000 |
+                 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000),
+       .rate_min = 32000,
+       .rate_max = 96000,
+       .channels_min = 1,
+       .channels_max = HDSPM_MAX_CHANNELS,
+       .buffer_bytes_max =
+           HDSPM_CHANNEL_BUFFER_BYTES * HDSPM_MAX_CHANNELS,
+       .period_bytes_min = (64 * 4),
+       .period_bytes_max = (8192 * 4) * HDSPM_MAX_CHANNELS,
+       .periods_min = 2,
+       .periods_max = 2,
+       .fifo_size = 0
+};
+
+static snd_pcm_hw_constraint_list_t hw_constraints_period_sizes = {
+       .count = ARRAY_SIZE(period_sizes),
+       .list = period_sizes,
+       .mask = 0
+};
+
+
+static int snd_hdspm_hw_rule_channels_rate(snd_pcm_hw_params_t * params,
+                                          snd_pcm_hw_rule_t * rule)
+{
+       hdspm_t *hdspm = rule->private;
+       snd_interval_t *c =
+           hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+       snd_interval_t *r =
+           hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
+
+       if (r->min > 48000) {
+               snd_interval_t t = {
+                       .min = 1,
+                       .max = hdspm->ds_channels,
+                       .integer = 1,
+               };
+               return snd_interval_refine(c, &t);
+       } else if (r->max < 64000) {
+               snd_interval_t t = {
+                       .min = 1,
+                       .max = hdspm->ss_channels,
+                       .integer = 1,
+               };
+               return snd_interval_refine(c, &t);
+       }
+       return 0;
+}
+
+static int snd_hdspm_hw_rule_rate_channels(snd_pcm_hw_params_t * params,
+                                          snd_pcm_hw_rule_t * rule)
+{
+       hdspm_t *hdspm = rule->private;
+       snd_interval_t *c =
+           hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+       snd_interval_t *r =
+           hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
+
+       if (c->min <= hdspm->ss_channels) {
+               snd_interval_t t = {
+                       .min = 32000,
+                       .max = 48000,
+                       .integer = 1,
+               };
+               return snd_interval_refine(r, &t);
+       } else if (c->max > hdspm->ss_channels) {
+               snd_interval_t t = {
+                       .min = 64000,
+                       .max = 96000,
+                       .integer = 1,
+               };
+
+               return snd_interval_refine(r, &t);
+       }
+       return 0;
+}
+
+static int snd_hdspm_playback_open(snd_pcm_substream_t * substream)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       snd_pcm_runtime_t *runtime = substream->runtime;
+
+       snd_printdd("Open device substream %d\n", substream->stream);
+
+       spin_lock_irq(&hdspm->lock);
+
+       snd_pcm_set_sync(substream);
+
+       runtime->hw = snd_hdspm_playback_subinfo;
+
+       if (hdspm->capture_substream == NULL)
+               hdspm_stop_audio(hdspm);
+
+       hdspm->playback_pid = current->pid;
+       hdspm->playback_substream = substream;
+
+       spin_unlock_irq(&hdspm->lock);
+
+       snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
+
+       snd_pcm_hw_constraint_list(runtime, 0,
+                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+                                  &hw_constraints_period_sizes);
+
+       snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
+                           snd_hdspm_hw_rule_channels_rate, hdspm,
+                           SNDRV_PCM_HW_PARAM_RATE, -1);
+
+       snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
+                           snd_hdspm_hw_rule_rate_channels, hdspm,
+                           SNDRV_PCM_HW_PARAM_CHANNELS, -1);
+
+       return 0;
+}
+
+static int snd_hdspm_playback_release(snd_pcm_substream_t * substream)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+
+       spin_lock_irq(&hdspm->lock);
+
+       hdspm->playback_pid = -1;
+       hdspm->playback_substream = NULL;
+
+       spin_unlock_irq(&hdspm->lock);
+
+       return 0;
+}
+
+
+static int snd_hdspm_capture_open(snd_pcm_substream_t * substream)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+       snd_pcm_runtime_t *runtime = substream->runtime;
+
+       spin_lock_irq(&hdspm->lock);
+       snd_pcm_set_sync(substream);
+       runtime->hw = snd_hdspm_capture_subinfo;
+
+       if (hdspm->playback_substream == NULL)
+               hdspm_stop_audio(hdspm);
+
+       hdspm->capture_pid = current->pid;
+       hdspm->capture_substream = substream;
+
+       spin_unlock_irq(&hdspm->lock);
+
+       snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
+       snd_pcm_hw_constraint_list(runtime, 0,
+                                  SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+                                  &hw_constraints_period_sizes);
+
+       snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
+                           snd_hdspm_hw_rule_channels_rate, hdspm,
+                           SNDRV_PCM_HW_PARAM_RATE, -1);
+
+       snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
+                           snd_hdspm_hw_rule_rate_channels, hdspm,
+                           SNDRV_PCM_HW_PARAM_CHANNELS, -1);
+       return 0;
+}
+
+static int snd_hdspm_capture_release(snd_pcm_substream_t * substream)
+{
+       hdspm_t *hdspm = snd_pcm_substream_chip(substream);
+
+       spin_lock_irq(&hdspm->lock);
+
+       hdspm->capture_pid = -1;
+       hdspm->capture_substream = NULL;
+
+       spin_unlock_irq(&hdspm->lock);
+       return 0;
+}
+
+static int snd_hdspm_hwdep_dummy_op(snd_hwdep_t * hw, struct file *file)
+{
+       /* we have nothing to initialize but the call is required */
+       return 0;
+}
+
+
+static int snd_hdspm_hwdep_ioctl(snd_hwdep_t * hw, struct file *file,
+                                unsigned int cmd, unsigned long arg)
+{
+       hdspm_t *hdspm = (hdspm_t *) hw->private_data;
+       struct sndrv_hdspm_mixer_ioctl mixer;
+       hdspm_config_info_t info;
+       hdspm_version_t hdspm_version;
+       struct sndrv_hdspm_peak_rms_ioctl rms;
+
+       switch (cmd) {
+
+               
+       case SNDRV_HDSPM_IOCTL_GET_PEAK_RMS:
+               if (copy_from_user(&rms, (void __user *)arg, sizeof(rms)))
+                       return -EFAULT;
+               /* maybe there is a chance to memorymap in future so dont touch just copy */
+               if(copy_to_user_fromio((void __user *)rms.peak,
+                                      hdspm->iobase+HDSPM_MADI_peakrmsbase,
+                                      sizeof(hdspm_peak_rms_t)) != 0 )
+                       return -EFAULT;
+
+               break;
+               
+
+       case SNDRV_HDSPM_IOCTL_GET_CONFIG_INFO:
+
+               spin_lock_irq(&hdspm->lock);
+               info.pref_sync_ref =
+                   (unsigned char) hdspm_pref_sync_ref(hdspm);
+               info.wordclock_sync_check =
+                   (unsigned char) hdspm_wc_sync_check(hdspm);
+
+               info.system_sample_rate = hdspm->system_sample_rate;
+               info.autosync_sample_rate =
+                   hdspm_external_sample_rate(hdspm);
+               info.system_clock_mode =
+                   (unsigned char) hdspm_system_clock_mode(hdspm);
+               info.clock_source =
+                   (unsigned char) hdspm_clock_source(hdspm);
+               info.autosync_ref =
+                   (unsigned char) hdspm_autosync_ref(hdspm);
+               info.line_out = (unsigned char) hdspm_line_out(hdspm);
+               info.passthru = 0;
+               spin_unlock_irq(&hdspm->lock);
+               if (copy_to_user((void __user *) arg, &info, sizeof(info)))
+                       return -EFAULT;
+               break;
+
+       case SNDRV_HDSPM_IOCTL_GET_VERSION:
+               hdspm_version.firmware_rev = hdspm->firmware_rev;
+               if (copy_to_user((void __user *) arg, &hdspm_version,
+                                sizeof(hdspm_version)))
+                       return -EFAULT;
+               break;
+
+       case SNDRV_HDSPM_IOCTL_GET_MIXER:
+               if (copy_from_user(&mixer, (void __user *)arg, sizeof(mixer)))
+                       return -EFAULT;
+               if (copy_to_user
+                   ((void __user *)mixer.mixer, hdspm->mixer, sizeof(hdspm_mixer_t)))
+                       return -EFAULT;
+               break;
+
+       default:
+               return -EINVAL;
+       }
+       return 0;
+}
+
+static snd_pcm_ops_t snd_hdspm_playback_ops = {
+       .open = snd_hdspm_playback_open,
+       .close = snd_hdspm_playback_release,
+       .ioctl = snd_hdspm_ioctl,
+       .hw_params = snd_hdspm_hw_params,
+       .hw_free = snd_hdspm_hw_free,
+       .prepare = snd_hdspm_prepare,
+       .trigger = snd_hdspm_trigger,
+       .pointer = snd_hdspm_hw_pointer,
+       .copy = snd_hdspm_playback_copy,
+       .silence = snd_hdspm_hw_silence,
+       .page = snd_pcm_sgbuf_ops_page,
+};
+
+static snd_pcm_ops_t snd_hdspm_capture_ops = {
+       .open = snd_hdspm_capture_open,
+       .close = snd_hdspm_capture_release,
+       .ioctl = snd_hdspm_ioctl,
+       .hw_params = snd_hdspm_hw_params,
+       .hw_free = snd_hdspm_hw_free,
+       .prepare = snd_hdspm_prepare,
+       .trigger = snd_hdspm_trigger,
+       .pointer = snd_hdspm_hw_pointer,
+       .copy = snd_hdspm_capture_copy,
+       .page = snd_pcm_sgbuf_ops_page,
+};
+
+static int __devinit snd_hdspm_create_hwdep(snd_card_t * card,
+                                           hdspm_t * hdspm)
+{
+       snd_hwdep_t *hw;
+       int err;
+
+       if ((err = snd_hwdep_new(card, "HDSPM hwdep", 0, &hw)) < 0)
+               return err;
+
+       hdspm->hwdep = hw;
+       hw->private_data = hdspm;
+       strcpy(hw->name, "HDSPM hwdep interface");
+
+       hw->ops.open = snd_hdspm_hwdep_dummy_op;
+       hw->ops.ioctl = snd_hdspm_hwdep_ioctl;
+       hw->ops.release = snd_hdspm_hwdep_dummy_op;
+
+       return 0;
+}
+
+
+/*------------------------------------------------------------
+   memory interface 
+ ------------------------------------------------------------*/
+static int __devinit snd_hdspm_preallocate_memory(hdspm_t * hdspm)
+{
+       int err;
+       snd_pcm_t *pcm;
+       size_t wanted;
+
+       pcm = hdspm->pcm;
+
+       wanted = HDSPM_DMA_AREA_BYTES + 4096;   /* dont know why, but it works */
+
+       if ((err =
+            snd_pcm_lib_preallocate_pages_for_all(pcm,
+                                                  SNDRV_DMA_TYPE_DEV_SG,
+                                                  snd_dma_pci_data(hdspm->pci),
+                                                  wanted,
+                                                  wanted)) < 0) {
+               snd_printdd("Could not preallocate %d  Bytes\n", wanted);
+
+               return err;
+       } else
+               snd_printdd(" Preallocated %d  Bytes\n", wanted);
+
+       return 0;
+}
+
+static int snd_hdspm_memory_free(hdspm_t * hdspm)
+{
+       snd_printdd("memory_free_for_all %p\n", hdspm->pcm);
+
+       snd_pcm_lib_preallocate_free_for_all(hdspm->pcm);
+       return 0;
+}
+
+
+static void hdspm_set_sgbuf(hdspm_t * hdspm, struct snd_sg_buf *sgbuf,
+                            unsigned int reg, int channels)
+{
+       int i;
+       for (i = 0; i < (channels * 16); i++)
+               hdspm_write(hdspm, reg + 4 * i,
+                           snd_pcm_sgbuf_get_addr(sgbuf,
+                                                  (size_t) 4096 * i));
+}
+
+/* ------------- ALSA Devices ---------------------------- */
+static int __devinit snd_hdspm_create_pcm(snd_card_t * card,
+                                         hdspm_t * hdspm)
+{
+       snd_pcm_t *pcm;
+       int err;
+
+       if ((err = snd_pcm_new(card, hdspm->card_name, 0, 1, 1, &pcm)) < 0)
+               return err;
+
+       hdspm->pcm = pcm;
+       pcm->private_data = hdspm;
+       strcpy(pcm->name, hdspm->card_name);
+
+       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                       &snd_hdspm_playback_ops);
+       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
+                       &snd_hdspm_capture_ops);
+
+       pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
+
+       if ((err = snd_hdspm_preallocate_memory(hdspm)) < 0)
+               return err;
+
+       return 0;
+}
+
+static inline void snd_hdspm_initialize_midi_flush(hdspm_t * hdspm)
+{
+       snd_hdspm_flush_midi_input(hdspm, 0);
+       snd_hdspm_flush_midi_input(hdspm, 1);
+}
+
+static int __devinit snd_hdspm_create_alsa_devices(snd_card_t * card,
+                                                  hdspm_t * hdspm)
+{
+       int err;
+
+       snd_printdd("Create card...\n");
+       if ((err = snd_hdspm_create_pcm(card, hdspm)) < 0)
+               return err;
+
+       if ((err = snd_hdspm_create_midi(card, hdspm, 0)) < 0)
+               return err;
+
+       if ((err = snd_hdspm_create_midi(card, hdspm, 1)) < 0)
+               return err;
+
+       if ((err = snd_hdspm_create_controls(card, hdspm)) < 0)
+               return err;
+
+       if ((err = snd_hdspm_create_hwdep(card, hdspm)) < 0)
+               return err;
+
+       snd_printdd("proc init...\n");
+       snd_hdspm_proc_init(hdspm);
+
+       hdspm->system_sample_rate = -1;
+       hdspm->last_external_sample_rate = -1;
+       hdspm->last_internal_sample_rate = -1;
+       hdspm->playback_pid = -1;
+       hdspm->capture_pid = -1;
+       hdspm->capture_substream = NULL;
+       hdspm->playback_substream = NULL;
+
+       snd_printdd("Set defaults...\n");
+       if ((err = snd_hdspm_set_defaults(hdspm)) < 0)
+               return err;
+
+       snd_printdd("Update mixer controls...\n");
+       hdspm_update_simple_mixer_controls(hdspm);
+
+       snd_printdd("Initializeing complete ???\n");
+
+       if ((err = snd_card_register(card)) < 0) {
+               snd_printk(KERN_ERR "HDSPM: error registering card\n");
+               return err;
+       }
+
+       snd_printdd("... yes now\n");
+
+       return 0;
+}
+
+static int __devinit snd_hdspm_create(snd_card_t * card, hdspm_t * hdspm,
+                                     int precise_ptr, int enable_monitor)
+{
+       struct pci_dev *pci = hdspm->pci;
+       int err;
+       int i;
+
+       unsigned long io_extent;
+
+       hdspm->irq = -1;
+       hdspm->irq_count = 0;
+
+       hdspm->midi[0].rmidi = NULL;
+       hdspm->midi[1].rmidi = NULL;
+       hdspm->midi[0].input = NULL;
+       hdspm->midi[1].input = NULL;
+       hdspm->midi[0].output = NULL;
+       hdspm->midi[1].output = NULL;
+       spin_lock_init(&hdspm->midi[0].lock);
+       spin_lock_init(&hdspm->midi[1].lock);
+       hdspm->iobase = NULL;
+       hdspm->control_register = 0;
+       hdspm->control2_register = 0;
+
+       hdspm->playback_buffer = NULL;
+       hdspm->capture_buffer = NULL;
+
+       for (i = 0; i < HDSPM_MAX_CHANNELS; ++i)
+               hdspm->playback_mixer_ctls[i] = NULL;
+       hdspm->mixer = NULL;
+
+       hdspm->card = card;
+
+       spin_lock_init(&hdspm->lock);
+
+       tasklet_init(&hdspm->midi_tasklet,
+                    hdspm_midi_tasklet, (unsigned long) hdspm);
+
+       pci_read_config_word(hdspm->pci,
+                            PCI_CLASS_REVISION, &hdspm->firmware_rev);
+
+       strcpy(card->driver, "HDSPM");
+       strcpy(card->mixername, "Xilinx FPGA");
+       hdspm->card_name = "RME HDSPM MADI";
+
+       if ((err = pci_enable_device(pci)) < 0)
+               return err;
+
+       pci_set_master(hdspm->pci);
+
+       if ((err = pci_request_regions(pci, "hdspm")) < 0)
+               return err;
+
+       hdspm->port = pci_resource_start(pci, 0);
+       io_extent = pci_resource_len(pci, 0);
+
+       snd_printdd("grabbed memory region 0x%lx-0x%lx\n",
+                  hdspm->port, hdspm->port + io_extent - 1);
+
+
+       if ((hdspm->iobase = ioremap_nocache(hdspm->port, io_extent)) == NULL) {
+               snd_printk(KERN_ERR "HDSPM: unable to remap region 0x%lx-0x%lx\n",
+                          hdspm->port, hdspm->port + io_extent - 1);
+               return -EBUSY;
+       }
+       snd_printdd("remapped region (0x%lx) 0x%lx-0x%lx\n",
+                  (unsigned long)hdspm->iobase, hdspm->port,
+                  hdspm->port + io_extent - 1);
+
+       if (request_irq(pci->irq, snd_hdspm_interrupt,
+                       SA_INTERRUPT | SA_SHIRQ, "hdspm",
+                       (void *) hdspm)) {
+               snd_printk(KERN_ERR "HDSPM: unable to use IRQ %d\n", pci->irq);
+               return -EBUSY;
+       }
+
+       snd_printdd("use IRQ %d\n", pci->irq);
+
+       hdspm->irq = pci->irq;
+       hdspm->precise_ptr = precise_ptr;
+
+       hdspm->monitor_outs = enable_monitor;
+
+       snd_printdd("kmalloc Mixer memory of %d Bytes\n",
+                  sizeof(hdspm_mixer_t));
+       if ((hdspm->mixer =
+            (hdspm_mixer_t *) kmalloc(sizeof(hdspm_mixer_t), GFP_KERNEL))
+           == NULL) {
+               snd_printk(KERN_ERR "HDSPM: unable to kmalloc Mixer memory of %d Bytes\n",
+                          (int)sizeof(hdspm_mixer_t));
+               return err;
+       }
+
+       hdspm->ss_channels = MADI_SS_CHANNELS;
+       hdspm->ds_channels = MADI_DS_CHANNELS;
+       hdspm->qs_channels = MADI_QS_CHANNELS;
+
+       snd_printdd("create alsa devices.\n");
+       if ((err = snd_hdspm_create_alsa_devices(card, hdspm)) < 0)
+               return err;
+
+       snd_hdspm_initialize_midi_flush(hdspm);
+
+       return 0;
+}
+
+static int snd_hdspm_free(hdspm_t * hdspm)
+{
+
+       if (hdspm->port) {
+
+               /* stop th audio, and cancel all interrupts */
+               hdspm->control_register &=
+                   ~(HDSPM_Start | HDSPM_AudioInterruptEnable
+                     | HDSPM_Midi0InterruptEnable |
+                     HDSPM_Midi1InterruptEnable);
+               hdspm_write(hdspm, HDSPM_controlRegister,
+                           hdspm->control_register);
+       }
+
+       if (hdspm->irq >= 0)
+               free_irq(hdspm->irq, (void *) hdspm);
+
+
+       if (hdspm->mixer)
+               kfree(hdspm->mixer);
+
+       if (hdspm->iobase)
+               iounmap(hdspm->iobase);
+
+       snd_hdspm_memory_free(hdspm);
+
+       if (hdspm->port)
+               pci_release_regions(hdspm->pci);
+
+       pci_disable_device(hdspm->pci);
+       return 0;
+}
+
+static void snd_hdspm_card_free(snd_card_t * card)
+{
+       hdspm_t *hdspm = (hdspm_t *) card->private_data;
+
+       if (hdspm)
+               snd_hdspm_free(hdspm);
+}
+
+static int __devinit snd_hdspm_probe(struct pci_dev *pci,
+                                    const struct pci_device_id *pci_id)
+{
+       static int dev;
+       hdspm_t *hdspm;
+       snd_card_t *card;
+       int err;
+
+       if (dev >= SNDRV_CARDS)
+               return -ENODEV;
+       if (!enable[dev]) {
+               dev++;
+               return -ENOENT;
+       }
+
+       if (!(card = snd_card_new(index[dev], id[dev],
+                                 THIS_MODULE, sizeof(hdspm_t))))
+               return -ENOMEM;
+
+       hdspm = (hdspm_t *) card->private_data;
+       card->private_free = snd_hdspm_card_free;
+       hdspm->dev = dev;
+       hdspm->pci = pci;
+
+       if ((err =
+            snd_hdspm_create(card, hdspm, precise_ptr[dev],
+                             enable_monitor[dev])) < 0) {
+               snd_card_free(card);
+               return err;
+       }
+
+       strcpy(card->shortname, "HDSPM MADI");
+       sprintf(card->longname, "%s at 0x%lx, irq %d", hdspm->card_name,
+               hdspm->port, hdspm->irq);
+
+       if ((err = snd_card_register(card)) < 0) {
+               snd_card_free(card);
+               return err;
+       }
+
+       pci_set_drvdata(pci, card);
+
+       dev++;
+       return 0;
+}
+
+static void __devexit snd_hdspm_remove(struct pci_dev *pci)
+{
+       snd_card_free(pci_get_drvdata(pci));
+       pci_set_drvdata(pci, NULL);
+}
+
+static struct pci_driver driver = {
+       .name = "RME Hammerfall DSP MADI",
+       .id_table = snd_hdspm_ids,
+       .probe = snd_hdspm_probe,
+       .remove = __devexit_p(snd_hdspm_remove),
+};
+
+
+static int __init alsa_card_hdspm_init(void)
+{
+       return pci_register_driver(&driver);
+}
+
+static void __exit alsa_card_hdspm_exit(void)
+{
+       pci_unregister_driver(&driver);
+}
+
+module_init(alsa_card_hdspm_init)
+module_exit(alsa_card_hdspm_exit)