Changeset 281 for GPL/branches/alsa-resync1/alsa-kernel/pci

Timestamp:

Jan 23, 2008, 7:05:10 AM (18 years ago)

Author:

Brendan Oakley

Message:

Merged to ALSA 1.0.1

Location:

GPL/branches/alsa-resync1/alsa-kernel/pci

Files:

• als4000.c (modified) (1 diff)
• cmipci.c (modified) (4 diffs)
• ice1712/aureon.c (modified) (3 diffs)
• ice1712/delta.c (modified) (3 diffs)
• ice1712/ice1712.c (modified) (5 diffs)
• ice1712/ice1712.h (modified) (1 diff)
• ice1712/ice1724.c (modified) (7 diffs)
• korg1212/korg1212.c (modified) (1 diff)
• rme96.c (modified) (1 diff)
• rme9652/hdsp.c (modified) (104 diffs)
• rme9652/rme9652.c (modified) (2 diffs)
• sonicvibes.c (modified) (2 diffs)
• ymfpci/ymfpci.c (modified) (8 diffs)

GPL/branches/alsa-resync1/alsa-kernel/pci/als4000.c

@@ -654 +654 @@
         /* disable all legacy ISA stuff except for joystick */
 #ifdef SUPPORT_JOYSTICK
-        if (joystick_port[dev] > 0 &&
-            (acard->res_joystick = request_region(joystick_port[dev], 8, "ALS4000 gameport")) != NULL)
+        if (joystick_port[dev] == 1) {
+                /* auto-detect */
+                long p;
+                for (p = 0x200; p <= 0x218; p += 8) {
+                        if ((acard->res_joystick = request_region(p, 8, "ALS4000 gameport")) != NULL) {
+                                joystick_port[dev] = p;
+                                break;
+                        }
+                }
+        } else if (joystick_port[dev] > 0)
+                acard->res_joystick = request_region(joystick_port[dev], 8, "ALS4000 gameport");
+        if (acard->res_joystick)
                 joystick = joystick_port[dev];
+        else
+                joystick = 0;
 #endif
         snd_als4000_set_addr(gcr, 0, 0, 0, joystick);

GPL/branches/alsa-resync1/alsa-kernel/pci/cmipci.c

@@ -72 +72 @@
 MODULE_PARM(mpu_port, "1-" __MODULE_STRING(SNDRV_CARDS) "l");
 MODULE_PARM_DESC(mpu_port, "MPU-401 port.");
-MODULE_PARM_SYNTAX(mpu_port, SNDRV_ENABLED ",allows:{{-1},{0x330},{0x320},{0x310},{0x300}},dialog:list");
+MODULE_PARM_SYNTAX(mpu_port, SNDRV_ENABLED ",allows:{{0},{0x330},{0x320},{0x310},{0x300}},dialog:list");
 MODULE_PARM(fm_port, "1-" __MODULE_STRING(SNDRV_CARDS) "l");
 MODULE_PARM_DESC(fm_port, "FM port.");
-MODULE_PARM_SYNTAX(fm_port, SNDRV_ENABLED ",allows:{{-1},{0x388},{0x3c8},{0x3e0},{0x3e8}},dialog:list");
+MODULE_PARM_SYNTAX(fm_port, SNDRV_ENABLED ",allows:{{0},{0x388},{0x3c8},{0x3e0},{0x3e8}},dialog:list");
 #ifdef DO_SOFT_AC3
 MODULE_PARM(soft_ac3, "1-" __MODULE_STRING(SNDRV_CARDS) "l");
@@ -82 +82 @@
 #endif
 #ifdef SUPPORT_JOYSTICK
-MODULE_PARM(joystick, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
-MODULE_PARM_DESC(joystick, "Enable joystick.");
-MODULE_PARM_SYNTAX(joystick, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC);
+MODULE_PARM(joystick_port, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
+MODULE_PARM_DESC(joystick_port, "Joystick port address.");
+MODULE_PARM_SYNTAX(joystick_port, SNDRV_ENABLED ",allows:{{0},{1},{0x200},{0x201}},dialog:list");
 #endif
 
@@ -355 +355 @@
 #define CM_EXTENT_MIDI    0x2
 #define CM_EXTENT_SYNTH   0x4
-
-/* fixed legacy joystick address */
-#define CM_JOYSTICK_ADDR        0x200
   
 
@@ -2984 +2981 @@
 
 #ifdef SUPPORT_JOYSTICK
-        if (joystick[dev] &&
-            (cm->res_joystick = request_region(CM_JOYSTICK_ADDR, 8, "CMIPCI gameport")) != NULL) {
-                cm->gameport.io = CM_JOYSTICK_ADDR;
+        if (joystick_port[dev] > 0) {
+                if (joystick_port[dev] == 1) { /* auto-detect */
+                        static int ports[] = { 0x200, 0x201, 0 };
+                        int i;
+                        for (i = 0; ports[i]; i++) {
+                                joystick_port[dev] = ports[i];
+                                cm->res_joystick = request_region(ports[i], 8, "CMIPCI gameport");
+                                if (cm->res_joystick)
+                                        break;
+                        }
+                } else {
+                        cm->res_joystick = request_region(joystick_port[dev], 8, "CMIPCI gameport");
+                }
+        }
+        if (cm->res_joystick) {
+                cm->gameport.io = joystick_port[dev];
                 snd_cmipci_set_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);
                 gameport_register_port(&cm->gameport);
-        } else
+        } else {
+                if (joystick_port[dev] > 0)
+                        printk(KERN_WARNING "cmipci: cannot reserve joystick ports\n");
                 snd_cmipci_clear_bit(cm, CM_REG_FUNCTRL1, CM_JYSTK_EN);
+        }
 #endif
     *rcmipci = cm;

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/aureon.c

@@ -186 +186 @@
                         change = 0;
                 else
-                        wm_put(ice, idx, nvol | 0x100);
+                        wm_put(ice, idx, nvol | 0x180); /* update on zero detect */
         }
         snd_ice1712_restore_gpio_status(ice);
@@ -367 +367 @@
 {
         static unsigned short wm_inits[] = {
+                /* These come first to reduce init pop noise */
+                0x1b, 0x000,            /* ADC Mux */
+                0x1c, 0x009,            /* Out Mux1 */
+                0x1d, 0x009,            /* Out Mux2 */
+
+                0x18, 0x000,            /* All power-up */
+
                 0x16, 0x122,            /* I2S, normal polarity, 24bit */
                 0x17, 0x022,            /* 256fs, slave mode */
-                0x18, 0x000,            /* All power-up */
                 0x00, 0,                /* DAC1 analog mute */
                 0x01, 0,                /* DAC2 analog mute */
@@ -394 +400 @@
                 0x19, 0x000,            /* -12dB ADC/L */
                 0x1a, 0x000,            /* -12dB ADC/R */
-                0x1b, 0x000,            /* ADC Mux */
-                0x1c, 0x009,            /* Out Mux1 */
-                0x1d, 0x009,            /* Out Mux2 */
         };
         static unsigned short cs_inits[] = {

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/delta.c

@@ -258 +258 @@
 
 /*
+ * change the DFS bit according rate for Delta1010
+ */
+static void delta_1010_set_rate_val(ice1712_t *ice, unsigned int rate)
+{
+        unsigned char tmp, tmp2;
+
+        if (rate == 0)  /* no hint - S/PDIF input is master, simply return */
+                return;
+
+        down(&ice->gpio_mutex);
+        tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
+        tmp2 = tmp & ~ICE1712_DELTA_DFS;
+        if (rate > 48000)
+                tmp2 |= ICE1712_DELTA_DFS;
+        if (tmp != tmp2)
+                snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp2);
+        up(&ice->gpio_mutex);
+}
+
+/*
  * change the rate of AK4524 on Delta 44/66, AP, 1010LT
  */
@@ -272 +292 @@
         tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
         up(&ice->gpio_mutex);
-        tmp2 = tmp;
-        tmp2 &= ~ICE1712_DELTA_DFS; 
+        tmp2 = tmp & ~ICE1712_DELTA_DFS; 
         if (rate > 48000)
                 tmp2 |= ICE1712_DELTA_DFS;
@@ -455 +474 @@
                 break;
         case ICE1712_SUBDEVICE_DELTA1010:
+                ice->gpio.set_pro_rate = delta_1010_set_rate_val;
+                break;
         case ICE1712_SUBDEVICE_DELTADIO2496:
+                ice->gpio.set_pro_rate = delta_1010_set_rate_val;
+                /* fall thru */
         case ICE1712_SUBDEVICE_DELTA66:
                 ice->spdif.ops.open = delta_open_spdif;

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1712.c

@@ -1048 +1048 @@
         spin_unlock_irqrestore(&ice->reg_lock, flags);
 
+        if (ice->gpio.set_pro_rate)
+                ice->gpio.set_pro_rate(ice, rate);
         for (i = 0; i < ice->akm_codecs; i++) {
                 if (ice->akm[i].ops.set_rate_val)
@@ -1451 +1453 @@
 
         if (ice_has_con_ac97(ice)) {
+                ac97_bus_t bus, *pbus;
                 ac97_t ac97;
+                memset(&bus, 0, sizeof(bus));
+                bus.write = snd_ice1712_ac97_write;
+                bus.read = snd_ice1712_ac97_read;
+                if ((err = snd_ac97_bus(ice->card, &bus, &pbus)) < 0)
+                        return err;
                 memset(&ac97, 0, sizeof(ac97));
-                ac97.write = snd_ice1712_ac97_write;
-                ac97.read = snd_ice1712_ac97_read;
                 ac97.private_data = ice;
                 ac97.private_free = snd_ice1712_mixer_free_ac97;
-                if ((err = snd_ac97_mixer(ice->card, &ac97, &ice->ac97)) < 0)
+                if ((err = snd_ac97_mixer(pbus, &ac97, &ice->ac97)) < 0)
                         printk(KERN_WARNING "ice1712: cannot initialize ac97 for consumer, skipped\n");
                 else {
@@ -1467 +1473 @@
 
         if (! (ice->eeprom.data[ICE_EEP1_ACLINK] & ICE1712_CFG_PRO_I2S)) {
+                ac97_bus_t bus, *pbus;
                 ac97_t ac97;
+                memset(&bus, 0, sizeof(bus));
+                bus.write = snd_ice1712_pro_ac97_write;
+                bus.read = snd_ice1712_pro_ac97_read;
+                if ((err = snd_ac97_bus(ice->card, &bus, &pbus)) < 0)
+                        return err;
                 memset(&ac97, 0, sizeof(ac97));
-                ac97.write = snd_ice1712_pro_ac97_write;
-                ac97.read = snd_ice1712_pro_ac97_read;
                 ac97.private_data = ice;
                 ac97.private_free = snd_ice1712_mixer_free_ac97;
-                if ((err = snd_ac97_mixer(ice->card, &ac97, &ice->ac97)) < 0)
+                if ((err = snd_ac97_mixer(pbus, &ac97, &ice->ac97)) < 0)
                         printk(KERN_WARNING "ice1712: cannot initialize pro ac97, skipped\n");
                 else
@@ -1534 +1544 @@
 
         if (! snd_card_proc_new(ice->card, "ice1712", &entry))
-                snd_info_set_text_ops(entry, ice, snd_ice1712_proc_read);
+                snd_info_set_text_ops(entry, ice, 1024, snd_ice1712_proc_read);
 }
 
@@ -2358 +2368 @@
                 return -ENXIO;
         }
-        pci_set_dma_mask(pci, 0x0fffffff);
+        pci_set_consistent_dma_mask(pci, 0x0fffffff);
 
         ice = snd_magic_kcalloc(ice1712_t, 0, GFP_KERNEL);

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1712.h

@@ -354 +354 @@
                 void (*set_data)(ice1712_t *ice, unsigned int data);
                 unsigned int (*get_data)(ice1712_t *ice);
+                /* misc operators - move to another place? */
+                void (*set_pro_rate)(ice1712_t *ice, unsigned int rate);
         } gpio;
         struct semaphore gpio_mutex;

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ice1724.c

@@ -44 +44 @@
 #include "revo.h"
 #include "aureon.h"
+#include "prodigy.h"
+
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
@@ -53 +55 @@
                AMP_AUDIO2000_DEVICE_DESC
                AUREON_DEVICE_DESC
+               PRODIGY_DEVICE_DESC
                 "{VIA,VT1724},"
                 "{ICEnsemble,Generic ICE1724},"
@@ -909 +912 @@
 
         if (! (ice->eeprom.data[ICE_EEP2_ACLINK] & VT1724_CFG_PRO_I2S)) {
+                ac97_bus_t bus, *pbus;
                 ac97_t ac97;
                 /* cold reset */
@@ -915 +919 @@
                 outb(inb(ICEMT1724(ice, AC97_CMD)) & ~0x80, ICEMT1724(ice, AC97_CMD));
 
+                memset(&bus, 0, sizeof(bus));
+                bus.write = snd_vt1724_ac97_write;
+                bus.read = snd_vt1724_ac97_read;
+                if ((err = snd_ac97_bus(ice->card, &bus, &pbus)) < 0)
+                        return err;
                 memset(&ac97, 0, sizeof(ac97));
-                ac97.write = snd_vt1724_ac97_write;
-                ac97.read = snd_vt1724_ac97_read;
                 ac97.private_data = ice;
-                if ((err = snd_ac97_mixer(ice->card, &ac97, &ice->ac97)) < 0)
+                if ((err = snd_ac97_mixer(pbus, &ac97, &ice->ac97)) < 0)
                         printk(KERN_WARNING "ice1712: cannot initialize pro ac97, skipped\n");
                 else
@@ -976 +983 @@
 
         if (! snd_card_proc_new(ice->card, "ice1724", &entry))
-                snd_info_set_text_ops(entry, ice, snd_vt1724_proc_read);
+                snd_info_set_text_ops(entry, ice, 1024, snd_vt1724_proc_read);
 }
 
@@ -1577 +1584 @@
         snd_vt1724_amp_cards, 
         snd_vt1724_aureon_cards,
+        snd_vt1724_prodigy_cards,
         0,
 };
@@ -1794 +1802 @@
         if ((err = pci_enable_device(pci)) < 0)
                 return err;
-        pci_set_dma_mask(pci, 0xffffffff); 
+        pci_set_consistent_dma_mask(pci, 0xffffffff); 
 
         ice = snd_magic_kcalloc(ice1712_t, 0, GFP_KERNEL);

GPL/branches/alsa-resync1/alsa-kernel/pci/korg1212/korg1212.c

@@ -2094 +2094 @@
 
         if (! snd_card_proc_new(korg1212->card, "korg1212", &entry))
-                snd_info_set_text_ops(entry, korg1212, snd_korg1212_proc_read);
+                snd_info_set_text_ops(entry, korg1212, 1024, snd_korg1212_proc_read);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/pci/rme96.c

@@ -1931 +1931 @@
 
         if (! snd_card_proc_new(rme96->card, "rme96", &entry))
-                snd_info_set_text_ops(entry, rme96, snd_rme96_proc_read);
+                snd_info_set_text_ops(entry, rme96, 1024, snd_rme96_proc_read);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/hdsp.c

@@ -71 +71 @@
 MODULE_CLASSES("{sound}");
 MODULE_DEVICES("{{RME Hammerfall-DSP},"
-                "{RME HDSP-9652}}");
+                "{RME HDSP-9652},"
+                "{RME HDSP-9632}}");
 
 #define HDSP_MAX_CHANNELS        26
