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

Timestamp:

Aug 22, 2007, 5:33:25 AM (18 years ago)

Author:

Brendan Oakley

Message:

Merged to ALSA 0.9.3

Location:

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

Files:

• ice1712/ak4xxx.c (moved) (moved from GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/ak4524.c ) (4 diffs)
• ice1712/delta.c (modified) (16 diffs)
• ice1712/ews.c (modified) (17 diffs)
• ice1712/ice1712.c (modified) (20 diffs)
• ice1712/ice1712.h (modified) (5 diffs)
• ice1712/ice1724.c (modified) (19 diffs)
• ice1712/makefile.os2 (modified) (1 diff)
• ice1712/revo.c (modified) (6 diffs)
• korg1212/korg1212.c (modified) (31 diffs)
• rme96.c (modified) (3 diffs)
• rme9652/hdsp.c (modified) (109 diffs)
• rme9652/rme9652.c (modified) (7 diffs)
• sonicvibes.c (modified) (2 diffs)
• trident/trident_main.c (modified) (3 diffs)
• ymfpci/ymfpci_main.c (modified) (1 diff)

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

@@ -30 +30 @@
 #include "ice1712.h"
 
+static void snd_ice1712_akm4xxx_lock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
+
+        snd_ice1712_save_gpio_status(ice);
+}
+
+static void snd_ice1712_akm4xxx_unlock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
+
+        snd_ice1712_restore_gpio_status(ice);
+}
 
 /*
  * write AK4xxx register
  */
-void snd_ice1712_akm4xxx_write(akm4xxx_t *ak, int chip,
-                              unsigned char addr, unsigned char data)
+static void snd_ice1712_akm4xxx_write(akm4xxx_t *ak, int chip,
+                                      unsigned char addr, unsigned char data)
 {
         unsigned int tmp;
         int idx;
         unsigned int addrdata;
-        ice1712_t *ice = ak->chip;
+        struct snd_ak4xxx_private *priv = (void *)ak->private_value[0];
+        ice1712_t *ice = ak->private_data[0];
 
         snd_assert(chip >= 0 && chip < 4, return);
 
-        if (ak->ops.start) {
-                if (ak->ops.start(ak, chip) < 0)
-                        return;
-        } else
-                snd_ice1712_save_gpio_status(ice);
-
         tmp = snd_ice1712_gpio_read(ice);
-        tmp |= ak->add_flags;
-        tmp &= ~ak->mask_flags;
-        if (ak->cs_mask == ak->cs_addr) {
-                if (ak->cif) {
-                        tmp |= ak->cs_mask; /* start without chip select */
+        tmp |= priv->add_flags;
+        tmp &= ~priv->mask_flags;
+        if (priv->cs_mask == priv->cs_addr) {
+                if (priv->cif) {
+                        tmp |= priv->cs_mask; /* start without chip select */
                 }  else {
-                        tmp &= ~ak->cs_mask; /* chip select low */
+                        tmp &= ~priv->cs_mask; /* chip select low */
                         snd_ice1712_gpio_write(ice, tmp);
                         udelay(1);
@@ -63 +71 @@
         } else {
                 /* doesn't handle cf=1 yet */
-                tmp &= ~ak->cs_mask;
-                tmp |= ak->cs_addr;
+                tmp &= ~priv->cs_mask;
+                tmp |= priv->cs_addr;
                 snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
@@ -70 +78 @@
 
         /* build I2C address + data byte */
-        addrdata = (ak->caddr << 6) | 0x20 | (addr & 0x1f);
+        addrdata = (priv->caddr << 6) | 0x20 | (addr & 0x1f);
         addrdata = (addrdata << 8) | data;
         for (idx = 15; idx >= 0; idx--) {
                 /* drop clock */
-                tmp &= ~ak->clk_mask;
+                tmp &= ~priv->clk_mask;
                 snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
                 /* set data */
                 if (addrdata & (1 << idx))
-                        tmp |= ak->data_mask;
+                        tmp |= priv->data_mask;
                 else
-                        tmp &= ~ak->data_mask;
+                        tmp &= ~priv->data_mask;
                 snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
                 /* raise clock */
-                tmp |= ak->clk_mask;
+                tmp |= priv->clk_mask;
                 snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
@@ -101 +109 @@
         }
         
-        if (ak->cs_mask == ak->cs_addr) {
-                if (ak->cif) {
+        if (priv->cs_mask == priv->cs_addr) {
+                if (priv->cif) {
                         /* assert a cs pulse to trigger */
-                        tmp &= ~ak->cs_mask;
+                        tmp &= ~priv->cs_mask;
                         snd_ice1712_gpio_write(ice, tmp);
                         udelay(1);
                 }
-                tmp |= ak->cs_mask; /* chip select high to trigger */
+                tmp |= priv->cs_mask; /* chip select high to trigger */
         } else {
-                tmp &= ~ak->cs_mask;
-                tmp |= ak->cs_none; /* deselect address */
+                tmp &= ~priv->cs_mask;
+                tmp |= priv->cs_none; /* deselect address */
         }
         snd_ice1712_gpio_write(ice, tmp);
         udelay(1);
-
-        if (ak->ops.stop)
-                ak->ops.stop(ak);
-        else
-                snd_ice1712_restore_gpio_status(ice);
 }
-
-/*
- * reset the AKM codecs
- * @state: 1 = reset codec, 0 = restore the registers
- *
- * assert the reset operation and restores the register values to the chips.
- */
-void snd_ice1712_akm4xxx_reset(akm4xxx_t *ak, int state)
-{
-        unsigned int chip;
-        unsigned char reg;
-        
-        switch (ak->type) {
-        case SND_AK4524:
-        case SND_AK4528:
-                for (chip = 0; chip < ak->num_dacs/2; chip++) {
-                        snd_ice1712_akm4xxx_write(ak, chip, 0x01, state ? 0x00 : 0x03);
-                        if (state)
-                                continue;
-                        /* DAC volumes */
-                        for (reg = 0x04; reg < (ak->type == SND_AK4528 ? 0x06 : 0x08); reg++)
-                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->images[chip][reg]);
-                        if (ak->type == SND_AK4528)
-                                continue;
-                        /* IPGA */
-                        for (reg = 0x04; reg < 0x06; reg++)
-                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->ipga_gain[chip][reg-4]);
-                }
-                break;
-        case SND_AK4529:
-                /* FIXME: needed for ak4529? */
-                break;
-        case SND_AK4355:
-                snd_ice1712_akm4xxx_write(ak, 0, 0x01, state ? 0x02 : 0x01);
-                if (state)
-                        return;
-                for (reg = 0x00; reg < 0x0a; reg++)
-                        if (reg != 0x01)
-                                snd_ice1712_akm4xxx_write(ak, 0, reg, ak->images[0][reg]);
-                break;
-        case SND_AK4381:
-                for (chip = 0; chip < ak->num_dacs/2; chip++) {
-                        snd_ice1712_akm4xxx_write(ak, chip, 0x00, state ? 0x0c : 0x0f);
-                        if (state)
-                                continue;
-                        for (reg = 0x01; reg < 0x05; reg++)
-                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->images[chip][reg]);
-                }
-                break;
-        }
-}
-
-/*
- * initialize all the ak4xxx chips
- */
-static void __devinit snd_ice1712_akm4xxx_init_chip(akm4xxx_t *ak)
-{
-        static unsigned char inits_ak4524[] = {
-                0x00, 0x07, /* 0: all power up */
-                0x01, 0x00, /* 1: ADC/DAC reset */
-                0x02, 0x60, /* 2: 24bit I2S */
-                0x03, 0x19, /* 3: deemphasis off */
-                0x01, 0x03, /* 1: ADC/DAC enable */
-                0x04, 0x00, /* 4: ADC left muted */
-                0x05, 0x00, /* 5: ADC right muted */
-                0x04, 0x80, /* 4: ADC IPGA gain 0dB */
-                0x05, 0x80, /* 5: ADC IPGA gain 0dB */
-                0x06, 0x00, /* 6: DAC left muted */
-                0x07, 0x00, /* 7: DAC right muted */
-                0xff, 0xff
-        };
-        static unsigned char inits_ak4528[] = {
-                0x00, 0x07, /* 0: all power up */
-                0x01, 0x00, /* 1: ADC/DAC reset */
-                0x02, 0x60, /* 2: 24bit I2S */
-                0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */
-                0x01, 0x03, /* 1: ADC/DAC enable */
-                0x04, 0x00, /* 4: ADC left muted */
-                0x05, 0x00, /* 5: ADC right muted */
-                0xff, 0xff
-        };
-        static unsigned char inits_ak4529[] = {
-                0x09, 0x01, /* 9: ATS=0, RSTN=1 */
-                0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
-                0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
-                0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
-                0x02, 0xff, /* 2: LOUT1 muted */
-                0x03, 0xff, /* 3: ROUT1 muted */
-                0x04, 0xff, /* 4: LOUT2 muted */
-                0x05, 0xff, /* 5: ROUT2 muted */
-                0x06, 0xff, /* 6: LOUT3 muted */
-                0x07, 0xff, /* 7: ROUT3 muted */
-                0x0b, 0xff, /* B: LOUT4 muted */
-                0x0c, 0xff, /* C: ROUT4 muted */
-                0x08, 0x55, /* 8: deemphasis all off */
-                0xff, 0xff
-        };
-        static unsigned char inits_ak4355[] = {
-                0x01, 0x02, /* 1: reset and soft-mute */
-                0x00, 0x06, /* 0: mode3(i2s), disable auto-clock detect, disable DZF, sharp roll-off, RSTN#=0 */
-                // 0x02, 0x0e, /* 2: DA's power up, normal speed, RSTN#=0 */
-                0x02, 0x2e,
-                0x03, 0x01, /* 3: de-emphasis off */
-                0x04, 0x00, /* 4: LOUT1 volume muted */
-                0x05, 0x00, /* 5: ROUT1 volume muted */
-                0x06, 0x00, /* 6: LOUT2 volume muted */
-                0x07, 0x00, /* 7: ROUT2 volume muted */
-                0x08, 0x00, /* 8: LOUT3 volume muted */
-                0x09, 0x00, /* 9: ROUT3 volume muted */
-                0x0a, 0x00, /* a: DATT speed=0, ignore DZF */
-                0x01, 0x01, /* 1: un-reset, unmute */
-                0xff, 0xff
-        };
-        static unsigned char inits_ak4381[] = {
-                0x00, 0x0c, /* 0: mode3(i2s), disable auto-clock detect */
-                // 0x01, 0x02, /* 1: de-emphasis off, normal speed, sharp roll-off, DZF off */
-                0x01, 0x12,
-                0x02, 0x00, /* 2: DZF disabled */
-                0x03, 0x00, /* 3: LATT 0 */
-                0x04, 0x00, /* 4: RATT 0 */
-                0x00, 0x0f, /* 0: power-up, un-reset */
-                0xff, 0xff
-        };
-
-        int chip, num_chips;
-        unsigned char *ptr, reg, data, *inits;
-
-        switch (ak->type) {
-        case SND_AK4524:
-                inits = inits_ak4524;
-                num_chips = ak->num_dacs / 2;
-                break;
-        case SND_AK4528:
-                inits = inits_ak4528;
-                num_chips = ak->num_dacs / 2;
-                break;
-        case SND_AK4529:
-                inits = inits_ak4529;
-                num_chips = 1;
-                break;
-        case SND_AK4355:
-                inits = inits_ak4355;
-                num_chips = 1;
-                break;
-        case SND_AK4381:
-                inits = inits_ak4381;
-                num_chips = ak->num_dacs / 2;
-                break;
-        default:
-                snd_BUG();
-                return;
-        }
-
-        for (chip = 0; chip < num_chips; chip++) {
-                ptr = inits;
-                while (*ptr != 0xff) {
-                        reg = *ptr++;
-                        data = *ptr++;
-                        snd_ice1712_akm4xxx_write(ak, chip, reg, data);
-                }
-        }
-}
-
 
 /*
  * initialize the akm4xxx_t record with the template
  */
-void snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *temp, ice1712_t *ice)
+int __devinit snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *temp,
+                                       const struct snd_ak4xxx_private *_priv, ice1712_t *ice)
 {
+        struct snd_ak4xxx_private *priv;
+
+        priv = kmalloc(sizeof(*priv), GFP_KERNEL);
+        if (priv == NULL)
+                return -ENOMEM;
         *ak = *temp;
-        ak->chip = ice;
-        snd_ice1712_akm4xxx_init_chip(ak);
-}
-
-
-#define AK_GET_CHIP(val)                (((val) >> 8) & 0xff)
-#define AK_GET_ADDR(val)                ((val) & 0xff)
-#define AK_GET_SHIFT(val)               (((val) >> 16) & 0x7f)
-#define AK_GET_INVERT(val)              (((val) >> 23) & 1)
-#define AK_GET_MASK(val)                (((val) >> 24) & 0xff)
-#define AK_COMPOSE(chip,addr,shift,mask) (((chip) << 8) | (addr) | ((shift) << 16) | ((mask) << 24))
-#define AK_INVERT                       (1<<23)
-
-static int snd_ice1712_akm4xxx_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
-
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = mask;
+        ak->card = ice->card;
+        *priv = *_priv;
+        ak->private_value[0] = (unsigned long)priv;
+        ak->private_data[0] = ice;
+        if (ak->ops.lock == NULL)
+                ak->ops.lock = snd_ice1712_akm4xxx_lock;
+        if (ak->ops.unlock == NULL)
+                ak->ops.unlock = snd_ice1712_akm4xxx_unlock;
+        if (ak->ops.write == NULL)
+                ak->ops.write = snd_ice1712_akm4xxx_write;
+        snd_akm4xxx_init(ak);
         return 0;
 }
 
-static int snd_ice1712_akm4xxx_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+void __devexit snd_ice1712_akm4xxx_free(ice1712_t *ice)
 {
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        int invert = AK_GET_INVERT(kcontrol->private_value);
-        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
-        unsigned char val = ak->images[chip][addr];
-        
-        ucontrol->value.integer.value[0] = invert ? mask - val : val;
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        int invert = AK_GET_INVERT(kcontrol->private_value);
-        unsigned int mask = AK_GET_MASK(kcontrol->private_value);
-        unsigned char nval = ucontrol->value.integer.value[0] % (mask+1);
-        int change;
-
-        if (invert)
-                nval = mask - nval;
-        change = ak->images[chip][addr] != nval;
-        if (change)
-                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
-        return change;
-}
-
-static int snd_ice1712_akm4xxx_ipga_gain_info(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 = 36;
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_ipga_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        ucontrol->value.integer.value[0] = ak->ipga_gain[chip][addr-4] & 0x7f;
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_ipga_gain_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        unsigned char nval = (ucontrol->value.integer.value[0] % 37) | 0x80;
-        int change = ak->ipga_gain[chip][addr] != nval;
-        if (change)
-                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
-        return change;
-}
-
-static int snd_ice1712_akm4xxx_deemphasis_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
-{
-        static char *texts[4] = {
-                "44.1kHz", "Off", "48kHz", "32kHz",
-        };
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-        uinfo->count = 1;
-        uinfo->value.enumerated.items = 4;
-        if (uinfo->value.enumerated.item >= 4)
-                uinfo->value.enumerated.item = 3;
-        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_deemphasis_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        int shift = AK_GET_SHIFT(kcontrol->private_value);
-        ucontrol->value.enumerated.item[0] = (ak->images[chip][addr] >> shift) & 3;
-        return 0;
-}
-
-static int snd_ice1712_akm4xxx_deemphasis_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        akm4xxx_t *ak = _snd_kcontrol_chip(kcontrol);
-        int chip = AK_GET_CHIP(kcontrol->private_value);
-        int addr = AK_GET_ADDR(kcontrol->private_value);
-        int shift = AK_GET_SHIFT(kcontrol->private_value);
-        unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
-        int change;
-        
-        nval = (nval << shift) | (ak->images[chip][addr] & ~(3 << shift));
-        change = ak->images[chip][addr] != nval;
-        if (change)
-                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
-        return change;
+        unsigned int akidx;
+        if (ice->akm == NULL)
+                return;
+        for (akidx = 0; akidx < ice->akm_codecs; akidx++) {
+                akm4xxx_t *ak = &ice->akm[akidx];
+                if (ak->private_value[0])
+                        kfree((void *)ak->private_value[0]);
+        }
+        kfree(ice->akm);
 }
 
 /*
- * build AK4524 controls
+ * build AK4xxx controls
  */
-
 int __devinit snd_ice1712_akm4xxx_build_controls(ice1712_t *ice)
 {
-        unsigned int idx;
+        unsigned int akidx;
         int err;
-        unsigned int akidx;
 
         for (akidx = 0; akidx < ice->akm_codecs; akidx++) {
                 akm4xxx_t *ak = &ice->akm[akidx];
-                for (idx = 0; idx < ak->num_dacs; ++idx) {
-                        snd_kcontrol_t ctl;
-                        memset(&ctl, 0, sizeof(ctl));
-                        strcpy(ctl.id.name, "DAC Volume");
-                        ctl.id.index = idx + ak->idx_offset * 2;
-                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_akm4xxx_volume_info;
-                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_akm4xxx_volume_get;
-                        ctl.put = snd_ice1712_akm4xxx_volume_put;
-                        switch (ak->type) {
-                        case SND_AK4524:
-                                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 6, 0, 127); /* register 6 & 7 */
-                                break;
-                        case SND_AK4528:
-                                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127); /* register 4 & 5 */
-                                break;
-                        case SND_AK4529: {
-                                int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb; /* registers 2-7 and b,c */
-                                ctl.private_value = AK_COMPOSE(0, val, 0, 255) | AK_INVERT;
-                                break;
-                        }
-                        case SND_AK4355:
-                                ctl.private_value = AK_COMPOSE(0, idx + 4, 0, 255); /* register 4-9, chip #0 only */
-                                break;
-                        case SND_AK4381:
-                                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 3, 0, 255); /* register 3 & 4 */
-                                break;
-                        default:
-                                return -EINVAL;
-                        }
-                        ctl.private_data = ak;
-                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
-                                return err;
-                }
-                for (idx = 0; idx < ak->num_adcs && ak->type == SND_AK4524; ++idx) {
-                        snd_kcontrol_t ctl;
-                        memset(&ctl, 0, sizeof(ctl));
-                        strcpy(ctl.id.name, "ADC Volume");
-                        ctl.id.index = idx;
-                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_akm4xxx_volume_info;
-                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_akm4xxx_volume_get;
-                        ctl.put = snd_ice1712_akm4xxx_volume_put;
-                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 127); /* register 4 & 5 */
-                        ctl.private_data = ak;
-                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
-                                return err;
-                        memset(&ctl, 0, sizeof(ctl));
-                        strcpy(ctl.id.name, "IPGA Analog Capture Volume");
-                        ctl.id.index = idx;
-                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_akm4xxx_ipga_gain_info;
-                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_akm4xxx_ipga_gain_get;
-                        ctl.put = snd_ice1712_akm4xxx_ipga_gain_put;
-                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0, 0); /* register 4 & 5 */
-                        ctl.private_data = ak;
-                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
-                                return err;
-                }
-                for (idx = 0; idx < ak->num_dacs/2; idx++) {
-                        snd_kcontrol_t ctl;
-                        memset(&ctl, 0, sizeof(ctl));
-                        strcpy(ctl.id.name, "Deemphasis");
-                        ctl.id.index = idx + ak->idx_offset;
-                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_akm4xxx_deemphasis_info;
-                        ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_akm4xxx_deemphasis_get;
-                        ctl.put = snd_ice1712_akm4xxx_deemphasis_put;
-                        switch (ak->type) {
-                        case SND_AK4524:
-                        case SND_AK4528:
-                                ctl.private_value = AK_COMPOSE(idx, 3, 0, 0); /* register 3 */
-                                break;
-                        case SND_AK4529: {
-                                int shift = idx == 3 ? 6 : (2 - idx) * 2;
-                                ctl.private_value = AK_COMPOSE(0, 8, shift, 0); /* register 8 with shift */
-                                break;
-                        }
-                        case SND_AK4355:
-                                ctl.private_value = AK_COMPOSE(idx, 3, 0, 0);
-                                break;
-                        case SND_AK4381:
-                                ctl.private_value = AK_COMPOSE(idx, 1, 1, 0);
-                                break;
-                        }
-                        ctl.private_data = ak;
-                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
-                                return err;
-                }
+                err = snd_akm4xxx_build_controls(ak);
+                if (err < 0)
+                        return err;
         }
         return 0;
 }
-
-

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

@@ -233 +233 @@
  * AK4524 on Delta 44 and 66 to choose the chip mask
  */
-static int delta_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        snd_ice1712_save_gpio_status(ak->chip);
-        ak->cs_mask =
-        ak->cs_addr = chip == 0 ? ICE1712_DELTA_CODEC_CHIP_A :
-                                  ICE1712_DELTA_CODEC_CHIP_B;
-        return 0;
+static void delta_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        struct snd_ak4xxx_private *priv = (void *)ak->private_value[0];
+        ice1712_t *ice = ak->private_data[0];
+
+        snd_ice1712_save_gpio_status(ice);
+        priv->cs_mask =
+        priv->cs_addr = chip == 0 ? ICE1712_DELTA_CODEC_CHIP_A :
+                                    ICE1712_DELTA_CODEC_CHIP_B;
 }
 
@@ -245 +247 @@
  * AK4524 on Delta1010LT to choose the chip address
  */
-static int delta1010lt_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        snd_ice1712_save_gpio_status(ak->chip);
-        ak->cs_mask = ICE1712_DELTA_1010LT_CS;
-        ak->cs_addr = chip << 4;
-        return 0;
+static void delta1010lt_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        struct snd_ak4xxx_private *priv = (void *)ak->private_value[0];
+        ice1712_t *ice = ak->private_data[0];
+
+        snd_ice1712_save_gpio_status(ice);
+        priv->cs_mask = ICE1712_DELTA_1010LT_CS;
+        priv->cs_addr = chip << 4;
 }
 
@@ -259 +263 @@
 {
         unsigned char tmp, tmp2;
-        ice1712_t *ice = ak->chip;
+        ice1712_t *ice = ak->private_data[0];
 
         if (rate == 0)  /* no hint - S/PDIF input is master, simply return */
@@ -276 +280 @@
 
         /* do it again */
-        snd_ice1712_akm4xxx_reset(ak, 1);
+        snd_akm4xxx_reset(ak, 1);
         down(&ice->gpio_mutex);
         tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ~ICE1712_DELTA_DFS;
@@ -283 +287 @@
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
         up(&ice->gpio_mutex);
-        snd_ice1712_akm4xxx_reset(ak, 0);
+        snd_akm4xxx_reset(ak, 0);
 }
 
@@ -331 +335 @@
         .num_adcs = 2,
         .num_dacs = 2,
+        .ops = {
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_audiophile_priv __devinitdata = {
         .caddr = 2,
         .cif = 0,
@@ -340 +350 @@
         .add_flags = ICE1712_DELTA_AP_CS_DIGITAL,
         .mask_flags = 0,
-        .ops = {
-                .set_rate_val = delta_ak4524_set_rate_val
-        }
 };
 
@@ -349 +356 @@
         .num_adcs = 2,
         .num_dacs = 8,
+        .ops = {
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_delta410_priv __devinitdata = {
         .caddr = 0,
         .cif = 0,
@@ -358 +371 @@
         .add_flags = ICE1712_DELTA_AP_CS_DIGITAL,
         .mask_flags = 0,
-        .ops = {
-                .set_rate_val = delta_ak4524_set_rate_val
-        }
 };
 
@@ -367 +377 @@
         .num_adcs = 8,
         .num_dacs = 8,
+        .ops = {
+                .lock = delta1010lt_ak4524_lock,
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_delta1010lt_priv __devinitdata = {
         .caddr = 2,
         .cif = 0, /* the default level of the CIF pin from AK4524 */
@@ -376 +393 @@
         .add_flags = 0,
         .mask_flags = 0,
-        .ops = {
-                .start = delta1010lt_ak4524_start,
-                .set_rate_val = delta_ak4524_set_rate_val
-        }
 };
 
@@ -386 +399 @@
         .num_adcs = 4,
         .num_dacs = 4,
+        .ops = {
+                .lock = delta_ak4524_lock,
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_delta44_priv __devinitdata = {
         .caddr = 2,
         .cif = 0, /* the default level of the CIF pin from AK4524 */
@@ -395 +415 @@
         .add_flags = 0,
         .mask_flags = 0,
-        .ops = {
-                .start = delta_ak4524_start,
-                .set_rate_val = delta_ak4524_set_rate_val
-        }
 };
 
@@ -467 +483 @@
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_AUDIOPHILE:
-                snd_ice1712_akm4xxx_init(ak, &akm_audiophile, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_audiophile, &akm_audiophile_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA410:
-                snd_ice1712_akm4xxx_init(ak, &akm_delta410, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_delta410, &akm_delta410_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA1010LT:
-                snd_ice1712_akm4xxx_init(ak, &akm_delta1010lt, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_delta1010lt, &akm_delta1010lt_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA66:
         case ICE1712_SUBDEVICE_DELTA44:
-                snd_ice1712_akm4xxx_init(ak, &akm_delta44, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_delta44, &akm_delta44_priv, ice);
                 break;
         default:
@@ -484 +500 @@
         }
 
-        return 0;
+        return err;
 }
 
@@ -535 +551 @@
         case ICE1712_SUBDEVICE_DELTADIO2496:
         case ICE1712_SUBDEVICE_DELTA66:
-        case ICE1712_SUBDEVICE_AUDIOPHILE:
-        case ICE1712_SUBDEVICE_DELTA410:
-        case ICE1712_SUBDEVICE_DELTA1010LT:
                 err = snd_ice1712_spdif_build_controls(ice);
                 if (err < 0)

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

@@ -156 +156 @@
 
 /* start callback for EWS88MT, needs to select a certain chip mask */
-static int ews88mt_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        ice1712_t *ice = ak->chip;
+static void ews88mt_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
         unsigned char tmp;
         /* assert AK4524 CS */
         if (snd_ice1712_ews88mt_chip_select(ice, ~(1 << chip) & 0x0f) < 0)
-                return -EINVAL;
+                snd_printk(KERN_ERR "fatal error (ews88mt chip select)\n");
         snd_ice1712_save_gpio_status(ice);
         tmp = ICE1712_EWS88_SERIAL_DATA |
@@ -170 +170 @@
                           ice->gpio.direction | tmp);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
-        return 0;
 }
 
 /* stop callback for EWS88MT, needs to deselect chip mask */
-static void ews88mt_ak4524_stop(akm4xxx_t *ak)
-{
-        ice1712_t *ice = ak->chip;
+static void ews88mt_ak4524_unlock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
         snd_ice1712_restore_gpio_status(ice);
         udelay(1);
@@ -183 +182 @@
 
 /* start callback for EWX24/96 */
-static int ewx2496_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        ice1712_t *ice = ak->chip;
+static void ewx2496_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->private_data[0];
         unsigned char tmp;
         snd_ice1712_save_gpio_status(ice);
@@ -195 +194 @@
                           ice->gpio.direction | tmp);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
-        return 0;
 }
 
 /* start callback for DMX 6fire */
-static int dmx6fire_ak4524_start(akm4xxx_t *ak, int chip)
-{
-        ice1712_t *ice = ak->chip;
+static void dmx6fire_ak4524_lock(akm4xxx_t *ak, int chip)
+{
+        struct snd_ak4xxx_private *priv = (void *)ak->private_value[0];
+        ice1712_t *ice = ak->private_data[0];
         unsigned char tmp;
         snd_ice1712_save_gpio_status(ice);
-        tmp = ak->cs_mask = ak->cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
+        tmp = priv->cs_mask = priv->cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
         tmp |= ICE1712_6FIRE_SERIAL_DATA |
                 ICE1712_6FIRE_SERIAL_CLOCK |
@@ -211 +210 @@
                           ice->gpio.direction | tmp);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
-        return 0;
-}
-
+}
 
 /*
@@ -329 +326 @@
         .num_dacs = 8,
         .type = SND_AK4524,
+        .ops = {
+                .lock = ews88mt_ak4524_lock,
+                .unlock = ews88mt_ak4524_unlock
+        }
+};
+
+static struct snd_ak4xxx_private akm_ews88mt_priv __devinitdata = {
         .caddr = 2,
         .cif = 1, /* CIF high */
@@ -338 +342 @@
         .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
         .mask_flags = 0,
-        .ops = {
-                .start = ews88mt_ak4524_start,
-                .stop = ews88mt_ak4524_stop
-        }
 };
 
@@ -348 +348 @@
         .num_dacs = 2,
         .type = SND_AK4524,
+        .ops = {
+                .lock = ewx2496_ak4524_lock
+        }
+};
+
+static struct snd_ak4xxx_private akm_ewx2496_priv __devinitdata = {
         .caddr = 2,
         .cif = 1, /* CIF high */
@@ -357 +363 @@
         .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
         .mask_flags = 0,
-        .ops = {
-                .start = ewx2496_ak4524_start
-        }
 };
 
@@ -366 +369 @@
         .num_dacs = 6,
         .type = SND_AK4524,
+        .ops = {
+                .lock = dmx6fire_ak4524_lock
+        }
+};
+
+static struct snd_ak4xxx_private akm_6fire_priv __devinitdata = {
         .caddr = 2,
         .cif = 1, /* CIF high */
@@ -375 +384 @@
         .add_flags = ICE1712_6FIRE_RW, /* set rw bit high */
         .mask_flags = 0,
-        .ops = {
-                .start = dmx6fire_ak4524_start
-        }
-};
-
+};
 
 /*
@@ -480 +485 @@
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88MT_NEW:
-                snd_ice1712_akm4xxx_init(ak, &akm_ews88mt, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_ews88mt, &akm_ews88mt_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_EWX2496:
-                snd_ice1712_akm4xxx_init(ak, &akm_ewx2496, ice);
+                err = snd_ice1712_akm4xxx_init(ak, &akm_ewx2496, &akm_ewx2496_priv, ice);
                 break;
         case ICE1712_SUBDEVICE_DMX6FIRE:
-                snd_ice1712_akm4xxx_init(ak, &akm_6fire, ice);
-                break;
-        }
-
-        return 0;
+                err = snd_ice1712_akm4xxx_init(ak, &akm_6fire, &akm_6fire_priv, ice);
+                break;
+        default:
+                err = 0;
+        }
+
+        return err;
 }
 
@@ -603 +610 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int channel = kcontrol->id.index;
+        int channel = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned char data;
 
@@ -622 +629 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int channel = kcontrol->id.index;
+        int channel = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned char data, ndata;
 
@@ -646 +653 @@
         .get = snd_ice1712_ews88mt_input_sense_get,
         .put = snd_ice1712_ews88mt_input_sense_put,
+        .count = 8,
 };
 
@@ -895 +903 @@
         unsigned int idx;
         int err;
-        snd_kcontrol_t *kctl;
         
-        /* all terratec cards have spdif */
-        err = snd_ice1712_spdif_build_controls(ice);
-        if (err < 0)
-                return err;
+        /* all terratec cards have spdif, but cs8427 module builds it's own controls */
+        if (ice->cs8427 == NULL) {
+                err = snd_ice1712_spdif_build_controls(ice);
+                if (err < 0)
+                        return err;
+        }
 
         /* ak4524 controls */
@@ -925 +934 @@
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88MT_NEW:
-                for (idx = 0; idx < 8; idx++) {
-                        kctl = snd_ctl_new1(&snd_ice1712_ews88mt_input_sense, ice);
-                        kctl->id.index = idx;
-                        err = snd_ctl_add(ice->card, kctl);
-                        if (err < 0)
-                                return err;
-                }
+                err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88mt_input_sense, ice));
+                if (err < 0)
+                        return err;
                 err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88mt_output_sense, ice));
                 if (err < 0)

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

@@ -119 +119 @@
 
 /*
+ *  AK4xxx stuff
+ */
+
+#include "ak4xxx.c"
+
+/*
  *  Basic I/O
  */
@@ -399 +405 @@
  */
 
-static void snd_ice1712_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return);
+static irqreturn_t snd_ice1712_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return IRQ_NONE);
         unsigned char status;
+        int handled = 0;
 
         while (1) {
@@ -408 +415 @@
                 if (status == 0)
                         break;
+                handled = 1;
                 if (status & ICE1712_IRQ_MPU1) {
                         if (ice->rmidi[0])
@@ -463 +471 @@
                 }
         }
+        return IRQ_RETVAL(handled);
 }
 
@@ -963 +972 @@
                 unsigned int what = 0;
                 unsigned int old;
-                snd_pcm_substream_t *s = substream;
-
-                do {
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
+
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == ice->playback_pro_substream) {
                                 what |= ICE1712_PLAYBACK_START;
@@ -973 +984 @@
                                 snd_pcm_trigger_done(s, substream);
                         }
-                        s = s->link_next;
-                } while (s != substream);
+                }
                 spin_lock(&ice->reg_lock);
                 old = inl(ICEMT(ice, PLAYBACK_CONTROL));
@@ -1297 +1307 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int index = kcontrol->private_value;
+        int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value;
         
         spin_lock_irq(&ice->reg_lock);
@@ -1309 +1319 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int index = kcontrol->private_value;
+        int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value;
         unsigned int nval, change;
 
@@ -1335 +1345 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int index = kcontrol->private_value;
+        int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value;
         
         spin_lock_irq(&ice->reg_lock);
@@ -1347 +1357 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int index = kcontrol->private_value;
+        int index = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id) + kcontrol->private_value;
         unsigned int nval, change;
 
@@ -1362 +1372 @@
 
 
+static snd_kcontrol_new_t snd_ice1712_multi_ctrls[] __devinitdata = {
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Multi Playback Switch",
+                .info = snd_ice1712_pro_mixer_switch_info,
+                .get = snd_ice1712_pro_mixer_switch_get,
+                .put = snd_ice1712_pro_mixer_switch_put,
+                .private_value = 0,
+                .count = 10,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Multi Playback Volume",
+                .info = snd_ice1712_pro_mixer_volume_info,
+                .get = snd_ice1712_pro_mixer_volume_get,
+                .put = snd_ice1712_pro_mixer_volume_put,
+                .private_value = 0,
+                .count = 10,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Multi Capture Switch",
+                .info = snd_ice1712_pro_mixer_switch_info,
+                .get = snd_ice1712_pro_mixer_switch_get,
+                .put = snd_ice1712_pro_mixer_switch_put,
+                .private_value = 10,
+                .count = 10,
+        },
+        {
+                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                .name = "Multi Capture Volume",
+                .info = snd_ice1712_pro_mixer_volume_info,
+                .get = snd_ice1712_pro_mixer_volume_get,
+                .put = snd_ice1712_pro_mixer_volume_put,
+                .private_value = 10,
+                .count = 10,
+        },
+};
+
 static int __devinit snd_ice1712_build_pro_mixer(ice1712_t *ice)
 {
         snd_card_t * card = ice->card;
-        snd_kcontrol_t ctl;
-        int idx, err;
-
-        /* PCM playback */
-        for (idx = 0; idx < 10; idx++) {
-                memset(&ctl, 0, sizeof(ctl));
-                strcpy(ctl.id.name, "Multi Playback Switch");
-                ctl.id.index = idx;
-                ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                ctl.info = snd_ice1712_pro_mixer_switch_info;
-                ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                ctl.get = snd_ice1712_pro_mixer_switch_get;
-                ctl.put = snd_ice1712_pro_mixer_switch_put;
-                ctl.private_value = idx;
-                ctl.private_data = ice;
-                if ((err = snd_ctl_add(card, snd_ctl_new(&ctl))) < 0)
-                        return err;
-                memset(&ctl, 0, sizeof(ctl));
-                strcpy(ctl.id.name, "Multi Playback Volume");
-                ctl.id.index = idx;
-                ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                ctl.info = snd_ice1712_pro_mixer_volume_info;
-                ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                ctl.get = snd_ice1712_pro_mixer_volume_get;
-                ctl.put = snd_ice1712_pro_mixer_volume_put;
-                ctl.private_value = idx;
-                ctl.private_data = ice;
-                if ((err = snd_ctl_add(card, snd_ctl_new(&ctl))) < 0)
-                        return err;
-        }
-
-        /* PCM capture */
-        for (idx = 0; idx < 10; idx++) {
-                memset(&ctl, 0, sizeof(ctl));
-                strcpy(ctl.id.name, "Multi Capture Switch");
-                ctl.id.index = idx;
-                ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                ctl.info = snd_ice1712_pro_mixer_switch_info;
-                ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                ctl.get = snd_ice1712_pro_mixer_switch_get;
-                ctl.put = snd_ice1712_pro_mixer_switch_put;
-                ctl.private_value = idx + 10;
-                ctl.private_data = ice;
-                if ((err = snd_ctl_add(card, snd_ctl_new(&ctl))) < 0)
-                        return err;
-                memset(&ctl, 0, sizeof(ctl));
-                strcpy(ctl.id.name, "Multi Capture Volume");
-                ctl.id.index = idx;
-                ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                ctl.info = snd_ice1712_pro_mixer_volume_info;
-                ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                ctl.get = snd_ice1712_pro_mixer_volume_get;
-                ctl.put = snd_ice1712_pro_mixer_volume_put;
-                ctl.private_value = idx + 10;
-                ctl.private_data = ice;
-                if ((err = snd_ctl_add(card, snd_ctl_new(&ctl))) < 0)
+        unsigned int idx;
+        int err;
+
+        /* multi-channel mixer */
+        for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_multi_ctrls); idx++) {
+                err = snd_ctl_add(card, snd_ctl_new1(&snd_ice1712_multi_ctrls[idx], ice));
+                if (err < 0)
                         return err;
         }
@@ -1909 +1909 @@
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = kcontrol->id.index < 2 ? 12 : 11;
+        uinfo->value.enumerated.items = snd_ctl_get_ioffidx(kcontrol, &uinfo->id) < 2 ? 12 : 11;
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
@@ -1919 +1919 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned int val, cval;
 
@@ -1945 +1945 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         int change, shift;
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned int val, old_val, nval;
         
@@ -1993 +1993 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned int val, cval;
         val = inw(ICEMT(ice, ROUTE_SPDOUT));
@@ -2013 +2013 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         int change, shift;
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         unsigned int val, old_val, nval;
         
@@ -2061 +2061 @@
         .get = snd_ice1712_pro_route_spdif_get,
         .put = snd_ice1712_pro_route_spdif_put,
+        .count = 2,
 };
 
@@ -2247 +2248 @@
 static int __devinit snd_ice1712_build_controls(ice1712_t *ice)
 {
-        unsigned int idx;
-        snd_kcontrol_t *kctl;
         int err;
 
@@ -2265 +2264 @@
                 return err;
 
-        for (idx = 0; idx < ice->num_total_dacs; idx++) {
-                kctl = snd_ctl_new1(&snd_ice1712_mixer_pro_analog_route, ice);
-                if (kctl == NULL)
-                        return -ENOMEM;
-                kctl->id.index = idx;
-                err = snd_ctl_add(ice->card, kctl);
+        if (ice->num_total_dacs > 0) {
+                snd_kcontrol_new_t tmp = snd_ice1712_mixer_pro_analog_route;
+                tmp.count = ice->num_total_dacs;
+                err = snd_ctl_add(ice->card, snd_ctl_new1(&tmp, ice));
                 if (err < 0)
                         return err;
         }
 
-        for (idx = 0; idx < 2; idx++) {
-                kctl = snd_ctl_new1(&snd_ice1712_mixer_pro_spdif_route, ice);
-                if (kctl == NULL)
-                        return -ENOMEM;
-                kctl->id.index = idx;
-                err = snd_ctl_add(ice->card, kctl);
-                if (err < 0)
-                        return err;
-        }
+        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_pro_spdif_route, ice));
+        if (err < 0)
+                return err;
 
         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_pro_volume_rate, ice));
@@ -2324 +2315 @@
                 kfree_nocheck(ice->res_profi_port);
         }
-        if (ice->akm)
-                kfree(ice->akm);
+        snd_ice1712_akm4xxx_free(ice);
         snd_magic_kfree(ice);
         return 0;

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

@@ -27 +27 @@
 #include <sound/rawmidi.h>
 #include <sound/i2c.h>
+#include <sound/ak4xxx-adda.h>
 #include <sound/pcm.h>
 
@@ -215 +216 @@
 
 typedef struct _snd_ice1712 ice1712_t;