+#define HDSP_MAX_DS_CHANNELS     14
+#define HDSP_MAX_QS_CHANNELS     8
 #define DIGIFACE_SS_CHANNELS     26
 #define DIGIFACE_DS_CHANNELS     14
@@ -80 +83 @@
 #define H9652_SS_CHANNELS        26
 #define H9652_DS_CHANNELS        14
+/* This does not include possible Analog Extension Boards
+   AEBs are detected at card initialization
+*/
+#define H9632_SS_CHANNELS        12
+#define H9632_DS_CHANNELS        8
+#define H9632_QS_CHANNELS        4
 
 /* Write registers. These are defined as byte-offsets from the iobase value.
@@ -123 +132 @@
 #define HDSP_inputRmsLevel      4868  /* 26 * 64 bit values */
 
-#define HDSP_IO_EXTENT     5192
+
+/* This is for H9652 cards
+   Peak values are read downward from the base
+   Rms values are read upward
+   There are rms values for the outputs too
+   26*3 values are read in ss mode
+   14*3 in ds mode, with no gap between values
+*/
+#define HDSP_9652_peakBase      7164    
+#define HDSP_9652_rmsBase       4096
+
+/* c.f. the hdsp_9632_meters_t struct */
+#define HDSP_9632_metersBase    4096
+
+#define HDSP_IO_EXTENT     7168
 
 /* control2 register bits */
@@ -139 +162 @@
 #define HDSP_RD_MULTIPLE        0x400
 #define HDSP_9652_ENABLE_MIXER  0x800
+#define HDSP_TDO                0x10000000
 
 #define HDSP_S_PROGRAM          (HDSP_PROGRAM|HDSP_CONFIG_MODE_0)
@@ -148 +172 @@
 #define HDSP_Latency0             (1<<1)  /* buffer size = 2^n where n is defined by Latency{2,1,0} */
 #define HDSP_Latency1             (1<<2)  /* [ see above ] */
-#define HDSP_Latency2             (1<<3)  /* ] see above ] */
+#define HDSP_Latency2             (1<<3)  /* [ see above ] */
 #define HDSP_ClockModeMaster      (1<<4)  /* 1=Master, 0=Slave/Autosync */
 #define HDSP_AudioInterruptEnable (1<<5)  /* what do you think ? */
-#define HDSP_Frequency0           (1<<6)  /* 0=44.1kHz/88.2kHz 1=48kHz/96kHz */
-#define HDSP_Frequency1           (1<<7)  /* 0=32kHz/64kHz */
+#define HDSP_Frequency0           (1<<6)  /* 0=44.1kHz/88.2kHz/176.4kHz 1=48kHz/96kHz/192kHz */
+#define HDSP_Frequency1           (1<<7)  /* 0=32kHz/64kHz/128kHz */
 #define HDSP_DoubleSpeed          (1<<8)  /* 0=normal speed, 1=double speed */
 #define HDSP_SPDIFProfessional    (1<<9)  /* 0=consumer, 1=professional */
@@ -162 +186 @@
 #define HDSP_SPDIFInputSelect1    (1<<15) 
 #define HDSP_SyncRef0             (1<<16) 
-#define HDSP_SyncRef1             (1<<17) 
+#define HDSP_SyncRef1             (1<<17)
+#define HDSP_AnalogExtensionBoard (1<<18) /* For H9632 cards */ 
+#define HDSP_XLRBreakoutCable     (1<<20) /* For H9632 cards */
 #define HDSP_Midi0InterruptEnable (1<<22)
 #define HDSP_Midi1InterruptEnable (1<<23)
 #define HDSP_LineOut              (1<<24)
+#define HDSP_ADGain0              (1<<25) /* From here : H9632 specific */
+#define HDSP_ADGain1              (1<<26)
+#define HDSP_DAGain0              (1<<27)
+#define HDSP_DAGain1              (1<<28)
+#define HDSP_PhoneGain0           (1<<29)
+#define HDSP_PhoneGain1           (1<<30)
+#define HDSP_QuadSpeed            (1<<31)
+
+#define HDSP_ADGainMask       (HDSP_ADGain0|HDSP_ADGain1)
+#define HDSP_ADGainMinus10dBV  HDSP_ADGainMask
+#define HDSP_ADGainPlus4dBu   (HDSP_ADGain0)
+#define HDSP_ADGainLowGain     0
+
+#define HDSP_DAGainMask         (HDSP_DAGain0|HDSP_DAGain1)
+#define HDSP_DAGainHighGain      HDSP_DAGainMask
+#define HDSP_DAGainPlus4dBu     (HDSP_DAGain0)
+#define HDSP_DAGainMinus10dBV    0
+
+#define HDSP_PhoneGainMask      (HDSP_PhoneGain0|HDSP_PhoneGain1)
+#define HDSP_PhoneGain0dB        HDSP_PhoneGainMask
+#define HDSP_PhoneGainMinus6dB  (HDSP_PhoneGain0)
+#define HDSP_PhoneGainMinus12dB  0
 
 #define HDSP_LatencyMask    (HDSP_Latency0|HDSP_Latency1|HDSP_Latency2)
-#define HDSP_FrequencyMask  (HDSP_Frequency0|HDSP_Frequency1|HDSP_DoubleSpeed)
+#define HDSP_FrequencyMask  (HDSP_Frequency0|HDSP_Frequency1|HDSP_DoubleSpeed|HDSP_QuadSpeed)
 
 #define HDSP_SPDIFInputMask    (HDSP_SPDIFInputSelect0|HDSP_SPDIFInputSelect1)
 #define HDSP_SPDIFInputADAT1    0
-#define HDSP_SPDIFInputCoaxial (HDSP_SPDIFInputSelect1)
-#define HDSP_SPDIFInputCDROM   (HDSP_SPDIFInputSelect0|HDSP_SPDIFInputSelect1)
+#define HDSP_SPDIFInputCoaxial (HDSP_SPDIFInputSelect0)
+#define HDSP_SPDIFInputCdrom   (HDSP_SPDIFInputSelect1)
+#define HDSP_SPDIFInputAES     (HDSP_SPDIFInputSelect0|HDSP_SPDIFInputSelect1)
 
 #define HDSP_SyncRefMask        (HDSP_SyncRef0|HDSP_SyncRef1|HDSP_SyncRef2)
-#define HDSP_SyncRef_ADAT1      0
+#define HDSP_SyncRef_ADAT1       0
 #define HDSP_SyncRef_ADAT2      (HDSP_SyncRef0)
 #define HDSP_SyncRef_ADAT3      (HDSP_SyncRef1)
@@ -185 +234 @@
 /* Sample Clock Sources */
 
-#define HDSP_CLOCK_SOURCE_AUTOSYNC         0
-#define HDSP_CLOCK_SOURCE_INTERNAL_32KHZ   1
-#define HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ 2
-#define HDSP_CLOCK_SOURCE_INTERNAL_48KHZ   3
-#define HDSP_CLOCK_SOURCE_INTERNAL_64KHZ   4
-#define HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ 5
-#define HDSP_CLOCK_SOURCE_INTERNAL_96KHZ   6
+#define HDSP_CLOCK_SOURCE_AUTOSYNC           0
+#define HDSP_CLOCK_SOURCE_INTERNAL_32KHZ     1
+#define HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ   2
+#define HDSP_CLOCK_SOURCE_INTERNAL_48KHZ     3
+#define HDSP_CLOCK_SOURCE_INTERNAL_64KHZ     4
+#define HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ   5
+#define HDSP_CLOCK_SOURCE_INTERNAL_96KHZ     6
+#define HDSP_CLOCK_SOURCE_INTERNAL_128KHZ    7
+#define HDSP_CLOCK_SOURCE_INTERNAL_176_4KHZ  8
+#define HDSP_CLOCK_SOURCE_INTERNAL_192KHZ    9
 
 /* Preferred sync reference choices - used by "pref_sync_ref" control switch */
 
 #define HDSP_SYNC_FROM_WORD      0
-#define HDSP_SYNC_FROM_ADAT_SYNC 1
-#define HDSP_SYNC_FROM_SPDIF     2
-#define HDSP_SYNC_FROM_ADAT1     3
+#define HDSP_SYNC_FROM_SPDIF     1
+#define HDSP_SYNC_FROM_ADAT1     2
+#define HDSP_SYNC_FROM_ADAT_SYNC 3
 #define HDSP_SYNC_FROM_ADAT2     4
 #define HDSP_SYNC_FROM_ADAT3     5
@@ -220 +272 @@
 /* Possible sources of S/PDIF input */
 
-#define HDSP_SPDIFIN_OPTICAL 0  /* optical  (ADAT1) */
-#define HDSP_SPDIFIN_COAXIAL 1  /* coaxial  (RCA) */
-#define HDSP_SPDIFIN_INTERN  2  /* internal (CDROM) */
+#define HDSP_SPDIFIN_OPTICAL  0 /* optical  (ADAT1) */
+#define HDSP_SPDIFIN_COAXIAL  1 /* coaxial (RCA) */
+#define HDSP_SPDIFIN_INTERNAL 2 /* internal (CDROM) */
+#define HDSP_SPDIFIN_AES      3 /* xlr for H9632 (AES)*/
 
 #define HDSP_Frequency32KHz    HDSP_Frequency0
 #define HDSP_Frequency44_1KHz  HDSP_Frequency1
-#define HDSP_Frequency48KHz   (HDSP_Frequency1|HDSP_Frequency0)
-#define HDSP_Frequency64KHz   (HDSP_DoubleSpeed|HDSP_Frequency0)
-#define HDSP_Frequency88_2KHz (HDSP_DoubleSpeed|HDSP_Frequency1)
-#define HDSP_Frequency96KHz   (HDSP_DoubleSpeed|HDSP_Frequency1|HDSP_Frequency0)
+#define HDSP_Frequency48KHz    (HDSP_Frequency1|HDSP_Frequency0)
+#define HDSP_Frequency64KHz    (HDSP_DoubleSpeed|HDSP_Frequency0)
+#define HDSP_Frequency88_2KHz  (HDSP_DoubleSpeed|HDSP_Frequency1)
+#define HDSP_Frequency96KHz    (HDSP_DoubleSpeed|HDSP_Frequency1|HDSP_Frequency0)
+/* For H9632 cards */
+#define HDSP_Frequency128KHz   (HDSP_QuadSpeed|HDSP_DoubleSpeed|HDSP_Frequency0)
+#define HDSP_Frequency176_4KHz (HDSP_QuadSpeed|HDSP_DoubleSpeed|HDSP_Frequency1)
+#define HDSP_Frequency192KHz   (HDSP_QuadSpeed|HDSP_DoubleSpeed|HDSP_Frequency1|HDSP_Frequency0)
 
 #define hdsp_encode_latency(x)       (((x)<<1) & HDSP_LatencyMask)