-typedef struct snd_ak4xxx akm4xxx_t;
 
 typedef struct {
@@ -255 +255 @@
 
 
-struct snd_ak4xxx {
-        unsigned int num_adcs;          /* AK4524 or AK4528 ADCs */
-        unsigned int num_dacs;          /* AK4524 or AK4528 DACs */
-        unsigned char images[4][16];    /* saved register image */
-        unsigned char ipga_gain[4][2];  /* saved register image for IPGA (AK4528) */
-        ice1712_t *chip;
-        /* template should fill the following fields */
-        unsigned int idx_offset;        /* control index offset */
-        enum {
-                SND_AK4524, SND_AK4528, SND_AK4529, SND_AK4355, SND_AK4381
-        } type;
+struct snd_ak4xxx_private {
         unsigned int cif: 1;            /* CIF mode */
         unsigned char caddr;            /* C0 and C1 bits */
@@ -276 +266 @@
         unsigned int mask_flags;        /* total mask bits */
         struct snd_akm4xxx_ops {
-                int (*start)(akm4xxx_t *ak, int chip);
-                void (*stop)(akm4xxx_t *ak);
                 void (*set_rate_val)(akm4xxx_t *ak, unsigned int rate);
         } ops;
@@ -440 +428 @@
 int snd_ice1712_spdif_build_controls(ice1712_t *ice);
 
-void snd_ice1712_akm4xxx_write(akm4xxx_t *ice, int chip, unsigned char addr, unsigned char data);
-void snd_ice1712_akm4xxx_reset(akm4xxx_t *ice, int state);
-void snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *template, ice1712_t *ice);
+int snd_ice1712_akm4xxx_init(akm4xxx_t *ak, const akm4xxx_t *template, const struct snd_ak4xxx_private *priv, ice1712_t *ice);
+void snd_ice1712_akm4xxx_free(ice1712_t *ice);
 int snd_ice1712_akm4xxx_build_controls(ice1712_t *ice);
 

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

@@ -89 +89 @@
 
 /*
+ *  AK4xxx stuff
+ */
+
+#include "ak4xxx.c"
+
+/*
  *  Basic I/O
  */
@@ -195 +201 @@
  */
 
-static void snd_vt1724_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return);
+static irqreturn_t snd_vt1724_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, dev_id, return IRQ_NONE);
         unsigned char status;
+        int handled = 0;
 
         while (1) {
@@ -204 +211 @@
                 if (status == 0)
                         break;
-                
+
+                handled = 1;            
                 /*  these should probably be separated at some point, 
                         but as we don't currently have MPU support on the board I will leave it */
@@ -243 +251 @@
                 }
         }
+        return IRQ_RETVAL(handled);
 }
 
@@ -282 +291 @@
         unsigned int what;
         unsigned int old;
+        struct list_head *pos;
         snd_pcm_substream_t *s;
 
@@ -288 +298 @@
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
                 what = 0;
-                s = substream;
-                do {
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == ice->playback_pro_substream)
                                 what |= VT1724_PDMA0_PAUSE;
@@ -298 +308 @@
                         else if (s == ice->capture_con_substream)
                                 what |= VT1724_RDMA1_PAUSE;
-                        s = s->link_next;
-                } while (s != substream);
+                }
                 spin_lock(&ice->reg_lock);
                 old = inl(ICEMT1724(ice, DMA_PAUSE));
@@ -314 +323 @@
                 what = 0;
                 s = substream;
-                do {
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == ice->playback_pro_substream) {
                                 what |= VT1724_PDMA0_START;
@@ -328 +338 @@
                                 snd_pcm_trigger_done(s, substream);
                         }
-                        s = s->link_next;
-                } while (s != substream);
+                }
                 spin_lock(&ice->reg_lock);
                 old = inl(ICEMT1724(ice, DMA_CONTROL));
@@ -1295 +1304 @@
 }
 
-static snd_kcontrol_new_t snd_vt1724_pro_internal_clock = __devinitdata {
+static snd_kcontrol_new_t snd_vt1724_pro_internal_clock __devinitdata = {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         .name = "Multi Track Internal Clock",
@@ -1450 +1459 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         ucontrol->value.enumerated.item[0] = get_route_val(ice, analog_route_shift(idx));
         return 0;
@@ -1458 +1467 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         return put_route_val(ice, ucontrol->value.enumerated.item[0],
                              analog_route_shift(idx));
@@ -1466 +1475 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         ucontrol->value.enumerated.item[0] = get_route_val(ice, digital_route_shift(idx));
         return 0;
@@ -1474 +1483 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int idx = kcontrol->id.index;
+        int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
         return put_route_val(ice, ucontrol->value.enumerated.item[0],
                              digital_route_shift(idx));
@@ -1493 +1502 @@
         .get = snd_vt1724_pro_route_spdif_get,
         .put = snd_vt1724_pro_route_spdif_put,
+        .count = 2,
 };
 
@@ -1603 +1613 @@
 {
         int err;
-        unsigned int idx;
         snd_kcontrol_t *kctl;
 
         snd_assert(ice->pcm != NULL, return -EIO);
 
-        for (idx = 0; idx < 2; idx++) {
-                kctl = snd_ctl_new1(&snd_vt1724_mixer_pro_spdif_route, ice);
-                if (kctl == NULL)
-                        return -ENOMEM;
-                kctl->id.index = idx;
-                err = snd_ctl_add(ice->card, kctl);
-                if (err < 0)
-                        return err;
-        }
+        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_mixer_pro_spdif_route, ice));
+        if (err < 0)
+                return err;
 
         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_spdif_switch, ice));
@@ -1647 +1650 @@
 static int __devinit snd_vt1724_build_controls(ice1712_t *ice)
 {
-        unsigned int idx;
-        snd_kcontrol_t *kctl;
         int err;
 
@@ -1665 +1666 @@
                 return err;
 
-        for (idx = 0; idx < ice->num_total_dacs; idx++) {
-                kctl = snd_ctl_new1(&snd_vt1724_mixer_pro_analog_route, ice);
-                if (kctl == NULL)
-                        return -ENOMEM;
-                kctl->id.index = idx;
-                err = snd_ctl_add(ice->card, kctl);
+        if (ice->num_total_dacs > 0) {
+                snd_kcontrol_new_t tmp = snd_vt1724_mixer_pro_analog_route;
+                tmp.count = ice->num_total_dacs;
+                err = snd_ctl_add(ice->card, snd_ctl_new1(&tmp, ice));
                 if (err < 0)
                         return err;
@@ -1703 +1702 @@
                 kfree_nocheck(ice->res_profi_port);
         }
-        if (ice->akm)
-                kfree(ice->akm);
+        snd_ice1712_akm4xxx_free(ice);
         snd_magic_kfree(ice);
         return 0;

GPL/branches/alsa-resync1/alsa-kernel/pci/ice1712/makefile.os2

@@ -13 +13 @@
 #
 #===================================================================
-FILE1    = ak4524.obj delta.obj ews.obj hoontech.obj ice1712.obj
+FILE1    = ak4xxx.obj delta.obj ews.obj hoontech.obj ice1712.obj
 FILE2    = ice1724.obj revo.obj
 FILE3    = 

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

@@ -66 +66 @@
 
         /* reset DFS */
-        snd_ice1712_akm4xxx_reset(ak, 1);
+        snd_akm4xxx_reset(ak, 1);
         tmp = ak->images[0][reg];
         tmp &= ~(0x03 << shift);
         tmp |= dfs << shift;
-        snd_ice1712_akm4xxx_write(ak, 0, reg, tmp);
-        snd_ice1712_akm4xxx_reset(ak, 0);
+        snd_akm4xxx_write(ak, 0, reg, tmp);
+        snd_akm4xxx_reset(ak, 0);
 }
 
@@ -81 +81 @@
         .type = SND_AK4381,
         .num_dacs = 2,
+        .ops = {
+                .set_rate_val = revo_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_revo_front_priv __devinitdata = {
         .caddr = 1,
         .cif = 0,
@@ -90 +96 @@
         .add_flags = VT1724_REVO_CCLK, /* high at init */
         .mask_flags = 0,
-        .ops = {
-                .set_rate_val = revo_set_rate_val
-        }
 };
 
@@ -99 +102 @@
         .idx_offset = 1,
         .num_dacs = 6,
+        .ops = {
+                .set_rate_val = revo_set_rate_val
+        }
+};
+
+static struct snd_ak4xxx_private akm_revo_surround_priv __devinitdata = {
         .caddr = 3,
         .cif = 0,
@@ -108 +117 @@
         .add_flags = VT1724_REVO_CCLK, /* high at init */
         .mask_flags = 0,
-        .ops = {
-                .set_rate_val = revo_set_rate_val
-        }
 };
 
@@ -134 +140 @@
         switch (ice->eeprom.subvendor) {
         case VT1724_SUBDEVICE_REVOLUTION71:
-                snd_ice1712_akm4xxx_init(ak, &akm_revo_front, ice);
-                snd_ice1712_akm4xxx_init(ak + 1, &akm_revo_surround, ice);
+                snd_ice1712_akm4xxx_init(ak, &akm_revo_front, &akm_revo_front_priv, ice);
+                snd_ice1712_akm4xxx_init(ak + 1, &akm_revo_surround, &akm_revo_surround_priv, ice);
                 /* unmute all codecs */
                 snd_ice1712_gpio_write_bits(ice, VT1724_REVO_MUTE, VT1724_REVO_MUTE);

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

@@ -150 +150 @@
 #define MAILBOX2_OFFSET      0x48       // location of mailbox 2 relative to base address
 #define MAILBOX3_OFFSET      0x4c       // location of mailbox 3 relative to base address
-#define OUT_DOORBELL_OFFSET  0x60       // location of PCI to local doorbell "
-#define IN_DOORBELL_OFFSET   0x64       // location of local to PCI doorbell "
-#define STATUS_REG_OFFSET    0x68       // location of interrupt control/status register "
+#define OUT_DOORBELL_OFFSET  0x60       // location of PCI to local doorbell
+#define IN_DOORBELL_OFFSET   0x64       // location of local to PCI doorbell
+#define STATUS_REG_OFFSET    0x68       // location of interrupt control/status register
 #define PCI_CONTROL_OFFSET   0x6c       // location of the EEPROM, PCI, User I/O, init control
                                         //    register
@@ -330 +330 @@
 
         spinlock_t    lock;
+        struct semaphore open_mutex;
+
+        struct timer_list timer;        /* timer callback for checking ack of stop request */
+        int stop_pending_cnt;           /* counter for stop pending check */
 
         wait_queue_head_t wait;
@@ -603 +607 @@
 }
 
-static void snd_korg1212_WaitForCardStopAck(korg1212_t *korg1212)
-{
-        u32 endtime = jiffies + 2 * HZ;
-
-#if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck.in [%s] %lu %lu\n", stateName[korg1212->cardState], jiffies, korg1212->inIRQ);
-#endif
-
-        if (korg1212->inIRQ)
-                return;
-
-        do {
+/* spinlock already held */
+static void snd_korg1212_SendStop(korg1212_t *korg1212)
+{
+        if (! korg1212->stop_pending_cnt) {
+                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
+                /* program the timer */
+                korg1212->stop_pending_cnt = HZ;
+                korg1212->timer.expires = jiffies + 1;
+                add_timer(&korg1212->timer);
+        }
+}
+
+static void snd_korg1212_SendStopAndWait(korg1212_t *korg1212)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&korg1212->lock, flags);
+        snd_korg1212_SendStop(korg1212);
+        spin_unlock_irqrestore(&korg1212->lock, flags);
+        sleep_on_timeout(&korg1212->wait, (HZ * 3) / 2);
+}
+
+/* timer callback for checking the ack of stop request */
+static void snd_korg1212_timer_func(unsigned long data)
+{
+        korg1212_t *korg1212 = snd_magic_cast(korg1212_t, (void*)data, return);
+        
+        spin_lock(&korg1212->lock);
                 if (readl(&korg1212->sharedBufferPtr->cardCommand) == 0) {
-#if K1212_DEBUG_LEVEL > 0
-                        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck.out [%s] %lu %lu\n", stateName[korg1212->cardState], jiffies, korg1212->inIRQ);
-#endif
-                        return;
+                /* ack'ed */
+                korg1212->stop_pending_cnt = 0;
+                wake_up(&korg1212->wait);
+#if K1212_DEBUG_LEVEL > 1
+                K1212_DEBUG_PRINTK("K1212_DEBUG: Stop ack'ed [%s]\n", stateName[korg1212->cardState]);
+#endif
+        } else {
+                if (--korg1212->stop_pending_cnt > 0) {
+                        /* reprogram timer */
+                        korg1212->timer.expires = jiffies + 1;
+                        add_timer(&korg1212->timer);
+                } else {
+                        snd_printd("korg1212_timer_func timeout\n");
+        writel(0, &korg1212->sharedBufferPtr->cardCommand);
+                        wake_up(&korg1212->wait);
+#if K1212_DEBUG_LEVEL > 0
+                        K1212_DEBUG_PRINTK("K1212_DEBUG: Stop timeout [%s]\n", stateName[korg1212->cardState]);
+#endif
                 }
-                if (!korg1212->inIRQ)
-                        schedule();
-        } while (time_before(jiffies, endtime));
-
-#if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck.out TO [%s] %lu %lu\n", stateName[korg1212->cardState], jiffies, korg1212->inIRQ);
-#endif
-        writel(0, &korg1212->sharedBufferPtr->cardCommand);
+        }
+        spin_unlock(&korg1212->lock);
 }
 
 static void snd_korg1212_TurnOnIdleMonitor(korg1212_t *korg1212)
 {
+        unsigned long flags;
+
         udelay(INTERCOMMAND_DELAY);
+        spin_lock_irqsave(&korg1212->lock, flags);
         korg1212->idleMonitorOn = 1;
         rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
                         K1212_MODE_MonitorOn, 0, 0, 0);
+        spin_unlock_irqrestore(&korg1212->lock, flags);
 }
 
@@ -642 +673 @@
 {
         if (korg1212->idleMonitorOn) {
-                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
-                snd_korg1212_WaitForCardStopAck(korg1212);
+                snd_korg1212_SendStopAndWait(korg1212);
                 korg1212->idleMonitorOn = 0;
         }
 }
 
-static void snd_korg1212_setCardState(korg1212_t * korg1212, CardState csState)
-{
-        switch (csState) {
-                case K1212_STATE_READY:
-                        snd_korg1212_TurnOnIdleMonitor(korg1212);
-                        break;
-
-                case K1212_STATE_OPEN:
-                        snd_korg1212_TurnOffIdleMonitor(korg1212);
-                        break;
-
-                default:
-                        break;
-        }
-
+static inline void snd_korg1212_setCardState(korg1212_t * korg1212, CardState csState)
+{
         korg1212->cardState = csState;
 }
@@ -671 +688 @@
         K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n", stateName[korg1212->cardState], korg1212->opencnt);
 #endif
-        if (korg1212->opencnt++ == 0)
+        down(&korg1212->open_mutex);
+        if (korg1212->opencnt++ == 0) {
+                snd_korg1212_TurnOffIdleMonitor(korg1212);
         snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
+        }
+
+        up(&korg1212->open_mutex);
         return 1;
 }
@@ -682 +704 @@
 #endif
 
-        if (--(korg1212->opencnt))
+        down(&korg1212->open_mutex);
+        if (--(korg1212->opencnt)) {
+                up(&korg1212->open_mutex);
                 return 0;
+        }
 
         if (korg1212->cardState == K1212_STATE_SETUP) {
@@ -692 +717 @@
 #endif
 
-                if (rc != K1212_CMDRET_Success)
+                if (rc != K1212_CMDRET_Success) {
+                        up(&korg1212->open_mutex);
                         return 0;
+                }
         } else if (korg1212->cardState > K1212_STATE_SETUP) {
-                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
-                snd_korg1212_WaitForCardStopAck(korg1212);
-        }
-
-        if (korg1212->cardState > K1212_STATE_READY)
+                snd_korg1212_SendStopAndWait(korg1212);
+        }
+
+        if (korg1212->cardState > K1212_STATE_READY) {
+                snd_korg1212_TurnOnIdleMonitor(korg1212);
                 snd_korg1212_setCardState(korg1212, K1212_STATE_READY);
-
+        }
+
+        up(&korg1212->open_mutex);
         return 0;
 }
 
+/* spinlock already held */
 static int snd_korg1212_SetupForPlay(korg1212_t * korg1212)
 {
@@ -727 +757 @@
 }
 
+/* spinlock already held */
 static int snd_korg1212_TriggerPlay(korg1212_t * korg1212)
 {
@@ -749 +780 @@
 }
 
+/* spinlock already held */
 static int snd_korg1212_StopPlay(korg1212_t * korg1212)
 {
@@ -760 +792 @@
         korg1212->setcnt = 0;
 
-        if (korg1212->cardState != K1212_STATE_ERRORSTOP) {
-                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
-                snd_korg1212_WaitForCardStopAck(korg1212);
-        }
+        if (korg1212->cardState != K1212_STATE_ERRORSTOP)
+                snd_korg1212_SendStop(korg1212);
+
         snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
         return 0;
@@ -790 +821 @@
                                 return 0;
                         } else {
-                                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
-                                snd_korg1212_WaitForCardStopAck(korg1212);
+                                snd_korg1212_SendStopAndWait(korg1212);
                                 snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
                         }
@@ -885 +915 @@
                                    //  the card's eeprom control register.
         u16       count;
+        unsigned long flags;
 
 #if K1212_DEBUG_LEVEL > 0
@@ -901 +932 @@
         // ----------------------------------------------------------------------------
         if (korg1212->cardState == K1212_STATE_MONITOR || korg1212->idleMonitorOn) {
-                writel(0xffffffff, &korg1212->sharedBufferPtr->cardCommand);
                 monModeSet = 1;
-                snd_korg1212_WaitForCardStopAck(korg1212);
+                snd_korg1212_SendStopAndWait(korg1212);
         } else
                 monModeSet = 0;
+
+        spin_lock_irqsave(&korg1212->lock, flags);
 
         // ----------------------------------------------------------------------------
@@ -1017 +1049 @@
         }
 
+        spin_unlock_irqrestore(&korg1212->lock, flags);
+
         return 1;
 }
@@ -1090 +1124 @@
 #endif
 
+        snd_korg1212_TurnOnIdleMonitor(korg1212);
         snd_korg1212_setCardState(korg1212, K1212_STATE_READY);
 
@@ -1096 +1131 @@
 #endif
 
-        wake_up_interruptible(&korg1212->wait);
-}
-
-static void snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+        snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_COMPLETE);
+}
+
+static irqreturn_t snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         u32 doorbellValue;
-        korg1212_t *korg1212 = snd_magic_cast(korg1212_t, dev_id, return);
+        korg1212_t *korg1212 = snd_magic_cast(korg1212_t, dev_id, return IRQ_NONE);
 
         if(irq != korg1212->irq)
-                return;
+                return IRQ_NONE;
 
         doorbellValue = readl(korg1212->inDoorbellPtr);
 
         if (!doorbellValue)
-                return;
+                return IRQ_HANDLED;
+
+        spin_lock(&korg1212->lock);
 
         writel(doorbellValue, korg1212->inDoorbellPtr);
@@ -1124 +1161 @@
                         K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DNLD count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]);
 #endif
-                        if (korg1212->cardState == K1212_STATE_DSP_IN_PROCESS) {
-                                        snd_korg1212_setCardState(korg1212, K1212_STATE_DSP_COMPLETE);
-                                        snd_korg1212_OnDSPDownloadComplete(korg1212);
-                        }
+                        if (korg1212->cardState == K1212_STATE_DSP_IN_PROCESS)
+                                wake_up(&korg1212->wait);
                         break;
 
@@ -1167 +1202 @@
 
                                 if (korg1212->capture_substream) {
+                                        spin_unlock(&korg1212->lock);
                                         snd_pcm_period_elapsed(korg1212->capture_substream);
+                                        spin_lock(&korg1212->lock);
                                 }
 
                                 if (korg1212->playback_substream) {
+                                        spin_unlock(&korg1212->lock);
                                         snd_pcm_period_elapsed(korg1212->playback_substream);
+                                        spin_lock(&korg1212->lock);
                                 }
                         }
@@ -1178 +1217 @@
 
         korg1212->inIRQ--;
+
+        spin_unlock(&korg1212->lock);
+        return IRQ_HANDLED;
 }
 
@@ -1206 +1248 @@
 #endif
 
-        interruptible_sleep_on_timeout(&korg1212->wait, HZ * 4);
+        if (! sleep_on_timeout(&korg1212->wait, HZ * 4))
+                return -EBUSY; /* timeout */
+
+        snd_korg1212_OnDSPDownloadComplete(korg1212);
 
         return 0;
@@ -1364 +1409 @@
         snd_pcm_set_sync(substream);    // ???
 
-        spin_lock_irqsave(&korg1212->lock, flags);
-
         snd_korg1212_OpenCard(korg1212);
 
+        runtime->hw = snd_korg1212_playback_info;
         runtime->dma_area = (char *) korg1212->playDataBufsPtr;
         runtime->dma_bytes = K1212_BUF_SIZE;
+
+        spin_lock_irqsave(&korg1212->lock, flags);
 
         korg1212->playback_substream = substream;
@@ -1394 +1440 @@
         snd_pcm_set_sync(substream);    // ???
 
-        spin_lock_irqsave(&korg1212->lock, flags);
-
         snd_korg1212_OpenCard(korg1212);
 
@@ -1402 +1446 @@
         runtime->dma_bytes = K1212_BUF_SIZE;
 
+        spin_lock_irqsave(&korg1212->lock, flags);
+
         korg1212->capture_substream = substream;
         korg1212->periodsize = K1212_PERIODS;
@@ -1428 +1474 @@
         korg1212->periodsize = 0;
 
-        snd_korg1212_CloseCard(korg1212);
-
         spin_unlock_irqrestore(&korg1212->lock, flags);
+
+        snd_korg1212_CloseCard(korg1212);
         return 0;
 }
@@ -1448 +1494 @@
         korg1212->periodsize = 0;
 
-        snd_korg1212_CloseCard(korg1212);
-
         spin_unlock_irqrestore(&korg1212->lock, flags);
+
+        snd_korg1212_CloseCard(korg1212);
         return 0;
 }
@@ -1508 +1554 @@
 {
         korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
-        unsigned long flags;
         int rc;
 
@@ -1515 +1560 @@
 #endif
 
-        spin_lock_irqsave(&korg1212->lock, flags);
+        spin_lock(&korg1212->lock);
+
+        /* FIXME: we should wait for ack! */
+        if (korg1212->stop_pending_cnt > 0) {
+#if K1212_DEBUG_LEVEL > 0
+                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_prepare - Stop is pending... [%s]\n", stateName[korg1212->cardState]);
+#endif
+                spin_unlock(&korg1212->lock);
+                return -EAGAIN;
+                /*
+                writel(0, &korg1212->sharedBufferPtr->cardCommand);
+                del_timer(&korg1212->timer);
+                korg1212->stop_pending_cnt = 0;
+                */
+        }
 
         rc = snd_korg1212_SetupForPlay(korg1212);
+
         korg1212->currentBuffer = 0;
 
-        spin_unlock_irqrestore(&korg1212->lock, flags);
+        spin_unlock(&korg1212->lock);
 
         return rc ? -EINVAL : 0;
@@ -1535 +1595 @@
 #endif
 
+        spin_lock(&korg1212->lock);
         switch (cmd) {
                 case SNDRV_PCM_TRIGGER_START:
@@ -1566 +1627 @@
                         break;
         }
+        spin_unlock(&korg1212->lock);
         return rc ? -EINVAL : 0;
 }
@@ -1894 +1956 @@
         }
 
+        spin_unlock_irqrestore(&korg1212->lock, flags);
+
         if (change)
                 snd_korg1212_WriteADCSensitivity(korg1212);
-
-        spin_unlock_irqrestore(&korg1212->lock, flags);
 
         return change;
@@ -2151 +2213 @@
         init_waitqueue_head(&korg1212->wait);
         spin_lock_init(&korg1212->lock);
+        init_MUTEX(&korg1212->open_mutex);
+        init_timer(&korg1212->timer);
+        korg1212->timer.function = snd_korg1212_timer_func;
+        korg1212->timer.data = (unsigned long)korg1212;
 
         korg1212->irq = -1;

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

@@ -1154 +1154 @@
 }
 
-static void
+static irqreturn_t
 snd_rme96_interrupt(int irq,
                     void *dev_id,
@@ -1166 +1166 @@
               (rme96->rcreg & RME96_RCR_IRQ_2)))
         {
-                return;
+                return IRQ_NONE;
         }
         
@@ -1179 +1179 @@
                 writel(0, rme96->iobase + RME96_IO_CONFIRM_REC_IRQ);
         }
+        return IRQ_HANDLED;
 }
 

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

@@ -3 +3 @@
  *
  *      Copyright (c) 2002  Paul Davis
+ *                          Marcus Andersson
+ *                          Thomas Charbonnel
  *
  *   This program is free software; you can redistribute it and/or modify
@@ -21 +23 @@
 
 #include <sound/driver.h>
-#include <asm/io.h>
-#include <asm/byteorder.h>
 #include <linux/delay.h>
-#include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
+
 #include <sound/core.h>
 #include <sound/control.h>
@@ -33 +34 @@
 #include <sound/asoundef.h>
 #include <sound/rawmidi.h>
+#include <sound/hwdep.h>
 #define SNDRV_GET_ID
 #include <sound/initval.h>
-
-#include "multiface_firmware.dat"
-#include "digiface_firmware.dat"
+#include <sound/hdsp.h>
+
+#include <asm/byteorder.h>
+#include <asm/current.h>
+#include <asm/io.h>
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
@@ -44 +48 @@
 static int precise_ptr[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0 }; /* Enable precise pointer */
 static int line_outs_monitor[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0}; /* Send all inputs/playback to line outs */
-static int force_firmware[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0}; /* Force firmware reload */
 
 MODULE_PARM(index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
@@ -61 +64 @@
 MODULE_PARM_DESC(line_outs_monitor, "Send all input and playback streams to line outs by default.");
 MODULE_PARM_SYNTAX(line_outs_monitor, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC);
-MODULE_PARM(force_firmware,"1-" __MODULE_STRING(SNDRV_CARDS) "i");
-MODULE_PARM_DESC(force_firmware, "Force a reload of the I/O box firmware");
-MODULE_PARM_SYNTAX(force_firmware, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC);
-MODULE_AUTHOR("Paul Davis <pbd@op.net>");
+MODULE_AUTHOR("Paul Davis <paul@linuxaudiosystems.com>, Marcus Andersson, Thomas Charbonnel <thomas@undata.org>");
 MODULE_DESCRIPTION("RME Hammerfall DSP");
 MODULE_LICENSE("GPL");
 MODULE_CLASSES("{sound}");
-MODULE_DEVICES("{{RME,Hammerfall-DSP}}");
-
-typedef enum {
-        Digiface,
-        Multiface
-} HDSP_Type;
+MODULE_DEVICES("{{RME Hammerfall-DSP},"
+                "{RME HDSP-9652}}");
 
 #define HDSP_MAX_CHANNELS        26
@@ -79 +75 @@
 #define DIGIFACE_DS_CHANNELS     14
 #define MULTIFACE_SS_CHANNELS    18
-#define MULTIFACE_DS_CHANNELS    10
+#define MULTIFACE_DS_CHANNELS    14
 
 /* Write registers. These are defined as byte-offsets from the iobase value.
@@ -119 +115 @@
 #define HDSP_playbackPeakLevel  4096  /* 26 * 32 bit values */
 #define HDSP_inputPeakLevel     4224  /* 26 * 32 bit values */
-#define HDSP_outputPeakLevel    4100  /* 26 * 32 bit values */
+#define HDSP_outputPeakLevel    4352  /* (26+2) * 32 bit values */
 #define HDSP_playbackRmsLevel   4612  /* 26 * 64 bit values */
-#define HDSP_inputRmsLevel      4884  /* 26 * 64 bit values */
+#define HDSP_inputRmsLevel      4868  /* 26 * 64 bit values */
 
 #define HDSP_IO_EXTENT     5192
@@ -144 +140 @@
 /* Control Register bits */
 
-#define HDSP_Start                (1<<0)  // start engine
-#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_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_DoubleSpeed          (1<<8)  // 0=normal speed, 1=double speed
-#define HDSP_SPDIFProfessional    (1<<9)  // 0=consumer, 1=professional
-#define HDSP_SPDIFEmphasis        (1<<10) // 0=none, 1=on
-#define HDSP_SPDIFNonAudio        (1<<11) // 0=off, 1=on
-#define HDSP_SPDIFOpticalOut      (1<<12) // 1=use 1st ADAT connector for SPDIF, 0=do not
+#define HDSP_Start                (1<<0)  /* start engine */
+#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_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_DoubleSpeed          (1<<8)  /* 0=normal speed, 1=double speed */
+#define HDSP_SPDIFProfessional    (1<<9)  /* 0=consumer, 1=professional */
+#define HDSP_SPDIFEmphasis        (1<<10) /* 0=none, 1=on */
+#define HDSP_SPDIFNonAudio        (1<<11) /* 0=off, 1=on */
+#define HDSP_SPDIFOpticalOut      (1<<12) /* 1=use 1st ADAT connector for SPDIF, 0=do not */
 #define HDSP_SyncRef2             (1<<13) 
 #define HDSP_SPDIFInputSelect0    (1<<14) 
@@ -182 +178 @@
 #define HDSP_SyncRef_ADAT_SYNC  (HDSP_SyncRef0|HDSP_SyncRef2)
 
-/* Preferred sync source choices - used by "sync_pref" control switch */
-
-#define HDSP_SYNC_FROM_SELF      0
-#define HDSP_SYNC_FROM_WORD      1
-#define HDSP_SYNC_FROM_ADAT_SYNC 2
-#define HDSP_SYNC_FROM_SPDIF     3
-#define HDSP_SYNC_FROM_ADAT1     4
-#define HDSP_SYNC_FROM_ADAT2     5
-#define HDSP_SYNC_FROM_ADAT3     6
+/* 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
+
+/* 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_ADAT2     4
+#define HDSP_SYNC_FROM_ADAT3     5
+
+/* SyncCheck status */
+
+#define HDSP_SYNC_CHECK_NO_LOCK 0
+#define HDSP_SYNC_CHECK_LOCK    1
+#define HDSP_SYNC_CHECK_SYNC    2
+
+/* AutoSync references - used by "autosync_ref" control switch */
+
+#define HDSP_AUTOSYNC_FROM_WORD      0
+#define HDSP_AUTOSYNC_FROM_ADAT_SYNC 1
+#define HDSP_AUTOSYNC_FROM_SPDIF     2
+#define HDSP_AUTOSYNC_FROM_NONE      3
+#define HDSP_AUTOSYNC_FROM_ADAT1     4
+#define HDSP_AUTOSYNC_FROM_ADAT2     5
+#define HDSP_AUTOSYNC_FROM_ADAT3     6
 
 /* Possible sources of S/PDIF input */
@@ -238 +259 @@
 #define HDSP_spdifFrequencyMask    (HDSP_spdifFrequency0|HDSP_spdifFrequency1|HDSP_spdifFrequency2)
 
-#define HDSP_spdifFrequency32KHz   (HDSP_spdifFrequency0|HDSP_spdifFrequency1|HDSP_spdifFrequency2)
-#define HDSP_spdifFrequency44_1KHz (HDSP_spdifFrequency2|HDSP_spdifFrequency1)
-#define HDSP_spdifFrequency48KHz   (HDSP_spdifFrequency0|HDSP_spdifFrequency2)
-
-#define HDSP_spdifFrequency64KHz    0
-#define HDSP_spdifFrequency88_2KHz (HDSP_spdifFrequency2)
-#define HDSP_spdifFrequency96KHz   (HDSP_spdifFrequency0|HDSP_spdifFrequency1)
+#define HDSP_spdifFrequency32KHz   (HDSP_spdifFrequency0)
+#define HDSP_spdifFrequency44_1KHz (HDSP_spdifFrequency1)
+#define HDSP_spdifFrequency48KHz   (HDSP_spdifFrequency0|HDSP_spdifFrequency1)
+
+#define HDSP_spdifFrequency64KHz   (HDSP_spdifFrequency2)
+#define HDSP_spdifFrequency88_2KHz (HDSP_spdifFrequency0|HDSP_spdifFrequency2)
+#define HDSP_spdifFrequency96KHz   (HDSP_spdifFrequency2|HDSP_spdifFrequency1)
 
 /* Status2 Register bits */
@@ -278 +299 @@
 #define HDSP_SelSyncRef_ADAT_SYNC  (HDSP_SelSyncRef0|HDSP_SelSyncRef2)
 
-/* FIFO wait times, defined in terms of loops on readl() */
-
-#define HDSP_LONG_WAIT   40000
-#define HDSP_SHORT_WAIT  100
-
-/* Computing addresses for adjusting gains */
-
-#define INPUT_TO_OUTPUT_KEY(in,out)     ((64 * (out)) + (in))
-#define PLAYBACK_TO_OUTPUT_KEY(chn,out) ((64 * (out)) + 32 + (chn))
+/* Card state flags */
+
+#define HDSP_InitializationComplete  (1<<0)
+#define HDSP_FirmwareLoaded          (1<<1)
+#define HDSP_FirmwareCached          (1<<2)
+
+/* FIFO wait times, defined in terms of 1/10ths of msecs */
+
+#define HDSP_LONG_WAIT   5000
+#define HDSP_SHORT_WAIT  30
+
 #define UNITY_GAIN                       32768
 #define MINUS_INFINITY_GAIN              0
@@ -314 +337 @@
 #define HDSP_DMA_AREA_KILOBYTES (HDSP_DMA_AREA_BYTES/1024)
 
-#define HDSP_MATRIX_MIXER_SIZE 2048
-
-typedef struct _hdsp      hdsp_t;
-typedef struct _hdsp_midi hdsp_midi_t;
+typedef struct _hdsp          hdsp_t;
+typedef struct _hdsp_midi     hdsp_midi_t;
 
 struct _hdsp_midi {
@@ -328 +349 @@
     struct timer_list        timer;
     spinlock_t               lock;
+    int                      pending;
 };
 
 struct _hdsp {
-        spinlock_t lock;
-        snd_pcm_substream_t *capture_substream;
-        snd_pcm_substream_t *playback_substream;
-        hdsp_midi_t midi[2];
-        int precise_ptr;
-        u32 control_register;            /* cached value */
-        u32 creg_spdif;
-        u32 creg_spdif_stream;
-        char *card_name;                 /* digiface/multiface */
-        HDSP_Type type;                  /* ditto, but for code use */
-        size_t period_bytes;             /* guess what this is */
-        unsigned char ds_channels;
-        unsigned char ss_channels;       /* different for multiface/digiface */
-        void *capture_buffer_unaligned;  /* original buffer addresses */
-        void *playback_buffer_unaligned; /* original buffer addresses */
-        unsigned char *capture_buffer;   /* suitably aligned address */
-        unsigned char *playback_buffer;  /* suitably aligned address */
-        dma_addr_t capture_buffer_addr;
-        dma_addr_t playback_buffer_addr;
-        pid_t capture_pid;
-        pid_t playback_pid;
-        int running;
-        int passthru;                   /* non-zero if doing pass-thru */
-        int last_spdif_sample_rate;     /* so that we can catch externally ... */
-        int last_adat_sample_rate;      /* ... induced rate changes            */
-        char *channel_map;
-        int dev;
-        int irq;
-        unsigned long port;
-        struct resource *res_port;
-        unsigned long iobase;
-        snd_card_t *card;
-        snd_pcm_t *pcm;
-        struct pci_dev *pci;
-        snd_info_entry_t *proc_entry;
-        snd_kcontrol_t *spdif_ctl;
-        unsigned short mixer_matrix[HDSP_MATRIX_MIXER_SIZE];
+        spinlock_t            lock;
+        snd_pcm_substream_t  *capture_substream;
+        snd_pcm_substream_t  *playback_substream;
+        hdsp_midi_t           midi[2];
+        struct tasklet_struct midi_tasklet;
+        int                   precise_ptr;
+        u32                   control_register;          /* cached value */
+        u32                   creg_spdif;
+        u32                   creg_spdif_stream;
+        char                 *card_name;                    /* digiface/multiface */
+        HDSP_IO_Type          io_type;               /* ditto, but for code use */
+        unsigned short        firmware_rev;
+        unsigned short        state;                 /* stores state bits */
+        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 */
+        void                 *capture_buffer_unaligned;  /* original buffer addresses */
+        void                 *playback_buffer_unaligned; /* original buffer addresses */
+        unsigned char        *capture_buffer;       /* suitably aligned address */
+        unsigned char        *playback_buffer;      /* suitably aligned address */
+        dma_addr_t            capture_buffer_addr;
+        dma_addr_t            playback_buffer_addr;
+        pid_t                 capture_pid;
+        pid_t                 playback_pid;
+        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;
+        int                   dev;
+        int                   irq;
+        unsigned long         port;
+        struct resource      *res_port;
+        unsigned long         iobase;
+        snd_card_t           *card;
+        snd_pcm_t            *pcm;
+        snd_hwdep_t          *hwdep;
+        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];
 };
 
@@ -384 +413 @@
 
 static char channel_map_mf_ss[HDSP_MAX_CHANNELS] = { /* Multiface */
-        /* ADAT 0 */
+        /* Analog */
         0, 1, 2, 3, 4, 5, 6, 7, 
         /* ADAT 2 */
@@ -410 +439 @@
 
 static struct pci_device_id snd_hdsp_ids[] __devinitdata = {
-        {PCI_VENDOR_ID_XILINX,
-         PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP, 
-         PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,}, /* RME Hammerfall-DSP */
-        {0,}
+        {
+                .vendor = PCI_VENDOR_ID_XILINX,
+                .device = PCI_DEVICE_ID_XILINX_HAMMERFALL_DSP, 
+                .subvendor = PCI_ANY_ID,
+                .subdevice = PCI_ANY_ID,
+        }, /* RME Hammerfall-DSP */
+        { 0, },
 };
 
 MODULE_DEVICE_TABLE(pci, snd_hdsp_ids);
 
+/* prototypes */
+static int __devinit snd_hdsp_create_alsa_devices(snd_card_t *card, hdsp_t *hdsp);
+static int __devinit snd_hdsp_create_pcm(snd_card_t *card, hdsp_t *hdsp);
+static inline int snd_hdsp_initialize_input_enable (hdsp_t *hdsp);
+static inline void snd_hdsp_initialize_midi_flush (hdsp_t *hdsp);
+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 int hdsp_is_9652 (hdsp_t *hdsp)
+{
+        switch (hdsp->firmware_rev) {
+        case 0x64:
+        case 0x65:
+        case 0x68:
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+static inline int hdsp_playback_to_output_key (hdsp_t *hdsp, int in, int out)
+{
+        switch (hdsp->firmware_rev) {
+        case 0xa:
+                return (64 * out) + (32 + (in));
+        default:
+                return (52 * out) + (26 + (in));
+        }
+}
+
+static inline int hdsp_input_to_output_key (hdsp_t *hdsp, int in, int out)
+{
+        switch (hdsp->firmware_rev) {
+        case 0xa:
+                return (64 * out) + in;
+        default:
+                return (52 * out) + in;
+        }
+}
+
 static inline void hdsp_write(hdsp_t *hdsp, int reg, int val)
 {
@@ -426 +501 @@
 {
         return readl (hdsp->iobase + reg);
-}
-
-static inline unsigned long long hdsp_read64 (hdsp_t *hdsp, int reg)
-{
-        unsigned long long val;
-        val = hdsp_read(hdsp, reg);
-        val = (val<<32)|hdsp_read(hdsp, reg + 4);
-
-        return val;
 }
 
@@ -441 +507 @@
         if (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_ConfigError) {
                 snd_printk ("Hammerfall-DSP: no Digiface or Multiface connected!\n");
+                hdsp->state &= ~HDSP_FirmwareLoaded;
                 return -EIO;
         }
         return 0;
 }
+
+static int snd_hdsp_load_firmware_from_cache(hdsp_t *hdsp) {
+
+        int i;
+        unsigned long flags;
+
+        if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
+                
+                snd_printk ("loading firmware\n");
+
+                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_PROGRAM);
+                hdsp_write (hdsp, HDSP_fifoData, 0);
+                
+                if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
+                        snd_printk ("timeout waiting for download preparation\n");
+                        return -EIO;
+                }
+                
+                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
+                
+                for (i = 0; i < 24413; ++i) {
+                        hdsp_write(hdsp, HDSP_fifoData, hdsp->firmware_cache[i]);
+                        if (hdsp_fifo_wait (hdsp, 127, HDSP_LONG_WAIT)) {
+                                snd_printk ("timeout during firmware loading\n");
+                                return -EIO;
+                        }
+                }
+                
+                if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
+                        snd_printk ("timeout at end of firmware loading\n");
+                        return -EIO;
+                }
+
+                hdsp_write (hdsp, HDSP_jtagReg, 0);
+                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) {
+                snd_printk("firmware loaded from cache, restoring defaults\n");
+                spin_lock_irqsave(&hdsp->lock, flags);
+                snd_hdsp_set_defaults(hdsp);
+                spin_unlock_irqrestore(&hdsp->lock, flags); 
+        }
+        
+        hdsp->state |= HDSP_FirmwareLoaded;
+
+        return 0;
+}
+
+static inline int hdsp_get_iobox_version (hdsp_t *hdsp)
+{
+        int err;
+        
+        if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if ((err = snd_hdsp_initialize_input_enable(hdsp)) < 0) {
+                return err;
+        }
+                
+        if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
+        
+                hdsp_write (hdsp, HDSP_jtagReg, HDSP_PROGRAM);
+                hdsp_write (hdsp, HDSP_fifoData, 0);
+                if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT) < 0) {
+                        return -EIO;
+                }
+
+                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
+                hdsp_write (hdsp, HDSP_fifoData, 0);
+
+                if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT)) {
+                        hdsp->io_type = Multiface;
+                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_VERSION_BIT);
+                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
+                        hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT);
+                } else {
+                        hdsp->io_type = Digiface;
+                } 
+        } else {
+                /* firmware was already loaded, get iobox type */
+                if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1) {
+                        hdsp->io_type = Multiface;
+                } else {
+                        hdsp->io_type = Digiface;
+                }
+        }
+        return 0;
+}
+
+
+static inline int hdsp_check_for_firmware (hdsp_t *hdsp)
+{
+        if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
+                snd_printk("firmware not present.\n");
+                hdsp->state &= ~HDSP_FirmwareLoaded;
+                return -EIO;
+        }
+        return 0;
+}
+
 
 static inline int hdsp_fifo_wait(hdsp_t *hdsp, int count, int timeout)