@@ -240 +297 @@
 
 #define HDSP_audioIRQPending    (1<<0)
-#define HDSP_Lock2              (1<<1)
+#define HDSP_Lock2              (1<<1)     /* this is for Digiface and H9652 */
+#define HDSP_spdifFrequency3    HDSP_Lock2 /* this is for H9632 only */
 #define HDSP_Lock1              (1<<2)
 #define HDSP_Lock0              (1<<3)
@@ -258 +316 @@
 #define HDSP_BufferID           (1<<26)
 #define HDSP_TimecodeSync       (1<<27)
-#define HDSP_CIN                (1<<28)
-#define HDSP_midi0IRQPending    (1<<30) /* notice the gap at bit 29 */
+#define HDSP_AEBO               (1<<28) /* H9632 specific Analog Extension Boards */
+#define HDSP_AEBI               (1<<29) /* 0 = present, 1 = absent */
+#define HDSP_midi0IRQPending    (1<<30) 
 #define HDSP_midi1IRQPending    (1<<31)
 
@@ -271 +330 @@
 #define HDSP_spdifFrequency88_2KHz (HDSP_spdifFrequency0|HDSP_spdifFrequency2)
 #define HDSP_spdifFrequency96KHz   (HDSP_spdifFrequency2|HDSP_spdifFrequency1)
+
+/* This is for H9632 cards */
+#define HDSP_spdifFrequency128KHz   HDSP_spdifFrequencyMask
+#define HDSP_spdifFrequency176_4KHz HDSP_spdifFrequency3
+#define HDSP_spdifFrequency192KHz   (HDSP_spdifFrequency3|HDSP_spdifFrequency0)
 
 /* Status2 Register bits */
@@ -295 +359 @@
 #define HDSP_systemFrequency88_2 (HDSP_inp_freq0|HDSP_inp_freq2)
 #define HDSP_systemFrequency96   (HDSP_inp_freq1|HDSP_inp_freq2)
+/* FIXME : more values for 9632 cards ? */
 
 #define HDSP_SelSyncRefMask        (HDSP_SelSyncRef0|HDSP_SelSyncRef1|HDSP_SelSyncRef2)
@@ -342 +407 @@
 #define HDSP_DMA_AREA_KILOBYTES (HDSP_DMA_AREA_BYTES/1024)
 
-typedef struct _hdsp          hdsp_t;
-typedef struct _hdsp_midi     hdsp_midi_t;
+typedef struct _hdsp             hdsp_t;
+typedef struct _hdsp_midi        hdsp_midi_t;
+typedef struct _hdsp_9632_meters hdsp_9632_meters_t;
+
+struct _hdsp_9632_meters {
+    u32 input_peak[16];
+    u32 playback_peak[16];
+    u32 output_peak[16];
+    u32 xxx_peak[16];
+    u32 padding[64];
+    u32 input_rms_low[16];
+    u32 playback_rms_low[16];
+    u32 output_rms_low[16];
+    u32 xxx_rms_low[16];
+    u32 input_rms_high[16];
+    u32 playback_rms_high[16];
+    u32 output_rms_high[16];
+    u32 xxx_rms_high[16];
+};
 
 struct _hdsp_midi {
@@ -374 +456 @@
         u32                   firmware_cache[24413]; /* this helps recover from accidental iobox power failure */
         size_t                period_bytes;          /* guess what this is */
-        unsigned char         ds_channels;
-        unsigned char         ss_channels;          /* different for multiface/digiface */
+        unsigned char         max_channels;
+        unsigned char         qs_in_channels;        /* quad speed mode for H9632 */
+        unsigned char         ds_in_channels;
+        unsigned char         ss_in_channels;       /* different for multiface/digiface */
+        unsigned char         qs_out_channels;      
+        unsigned char         ds_out_channels;
+        unsigned char         ss_out_channels;
         void                 *capture_buffer_unaligned;  /* original buffer addresses */
         void                 *playback_buffer_unaligned; /* original buffer addresses */
@@ -386 +473 @@
         int                   running;
         int                   passthru;              /* non-zero if doing pass-thru */
-        int                   last_spdif_sample_rate;/* for information reporting */
-        int                   last_external_sample_rate;
-        int                   last_internal_sample_rate;
         int                   system_sample_rate;
         char                 *channel_map;
@@ -401 +485 @@
         struct pci_dev       *pci;
         snd_kcontrol_t       *spdif_ctl;
-        snd_kcontrol_t       *playback_mixer_ctls[HDSP_MAX_CHANNELS];
         unsigned short        mixer_matrix[HDSP_MATRIX_MIXER_SIZE];
 };
@@ -425 +508 @@
         /* SPDIF */
         24, 25,
-        -1, -1, -1, -1, -1, -1, -1, -1, 
+        -1, -1, -1, -1, -1, -1, -1, -1
 };
 
@@ -434 +517 @@
         24, 25,
         /* others don't exist */
-        -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_H9632_ss[HDSP_MAX_CHANNELS] = {
+        /* ADAT channels */
+        0, 1, 2, 3, 4, 5, 6, 7,
+        /* SPDIF */
+        8, 9,
+        /* Analog */
+        10, 11, 
+        /* AO4S-192 and AI4S-192 extension boards */
+        12, 13, 14, 15,
+        /* others don't exist */
+        -1, -1, -1, -1, -1, -1, -1, -1, 
+        -1, -1
+};
+
+static char channel_map_H9632_ds[HDSP_MAX_CHANNELS] = {
+        /* ADAT */
+        1, 3, 5, 7,
+        /* SPDIF */
+        8, 9,
+        /* Analog */
+        10, 11, 
+        /* AO4S-192 and AI4S-192 extension boards */
+        12, 13, 14, 15,
+        /* others don't exist */
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1
+};
+
+static char channel_map_H9632_qs[HDSP_MAX_CHANNELS] = {
+        /* ADAT is disabled in this mode */
+        /* SPDIF */
+        8, 9,
+        /* Analog */
+        10, 11,
+        /* AO4S-192 and AI4S-192 extension boards */
+        12, 13, 14, 15,
+        /* others don't exist */
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1, -1, -1, -1, -1, -1, -1,
+        -1, -1
 };
 
@@ -494 +619 @@
 static inline void snd_hdsp_initialize_channels (hdsp_t *hdsp);
 static inline int hdsp_fifo_wait(hdsp_t *hdsp, int count, int timeout);
-static int hdsp_update_simple_mixer_controls(hdsp_t *hdsp);
 static int hdsp_autosync_ref(hdsp_t *hdsp);
 static int snd_hdsp_set_defaults(hdsp_t *hdsp);
+static inline void snd_hdsp_9652_enable_mixer (hdsp_t *hdsp);
 
 static inline int hdsp_playback_to_output_key (hdsp_t *hdsp, int in, int out)
@@ -503 +628 @@
         case 0xa:
                 return (64 * out) + (32 + (in));
+        case 0x96:
+                return (32 * out) + (16 + (in));
         default:
                 return (52 * out) + (26 + (in));
@@ -513 +640 @@
         case 0xa:
                 return (64 * out) + in;
+        case 0x96:
+                return (32 * out) + in;
         default:
                 return (52 * out) + in;
@@ -531 +660 @@
 {
 
-        if (hdsp->io_type == H9652) return 0;
+        if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return 0;
         if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_ConfigError) {
                 snd_printk ("Hammerfall-DSP: no Digiface or Multiface connected!\n");
@@ -567 +696 @@
                         }
                 }
+
+                if ((1000 / HZ) < 3000) {
+                        set_current_state(TASK_UNINTERRUPTIBLE);
+                        schedule_timeout((3000 * HZ + 999) / 1000);
+                } else {
+                        mdelay(3000);
+                }
                 
                 if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
@@ -581 +717 @@
                 snd_printk ("finished firmware loading\n");
                 