@@ -454 +629 @@
         */
         
-        for (i = 0; i < timeout; i++)
+        for (i = 0; i < timeout; i++) {
+
                 if ((int)(hdsp_read (hdsp, HDSP_fifoStatus) & 0xff) <= count)
                         return 0;
+
+                /* not very friendly, but we only do this during a firmware
+                   load and changing the mixer, so we just put up with it.
+                */
+
+                udelay (100);
+        }
 
         snd_printk ("wait for FIFO status <= %d failed after %d iterations\n",
@@ -475 +658 @@
         unsigned int ad;
 
-        if (addr >= HDSP_MATRIX_MIXER_SIZE)
-                return -1;
-
-        ad = data + addr * 65536;
-
-        if (hdsp_fifo_wait(hdsp, 127, HDSP_LONG_WAIT)) {
-                return -1;
-        }
-        hdsp_write (hdsp, HDSP_fifoData, ad);
-        hdsp->mixer_matrix[addr] = data;
+        if (hdsp_is_9652 (hdsp)) {
+
+                if ((ad = addr/2) < 676) {
+
+                        /* from martin björnsen:
+
+                           "You can only write dwords to the
+                           mixer memory which contain two
+                           mixer values in the low and high
+                           word. So if you want to change
+                           value 0 you have to read value 1
+                           from the cache and write both to
+                           the first dword in the mixer
+                           memory."
+                        */
+
+                        hdsp->mixer_matrix[addr] = data;
+                        hdsp_write (hdsp, 1024 + ad, 
+                                    (hdsp->mixer_matrix[(addr&0x7fe)+1] << 16) + 
+                                    hdsp->mixer_matrix[addr&0x7fe]);
+                        return 0;
+                } else {
+                        return -1;
+                }
+                
+
+        } else {
+                if (addr >= HDSP_MATRIX_MIXER_SIZE)
+                        return -1;
+                
+                ad = (addr << 16) + data;
+                
+                if (hdsp_fifo_wait(hdsp, 127, HDSP_LONG_WAIT)) {
+                        return -1;
+                }
+
+                hdsp_write (hdsp, HDSP_fifoData, ad);
+                hdsp->mixer_matrix[addr] = data;
+
+        }
 
         return 0;
@@ -503 +716 @@
 }
 
-static inline int hdsp_system_sample_rate (hdsp_t *hdsp)
+static inline int hdsp_external_sample_rate (hdsp_t *hdsp)
 {
         unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register);
@@ -515 +728 @@
         case HDSP_systemFrequency88_2: return 88200;
         case HDSP_systemFrequency96:   return 96000;
-        default:                       return 0;
+        default:
+                return 0;
         }
 }
@@ -527 +741 @@
                 return 0;
         }
-
+        
         switch (rate_bits) {
         case HDSP_spdifFrequency32KHz: return 32000;
@@ -536 +750 @@
         case HDSP_spdifFrequency96KHz: return 96000;
         default:
-                snd_printk ("unknown frequency status; bits = 0x%x, status = 0x%x", rate_bits, status);
+                snd_printk ("unknown spdif frequency status; bits = 0x%x, status = 0x%x\n", rate_bits, status);
                 return 0;
         }
@@ -565 +779 @@
 static inline void hdsp_reset_hw_pointer(hdsp_t *hdsp)
 {
-#if 0
-        /* reset the hw pointer to zero. We do this by writing to 8
-           registers, each of which is a 32bit wide register, and set
-           them all to zero. 
-        */
-
-        for (i = 0; i < 8; ++i) {
-                hdsp_write(hdsp, i, 0);
-                udelay(10);
-        }
-#endif
+        hdsp_write (hdsp, HDSP_resetPointer, 0);
 }
 
@@ -620 +824 @@
 }
 
-static int hdsp_set_rate(hdsp_t *hdsp, int rate)
+static int hdsp_set_rate(hdsp_t *hdsp, int rate, int called_internally)
 {
         int reject_if_open = 0;
         int current_rate;
-
-        if (!(hdsp->control_register & HDSP_ClockModeMaster)) {
-                snd_printk ("device is not running as a clock master: cannot set sample rate.\n");
-                return -1;
-        }
+        int rate_bits;
+
+        if (!(hdsp->control_register & HDSP_ClockModeMaster)) { 
+                if (called_internally) {
+                        /* request from ctl or card initialization */
+                        snd_printk("device is not running as a clock master: cannot set sample rate.\n");
+                        return -1;
+                } else {                
+                        /* hw_param request while in AutoSync mode */
+                        int external_freq = hdsp_external_sample_rate(hdsp);
+                        int spdif_freq = hdsp_spdif_sample_rate(hdsp);
+                
+                        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 (rate != external_freq) {
+                                snd_printk("No AutoSync source for requested rate\n");
+                                return -1;
+                        }               
+                }       
+        }
+
+        current_rate = hdsp->system_sample_rate;
 
         /* Changing from a "single speed" to a "double speed" rate is
@@ -638 +859 @@
            Note that a similar but essentially insoluble problem
            exists for externally-driven rate changes. All we can do
-           is to flag rate changes in the read/write routines.
-         */
+           is to flag rate changes in the read/write routines.  */
 
         spin_lock_irq(&hdsp->lock);
-        current_rate = hdsp_system_sample_rate(hdsp);
 
         switch (rate) {
@@ -649 +868 @@
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency32KHz;
+                rate_bits = HDSP_Frequency32KHz;
                 break;
         case 44100:
@@ -655 +874 @@
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency44_1KHz;
+                rate_bits = HDSP_Frequency44_1KHz;
                 break;
         case 48000:
@@ -661 +880 @@
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency48KHz;
+                rate_bits = HDSP_Frequency48KHz;
                 break;
         case 64000:
-                if (current_rate < 48000) {
+                if (current_rate <= 48000) {
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency64KHz;
+                rate_bits = HDSP_Frequency64KHz;
                 break;
         case 88200:
-                if (current_rate < 48000) {
+                if (current_rate <= 48000) {
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency88_2KHz;
+                rate_bits = HDSP_Frequency88_2KHz;
                 break;
         case 96000:
-                if (current_rate < 48000) {
+                if (current_rate <= 48000) {
                         reject_if_open = 1;
                 }
-                rate = HDSP_Frequency96KHz;
+                rate_bits = HDSP_Frequency96KHz;
                 break;
         default:
+                spin_unlock_irq(&hdsp->lock);
                 return -EINVAL;
         }
@@ -694 +914 @@
 
         hdsp->control_register &= ~HDSP_FrequencyMask;
-        hdsp->control_register |= rate;
+        hdsp->control_register |= rate_bits;
         hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
 
@@ -700 +920 @@
                 hdsp->channel_map = channel_map_ds;
         } else {
-                switch (hdsp->type) {
+                switch (hdsp->io_type) {
                 case Multiface:
                         hdsp->channel_map = channel_map_mf_ss;
@@ -707 +927 @@
                         hdsp->channel_map = channel_map_df_ss;
                         break;
-                }
+                default:
+                        /* should never happen */
+                        break;
+                }
+        }
+        
+        hdsp->system_sample_rate = rate;
+        
+        if (reject_if_open) {
+                hdsp_update_simple_mixer_controls (hdsp);
         }
 
@@ -727 +956 @@
                 if (enable) {
                         for (i = 0; i < 26; i++) {
-                                hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY(i,i), UNITY_GAIN);
+                                hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,i,i), UNITY_GAIN);
                         }
                 } else {
                         for (i = 0; i < 26; i++) {
-                                hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY(i,i), MINUS_INFINITY_GAIN);
+                                hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,i,i), MINUS_INFINITY_GAIN);
                         }
                 }
@@ -742 +971 @@
                 mapped_channel = hdsp->channel_map[channel];
 
+                snd_assert(mapped_channel > -1, return);
+
                 if (enable) {
-                        hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY(channel,channel), UNITY_GAIN);
+                        hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,mapped_channel,mapped_channel), UNITY_GAIN);
                 } else {
-                        hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY(channel,channel), MINUS_INFINITY_GAIN);
+                        hdsp_write_gain (hdsp, hdsp_input_to_output_key(hdsp,mapped_channel,mapped_channel), MINUS_INFINITY_GAIN);
                 }
         }
@@ -809 +1040 @@
 static inline int snd_hdsp_midi_output_possible (hdsp_t *hdsp, int id)
 {
+        int fifo_bytes_used;
+
         if (id) {
-                return (hdsp_read(hdsp, HDSP_midiStatusOut1) & 0xff) < 128;
+                fifo_bytes_used = hdsp_read(hdsp, HDSP_midiStatusOut1) & 0xff;
         } else {
-                return (hdsp_read(hdsp, HDSP_midiStatusOut0) & 0xff)< 128;
+                fifo_bytes_used = hdsp_read(hdsp, HDSP_midiStatusOut0) & 0xff;
+        }
+
+        if (fifo_bytes_used < 128) {
+                return  128 - fifo_bytes_used;
+        } else {
+                return 0;
         }
 }
@@ -827 +1066 @@
         unsigned long flags;
         int n_pending;
-        int clear_timer = 0;
         int to_write;
         int i;
@@ -835 +1073 @@
                 
         spin_lock_irqsave (&hmidi->lock, flags);
-
         if (hmidi->output) {
                 if (!snd_rawmidi_transmit_empty (hmidi->output)) {
@@ -845 +1082 @@
                                         for (i = 0; i < to_write; ++i) 
                                                 snd_hdsp_midi_write_byte (hmidi->hdsp, hmidi->id, buf[i]);
-                                } else {
-                                        clear_timer = 1;
                                 }
                         }
-                } else {
-                        clear_timer = 1;
-                }
-
-                if (clear_timer && hmidi->istimer && --hmidi->istimer <= 0) {
-                        del_timer(&hmidi->timer);
-                } 
-        }
-
+                }
+        }
         spin_unlock_irqrestore (&hmidi->lock, flags);
         return 0;
@@ -870 +1098 @@
 
         spin_lock_irqsave (&hmidi->lock, flags);
-
         if ((n_pending = snd_hdsp_midi_input_available (hmidi->hdsp, hmidi->id)) > 0) {
                 if (hmidi->input) {
@@ -888 +1115 @@
                         }
                 }
-        } 
+        }
+        hmidi->pending = 0;
+        if (hmidi->id) {
+                hmidi->hdsp->control_register |= HDSP_Midi1InterruptEnable;
+        } else {
+                hmidi->hdsp->control_register |= HDSP_Midi0InterruptEnable;
+        }
+        hdsp_write(hmidi->hdsp, HDSP_controlRegister, hmidi->hdsp->control_register);
         spin_unlock_irqrestore (&hmidi->lock, flags);
         return snd_hdsp_midi_output_write (hmidi);
@@ -963 +1197 @@
         }
         spin_unlock_irqrestore (&hmidi->lock, flags);
+        if (up)
+                snd_hdsp_midi_output_write(hmidi);
 }
 
@@ -1046 +1282 @@
         hdsp->midi[id].hdsp = hdsp;
         hdsp->midi[id].istimer = 0;
+        hdsp->midi[id].pending = 0;
         spin_lock_init (&hdsp->midi[id].lock);
 
@@ -1168 +1405 @@
 
 #define HDSP_SPDIF_IN(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_PCM,  \
+  .name = xname, \
+  .index = xindex, \
   .info = snd_hdsp_info_spdif_in, \
-  .get = snd_hdsp_get_spdif_in, .put = snd_hdsp_put_spdif_in }
+  .get = snd_hdsp_get_spdif_in, \
+  .put = snd_hdsp_put_spdif_in }
 
 static unsigned int hdsp_spdif_in(hdsp_t *hdsp)
@@ -1201 +1441 @@
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
-        
-        spin_lock_irqsave(&hdsp->lock, flags);
+        
         ucontrol->value.enumerated.item[0] = hdsp_spdif_in(hdsp);
-        spin_unlock_irqrestore(&hdsp->lock, flags);
         return 0;
 }
@@ -1228 +1465 @@
 
 #define HDSP_SPDIF_OUT(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
-  .info = snd_hdsp_info_spdif_out, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
+  .info = snd_hdsp_info_spdif_bits, \
   .get = snd_hdsp_get_spdif_out, .put = snd_hdsp_put_spdif_out }
 
@@ -1248 +1485 @@
 }
 
-static int snd_hdsp_info_spdif_out(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_hdsp_info_spdif_bits(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
@@ -1260 +1497 @@
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
-        
-        spin_lock_irqsave(&hdsp->lock, flags);
+        
         ucontrol->value.integer.value[0] = hdsp_spdif_out(hdsp);
-        spin_unlock_irqrestore(&hdsp->lock, flags);
         return 0;
 }
@@ -1285 +1519 @@
 }
 
-#define HDSP_SYNC_PREF(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
-  .info = snd_hdsp_info_sync_pref, \
-  .get = snd_hdsp_get_sync_pref, .put = snd_hdsp_put_sync_pref }
-
-static int hdsp_sync_pref(hdsp_t *hdsp)
+#define HDSP_SPDIF_PROFESSIONAL(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
+  .info = snd_hdsp_info_spdif_bits, \
+  .get = snd_hdsp_get_spdif_professional, .put = snd_hdsp_put_spdif_professional }
+
+static int hdsp_spdif_professional(hdsp_t *hdsp)
+{
+        return (hdsp->control_register & HDSP_SPDIFProfessional) ? 1 : 0;
+}
+
+static int hdsp_set_spdif_professional(hdsp_t *hdsp, int val)
+{
+        if (val) {
+                hdsp->control_register |= HDSP_SPDIFProfessional;
+        } else {
+                hdsp->control_register &= ~HDSP_SPDIFProfessional;
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_get_spdif_professional(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.integer.value[0] = hdsp_spdif_professional(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_spdif_professional(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        unsigned 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_spdif_professional(hdsp);
+        hdsp_set_spdif_professional(hdsp, val);
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_SPDIF_EMPHASIS(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
+  .info = snd_hdsp_info_spdif_bits, \
+  .get = snd_hdsp_get_spdif_emphasis, .put = snd_hdsp_put_spdif_emphasis }
+
+static int hdsp_spdif_emphasis(hdsp_t *hdsp)
+{
+        return (hdsp->control_register & HDSP_SPDIFEmphasis) ? 1 : 0;
+}
+
+static int hdsp_set_spdif_emphasis(hdsp_t *hdsp, int val)
+{
+        if (val) {
+                hdsp->control_register |= HDSP_SPDIFEmphasis;
+        } else {
+                hdsp->control_register &= ~HDSP_SPDIFEmphasis;
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_get_spdif_emphasis(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.integer.value[0] = hdsp_spdif_emphasis(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_spdif_emphasis(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        unsigned 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_spdif_emphasis(hdsp);
+        hdsp_set_spdif_emphasis(hdsp, val);
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_SPDIF_NON_AUDIO(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, .name = xname, .index = xindex, \
+  .info = snd_hdsp_info_spdif_bits, \
+  .get = snd_hdsp_get_spdif_nonaudio, .put = snd_hdsp_put_spdif_nonaudio }
+
+static int hdsp_spdif_nonaudio(hdsp_t *hdsp)
+{
+        return (hdsp->control_register & HDSP_SPDIFNonAudio) ? 1 : 0;
+}
+
+static int hdsp_set_spdif_nonaudio(hdsp_t *hdsp, int val)
+{
+        if (val) {
+                hdsp->control_register |= HDSP_SPDIFNonAudio;
+        } else {
+                hdsp->control_register &= ~HDSP_SPDIFNonAudio;
+        }
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        return 0;
+}
+
+static int snd_hdsp_get_spdif_nonaudio(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.integer.value[0] = hdsp_spdif_nonaudio(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_spdif_nonaudio(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        unsigned long flags;
+        int change;
+        unsigned 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_spdif_nonaudio(hdsp);
+        hdsp_set_spdif_nonaudio(hdsp, val);
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_SPDIF_SAMPLE_RATE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_spdif_sample_rate, \
+  .get = snd_hdsp_get_spdif_sample_rate \
+}
+
+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"};
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 7 ;
+        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_spdif_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        switch (hdsp_spdif_sample_rate(hdsp)) {
+        case 32000:
+                ucontrol->value.enumerated.item[0] = 0;
+                break;
+        case 44100:
+                ucontrol->value.enumerated.item[0] = 1;
+                break;
+        case 48000:
+                ucontrol->value.enumerated.item[0] = 2;
+                break;
+        case 64000:
+                ucontrol->value.enumerated.item[0] = 3;
+                break;
+        case 88200:
+                ucontrol->value.enumerated.item[0] = 4;
+                break;
+        case 96000:
+                ucontrol->value.enumerated.item[0] = 5;
+                break;
+        default:
+                ucontrol->value.enumerated.item[0] = 6;         
+        }
+        return 0;
+}
+
+#define HDSP_SYSTEM_SAMPLE_RATE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_system_sample_rate, \
+  .get = snd_hdsp_get_system_sample_rate \
+}
+
+static int snd_hdsp_info_system_sample_rate(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        return 0;
+}
+
+static int snd_hdsp_get_system_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp->system_sample_rate;
+        return 0;
+}
+
+#define HDSP_AUTOSYNC_SAMPLE_RATE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_autosync_sample_rate, \
+  .get = snd_hdsp_get_autosync_sample_rate \
+}
+
+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"};  
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 7 ;
+        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_autosync_sample_rate(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        switch (hdsp_external_sample_rate(hdsp)) {
+        case 32000:
+                ucontrol->value.enumerated.item[0] = 0;
+                break;
+        case 44100:
+                ucontrol->value.enumerated.item[0] = 1;
+                break;
+        case 48000:
+                ucontrol->value.enumerated.item[0] = 2;
+                break;
+        case 64000:
+                ucontrol->value.enumerated.item[0] = 3;
+                break;
+        case 88200:
+                ucontrol->value.enumerated.item[0] = 4;
+                break;
+        case 96000:
+                ucontrol->value.enumerated.item[0] = 5;
+                break;
+        default:
+                ucontrol->value.enumerated.item[0] = 6;         
+        }
+        return 0;
+}
+
+#define HDSP_SYSTEM_CLOCK_MODE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_system_clock_mode, \
+  .get = snd_hdsp_get_system_clock_mode \
+}
+
+static int hdsp_system_clock_mode(hdsp_t *hdsp)
+{
+        if (hdsp->control_register & HDSP_ClockModeMaster) {
+                return 0;
+        } else if (hdsp_external_sample_rate(hdsp) != hdsp->system_sample_rate) {
+                        return 0;
+        }
+        return 1;
+}
+
+static int snd_hdsp_info_system_clock_mode(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"Master", "Slave" };
+        
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 2;
+        if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+                uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
+        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int snd_hdsp_get_system_clock_mode(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_system_clock_mode(hdsp);
+        return 0;
+}
+
+#define HDSP_CLOCK_SOURCE(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdsp_info_clock_source, \
+  .get = snd_hdsp_get_clock_source, \
+  .put = snd_hdsp_put_clock_source \
+}
+
+static int hdsp_clock_source(hdsp_t *hdsp)
+{
+        if (hdsp->control_register & HDSP_ClockModeMaster) {
+                switch (hdsp->system_sample_rate) {
+                case 32000:
+                        return 1;
+                case 44100:
+                        return 2;
+                case 48000:
+                        return 3;
+                case 64000:
+                        return 4;
+                case 88200:
+                        return 5;
+                case 96000:
+                        return 6;
+                default:
+                        return 3;       
+                }
+        } else {
+                return 0;
+        }
+}
+
+static int hdsp_set_clock_source(hdsp_t *hdsp, int mode)
+{
+        int rate;
+        switch (mode) {
+        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;
+                }
+                return -1;
+        case HDSP_CLOCK_SOURCE_INTERNAL_32KHZ:
+                rate = 32000;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ:
+                rate = 44100;
+                break;      
+        case HDSP_CLOCK_SOURCE_INTERNAL_48KHZ:
+                rate = 48000;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_64KHZ:
+                rate = 64000;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ:
+                rate = 88200;
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_96KHZ:
+                rate = 96000;
+                break;
+        default:
+                rate = 48000;
+        }
+        hdsp->control_register |= HDSP_ClockModeMaster;
+        hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+        hdsp_set_rate(hdsp, rate, 1);
+        return 0;
+}
+
+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" };
+        
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 7;
+        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_clock_source(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_clock_source(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_clock_source(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 > 6) val = 6;
+        spin_lock_irqsave(&hdsp->lock, flags);
+        if (val != hdsp_clock_source(hdsp)) {
+                change = (hdsp_set_clock_source(hdsp, val) == 0) ? 1 : 0;
+        } else {
+                change = 0;
+        }
+        spin_unlock_irqrestore(&hdsp->lock, flags);
+        return change;
+}
+
+#define HDSP_PREF_SYNC_REF(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .info = snd_hdsp_info_pref_sync_ref, \
+  .get = snd_hdsp_get_pref_sync_ref, \
+  .put = snd_hdsp_put_pref_sync_ref \
+}
+
+static int hdsp_pref_sync_ref(hdsp_t *hdsp)
 {
         /* Notice that this looks at the requested sync source,
            not the one actually in use.
         */
-        
-        if (hdsp->control_register & HDSP_ClockModeMaster) {
-                return HDSP_SYNC_FROM_SELF;
-        }
 
         switch (hdsp->control_register & HDSP_SyncRefMask) {
@@ -1314 +1964 @@
                 return HDSP_SYNC_FROM_ADAT_SYNC;
         default:
-                return HDSP_SYNC_FROM_SELF;
-        }
-        return 0;
-}
-
-static int hdsp_set_sync_pref(hdsp_t *hdsp, int pref)
+                return HDSP_SYNC_FROM_WORD;
+        }
+        return 0;
+}
+
+static int hdsp_set_pref_sync_ref(hdsp_t *hdsp, int pref)
 {
         hdsp->control_register &= ~HDSP_SyncRefMask;
         switch (pref) {
         case HDSP_SYNC_FROM_ADAT1:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register &= ~HDSP_SyncRefMask; /* clear SyncRef bits */
                 break;
         case HDSP_SYNC_FROM_ADAT2:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_ADAT2;
                 break;
         case HDSP_SYNC_FROM_ADAT3:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_ADAT3;
                 break;
         case HDSP_SYNC_FROM_SPDIF:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_SPDIF;
                 break;
         case HDSP_SYNC_FROM_WORD:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_WORD;
                 break;
         case HDSP_SYNC_FROM_ADAT_SYNC:
-                hdsp->control_register &= ~HDSP_ClockModeMaster;
                 hdsp->control_register |= HDSP_SyncRef_ADAT_SYNC;
-                break;
-        case HDSP_SYNC_FROM_SELF:
-                hdsp->control_register |= HDSP_ClockModeMaster;
                 break;
         default:
@@ -1357 +1998 @@
 }
 
-static int snd_hdsp_info_sync_pref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        static char *texts[] = {"Internal", "Word", "ADAT Sync", "IEC958", "ADAT1", "ADAT2", "ADAT3" };
+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" };
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
         
         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
         uinfo->count = 1;
-        uinfo->value.enumerated.items = (hdsp->type == Digiface) ? 7 : 6;
+        uinfo->value.enumerated.items = (hdsp->io_type == Digiface) ? 6 : 4;
         if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
                 uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
@@ -1371 +2012 @@
 }
 
-static int snd_hdsp_get_sync_pref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+static int snd_hdsp_get_pref_sync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
-        
-        spin_lock_irqsave(&hdsp->lock, flags);
-        ucontrol->value.enumerated.item[0] = hdsp_sync_pref(hdsp);
-        spin_unlock_irqrestore(&hdsp->lock, flags);
-        return 0;
-}
-
-static int snd_hdsp_put_sync_pref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+        
+        ucontrol->value.enumerated.item[0] = hdsp_pref_sync_ref(hdsp);
+        return 0;
+}
+
+static int snd_hdsp_put_pref_sync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
@@ -1391 +2029 @@
         if (!snd_hdsp_use_is_exclusive(hdsp))
                 return -EBUSY;
-        max = hdsp->ss_channels == (hdsp->type == Digiface) ? 7 : 6;
+        max = (hdsp->io_type == Digiface) ? 6 : 4;
         val = ucontrol->value.enumerated.item[0] % max;
         spin_lock_irqsave(&hdsp->lock, flags);
-        change = (int)val != hdsp_sync_pref(hdsp);
-        hdsp_set_sync_pref(hdsp, val);
+        change = (int)val != hdsp_pref_sync_ref(hdsp);
+        hdsp_set_pref_sync_ref(hdsp, val);
         spin_unlock_irqrestore(&hdsp->lock, flags);
         return change;
 }
 
+#define HDSP_AUTOSYNC_REF(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READ, \
+  .info = snd_hdsp_info_autosync_ref, \
+  .get = snd_hdsp_get_autosync_ref, \
+}
+
+static int hdsp_autosync_ref(hdsp_t *hdsp)
+{
+        /* This looks at the autosync selected sync reference */
+        unsigned int status2 = hdsp_read(hdsp, HDSP_status2Register);
+
+        switch (status2 & HDSP_SelSyncRefMask) {
+        case HDSP_SelSyncRef_WORD:
+                return HDSP_AUTOSYNC_FROM_WORD;
+        case HDSP_SelSyncRef_ADAT_SYNC:
+                return HDSP_AUTOSYNC_FROM_ADAT_SYNC;
+        case HDSP_SelSyncRef_SPDIF:
+                return HDSP_AUTOSYNC_FROM_SPDIF;
+        case HDSP_SelSyncRefMask:
+                return HDSP_AUTOSYNC_FROM_NONE; 
+        case HDSP_SelSyncRef_ADAT1:
+                return HDSP_AUTOSYNC_FROM_ADAT1;
+        case HDSP_SelSyncRef_ADAT2:
+                return HDSP_AUTOSYNC_FROM_ADAT2;
+        case HDSP_SelSyncRef_ADAT3:
+                return HDSP_AUTOSYNC_FROM_ADAT3;
+        default:
+                return HDSP_AUTOSYNC_FROM_WORD;
+        }
+        return 0;
+}
+
+static int snd_hdsp_info_autosync_ref(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"Word", "ADAT Sync", "IEC958", "None", "ADAT1", "ADAT2", "ADAT3" };
+        
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 7;
+        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_autosync_ref(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
+        
+        ucontrol->value.enumerated.item[0] = hdsp_pref_sync_ref(hdsp);
+        return 0;
+}
+
 #define HDSP_PASSTHRU(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .info = snd_hdsp_info_passthru, \
   .put = snd_hdsp_put_passthru, \
-  .get = snd_hdsp_get_passthru }
+  .get = snd_hdsp_get_passthru \
+}
 
 static int snd_hdsp_info_passthru(snd_kcontrol_t * kcontrol, snd_ctl_elem_info_t * uinfo)
@@ -1447 +2144 @@
 
 #define HDSP_LINE_OUT(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .info = snd_hdsp_info_line_out, \
-  .get = snd_hdsp_get_line_out, .put = snd_hdsp_put_line_out }
+  .get = snd_hdsp_get_line_out, \
+  .put = snd_hdsp_put_line_out \
+}
 
 static int hdsp_line_out(hdsp_t *hdsp)
@@ -1505 +2206 @@
 
 #define HDSP_MIXER(xname, xindex) \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, .name = xname, .index = xindex, \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
+  .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
+                 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
   .info = snd_hdsp_info_mixer, \
-  .get = snd_hdsp_get_mixer, .put = snd_hdsp_put_mixer }
+  .get = snd_hdsp_get_mixer, \
+  .put = snd_hdsp_put_mixer \
+}
 
 static int snd_hdsp_info_mixer(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
@@ -1531 +2238 @@
 
         if (source > 25) {
-                addr = PLAYBACK_TO_OUTPUT_KEY(source-26,destination);
+                addr = hdsp_playback_to_output_key(hdsp,source-26,destination);
         } else {
-                addr = INPUT_TO_OUTPUT_KEY(source, destination);
+                addr = hdsp_input_to_output_key(hdsp,source, destination);
         }
         
         spin_lock_irqsave(&hdsp->lock, flags);
-        ucontrol->value.integer.value[0] = hdsp_read_gain (hdsp, addr);
+        ucontrol->value.integer.value[2] = hdsp_read_gain (hdsp, addr);
         spin_unlock_irqrestore(&hdsp->lock, flags);
         return 0;
@@ -1559 +2266 @@
 
         if (source > 25) {
-                addr = PLAYBACK_TO_OUTPUT_KEY(source-26, destination);
+                addr = hdsp_playback_to_output_key(hdsp,source-26, destination);
         } else {
-                addr = INPUT_TO_OUTPUT_KEY(source, destination);
+                addr = hdsp_input_to_output_key(hdsp,source, destination);
         }
 
@@ -1584 +2291 @@
                  SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
   .info = snd_hdsp_info_playback_mixer, \
-  .get = snd_hdsp_get_playback_mixer, .put = snd_hdsp_put_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)
@@ -1601 +2310 @@
         unsigned long flags;
         int addr;
-        int chn;
-
-        chn = ucontrol->id.index - 1;
-        addr = PLAYBACK_TO_OUTPUT_KEY(chn, chn);
+        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);
@@ -1618 +2335 @@
         int change;
         int addr;
-        int chn;
+        int channel;
+        int mapped_channel;
         int gain;
 
@@ -1624 +2342 @@
                 return -EBUSY;
         
-        chn = ucontrol->id.index - 1;
-        addr = PLAYBACK_TO_OUTPUT_KEY(chn, chn);
+        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];
 
@@ -1637 +2362 @@
 }
 
-#define HDSP_PEAK_PLAYBACK \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+#define HDSP_WC_SYNC_CHECK(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_peak_playback, \
-  .get = snd_hdsp_get_peak_playback \
-}
-
-static int snd_hdsp_info_peak_playback(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 2;
-        return 0;
-}
-
-static int snd_hdsp_get_peak_playback(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+  .info = snd_hdsp_info_sync_check, \
+  .get = snd_hdsp_get_wc_sync_check \
+}
+
+static int snd_hdsp_info_sync_check(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {"No Lock", "Lock", "Sync" };    
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 3;
+        if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+                uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
+        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int hdsp_wc_sync_check(hdsp_t *hdsp)
+{
+        int status2 = hdsp_read(hdsp, HDSP_status2Register);
+        if (status2 & HDSP_wc_lock) {
+                if (status2 & HDSP_wc_sync) {
+                        return 2;
+                } else {
+                         return 1;
+                }
+        } else {                
+                return 0;
+        }
+        return 0;
+}
+
+static int snd_hdsp_get_wc_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned int peakval = hdsp_read (hdsp, HDSP_playbackPeakLevel + (4 * (ucontrol->id.index-1)));
-        ucontrol->value.integer.value[0] = peakval & 0xffffff00;  /* peak */
-        ucontrol->value.integer.value[1] = peakval & 0xf;         /* overs */
-        return 0;
-}
-
-#define HDSP_PEAK_INPUT \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+
+        ucontrol->value.enumerated.item[0] = hdsp_wc_sync_check(hdsp);
+        return 0;
+}
+
+#define HDSP_SPDIF_SYNC_CHECK(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_peak_input, \
-  .get = snd_hdsp_get_peak_input \
-}
-
-static int snd_hdsp_info_peak_input(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 2;
-        return 0;
-}
-
-static int snd_hdsp_get_peak_input(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+  .info = snd_hdsp_info_sync_check, \
+  .get = snd_hdsp_get_spdif_sync_check \
+}
+
+static int hdsp_spdif_sync_check(hdsp_t *hdsp)
+{
+        int status = hdsp_read(hdsp, HDSP_statusRegister);
+        if (status & HDSP_SPDIFErrorFlag) {
+                return 0;
+        } else {        
+                if (status & HDSP_SPDIFSync) {
+                        return 2;
+                } else {
+                        return 1;
+                }
+        }
+        return 0;
+}
+
+static int snd_hdsp_get_spdif_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned int peakval = hdsp_read (hdsp, HDSP_inputPeakLevel + (4 * (ucontrol->id.index-1)));
-        ucontrol->value.integer.value[0] = peakval & 0xffffff00;  /* peak */
-        ucontrol->value.integer.value[1] = peakval & 0xf;         /* overs */
-        return 0;
-}
-
-#define HDSP_PEAK_OUTPUT \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+
+        ucontrol->value.enumerated.item[0] = hdsp_spdif_sync_check(hdsp);
+        return 0;
+}
+
+#define HDSP_ADATSYNC_SYNC_CHECK(xname, xindex) \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
+  .name = xname, \
+  .index = xindex, \
   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_peak_output, \
-  .get = snd_hdsp_get_peak_output \
-}
-
-static int snd_hdsp_info_peak_output(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 2;
-        return 0;
-}
-
-static int snd_hdsp_get_peak_output(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+  .info = snd_hdsp_info_sync_check, \
+  .get = snd_hdsp_get_adatsync_sync_check \
+}
+
+static int hdsp_adatsync_sync_check(hdsp_t *hdsp)
+{
+        int status = hdsp_read(hdsp, HDSP_statusRegister);
+        if (status & HDSP_TimecodeLock) {
+                if (status & HDSP_TimecodeSync) {
+                        return 2;
+                } else {
+                        return 1;
+                }
+        } else {
+                return 0;
+        }
+}       
+
+static int snd_hdsp_get_adatsync_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        unsigned int peakval = hdsp_read (hdsp, HDSP_outputPeakLevel + (4 * (ucontrol->id.index-1)));
-        ucontrol->value.integer.value[0] = peakval & 0xffffff00;  /* peak */
-        ucontrol->value.integer.value[1] = peakval & 0xf;         /* overs */
-        return 0;
-}
-
-#define HDSP_RMS_INPUT \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
+
+        ucontrol->value.enumerated.item[0] = hdsp_adatsync_sync_check(hdsp);
+        return 0;
+}
+
+#define HDSP_ADAT_SYNC_CHECK \
+{ .iface = SNDRV_CTL_ELEM_IFACE_HWDEP, \
   .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_rms_input, \
-  .get = snd_hdsp_get_rms_input \
-}
-
-static int snd_hdsp_info_rms_input(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER64;
-        uinfo->count = 1;
-        return 0;
-}
-
-static int snd_hdsp_get_rms_input(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
-{
+  .info = snd_hdsp_info_sync_check, \
+  .get = snd_hdsp_get_adat_sync_check \
+}
+
+static int hdsp_adat_sync_check(hdsp_t *hdsp, int idx)
+{       
+        int status = hdsp_read(hdsp, HDSP_statusRegister);
+        
+        if (status & (HDSP_Lock0>>idx)) {
+                if (status & (HDSP_Sync0>>idx)) {
+                        return 2;
+                } else {
+                        return 1;               
+                }
+        } else {
+                return 0;
+        }               
+} 
+
+static int snd_hdsp_get_adat_sync_check(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        int offset;
         hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        ucontrol->value.integer64.value[0] = hdsp_read64 (hdsp, HDSP_inputRmsLevel + (8 * (ucontrol->id.index-1)));
-        return 0;
-}
-
-#define HDSP_RMS_PLAYBACK \
-{ .iface = SNDRV_CTL_ELEM_IFACE_PCM, \
-  .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, \
-  .info = snd_hdsp_info_rms_playback, \
-  .get = snd_hdsp_get_rms_playback \
-}
-
-static int snd_hdsp_info_rms_playback(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER64;
-        uinfo->count = 1;
-        return 0;
-}
-
-static int snd_hdsp_get_rms_playback(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
-{
-        hdsp_t *hdsp = _snd_kcontrol_chip(kcontrol);
-        ucontrol->value.integer64.value[0] = hdsp_read64 (hdsp, HDSP_playbackRmsLevel + (8 * (ucontrol->id.index-1)));
+
+        offset = ucontrol->id.index - 1;
+        snd_assert(offset >= 0 || offset < ((hdsp->io_type == Digiface) ? 3 : 1), return -EINVAL);
+        ucontrol->value.enumerated.item[0] = hdsp_adat_sync_check(hdsp, offset);
         return 0;
 }
@@ -1771 +2525 @@
         .get =          snd_hdsp_control_spdif_mask_get,
         .private_value = IEC958_AES0_NONAUDIO |
-                        IEC958_AES0_PROFESSIONAL |
-                        IEC958_AES0_CON_EMPHASIS,                                                                                             
+                         IEC958_AES0_PROFESSIONAL |
+                         IEC958_AES0_CON_EMPHASIS,                                                                                            
 },
 {
@@ -1781 +2535 @@
         .get =          snd_hdsp_control_spdif_mask_get,
         .private_value = IEC958_AES0_NONAUDIO |
-                        IEC958_AES0_PROFESSIONAL |
-                        IEC958_AES0_PRO_EMPHASIS,
+                         IEC958_AES0_PROFESSIONAL |
+                         IEC958_AES0_PRO_EMPHASIS,
 },
 HDSP_MIXER("Mixer", 0),
 HDSP_SPDIF_IN("IEC958 Input Connector", 0),
 HDSP_SPDIF_OUT("IEC958 Output also on ADAT1", 0),
-HDSP_SYNC_PREF("Preferred Sync Source", 0),
+HDSP_SPDIF_PROFESSIONAL("IEC958 Professional Bit", 0),
+HDSP_SPDIF_EMPHASIS("IEC958 Emphasis Bit", 0),
+HDSP_SPDIF_NON_AUDIO("IEC958 Non-audio Bit", 0),
+/* 'Sample Clock Source' complies with the alsa control naming scheme */ 
+HDSP_CLOCK_SOURCE("Sample Clock Source", 0),
+HDSP_SYSTEM_CLOCK_MODE("System Clock Mode", 0),
+HDSP_PREF_SYNC_REF("Preferred Sync Reference", 0),
+HDSP_AUTOSYNC_REF("AutoSync Reference", 0),
+HDSP_SPDIF_SAMPLE_RATE("SPDIF Sample Rate", 0),
+HDSP_SYSTEM_SAMPLE_RATE("System Sample Rate", 0),
+/* 'External Rate' complies with the alsa control naming scheme */
+HDSP_AUTOSYNC_SAMPLE_RATE("External Rate", 0),
+HDSP_WC_SYNC_CHECK("Word Clock Lock Status", 0),
+HDSP_SPDIF_SYNC_CHECK("SPDIF Lock Status", 0),
+HDSP_ADATSYNC_SYNC_CHECK("ADAT Sync Lock Status", 0),
 HDSP_PASSTHRU("Passthru", 0),
 HDSP_LINE_OUT("Line Out", 0),
@@ -1795 +2563 @@
 
 static snd_kcontrol_new_t snd_hdsp_playback_mixer = HDSP_PLAYBACK_MIXER;
-static snd_kcontrol_new_t snd_hdsp_input_peak = HDSP_PEAK_INPUT;
-static snd_kcontrol_new_t snd_hdsp_output_peak = HDSP_PEAK_OUTPUT;
-static snd_kcontrol_new_t snd_hdsp_playback_peak = HDSP_PEAK_PLAYBACK;
-static snd_kcontrol_new_t snd_hdsp_input_rms = HDSP_RMS_INPUT;
-static snd_kcontrol_new_t snd_hdsp_playback_rms = HDSP_RMS_PLAYBACK;
+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)
@@ -1814 +2600 @@
         }
 
-        if (hdsp->type == Digiface) {
+        snd_hdsp_playback_mixer.name = "Chn";
+        snd_hdsp_adat_sync_check.name = "ADAT Lock Status";
+
+        if (hdsp->io_type == Digiface) {
                 limit = DIGIFACE_SS_CHANNELS;
         } else {
                 limit = MULTIFACE_SS_CHANNELS;
         }
-
+        
         /* The index values are one greater than the channel ID so that alsamixer
            will display them correctly. We want to use the index for fast lookup
@@ -1826 +2615 @@
         */
 
-        snd_hdsp_playback_mixer.name = "Chn";
-        snd_hdsp_input_peak.name = "Input Peak";
-        snd_hdsp_output_peak.name = "Output Peak";
-        snd_hdsp_playback_peak.name = "Playback Peak";
-        snd_hdsp_playback_rms.name = "Playback RMS";
-        snd_hdsp_input_rms.name = "Input RMS";
-
         for (idx = 0; idx < limit; ++idx) {
                 snd_hdsp_playback_mixer.index = idx+1;
@@ -1838 +2620 @@
                         return err;
                 }
-                snd_hdsp_input_peak.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_input_peak, hdsp)))) {
-                        return err;
-                }
-                snd_hdsp_output_peak.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_output_peak, hdsp)))) {
-                        return err;
-                }
-                snd_hdsp_playback_peak.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_playback_peak, hdsp)))) {
-                        return err;
-                }
-                snd_hdsp_playback_rms.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_playback_rms, hdsp)))) {
-                        return err;
-                }
-                snd_hdsp_input_rms.index = idx+1;
-                if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_input_rms, 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)))) {
+                return err;
+        }       
+        if (hdsp->io_type == Digiface) {
+                for (idx = 1; idx < 3; ++idx) {
+                        snd_hdsp_adat_sync_check.index = idx+1;
+                        if ((err = snd_ctl_add (card, kctl = snd_ctl_new1(&snd_hdsp_adat_sync_check, hdsp)))) {
+                                return err;
+                        }
                 }
         }