-                if ((1000 / HZ) < 3000) {
-                        set_current_state(TASK_UNINTERRUPTIBLE);
-                        schedule_timeout((3000 * HZ + 999) / 1000);
-                } else {
-                        mdelay(3000);
-                }
         }
         if (hdsp->state & HDSP_InitializationComplete) {
@@ -645 +775 @@
 static inline int hdsp_check_for_firmware (hdsp_t *hdsp)
 {
-        if (hdsp->io_type == H9652) return 0;
+        if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return 0;
         if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
                 snd_printk("firmware not present.\n");
@@ -694 +824 @@
         if (addr >= HDSP_MATRIX_MIXER_SIZE)
                 return -1;
-                
-        if (hdsp->io_type == H9652) {
+        
+        if (hdsp->io_type == H9652 || hdsp->io_type == H9632) {
 
                 /* from martin björnsen:
@@ -709 +839 @@
                 */
 
+                if (hdsp->io_type == H9632 && addr >= 512) {
+                        return 0;
+                }
+
+                if (hdsp->io_type == H9652 && addr >= 1352) {
+                        return 0;
+                }
+
                 hdsp->mixer_matrix[addr] = data;
 
+                
                 /* `addr' addresses a 16-bit wide address, but
                    the address space accessed via hdsp_write
@@ -718 +857 @@
                    to access 0 to 2703 ...
                 */
-
-                hdsp_write (hdsp, 4096 + (addr*2), 
+                ad = addr/2;
+        
+                hdsp_write (hdsp, 4096 + (ad*4), 
                             (hdsp->mixer_matrix[(addr&0x7fe)+1] << 16) + 
                             hdsp->mixer_matrix[addr&0x7fe]);
@@ -788 +928 @@
         case HDSP_spdifFrequency88_2KHz: return 88200;
         case HDSP_spdifFrequency96KHz: return 96000;
+        case HDSP_spdifFrequency128KHz: 
+                if (hdsp->io_type == H9632) return 128000;
+                break;
+        case HDSP_spdifFrequency176_4KHz: 
+                if (hdsp->io_type == H9632) return 176400;
+                break;
+        case HDSP_spdifFrequency192KHz: 
+                if (hdsp->io_type == H9632) return 192000;
+                break;
         default:
-                snd_printk ("unknown spdif frequency status; bits = 0x%x, status = 0x%x\n", rate_bits, status);
-                return 0;
-        }
+                break;
+        }
+        snd_printk ("unknown spdif frequency status; bits = 0x%x, status = 0x%x\n", rate_bits, status);
+        return 0;
 }
 
@@ -869 +1019 @@
         int rate_bits;
 
-        /* ASSUMPTION: hdsp->lock is either help, or
+        /* ASSUMPTION: hdsp->lock is either held, or
            there is no need for it (e.g. during module
            initialization).
@@ -886 +1036 @@
                         if ((spdif_freq == external_freq*2) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1)) {
                                 snd_printk("Detected ADAT in double speed mode\n");
+                        } else if (hdsp->io_type == H9632 && (spdif_freq == external_freq*4) && (hdsp_autosync_ref(hdsp) >= HDSP_AUTOSYNC_FROM_ADAT1)) {
+                                snd_printk("Detected ADAT in quad speed mode\n");                       
                         } else if (rate != external_freq) {
                                 snd_printk("No AutoSync source for requested rate\n");
@@ -905 +1057 @@
            is to flag rate changes in the read/write routines.  */
 
+        if (rate > 96000 && hdsp->io_type != H9632) {
+                return -EINVAL;
+        }
+        
         switch (rate) {
         case 32000:
@@ -925 +1081 @@
                 break;
         case 64000:
-                if (current_rate <= 48000) {
+                if (current_rate <= 48000 || current_rate > 96000) {
                         reject_if_open = 1;
                 }
@@ -931 +1087 @@
                 break;
         case 88200:
-                if (current_rate <= 48000) {
+                if (current_rate <= 48000 || current_rate > 96000) {
                         reject_if_open = 1;
                 }
@@ -937 +1093 @@
                 break;
         case 96000:
-                if (current_rate <= 48000) {
+                if (current_rate <= 48000 || current_rate > 96000) {
                         reject_if_open = 1;
                 }
                 rate_bits = HDSP_Frequency96KHz;
+                break;
+        case 128000:
+                if (current_rate < 128000) {
+                        reject_if_open = 1;
+                }
+                rate_bits = HDSP_Frequency128KHz;
+                break;
+        case 176400:
+                if (current_rate < 128000) {
+                        reject_if_open = 1;
+                }
+                rate_bits = HDSP_Frequency176_4KHz;
+                break;
+        case 192000:
+                if (current_rate < 128000) {
+                        reject_if_open = 1;
+                }
+                rate_bits = HDSP_Frequency192KHz;
                 break;
         default:
@@ -947 +1121 @@
 
         if (reject_if_open && (hdsp->capture_pid >= 0 || hdsp->playback_pid >= 0)) {
-                snd_printk ("cannot change between single- and double-speed mode (capture PID = %d, playback PID = %d)\n",
+                snd_printk ("cannot change speed mode (capture PID = %d, playback PID = %d)\n",
                             hdsp->capture_pid,
                             hdsp->playback_pid);
@@ -957 +1131 @@
         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
 
-        if (rate > 48000) {
-                hdsp->channel_map = channel_map_ds;
+        if (rate >= 128000) {
+                hdsp->channel_map = channel_map_H9632_qs;
+        } else if (rate > 48000) {
+                if (hdsp->io_type == H9632) {
+                        hdsp->channel_map = channel_map_H9632_ds;
+                } else {
+                        hdsp->channel_map = channel_map_ds;
+                }
         } else {
                 switch (hdsp->io_type) {
@@ -968 +1148 @@
                         hdsp->channel_map = channel_map_df_ss;
                         break;
+                case H9632:
+                        hdsp->channel_map = channel_map_H9632_ss;
+                        break;
                 default:
                         /* should never happen */
@@ -975 +1158 @@
         
         hdsp->system_sample_rate = rate;
-        
-        if (reject_if_open) {
-                hdsp_update_simple_mixer_controls (hdsp);
-        }
 
         return 0;
@@ -995 +1174 @@
 
                 if (enable) {
-                        for (i = 0; i < 26; i++) {
+                        for (i = 0; i < hdsp->max_channels; i++) {
                                 hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,i,i), UNITY_GAIN);
                         }
                 } else {
-                        for (i = 0; i < 26; i++) {
+                        for (i = 0; i < hdsp->max_channels; i++) {
                                 hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,i,i), MINUS_INFINITY_GAIN);
                         }
@@ -1007 +1186 @@
                 int mapped_channel;
 
-                snd_assert(channel < HDSP_MAX_CHANNELS, return);
+                snd_assert(channel < hdsp->max_channels, return);
 
                 mapped_channel = hdsp->channel_map[channel];
@@ -1465 +1644 @@
 static int snd_hdsp_info_spdif_in(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
-        static char *texts[3] = {"ADAT1", "Coaxial", "Internal"};
+        static char *texts[4] = {"Optical", "Coaxial", "Internal", "AES"};
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
 
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = 3;
-        if (uinfo->value.enumerated.item > 2)
-                uinfo->value.enumerated.item = 2;
+        uinfo->value.enumerated.items = ((hdsp->io_type == H9632) ? 4 : 3);
+        if (uinfo->value.enumerated.item > ((hdsp->io_type == H9632) ? 3 : 2))
+                uinfo->value.enumerated.item = ((hdsp->io_type == H9632) ? 3 : 2);
         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
         return 0;
@@ -1493 +1673 @@
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
-        val = ucontrol->value.enumerated.item[0] % 3;
+        val = ucontrol->value.enumerated.item[0] % ((hdsp->io_type == H9632) ? 4 : 3);
         spin_lock_irqsave(&hdsp->lock, flags);
         change = val != hdsp_spdif_in(hdsp);
@@ -1706 +1886 @@
 static int snd_hdsp_info_spdif_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
-        static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None"};
+        static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"};
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = 7 ;
+        uinfo->value.enumerated.items = (hdsp->io_type == H9632) ? 10 : 7;
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
@@ -1738 +1920 @@
         case 96000:
                 ucontrol->value.enumerated.item[0] = 5;
+                break;
+        case 128000:
+                ucontrol->value.enumerated.item[0] = 7;
+                break;
+        case 176400:
+                ucontrol->value.enumerated.item[0] = 8;
+                break;
+        case 192000:
+                ucontrol->value.enumerated.item[0] = 9;
                 break;
         default:
@@ -1780 +1971 @@
 static int snd_hdsp_info_autosync_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
-        static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None"};  
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        static char *texts[] = {"32000", "44100", "48000", "64000", "88200", "96000", "None", "128000", "176400", "192000"};    
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = 7 ;
+        uinfo->value.enumerated.items = (hdsp->io_type == H9632) ? 10 : 7 ;
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
@@ -1813 +2005 @@
                 ucontrol->value.enumerated.item[0] = 5;
                 break;
+        case 128000:
+                ucontrol->value.enumerated.item[0] = 7;
+                break;
+        case 176400:
+                ucontrol->value.enumerated.item[0] = 8;
+                break;
+        case 192000:
+                ucontrol->value.enumerated.item[0] = 9;
+                break;  
         default:
                 ucontrol->value.enumerated.item[0] = 6;         
@@ -1884 +2085 @@
                 case 96000:
                         return 6;
+                case 128000:
+                        return 7;
+                case 176400:
+                        return 8;
+                case 192000:
+                        return 9;
                 default:
                         return 3;       
@@ -1898 +2105 @@
         case HDSP_CLOCK_SOURCE_AUTOSYNC:
                 if (hdsp_external_sample_rate(hdsp) != 0) {
-                    hdsp->control_register &= ~HDSP_ClockModeMaster;            
-                    hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
-                    return 0;
+                    if (!hdsp_set_rate(hdsp, hdsp_external_sample_rate(hdsp), 1)) {
+                        hdsp->control_register &= ~HDSP_ClockModeMaster;                
+                        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+                        return 0;
+                    }
                 }
                 return -1;
@@ -1921 +2130 @@
                 rate = 96000;
                 break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_128KHZ:
+                rate = 128000;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_176_4KHZ:
+                rate = 176400;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_192KHZ:
+                rate = 192000;
+                break;
         default:
                 rate = 48000;
@@ -1932 +2150 @@
 static int snd_hdsp_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" };
+        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 kHz", "Internal 176.4 kHz", "Internal 192.0 KHz" };
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
         
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = 7;
+        if (hdsp->io_type == H9632)
+            uinfo->value.enumerated.items = 10;
+        else
+            uinfo->value.enumerated.items = 7;  
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
@@ -1962 +2184 @@
         val = ucontrol->value.enumerated.item[0];
         if (val < 0) val = 0;
-        if (val > 6) val = 6;
+        if (hdsp->io_type == H9632) {
+            if (val > 9) val = 9;
+        } else {
+            if (val > 6) val = 6;
+        }
         spin_lock_irqsave(&hdsp->lock, flags);
         if (val != hdsp_clock_source(hdsp)) {
@@ -1969 +2195 @@
                 change = 0;
         }
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_DA_GAIN(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdsp_info_da_gain, \
+  .get = snd_hdsp_get_da_gain, \
+  .put = snd_hdsp_put_da_gain \
+}
+
+static int hdsp_da_gain(hdsp_t *hdsp)
+{
+        switch (hdsp->control_register & HDSP_DAGainMask) {
+        case HDSP_DAGainHighGain:
+                return 0;
+        case HDSP_DAGainPlus4dBu:
+                return 1;
+        case HDSP_DAGainMinus10dBV:
+                return 2;
+        default:
+                return 1;       
+        }
+}
+
+static int hdsp_set_da_gain(hdsp_t *hdsp, int mode)
+{
+        hdsp->control_register &= ~HDSP_DAGainMask;
+        switch (mode) {
+        case 0:
+                hdsp->control_register |= HDSP_DAGainHighGain;
+                break;
+        case 1:
+                hdsp->control_register |= HDSP_DAGainPlus4dBu;
+                break;
+        case 2:
+                hdsp->control_register |= HDSP_DAGainMinus10dBV;                
+                break;      
+        default:
+                return -1;
+
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_info_da_gain(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"Hi Gain", "+4 dBu", "-10 dbV"};
+        
+        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_hdsp_get_da_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_da_gain(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_da_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        int val;
+        
+        if (!snd_hdsp_use_is_exclusive(hdsp))
+                return -EBUSY;
+        val = ucontrol->value.enumerated.item[0];
+        if (val < 0) val = 0;
+        if (val > 2) val = 2;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        if (val != hdsp_da_gain(hdsp)) {
+                change = (hdsp_set_da_gain(hdsp, val) == 0) ? 1 : 0;
+        } else {
+                change = 0;
+        }
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_AD_GAIN(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdsp_info_ad_gain, \
+  .get = snd_hdsp_get_ad_gain, \
+  .put = snd_hdsp_put_ad_gain \
+}
+
+static int hdsp_ad_gain(hdsp_t *hdsp)
+{
+        switch (hdsp->control_register & HDSP_ADGainMask) {
+        case HDSP_ADGainMinus10dBV:
+                return 0;
+        case HDSP_ADGainPlus4dBu:
+                return 1;
+        case HDSP_ADGainLowGain:
+                return 2;
+        default:
+                return 1;       
+        }
+}
+
+static int hdsp_set_ad_gain(hdsp_t *hdsp, int mode)
+{
+        hdsp->control_register &= ~HDSP_ADGainMask;
+        switch (mode) {
+        case 0:
+                hdsp->control_register |= HDSP_ADGainMinus10dBV;
+                break;
+        case 1:
+                hdsp->control_register |= HDSP_ADGainPlus4dBu;          
+                break;
+        case 2:
+                hdsp->control_register |= HDSP_ADGainLowGain;           
+                break;      
+        default:
+                return -1;
+
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_info_ad_gain(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"-10 dBV", "+4 dBu", "Lo Gain"};
+        
+        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_hdsp_get_ad_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_ad_gain(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_ad_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        int val;
+        
+        if (!snd_hdsp_use_is_exclusive(hdsp))
+                return -EBUSY;
+        val = ucontrol->value.enumerated.item[0];
+        if (val < 0) val = 0;
+        if (val > 2) val = 2;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        if (val != hdsp_ad_gain(hdsp)) {
+                change = (hdsp_set_ad_gain(hdsp, val) == 0) ? 1 : 0;
+        } else {
+                change = 0;
+        }
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_PHONE_GAIN(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdsp_info_phone_gain, \
+  .get = snd_hdsp_get_phone_gain, \
+  .put = snd_hdsp_put_phone_gain \
+}
+
+static int hdsp_phone_gain(hdsp_t *hdsp)
+{
+        switch (hdsp->control_register & HDSP_PhoneGainMask) {
+        case HDSP_PhoneGain0dB:
+                return 0;
+        case HDSP_PhoneGainMinus6dB:
+                return 1;
+        case HDSP_PhoneGainMinus12dB:
+                return 2;
+        default:
+                return 0;       
+        }
+}
+
+static int hdsp_set_phone_gain(hdsp_t *hdsp, int mode)
+{
+        hdsp->control_register &= ~HDSP_PhoneGainMask;
+        switch (mode) {
+        case 0:
+                hdsp->control_register |= HDSP_PhoneGain0dB;
+                break;
+        case 1:
+                hdsp->control_register |= HDSP_PhoneGainMinus6dB;               
+                break;
+        case 2:
+                hdsp->control_register |= HDSP_PhoneGainMinus12dB;              
+                break;      
+        default:
+                return -1;
+
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_info_phone_gain(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"0 dB", "-6 dB", "-12 dB"};
+        
+        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_hdsp_get_phone_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_phone_gain(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_phone_gain(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        int val;
+        
+        if (!snd_hdsp_use_is_exclusive(hdsp))
+                return -EBUSY;
+        val = ucontrol->value.enumerated.item[0];
+        if (val < 0) val = 0;
+        if (val > 2) val = 2;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        if (val != hdsp_phone_gain(hdsp)) {
+                change = (hdsp_set_phone_gain(hdsp, val) == 0) ? 1 : 0;
+        } else {
+                change = 0;
+        }
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_XLR_BREAKOUT_CABLE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdsp_info_xlr_breakout_cable, \
+  .get = snd_hdsp_get_xlr_breakout_cable, \
+  .put = snd_hdsp_put_xlr_breakout_cable \
+}
+
+static int hdsp_xlr_breakout_cable(hdsp_t *hdsp)
+{
+        if (hdsp->control_register & HDSP_XLRBreakoutCable) {
+                return 1;
+        }
+        return 0;
+}
+
+static int hdsp_set_xlr_breakout_cable(hdsp_t *hdsp, int mode)
+{
+        if (mode) {
+                hdsp->control_register |= HDSP_XLRBreakoutCable;
+        } else {
+                hdsp->control_register &= ~HDSP_XLRBreakoutCable;
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_info_xlr_breakout_cable(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_hdsp_get_xlr_breakout_cable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_xlr_breakout_cable(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_xlr_breakout_cable(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        int val;
+        
+        if (!snd_hdsp_use_is_exclusive(hdsp))
+                return -EBUSY;
+        val = ucontrol->value.integer.value[0] & 1;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        change = (int)val != hdsp_xlr_breakout_cable(hdsp);
+        hdsp_set_xlr_breakout_cable(hdsp, val);
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+/* (De)activates old RME Analog Extension Board
+   These are connected to the internal ADAT connector
+   Switching this on desactivates external ADAT
+*/
+#define HDSP_AEB(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdsp_info_aeb, \
+  .get = snd_hdsp_get_aeb, \
+  .put = snd_hdsp_put_aeb \
+}
+
+static int hdsp_aeb(hdsp_t *hdsp)
+{
+        if (hdsp->control_register & HDSP_AnalogExtensionBoard) {
+                return 1;
+        }
+        return 0;
+}
+
+static int hdsp_set_aeb(hdsp_t *hdsp, int mode)
+{
+        if (mode) {
+                hdsp->control_register |= HDSP_AnalogExtensionBoard;
+        } else {
+                hdsp->control_register &= ~HDSP_AnalogExtensionBoard;
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_info_aeb(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_hdsp_get_aeb(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_aeb(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_aeb(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        int val;
+        
+        if (!snd_hdsp_use_is_exclusive(hdsp))
+                return -EBUSY;
+        val = ucontrol->value.integer.value[0] & 1;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        change = (int)val != hdsp_aeb(hdsp);
+        hdsp_set_aeb(hdsp, val);
         spin_unlock_irqrestore(&hdsp->lock, flags);
         return change;
@@ -2038 +2653 @@
 static int snd_hdsp_info_pref_sync_ref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
-        static char *texts[] = {"Word", "ADAT Sync", "IEC958", "ADAT1", "ADAT2", "ADAT3" };
+        static char *texts[] = {"Word", "IEC958", "ADAT1", "ADAT Sync", "ADAT2", "ADAT3" };
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
         
@@ -2051 +2666 @@
         case Multiface:
                 uinfo->value.enumerated.items = 4;
+                break;
+        case H9632:
+                uinfo->value.enumerated.items = 3;
+                break;
         default:
                 uinfo->value.enumerated.items = 0;
@@ -2087 +2706 @@
         case Multiface:
                 max = 4;
+                break;
+        case H9632:
+                max = 3;
                 break;
         default:
@@ -2298 +2920 @@
         source = ucontrol->value.integer.value[0];
         destination = ucontrol->value.integer.value[1];
-
-        if (source > 25) {
-                addr = hdsp_playback_to_output_key(hdsp,source-26,destination);
+        
+        if (source >= hdsp->max_channels) {
+                addr = hdsp_playback_to_output_key(hdsp,source-hdsp->max_channels,destination);
         } else {
                 addr = hdsp_input_to_output_key(hdsp,source, destination);
@@ -2327 +2949 @@
         destination = ucontrol->value.integer.value[1];
 
-        if (source > 25) {
-                addr = hdsp_playback_to_output_key(hdsp,source-26, destination);
+        if (source >= hdsp->max_channels) {
+                addr = hdsp_playback_to_output_key(hdsp,source-hdsp->max_channels, destination);
         } else {
                 addr = hdsp_input_to_output_key(hdsp,source, destination);
@@ -2334 +2956 @@
 
         gain = ucontrol->value.integer.value[2];
-
-        spin_lock_irqsave(&hdsp->lock, flags);
-        change = gain != hdsp_read_gain(hdsp, addr);
-        if (change)
-                hdsp_write_gain(hdsp, addr, gain);
-        spin_unlock_irqrestore(&hdsp->lock, flags);
-        return change;
-}
-
-/* The simple mixer control(s) provide gain control for the
-   basic 1:1 mappings of playback streams to output
-   streams. 
-*/
-
-#define HDSP_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_hdsp_info_playback_mixer, \
-  .get = snd_hdsp_get_playback_mixer, \
-  .put = snd_hdsp_put_playback_mixer \
-}
-
-static int snd_hdsp_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_hdsp_get_playback_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
-{
-        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
-        int addr;
-        int channel;
-        int mapped_channel;
-
-        channel = ucontrol->id.index - 1;
-
-        snd_assert(channel >= 0 || channel < HDSP_MAX_CHANNELS, return -EINVAL);
-        
-        if ((mapped_channel = hdsp->channel_map[channel]) < 0) {
-                return -EINVAL;
-        }
-
-        addr = hdsp_playback_to_output_key(hdsp,mapped_channel, mapped_channel);
-
-        spin_lock_irqsave(&hdsp->lock, flags);
-        ucontrol->value.integer.value[0] = hdsp_read_gain (hdsp, addr);
-        spin_unlock_irqrestore(&hdsp->lock, flags);
-        return 0;
-}
-
-static int snd_hdsp_put_playback_mixer(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
-{
-        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
-        int change;
-        int addr;
-        int channel;
-        int mapped_channel;
-        int gain;
-
-        if (!snd_hdsp_use_is_exclusive(hdsp))
-                return -EBUSY;
-        
-        channel = ucontrol->id.index - 1;
-
-        snd_assert(channel >= 0 || channel < HDSP_MAX_CHANNELS, return -EINVAL);
-        
-        if ((mapped_channel = hdsp->channel_map[channel]) < 0) {
-                return -EINVAL;
-        }
-
-        addr = hdsp_playback_to_output_key(hdsp,mapped_channel, mapped_channel);
-        gain = ucontrol->value.integer.value[0];
-
 
         spin_lock_irqsave(&hdsp->lock, flags);
@@ -2568 +3109 @@
                 break;
         case Multiface:
+        case H9632:
                 if (offset >= 1) 
                         return -EINVAL;
@@ -2578 +3120 @@
         return 0;
 }
+
+static snd_kcontrol_new_t snd_hdsp_9632_controls[] = {
+HDSP_DA_GAIN("DA Gain", 0),
+HDSP_AD_GAIN("AD Gain", 0),
+HDSP_PHONE_GAIN("Phones Gain", 0),
+HDSP_XLR_BREAKOUT_CABLE("XLR Breakout Cable", 0)
+};
 
 static snd_kcontrol_new_t snd_hdsp_controls[] = {
@@ -2639 +3188 @@
 #define HDSP_CONTROLS (sizeof(snd_hdsp_controls)/sizeof(snd_kcontrol_new_t))
 
-static snd_kcontrol_new_t snd_hdsp_playback_mixer = HDSP_PLAYBACK_MIXER;
+#define HDSP_9632_CONTROLS (sizeof(snd_hdsp_9632_controls)/sizeof(snd_kcontrol_new_t))
+
+static snd_kcontrol_new_t snd_hdsp_96xx_aeb = HDSP_AEB("Analog Extension Board", 0);
 static snd_kcontrol_new_t snd_hdsp_adat_sync_check = HDSP_ADAT_SYNC_CHECK;
 
-
-static int hdsp_update_simple_mixer_controls(hdsp_t *hdsp)
-{
-    int i;
-
-    for (i = hdsp->ds_channels; i < hdsp->ss_channels; ++i) {
-            if (hdsp->system_sample_rate > 48000) {
-                    hdsp->playback_mixer_ctls[i]->vd[0].access = SNDRV_CTL_ELEM_ACCESS_INACTIVE |
-                                                            SNDRV_CTL_ELEM_ACCESS_READ |
-                                                             SNDRV_CTL_ELEM_ACCESS_VOLATILE;
-            } else {
-                    hdsp->playback_mixer_ctls[i]->vd[0].access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
-                                                             SNDRV_CTL_ELEM_ACCESS_VOLATILE;
-            }
-            snd_ctl_notify(hdsp->card, SNDRV_CTL_EVENT_MASK_VALUE | 
-                            SNDRV_CTL_EVENT_MASK_INFO, &hdsp->playback_mixer_ctls[i]->id);
-    }
-
-    return 0;
-}
-
-
 int snd_hdsp_create_controls(snd_card_t *card, hdsp_t *hdsp)
 {
-        unsigned int idx, limit;
+        unsigned int idx;
         int err;
         snd_kcontrol_t *kctl;
@@ -2678 +3207 @@
         }
 
-        snd_hdsp_playback_mixer.name = "Chn";
+        /* ADAT SyncCheck status */
         snd_hdsp_adat_sync_check.name = "ADAT Lock Status";
-
-        switch (hdsp->io_type) {
-        case Digiface:
-                limit = DIGIFACE_SS_CHANNELS;
-                break;
-        case H9652:
-                limit = H9652_SS_CHANNELS;
-                break;
-        case Multiface:
-                limit = MULTIFACE_SS_CHANNELS;
-                break;
-        default:
-                return -EIO;
-        }
-        
-        /* 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_hdsp_playback_mixer.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_playback_mixer, hdsp)))) {
-                        return err;
-                }
-                hdsp->playback_mixer_ctls[idx] = kctl;
-        }
-        
-        /* ADAT SyncCheck status */
         snd_hdsp_adat_sync_check.index = 1;
         if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_adat_sync_check, hdsp)))) {
@@ -2722 +3221 @@
                 }
         }
+        
+        /* DA, AD and Phone gain and XLR breakout cable controls for H9632 cards */
+        if (hdsp->io_type == H9632) {
+                for (idx = 0; idx < HDSP_9632_CONTROLS; idx++) {
+                        if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_9632_controls[idx], hdsp))) < 0) {
+                                return err;
+                        }
+                }
+        }
+
+        /* AEB control for H96xx card */
+        if (hdsp->io_type == H9632 || hdsp->io_type == H9652) {
+                if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_hdsp_96xx_aeb, hdsp))) < 0) {
+                                return err;
+                }       
+        }
 
         return 0;
@@ -2814 +3329 @@
                 clock_source = "Internal 96 kHz";
                 break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_128KHZ:
+                clock_source = "Internal 128 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_176_4KHZ:
+                clock_source = "Internal 176.4 kHz";
+                break;
+                case HDSP_CLOCK_SOURCE_INTERNAL_192KHZ:
+                clock_source = "Internal 192 kHz";
+                break;  
         default:
                 clock_source = "Error";         
@@ -2886 +3410 @@
         snd_iprintf(buffer, "\n");
 
-        switch ((hdsp->control_register & HDSP_SPDIFInputMask) >> 14) {
+        switch (hdsp_spdif_in(hdsp)) {
         case HDSP_SPDIFIN_OPTICAL:
-                snd_iprintf(buffer, "IEC958 input: ADAT1\n");
+                snd_iprintf(buffer, "IEC958 input: Optical\n");
                 break;
         case HDSP_SPDIFIN_COAXIAL:
                 snd_iprintf(buffer, "IEC958 input: Coaxial\n");
                 break;
-        case HDSP_SPDIFIN_INTERN:
+        case HDSP_SPDIFIN_INTERNAL:
                 snd_iprintf(buffer, "IEC958 input: Internal\n");
+                break;
+        case HDSP_SPDIFIN_AES:
+                snd_iprintf(buffer, "IEC958 input: AES\n");
                 break;
         default:
@@ -2982 +3509 @@
 
         snd_iprintf(buffer, "\n");
-
-#if 0
-        for (x = 0; x < 26; x++) {
-                unsigned int val = hdsp_read (hdsp, HDSP_inputPeakLevel + (4 * x));
-                snd_iprintf (buffer, "%d: input peak = %d overs = %d\n", x, val&0xffffff00, val&0xf);
-        }
-#endif
+        
+        /* Informations about H9632 specific controls */
+        if (hdsp->io_type == H9632) {
+                char *tmp;
+        
+                switch (hdsp_ad_gain(hdsp)) {
+                case 0:
+                        tmp = "-10 dBV";
+                        break;
+                case 1:
+                        tmp = "+4 dBu";
+                        break;
+                default:
+                        tmp = "Lo Gain";
+                        break;
+                }
+                snd_iprintf(buffer, "AD Gain : %s\n", tmp);
+
+                switch (hdsp_da_gain(hdsp)) {
+                case 0:
+                        tmp = "Hi Gain";
+                        break;
+                case 1:
+                        tmp = "+4 dBu";
+                        break;
+                default:
+                        tmp = "-10 dBV";
+                        break;
+                }
+                snd_iprintf(buffer, "DA Gain : %s\n", tmp);
+                
+                switch (hdsp_phone_gain(hdsp)) {
+                case 0:
+                        tmp = "0 dB";
+                        break;
+                case 1:
+                        tmp = "-6 dB";
+                        break;
+                default:
+                        tmp = "-12 dB";
+                        break;
+                }
+                snd_iprintf(buffer, "Phones Gain : %s\n", tmp);
+
+                snd_iprintf(buffer, "XLR Breakout Cable : %s\n", hdsp_xlr_breakout_cable(hdsp) ? "yes" : "no"); 
+                
+                if (hdsp->control_register & HDSP_AnalogExtensionBoard) {
+                        snd_iprintf(buffer, "AEB : on (ADAT1 internal)\n");
+                } else {
+                        snd_iprintf(buffer, "AEB : off (ADAT1 external)\n");
+                }
+                snd_iprintf(buffer, "\n");
+        }
+
 }
 
@@ -2996 +3570 @@
 
         if (! snd_card_proc_new(hdsp->card, "hdsp", &entry))
-                snd_info_set_text_ops(entry, hdsp, snd_hdsp_proc_read);
+                snd_info_set_text_ops(entry, hdsp, 1024, snd_hdsp_proc_read);
 }
 
@@ -3080 +3654 @@
                                  hdsp_encode_latency(7) | 
                                  HDSP_LineOut;
+        
 
         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+
+#ifdef SNDRV_BIG_ENDIAN
+        hdsp->control2_register = HDSP_BIGENDIAN_MODE;
+#else
+        hdsp->control2_register = 0;
+#endif
+        if (hdsp->io_type == H9652) {
+                snd_hdsp_9652_enable_mixer (hdsp);
+        } else {
+            hdsp_write (hdsp, HDSP_control2Reg, hdsp->control2_register);
+        } 
+
         hdsp_reset_hw_pointer(hdsp);
         hdsp_compute_period_size(hdsp);
@@ -3091 +3678 @@
         }
 
-        for (i = 0; i < (hdsp->io_type == H9652 ? 1352 : HDSP_MATRIX_MIXER_SIZE); i++) {
+        for (i = 0; i < ((hdsp->io_type == H9652 || hdsp->io_type == H9632) ? 1352 : HDSP_MATRIX_MIXER_SIZE); ++i) {
                 if (hdsp_write_gain (hdsp, i, MINUS_INFINITY_GAIN)) {
                         return -EIO;
@@ -3098 +3685 @@
         
         if ((hdsp->io_type != H9652) && line_outs_monitor[hdsp->dev]) {
+                
+                int lineouts_base;
                 
                 snd_printk ("sending all inputs and playback streams to line outs.\n");
@@ -3104 +3693 @@
                    odd numbered channels to right, even to left.
                 */
+                if (hdsp->io_type == H9632) {
+                        /* this is the phones/analog output */
+                        lineouts_base = 10;
+                } else {
+                        lineouts_base = 26;
+                }
                 
-                for (i = 0; i < HDSP_MAX_CHANNELS; i++) {
+                for (i = 0; i < hdsp->max_channels; i++) {
                         if (i & 1) { 
-                                if (hdsp_write_gain (hdsp, hdsp_input_to_output_key (hdsp, i, 26), UNITY_GAIN) ||
-                                    hdsp_write_gain (hdsp, hdsp_playback_to_output_key (hdsp, i, 26), UNITY_GAIN)) {
+                                if (hdsp_write_gain (hdsp, hdsp_input_to_output_key (hdsp, i, lineouts_base), UNITY_GAIN) ||
+                                    hdsp_write_gain (hdsp, hdsp_playback_to_output_key (hdsp, i, lineouts_base), UNITY_GAIN)) {
                                     return -EIO;
                                 }    
                         } else {
-                                if (hdsp_write_gain (hdsp, hdsp_input_to_output_key (hdsp, i, 27), UNITY_GAIN) ||
-                                    hdsp_write_gain (hdsp, hdsp_playback_to_output_key (hdsp, i, 27), UNITY_GAIN)) {
+                                if (hdsp_write_gain (hdsp, hdsp_input_to_output_key (hdsp, i, lineouts_base+1), UNITY_GAIN) ||
+                                    hdsp_write_gain (hdsp, hdsp_playback_to_output_key (hdsp, i, lineouts_base+1), UNITY_GAIN)) {
+                                    
                                     return -EIO;
                                 }
@@ -3121 +3717 @@
 
         hdsp->passthru = 0;
+
+        /* H9632 specific defaults */
+        if (hdsp->io_type == H9632) {
+                hdsp->control_register |= (HDSP_DAGainPlus4dBu | HDSP_ADGainPlus4dBu | HDSP_PhoneGain0dB);
+                hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        }
 
         /* set a default rate so that the channel map is set up.
@@ -3210 +3812 @@
         int mapped_channel;
 
-        snd_assert(channel >= 0 || channel < HDSP_MAX_CHANNELS, return NULL);
+        snd_assert(channel >= 0 || channel < hdsp->max_channels, return NULL);
         
         if ((mapped_channel = hdsp->channel_map[channel]) < 0) {
@@ -3382 +3984 @@
         int mapped_channel;
 
-        snd_assert(info->channel < HDSP_MAX_CHANNELS, return -EINVAL);
+        snd_assert(info->channel < hdsp->max_channels, return -EINVAL);
 
         if ((mapped_channel = hdsp->channel_map[info->channel]) < 0) {
@@ -3571 +4173 @@
 };
 
-static unsigned int period_sizes[] = { 64, 128, 256, 512, 1024, 2048, 4096, 8192 };
-
-#define PERIOD_SIZES sizeof(period_sizes) / sizeof(period_sizes[0])
-
-static snd_pcm_hw_constraint_list_t hw_constraints_period_sizes = {
-        .count = PERIOD_SIZES,
-        .list = period_sizes,
+static unsigned int hdsp_period_sizes[] = { 64, 128, 256, 512, 1024, 2048, 4096, 8192 };
+
+#define HDSP_PERIOD_SIZES sizeof(hdsp_period_sizes) / sizeof(hdsp_period_sizes[0])
+
+static snd_pcm_hw_constraint_list_t hdsp_hw_constraints_period_sizes = {
+        .count = HDSP_PERIOD_SIZES,
+        .list = hdsp_period_sizes,
         .mask = 0
 };
 
-static int snd_hdsp_hw_rule_channels(snd_pcm_hw_params_t *params,
+static unsigned int hdsp_9632_sample_rates[] = { 32000, 44100, 48000, 64000, 88200, 96000, 128000, 176400, 192000 };
+
+#define HDSP_9632_SAMPLE_RATES sizeof(hdsp_9632_sample_rates) / sizeof(hdsp_9632_sample_rates[0])
+
+static snd_pcm_hw_constraint_list_t hdsp_hw_constraints_9632_sample_rates = {
+        .count = HDSP_9632_SAMPLE_RATES,
+        .list = hdsp_9632_sample_rates,
+        .mask = 0
+};
+
+static int snd_hdsp_hw_rule_in_channels(snd_pcm_hw_params_t *params,
                                         snd_pcm_hw_rule_t *rule)
 {
         hdsp_t *hdsp = rule->private;
         snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
-        unsigned int list[2] = { hdsp->ds_channels, hdsp->ss_channels };
+        if (hdsp->io_type == H9632) {
+                unsigned int list[3];
+                list[0] = hdsp->qs_in_channels;
+                list[1] = hdsp->ds_in_channels;
+                list[2] = hdsp->ss_in_channels;
+                return snd_interval_list(c, 3, list, 0);
+        } else {
+                unsigned int list[2];
+                list[0] = hdsp->ds_in_channels;
+                list[1] = hdsp->ss_in_channels;
+                return snd_interval_list(c, 2, list, 0);
+        }
+}
+
+static int snd_hdsp_hw_rule_out_channels(snd_pcm_hw_params_t *params,
+                                        snd_pcm_hw_rule_t *rule)
+{
+        unsigned int list[3];
+        hdsp_t *hdsp = rule->private;
+        snd_interval_t *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+        if (hdsp->io_type == H9632) {
+                list[0] = hdsp->qs_out_channels;
+                list[1] = hdsp->ds_out_channels;
+                list[2] = hdsp->ss_out_channels;
+                return snd_interval_list(c, 3, list, 0);
+        } else {
+                list[0] = hdsp->ds_out_channels;
+                list[1] = hdsp->ss_out_channels;
+        }
         return snd_interval_list(c, 2, list, 0);
 }
 
-static int snd_hdsp_hw_rule_channels_rate(snd_pcm_hw_params_t *params,
+static int snd_hdsp_hw_rule_in_channels_rate(snd_pcm_hw_params_t *params,
                                              snd_pcm_hw_rule_t *rule)
 {
@@ -3596 +4236 @@
         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) {
+        if (r->min > 96000 && hdsp->io_type == H9632) {
                 snd_interval_t t = {
-                        .min = hdsp->ds_channels,
-                        .max = hdsp->ds_channels,
+                        .min = hdsp->qs_in_channels,
+                        .max = hdsp->qs_in_channels,
+                        .integer = 1,
+                };
+                return snd_interval_refine(c, &t);      
+        } else if (r->min > 48000 && r->max <= 96000) {
+                snd_interval_t t = {
+                        .min = hdsp->ds_in_channels,
+                        .max = hdsp->ds_in_channels,
                         .integer = 1,
                 };
@@ -3605 +4252 @@
         } else if (r->max < 64000) {
                 snd_interval_t t = {
-                        .min = hdsp->ss_channels,
-                        .max = hdsp->ss_channels,
+                        .min = hdsp->ss_in_channels,
+                        .max = hdsp->ss_in_channels,
                         .integer = 1,
                 };
@@ -3614 +4261 @@
 }
 
-static int snd_hdsp_hw_rule_rate_channels(snd_pcm_hw_params_t *params,
+static int snd_hdsp_hw_rule_out_channels_rate(snd_pcm_hw_params_t *params,
                                              snd_pcm_hw_rule_t *rule)
 {
@@ -3620 +4267 @@
         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 >= hdsp->ss_channels) {
+        if (r->min > 96000 && hdsp->io_type == H9632) {
+                snd_interval_t t = {
+                        .min = hdsp->qs_out_channels,
+                        .max = hdsp->qs_out_channels,
+                        .integer = 1,
+                };
+                return snd_interval_refine(c, &t);      
+        } else if (r->min > 48000 && r->max <= 96000) {
+                snd_interval_t t = {
+                        .min = hdsp->ds_out_channels,
+                        .max = hdsp->ds_out_channels,
+                        .integer = 1,
+                };
+                return snd_interval_refine(c, &t);
+        } else if (r->max < 64000) {
+                snd_interval_t t = {
+                        .min = hdsp->ss_out_channels,
+                        .max = hdsp->ss_out_channels,
+                        .integer = 1,
+                };
+                return snd_interval_refine(c, &t);
+        }
+        return 0;
+}
+
+static int snd_hdsp_hw_rule_rate_out_channels(snd_pcm_hw_params_t *params,
+                                             snd_pcm_hw_rule_t *rule)
+{
+        hdsp_t *hdsp = 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 >= hdsp->ss_out_channels) {
                 snd_interval_t t = {
                         .min = 32000,
@@ -3627 +4305 @@
                 };
                 return snd_interval_refine(r, &t);
-        } else if (c->max <= hdsp->ds_channels) {
+        } else if (c->max <= hdsp->qs_out_channels && hdsp->io_type == H9632) {
+                snd_interval_t t = {
+                        .min = 128000,
+                        .max = 192000,
+                        .integer = 1,
+                };
+                return snd_interval_refine(r, &t);
+        } else if (c->max <= hdsp->ds_out_channels) {
+                snd_interval_t t = {
+                        .min = 64000,
+                        .max = 96000,
+                        .integer = 1,
+                };
+                return snd_interval_refine(r, &t);
+        }
+        return 0;
+}
+
+static int snd_hdsp_hw_rule_rate_in_channels(snd_pcm_hw_params_t *params,
+                                             snd_pcm_hw_rule_t *rule)
+{
+        hdsp_t *hdsp = 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 >= hdsp->ss_in_channels) {
+                snd_interval_t t = {
+                        .min = 32000,
+                        .max = 48000,
+                        .integer = 1,
+                };
+                return snd_interval_refine(r, &t);
+        } else if (c->max <= hdsp->qs_in_channels && hdsp->io_type == H9632) {
+                snd_interval_t t = {
+                        .min = 128000,
+                        .max = 192000,
+                        .integer = 1,
+                };
+                return snd_interval_refine(r, &t);
+        } else if (c->max <= hdsp->ds_in_channels) {
                 snd_interval_t t = {
                         .min = 64000,
@@ -3678 +4394 @@
 
         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_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hdsp_hw_constraints_period_sizes);
+        if (hdsp->io_type == H9632) {
+                runtime->hw.channels_min = hdsp->qs_out_channels;
+                runtime->hw.channels_max = hdsp->ss_out_channels;
+                runtime->hw.rate_max = 192000;
+                runtime->hw.rates = SNDRV_PCM_RATE_KNOT;
+                snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hdsp_hw_constraints_9632_sample_rates);
+        }
+        
         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
-                             snd_hdsp_hw_rule_channels, hdsp,
+                             snd_hdsp_hw_rule_out_channels, hdsp,
                              SNDRV_PCM_HW_PARAM_CHANNELS, -1);
         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
-                             snd_hdsp_hw_rule_channels_rate, hdsp,
+                             snd_hdsp_hw_rule_out_channels_rate, hdsp,
                              SNDRV_PCM_HW_PARAM_RATE, -1);
         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
-                             snd_hdsp_hw_rule_rate_channels, hdsp,
+                             snd_hdsp_hw_rule_rate_out_channels, hdsp,
                              SNDRV_PCM_HW_PARAM_CHANNELS, -1);
 
@@ -3755 +4479 @@
 
         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_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hdsp_hw_constraints_period_sizes);
+        if (hdsp->io_type == H9632) {
+                runtime->hw.channels_min = hdsp->qs_in_channels;
+                runtime->hw.channels_max = hdsp->ss_in_channels;
+                runtime->hw.rate_max = 192000;
+                runtime->hw.rates = SNDRV_PCM_RATE_KNOT;
+                snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &hdsp_hw_constraints_9632_sample_rates);
+        }
         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
-                             snd_hdsp_hw_rule_channels, hdsp,
+                             snd_hdsp_hw_rule_in_channels, hdsp,
                              SNDRV_PCM_HW_PARAM_CHANNELS, -1);
         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
-                             snd_hdsp_hw_rule_channels_rate, hdsp,
+                             snd_hdsp_hw_rule_in_channels_rate, hdsp,
                              SNDRV_PCM_HW_PARAM_RATE, -1);
         snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
-                             snd_hdsp_hw_rule_rate_channels, hdsp,
+                             snd_hdsp_hw_rule_rate_in_channels, hdsp,
                              SNDRV_PCM_HW_PARAM_CHANNELS, -1);
         return 0;
@@ -3784 +4515 @@
 static int snd_hdsp_hwdep_dummy_op(snd_hwdep_t *hw, struct file *file)
 {
-    /* we have nothing to initialize but the call is required */
-    return 0;
+        /* we have nothing to initialize but the call is required */
+        return 0;
 }
 
@@ -3792 +4523 @@
 {
         hdsp_t *hdsp = (hdsp_t *)hw->private_data;      
-        
+
         switch (cmd) {
         case SNDRV_HDSP_IOCTL_GET_PEAK_RMS: {
                 hdsp_peak_rms_t *peak_rms;
-
+                int i;
+                
                 if (hdsp->io_type == H9652) {
-                    snd_printk("hardware metering isn't supported yet for hdsp9652 cards\n");
-                    return -EINVAL;
+                        unsigned long rms_low, rms_high;
+                        int doublespeed = 0;
+                        if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DoubleSpeedStatus)
+                                doublespeed = 1;
+                        peak_rms = (hdsp_peak_rms_t *)arg;
+                        for (i = 0; i < 26; ++i) {
+                                if (!(doublespeed && (i & 4))) {
+                                        if (copy_to_user_fromio((void *)peak_rms->input_peaks+i*4, hdsp->iobase+HDSP_9652_peakBase-i*4, 4) != 0)
+                                                return -EFAULT;
+                                        if (copy_to_user_fromio((void *)peak_rms->playback_peaks+i*4, hdsp->iobase+HDSP_9652_peakBase-(doublespeed ? 14 : 26)*4-i*4, 4) != 0)
+                                                return -EFAULT;
+                                        if (copy_to_user_fromio((void *)peak_rms->output_peaks+i*4, hdsp->iobase+HDSP_9652_peakBase-2*(doublespeed ? 14 : 26)*4-i*4, 4) != 0)
+                                                return -EFAULT;
+                                        rms_low = *(u32 *)(hdsp->iobase+HDSP_9652_rmsBase+i*8) & 0xFFFFFF00;
+                                        rms_high = *(u32 *)(hdsp->iobase+HDSP_9652_rmsBase+i*8+4) & 0xFFFFFF00;
+                                        rms_high += (rms_low >> 24);
+                                        rms_low <<= 8;
+                                        if (copy_to_user((void *)peak_rms->input_rms+i*8, &rms_low, 4) != 0)
+                                                return -EFAULT;
+                                        if (copy_to_user((void *)peak_rms->input_rms+i*8+4, &rms_high, 4) != 0)
+                                                return -EFAULT;                                 
+                                        rms_low = *(u32 *)(hdsp->iobase+HDSP_9652_rmsBase+(doublespeed ? 14 : 26)*8+i*8) & 0xFFFFFF00;
+                                        rms_high = *(u32 *)(hdsp->iobase+HDSP_9652_rmsBase+(doublespeed ? 14 : 26)*8+i*8+4) & 0xFFFFFF00;
+                                        rms_high += (rms_low >> 24);
+                                        rms_low <<= 8;
+                                        if (copy_to_user((void *)peak_rms->playback_rms+i*8, &rms_low, 4) != 0)
+                                                return -EFAULT;
+                                        if (copy_to_user((void *)peak_rms->playback_rms+i*8+4, &rms_high, 4) != 0)
+                                                return -EFAULT;                                 
+                                        rms_low = *(u32 *)(hdsp->iobase+HDSP_9652_rmsBase+2*(doublespeed ? 14 : 26)*8+i*8) & 0xFFFFFF00;
+                                        rms_high = *(u32 *)(hdsp->iobase+HDSP_9652_rmsBase+2*(doublespeed ? 14 : 26)*8+i*8+4) & 0xFFFFFF00;
+                                        rms_high += (rms_low >> 24);
+                                        rms_low <<= 8;
+                                        if (copy_to_user((void *)peak_rms->output_rms+i*8, &rms_low, 4) != 0)
+                                                return -EFAULT;
+                                        if (copy_to_user((void *)peak_rms->output_rms+i*8+4, &rms_high, 4) != 0)
+                                                return -EFAULT;                                 
+                                }
+                        }
+                        return 0;
+                }
+                if (hdsp->io_type == H9632) {
+                        int j;
+                        hdsp_9632_meters_t *m;
+                        int doublespeed = 0;
+                        if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DoubleSpeedStatus)
+                                doublespeed = 1;
+                        m = (hdsp_9632_meters_t *)(hdsp->iobase+HDSP_9632_metersBase);
+                        peak_rms = (hdsp_peak_rms_t *)arg;
+                        for (i = 0, j = 0; i < 16; ++i, ++j) {
+                                if (copy_to_user((void *)peak_rms->input_peaks+i*4, &(m->input_peak[j]), 4) != 0)
+                                        return -EFAULT;
+                                if (copy_to_user((void *)peak_rms->playback_peaks+i*4, &(m->playback_peak[j]), 4) != 0)
+                                        return -EFAULT;
+                                if (copy_to_user((void *)peak_rms->output_peaks+i*4, &(m->output_peak[j]), 4) != 0)
+                                        return -EFAULT;
+                                if (copy_to_user((void *)peak_rms->input_rms+i*8, &(m->input_rms_low[j]), 4) != 0)
+                                        return -EFAULT;
+                                if (copy_to_user((void *)peak_rms->playback_rms+i*8, &(m->playback_rms_low[j]), 4) != 0)
+                                        return -EFAULT;
+                                if (copy_to_user((void *)peak_rms->output_rms+i*8, &(m->output_rms_low[j]), 4) != 0)
+                                        return -EFAULT;
+                                if (copy_to_user((void *)peak_rms->input_rms+i*8+4, &(m->input_rms_high[j]), 4) != 0)
+                                        return -EFAULT;
+                                if (copy_to_user((void *)peak_rms->playback_rms+i*8+4, &(m->playback_rms_high[j]), 4) != 0)
+                                        return -EFAULT;
+                                if (copy_to_user((void *)peak_rms->output_rms+i*8+4, &(m->output_rms_high[j]), 4) != 0)
+                                        return -EFAULT;
+                                if (doublespeed && i == 3) i += 4;
+                        }
+                        return 0;
                 }
                 if (!(hdsp->state & HDSP_FirmwareLoaded)) {
@@ -3806 +4607 @@
                 }
                 peak_rms = (hdsp_peak_rms_t *)arg;
-                if (copy_to_user_fromio((void *)peak_rms->playback_peaks, hdsp->iobase+HDSP_playbackPeakLevel, 26*4) != 0) {
-                        return -EFAULT;
-                }
-                if (copy_to_user_fromio((void *)peak_rms->input_peaks, hdsp->iobase+HDSP_inputPeakLevel, 26*4) != 0) {
-                        return -EFAULT;
-                }
-                if (copy_to_user_fromio((void *)peak_rms->output_peaks, hdsp->iobase+HDSP_outputPeakLevel, 28*4) != 0) {
-                        return -EFAULT;
-                }
-                if (copy_to_user_fromio((void *)peak_rms->playback_rms, hdsp->iobase+HDSP_playbackRmsLevel, 26*8) != 0) {
-                        return -EFAULT;
-                }
-                if (copy_to_user_fromio((void *)peak_rms->input_rms, hdsp->iobase+HDSP_inputRmsLevel, 26*8) != 0) {
-                        return -EFAULT;
+                for (i = 0; i < 26; ++i) {
+                    if (copy_to_user((void *)peak_rms->playback_peaks+i*4, (void *)hdsp->iobase+HDSP_playbackPeakLevel+i*4, 4) != 0)
+                            return -EFAULT;
+                    if (copy_to_user((void *)peak_rms->input_peaks+i*4, (void *)hdsp->iobase+HDSP_inputPeakLevel+i*4, 4) != 0)
+                            return -EFAULT;
+                }
+                for (i = 0; i < 26; ++i) {
+                        if (copy_to_user((void *)peak_rms->playback_rms+i*8+4, (void *)hdsp->iobase+HDSP_playbackRmsLevel+i*8, 4) != 0)
+                                return -EFAULT;
+                        if (copy_to_user((void *)peak_rms->playback_rms+i*8, (void *)hdsp->iobase+HDSP_playbackRmsLevel+i*8+4, 4) != 0)
+                                return -EFAULT;
+                        if (copy_to_user((void *)peak_rms->input_rms+i*8+4, (void *)hdsp->iobase+HDSP_inputRmsLevel+i*8, 4) != 0)
+                                return -EFAULT;
+                        if (copy_to_user((void *)peak_rms->input_rms+i*8, (void *)hdsp->iobase+HDSP_inputRmsLevel+i*8+4, 4) != 0)
+                                return -EFAULT;
+                }
+                for (i = 0; i < 28; ++i) {
+                    if (copy_to_user((void *)peak_rms->output_peaks+i*4, (void *)hdsp->iobase+HDSP_outputPeakLevel+i*4, 4) != 0)
+                            return -EFAULT;
                 }
                 break;
@@ -3827 +4633 @@
                 unsigned long flags;
                 int i;
-
+                
                 if (!(hdsp->state & HDSP_FirmwareLoaded)) {
                         snd_printk("Firmware needs to be uploaded to the card.\n");     
@@ -3835 +4641 @@
                 info.pref_sync_ref = (unsigned char)hdsp_pref_sync_ref(hdsp);
                 info.wordclock_sync_check = (unsigned char)hdsp_wc_sync_check(hdsp);
-                info.adatsync_sync_check = (unsigned char)hdsp_adatsync_sync_check(hdsp);
+                if (hdsp->io_type != H9632) {
+                    info.adatsync_sync_check = (unsigned char)hdsp_adatsync_sync_check(hdsp);
+                }
                 info.spdif_sync_check = (unsigned char)hdsp_spdif_sync_check(hdsp);
-                for (i = 0; i < ((hdsp->io_type != Multiface) ? 3 : 1); ++i) {
+                for (i = 0; i < ((hdsp->io_type != Multiface && hdsp->io_type != H9632) ? 3 : 1); ++i) {
                         info.adat_sync_check[i] = (unsigned char)hdsp_adat_sync_check(hdsp, i);
                 }
@@ -3853 +4661 @@
                 info.line_out = (unsigned char)hdsp_line_out(hdsp);
                 info.passthru = (unsigned char)hdsp->passthru;
+                if (hdsp->io_type == H9632) {
+                        info.da_gain = (unsigned char)hdsp_da_gain(hdsp);
+                        info.ad_gain = (unsigned char)hdsp_ad_gain(hdsp);
+                        info.phone_gain = (unsigned char)hdsp_phone_gain(hdsp);
+                        info.xlr_breakout_cable = (unsigned char)hdsp_xlr_breakout_cable(hdsp);
+                
+                }
+                if (hdsp->io_type == H9632 || hdsp->io_type == H9652) {
+                        info.analog_extension_board = (unsigned char)hdsp_aeb(hdsp);
+                }
                 spin_unlock_irqrestore(&hdsp->lock, flags);
                 if (copy_to_user((void *)arg, &info, sizeof(info)))
@@ -3858 +4676 @@
                 break;
         }
+        case SNDRV_HDSP_IOCTL_GET_9632_AEB: {
+                hdsp_9632_aeb_t h9632_aeb;
+                
+                if (hdsp->io_type != H9632) return -EINVAL;
+                h9632_aeb.aebi = hdsp->ss_in_channels - H9632_SS_CHANNELS;
+                h9632_aeb.aebo = hdsp->ss_out_channels - H9632_SS_CHANNELS;
+                if (copy_to_user((void *)arg, &h9632_aeb, sizeof(h9632_aeb)))
+                        return -EFAULT;
+                break;
+        }
         case SNDRV_HDSP_IOCTL_GET_VERSION: {
                 hdsp_version_t hdsp_version;
                 int err;
-
-                if (hdsp->io_type == H9652) return -EINVAL;
+                
+                if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return -EINVAL;
                 if (hdsp->io_type == Undefined) {
                         if ((err = hdsp_get_iobox_version(hdsp)) < 0) {
@@ -3879 +4707 @@
                 unsigned long *firmware_data;
                 int err;
-
-                if (hdsp->io_type == H9652) return -EINVAL;
+                
+                if (hdsp->io_type == H9652 || hdsp->io_type == H9632) return -EINVAL;
                 /* SNDRV_HDSP_IOCTL_GET_VERSION must have been called */
                 if (hdsp->io_type == Undefined) return -EINVAL;
@@ -3886 +4714 @@
                 snd_printk("initializing firmware upload\n");
                 firmware = (hdsp_firmware_t *)arg;
+
                 if (get_user(firmware_data, &firmware->firmware_data)) {
                         return -EFAULT;
                 }
-
+                
                 if (hdsp_check_for_iobox (hdsp)) {
                         return -EIO;
@@ -3903 +4732 @@
                         return err;
                 }
-                
                 
                 if (!(hdsp->state & HDSP_InitializationComplete)) {
@@ -3918 +4746 @@
         }
         case SNDRV_HDSP_IOCTL_GET_MIXER: {
-                hdsp_mixer_t    *mixer;
-
+                hdsp_mixer_t *mixer;
+                
                 mixer = (hdsp_mixer_t *)arg;
                 if (copy_to_user(mixer->matrix, hdsp->mixer_matrix, sizeof(unsigned short)*HDSP_MATRIX_MIXER_SIZE))
@@ -4015 +4843 @@
         }
         
-        for (i = 0; i < HDSP_MAX_CHANNELS; ++i) {
+        for (i = 0; i < hdsp->max_channels; ++i) {
                 hdsp_write (hdsp, HDSP_inputEnable + (4 * i), 1);
                 hdsp_write (hdsp, HDSP_outputEnable + (4 * i), 1);
@@ -4025 +4853 @@
 static inline void snd_hdsp_initialize_channels(hdsp_t *hdsp)
 {
+        int status, aebi_channels, aebo_channels;
+        
         switch (hdsp->io_type) {
         case Digiface:
                 hdsp->card_name = "RME Hammerfall DSP + Digiface";
-                hdsp->ss_channels = DIGIFACE_SS_CHANNELS;
-                hdsp->ds_channels = DIGIFACE_DS_CHANNELS;
+                hdsp->ss_in_channels = hdsp->ss_out_channels = DIGIFACE_SS_CHANNELS;
+                hdsp->ds_in_channels = hdsp->ds_out_channels = DIGIFACE_DS_CHANNELS;
                 break;
 
         case H9652:
                 hdsp->card_name = "RME Hammerfall HDSP 9652";
-                hdsp->ss_channels = H9652_SS_CHANNELS;
-                hdsp->ds_channels = H9652_DS_CHANNELS;
+                hdsp->ss_in_channels = hdsp->ss_out_channels = H9652_SS_CHANNELS;
+                hdsp->ds_in_channels = hdsp->ds_out_channels = H9652_DS_CHANNELS;
+                break;
+        
+        case H9632:
+                status = hdsp_read(hdsp, HDSP_statusRegister);
+                /* HDSP_AEBx bits are low when AEB are connected */
+                aebi_channels = (status & HDSP_AEBI) ? 0 : 4;
+                aebo_channels = (status & HDSP_AEBO) ? 0 : 4;
+                hdsp->card_name = "RME Hammerfall HDSP 9632";
+                hdsp->ss_in_channels = H9632_SS_CHANNELS+aebi_channels;
+                hdsp->ds_in_channels = H9632_DS_CHANNELS+aebi_channels;
+                hdsp->qs_in_channels = H9632_QS_CHANNELS+aebi_channels;
+                hdsp->ss_out_channels = H9632_SS_CHANNELS+aebo_channels;
+                hdsp->ds_out_channels = H9632_DS_CHANNELS+aebo_channels;
+                hdsp->qs_out_channels = H9632_QS_CHANNELS+aebo_channels;
                 break;
 
         case Multiface:
                 hdsp->card_name = "RME Hammerfall DSP + Multiface";
-                hdsp->ss_channels = MULTIFACE_SS_CHANNELS;
-                hdsp->ds_channels = MULTIFACE_DS_CHANNELS;
-
+                hdsp->ss_in_channels = hdsp->ss_out_channels = MULTIFACE_SS_CHANNELS;
+                hdsp->ds_in_channels = hdsp->ds_out_channels = MULTIFACE_DS_CHANNELS;
+                break;
+                
         default:
                 /* should never get here */
@@ -4060 +4905 @@
         
         if ((err = snd_hdsp_create_pcm(card, hdsp)) < 0) {
+                snd_printk("Error creating pcm interface\n");
                 return err;
         }
         
+
         if ((err = snd_hdsp_create_midi(card, hdsp, 0)) < 0) {
+                snd_printk("Error creating first midi interface\n");
                 return err;
         }
 
+
         if ((err = snd_hdsp_create_midi(card, hdsp, 1)) < 0) {
+                snd_printk("Error creating second midi interface\n");
                 return err;
         }
 
         if ((err = snd_hdsp_create_controls(card, hdsp)) < 0) {
+                snd_printk("Error creating ctl interface\n");
                 return err;
         }
@@ -4077 +4928 @@
         snd_hdsp_proc_init(hdsp);
 
-        hdsp->last_spdif_sample_rate = -1;
         hdsp->system_sample_rate = -1;
-        hdsp->last_external_sample_rate = -1;
-        hdsp->last_internal_sample_rate = -1;
         hdsp->playback_pid = -1;
         hdsp->capture_pid = -1;
@@ -4087 +4935 @@
 
         if ((err = snd_hdsp_set_defaults(hdsp)) < 0) {
+                snd_printk("Error setting default values\n");
                 return err;
         }
-        
-        hdsp_update_simple_mixer_controls(hdsp);
         
         if (!(hdsp->state & HDSP_InitializationComplete)) {
@@ -4112 +4959 @@
         struct pci_dev *pci = hdsp->pci;
         int err;
-        int i;
         int is_9652 = 0;
+        int is_9632 = 0;
 
         hdsp->irq = -1;
@@ -4127 +4974 @@
         hdsp->iobase = 0;
         hdsp->res_port = 0;
+        hdsp->control_register = 0;
+        hdsp->control2_register = 0;
         hdsp->io_type = Undefined;
-        for (i = 0; i < HDSP_MAX_CHANNELS; ++i)
-                hdsp->playback_mixer_ctls[i] = 0;
+        hdsp->max_channels = 26;
 
         hdsp->card = card;
@@ -4154 +5002 @@
                 is_9652 = 1;
                 break;
-
+        case 0x96:
+                hdsp->card_name = "RME HDSP 9632";
+                hdsp->max_channels = 16;
+                is_9632 = 1;
+                break;
         default:
                 return -ENODEV;
@@ -4189 +5041 @@
         }
         
-        if (!is_9652 && hdsp_check_for_iobox (hdsp)) {
+        if (!is_9652 && !is_9632 && hdsp_check_for_iobox (hdsp)) {
                 /* no iobox connected, we defer initialization */
                 snd_printk("card initialization pending : waiting for firmware\n");
@@ -4220 +5072 @@
         if (is_9652) {
                 hdsp->io_type = H9652;
-                snd_hdsp_9652_enable_mixer (hdsp);
+        }
+        
+        if (is_9632) {
+                hdsp->io_type = H9632;
         }
 

GPL/branches/alsa-resync1/alsa-kernel/pci/rme9652/rme9652.c

@@ -1618 +1618 @@
 RME9652_ADAT_SYNC("ADAT1 Sync Check", 0, 0),
 RME9652_ADAT_SYNC("ADAT2 Sync Check", 0, 1),
-RME9652_ADAT_SYNC("ADAT3 Sync Check", 0, 2),
 RME9652_TC_VALID("Timecode Valid", 0),
 RME9652_PASSTHRU("Passthru", 0)
@@ -1835 +1834 @@
 
         if (! snd_card_proc_new(rme9652->card, "rme9652", &entry))
-                snd_info_set_text_ops(entry, rme9652, snd_rme9652_proc_read);
+                snd_info_set_text_ops(entry, rme9652, 1024, snd_rme9652_proc_read);
 }
 

GPL/branches/alsa-resync1/alsa-kernel/pci/sonicvibes.c

@@ -1182 +1182 @@
 
         if (! snd_card_proc_new(sonic->card, "sonicvibes", &entry))
-                snd_info_set_text_ops(entry, sonic, snd_sonicvibes_proc_read);
+                snd_info_set_text_ops(entry, sonic, 1024, snd_sonicvibes_proc_read);
 }
 
@@ -1258 +1258 @@
                 return -ENXIO;
         }
-        pci_set_dma_mask(pci, 0x00ffffff);
+        pci_set_consistent_dma_mask(pci, 0x00ffffff);
 
         sonic = snd_magic_kcalloc(sonicvibes_t, 0, GFP_KERNEL);

GPL/branches/alsa-resync1/alsa-kernel/pci/ymfpci/ymfpci.c

@@ -135 +135 @@
 
         if (pci_id->device >= 0x0010) { /* YMF 744/754 */
-                if (fm_port[dev] <= 0) {
+                if (fm_port[dev] == 1) {
+                        /* auto-detect */
                         fm_port[dev] = pci_resource_start(pci, 1);
                 }
@@ -143 +144 @@
                         pci_write_config_word(pci, PCIR_DSXG_FMBASE, fm_port[dev]);
                 }
-                if (mpu_port[dev] <= 0) {
+                if (mpu_port[dev] == 1) {
+                        /* auto-detect */
                         mpu_port[dev] = pci_resource_start(pci, 1) + 0x20;
                 }
@@ -152 +154 @@
                 }
 #ifdef SUPPORT_JOYSTICK
-                if (joystick_port[dev] < 0) {
+                if (joystick_port[dev] == 1) {
+                        /* auto-detect */
                         joystick_port[dev] = pci_resource_start(pci, 2);
                 }
-                if (joystick_port[dev] >= 0 &&
+                if (joystick_port[dev] > 0 &&
                     (joystick_res = request_region(joystick_port[dev], 1, "YMFPCI gameport")) != NULL) {
                         legacy_ctrl |= YMFPCI_LEGACY_JPEN;
@@ -167 +170 @@
                 case 0x3a0: legacy_ctrl2 |= 2; break;
                 case 0x3a8: legacy_ctrl2 |= 3; break;
-                default: fm_port[dev] = -1; break;
+                default: fm_port[dev] = 0; break;
                 }
                 if (fm_port[dev] > 0 &&
@@ -174 +177 @@
                 } else {
                         legacy_ctrl2 &= ~YMFPCI_LEGACY2_FMIO;
-                        fm_port[dev] = -1;
+                        fm_port[dev] = 0;
                 }
                 switch (mpu_port[dev]) {
@@ -181 +184 @@
                 case 0x332: legacy_ctrl2 |= 2 << 4; break;
                 case 0x334: legacy_ctrl2 |= 3 << 4; break;
-                default: mpu_port[dev] = -1; break;
+                default: mpu_port[dev] = 0; break;
                 }
                 if (mpu_port[dev] > 0 &&
@@ -188 +191 @@
                 } else {
                         legacy_ctrl2 &= ~YMFPCI_LEGACY2_MPUIO;
-                        mpu_port[dev] = -1;
-                }
-#ifdef SUPPORT_JOYSTICK
+                        mpu_port[dev] = 0;
+                }
+#ifdef SUPPORT_JOYSTICK
+                if (joystick_port[dev] == 1) {
+                        /* auto-detect */
+                        long p;
+                        for (p = 0x201; p <= 0x205; p++) {
+                                if (p == 0x203) continue;
+                                if ((joystick_res = request_region(p, 1, "YMFPCI gameport")) != NULL)
+                                        break;
+                        }
+                        if (joystick_res)
+                                joystick_port[dev] = p;
+                }
                 switch (joystick_port[dev]) {
                 case 0x201: legacy_ctrl2 |= 0 << 6; break;
@@ -196 +210 @@
                 case 0x204: legacy_ctrl2 |= 2 << 6; break;
                 case 0x205: legacy_ctrl2 |= 3 << 6; break;
-                default: joystick_port[dev] = -1; break;
-                }
-                if (joystick_port[dev] > 0 &&
-                    (joystick_res = request_region(joystick_port[dev], 1, "YMFPCI gameport")) != NULL) {
+                default: joystick_port[dev] = 0; break;
+                }
+                if (! joystick_res && joystick_port[dev] > 0)
+                        joystick_res = request_region(joystick_port[dev], 1, "YMFPCI gameport");
+                if (joystick_res) {
                         legacy_ctrl |= YMFPCI_LEGACY_JPEN;
                 } else {
                         legacy_ctrl2 &= ~YMFPCI_LEGACY2_JSIO;
-                        joystick_port[dev] = -1;
+                        joystick_port[dev] = 0;
                 }
 #endif