@@ -1873 +2650 @@
         unsigned int status;
         unsigned int status2;
-        char *requested_sync_ref;
+        char *pref_sync_ref;
+        char *autosync_ref;
+        char *system_clock_mode;
+        char *clock_source;
         int x;
 
         if (hdsp_check_for_iobox (hdsp)) {
+                snd_iprintf(buffer, "No I/O box connected.\nPlease connect one and upload firmware.\n");
                 return;
         }
 
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_iprintf(buffer, "Firmware loading from cache failed, please upload manually.\n");
+                                return;
+                        }
+                } else {
+                        snd_iprintf(buffer, "No firmware loaded nor cached, please upload firmware.\n");
+                        return;
+                }
+        }
+        
         status = hdsp_read(hdsp, HDSP_statusRegister);
         status2 = hdsp_read(hdsp, HDSP_status2Register);
@@ -1902 +2695 @@
         x = 1 << (6 + hdsp_decode_latency(hdsp->control_register & HDSP_LatencyMask));
 
-        snd_iprintf(buffer, "Latency: %d samples (2 periods of %lu bytes)\n", x, (unsigned long) hdsp->period_bytes);
+        snd_iprintf(buffer, "Buffer Size (Latency): %d samples (2 periods of %lu bytes)\n", x, (unsigned long) hdsp->period_bytes);
         snd_iprintf(buffer, "Hardware pointer (frames): %ld\n", hdsp_hw_pointer(hdsp));
         snd_iprintf(buffer, "Passthru: %s\n", hdsp->passthru ? "yes" : "no");
@@ -1909 +2702 @@
         snd_iprintf(buffer, "Firmware version: %d\n", (status2&HDSP_version0)|(status2&HDSP_version1)<<1|(status2&HDSP_version2)<<2);
 
-        switch (hdsp_sync_pref (hdsp)) {
+        snd_iprintf(buffer, "\n");
+
+
+        switch (hdsp_clock_source(hdsp)) {
+        case HDSP_CLOCK_SOURCE_AUTOSYNC:
+                clock_source = "AutoSync";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_32KHZ:
+                clock_source = "Internal 32 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_44_1KHZ:
+                clock_source = "Internal 44.1 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_48KHZ:
+                clock_source = "Internal 48 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_64KHZ:
+                clock_source = "Internal 64 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_88_2KHZ:
+                clock_source = "Internal 88.2 kHz";
+                break;
+        case HDSP_CLOCK_SOURCE_INTERNAL_96KHZ:
+                clock_source = "Internal 96 kHz";
+                break;
+        default:
+                clock_source = "Error";         
+        }
+        snd_iprintf (buffer, "Sample Clock Source: %s\n", clock_source);
+                        
+        if (hdsp_system_clock_mode(hdsp)) {
+                system_clock_mode = "Slave";
+        } else {
+                system_clock_mode = "Master";
+        }
+        
+        switch (hdsp_pref_sync_ref (hdsp)) {
         case HDSP_SYNC_FROM_WORD:
-                requested_sync_ref = "Word";
+                pref_sync_ref = "Word Clock";
                 break;
         case HDSP_SYNC_FROM_ADAT_SYNC:
-                requested_sync_ref = "ADAT Sync";
+                pref_sync_ref = "ADAT Sync";
                 break;
         case HDSP_SYNC_FROM_SPDIF:
-                requested_sync_ref = "SPDIF";
+                pref_sync_ref = "SPDIF";
                 break;
         case HDSP_SYNC_FROM_ADAT1:
-                requested_sync_ref = "ADAT1";
+                pref_sync_ref = "ADAT1";
                 break;
         case HDSP_SYNC_FROM_ADAT2:
-                requested_sync_ref = "ADAT2";
+                pref_sync_ref = "ADAT2";
                 break;
         case HDSP_SYNC_FROM_ADAT3:
-                requested_sync_ref = "ADAT3";
-                break;
-        case HDSP_SYNC_FROM_SELF:
+                pref_sync_ref = "ADAT3";
+                break;
         default:
-                requested_sync_ref = "Master";
-                break;
-        }
-
-        if ((hdsp->control_register & HDSP_ClockModeMaster)) {
-                snd_iprintf (buffer, "Sync reference: %s/Master (chosen)\n", requested_sync_ref);
-        } else if (hdsp_system_sample_rate(hdsp) == 0) {
-                snd_iprintf (buffer, "Sync reference: %s/Master (forced)\n", requested_sync_ref);
-        } else {
-                switch (status2 & HDSP_SelSyncRefMask) {
-                case HDSP_SelSyncRef_ADAT1:
-                        snd_iprintf (buffer, "Sync reference: %s/ADAT1\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_ADAT2:
-                        snd_iprintf (buffer, "Sync reference: %s/ADAT2\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_ADAT3:
-                        snd_iprintf (buffer, "Sync reference: %s/ADAT3\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_SPDIF:
-                        snd_iprintf (buffer, "Sync reference: %s/SPDIF\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_WORD:
-                        snd_iprintf (buffer, "Sync reference: %s/WORD\n", requested_sync_ref);
-                        break;
-                case HDSP_SelSyncRef_ADAT_SYNC:
-                        snd_iprintf (buffer, "Sync reference: %s/ADAT Sync\n", requested_sync_ref);
-                        break;
-                default:
-                        snd_iprintf (buffer, "Sync reference: %s/Master (fallback)\n", requested_sync_ref);
-                        break;
-                }
-        }
-        snd_iprintf (buffer, "Sample rate: %d\n", hdsp_system_sample_rate(hdsp));
-
+                pref_sync_ref = "Word Clock";
+                break;
+        }
+        snd_iprintf (buffer, "Preferred Sync Reference: %s\n", pref_sync_ref);
+        
+        switch (hdsp_autosync_ref (hdsp)) {
+        case HDSP_AUTOSYNC_FROM_WORD:
+                autosync_ref = "Word Clock";
+                break;
+        case HDSP_AUTOSYNC_FROM_ADAT_SYNC:
+                autosync_ref = "ADAT Sync";
+                break;
+        case HDSP_AUTOSYNC_FROM_SPDIF:
+                autosync_ref = "SPDIF";
+                break;
+        case HDSP_AUTOSYNC_FROM_NONE:
+                autosync_ref = "None";
+                break;  
+        case HDSP_AUTOSYNC_FROM_ADAT1:
+                autosync_ref = "ADAT1";
+                break;
+        case HDSP_AUTOSYNC_FROM_ADAT2:
+                autosync_ref = "ADAT2";
+                break;
+        case HDSP_AUTOSYNC_FROM_ADAT3:
+                autosync_ref = "ADAT3";
+                break;
+        default:
+                autosync_ref = "---";
+                break;
+        }
+        snd_iprintf (buffer, "AutoSync Reference: %s\n", autosync_ref);
+        
+        snd_iprintf (buffer, "AutoSync Frequency: %d\n", hdsp_external_sample_rate(hdsp));
+        
+        snd_iprintf (buffer, "System Clock Mode: %s\n", system_clock_mode);
+
+        snd_iprintf (buffer, "System Clock Frequency: %d\n", hdsp->system_sample_rate);
+                
         snd_iprintf(buffer, "\n");
 
@@ -2005 +2837 @@
                 snd_iprintf(buffer, "IEC958 NonAudio: off\n");
         }
-
-        snd_iprintf(buffer, "\n");
-
         if ((x = hdsp_spdif_sample_rate (hdsp)) != 0) {
                 snd_iprintf (buffer, "IEC958 sample rate: %d\n", x);
@@ -2024 +2853 @@
         }
 
-        x = status & HDSP_Sync1;
-        if (status & HDSP_Lock1) {
-                snd_iprintf(buffer, "ADAT2: %s\n", x ? "Sync" : "Lock");
-        } else {
-                snd_iprintf(buffer, "ADAT2: No Lock\n");
-        }
-
-        if (hdsp->type == Digiface) {
+        switch (hdsp->io_type) {
+        case Digiface:
+                x = status & HDSP_Sync1;
+                if (status & HDSP_Lock1) {
+                        snd_iprintf(buffer, "ADAT2: %s\n", x ? "Sync" : "Lock");
+                } else {
+                        snd_iprintf(buffer, "ADAT2: No Lock\n");
+                }
                 x = status & HDSP_Sync2;
                 if (status & HDSP_Lock2) {
@@ -2038 +2867 @@
                         snd_iprintf(buffer, "ADAT3: No Lock\n");
                 }
+        default:
+                /* relax */
+                break;
+        }
+
+        x = status & HDSP_SPDIFSync;
+        if (status & HDSP_SPDIFErrorFlag) {
+                snd_iprintf (buffer, "SPDIF: No Lock\n");
+        } else {
+                snd_iprintf (buffer, "SPDIF: %s\n", x ? "Sync" : "Lock");
+        }
+        
+        x = status2 & HDSP_wc_sync;
+        if (status2 & HDSP_wc_lock) {
+                snd_iprintf (buffer, "Word Clock: %s\n", x ? "Sync" : "Lock");
+        } else {
+                snd_iprintf (buffer, "Word Clock: No Lock\n");
+        }
+        
+        x = status & HDSP_TimecodeSync;
+        if (status & HDSP_TimecodeLock) {
+                snd_iprintf(buffer, "ADAT Sync: %s\n", x ? "Sync" : "Lock");
+        } else {
+                snd_iprintf(buffer, "ADAT Sync: No Lock\n");
         }
 
@@ -2054 +2907 @@
         snd_info_entry_t *entry;
 
-        if ((entry = snd_info_create_card_entry(hdsp->card, "hdsp", hdsp->card->proc_root)) !=
-            NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = hdsp;
-                entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 256;
-                entry->c.text.read = snd_hdsp_proc_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        hdsp->proc_entry = entry;
-}
-
-static void snd_hdsp_proc_done(hdsp_t *hdsp)
-{
-        if (hdsp->proc_entry) {
-                snd_info_unregister(hdsp->proc_entry);
-                hdsp->proc_entry = NULL;
-        }
+        if (! snd_card_proc_new(hdsp->card, "hdsp", &entry))
+                snd_info_set_text_ops(entry, hdsp, snd_hdsp_proc_read);
 }
 
@@ -2159 +2993 @@
 }
 
-static void snd_hdsp_set_defaults(hdsp_t *hdsp)
+static int snd_hdsp_set_defaults(hdsp_t *hdsp)
 {
         unsigned int i;
@@ -2192 +3026 @@
         }
 
-        for (i = 0; i < 2048; i++)
-                hdsp_write_gain (hdsp, i, MINUS_INFINITY_GAIN);
-
-        if (line_outs_monitor[hdsp->dev]) {
+        for (i = 0; i < (hdsp_is_9652(hdsp) ? 1352 : HDSP_MATRIX_MIXER_SIZE); i++) {
+                if (hdsp_write_gain (hdsp, i, MINUS_INFINITY_GAIN)) {
+                        return -EIO;
+                }
+        }
+        
+        if (!hdsp_is_9652(hdsp) && line_outs_monitor[hdsp->dev]) {
                 
                 snd_printk ("sending all inputs and playback streams to line outs.\n");
@@ -2205 +3042 @@
                 for (i = 0; i < HDSP_MAX_CHANNELS; i++) {
                         if (i & 1) { 
-                                hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY (i, 26), UNITY_GAIN);
-                                hdsp_write_gain (hdsp, PLAYBACK_TO_OUTPUT_KEY (i, 26), UNITY_GAIN);
+                                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)) {
+                                    return -EIO;
+                                }    
                         } else {
-                                hdsp_write_gain (hdsp, INPUT_TO_OUTPUT_KEY (i, 27), UNITY_GAIN);
-                                hdsp_write_gain (hdsp, PLAYBACK_TO_OUTPUT_KEY (i, 27), UNITY_GAIN);
+                                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)) {
+                                    return -EIO;
+                                }
                         }
                 }
@@ -2219 +3060 @@
          */
 
-        hdsp_set_rate(hdsp, 48000);
-}
-
-void snd_hdsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+        hdsp_set_rate(hdsp, 48000, 1);
+
+        return 0;
+}
+
+void hdsp_midi_tasklet(unsigned long arg)
+{
+        hdsp_t *hdsp = (hdsp_t *)arg;
+        
+        if (hdsp->midi[0].pending) {
+                snd_hdsp_midi_input_read (&hdsp->midi[0]);
+        }
+        if (hdsp->midi[1].pending) {
+                snd_hdsp_midi_input_read (&hdsp->midi[1]);
+        }
+} 
+
+static irqreturn_t snd_hdsp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         hdsp_t *hdsp = (hdsp_t *) dev_id;
@@ -2231 +3086 @@
         unsigned int midi0status;
         unsigned int midi1status;
-
+        int schedule = 0;
+        
         status = hdsp_read(hdsp, HDSP_statusRegister);
 
@@ -2239 +3095 @@
 
         if (!audio && !midi0 && !midi1) {
-                return;
+                return IRQ_NONE;
         }
 
@@ -2246 +3102 @@
         midi0status = hdsp_read (hdsp, HDSP_midiStatusIn0) & 0xff;
         midi1status = hdsp_read (hdsp, HDSP_midiStatusIn1) & 0xff;
-
+        
         if (audio) {
                 if (hdsp->capture_substream) {
@@ -2256 +3112 @@
                 }
         }
-
-        /* note: snd_hdsp_midi_input_read() calls output_write() because
-           output is not interrupt-driven ...
-        */
-
-        if (midi0status)
-                snd_hdsp_midi_input_read (&hdsp->midi[0]);
-        if (midi1status)
-                snd_hdsp_midi_input_read (&hdsp->midi[1]);
+        
+        if (midi0 && midi0status) {
+                /* we disable interrupts for this input until processing is done */
+                hdsp->control_register &= ~HDSP_Midi0InterruptEnable;
+                hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+                hdsp->midi[0].pending = 1;
+                schedule = 1;
+        }
+        if (midi1 && midi1status) {
+                /* we disable interrupts for this input until processing is done */
+                hdsp->control_register &= ~HDSP_Midi1InterruptEnable;
+                hdsp_write(hdsp, HDSP_controlRegister, hdsp->control_register);
+                hdsp->midi[1].pending = 1;
+                schedule = 1;
+        }
+        if (schedule)
+            tasklet_hi_schedule(&hdsp->midi_tasklet);
+        return IRQ_HANDLED;
 }
 
@@ -2303 +3168 @@
         channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
         snd_assert(channel_buf != NULL, return -EIO);
-        if (copy_from_user(channel_buf + pos * 4, src, count * 4))
-                return -EFAULT;
+        copy_from_user(channel_buf + pos * 4, src, count * 4);
         return count;
 }
@@ -2318 +3182 @@
         channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
         snd_assert(channel_buf != NULL, return -EIO);
-        if (copy_to_user(dst, channel_buf + pos * 4, count * 4))
-                return -EFAULT;
+        copy_to_user(dst, channel_buf + pos * 4, count * 4);
         return count;
 }
@@ -2349 +3212 @@
                 runtime->status->hw_ptr = 0;
         if (other) {
-                snd_pcm_substream_t *s = substream;
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
                 snd_pcm_runtime_t *oruntime = other->runtime;
-                do {
-                        s = s->link_next;
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == other) {
                                 oruntime->status->hw_ptr = runtime->status->hw_ptr;
                                 break;
                         }
-                } while (s != substream);
+                }
         }
         return 0;
@@ -2371 +3235 @@
 
         if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
                 return -EIO;
         }
@@ -2393 +3268 @@
                  */
 
-                if ((int)params_rate(params) != hdsp_system_sample_rate(hdsp)) {
+                if (params_rate(params) != hdsp->system_sample_rate) {
                         spin_unlock_irq(&hdsp->lock);
                         _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
@@ -2417 +3292 @@
          */
 
-        if ((err = hdsp_set_rate(hdsp, params_rate(params))) < 0) {
+        if ((err = hdsp_set_rate(hdsp, params_rate(params), 0)) < 0) {
                 _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
                 return err;
@@ -2434 +3309 @@
 {
         hdsp_t *hdsp = _snd_pcm_substream_chip(substream);
-        int chn;
+        int mapped_channel;
 
         snd_assert(info->channel < HDSP_MAX_CHANNELS, return -EINVAL);
 
-        if ((chn = hdsp->channel_map[info->channel]) < 0) {
+        if ((mapped_channel = hdsp->channel_map[info->channel]) < 0) {
                 return -EINVAL;
         }
 
-        info->offset = chn * HDSP_CHANNEL_BUFFER_BYTES;
+        info->offset = mapped_channel * HDSP_CHANNEL_BUFFER_BYTES;
         info->first = 0;
         info->step = 32;
@@ -2475 +3350 @@
         
         if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
                 return -EIO;
         }
@@ -2498 +3384 @@
 
         if (other) {
-                snd_pcm_substream_t *s = substream;
-                do {
-                        s = s->link_next;
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == other) {
                                 snd_pcm_trigger_done(s, substream);
@@ -2509 +3396 @@
                                 goto _ok;
                         }
-                } while (s != substream);
+                }
                 if (cmd == SNDRV_PCM_TRIGGER_START) {
                         if (!(running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) &&
@@ -2541 +3428 @@
 
         if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
                 return -EIO;
         }
@@ -2567 +3465 @@
         .rate_min =             32000,
         .rate_max =             96000,
-        .channels_min =         10,
+        .channels_min =         14,
         .channels_max =         HDSP_MAX_CHANNELS,
         .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
-        .period_bytes_min =     (64 * 4) *10,
+        .period_bytes_min =     (64 * 4) * 10,
         .period_bytes_max =     (8192 * 4) * HDSP_MAX_CHANNELS,
         .periods_min =          2,
         .periods_max =          2,
-        .fifo_size =            0,
+        .fifo_size =            0
 };
 
@@ -2592 +3490 @@
         .rate_min =             32000,
         .rate_max =             96000,
-        .channels_min =         10,
+        .channels_min =         14,
         .channels_max =         HDSP_MAX_CHANNELS,
         .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
@@ -2599 +3497 @@
         .periods_min =          2,
         .periods_max =          2,
-        .fifo_size =            0,
+        .fifo_size =            0
 };
 
@@ -2679 +3577 @@
         }
 
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
+                return -EIO;
+        }
+
         spin_lock_irqsave(&hdsp->lock, flags);
 
@@ -2710 +3619 @@
 
         hdsp->creg_spdif_stream = hdsp->creg_spdif;
-        hdsp->spdif_ctl->access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        hdsp->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
         snd_ctl_notify(hdsp->card, SNDRV_CTL_EVENT_MASK_VALUE |
                        SNDRV_CTL_EVENT_MASK_INFO, &hdsp->spdif_ctl->id);
@@ -2728 +3637 @@
         spin_unlock_irqrestore(&hdsp->lock, flags);
 
-        hdsp->spdif_ctl->access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        hdsp->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
         snd_ctl_notify(hdsp->card, SNDRV_CTL_EVENT_MASK_VALUE |
                        SNDRV_CTL_EVENT_MASK_INFO, &hdsp->spdif_ctl->id);
@@ -2742 +3651 @@
 
         if (hdsp_check_for_iobox (hdsp)) {
+                return -EIO;
+        }
+
+        if (hdsp_check_for_firmware(hdsp)) {
+                if (hdsp->state & HDSP_FirmwareCached) {
+                        if (snd_hdsp_load_firmware_from_cache(hdsp) != 0) {
+                                snd_printk("Firmware loading from cache failed, please upload manually.\n");
+                        }
+                } else {
+                        snd_printk("No firmware loaded nor cached, please upload firmware.\n");
+                }
                 return -EIO;
         }
@@ -2791 +3711 @@
 }
 
+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;
+}
+
+
+static int snd_hdsp_hwdep_ioctl(snd_hwdep_t *hw, struct file *file, unsigned int cmd, unsigned long arg)
+{
+        hdsp_t *hdsp = (hdsp_t *)hw->private_data;      
+        hdsp_peak_rms_t *peak_rms;
+        hdsp_firmware_t *firmware;
+        hdsp_mixer_t    *mixer;
+        hdsp_config_info_t info;
+        hdsp_version_t hdsp_version;
+        int i;
+        int err;
+        unsigned long flags;
+        
+        switch (cmd) {
+        case SNDRV_HDSP_IOCTL_GET_PEAK_RMS:
+                if (!(hdsp->state & HDSP_FirmwareLoaded)) {
+                        snd_printk("firmware needs to be uploaded to the card.\n");     
+                        return -EINVAL;
+                }
+                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;
+                }
+                break;
+        case SNDRV_HDSP_IOCTL_GET_CONFIG_INFO:
+                if (!(hdsp->state & HDSP_FirmwareLoaded)) {
+                        snd_printk("Firmware needs to be uploaded to the card.\n");     
+                        return -EINVAL;
+                }
+                spin_lock_irqsave(&hdsp->lock, flags);
+                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);
+                info.spdif_sync_check = (unsigned char)hdsp_spdif_sync_check(hdsp);
+                for (i = 0; i < ((hdsp->io_type != Multiface) ? 3 : 1); ++i) {
+                        info.adat_sync_check[i] = (unsigned char)hdsp_adat_sync_check(hdsp, i);
+                }
+                info.spdif_in = (unsigned char)hdsp_spdif_in(hdsp);
+                info.spdif_out = (unsigned char)hdsp_spdif_out(hdsp);
+                info.spdif_professional = (unsigned char)hdsp_spdif_professional(hdsp);
+                info.spdif_emphasis = (unsigned char)hdsp_spdif_emphasis(hdsp);
+                info.spdif_nonaudio = (unsigned char)hdsp_spdif_nonaudio(hdsp);
+                info.spdif_sample_rate = hdsp_spdif_sample_rate(hdsp);
+                info.system_sample_rate = hdsp->system_sample_rate;
+                info.autosync_sample_rate = hdsp_external_sample_rate(hdsp);
+                info.system_clock_mode = (unsigned char)hdsp_system_clock_mode(hdsp);
+                info.clock_source = (unsigned char)hdsp_clock_source(hdsp);
+                info.autosync_ref = (unsigned char)hdsp_autosync_ref(hdsp);
+                info.line_out = (unsigned char)hdsp_line_out(hdsp);
+                info.passthru = (unsigned char)hdsp->passthru;
+                spin_unlock_irqrestore(&hdsp->lock, flags);
+                if (copy_to_user((void *)arg, &info, sizeof(info)))
+                        return -EFAULT;
+                break;
+        case SNDRV_HDSP_IOCTL_GET_VERSION:
+                if (hdsp_is_9652(hdsp)) return -EINVAL;
+                if (hdsp->io_type == Undefined) {
+                        if ((err = hdsp_get_iobox_version(hdsp)) < 0) {
+                                return err;
+                        }
+                }
+                hdsp_version.io_type = hdsp->io_type;
+                hdsp_version.firmware_rev = hdsp->firmware_rev;
+                if ((err = copy_to_user((void *)arg, &hdsp_version, sizeof(hdsp_version)))) {
+                        return -EFAULT;
+                }
+                break;
+        case SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE:
+                if (hdsp_is_9652(hdsp)) return -EINVAL;
+                /* SNDRV_HDSP_IOCTL_GET_VERSION must have been called */
+                if (hdsp->io_type == Undefined) return -EINVAL;
+
+                snd_printk("initializing firmware upload\n");
+                firmware = (hdsp_firmware_t *)arg;
+
+                if (hdsp_check_for_iobox (hdsp)) {
+                        return -EIO;
+                }
+
+                if (copy_from_user(hdsp->firmware_cache, firmware->firmware_data, sizeof(unsigned long)*24413) != 0) {
+                        return -EFAULT;
+                }
+                
+                hdsp->state |= HDSP_FirmwareCached;
+
+                if ((err = snd_hdsp_load_firmware_from_cache(hdsp)) < 0) {
+                        return err;
+                }
+                
+                
+                if (!(hdsp->state & HDSP_InitializationComplete)) {
+                        snd_hdsp_initialize_channels(hdsp);
+                
+                        snd_hdsp_initialize_midi_flush(hdsp);
+            
+                        if ((err = snd_hdsp_create_alsa_devices(hdsp->card, hdsp)) < 0) {
+                                snd_printk("error creating alsa devices\n");
+                            return err;
+                        }
+                }
+                break;
+        case SNDRV_HDSP_IOCTL_GET_MIXER:
+                mixer = (hdsp_mixer_t *)arg;
+                if (copy_to_user(mixer->matrix, hdsp->mixer_matrix, sizeof(unsigned short)*HDSP_MATRIX_MIXER_SIZE))
+                        return -EFAULT;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
 static snd_pcm_ops_t snd_hdsp_playback_ops = {
         .open =         snd_hdsp_playback_open,
@@ -2814 +3864 @@
 };
 
+static int __devinit snd_hdsp_create_hwdep(snd_card_t *card,
+                                           hdsp_t *hdsp)
+{
+        snd_hwdep_t *hw;
+        int err;
+        
+        if ((err = snd_hwdep_new(card, "HDSP hwdep", 0, &hw)) < 0)
+                return err;
+                
+        hdsp->hwdep = hw;
+        hw->private_data = hdsp;
+        strcpy(hw->name, "HDSP hwdep interface");
+
+        hw->ops.open = snd_hdsp_hwdep_dummy_op;
+        hw->ops.ioctl = snd_hdsp_hwdep_ioctl;
+        hw->ops.release = snd_hdsp_hwdep_dummy_op;
+                
+        return 0;
+}
+
 static int __devinit snd_hdsp_create_pcm(snd_card_t *card,
                                          hdsp_t *hdsp)
@@ -2835 +3905 @@
 }
 
-static int __devinit snd_hdsp_initialize_firmware (hdsp_t *hdsp)
+static inline int snd_hdsp_initialize_input_enable (hdsp_t *hdsp)
 {
         int i;
-        u32 *firmware_ptr;
-
-        if (hdsp_check_for_iobox (hdsp)) {
-                return -EIO;
-        }
-
+        
         if (hdsp_fifo_wait (hdsp, 0, 100)) {
                 return -EIO;
         }
         
-        /* enable all channels */
-
         for (i = 0; i < HDSP_MAX_CHANNELS; ++i) {
                 hdsp_write (hdsp, HDSP_inputEnable + (4 * i), 1);
                 hdsp_write (hdsp, HDSP_outputEnable + (4 * i), 1);
         }
-
-        if (force_firmware[hdsp->dev] || (hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
-
-                snd_printk ("loading firmware\n");
-
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_PROGRAM);
-                hdsp_write (hdsp, HDSP_fifoData, 0);
-                if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT) < 0) {
-                        snd_printk ("timeout waiting for firmware setup\n");
-                        return -EIO;
-                }
-
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
-                hdsp_write (hdsp, HDSP_fifoData, 0);
-
-                if (hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT)) {
-                        hdsp->type = Multiface;
-                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_VERSION_BIT);
-                        hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
-                        hdsp_fifo_wait (hdsp, 0, HDSP_SHORT_WAIT);
-                } else {
-                        hdsp->type = Digiface;
-                } 
-
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_PROGRAM);
-                hdsp_write (hdsp, HDSP_fifoData, 0);
-                
-                if (hdsp_fifo_wait (hdsp, 0, HDSP_LONG_WAIT)) {
-                        snd_printk ("timeout waiting for download preparation\n");
-                        return -EIO;
-                }
-                
-                hdsp_write (hdsp, HDSP_jtagReg, HDSP_S_LOAD);
-                
-                if (hdsp->type == Digiface) {
-                        firmware_ptr = (u32 *) digiface_firmware;
-                } else {
-                        firmware_ptr = (u32 *) multiface_firmware;
-                }
-                
-                for (i = 0; i < 24413; ++i) {
-                        hdsp_write(hdsp, HDSP_fifoData, firmware_ptr[i]);
-                        if (hdsp_fifo_wait (hdsp, 127, HDSP_LONG_WAIT)) {
-                                snd_printk ("timeout during firmware loading\n");
-                                return -EIO;
-                        }
-                }
-                
-                if (hdsp_fifo_wait (hdsp, 3, HDSP_LONG_WAIT)) {
-                        snd_printk ("timeout at end of firmware loading\n");
-                        return -EIO;
-                }
-
-        } else {
-
-                /* firmware already loaded, but we need to know what type
-                   of I/O box is connected.
-                */
-
-                if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1) {
-                        hdsp->type = Multiface;
-                } else {
-                        hdsp->type = Digiface;
-                }
-        }
-
-        if (hdsp->type == Digiface) {
-                snd_printk ("I/O Box is a Digiface\n");
-                hdsp->card_name = "RME Hammerfall DSP (Digiface)";
+        
+        return 0;
+}
+
+static inline void snd_hdsp_initialize_channels(hdsp_t *hdsp)
+{
+        if (hdsp->io_type == Digiface) {
+                hdsp->card_name = "RME Hammerfall DSP + Digiface";
                 hdsp->ss_channels = DIGIFACE_SS_CHANNELS;
                 hdsp->ds_channels = DIGIFACE_DS_CHANNELS;
         } else {
-                snd_printk ("I/O Box is a Multiface\n");
-                hdsp->card_name = "RME Hammerfall DSP (Multiface)";
+                hdsp->card_name = "RME Hammerfall DSP + Multiface";
                 hdsp->ss_channels = MULTIFACE_SS_CHANNELS;
                 hdsp->ds_channels = MULTIFACE_DS_CHANNELS;
         }
-        
+}
+
+static inline void snd_hdsp_initialize_midi_flush (hdsp_t *hdsp)
+{
         snd_hdsp_flush_midi_input (hdsp, 0);
         snd_hdsp_flush_midi_input (hdsp, 1);
@@ -2938 +3942 @@
         hdsp_write(hdsp, HDSP_jtagReg, HDSP_BIGENDIAN_MODE);
 #endif
-
+}
+
+static int __devinit snd_hdsp_create_alsa_devices(snd_card_t *card, hdsp_t *hdsp)
+{
+        int err;
+        
+        if ((err = snd_hdsp_create_pcm(card, hdsp)) < 0) {
+                return err;
+        }
+        
+        if ((err = snd_hdsp_create_midi(card, hdsp, 0)) < 0) {
+                return err;
+        }
+
+        if ((err = snd_hdsp_create_midi(card, hdsp, 1)) < 0) {
+                return err;
+        }
+
+        if ((err = snd_hdsp_create_controls(card, hdsp)) < 0) {
+                return err;
+        }
+
+        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;
+        hdsp->capture_substream = NULL;
+        hdsp->playback_substream = NULL;
+
+        if ((err = snd_hdsp_set_defaults(hdsp)) < 0) {
+                return err;
+        }
+        
+        hdsp_update_simple_mixer_controls(hdsp);
+        
+        if (!(hdsp->state & HDSP_InitializationComplete)) {
+                sprintf(card->longname, "%s at 0x%lx, irq %d", hdsp->card_name, 
+                        hdsp->port, hdsp->irq);
+            
+                if ((err = snd_card_register(card)) < 0) {
+                        snd_printk("error registering card\n");
+                        return err;
+                }
+                hdsp->state |= HDSP_InitializationComplete;
+        }
+        
         return 0;
 }
@@ -2948 +4001 @@
         struct pci_dev *pci = hdsp->pci;
         int err;
-        unsigned short rev;
+        int i;
 
         hdsp->irq = -1;
+        hdsp->state = 0;
         hdsp->midi[0].rmidi = 0;
         hdsp->midi[1].rmidi = 0;
@@ -2961 +4015 @@
         hdsp->iobase = 0;
         hdsp->res_port = 0;
+        hdsp->io_type = Undefined;
+        for (i = 0; i < HDSP_MAX_CHANNELS; ++i)
+                hdsp->playback_mixer_ctls[i] = 0;
 
         hdsp->card = card;
@@ -2966 +4023 @@
         spin_lock_init(&hdsp->lock);
 
-        pci_read_config_word(hdsp->pci, PCI_CLASS_REVISION, &rev);
+        tasklet_init(&hdsp->midi_tasklet, hdsp_midi_tasklet, (unsigned long)hdsp);
+        
+        pci_read_config_word(hdsp->pci, PCI_CLASS_REVISION, &hdsp->firmware_rev);
         strcpy(card->driver, "H-DSP");
         strcpy(card->mixername, "Xilinx FPGA");
         
-        switch (rev & 0xff) {
+        switch (hdsp->firmware_rev & 0xff) {
         case 0xa:
         case 0xb:
+                hdsp->card_name = "RME Hammerfall DSP";
+                break;
         case 0x64:
-                /* hdsp_initialize_firmware() will reset this */
-                hdsp->card_name = "RME Hammerfall DSP";
-                break;
-
+        case 0x65:
+        case 0x68:
+                hdsp->card_name = "RME HDSP 9652";
+                break;
         default:
                 return -ENODEV;
@@ -3010 +4071 @@
                 return err;
         }
-
-        if ((err = snd_hdsp_initialize_firmware(hdsp)) < 0) {
+        
+        if (hdsp_is_9652(hdsp)) {
+                
+                if ((err = snd_hdsp_initialize_input_enable(hdsp)) != 0) {
+                        return err;
+                }
+
+                hdsp->io_type = Digiface;               
+        
+                hdsp->ss_channels = DIGIFACE_SS_CHANNELS;
+                hdsp->ds_channels = DIGIFACE_DS_CHANNELS;
+        
+                snd_hdsp_initialize_midi_flush(hdsp);
+        
+                if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
+                        return err;
+                }
+
+        } else {
+        
+                if (hdsp_check_for_iobox (hdsp)) {
+                        /* no iobox connected, we defer initialization */
+                        snd_printk("card initialization pending : waiting for firmware\n");
+                        if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
+                                return err;
+                        }
+                        return 0;
+                }
+
+                if ((err = snd_hdsp_initialize_input_enable(hdsp)) != 0) {
+                        return err;
+                }
+                
+                if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
+                        snd_printk("card initialization pending : waiting for firmware\n");
+                        if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
+                                return err;
+                        }
+                return 0;
+                } 
+                
+                snd_printk("Firmware already loaded, initializing card.\n");
+
+                if (hdsp_read(hdsp, HDSP_status2Register) & HDSP_version1) {
+                        hdsp->io_type = Multiface;
+                } else {
+                        hdsp->io_type = Digiface;
+                }
+                
+                if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0) {
+                        return err;
+                }
+                
+                snd_hdsp_initialize_channels(hdsp);
+                
+                snd_hdsp_initialize_midi_flush(hdsp);
+                
+        }
+        
+        hdsp->state |= HDSP_FirmwareLoaded;     
+        
+        if ((err = snd_hdsp_create_alsa_devices(card, hdsp)) < 0) {
                 return err;
         }
-
-        if ((err = snd_hdsp_create_pcm(card, hdsp)) < 0) {
-                return err;
-        }
-
-        if ((err = snd_hdsp_create_midi(card, hdsp, 0)) < 0) {
-                return err;
-        }
-
-        if ((err = snd_hdsp_create_midi(card, hdsp, 1)) < 0) {
-                return err;
-        }
-
-        if ((err = snd_hdsp_create_controls(card, hdsp)) < 0) {
-                return err;
-        }
-
-        snd_hdsp_proc_init(hdsp);
-
-        hdsp->last_spdif_sample_rate = -1;
-        hdsp->last_adat_sample_rate = -1;
-        hdsp->playback_pid = -1;
-        hdsp->capture_pid = -1;
-        hdsp->capture_substream = NULL;
-        hdsp->playback_substream = NULL;
-
-        snd_hdsp_set_defaults(hdsp);
-
-        return 0;
+        
+        return 0;       
 }
 
 static int snd_hdsp_free(hdsp_t *hdsp)
 {
-        /* stop the audio, and cancel all interrupts */
-        hdsp->control_register &= ~(HDSP_Start|HDSP_AudioInterruptEnable|HDSP_Midi0InterruptEnable|HDSP_Midi1InterruptEnable);
-        hdsp_write (hdsp, HDSP_controlRegister, hdsp->control_register);
+        if (hdsp->res_port) {
+                /* stop the audio, and cancel all interrupts */
+                hdsp->control_register &= ~(HDSP_Start|HDSP_AudioInterruptEnable|HDSP_Midi0InterruptEnable|HDSP_Midi1InterruptEnable);
+                hdsp_write (hdsp, HDSP_controlRegister, hdsp->control_register);
+        }
 
         if (hdsp->irq >= 0)
                 free_irq(hdsp->irq, (void *)hdsp);
 
-        snd_hdsp_proc_done(hdsp);
         snd_hdsp_free_buffers(hdsp);
         
@@ -3124 +4219 @@
 
 static struct pci_driver driver = {
-        .name = "RME Hammerfall DSP",
+        .name =     "RME Hammerfall DSP",
         .id_table = snd_hdsp_ids,
-        .probe = snd_hdsp_probe,
+        .probe =    snd_hdsp_probe,
         .remove = __devexit_p(snd_hdsp_remove),
 };

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

@@ -1947 +1947 @@
 }
 
-void snd_rme9652_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_rme9652_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         rme9652_t *rme9652 = (rme9652_t *) dev_id;
 
         if (!(rme9652_read(rme9652, RME9652_status_register) & RME9652_IRQ)) {
-                return;
+                return IRQ_NONE;
         }
 
@@ -1964 +1964 @@
                 snd_pcm_period_elapsed(rme9652->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
         }
+        return IRQ_HANDLED;
 }
 
@@ -2054 +2055 @@
                 runtime->status->hw_ptr = 0;
         if (other) {
-                snd_pcm_substream_t *s = substream;
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
                 snd_pcm_runtime_t *oruntime = other->runtime;
-                do {
-                        s = s->link_next;
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == other) {
                                 oruntime->status->hw_ptr = runtime->status->hw_ptr;
                                 break;
                         }
-                } while (s != substream);
+                }
         }
         return 0;
@@ -2200 +2202 @@
 
         if (other) {
-                snd_pcm_substream_t *s = substream;
-                do {
-                        s = s->link_next;
+                struct list_head *pos;
+                snd_pcm_substream_t *s;
+                snd_pcm_group_for_each(pos, substream) {
+                        s = snd_pcm_group_substream_entry(pos);
                         if (s == other) {
                                 snd_pcm_trigger_done(s, substream);
@@ -2211 +2214 @@
                                 goto _ok;
                         }
-                } while (s != substream);
+                }
                 if (cmd == SNDRV_PCM_TRIGGER_START) {
                         if (!(running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) &&
@@ -2405 +2408 @@
 
         rme9652->creg_spdif_stream = rme9652->creg_spdif;
-        rme9652->spdif_ctl->access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        rme9652->spdif_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
         snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
                        SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);
@@ -2423 +2426 @@
         spin_unlock_irqrestore(&rme9652->lock, flags);
 
-        rme9652->spdif_ctl->access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
+        rme9652->spdif_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
         snd_ctl_notify(rme9652->card, SNDRV_CTL_EVENT_MASK_VALUE |
                        SNDRV_CTL_EVENT_MASK_INFO, &rme9652->spdif_ctl->id);

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

@@ -602 +602 @@
 }
 
-static void snd_sonicvibes_interrupt(int irq, void *dev_id, struct pt_regs *regs)
-{
-        sonicvibes_t *sonic = snd_magic_cast(sonicvibes_t, dev_id, return);
+static irqreturn_t snd_sonicvibes_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        sonicvibes_t *sonic = snd_magic_cast(sonicvibes_t, dev_id, return IRQ_NONE);
         unsigned char status;
 
         status = inb(SV_REG(sonic, STATUS));
         if (!(status & (SV_DMAA_IRQ | SV_DMAC_IRQ | SV_MIDI_IRQ)))
-                return;
+                return IRQ_NONE;
         if (status == 0xff) {   /* failure */
                 outb(sonic->irqmask = ~0, SV_REG(sonic, IRQMASK));
                 snd_printk("IRQ failure - interrupts disabled!!\n");
-                return;
+                return IRQ_HANDLED;
         }
         if (sonic->pcm) {
@@ -660 +660 @@
                 snd_ctl_notify(sonic->card, SNDRV_CTL_EVENT_MASK_VALUE, &sonic->master_volume->id);
         }
+        return IRQ_HANDLED;
 }
 

GPL/branches/alsa-resync1/alsa-kernel/pci/trident/trident_main.c

@@ -2715 +2715 @@
         .name =         "PCM Front Playback Volume",
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
+        .count =        32,
         .info =         snd_trident_pcm_vol_control_info,
         .get =          snd_trident_pcm_vol_control_get,
@@ -2776 +2777 @@
         .name =         "PCM Pan Playback Control",
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
+        .count =        32,
         .info =         snd_trident_pcm_pan_control_info,
         .get =          snd_trident_pcm_pan_control_get,
@@ -2829 +2831 @@
         .name =         "PCM Reverb Playback Volume",
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
+        .count =        32,
         .info =         snd_trident_pcm_rvol_control_info,
         .get =          snd_trident_pcm_rvol_control_get,

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

@@ -1368 +1368 @@
 {
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
-        .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
-        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
         .info =         snd_ymfpci_spdif_stream_info,
         .get =          snd_ymfpci_spdif_stream_get,