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

Timestamp:

Jul 26, 2007, 7:21:09 AM (18 years ago)

Author:

Brendan Oakley

Message:

Merged to Alsa 0.9.1

Location:

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

Files:

• emu10k1/emuproc.c (modified) (1 diff)
• ice1712/ak4524.c (modified) (16 diffs)
• ice1712/delta.c (modified) (13 diffs)
• ice1712/ews.c (modified) (32 diffs)
• ice1712/ews.h (modified) (2 diffs)
• ice1712/ice1712.c (modified) (75 diffs)
• ice1712/ice1712.h (modified) (8 diffs)
• ice1712/ice1724.c (added)
• ice1712/makefile.os2 (modified) (1 diff)
• ice1712/revo.c (added)
• ice1712/revo.h (added)
• korg1212/korg1212.c (modified) (85 diffs)
• rme96.c (modified) (28 diffs)
• rme9652/hammerfall_mem.c (modified) (4 diffs)
• rme9652/hdsp.c (modified) (18 diffs)
• rme9652/rme9652.c (modified) (21 diffs)
• sonicvibes.c (modified) (10 diffs)
• trident/trident_main.c (modified) (5 diffs)
• ymfpci/ymfpci_main.c (modified) (3 diffs)

GPL/branches/alsa-resync1/alsa-kernel/pci/emu10k1/emuproc.c

@@ -478 +478 @@
 
 
-#ifdef TARGET_OS2
 static struct snd_info_entry_ops snd_emu10k1_proc_ops_fx8010 = {
-    0, 0, snd_emu10k1_fx8010_read, 0, 0,0,0,0
+        .read = snd_emu10k1_fx8010_read,
 };
-#else
-static struct snd_info_entry_ops snd_emu10k1_proc_ops_fx8010 = {
-read: snd_emu10k1_fx8010_read,
-};
-#endif
+
 int __devinit snd_emu10k1_proc_init(struct snd_emu10k1 * emu)
 {

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

@@ -2 +2 @@
  *   ALSA driver for ICEnsemble ICE1712 (Envy24)
  *
- *   AK4524 / AK4528 / AK4529 interface
+ *   AK4524 / AK4528 / AK4529 / AK4355 / AK4381 interface
  *
  *      Copyright (c) 2000 Jaroslav Kysela <perex@suse.cz>
@@ -32 +32 @@
 
 /*
- * write AK4524 register
+ * write AK4xxx register
  */
-void snd_ice1712_ak4524_write(ice1712_t *ice, int chip,
-                                     unsigned char addr, unsigned char data)
-{
-        unsigned char tmp, saved[2];
+void snd_ice1712_akm4xxx_write(akm4xxx_t *ak, int chip,
+                              unsigned char addr, unsigned char data)
+{
+        unsigned int tmp;
         int idx;
         unsigned int addrdata;
-        ak4524_t *ak = &ice->ak4524;
+        ice1712_t *ice = ak->chip;
 
         snd_assert(chip >= 0 && chip < 4, return);
 
         if (ak->ops.start) {
-                if (ak->ops.start(ice, saved, chip) < 0)
+                if (ak->ops.start(ak, chip) < 0)
                         return;
         } else
-                snd_ice1712_save_gpio_status(ice, saved);
-
-        tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
+                snd_ice1712_save_gpio_status(ice);
+
+        tmp = snd_ice1712_gpio_read(ice);
         tmp |= ak->add_flags;
         tmp &= ~ak->mask_flags;
@@ -56 +56 @@
                 if (ak->cif) {
                         tmp |= ak->cs_mask; /* start without chip select */
+                }  else {
+                        tmp &= ~ak->cs_mask; /* chip select low */
+                        snd_ice1712_gpio_write(ice, tmp);
+                        udelay(1);
+                }
         } else {
-                        tmp &= ~ak->cs_mask; /* chip select low */
-                snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
-                udelay(1);
-                }
-        } else {
+                /* doesn't handle cf=1 yet */
                 tmp &= ~ak->cs_mask;
                 tmp |= ak->cs_addr;
-        }
-
-        addr &= 0x07;
+                snd_ice1712_gpio_write(ice, tmp);
+                udelay(1);
+        }
+
         /* build I2C address + data byte */
-        /* assume C1=1, C0=0 */
-        addrdata = 0xa000 | (addr << 8) | data;
+        addrdata = (ak->caddr << 6) | 0x20 | (addr & 0x1f);
+        addrdata = (addrdata << 8) | data;
         for (idx = 15; idx >= 0; idx--) {
-                tmp &= ~(ak->data_mask | ak->clk_mask);
+                /* drop clock */
+                tmp &= ~ak->clk_mask;
+                snd_ice1712_gpio_write(ice, tmp);
+                udelay(1);
+                /* set data */
                 if (addrdata & (1 << idx))
                         tmp |= ak->data_mask;
-                snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
-                //udelay(200);
+                else
+                        tmp &= ~ak->data_mask;
+                snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
+                /* raise clock */
                 tmp |= ak->clk_mask;
-                snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
+                snd_ice1712_gpio_write(ice, tmp);
                 udelay(1);
         }
 
-        if (ak->type == SND_AK4524) {
-        if ((addr != 0x04 && addr != 0x05) || (data & 0x80) == 0)
+        /* save the data */
+        if (ak->type == SND_AK4524 || ak->type == SND_AK4528) {
+                if ((addr != 0x04 && addr != 0x05) || (data & 0x80) == 0)
+                        ak->images[chip][addr] = data;
+                else
+                        ak->ipga_gain[chip][addr-4] = data;
+        } else {
+                /* AK4529, or else */
                 ak->images[chip][addr] = data;
-        else
-                ak->ipga_gain[chip][addr-4] = data;
-        }
-
+        }
+        
         if (ak->cs_mask == ak->cs_addr) {
                 if (ak->cif) {
                         /* assert a cs pulse to trigger */
                         tmp &= ~ak->cs_mask;
-                        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
+                        snd_ice1712_gpio_write(ice, tmp);
                         udelay(1);
                 }
@@ -101 +113 @@
                 tmp |= ak->cs_none; /* deselect address */
         }
-                snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
-                udelay(1);
+        snd_ice1712_gpio_write(ice, tmp);
+        udelay(1);
 
         if (ak->ops.stop)
-                ak->ops.stop(ice, saved);
+                ak->ops.stop(ak);
         else
-                snd_ice1712_restore_gpio_status(ice, saved);
-}
-
-void snd_ice1712_ak4524_reset(ice1712_t *ice, int state)
-{
-        int chip;
+                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;
-        ak4524_t *ak = &ice->ak4524;
         
         switch (ak->type) {
         case SND_AK4524:
         case SND_AK4528:
-        for (chip = 0; chip < ak->num_dacs/2; chip++) {
-                snd_ice1712_ak4524_write(ice, chip, 0x01, state ? 0x00 : 0x03);
-                if (state)
-                        continue;
+                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_ak4524_write(ice, chip, reg, ak->images[chip][reg]);
+                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->images[chip][reg]);
                         if (ak->type == SND_AK4528)
-                        continue;
+                                continue;
                         /* IPGA */
-                for (reg = 0x04; reg < 0x06; reg++)
-                        snd_ice1712_ak4524_write(ice, chip, reg, ak->ipga_gain[chip][reg-4]);
+                        for (reg = 0x04; reg < 0x06; reg++)
+                                snd_ice1712_akm4xxx_write(ak, chip, reg, ak->ipga_gain[chip][reg-4]);
                 }
                 break;
@@ -136 +153 @@
                 /* 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 ak4524/4528 chips
+ * initialize all the ak4xxx chips
  */
-void __devinit snd_ice1712_ak4524_init(ice1712_t *ice)
+static void __devinit snd_ice1712_akm4xxx_init_chip(akm4xxx_t *ak)
 {
         static unsigned char inits_ak4524[] = {
@@ -171 +205 @@
                 0x09, 0x01, /* 9: ATS=0, RSTN=1 */
                 0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
-                0x00, 0x08, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
+                0x00, 0x0c, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
                 0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
                 0x02, 0xff, /* 2: LOUT1 muted */
@@ -184 +218 @@
                 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;
-        ak4524_t *ak = &ice->ak4524;
 
         switch (ak->type) {
@@ -198 +258 @@
                 break;
         case SND_AK4529:
-        default:
                 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;
         }
 
@@ -209 +279 @@
                         reg = *ptr++;
                         data = *ptr++;
-                        snd_ice1712_ak4524_write(ice, chip, reg, data);
-                }
-        }
+                        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)
+{
+        *ak = *temp;
+        ak->chip = ice;
+        snd_ice1712_akm4xxx_init_chip(ak);
 }
 
@@ -217 +298 @@
 #define AK_GET_CHIP(val)                (((val) >> 8) & 0xff)
 #define AK_GET_ADDR(val)                ((val) & 0xff)
-#define AK_GET_SHIFT(val)               (((val) >> 16) & 0xff)
-#define AK_COMPOSE(chip,addr,shift)     (((chip) << 8) | (addr) | ((shift) << 16))
-
-static int snd_ice1712_ak4524_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
+#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 = 127;
-        return 0;
-}
-
-static int snd_ice1712_ak4524_volume_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+        uinfo->value.integer.max = mask;
+        return 0;
+}
+
+static int snd_ice1712_akm4xxx_volume_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] = ice->ak4524.images[chip][addr];
-        return 0;
-}
-
-static int snd_ice1712_ak4524_volume_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+        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);
-        unsigned char nval = ucontrol->value.integer.value[0];
-        int change = ice->ak4524.images[chip][addr] != nval;
+        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_ak4524_write(ice, chip, addr, nval);
+                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
         return change;
 }
 
-static int snd_ice1712_ak4524_ipga_gain_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+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;
@@ -259 +355 @@
 }
 
-static int snd_ice1712_ak4524_ipga_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+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] = ice->ak4524.ipga_gain[chip][addr-4] & 0x7f;
-        return 0;
-}
-
-static int snd_ice1712_ak4524_ipga_gain_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+        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 = ice->ak4524.ipga_gain[chip][addr] != nval;
+        int change = ak->ipga_gain[chip][addr] != nval;
         if (change)
-                snd_ice1712_ak4524_write(ice, chip, addr, nval);
+                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
         return change;
 }
 
-static int snd_ice1712_ak4524_deemphasis_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
+static int snd_ice1712_akm4xxx_deemphasis_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
 {
         static char *texts[4] = {
@@ -294 +390 @@
 }
 
-static int snd_ice1712_ak4524_deemphasis_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+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] = (ice->ak4524.images[chip][addr] >> shift) & 3;
-        return 0;
-}
-
-static int snd_ice1712_ak4524_deemphasis_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+        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);
@@ -313 +409 @@
         int change;
         
-        nval = (nval << shift) | (ice->ak4524.images[chip][addr] & ~(3 << shift));
-        change = ice->ak4524.images[chip][addr] != nval;
+        nval = (nval << shift) | (ak->images[chip][addr] & ~(3 << shift));
+        change = ak->images[chip][addr] != nval;
         if (change)
-                snd_ice1712_ak4524_write(ice, chip, addr, nval);
+                snd_ice1712_akm4xxx_write(ak, chip, addr, nval);
         return change;
 }
@@ -324 +420 @@
  */
 
-int __devinit snd_ice1712_ak4524_build_controls(ice1712_t *ice)
-{
-        int err, idx;
-        ak4524_t *ak = &ice->ak4524;
-
-        for (idx = 0; idx < ak->num_dacs; ++idx) {
+int __devinit snd_ice1712_akm4xxx_build_controls(ice1712_t *ice)
+{
+        unsigned int idx;
+        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;
+                        ctl.id.index = idx + ak->idx_offset * 2;
                         ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_ak4524_volume_info;
+                        ctl.info = snd_ice1712_akm4xxx_volume_info;
                         ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_ak4524_volume_get;
-                        ctl.put = snd_ice1712_ak4524_volume_put;
-                switch (ak->type) {
-                case SND_AK4524:
-                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 6, 0); /* register 6 & 7 */
-                        break;
-                case SND_AK4528:
-                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* 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);
-                        break;
-                }
-                }
-                        ctl.private_data = ice;
+                        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) {
+                for (idx = 0; idx < ak->num_adcs && ak->type == SND_AK4524; ++idx) {
                         snd_kcontrol_t ctl;
                         memset(&ctl, 0, sizeof(ctl));
@@ -362 +469 @@
                         ctl.id.index = idx;
                         ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_ak4524_volume_info;
+                        ctl.info = snd_ice1712_akm4xxx_volume_info;
                         ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_ak4524_volume_get;
-                        ctl.put = snd_ice1712_ak4524_volume_put;
-                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
-                        ctl.private_data = ice;
+                        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;
@@ -374 +481 @@
                         ctl.id.index = idx;
                         ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_ak4524_ipga_gain_info;
+                        ctl.info = snd_ice1712_akm4xxx_ipga_gain_info;
                         ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_ak4524_ipga_gain_get;
-                        ctl.put = snd_ice1712_ak4524_ipga_gain_put;
-                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
-                        ctl.private_data = ice;
+                        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++) {
+                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;
+                        ctl.id.index = idx + ak->idx_offset;
                         ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
-                        ctl.info = snd_ice1712_ak4524_deemphasis_info;
+                        ctl.info = snd_ice1712_akm4xxx_deemphasis_info;
                         ctl.access = SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE;
-                        ctl.get = snd_ice1712_ak4524_deemphasis_get;
-                        ctl.put = snd_ice1712_ak4524_deemphasis_put;
-                switch (ak->type) {
-                case SND_AK4524:
-                case SND_AK4528:
-                        ctl.private_value = AK_COMPOSE(idx, 3, 0); /* register 3 */
-                        break;
-                case SND_AK4529: {
-                        int shift = idx == 3 ? 6 : (2 - idx) * 2;
-                        ctl.private_value = AK_COMPOSE(0, 8, shift); /* register 8 with shift */
-                        break;
-                }
-                }
-                        ctl.private_data = ice;
+                        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;
                 }
-        return 0;
-}
-
-
+        }
+        return 0;
+}
+
+

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

@@ -190 +190 @@
 static int delta_spdif_default_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol)
 {
-        unsigned long flags;
         unsigned int val;
         int change;
 
         val = snd_cs8403_encode_spdif_bits(&ucontrol->value.iec958);
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         change = ice->spdif.cs8403_bits != val;
         ice->spdif.cs8403_bits = val;
         if (change && ice->playback_pro_substream == NULL) {
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                spin_unlock_irq(&ice->reg_lock);
                 snd_ice1712_delta_cs8403_spdif_write(ice, val);
         } else {
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                spin_unlock_irq(&ice->reg_lock);
         }
         return change;
@@ -214 +213 @@
 static int delta_spdif_stream_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol)
 {
-        unsigned long flags;
         unsigned int val;
         int change;
 
         val = snd_cs8403_encode_spdif_bits(&ucontrol->value.iec958);
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         change = ice->spdif.cs8403_stream_bits != val;
         ice->spdif.cs8403_stream_bits = val;
         if (change && ice->playback_pro_substream != NULL) {
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                spin_unlock_irq(&ice->reg_lock);
                 snd_ice1712_delta_cs8403_spdif_write(ice, val);
         } else {
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                spin_unlock_irq(&ice->reg_lock);
         }
         return change;
@@ -235 +233 @@
  * AK4524 on Delta 44 and 66 to choose the chip mask
  */
-static int delta_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
-{
-        snd_ice1712_save_gpio_status(ice, saved);
-        ice->ak4524.cs_mask =
-        ice->ak4524.cs_addr = chip == 0 ? ICE1712_DELTA_CODEC_CHIP_A :
-                                          ICE1712_DELTA_CODEC_CHIP_B;
+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;
 }
@@ -247 +245 @@
  * AK4524 on Delta1010LT to choose the chip address
  */
-static int delta1010lt_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
-{
-        snd_ice1712_save_gpio_status(ice, saved);
-        ice->ak4524.cs_mask = ICE1712_DELTA_1010LT_CS;
-        ice->ak4524.cs_addr = chip << 4;
+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;
 }
@@ -258 +256 @@
  * change the rate of AK4524 on Delta 44/66, AP, 1010LT
  */
-static void delta_ak4524_set_rate_val(ice1712_t *ice, unsigned int rate)
+static void delta_ak4524_set_rate_val(akm4xxx_t *ak, unsigned int rate)
 {
         unsigned char tmp, tmp2;
+        ice1712_t *ice = ak->chip;
 
         if (rate == 0)  /* no hint - S/PDIF input is master, simply return */
@@ -277 +276 @@
 
         /* do it again */
-        snd_ice1712_ak4524_reset(ice, 1);
+        snd_ice1712_akm4xxx_reset(ak, 1);
         down(&ice->gpio_mutex);
         tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ~ICE1712_DELTA_DFS;
@@ -284 +283 @@
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
         up(&ice->gpio_mutex);
-        snd_ice1712_ak4524_reset(ice, 0);
+        snd_ice1712_akm4xxx_reset(ak, 0);
 }
 
@@ -299 +298 @@
 
 /* set up */
-static void delta_setup_spdif(ice1712_t *ice, snd_pcm_substream_t * substream)
+static void delta_setup_spdif(ice1712_t *ice, int rate)
 {
         unsigned long flags;
@@ -309 +308 @@
         if (tmp & 0x01)         /* consumer */
                 tmp &= (tmp & 0x01) ? ~0x06 : ~0x18;
-        switch (substream->runtime->rate) {
+        switch (rate) {
         case 32000: tmp |= (tmp & 0x01) ? 0x04 : 0x00; break;
         case 44100: tmp |= (tmp & 0x01) ? 0x00 : 0x10; break;
@@ -328 +327 @@
  */
 
+static akm4xxx_t akm_audiophile __devinitdata = {
+        .type = SND_AK4528,
+        .num_adcs = 2,
+        .num_dacs = 2,
+        .caddr = 2,
+        .cif = 0,
+        .data_mask = ICE1712_DELTA_AP_DOUT,
+        .clk_mask = ICE1712_DELTA_AP_CCLK,
+        .cs_mask = ICE1712_DELTA_AP_CS_CODEC,
+        .cs_addr = ICE1712_DELTA_AP_CS_CODEC,
+        .cs_none = 0,
+        .add_flags = ICE1712_DELTA_AP_CS_DIGITAL,
+        .mask_flags = 0,
+        .ops = {
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static akm4xxx_t akm_delta410 __devinitdata = {
+        .type = SND_AK4529,
+        .num_adcs = 2,
+        .num_dacs = 8,
+        .caddr = 0,
+        .cif = 0,
+        .data_mask = ICE1712_DELTA_AP_DOUT,
+        .clk_mask = ICE1712_DELTA_AP_CCLK,
+        .cs_mask = ICE1712_DELTA_AP_CS_CODEC,
+        .cs_addr = ICE1712_DELTA_AP_CS_CODEC,
+        .cs_none = 0,
+        .add_flags = ICE1712_DELTA_AP_CS_DIGITAL,
+        .mask_flags = 0,
+        .ops = {
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static akm4xxx_t akm_delta1010lt __devinitdata = {
+        .type = SND_AK4524,
+        .num_adcs = 8,
+        .num_dacs = 8,
+        .caddr = 2,
+        .cif = 0, /* the default level of the CIF pin from AK4524 */
+        .data_mask = ICE1712_DELTA_1010LT_DOUT,
+        .clk_mask = ICE1712_DELTA_1010LT_CCLK,
+        .cs_mask = 0,
+        .cs_addr = 0, /* set later */
+        .cs_none = ICE1712_DELTA_1010LT_CS_NONE,
+        .add_flags = 0,
+        .mask_flags = 0,
+        .ops = {
+                .start = delta1010lt_ak4524_start,
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
+static akm4xxx_t akm_delta44 __devinitdata = {
+        .type = SND_AK4524,
+        .num_adcs = 4,
+        .num_dacs = 4,
+        .caddr = 2,
+        .cif = 0, /* the default level of the CIF pin from AK4524 */
+        .data_mask = ICE1712_DELTA_CODEC_SERIAL_DATA,
+        .clk_mask = ICE1712_DELTA_CODEC_SERIAL_CLOCK,
+        .cs_mask = 0,
+        .cs_addr = 0, /* set later */
+        .cs_none = 0,
+        .add_flags = 0,
+        .mask_flags = 0,
+        .ops = {
+                .start = delta_ak4524_start,
+                .set_rate_val = delta_ak4524_set_rate_val
+        }
+};
+
 static int __devinit snd_ice1712_delta_init(ice1712_t *ice)
 {
         int err;
-        ak4524_t *ak;
+        akm4xxx_t *ak;
 
         /* determine I2C, DACs and ADCs */
@@ -369 +442 @@
         case ICE1712_SUBDEVICE_DELTA66:
                 ice->spdif.ops.open = delta_open_spdif;
-                ice->spdif.ops.setup = delta_setup_spdif;
+                ice->spdif.ops.setup_rate = delta_setup_spdif;
                 ice->spdif.ops.default_get = delta_spdif_default_get;
                 ice->spdif.ops.default_put = delta_spdif_default_put;
@@ -379 +452 @@
         }
 
+        /* no analog? */
+        switch (ice->eeprom.subvendor) {
+        case ICE1712_SUBDEVICE_DELTA1010:
+        case ICE1712_SUBDEVICE_DELTADIO2496:
+                return 0;
+        }
+
         /* second stage of initialization, analog parts and others */
-        ak = &ice->ak4524;
+        ak = ice->akm = kmalloc(sizeof(akm4xxx_t), GFP_KERNEL);
+        if (! ak)
+                return -ENOMEM;
+        ice->akm_codecs = 1;
+
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_AUDIOPHILE:
+                snd_ice1712_akm4xxx_init(ak, &akm_audiophile, ice);
+                break;
         case ICE1712_SUBDEVICE_DELTA410:
-                ak->num_adcs = ak->num_dacs = 2;
-                ak->type = SND_AK4528;
-                if (ice->eeprom.subvendor == ICE1712_SUBDEVICE_DELTA410) {
-                        ak->num_dacs = 8;
-                        ak->type = SND_AK4529;
-                }
-                ak->cif = 0; /* the default level of the CIF pin from AK4528/4529 */
-                ak->data_mask = ICE1712_DELTA_AP_DOUT;
-                ak->clk_mask = ICE1712_DELTA_AP_CCLK;
-                ak->cs_mask = ak->cs_addr = ICE1712_DELTA_AP_CS_CODEC; /* select AK4528/4529 codec */
-                ak->cs_none = 0;
-                ak->add_flags = ICE1712_DELTA_AP_CS_DIGITAL; /* assert digital high */
-                ak->mask_flags = 0;
-                ak->ops.set_rate_val = delta_ak4524_set_rate_val;
-                snd_ice1712_ak4524_init(ice);
+                snd_ice1712_akm4xxx_init(ak, &akm_delta410, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA1010LT:
-                ak->num_adcs = ak->num_dacs = 8;
-                ak->type = SND_AK4524;
-                ak->cif = 0; /* the default level of the CIF pin from AK4524 */
-                ak->data_mask = ICE1712_DELTA_1010LT_DOUT;
-                ak->clk_mask = ICE1712_DELTA_1010LT_CCLK;
-                ak->cs_mask = ak->cs_addr = 0; /* set later */
-                ak->cs_none = ICE1712_DELTA_1010LT_CS_NONE;
-                ak->add_flags = 0;
-                ak->mask_flags = 0;
-                ak->ops.start = delta1010lt_ak4524_start;
-                ak->ops.set_rate_val = delta_ak4524_set_rate_val;
-                snd_ice1712_ak4524_init(ice);
+                snd_ice1712_akm4xxx_init(ak, &akm_delta1010lt, ice);
                 break;
         case ICE1712_SUBDEVICE_DELTA66:
         case ICE1712_SUBDEVICE_DELTA44:
-                ak->num_adcs = ak->num_dacs = 4;
-                ak->type = SND_AK4524;
-                ak->cif = 0; /* the default level of the CIF pin from AK4524 */
-                ak->data_mask = ICE1712_DELTA_CODEC_SERIAL_DATA;
-                ak->clk_mask = ICE1712_DELTA_CODEC_SERIAL_CLOCK;
-                ak->cs_mask = ak->cs_addr = 0; /* set later */
-                ak->cs_none = 0;
-                ak->add_flags = 0;
-                ak->mask_flags = 0;
-                ak->ops.start = delta_ak4524_start;
-                ak->ops.set_rate_val = delta_ak4524_set_rate_val;
-                snd_ice1712_ak4524_init(ice);
-                break;
+                snd_ice1712_akm4xxx_init(ak, &akm_delta44, ice);
+                break;
+        default:
+                snd_BUG();
+                return -EINVAL;
         }
 
@@ -509 +562 @@
         case ICE1712_SUBDEVICE_DELTA44:
         case ICE1712_SUBDEVICE_DELTA66:
-                err = snd_ice1712_ak4524_build_controls(ice);
+                err = snd_ice1712_akm4xxx_build_controls(ice);
                 if (err < 0)
                         return err;

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

@@ -84 +84 @@
         unsigned char mask;
 
-        snd_ice1712_save_gpio_status(ice, (unsigned char *)&bus->private_value);
+        snd_ice1712_save_gpio_status(ice);
         /* set RW high */
         mask = ICE1712_EWX2496_RW;
@@ -101 +101 @@
 {
         ice1712_t *ice = snd_magic_cast(ice1712_t, bus->private_data, return);
-        snd_ice1712_restore_gpio_status(ice, (unsigned char *)&bus->private_value);
+        snd_ice1712_restore_gpio_status(ice);
 }
 
@@ -113 +113 @@
         if (data)
                 mask |= ICE1712_EWX2496_SERIAL_DATA; /* write SDA */
-        ice->gpio_direction &= ~(ICE1712_EWX2496_SERIAL_CLOCK|ICE1712_EWX2496_SERIAL_DATA);
-        ice->gpio_direction |= mask;
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->gpio_direction);
+        ice->gpio.direction &= ~(ICE1712_EWX2496_SERIAL_CLOCK|ICE1712_EWX2496_SERIAL_DATA);
+        ice->gpio.direction |= mask;
+        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->gpio.direction);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~mask);
 }
@@ -156 +156 @@
 
 /* start callback for EWS88MT, needs to select a certain chip mask */
-static int ews88mt_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
-{
+static int ews88mt_ak4524_start(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->chip;
         unsigned char tmp;
         /* assert AK4524 CS */
         if (snd_ice1712_ews88mt_chip_select(ice, ~(1 << chip) & 0x0f) < 0)
                 return -EINVAL;
-        snd_ice1712_save_gpio_status(ice, saved);
+        snd_ice1712_save_gpio_status(ice);
         tmp = ICE1712_EWS88_SERIAL_DATA |
                 ICE1712_EWS88_SERIAL_CLOCK |
                 ICE1712_EWS88_RW;
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
-                          ice->gpio_direction | tmp);
+                          ice->gpio.direction | tmp);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
         return 0;
@@ -173 +174 @@
 
 /* stop callback for EWS88MT, needs to deselect chip mask */
-static void ews88mt_ak4524_stop(ice1712_t *ice, unsigned char *saved)
-{
-        snd_ice1712_restore_gpio_status(ice, saved);
+static void ews88mt_ak4524_stop(akm4xxx_t *ak)
+{
+        ice1712_t *ice = ak->chip;
+        snd_ice1712_restore_gpio_status(ice);
         udelay(1);
         snd_ice1712_ews88mt_chip_select(ice, 0x0f);
@@ -181 +183 @@
 
 /* start callback for EWX24/96 */
-static int ewx2496_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
-{
+static int ewx2496_ak4524_start(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->chip;
         unsigned char tmp;
-        snd_ice1712_save_gpio_status(ice, saved);
+        snd_ice1712_save_gpio_status(ice);
         tmp =  ICE1712_EWX2496_SERIAL_DATA |
                 ICE1712_EWX2496_SERIAL_CLOCK |
@@ -190 +193 @@
                 ICE1712_EWX2496_RW;
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
-                          ice->gpio_direction | tmp);
+                          ice->gpio.direction | tmp);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
         return 0;
@@ -196 +199 @@
 
 /* start callback for DMX 6fire */
-static int dmx6fire_ak4524_start(ice1712_t *ice, unsigned char *saved, int chip)
-{
+static int dmx6fire_ak4524_start(akm4xxx_t *ak, int chip)
+{
+        ice1712_t *ice = ak->chip;
         unsigned char tmp;
-        snd_ice1712_save_gpio_status(ice, saved);
-        tmp = ice->ak4524.cs_mask = ice->ak4524.cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
+        snd_ice1712_save_gpio_status(ice);
+        tmp = ak->cs_mask = ak->cs_addr = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
         tmp |= ICE1712_6FIRE_SERIAL_DATA |
                 ICE1712_6FIRE_SERIAL_CLOCK |
                 ICE1712_6FIRE_RW;
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
-                          ice->gpio_direction | tmp);
+                          ice->gpio.direction | tmp);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~tmp);
         return 0;
@@ -222 +226 @@
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_EWS88MT:
+        case ICE1712_SUBDEVICE_EWS88MT_NEW:
                 snd_runtime_check(snd_i2c_sendbytes(ice->cs8404, &bits, 1) == 1, goto _error);
                 break;
@@ -246 +251 @@
 static int ews88_spdif_default_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol)
 {
-        unsigned long flags;
         unsigned int val;
         int change;
 
         val = snd_cs8404_encode_spdif_bits(&ucontrol->value.iec958);
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         change = ice->spdif.cs8403_bits != val;
         ice->spdif.cs8403_bits = val;
         if (change && ice->playback_pro_substream == NULL) {
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                spin_unlock_irq(&ice->reg_lock);
                 snd_ice1712_ews_cs8404_spdif_write(ice, val);
         } else {
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                spin_unlock_irq(&ice->reg_lock);
         }
         return change;
@@ -270 +274 @@
 static int ews88_spdif_stream_put(ice1712_t *ice, snd_ctl_elem_value_t * ucontrol)
 {
-        unsigned long flags;
         unsigned int val;
         int change;
 
         val = snd_cs8404_encode_spdif_bits(&ucontrol->value.iec958);
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         change = ice->spdif.cs8403_stream_bits != val;
         ice->spdif.cs8403_stream_bits = val;
         if (change && ice->playback_pro_substream != NULL) {
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                spin_unlock_irq(&ice->reg_lock);
                 snd_ice1712_ews_cs8404_spdif_write(ice, val);
         } else {
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                spin_unlock_irq(&ice->reg_lock);
         }
         return change;
@@ -295 +298 @@
 
 /* set up SPDIF for EWS88MT / EWS88D */
-static void ews88_setup_spdif(ice1712_t *ice, snd_pcm_substream_t * substream)
+static void ews88_setup_spdif(ice1712_t *ice, int rate)
 {
         unsigned long flags;
@@ -305 +308 @@
         if (tmp & 0x10)         /* consumer */
                 tmp &= (tmp & 0x01) ? ~0x06 : ~0x60;
-        switch (substream->runtime->rate) {
+        switch (rate) {
         case 32000: tmp |= (tmp & 0x01) ? 0x02 : 0x00; break;
         case 44100: tmp |= (tmp & 0x01) ? 0x06 : 0x40; break;
@@ -321 +324 @@
 
 /*
+ */
+static akm4xxx_t akm_ews88mt __devinitdata = {
+        .num_adcs = 8,
+        .num_dacs = 8,
+        .type = SND_AK4524,
+        .caddr = 2,
+        .cif = 1, /* CIF high */
+        .data_mask = ICE1712_EWS88_SERIAL_DATA,
+        .clk_mask = ICE1712_EWS88_SERIAL_CLOCK,
+        .cs_mask = 0,
+        .cs_addr = 0,
+        .cs_none = 0, /* no chip select on gpio */
+        .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
+        .mask_flags = 0,
+        .ops = {
+                .start = ews88mt_ak4524_start,
+                .stop = ews88mt_ak4524_stop
+        }
+};
+
+static akm4xxx_t akm_ewx2496 __devinitdata = {
+        .num_adcs = 2,
+        .num_dacs = 2,
+        .type = SND_AK4524,
+        .caddr = 2,
+        .cif = 1, /* CIF high */
+        .data_mask = ICE1712_EWS88_SERIAL_DATA,
+        .clk_mask = ICE1712_EWS88_SERIAL_CLOCK,
+        .cs_mask = ICE1712_EWX2496_AK4524_CS,
+        .cs_addr = ICE1712_EWX2496_AK4524_CS,
+        .cs_none = 0,
+        .add_flags = ICE1712_EWS88_RW, /* set rw bit high */
+        .mask_flags = 0,
+        .ops = {
+                .start = ewx2496_ak4524_start
+        }
+};
+
+static akm4xxx_t akm_6fire __devinitdata = {
+        .num_adcs = 6,
+        .num_dacs = 6,
+        .type = SND_AK4524,
+        .caddr = 2,
+        .cif = 1, /* CIF high */
+        .data_mask = ICE1712_6FIRE_SERIAL_DATA,
+        .clk_mask = ICE1712_6FIRE_SERIAL_CLOCK,
+        .cs_mask = 0,
+        .cs_addr = 0, /* set later */
+        .cs_none = 0,
+        .add_flags = ICE1712_6FIRE_RW, /* set rw bit high */
+        .mask_flags = 0,
+        .ops = {
+                .start = dmx6fire_ak4524_start
+        }
+};
+
+
+/*
  * initialize the chip
  */
@@ -327 +388 @@
 {
         int err;
-        ak4524_t *ak;
+        akm4xxx_t *ak;
 
         /* set the analog DACs */
@@ -335 +396 @@
                 break;  
         case ICE1712_SUBDEVICE_EWS88MT:
+        case ICE1712_SUBDEVICE_EWS88MT_NEW:
                 ice->num_total_dacs = 8;
                 break;
@@ -361 +423 @@
                 break;
         case ICE1712_SUBDEVICE_EWS88MT:
+        case ICE1712_SUBDEVICE_EWS88MT_NEW:
                 if ((err = snd_i2c_device_create(ice->i2c, "CS8404", ICE1712_EWS88MT_CS8404_ADDR, &ice->cs8404)) < 0)
                         return err;
@@ -383 +446 @@
                         return err;
                 break;
-#if 0 // XXX not working...
         case ICE1712_SUBDEVICE_DMX6FIRE:
                 if ((err = snd_ice1712_init_cs8427(ice, ICE1712_6FIRE_CS8427_ADDR)) < 0)
                         return err;
-#endif
+                break;
         case ICE1712_SUBDEVICE_EWS88MT:
+        case ICE1712_SUBDEVICE_EWS88MT_NEW:
         case ICE1712_SUBDEVICE_EWS88D:
                 /* set up CS8404 */
                 ice->spdif.ops.open = ews88_open_spdif;
-                ice->spdif.ops.setup = ews88_setup_spdif;
+                ice->spdif.ops.setup_rate = ews88_setup_spdif;
                 ice->spdif.ops.default_get = ews88_spdif_default_get;
                 ice->spdif.ops.default_put = ews88_spdif_default_put;
@@ -402 +465 @@
         }
 
+        /* no analog? */
+        switch (ice->eeprom.subvendor) {
+        case ICE1712_SUBDEVICE_EWS88D:
+                return 0;
+        }
+
         /* analog section */
-        ak = &ice->ak4524;
+        ak = ice->akm = kmalloc(sizeof(akm4xxx_t), GFP_KERNEL);
+        if (! ak)
+                return -ENOMEM;
+        ice->akm_codecs = 1;
+
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_EWS88MT:
-                ak->num_adcs = ak->num_dacs = 8;
-                ak->type = SND_AK4524;
-                ak->cif = 1; /* CIF high */
-                ak->data_mask = ICE1712_EWS88_SERIAL_DATA;
-                ak->clk_mask = ICE1712_EWS88_SERIAL_CLOCK;
-                ak->cs_mask = ak->cs_addr = ak->cs_none = 0; /* no chip select on gpio */
-                ak->add_flags = ICE1712_EWS88_RW; /* set rw bit high */
-                ak->mask_flags = 0;
-                ak->ops.start = ews88mt_ak4524_start;
-                ak->ops.stop = ews88mt_ak4524_stop;
-                snd_ice1712_ak4524_init(ice);
+        case ICE1712_SUBDEVICE_EWS88MT_NEW:
+                snd_ice1712_akm4xxx_init(ak, &akm_ews88mt, ice);
                 break;
         case ICE1712_SUBDEVICE_EWX2496:
-                ak->num_adcs = ak->num_dacs = 2;
-                ak->type = SND_AK4524;
-                ak->cif = 1; /* CIF high */
-                ak->data_mask = ICE1712_EWS88_SERIAL_DATA;
-                ak->clk_mask = ICE1712_EWS88_SERIAL_CLOCK;
-                ak->cs_mask = ak->cs_addr = ICE1712_EWX2496_AK4524_CS;
-                ak->cs_none = 0;
-                ak->add_flags = ICE1712_EWS88_RW; /* set rw bit high */
-                ak->mask_flags = 0;
-                ak->ops.start = ewx2496_ak4524_start;
-                snd_ice1712_ak4524_init(ice);
+                snd_ice1712_akm4xxx_init(ak, &akm_ewx2496, ice);
                 break;
         case ICE1712_SUBDEVICE_DMX6FIRE:
-                ak->num_adcs = ak->num_dacs = 6;
-                ak->type = SND_AK4524;
-                ak->cif = 1; /* CIF high */
-                ak->data_mask = ICE1712_6FIRE_SERIAL_DATA;
-                ak->clk_mask = ICE1712_6FIRE_SERIAL_CLOCK;
-                ak->cs_mask = ak->cs_addr = 0; /* set later */
-                ak->cs_none = 0;
-                ak->add_flags = ICE1712_6FIRE_RW; /* set rw bit high */
-                ak->mask_flags = 0;
-                ak->ops.start = dmx6fire_ak4524_start;
-                snd_ice1712_ak4524_init(ice);
+                snd_ice1712_akm4xxx_init(ak, &akm_6fire, ice);
                 break;
         }
@@ -472 +516 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         unsigned char mask = kcontrol->private_value & 0xff;
-        unsigned char saved[2];
         
-        snd_ice1712_save_gpio_status(ice, saved);
+        snd_ice1712_save_gpio_status(ice);
         ucontrol->value.enumerated.item[0] = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & mask ? 1 : 0;
-        snd_ice1712_restore_gpio_status(ice, saved);
+        snd_ice1712_restore_gpio_status(ice);
         return 0;
 }
@@ -484 +527 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         unsigned char mask = kcontrol->private_value & 0xff;
-        unsigned char saved[2];
         int val, nval;
 
@@ -490 +532 @@
                 return -EPERM;
         nval = ucontrol->value.enumerated.item[0] ? mask : 0;
-        snd_ice1712_save_gpio_status(ice, saved);
+        snd_ice1712_save_gpio_status(ice);
         val = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
         nval |= val & ~mask;
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, nval);
-        snd_ice1712_restore_gpio_status(ice, saved);
+        snd_ice1712_restore_gpio_status(ice);
         return val != nval;
 }
@@ -851 +893 @@
 static int __devinit snd_ice1712_ews_add_controls(ice1712_t *ice)
 {
-        int err, idx;
+        unsigned int idx;
+        int err;
         snd_kcontrol_t *kctl;
         
@@ -863 +906 @@
         case ICE1712_SUBDEVICE_EWX2496:
         case ICE1712_SUBDEVICE_EWS88MT:
+        case ICE1712_SUBDEVICE_EWS88MT_NEW:
         case ICE1712_SUBDEVICE_DMX6FIRE:
-                err = snd_ice1712_ak4524_build_controls(ice);
+                err = snd_ice1712_akm4xxx_build_controls(ice);
                 if (err < 0)
                         return err;
@@ -873 +917 @@
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_EWX2496:
-                for (idx = 0; idx < sizeof(snd_ice1712_ewx2496_controls)/sizeof(snd_ice1712_ewx2496_controls[0]); idx++) {
+                for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_ewx2496_controls); idx++) {
                         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ewx2496_controls[idx], ice));
                         if (err < 0)
@@ -880 +924 @@
                 break;
         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);
@@ -892 +937 @@
                 break;
         case ICE1712_SUBDEVICE_EWS88D:
-                for (idx = 0; idx < sizeof(snd_ice1712_ews88d_controls)/sizeof(snd_ice1712_ews88d_controls[0]); idx++) {
+                for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_ews88d_controls); idx++) {
                         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88d_controls[idx], ice));
                         if (err < 0)
@@ -899 +944 @@
                 break;
         case ICE1712_SUBDEVICE_DMX6FIRE:
-                for (idx = 0; idx < sizeof(snd_ice1712_6fire_controls)/sizeof(snd_ice1712_6fire_controls[0]); idx++) {
+                for (idx = 0; idx < ARRAY_SIZE(snd_ice1712_6fire_controls); idx++) {
                         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_6fire_controls[idx], ice));
                         if (err < 0)
@@ -914 +959 @@
         {
                 ICE1712_SUBDEVICE_EWX2496,
-                "TerraTec EWX 24/96",
+                "TerraTec EWX24/96",
                 snd_ice1712_ews_init,
                 snd_ice1712_ews_add_controls,
@@ -920 +965 @@
         {
                 ICE1712_SUBDEVICE_EWS88MT,
-                "TerraTec EWS 88MT",
+                "TerraTec EWS88MT",
+                snd_ice1712_ews_init,
+                snd_ice1712_ews_add_controls,
+        },
+        {
+                ICE1712_SUBDEVICE_EWS88MT_NEW,
+                "TerraTec EWS88MT",
                 snd_ice1712_ews_init,
                 snd_ice1712_ews_add_controls,
@@ -926 +977 @@
         {
                 ICE1712_SUBDEVICE_EWS88D,
-                "TerraTec EWS 88D",
+                "TerraTec EWS88D",
                 snd_ice1712_ews_init,
                 snd_ice1712_ews_add_controls,
@@ -932 +983 @@
         {
                 ICE1712_SUBDEVICE_DMX6FIRE,
-                "TerraTec DMX 6Fire",
+                "TerraTec DMX6Fire",
                 snd_ice1712_ews_init,
                 snd_ice1712_ews_add_controls,

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

@@ -34 +34 @@
 #define ICE1712_SUBDEVICE_EWX2496       0x3b153011
 #define ICE1712_SUBDEVICE_EWS88MT       0x3b151511
+#define ICE1712_SUBDEVICE_EWS88MT_NEW   0x3b152511
 #define ICE1712_SUBDEVICE_EWS88D        0x3b152b11
 #define ICE1712_SUBDEVICE_DMX6FIRE      0x3b153811
@@ -77 +78 @@
 
 #define ICE1712_6FIRE_PCF9554_ADDR      (0x40>>1)
-#define ICE1712_6FIRE_CS8427_ADDR       (0x22>>1)
+#define ICE1712_6FIRE_CS8427_ADDR       (0x22)
 
 #endif /* __SOUND_EWS_H */

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

@@ -33 +33 @@
  *      is stored in the local file and called from registration
  *      function from card_info struct.
+ *
+ *  2002.11.26  James Stafford <jstafford@ampltd.com>
+ *      Added support for VT1724 (Envy24HT)
+ *      I have left out support for 176.4 and 192 KHz for the moment. 
+ *  I also haven't done anything with the internal S/PDIF transmitter or the MPU-401
+ *
+ *  2003.02.20  Taksahi Iwai <tiwai@suse.de>
+ *      Split vt1724 part to an independent driver.
+ *      The GPIO is accessed through the callback functions now.
  */
 
@@ -96 +105 @@
 
 static struct pci_device_id snd_ice1712_ids[] __devinitdata = {
-        { PCI_VENDOR_ID_ICE, PCI_DEVICE_ID_ICE_1712, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },   /* ICE1712 */
+        { PCI_VENDOR_ID_ICE, PCI_DEVICE_ID_ICE_1712, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },   /* ICE1712 */
         { 0, }
 };
@@ -113 +122 @@
  */
  
+/* check whether the clock mode is spdif-in */
 static inline int is_spdif_master(ice1712_t *ice)
 {
@@ -240 +250 @@
 }
 
+/*
+ * consumer ac97 digital mix
+ */
 static int snd_ice1712_digmix_route_ac97_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
 {
@@ -252 +265 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
         
-        spin_lock_irqsave(&ice->reg_lock, flags);
         ucontrol->value.integer.value[0] = inb(ICEMT(ice, MONITOR_ROUTECTRL)) & ICE1712_ROUTE_AC97 ? 1 : 0;
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
         return 0;
 }
@@ -264 +274 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         unsigned char val, nval;
-        unsigned long flags;
         
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         val = inb(ICEMT(ice, MONITOR_ROUTECTRL));
         nval = val & ~ICE1712_ROUTE_AC97;
         if (ucontrol->value.integer.value[0]) nval |= ICE1712_ROUTE_AC97;
         outb(nval, ICEMT(ice, MONITOR_ROUTECTRL));
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock_irq(&ice->reg_lock);
         return val != nval;
 }
@@ -284 +293 @@
 
 
-
 /*
- * set gpio direction, write mask and data
+ * gpio operations
  */
-void snd_ice1712_gpio_write_bits(ice1712_t *ice, int mask, int bits)
-{
-        ice->gpio_direction |= mask;
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->gpio_direction);
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~mask);
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, mask & bits);
-}
-
-/*
- */
-void snd_ice1712_save_gpio_status(ice1712_t *ice, unsigned char *tmp)
-{
-        down(&ice->gpio_mutex);
-        tmp[0] = ice->gpio_direction;
-        tmp[1] = ice->gpio_write_mask;
-}
-
-void snd_ice1712_restore_gpio_status(ice1712_t *ice, unsigned char *tmp)
-{
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, tmp[0]);
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, tmp[1]);
-        ice->gpio_direction = tmp[0];
-        ice->gpio_write_mask = tmp[1];
-        up(&ice->gpio_mutex);
+static void snd_ice1712_set_gpio_dir(ice1712_t *ice, unsigned int data)
+{
+        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, data);
+}
+
+static void snd_ice1712_set_gpio_mask(ice1712_t *ice, unsigned int data)
+{
+        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, data);
+}
+
+static unsigned int snd_ice1712_get_gpio_data(ice1712_t *ice)
+{
+        return snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
+}
+
+static void snd_ice1712_set_gpio_data(ice1712_t *ice, unsigned int val)
+{
+        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, val);
 }
 
@@ -370 +372 @@
 }
 
-static void setup_cs8427(ice1712_t *ice, snd_pcm_substream_t * substream)
-{
-        snd_cs8427_iec958_pcm(ice->cs8427, substream->runtime->rate);
+static void setup_cs8427(ice1712_t *ice, int rate)
+{
+        snd_cs8427_iec958_pcm(ice->cs8427, rate);
 }
 
@@ -388 +390 @@
         ice->spdif.ops.open = open_cs8427;
         ice->spdif.ops.close = close_cs8427;
-        ice->spdif.ops.setup = setup_cs8427;
+        ice->spdif.ops.setup_rate = setup_cs8427;
         return 0;
 }
@@ -556 +558 @@
 static int snd_ice1712_playback_prepare(snd_pcm_substream_t * substream)
 {
-        unsigned long flags;
         ice1712_t *ice = snd_pcm_substream_chip(substream);
         snd_pcm_runtime_t *runtime = substream->runtime;
@@ -571 +572 @@
         if (rate > 0x000fffff)
                 rate = 0x000fffff;
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock(&ice->reg_lock);
         outb(0, ice->ddma_port + 15);
         outb(ICE1712_DMA_MODE_WRITE | ICE1712_DMA_AUTOINIT, ice->ddma_port + 0x0b);
@@ -584 +585 @@
         snd_ice1712_write(ice, ICE1712_IREG_PBK_LEFT, 0);
         snd_ice1712_write(ice, ICE1712_IREG_PBK_RIGHT, 0);
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock(&ice->reg_lock);
         return 0;
 }
@@ -590 +591 @@
 static int snd_ice1712_playback_ds_prepare(snd_pcm_substream_t * substream)
 {
-        unsigned long flags;
         ice1712_t *ice = snd_pcm_substream_chip(substream);
         snd_pcm_runtime_t *runtime = substream->runtime;
@@ -608 +608 @@
         ice->playback_con_virt_addr[substream->number] = runtime->dma_addr;
         chn = substream->number * 2;
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock(&ice->reg_lock);
         snd_ice1712_ds_write(ice, chn, ICE1712_DSC_ADDR0, runtime->dma_addr);
         snd_ice1712_ds_write(ice, chn, ICE1712_DSC_COUNT0, period_size);
@@ -620 +620 @@
                 snd_ice1712_ds_write(ice, chn + 1, ICE1712_DSC_VOLUME, 0);
         }
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock(&ice->reg_lock);
         return 0;
 }
@@ -626 +626 @@
 static int snd_ice1712_capture_prepare(snd_pcm_substream_t * substream)
 {
-        unsigned long flags;
         ice1712_t *ice = snd_pcm_substream_chip(substream);
         snd_pcm_runtime_t *runtime = substream->runtime;
@@ -639 +638 @@
         if (runtime->channels == 2)
                 tmp &= ~0x02;
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock(&ice->reg_lock);
         outl(ice->capture_con_virt_addr = runtime->dma_addr, ICEREG(ice, CONCAP_ADDR));
         outw(buf_size, ICEREG(ice, CONCAP_COUNT));
@@ -645 +644 @@
         snd_ice1712_write(ice, ICE1712_IREG_CAP_COUNT_LO, period_size & 0xff);
         snd_ice1712_write(ice, ICE1712_IREG_CAP_CTRL, tmp);
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock(&ice->reg_lock);
         snd_ac97_set_rate(ice->ac97, AC97_PCM_LR_ADC_RATE, runtime->rate);
         return 0;
@@ -763 +762 @@
         snd_pcm_runtime_t *runtime = substream->runtime;
         ice1712_t *ice = snd_pcm_substream_chip(substream);
-        unsigned long flags;
         u32 tmp;
 
         ice->playback_con_substream_ds[substream->number] = substream;
         runtime->hw = snd_ice1712_playback_ds;
-        spin_lock_irqsave(&ice->reg_lock, flags); 
+        spin_lock_irq(&ice->reg_lock); 
         tmp = inw(ICEDS(ice, INTMASK)) & ~(1 << (substream->number * 2));
         outw(tmp, ICEDS(ice, INTMASK));
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock_irq(&ice->reg_lock);
         return 0;
 }
@@ -799 +797 @@
 {
         ice1712_t *ice = snd_pcm_substream_chip(substream);
-        unsigned long flags;
         u32 tmp;
 
-        spin_lock_irqsave(&ice->reg_lock, flags); 
+        spin_lock_irq(&ice->reg_lock); 
         tmp = inw(ICEDS(ice, INTMASK)) | (3 << (substream->number * 2));
         outw(tmp, ICEDS(ice, INTMASK));
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock_irq(&ice->reg_lock);
         ice->playback_con_substream_ds[substream->number] = NULL;
         return 0;
@@ -967 +964 @@
                 unsigned int old;
                 snd_pcm_substream_t *s = substream;
+
                 do {
                         if (s == ice->playback_pro_substream) {
@@ -995 +993 @@
 /*
  */
-static void snd_ice1712_set_pro_rate(ice1712_t *ice, unsigned int rate, int do_not_lock)
+static void snd_ice1712_set_pro_rate(ice1712_t *ice, unsigned int rate, int force)
 {
         unsigned long flags;
         unsigned char val;
-        int old_lock_value;
+        unsigned int i;
 
         spin_lock_irqsave(&ice->reg_lock, flags);
-        old_lock_value = PRO_RATE_LOCKED;
-        if (do_not_lock)
-                PRO_RATE_LOCKED = 0;
         if (inb(ICEMT(ice, PLAYBACK_CONTROL)) & (ICE1712_CAPTURE_START_SHADOW|
                                                   ICE1712_PLAYBACK_PAUSE|
@@ -1011 +1006 @@
                 return;
         }
-        if (!is_pro_rate_locked(ice))
-                goto __unlock;
+        if (!force && is_pro_rate_locked(ice)) {
+                spin_unlock_irqrestore(&ice->reg_lock, flags);
+                return;
+        }
 
         switch (rate) {
@@ -1034 +1031 @@
         }
         outb(val, ICEMT(ice, RATE));
-        PRO_RATE_LOCKED = old_lock_value;
-
-      __unlock:
+
         spin_unlock_irqrestore(&ice->reg_lock, flags);
 
-        if (ice->ak4524.ops.set_rate_val)
-                ice->ak4524.ops.set_rate_val(ice, rate);
+        for (i = 0; i < ice->akm_codecs; i++) {
+                if (ice->akm[i].ops.set_rate_val)
+                        ice->akm[i].ops.set_rate_val(&ice->akm[i], rate);
+        }
 }
 
 static int snd_ice1712_playback_pro_prepare(snd_pcm_substream_t * substream)
 {
-        unsigned long flags;
         ice1712_t *ice = snd_pcm_substream_chip(substream);
 
         ice->playback_pro_size = snd_pcm_lib_buffer_bytes(substream);
-        snd_ice1712_set_pro_rate(ice, substream->runtime->rate, 0);
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock(&ice->reg_lock);
         outl(substream->runtime->dma_addr, ICEMT(ice, PLAYBACK_ADDR));
         outw((ice->playback_pro_size >> 2) - 1, ICEMT(ice, PLAYBACK_SIZE));
         outw((snd_pcm_lib_period_bytes(substream) >> 2) - 1, ICEMT(ice, PLAYBACK_COUNT));
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
-
-        if (ice->spdif.ops.setup)
-                ice->spdif.ops.setup(ice, substream);
-
-        return 0;
+        spin_unlock(&ice->reg_lock);
+
+        return 0;
+}
+
+static int snd_ice1712_playback_pro_hw_params(snd_pcm_substream_t * substream,
+                                              snd_pcm_hw_params_t * hw_params)
+{
+        ice1712_t *ice = snd_pcm_substream_chip(substream);
+
+        snd_ice1712_set_pro_rate(ice, params_rate(hw_params), 0);
+        if (ice->spdif.ops.setup_rate)
+                ice->spdif.ops.setup_rate(ice, params_rate(hw_params));
+        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 }
 
 static int snd_ice1712_capture_pro_prepare(snd_pcm_substream_t * substream)
 {
-        unsigned long flags;
         ice1712_t *ice = snd_pcm_substream_chip(substream);
 
         ice->capture_pro_size = snd_pcm_lib_buffer_bytes(substream);
-        snd_ice1712_set_pro_rate(ice, substream->runtime->rate, 0);
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock(&ice->reg_lock);
         outl(substream->runtime->dma_addr, ICEMT(ice, CAPTURE_ADDR));
         outw((ice->capture_pro_size >> 2) - 1, ICEMT(ice, CAPTURE_SIZE));
         outw((snd_pcm_lib_period_bytes(substream) >> 2) - 1, ICEMT(ice, CAPTURE_COUNT));
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
-        return 0;
+        spin_unlock(&ice->reg_lock);
+        return 0;
+}
+
+static int snd_ice1712_capture_pro_hw_params(snd_pcm_substream_t * substream,
+                                             snd_pcm_hw_params_t * hw_params)
+{
+        ice1712_t *ice = snd_pcm_substream_chip(substream);
+
+        snd_ice1712_set_pro_rate(ice, params_rate(hw_params), 0);
+        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
 }
 
@@ -1203 +1213 @@
         .close =        snd_ice1712_playback_pro_close,
         .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    snd_ice1712_hw_params,
+        .hw_params =    snd_ice1712_playback_pro_hw_params,
         .hw_free =      snd_ice1712_hw_free,
         .prepare =      snd_ice1712_playback_pro_prepare,
@@ -1214 +1224 @@
         .close =        snd_ice1712_capture_pro_close,
         .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    snd_ice1712_hw_params,
+        .hw_params =    snd_ice1712_capture_pro_hw_params,
         .hw_free =      snd_ice1712_hw_free,
         .prepare =      snd_ice1712_capture_pro_prepare,
@@ -1287 +1297 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
         int index = kcontrol->private_value;
         
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         ucontrol->value.integer.value[0] = !((ice->pro_volumes[index] >> 15) & 1);
         ucontrol->value.integer.value[1] = !((ice->pro_volumes[index] >> 31) & 1);
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock_irq(&ice->reg_lock);
         return 0;
 }
@@ -1299 +1308 @@
 static int snd_ice1712_pro_mixer_switch_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
-        unsigned long flags;
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         int index = kcontrol->private_value;
@@ -1306 +1314 @@
         nval = (ucontrol->value.integer.value[0] ? 0 : 0x00008000) |
                (ucontrol->value.integer.value[1] ? 0 : 0x80000000);
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         nval |= ice->pro_volumes[index] & ~0x80008000;
         change = nval != ice->pro_volumes[index];
         ice->pro_volumes[index] = nval;
         snd_ice1712_update_volume(ice, index);
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock_irq(&ice->reg_lock);
         return change;
 }
@@ -1327 +1335 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
         int index = kcontrol->private_value;
         
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         ucontrol->value.integer.value[0] = (ice->pro_volumes[index] >> 0) & 127;
         ucontrol->value.integer.value[1] = (ice->pro_volumes[index] >> 16) & 127;
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock_irq(&ice->reg_lock);
         return 0;
 }
@@ -1339 +1346 @@
 static int snd_ice1712_pro_mixer_volume_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
-        unsigned long flags;
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         int index = kcontrol->private_value;
@@ -1346 +1352 @@
         nval = (ucontrol->value.integer.value[0] & 127) |
                ((ucontrol->value.integer.value[1] & 127) << 16);
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         nval |= ice->pro_volumes[index] & ~0x007f007f;
         change = nval != ice->pro_volumes[index];
         ice->pro_volumes[index] = nval;
         snd_ice1712_update_volume(ice, index);
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock_irq(&ice->reg_lock);
         return change;
 }
 
 
-static int __init snd_ice1712_build_pro_mixer(ice1712_t *ice)
+static int __devinit snd_ice1712_build_pro_mixer(ice1712_t *ice)
 {
         snd_card_t * card = ice->card;
@@ -1436 +1442 @@
         int err;
 
-        if (!(ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97)) {
+        if (ice_has_con_ac97(ice)) {
                 ac97_t ac97;
                 memset(&ac97, 0, sizeof(ac97));
@@ -1451 +1457 @@
                 }
         }
-        /* hmm.. can we have both consumer and pro ac97 mixers? */
-        if (! (ice->eeprom.aclink & ICE1712_CFG_PRO_I2S)) {
+
+        if (! (ice->eeprom.data[ICE_EEP1_ACLINK] & ICE1712_CFG_PRO_I2S)) {
                 ac97_t ac97;
                 memset(&ac97, 0, sizeof(ac97));
@@ -1473 +1479 @@
  */
 
+static inline unsigned int eeprom_double(ice1712_t *ice, int idx)
+{
+        return (unsigned int)ice->eeprom.data[idx] | ((unsigned int)ice->eeprom.data[idx + 1] << 8);
+}
+
 static void snd_ice1712_proc_read(snd_info_entry_t *entry, 
                                   snd_info_buffer_t * buffer)
@@ -1479 +1490 @@
         unsigned int idx;
 
-        snd_iprintf(buffer, "ICE1712\n\n");
+        snd_iprintf(buffer, "%s\n\n", ice->card->longname);
         snd_iprintf(buffer, "EEPROM:\n");
+
         snd_iprintf(buffer, "  Subvendor        : 0x%x\n", ice->eeprom.subvendor);
         snd_iprintf(buffer, "  Size             : %i bytes\n", ice->eeprom.size);
         snd_iprintf(buffer, "  Version          : %i\n", ice->eeprom.version);
-        snd_iprintf(buffer, "  Codec            : 0x%x\n", ice->eeprom.codec);
-        snd_iprintf(buffer, "  ACLink           : 0x%x\n", ice->eeprom.aclink);
-        snd_iprintf(buffer, "  I2S ID           : 0x%x\n", ice->eeprom.i2sID);
-        snd_iprintf(buffer, "  S/PDIF           : 0x%x\n", ice->eeprom.spdif);
+        snd_iprintf(buffer, "  Codec            : 0x%x\n", ice->eeprom.data[ICE_EEP1_CODEC]);
+        snd_iprintf(buffer, "  ACLink           : 0x%x\n", ice->eeprom.data[ICE_EEP1_ACLINK]);
+        snd_iprintf(buffer, "  I2S ID           : 0x%x\n", ice->eeprom.data[ICE_EEP1_I2SID]);
+        snd_iprintf(buffer, "  S/PDIF           : 0x%x\n", ice->eeprom.data[ICE_EEP1_SPDIF]);
         snd_iprintf(buffer, "  GPIO mask        : 0x%x\n", ice->eeprom.gpiomask);
         snd_iprintf(buffer, "  GPIO state       : 0x%x\n", ice->eeprom.gpiostate);
         snd_iprintf(buffer, "  GPIO direction   : 0x%x\n", ice->eeprom.gpiodir);
-        snd_iprintf(buffer, "  AC'97 main       : 0x%x\n", ice->eeprom.ac97main);
-        snd_iprintf(buffer, "  AC'97 pcm        : 0x%x\n", ice->eeprom.ac97pcm);
-        snd_iprintf(buffer, "  AC'97 record     : 0x%x\n", ice->eeprom.ac97rec);
-        snd_iprintf(buffer, "  AC'97 record src : 0x%x\n", ice->eeprom.ac97recsrc);
+        snd_iprintf(buffer, "  AC'97 main       : 0x%x\n", eeprom_double(ice, ICE_EEP1_AC97_MAIN_LO));
+        snd_iprintf(buffer, "  AC'97 pcm        : 0x%x\n", eeprom_double(ice, ICE_EEP1_AC97_PCM_LO));
+        snd_iprintf(buffer, "  AC'97 record     : 0x%x\n", eeprom_double(ice, ICE_EEP1_AC97_REC_LO));
+        snd_iprintf(buffer, "  AC'97 record src : 0x%x\n", ice->eeprom.data[ICE_EEP1_AC97_RECSRC]);
         for (idx = 0; idx < 4; idx++)
-                snd_iprintf(buffer, "  DAC ID #%i        : 0x%x\n", idx, ice->eeprom.dacID[idx]);
+                snd_iprintf(buffer, "  DAC ID #%i        : 0x%x\n", idx, ice->eeprom.data[ICE_EEP1_DAC_ID + idx]);
         for (idx = 0; idx < 4; idx++)
-                snd_iprintf(buffer, "  ADC ID #%i        : 0x%x\n", idx, ice->eeprom.adcID[idx]);
-        for (idx = 0x1c; idx < ice->eeprom.size && idx < 0x1c + sizeof(ice->eeprom.extra); idx++)
-                snd_iprintf(buffer, "  Extra #%02i        : 0x%x\n", idx, ice->eeprom.extra[idx - 0x1c]);
+                snd_iprintf(buffer, "  ADC ID #%i        : 0x%x\n", idx, ice->eeprom.data[ICE_EEP1_ADC_ID + idx]);
+        for (idx = 0x1c; idx < ice->eeprom.size; idx++)
+                snd_iprintf(buffer, "  Extra #%02i        : 0x%x\n", idx, ice->eeprom.data[idx]);
+
+        snd_iprintf(buffer, "\nRegisters:\n");
+        snd_iprintf(buffer, "  PSDOUT03         : 0x%04x\n", (unsigned)inw(ICEMT(ice, ROUTE_PSDOUT03)));
+        snd_iprintf(buffer, "  CAPTURE          : 0x%08x\n", inl(ICEMT(ice, ROUTE_CAPTURE)));
+        snd_iprintf(buffer, "  SPDOUT           : 0x%04x\n", (unsigned)inw(ICEMT(ice, ROUTE_SPDOUT)));
+        snd_iprintf(buffer, "  RATE             : 0x%02x\n", (unsigned)inb(ICEMT(ice, RATE)));
 }
 
@@ -1507 +1525 @@
         snd_info_entry_t *entry;
 
-        if ((entry = snd_info_create_card_entry(ice->card, "ice1712", ice->card->proc_root)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = ice;
-                entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 2048;
-                entry->c.text.read = snd_ice1712_proc_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        ice->proc_entry = entry;
-}
-
-static void snd_ice1712_proc_done(ice1712_t * ice)
-{
-        if (ice->proc_entry) {
-                snd_info_unregister(ice->proc_entry);
-                ice->proc_entry = NULL;
-        }
+        if (! snd_card_proc_new(ice->card, "ice1712", &entry))
+                snd_info_set_text_ops(entry, ice, snd_ice1712_proc_read);
 }
 
@@ -1536 +1536 @@
 {
         uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
-        uinfo->count = 32;
+        uinfo->count = sizeof(ice1712_eeprom_t);
         return 0;
 }
@@ -1544 +1544 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         
-        memcpy(ucontrol->value.bytes.data, &ice->eeprom, 32);
+        memcpy(ucontrol->value.bytes.data, &ice->eeprom, sizeof(ice->eeprom));
         return 0;
 }
@@ -1585 +1585 @@
 static snd_kcontrol_new_t snd_ice1712_spdif_default __devinitdata =
 {
-        .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
-        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
         .info =         snd_ice1712_spdif_info,
         .get =          snd_ice1712_spdif_default_get,
@@ -1636 +1636 @@
 static snd_kcontrol_new_t snd_ice1712_spdif_maskc __devinitdata =
 {
-        .access =               SNDRV_CTL_ELEM_ACCESS_READ,
-        .iface =                SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ,
+        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
         .info =         snd_ice1712_spdif_info,
         .get =          snd_ice1712_spdif_maskc_get,
@@ -1645 +1645 @@
 static snd_kcontrol_new_t snd_ice1712_spdif_maskp __devinitdata =
 {
-        .access =               SNDRV_CTL_ELEM_ACCESS_READ,
-        .iface =                SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
+        .access =       SNDRV_CTL_ELEM_ACCESS_READ,
+        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
         .info =         snd_ice1712_spdif_info,
         .get =          snd_ice1712_spdif_maskp_get,
@@ -1672 +1672 @@
 static snd_kcontrol_new_t snd_ice1712_spdif_stream __devinitdata =
 {
-        .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),
+        .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),
         .info =         snd_ice1712_spdif_info,
         .get =          snd_ice1712_spdif_stream_get,
@@ -1694 +1694 @@
         unsigned char mask = kcontrol->private_value & 0xff;
         int invert = (kcontrol->private_value & (1<<24)) ? 1 : 0;
-        unsigned char saved[2];
         
-        snd_ice1712_save_gpio_status(ice, saved);
-        ucontrol->value.integer.value[0] = (snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & mask ? 1 : 0) ^ invert;
-        snd_ice1712_restore_gpio_status(ice, saved);
+        snd_ice1712_save_gpio_status(ice);
+        ucontrol->value.integer.value[0] = (snd_ice1712_gpio_read(ice) & mask ? 1 : 0) ^ invert;
+        snd_ice1712_restore_gpio_status(ice);
         return 0;
 }
@@ -1707 +1706 @@
         unsigned char mask = kcontrol->private_value & 0xff;
         int invert = (kcontrol->private_value & (1<<24)) ? mask : 0;
-        unsigned char saved[2];
-        int val, nval;
+        unsigned int val, nval;
 
         if (kcontrol->private_value & (1 << 31))
                 return -EPERM;
         nval = (ucontrol->value.integer.value[0] ? mask : 0) ^ invert;
-        snd_ice1712_save_gpio_status(ice, saved);
-        val = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
+        snd_ice1712_save_gpio_status(ice);
+        val = snd_ice1712_gpio_read(ice);
         nval |= val & ~mask;
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, nval);
-        snd_ice1712_restore_gpio_status(ice, saved);
+        if (val != nval)
+                snd_ice1712_gpio_write(ice, nval);
+        snd_ice1712_restore_gpio_status(ice);
         return val != nval;
 }
@@ -1790 +1789 @@
         } else {
                 PRO_RATE_DEFAULT = xrate[ucontrol->value.integer.value[0] % 13];
+                spin_unlock_irq(&ice->reg_lock);
                 snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 1);
+                spin_lock_irq(&ice->reg_lock);
         }
         change = inb(ICEMT(ice, RATE)) != oval;
+        spin_unlock_irq(&ice->reg_lock);
 
         if ((oval & ICE1712_SPDIF_MASTER) != (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER)) {
@@ -1800 +1802 @@
                 }
                 /* notify ak4524 chip as well */
-                if (is_spdif_master(ice) && ice->ak4524.ops.set_rate_val)
-                        ice->ak4524.ops.set_rate_val(ice, 0);
+                if (is_spdif_master(ice)) {
+                        unsigned int i;
+                        for (i = 0; i < ice->akm_codecs; i++) {
+                                if (ice->akm[i].ops.set_rate_val)
+                                        ice->akm[i].ops.set_rate_val(&ice->akm[i], 0);
+                        }
+                }
         }
 
@@ -1906 +1913 @@
         int idx = kcontrol->id.index;
         unsigned int val, cval;
+
+        spin_lock_irq(&ice->reg_lock);
         val = inw(ICEMT(ice, ROUTE_PSDOUT03));
+        cval = inl(ICEMT(ice, ROUTE_CAPTURE));
+        spin_unlock_irq(&ice->reg_lock);
+
         val >>= ((idx % 2) * 8) + ((idx / 2) * 2);
         val &= 3;
-        cval = inl(ICEMT(ice, ROUTE_CAPTURE));
         cval >>= ((idx / 2) * 8) + ((idx % 2) * 4);
         if (val == 1 && idx < 2)
@@ -1939 +1950 @@
                 nval = 0; /* pcm */
         shift = ((idx % 2) * 8) + ((idx / 2) * 2);
+        spin_lock_irq(&ice->reg_lock);
         val = old_val = inw(ICEMT(ice, ROUTE_PSDOUT03));
         val &= ~(0x03 << shift);
@@ -1945 +1957 @@
         if (change)
                 outw(val, ICEMT(ice, ROUTE_PSDOUT03));
+        spin_unlock_irq(&ice->reg_lock);
         if (nval < 2) /* dig mixer of pcm */
                 return change;
 
         /* update CAPTURE */
+        spin_lock_irq(&ice->reg_lock);
         val = old_val = inl(ICEMT(ice, ROUTE_CAPTURE));
         shift = ((idx / 2) * 8) + ((idx % 2) * 4);
@@ -1964 +1978 @@
                 outl(val, ICEMT(ice, ROUTE_CAPTURE));
         }
+        spin_unlock_irq(&ice->reg_lock);
         return change;
 }
@@ -1994 +2009 @@
         
         /* update SPDOUT */
+        spin_lock_irq(&ice->reg_lock);
         val = old_val = inw(ICEMT(ice, ROUTE_SPDOUT));
         if (ucontrol->value.enumerated.item[0] >= 11)
@@ -2019 +2035 @@
         if (change)
                 outw(val, ICEMT(ice, ROUTE_SPDOUT));
+        spin_unlock_irq(&ice->reg_lock);
         return change;
 }
@@ -2051 +2068 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
         
-        spin_lock_irqsave(&ice->reg_lock, flags);
         ucontrol->value.integer.value[0] = inb(ICEMT(ice, MONITOR_RATE));
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
         return 0;
 }
@@ -2061 +2075 @@
 static int snd_ice1712_pro_volume_rate_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
 {
-        unsigned long flags;
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         int change;
 
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         change = inb(ICEMT(ice, MONITOR_RATE)) != ucontrol->value.integer.value[0];
         outb(ucontrol->value.integer.value[0], ICEMT(ice, MONITOR_RATE));
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock_irq(&ice->reg_lock);
         return change;
 }
@@ -2092 +2105 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
         int idx;
         
-        spin_lock_irqsave(&ice->reg_lock, flags);
+        spin_lock_irq(&ice->reg_lock);
         for (idx = 0; idx < 22; idx++) {
                 outb(idx, ICEMT(ice, MONITOR_PEAKINDEX));
                 ucontrol->value.integer.value[idx] = inb(ICEMT(ice, MONITOR_PEAKDATA));
         }
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
+        spin_unlock_irq(&ice->reg_lock);
         return 0;
 }
@@ -2131 +2143 @@
 {
         int dev = 0xa0;         /* EEPROM device address */
-        unsigned int idx;
+        unsigned int i;
 
         if ((inb(ICEREG(ice, I2C_CTRL)) & ICE1712_I2C_EEPROM) == 0) {
@@ -2142 +2154 @@
                                 (snd_ice1712_read_i2c(ice, dev, 0x03) << 24);
         ice->eeprom.size = snd_ice1712_read_i2c(ice, dev, 0x04);
-        if (ice->eeprom.size < 28) {
+        if (ice->eeprom.size > 32) {
                 snd_printk("invalid EEPROM (size = %i)\n", ice->eeprom.size);
                 return -EIO;
@@ -2149 +2161 @@
         if (ice->eeprom.version != 1) {
                 snd_printk("invalid EEPROM version %i\n", ice->eeprom.version);
-                return -EIO;
-        }
-        ice->eeprom.codec = snd_ice1712_read_i2c(ice, dev, 0x06);
-        ice->eeprom.aclink = snd_ice1712_read_i2c(ice, dev, 0x07);
-        ice->eeprom.i2sID = snd_ice1712_read_i2c(ice, dev, 0x08);
-        ice->eeprom.spdif = snd_ice1712_read_i2c(ice, dev, 0x09);
-        ice->eeprom.gpiomask = snd_ice1712_read_i2c(ice, dev, 0x0a);
-        ice->eeprom.gpiostate = snd_ice1712_read_i2c(ice, dev, 0x0b);
-        ice->eeprom.gpiodir = snd_ice1712_read_i2c(ice, dev, 0x0c);
-        ice->eeprom.ac97main = (snd_ice1712_read_i2c(ice, dev, 0x0d) << 0) |
-                               (snd_ice1712_read_i2c(ice, dev, 0x0e) << 8);
-        ice->eeprom.ac97pcm = (snd_ice1712_read_i2c(ice, dev, 0x0f) << 0) |
-                              (snd_ice1712_read_i2c(ice, dev, 0x10) << 8);
-        ice->eeprom.ac97rec = (snd_ice1712_read_i2c(ice, dev, 0x11) << 0) |
-                              (snd_ice1712_read_i2c(ice, dev, 0x12) << 8);
-        ice->eeprom.ac97recsrc = snd_ice1712_read_i2c(ice, dev, 0x13) << 0;
-        for (idx = 0; idx < 4; idx++) {
-                ice->eeprom.dacID[idx] = snd_ice1712_read_i2c(ice, dev, 0x14 + idx);
-                ice->eeprom.adcID[idx] = snd_ice1712_read_i2c(ice, dev, 0x18 + idx);
-        }
-        for (idx = 0x1c; idx < ice->eeprom.size && idx < 0x1c + sizeof(ice->eeprom.extra); idx++)
-                ice->eeprom.extra[idx - 0x1c] = snd_ice1712_read_i2c(ice, dev, idx);
+                /* return -EIO; */
+        }
+        for (i = 0; i < ice->eeprom.size; i++)
+                ice->eeprom.data[i] = snd_ice1712_read_i2c(ice, dev, i + 6);
+
+        ice->eeprom.gpiomask = ice->eeprom.data[ICE_EEP1_GPIO_MASK];
+        ice->eeprom.gpiostate = ice->eeprom.data[ICE_EEP1_GPIO_STATE];
+        ice->eeprom.gpiodir = ice->eeprom.data[ICE_EEP1_GPIO_DIR];
+
         return 0;
 }
@@ -2182 +2181 @@
         outb(ICE1712_NATIVE, ICEREG(ice, CONTROL));
         udelay(200);
-        pci_write_config_byte(ice->pci, 0x60, ice->eeprom.codec);
-        pci_write_config_byte(ice->pci, 0x61, ice->eeprom.aclink);
-        pci_write_config_byte(ice->pci, 0x62, ice->eeprom.i2sID);
-        pci_write_config_byte(ice->pci, 0x63, ice->eeprom.spdif);
+        pci_write_config_byte(ice->pci, 0x60, ice->eeprom.data[ICE_EEP1_CODEC]);
+        pci_write_config_byte(ice->pci, 0x61, ice->eeprom.data[ICE_EEP1_ACLINK]);
+        pci_write_config_byte(ice->pci, 0x62, ice->eeprom.data[ICE_EEP1_I2SID]);
+        pci_write_config_byte(ice->pci, 0x63, ice->eeprom.data[ICE_EEP1_SPDIF]);
         if (ice->eeprom.subvendor != ICE1712_SUBDEVICE_STDSP24) {
-                ice->gpio_write_mask = ice->eeprom.gpiomask;
-                ice->gpio_direction = ice->eeprom.gpiodir;
+                ice->gpio.write_mask = ice->eeprom.gpiomask;
+                ice->gpio.direction = ice->eeprom.gpiodir;
                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ice->eeprom.gpiomask);
                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->eeprom.gpiodir);
                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, ice->eeprom.gpiostate);
         } else {
-                ice->gpio_write_mask = 0xc0;
-                ice->gpio_direction = 0xff;
+                ice->gpio.write_mask = 0xc0;
+                ice->gpio.direction = 0xff;
                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, 0xc0);
                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, 0xff);
@@ -2200 +2199 @@
         }
         snd_ice1712_write(ice, ICE1712_IREG_PRO_POWERDOWN, 0);
-        if (!(ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97)) {
+        if (!(ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97)) {
                 outb(ICE1712_AC97_WARM, ICEREG(ice, AC97_CMD));
                 udelay(100);
@@ -2210 +2209 @@
         return 0;
 }
-
 
 int __devinit snd_ice1712_spdif_build_controls(ice1712_t *ice)
@@ -2251 +2249 @@
         if (err < 0)
                 return err;
+
         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_rate_locking, ice));
         if (err < 0)
@@ -2257 +2256 @@
         if (err < 0)
                 return err;
+
         for (idx = 0; idx < ice->num_total_dacs; idx++) {
                 kctl = snd_ctl_new1(&snd_ice1712_mixer_pro_analog_route, ice);
@@ -2266 +2266 @@
                         return err;
         }
+
         for (idx = 0; idx < 2; idx++) {
                 kctl = snd_ctl_new1(&snd_ice1712_mixer_pro_spdif_route, ice);
@@ -2275 +2276 @@
                         return err;
         }
+
         err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_pro_volume_rate, ice));
         if (err < 0)
@@ -2281 +2283 @@
         if (err < 0)
                 return err;
+
         return 0;
 }
@@ -2293 +2296 @@
         /* --- */
       __hw_end:
-        snd_ice1712_proc_done(ice);
         if (ice->irq >= 0) {
                 synchronize_irq(ice->irq);
@@ -2314 +2316 @@
                 kfree_nocheck(ice->res_profi_port);
         }
+        if (ice->akm)
+                kfree(ice->akm);
         snd_magic_kfree(ice);
         return 0;
@@ -2353 +2357 @@
         spin_lock_init(&ice->reg_lock);
         init_MUTEX(&ice->gpio_mutex);
+        ice->gpio.set_mask = snd_ice1712_set_gpio_mask;
+        ice->gpio.set_dir = snd_ice1712_set_gpio_dir;
+        ice->gpio.set_data = snd_ice1712_set_gpio_data;
+        ice->gpio.get_data = snd_ice1712_get_gpio_data;
+
         ice->spdif.cs8403_bits =
                 ice->spdif.cs8403_stream_bits = (0x01 | /* consumer format */
@@ -2395 +2404 @@
                 return -EIO;
         }
+        
         ice->irq = pci->irq;
 
@@ -2407 +2417 @@
 
         /* unmask used interrupts */
-        outb((ice->eeprom.codec & ICE1712_CFG_2xMPU401) == 0 ? ICE1712_IRQ_MPU2 : 0 |
-             (ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97) ? ICE1712_IRQ_PBKDS | ICE1712_IRQ_CONCAP | ICE1712_IRQ_CONPBK : 0,
+        outb((ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_2xMPU401) == 0 ? ICE1712_IRQ_MPU2 : 0 |
+             (ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97) ? ICE1712_IRQ_PBKDS | ICE1712_IRQ_CONCAP | ICE1712_IRQ_CONPBK : 0,
              ICEREG(ice, IRQMASK));
         outb(0x00, ICEMT(ice, IRQ));
@@ -2488 +2498 @@
         }
         
-        if (!(ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97))
+        if (ice_has_con_ac97(ice))
                 if ((err = snd_ice1712_pcm(ice, pcm_dev++, NULL)) < 0) {
                         snd_card_free(card);
@@ -2511 +2521 @@
         }
 
-        if (!(ice->eeprom.codec & ICE1712_CFG_NO_CON_AC97))
+        if (ice_has_con_ac97(ice))
                 if ((err = snd_ice1712_pcm_ds(ice, pcm_dev++, NULL)) < 0) {
                         snd_card_free(card);
@@ -2526 +2536 @@
         }
 
-        if (ice->eeprom.codec & ICE1712_CFG_2xMPU401)
+                if (ice->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_2xMPU401)
                 if ((err = snd_mpu401_uart_new(card, 1, MPU401_HW_ICE1712,
                                                ICEREG(ice, MPU2_CTRL), 1,

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

@@ -215 +215 @@
 
 typedef struct _snd_ice1712 ice1712_t;
-typedef struct snd_ak4524 ak4524_t;
+typedef struct snd_ak4xxx akm4xxx_t;
 
 typedef struct {
         unsigned int subvendor; /* PCI[2c-2f] */
         unsigned char size;     /* size of EEPROM image in bytes */
-        unsigned char version;  /* must be 1 */
-        unsigned char codec;    /* codec configuration PCI[60] */
-        unsigned char aclink;   /* ACLink configuration PCI[61] */
-        unsigned char i2sID;    /* PCI[62] */
-        unsigned char spdif;    /* S/PDIF configuration PCI[63] */
-        unsigned char gpiomask; /* GPIO initial mask, 0 = write, 1 = don't */
-        unsigned char gpiostate; /* GPIO initial state */
-        unsigned char gpiodir;  /* GPIO direction state */
-        unsigned short ac97main;
-        unsigned short ac97pcm;
-        unsigned short ac97rec;
-        unsigned char ac97recsrc;
-        unsigned char dacID[4]; /* I2S IDs for DACs */
-        unsigned char adcID[4]; /* I2S IDs for ADCs */
-        unsigned char extra[4];
+        unsigned char version;  /* must be 1 (or 2 for vt1724) */
+        unsigned char data[32];
+        unsigned int gpiomask;
+        unsigned int gpiostate;
+        unsigned int gpiodir;
 } ice1712_eeprom_t;
 
-struct snd_ak4524 {
-        int num_adcs;                   /* AK4524 or AK4528 ADCs */
-        int num_dacs;                   /* AK4524 or AK4528 DACs */
-        unsigned char images[4][16];
-        unsigned char ipga_gain[4][2];
-        /* */
+enum {
+        ICE_EEP1_CODEC = 0,     /* 06 */
+        ICE_EEP1_ACLINK,        /* 07 */
+        ICE_EEP1_I2SID,         /* 08 */
+        ICE_EEP1_SPDIF,         /* 09 */
+        ICE_EEP1_GPIO_MASK,     /* 0a */
+        ICE_EEP1_GPIO_STATE,    /* 0b */
+        ICE_EEP1_GPIO_DIR,      /* 0c */
+        ICE_EEP1_AC97_MAIN_LO,  /* 0d */
+        ICE_EEP1_AC97_MAIN_HI,  /* 0e */
+        ICE_EEP1_AC97_PCM_LO,   /* 0f */
+        ICE_EEP1_AC97_PCM_HI,   /* 10 */
+        ICE_EEP1_AC97_REC_LO,   /* 11 */
+        ICE_EEP1_AC97_REC_HI,   /* 12 */
+        ICE_EEP1_AC97_RECSRC,   /* 13 */
+        ICE_EEP1_DAC_ID,        /* 14 */
+        ICE_EEP1_DAC_ID1,
+        ICE_EEP1_DAC_ID2,
+        ICE_EEP1_DAC_ID3,
+        ICE_EEP1_ADC_ID,        /* 18 */
+        ICE_EEP1_ADC_ID1,
+        ICE_EEP1_ADC_ID2,
+        ICE_EEP1_ADC_ID3
+};
+        
+#define ice_has_con_ac97(ice)   (!((ice)->eeprom.data[ICE_EEP1_CODEC] & ICE1712_CFG_NO_CON_AC97))
+
+
+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_AK4524, SND_AK4528, SND_AK4529, SND_AK4355, SND_AK4381
         } type;
-        unsigned int cif: 1;
-        unsigned char data_mask;
-        unsigned char clk_mask;
-        unsigned char cs_mask;
-        unsigned char cs_addr;
-        unsigned char cs_none;
-        unsigned char add_flags;
-        unsigned char mask_flags;
-        struct snd_ak4524_ops {
-                int (*start)(ice1712_t *, unsigned char *, int);
-                void (*stop)(ice1712_t *, unsigned char *);
-                void (*set_rate_val)(ice1712_t *, unsigned int);
+        unsigned int cif: 1;            /* CIF mode */
+        unsigned char caddr;            /* C0 and C1 bits */
+        unsigned int data_mask;         /* DATA gpio bit */
+        unsigned int clk_mask;          /* CLK gpio bit */
+        unsigned int cs_mask;           /* bit mask for select/deselect address */
+        unsigned int cs_addr;           /* bits to select address */
+        unsigned int cs_none;           /* bits to deselect address */
+        unsigned int add_flags;         /* additional bits at init */
+        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;
 };
@@ -268 +289 @@
         struct snd_ice1712_spdif_ops {
                 void (*open)(ice1712_t *, snd_pcm_substream_t *);
-                void (*setup)(ice1712_t *, snd_pcm_substream_t *);
+                void (*setup_rate)(ice1712_t *, int rate);
                 void (*close)(ice1712_t *, snd_pcm_substream_t *);
                 void (*default_get)(ice1712_t *, snd_ctl_elem_value_t * ucontrol);
@@ -293 +314 @@
         unsigned long profi_port;
         struct resource *res_profi_port;
-
-        unsigned int config;    /* system configuration */
 
         struct pci_dev *pci;
@@ -316 +335 @@
 
         spinlock_t reg_lock;
-        struct semaphore gpio_mutex;
         snd_info_entry_t *proc_entry;
 
@@ -322 +340 @@
 
         unsigned int pro_volumes[20];
-        int omni: 1;                    /* Delta Omni I/O */
-        int num_total_dacs;             /* total DACs */
+        unsigned int omni: 1;           /* Delta Omni I/O */
+        unsigned int vt1724: 1;
+        unsigned int num_total_dacs;    /* total DACs */
         unsigned char hoontech_boxbits[4];
         unsigned int hoontech_config;
         unsigned short hoontech_boxconfig[4];
-
-        struct snd_ak4524 ak4524;
+        unsigned int cur_rate;          /* current rate */
+
+        unsigned int akm_codecs;
+        akm4xxx_t *akm;
         struct snd_ice1712_spdif spdif;
 
@@ -336 +357 @@
         snd_i2c_device_t *i2cdevs[2];   /* additional i2c devices */
         
-        unsigned char gpio_direction, gpio_write_mask;
+        struct ice1712_gpio {
+                unsigned int direction;         /* current direction bits */
+                unsigned int write_mask;        /* current mask bits */
+                unsigned int saved[2];          /* for ewx_i2c */
+                /* operators */
+                void (*set_mask)(ice1712_t *ice, unsigned int data);
+                void (*set_dir)(ice1712_t *ice, unsigned int data);
+                void (*set_data)(ice1712_t *ice, unsigned int data);
+                unsigned int (*get_data)(ice1712_t *ice);
+        } gpio;
+        struct semaphore gpio_mutex;
 };
 
@@ -342 +373 @@
 
 
+/*
+ * gpio access functions
+ */
+static inline void snd_ice1712_gpio_set_dir(ice1712_t *ice, unsigned int bits)
+{
+        ice->gpio.set_dir(ice, bits);
+}
+
+static inline void snd_ice1712_gpio_set_mask(ice1712_t *ice, unsigned int bits)
+{
+        ice->gpio.set_mask(ice, bits);
+}
+
+static inline void snd_ice1712_gpio_write(ice1712_t *ice, unsigned int val)
+{
+        ice->gpio.set_data(ice, val);
+}
+
+static inline unsigned int snd_ice1712_gpio_read(ice1712_t *ice)
+{
+        return ice->gpio.get_data(ice);
+}
+
+/*
+ * save and restore gpio status
+ * The access to gpio will be protected by mutex, so don't forget to
+ * restore!
+ */
+static inline void snd_ice1712_save_gpio_status(ice1712_t *ice)
+{
+        down(&ice->gpio_mutex);
+        ice->gpio.saved[0] = ice->gpio.direction;
+        ice->gpio.saved[1] = ice->gpio.write_mask;
+}
+
+static inline void snd_ice1712_restore_gpio_status(ice1712_t *ice)
+{
+        ice->gpio.set_dir(ice, ice->gpio.saved[0]);
+        ice->gpio.set_mask(ice, ice->gpio.saved[1]);
+        ice->gpio.direction = ice->gpio.saved[0];
+        ice->gpio.write_mask = ice->gpio.saved[1];
+        up(&ice->gpio_mutex);
+}
+
+/* for bit controls */
 #define ICE1712_GPIO(xiface, xname, xindex, mask, invert, xaccess) \
 { .iface = xiface, .name = xname, .access = xaccess, .info = snd_ice1712_gpio_info, \
@@ -351 +427 @@
 int snd_ice1712_gpio_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol);
 
-void snd_ice1712_gpio_write_bits(ice1712_t *ice, int mask, int bits);
-void snd_ice1712_save_gpio_status(ice1712_t *ice, unsigned char *tmp);
-void snd_ice1712_restore_gpio_status(ice1712_t *ice, unsigned char *tmp);
-
+/*
+ * set gpio direction, write mask and data
+ */
+static inline void snd_ice1712_gpio_write_bits(ice1712_t *ice, unsigned int mask, unsigned int bits)
+{
+        ice->gpio.direction |= mask;
+        snd_ice1712_gpio_set_dir(ice, ice->gpio.direction);
+        snd_ice1712_gpio_set_mask(ice, ~mask);
+        snd_ice1712_gpio_write(ice, mask & bits);
+}
 
 int snd_ice1712_spdif_build_controls(ice1712_t *ice);
 
-void snd_ice1712_ak4524_write(ice1712_t *ice, int chip, unsigned char addr, unsigned char data);
-void snd_ice1712_ak4524_reset(ice1712_t *ice, int state);
-void snd_ice1712_ak4524_init(ice1712_t *ice);
-int snd_ice1712_ak4524_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_build_controls(ice1712_t *ice);
 
 int snd_ice1712_init_cs8427(ice1712_t *ice, int addr);

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

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

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

@@ -21 +21 @@
 
 #include <sound/driver.h>
-#include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
+#include <linux/wait.h>
+
 #include <sound/core.h>
 #include <sound/info.h>
@@ -34 +36 @@
 #include <sound/initval.h>
 
+#include <asm/io.h>
+
 // ----------------------------------------------------------------------------
 // Debug Stuff
@@ -39 +43 @@
 #define K1212_DEBUG_LEVEL               0
 #define K1212_DEBUG_PRINTK              printk
+//#define K1212_DEBUG_PRINTK(x...)      printk("<0>" x)
 
 // ----------------------------------------------------------------------------
@@ -175 +180 @@
 #define kPlayBufferFrames       1024
 
-#define K1212_CHANNELS          16
+#define K1212_ANALOG_CHANNELS   2
+#define K1212_SPDIF_CHANNELS    2
+#define K1212_ADAT_CHANNELS     8
+#define K1212_CHANNELS          (K1212_ADAT_CHANNELS + K1212_ANALOG_CHANNELS)
+#define K1212_MIN_CHANNELS      1
+#define K1212_MAX_CHANNELS      K1212_CHANNELS
 #define K1212_FRAME_SIZE        (sizeof(KorgAudioFrame))
 #define K1212_MAX_SAMPLES       (kPlayBufferFrames*kNumBuffers)
-#define K1212_PERIODS           (K1212_BUF_SIZE/K1212_BLOCK_SIZE)
-#define K1212_PERIOD_BYTES      (K1212_BLOCK_SIZE)
-#define K1212_BLOCK_SIZE        (K1212_FRAME_SIZE*kPlayBufferFrames)
-#define K1212_BUF_SIZE          (K1212_BLOCK_SIZE*kNumBuffers)
+#define K1212_PERIODS           (kNumBuffers)
+#define K1212_PERIOD_BYTES      (K1212_FRAME_SIZE*kPlayBufferFrames)
+#define K1212_BUF_SIZE          (K1212_PERIOD_BYTES*kNumBuffers)
+#define K1212_ANALOG_BUF_SIZE   (K1212_ANALOG_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)
+#define K1212_SPDIF_BUF_SIZE    (K1212_SPDIF_CHANNELS * 3 * kPlayBufferFrames * kNumBuffers)
+#define K1212_ADAT_BUF_SIZE     (K1212_ADAT_CHANNELS * 2 * kPlayBufferFrames * kNumBuffers)
+#define K1212_MAX_BUF_SIZE      (K1212_ANALOG_BUF_SIZE + K1212_ADAT_BUF_SIZE)
 
 #define k1212MinADCSens     0x7f
@@ -311 +324 @@
 
 struct _snd_korg1212 {
+        snd_card_t *card;
         struct pci_dev *pci;
-        snd_card_t *card;
-        snd_pcm_t *pcm16;
+        snd_pcm_t *pcm;
         int irq;
 
@@ -359 +372 @@
         u32 * idRegPtr;              // address of the device and vendor ID registers
 
-
         size_t periodsize;
-        size_t currentBuffer;
+        int channels;
+        int currentBuffer;
 
         snd_pcm_substream_t *playback_substream;
         snd_pcm_substream_t *capture_substream;
-        snd_info_entry_t * proc_entry;
 
         CardState cardState;
@@ -381 +393 @@
         u16 leftADCInSens;           // ADC left channel input sensitivity
         u16 rightADCInSens;          // ADC right channel input sensitivity
+
+        int opencnt;                    // Open/Close count
+        int setcnt;                     // SetupForPlay count
+        int playcnt;                    // TriggerPlay count
+
 };
 
@@ -404 +421 @@
 
 static struct pci_device_id snd_korg1212_ids[] __devinitdata = {
-        { 0x10b5, 0x906d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
-        { 0, }
+        {
+                .vendor    = 0x10b5,
+                .device    = 0x906d,
+                .subvendor = PCI_ANY_ID,
+                .subdevice = PCI_ANY_ID,
+        },
+        { 0, },
 };
 
@@ -456 +478 @@
                             };
 
-snd_korg1212rc rc;
-
+static snd_korg1212rc rc;
 
 MODULE_DEVICE_TABLE(pci, snd_korg1212_ids);
@@ -514 +535 @@
 #endif /* not used */
 
-void TickDelay(int time)
-{
-        udelay(time);
-}
-
 #define SetBitInWord(theWord,bitPosition)       (*theWord) |= (0x0001 << bitPosition)
 #define SetBitInDWord(theWord,bitPosition)      (*theWord) |= (0x00000001 << bitPosition)
@@ -529 +545 @@
         u32 retryCount;
         u16 mailBox3Lo;
-
-        if (korg1212->outDoorbellPtr) {
+        snd_korg1212rc rc = K1212_CMDRET_Success;
+
+        if (!korg1212->outDoorbellPtr) {
+#if K1212_DEBUG_LEVEL > 1
+                K1212_DEBUG_PRINTK("K1212_DEBUG: CardUninitialized\n");
+#endif
+                return K1212_CMDRET_CardUninitialized;
+        }
+
 #if K1212_DEBUG_LEVEL > 0
                 K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- 0x%08x 0x%08x [%s]\n", doorbellVal, mailBox0Val, stateName[korg1212->cardState]);
 #endif
                 for (retryCount = 0; retryCount < MAX_COMMAND_RETRIES; retryCount++) {
-
                         writel(mailBox3Val, korg1212->mailbox3Ptr);
                         writel(mailBox2Val, korg1212->mailbox2Ptr);
@@ -545 +567 @@
                         // the reboot command will not give an acknowledgement.
                         // --------------------------------------------------------------
-                        switch (doorbellVal) {
-                                case K1212_DB_RebootCard:
-                                case K1212_DB_BootFromDSPPage4:
-                                case K1212_DB_StartDSPDownload:
-                                        return K1212_CMDRET_Success;
-                                default:
+                if ( doorbellVal == K1212_DB_RebootCard ||
+                        doorbellVal == K1212_DB_BootFromDSPPage4 ||
+                        doorbellVal == K1212_DB_StartDSPDownload ) {
+                        rc = K1212_CMDRET_Success;
                                         break;
                         }
@@ -559 +579 @@
                         // low byte is equal to the doorbell value, then it ack'd.
                         // --------------------------------------------------------------
-                        TickDelay(COMMAND_ACK_DELAY);
+                udelay(COMMAND_ACK_DELAY);
                         mailBox3Lo = readl(korg1212->mailbox3Ptr);
                         if (mailBox3Lo & COMMAND_ACK_MASK) {
                                 if ((mailBox3Lo & DOORBELL_VAL_MASK) == (doorbellVal & DOORBELL_VAL_MASK)) {
-                                        korg1212->cmdRetryCount += retryCount;
-                                        return K1212_CMDRET_Success;
-                                }
+#if K1212_DEBUG_LEVEL > 1
+                                K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- Success\n");
+#endif
+                                rc = K1212_CMDRET_Success;
+                                break;
                         }
                 }
-                korg1212->cmdRetryCount += retryCount;
-                return K1212_CMDRET_NoAckFromCard;
-        } else {
-                return K1212_CMDRET_CardUninitialized;
-        }
+        }
+                                        korg1212->cmdRetryCount += retryCount;
+
+        if (retryCount >= MAX_COMMAND_RETRIES) {
+#if K1212_DEBUG_LEVEL > 1
+                K1212_DEBUG_PRINTK("K1212_DEBUG: Card <- NoAckFromCard\n");
+#endif
+                rc = K1212_CMDRET_NoAckFromCard;
+        }
+
+        return rc;
 }
 
 static void snd_korg1212_WaitForCardStopAck(korg1212_t *korg1212)
 {
-        unsigned long endtime = jiffies + 20 * HZ;
-
-#if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: WaitForCardStopAck [%s]\n", stateName[korg1212->cardState]);
+        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
 
@@ -587 +615 @@
 
         do {
-                if (readl(&korg1212->sharedBufferPtr->cardCommand) == 0)
+                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;
+                }
                 if (!korg1212->inIRQ)
                         schedule();
-        } while (jiffies < endtime);
-
+        } 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);
 }
@@ -598 +633 @@
 static void snd_korg1212_TurnOnIdleMonitor(korg1212_t *korg1212)
 {
-        TickDelay(INTERCOMMAND_DELAY);
+        udelay(INTERCOMMAND_DELAY);
         korg1212->idleMonitorOn = 1;
         rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SelectPlayMode,
@@ -634 +669 @@
 {
 #if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s]\n", stateName[korg1212->cardState]);
-#endif
+        K1212_DEBUG_PRINTK("K1212_DEBUG: OpenCard [%s] %d\n", stateName[korg1212->cardState], korg1212->opencnt);
+#endif
+        if (korg1212->opencnt++ == 0)
         snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
         return 1;
@@ -643 +679 @@
 {
 #if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s]\n", stateName[korg1212->cardState]);
-#endif
+        K1212_DEBUG_PRINTK("K1212_DEBUG: CloseCard [%s] %d\n", stateName[korg1212->cardState], korg1212->opencnt);
+#endif
+
+        if (--(korg1212->opencnt))
+                return 0;
 
         if (korg1212->cardState == K1212_STATE_SETUP) {
@@ -669 +708 @@
 {
 #if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s]\n", stateName[korg1212->cardState]);
-#endif
+        K1212_DEBUG_PRINTK("K1212_DEBUG: SetupForPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->setcnt);
+#endif
+
+        if (korg1212->setcnt++)
+                return 0;
 
         snd_korg1212_setCardState(korg1212, K1212_STATE_SETUP);
@@ -680 +722 @@
 #endif
         if (rc != K1212_CMDRET_Success) {
-                return 0;
-        }
         return 1;
 }
+        return 0;
+}
 
 static int snd_korg1212_TriggerPlay(korg1212_t * korg1212)
 {
 #if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s]\n", stateName[korg1212->cardState]);
-#endif
+        K1212_DEBUG_PRINTK("K1212_DEBUG: TriggerPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->playcnt);
+#endif
+
+        if (korg1212->playcnt++)
+                return 0;
 
         snd_korg1212_setCardState(korg1212, K1212_STATE_PLAYING);
@@ -699 +744 @@
 
         if (rc != K1212_CMDRET_Success) {
-                return 0;
-        }
         return 1;
 }
+        return 0;
+}
 
 static int snd_korg1212_StopPlay(korg1212_t * korg1212)
 {
 #if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s]\n", stateName[korg1212->cardState]);
-#endif
+        K1212_DEBUG_PRINTK("K1212_DEBUG: StopPlay [%s] %d\n", stateName[korg1212->cardState], korg1212->playcnt);
+#endif
+
+        if (--(korg1212->playcnt)) 
+                return 0;
+
+        korg1212->setcnt = 0;
 
         if (korg1212->cardState != K1212_STATE_ERRORSTOP) {
@@ -715 +765 @@
         }
         snd_korg1212_setCardState(korg1212, K1212_STATE_OPEN);
-        return 1;
+        return 0;
 }
 
@@ -795 +845 @@
         korg1212->clkRate = rate;
 
-        TickDelay(INTERCOMMAND_DELAY);
+        udelay(INTERCOMMAND_DELAY);
         rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,
                                           ClockSourceSelector[korg1212->clkSrcRate],
@@ -862 +912 @@
         // ----------------------------------------------------------------------------
         writel(0, korg1212->mailbox3Ptr);
-        TickDelay(LOADSHIFT_DELAY);
+        udelay(LOADSHIFT_DELAY);
 
         // ----------------------------------------------------------------------------
@@ -903 +953 @@
                 ClearBitInWord(&controlValue, SET_SENS_DATA_BITPOS);
                 writew(controlValue, korg1212->sensRegPtr);                          // load/shift goes low
-                TickDelay(LOADSHIFT_DELAY);
+                udelay(LOADSHIFT_DELAY);
 
                 for (bitPosition = 15; bitPosition >= 0; bitPosition--) {       // for all the bits
@@ -922 +972 @@
                         ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                         writew(controlValue, korg1212->sensRegPtr);                       // clock goes low
-                        TickDelay(SENSCLKPULSE_WIDTH);
+                        udelay(SENSCLKPULSE_WIDTH);
                         SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                         writew(controlValue, korg1212->sensRegPtr);                       // clock goes high
-                        TickDelay(SENSCLKPULSE_WIDTH);
+                        udelay(SENSCLKPULSE_WIDTH);
                 }
 
@@ -936 +986 @@
                 SetBitInWord(&controlValue, SET_SENS_LOADSHIFT_BITPOS);
                 writew(controlValue, korg1212->sensRegPtr);                   // load shift goes high - clk low
-                TickDelay(SENSCLKPULSE_WIDTH);
+                udelay(SENSCLKPULSE_WIDTH);
 
                 if (clkIs48K)
@@ -942 +992 @@
 
                 writew(controlValue, korg1212->sensRegPtr);                   // set/clear data bit
-                TickDelay(ONE_RTC_TICK);
+                udelay(ONE_RTC_TICK);
                 SetBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                 writew(controlValue, korg1212->sensRegPtr);                   // clock goes high
-                TickDelay(SENSCLKPULSE_WIDTH);
+                udelay(SENSCLKPULSE_WIDTH);
                 ClearBitInWord(&controlValue, SET_SENS_CLOCK_BITPOS);
                 writew(controlValue, korg1212->sensRegPtr);                   // clock goes low
-                TickDelay(SENSCLKPULSE_WIDTH);
+                udelay(SENSCLKPULSE_WIDTH);
         }
 
@@ -956 +1006 @@
         // ----------------------------------------------------------------------------
         for (count = 0; count < 10; count++)
-                TickDelay(SENSCLKPULSE_WIDTH);
+                udelay(SENSCLKPULSE_WIDTH);
 
         if (monModeSet) {
@@ -1004 +1054 @@
 #endif
 
-        TickDelay(INTERCOMMAND_DELAY);
+        udelay(INTERCOMMAND_DELAY);
 
         rc = snd_korg1212_Send1212Command(korg1212,
@@ -1022 +1072 @@
         // Initialize the routing and volume tables, then update the card's state.
         // --------------------------------------------------------------------------------
-        TickDelay(INTERCOMMAND_DELAY);
+        udelay(INTERCOMMAND_DELAY);
 
         for (channel = 0; channel < kAudioChannels; channel++) {
@@ -1032 +1082 @@
         snd_korg1212_WriteADCSensitivity(korg1212);
 
-        TickDelay(INTERCOMMAND_DELAY);
+        udelay(INTERCOMMAND_DELAY);
         rc = snd_korg1212_Send1212Command(korg1212, K1212_DB_SetClockSourceRate,
                                           ClockSourceSelector[korg1212->clkSrcRate],
@@ -1048 +1098 @@
         wake_up_interruptible(&korg1212->wait);
 }
-
 
 static void snd_korg1212_interrupt(int irq, void *dev_id, struct pt_regs *regs)
@@ -1085 +1134 @@
                 // ------------------------------------------------------------------------
                 case K1212_ISRCODE_DMAERROR:
-#if K1212_DEBUG_LEVEL > 0
+#if K1212_DEBUG_LEVEL > 1
                         K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DMAE count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]);
 #endif
                         writel(0, &korg1212->sharedBufferPtr->cardCommand);
+                        snd_korg1212_setCardState(korg1212, K1212_STATE_ERRORSTOP);
                         break;
 
@@ -1096 +1146 @@
                 // ------------------------------------------------------------------------
                 case K1212_ISRCODE_CARDSTOPPED:
-#if K1212_DEBUG_LEVEL > 0
+#if K1212_DEBUG_LEVEL > 1
                         K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ CSTP count - %ld, %x, [%s].\n", korg1212->irqcount, doorbellValue, stateName[korg1212->cardState]);
 #endif
@@ -1103 +1153 @@
 
                 default:
-#if K1212_DEBUG_LEVEL > 1
+#if K1212_DEBUG_LEVEL > 3
                         K1212_DEBUG_PRINTK("K1212_DEBUG: IRQ DFLT count - %ld, %x, cpos=%d [%s].\n", korg1212->irqcount, doorbellValue, 
                                 korg1212->currentBuffer, stateName[korg1212->cardState]);
@@ -1163 +1213 @@
 static snd_pcm_hardware_t snd_korg1212_playback_info =
 {
-        .info =               (SNDRV_PCM_INFO_MMAP |
+        .info =              (SNDRV_PCM_INFO_MMAP |
                               SNDRV_PCM_INFO_MMAP_VALID |
                               SNDRV_PCM_INFO_INTERLEAVED),
@@ -1171 +1221 @@
         .rate_min =           44100,
         .rate_max =           48000,
-        .channels_min =       K1212_CHANNELS,
-        .channels_max =       K1212_CHANNELS,
-        .buffer_bytes_max =   K1212_BUF_SIZE,
-        .period_bytes_min =   K1212_PERIOD_BYTES,
-        .period_bytes_max =   K1212_PERIOD_BYTES,
+        .channels_min =       K1212_MIN_CHANNELS,
+        .channels_max =       K1212_MAX_CHANNELS,
+        .buffer_bytes_max =   K1212_MAX_BUF_SIZE,
+        .period_bytes_min =   K1212_MIN_CHANNELS * 2 * kPlayBufferFrames,
+        .period_bytes_max =   K1212_MAX_CHANNELS * 2 * kPlayBufferFrames,
         .periods_min =        K1212_PERIODS,
         .periods_max =        K1212_PERIODS,
@@ -1183 +1233 @@
 static snd_pcm_hardware_t snd_korg1212_capture_info =
 {
-        .info =               (SNDRV_PCM_INFO_MMAP |
+        .info =              (SNDRV_PCM_INFO_MMAP |
                               SNDRV_PCM_INFO_MMAP_VALID |
                               SNDRV_PCM_INFO_INTERLEAVED),
@@ -1191 +1241 @@
         .rate_min =           44100,
         .rate_max =           48000,
-        .channels_min =       K1212_CHANNELS,
-        .channels_max =       K1212_CHANNELS,
-        .buffer_bytes_max =   K1212_BUF_SIZE,
-        .period_bytes_min =   K1212_PERIOD_BYTES,
-        .period_bytes_max =   K1212_PERIOD_BYTES,
+        .channels_min =       K1212_MIN_CHANNELS,
+        .channels_max =       K1212_MAX_CHANNELS,
+        .buffer_bytes_max =   K1212_MAX_BUF_SIZE,
+        .period_bytes_min =   K1212_MIN_CHANNELS * 2 * kPlayBufferFrames,
+        .period_bytes_max =   K1212_MAX_CHANNELS * 2 * kPlayBufferFrames,
         .periods_min =        K1212_PERIODS,
         .periods_max =        K1212_PERIODS,
@@ -1201 +1251 @@
 };
 
+static int snd_korg1212_silence(korg1212_t *korg1212, int pos, int count, int offset, int size)
+{
+        KorgAudioFrame * dst =  korg1212->playDataBufsPtr[0].bufferData + pos;
+        int i;
+
+#if K1212_DEBUG_LEVEL > 2
+        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_silence pos=%d offset=%d size=%d count=%d\n", pos, offset, size, count);
+#endif
+        snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
+
+        for (i=0; i < count; i++) {
+#if K1212_DEBUG_LEVEL > 0
+                if ( (void *) dst < (void *) korg1212->playDataBufsPtr ||
+                     (void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) {
+                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_silence KERNEL EFAULT dst=%p iter=%d\n", dst, i);
+                        return -EFAULT;
+                }
+#endif
+                memset((void*) dst + offset, 0, size);
+                dst++;
+        }
+
+        return 0;
+}
+
+static int snd_korg1212_copy_to(korg1212_t *korg1212, void *dst, int pos, int count, int offset, int size)
+{
+        KorgAudioFrame * src =  korg1212->recordDataBufsPtr[0].bufferData + pos;
+        int i, rc;
+
+#if K1212_DEBUG_LEVEL > 2
+        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to pos=%d offset=%d size=%d\n", pos, offset, size);
+#endif
+        snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
+
+        for (i=0; i < count; i++) {
+#if K1212_DEBUG_LEVEL > 0
+                if ( (void *) src < (void *) korg1212->recordDataBufsPtr ||
+                     (void *) src > (void *) korg1212->recordDataBufsPtr[8].bufferData ) {
+                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i);
+                        return -EFAULT;
+                }
+#endif
+                rc = copy_to_user((void*) dst + offset, src, size);
+                if (rc) {
+#if K1212_DEBUG_LEVEL > 0
+                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_to USER EFAULT src=%p dst=%p iter=%d\n", src, dst, i);
+#endif
+                        return -EFAULT;
+                }
+                src++;
+                dst += size;
+        }
+
+        return 0;
+}
+
+static int snd_korg1212_copy_from(korg1212_t *korg1212, void *src, int pos, int count, int offset, int size)
+{
+        KorgAudioFrame * dst =  korg1212->playDataBufsPtr[0].bufferData + pos;
+        int i, rc;
+
+#if K1212_DEBUG_LEVEL > 2
+        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from pos=%d offset=%d size=%d count=%d\n", pos, offset, size, count);
+#endif
+
+        snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
+
+        for (i=0; i < count; i++) {
+#if K1212_DEBUG_LEVEL > 0
+                if ( (void *) dst < (void *) korg1212->playDataBufsPtr ||
+                     (void *) dst > (void *) korg1212->playDataBufsPtr[8].bufferData ) {
+                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from KERNEL EFAULT, src=%p dst=%p iter=%d\n", src, dst, i);
+                        return -EFAULT;
+                }
+#endif
+                rc = copy_from_user((void*) dst + offset, src, size);
+                if (rc) {
+#if K1212_DEBUG_LEVEL > 0
+                        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_copy_from USER EFAULT src=%p dst=%p iter=%d\n", src, dst, i);
+#endif
+                        return -EFAULT;
+                }
+                dst++;
+                src += size;
+        }
+
+        return 0;
+}
+
 static void snd_korg1212_free_pcm(snd_pcm_t *pcm)
 {
@@ -1209 +1349 @@
 #endif
 
-        korg1212->pcm16 = NULL;
-}
-
-static unsigned int period_bytes[] = { K1212_PERIOD_BYTES };
-
-#define PERIOD_BYTES sizeof(period_bytes) / sizeof(period_bytes[0])
-
-static snd_pcm_hw_constraint_list_t hw_constraints_period_bytes = {
-        .count = PERIOD_BYTES,
-        .list = period_bytes,
-        .mask = 0
-};
+        korg1212->pcm = NULL;
+}
 
 static int snd_korg1212_playback_open(snd_pcm_substream_t *substream)
@@ -1232 +1362 @@
 #endif
 
+        snd_pcm_set_sync(substream);    // ???
+
         spin_lock_irqsave(&korg1212->lock, flags);
 
-        snd_korg1212_OpenCard(korg1212);
-
-        snd_pcm_set_sync(substream);    // ???
-
-        runtime->hw = snd_korg1212_playback_info;
+        snd_korg1212_OpenCard(korg1212);
+
         runtime->dma_area = (char *) korg1212->playDataBufsPtr;
         runtime->dma_bytes = K1212_BUF_SIZE;
@@ -1244 +1373 @@
         korg1212->playback_substream = substream;
         korg1212->periodsize = K1212_PERIODS;
+        korg1212->channels = K1212_CHANNELS;
 
         spin_unlock_irqrestore(&korg1212->lock, flags);
 
-        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, K1212_BUF_SIZE, K1212_BUF_SIZE);
-        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
+        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, kPlayBufferFrames, kPlayBufferFrames);
         return 0;
 }
+
 
 static int snd_korg1212_capture_open(snd_pcm_substream_t *substream)
@@ -1262 +1392 @@
 #endif
 
+        snd_pcm_set_sync(substream);    // ???
+
         spin_lock_irqsave(&korg1212->lock, flags);
 
-        snd_korg1212_OpenCard(korg1212);
-
-        snd_pcm_set_sync(substream);    // ???
+        snd_korg1212_OpenCard(korg1212);
 
         runtime->hw = snd_korg1212_capture_info;
@@ -1274 +1404 @@
         korg1212->capture_substream = substream;
         korg1212->periodsize = K1212_PERIODS;
+        korg1212->channels = K1212_CHANNELS;
 
         spin_unlock_irqrestore(&korg1212->lock, flags);
 
-        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, K1212_BUF_SIZE, K1212_BUF_SIZE);
-        snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
+        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, kPlayBufferFrames, kPlayBufferFrames);
         return 0;
 }
@@ -1291 +1421 @@
 #endif
 
+        snd_korg1212_silence(korg1212, 0, K1212_MAX_SAMPLES, 0, korg1212->channels * 2);
+
         spin_lock_irqsave(&korg1212->lock, flags);
 
@@ -1322 +1454 @@
 }
 
-static int snd_korg1212_channel_info(snd_pcm_substream_t *substream,
-                                    snd_pcm_channel_info_t *info)
-{
-        int chn = info->channel;
-
-        // snd_assert(info->channel < kAudioChannels + 1, return -EINVAL);
-
-        info->offset = 0;
-        // if (chn < k16BitChannels) {
-                info->first = chn * 16;
-        // } else {
-        //         info->first = k16BitChannels * 16 + (chn - k16BitChannels - 1) * 32;
-        // }
-        info->step = sizeof(KorgAudioFrame) * 8;
-
-#if K1212_DEBUG_LEVEL > 0
-                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_channel_info %d:, offset=%ld, first=%d, step=%d\n", chn, info->offset, info->first, info->step);
-#endif
-
-        return 0;
-}
-
 static int snd_korg1212_ioctl(snd_pcm_substream_t *substream,
                              unsigned int cmd, void *arg)
@@ -1350 +1460 @@
                 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_ioctl: cmd=%d\n", cmd);
 #endif
+
         if (cmd == SNDRV_PCM_IOCTL1_CHANNEL_INFO ) {
                 snd_pcm_channel_info_t *info = arg;
-                return snd_korg1212_channel_info(substream, info);
+                info->offset = 0;
+                info->first = info->channel * 16;
+                info->step = 256;
+#if K1212_DEBUG_LEVEL > 0
+                K1212_DEBUG_PRINTK("K1212_DEBUG: channel_info %d:, offset=%ld, first=%d, step=%d\n", info->channel, info->offset, info->first, info->step);
+#endif
+                return 0;
         }
 
@@ -1374 +1491 @@
                 return err;
         }
-
+/*
         if (params_format(params) != SNDRV_PCM_FORMAT_S16_LE) {
                 spin_unlock_irqrestore(&korg1212->lock, flags);
                 return -EINVAL;
         }
-
-        korg1212->periodsize = K1212_BLOCK_SIZE;
+*/
+        korg1212->channels = params_channels(params);
+        korg1212->periodsize = K1212_PERIOD_BYTES;
 
         spin_unlock_irqrestore(&korg1212->lock, flags);
@@ -1391 +1509 @@
         korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
         unsigned long flags;
+        int rc;
 
 #if K1212_DEBUG_LEVEL > 0
@@ -1398 +1517 @@
         spin_lock_irqsave(&korg1212->lock, flags);
 
-        snd_korg1212_SetupForPlay(korg1212);
-
-        korg1212->currentBuffer = -1;
+        rc = snd_korg1212_SetupForPlay(korg1212);
+        korg1212->currentBuffer = 0;
 
         spin_unlock_irqrestore(&korg1212->lock, flags);
-        return 0;
+
+        return rc ? -EINVAL : 0;
 }
 
@@ -1410 +1529 @@
 {
         korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
+        int rc;
 
 #if K1212_DEBUG_LEVEL > 0
@@ -1417 +1537 @@
         switch (cmd) {
                 case SNDRV_PCM_TRIGGER_START:
-                        korg1212->running = 1;
-                        snd_korg1212_TriggerPlay(korg1212);
+/*
+                        if (korg1212->running) {
+#if K1212_DEBUG_LEVEL > 1
+                                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger: Already running?\n");
+#endif
                         break;
+                        }
+*/
+                        korg1212->running++;
+                        rc = snd_korg1212_TriggerPlay(korg1212);
+                        break;
 
                 case SNDRV_PCM_TRIGGER_STOP:
-                        korg1212->running = 0;
-                        snd_korg1212_StopPlay(korg1212);
+/*
+                        if (!korg1212->running) {
+#if K1212_DEBUG_LEVEL > 1
+                                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_trigger: Already stopped?\n");
+#endif
+                                break;
+                        }
+*/
+                        korg1212->running--;
+                        rc = snd_korg1212_StopPlay(korg1212);
                         break;
 
                 default:
-                        return -EINVAL;
-        }
-        return 0;
-}
-
-static snd_pcm_uframes_t snd_korg1212_pointer(snd_pcm_substream_t *substream)
+                        rc = 1;
+                        break;
+        }
+        return rc ? -EINVAL : 0;
+}
+
+static snd_pcm_uframes_t snd_korg1212_playback_pointer(snd_pcm_substream_t *substream)
 {
         korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
         snd_pcm_uframes_t pos;
 
-        if (korg1212->currentBuffer < 0)
-                return 0;
-
         pos = korg1212->currentBuffer * kPlayBufferFrames;
 
-#if K1212_DEBUG_LEVEL > 1
-                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_pointer [%s] %ld\n", stateName[korg1212->cardState], pos);
+#if K1212_DEBUG_LEVEL > 2
+        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_pointer [%s] %ld\n", 
+                        stateName[korg1212->cardState], pos);
+#endif
+
+        return pos;
+}
+
+static snd_pcm_uframes_t snd_korg1212_capture_pointer(snd_pcm_substream_t *substream)
+{
+        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
+        snd_pcm_uframes_t pos;
+
+        pos = korg1212->currentBuffer * kPlayBufferFrames;
+
+#if K1212_DEBUG_LEVEL > 2
+        K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_pointer [%s] %ld\n",
+                        stateName[korg1212->cardState], pos);
 #endif
 
@@ -1456 +1606 @@
 {
         korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
-        KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;
-
-#if K1212_DEBUG_LEVEL > 0
+
+#if K1212_DEBUG_LEVEL > 2
                 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_copy [%s] %ld %ld\n", stateName[korg1212->cardState], pos, count);
 #endif
  
-        snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
-
-        return copy_from_user(dst, src, count * K1212_FRAME_SIZE) ? -EFAULT : 0;
+        return snd_korg1212_copy_from(korg1212, src, pos, count, 0, korg1212->channels * 2);
+
+}
+
+static int snd_korg1212_playback_silence(snd_pcm_substream_t *substream,
+                           int channel, /* not used (interleaved data) */
+                           snd_pcm_uframes_t pos,
+                           snd_pcm_uframes_t count)
+{
+        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
+
+#if K1212_DEBUG_LEVEL > 0
+                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_silence [%s]\n", stateName[korg1212->cardState]);
+#endif
+
+        return snd_korg1212_silence(korg1212, pos, count, 0, korg1212->channels * 2);
 }
 
@@ -1474 +1636 @@
 {
         korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
-        KorgAudioFrame * src = korg1212->recordDataBufsPtr[0].bufferData + pos;
-
-#if K1212_DEBUG_LEVEL > 0
+
+#if K1212_DEBUG_LEVEL > 2
                 K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_capture_copy [%s] %ld %ld\n", stateName[korg1212->cardState], pos, count);
 #endif
 
-        snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
-
-        return copy_to_user(dst, src, count * K1212_FRAME_SIZE) ? -EFAULT : 0;
-}
-
-static int snd_korg1212_playback_silence(snd_pcm_substream_t *substream,
-                           int channel, /* not used (interleaved data) */
-                           snd_pcm_uframes_t pos,
-                           snd_pcm_uframes_t count)
-{
-        korg1212_t *korg1212 = _snd_pcm_substream_chip(substream);
-        KorgAudioFrame * dst = korg1212->playDataBufsPtr[0].bufferData + pos;
-
-#if K1212_DEBUG_LEVEL > 0
-                K1212_DEBUG_PRINTK("K1212_DEBUG: snd_korg1212_playback_silence [%s]\n", stateName[korg1212->cardState]);
-#endif
-
-        snd_assert(pos + count <= K1212_MAX_SAMPLES, return -EINVAL);
-
-        memset(dst, 0, count * K1212_FRAME_SIZE);
-
-        return 0;
+        return snd_korg1212_copy_to(korg1212, dst, pos, count, 0, korg1212->channels * 2);
 }
 
@@ -1511 +1651 @@
         .prepare =      snd_korg1212_prepare,
         .trigger =      snd_korg1212_trigger,
-        .pointer =      snd_korg1212_pointer,
+        .pointer =      snd_korg1212_playback_pointer,
         .copy =         snd_korg1212_playback_copy,
         .silence =      snd_korg1212_playback_silence,
@@ -1523 +1663 @@
         .prepare =      snd_korg1212_prepare,
         .trigger =      snd_korg1212_trigger,
-        .pointer =      snd_korg1212_pointer,
+        .pointer =      snd_korg1212_capture_pointer,
         .copy =         snd_korg1212_capture_copy,
 };
@@ -1548 +1688 @@
         u->value.integer.value[0] = korg1212->volumePhase[i];
 
-        if (i >= 8) 
+        if (i >= 8)
                 u->value.integer.value[1] = korg1212->volumePhase[i+1];
 
@@ -1696 +1836 @@
         i = kcontrol->private_value;
 
-        if (u->value.enumerated.item[0] != korg1212->sharedBufferPtr->volumeData[i]) {
+        if (u->value.enumerated.item[0] != (unsigned) korg1212->sharedBufferPtr->volumeData[i]) {
                 korg1212->sharedBufferPtr->routeData[i] = u->value.enumerated.item[0];
                 change = 1;
@@ -1702 +1842 @@
 
         if (i >= 8) {
-                if (u->value.enumerated.item[1] != korg1212->sharedBufferPtr->volumeData[i+1]) {
+                if (u->value.enumerated.item[1] != (unsigned) korg1212->sharedBufferPtr->volumeData[i+1]) {
                         korg1212->sharedBufferPtr->routeData[i+1] = u->value.enumerated.item[1];
                         change = 1;
@@ -1713 +1853 @@
 }
 
-static int snd_korg1212_control_analog_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_korg1212_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
@@ -1722 +1862 @@
 }
 
-static int snd_korg1212_control_analog_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
+static int snd_korg1212_control_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
 {
         korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
@@ -1737 +1877 @@
 }
 
-static int snd_korg1212_control_analog_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
+static int snd_korg1212_control_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *u)
 {
         korg1212_t *korg1212 = _snd_kcontrol_chip(kcontrol);
@@ -1848 +1988 @@
                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name =         "ADC Attenuation",
-                .info =         snd_korg1212_control_analog_info,
-                .get =          snd_korg1212_control_analog_get,
-                .put =          snd_korg1212_control_analog_put,
+                .info =         snd_korg1212_control_info,
+                .get =          snd_korg1212_control_get,
+                .put =          snd_korg1212_control_put,
         }
 };
@@ -1868 +2008 @@
         snd_iprintf(buffer, " (index #%d)\n", korg1212->card->number + 1);
         snd_iprintf(buffer, "\nGeneral settings\n");
-        snd_iprintf(buffer, "    period size: %d bytes\n", K1212_BLOCK_SIZE);
+        snd_iprintf(buffer, "    period size: %d bytes\n", K1212_PERIOD_BYTES);
         snd_iprintf(buffer, "     clock mode: %s\n", clockSourceName[korg1212->clkSrcRate] );
         snd_iprintf(buffer, "  left ADC Sens: %d\n", korg1212->leftADCInSens );
@@ -1886 +2026 @@
 }
 
-static void __init snd_korg1212_proc_init(korg1212_t *korg1212)
+static void __devinit snd_korg1212_proc_init(korg1212_t *korg1212)
 {
         snd_info_entry_t *entry;
 
-        if ((entry = snd_info_create_card_entry(korg1212->card, "korg1212", korg1212->card->proc_root)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = korg1212;
-                entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 256;
-                entry->c.text.read = snd_korg1212_proc_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        korg1212->proc_entry = entry;
-}
-
-static void snd_korg1212_proc_done(korg1212_t * korg1212)
-{
-        if (korg1212->proc_entry) {
-                snd_info_unregister(korg1212->proc_entry);
-                korg1212->proc_entry = NULL;
-        }
-}
-
-static int __init snd_korg1212_create(korg1212_t *korg1212)
-{
-        struct pci_dev *pci = korg1212->pci;
+        if (! snd_card_proc_new(korg1212->card, "korg1212", &entry))
+                snd_info_set_text_ops(entry, korg1212, snd_korg1212_proc_read);
+}
+
+static int
+snd_korg1212_free(korg1212_t *korg1212)
+{
+        snd_korg1212_TurnOffIdleMonitor(korg1212);
+
+        if (korg1212->irq >= 0) {
+                synchronize_irq(korg1212->irq);                
+                snd_korg1212_DisableCardInterrupts(korg1212);
+                free_irq(korg1212->irq, (void *)korg1212);
+                korg1212->irq = -1;
+        }
+        
+        if (korg1212->iobase != 0) {
+                iounmap((void *)korg1212->iobase);
+                korg1212->iobase = 0;
+        }
+        
+        if (korg1212->res_iomem != NULL) {
+                release_resource(korg1212->res_iomem);
+                kfree_nocheck(korg1212->res_iomem);
+                korg1212->res_iomem = NULL;
+        }
+        
+        if (korg1212->res_ioport != NULL) {
+                release_resource(korg1212->res_ioport);
+                kfree_nocheck(korg1212->res_ioport);
+                korg1212->res_ioport = NULL;
+        }
+        
+        if (korg1212->res_iomem2 != NULL) {
+                release_resource(korg1212->res_iomem2);
+                kfree_nocheck(korg1212->res_iomem2);
+                korg1212->res_iomem2 = NULL;
+        }
+
+        // ----------------------------------------------------
+        // free up memory resources used for the DSP download.
+        // ----------------------------------------------------
+        if (korg1212->dspMemPtr) {
+                snd_free_pci_pages(korg1212->pci, korg1212->dspCodeSize,
+                                   korg1212->dspMemPtr, (dma_addr_t)korg1212->dspMemPhy);
+                korg1212->dspMemPhy = 0;
+                korg1212->dspMemPtr = 0;
+                korg1212->dspCodeSize = 0;
+        }
+
+#ifndef K1212_LARGEALLOC
+
+        // ------------------------------------------------------
+        // free up memory resources used for the Play/Rec Buffers
+        // ------------------------------------------------------
+        if (korg1212->playDataBufsPtr) {
+                snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
+                                   korg1212->playDataBufsPtr, (dma_addr_t)korg1212->PlayDataPhy);
+                korg1212->PlayDataPhy = 0;
+                korg1212->playDataBufsPtr = NULL;
+        }
+
+        if (korg1212->recordDataBufsPtr) {
+                snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
+                                   korg1212->recordDataBufsPtr, (dma_addr_t)korg1212->RecDataPhy);
+                korg1212->RecDataPhy = 0;
+                korg1212->recordDataBufsPtr = NULL;
+        }
+
+#endif
+
+        // ----------------------------------------------------
+        // free up memory resources used for the Shared Buffers
+        // ----------------------------------------------------
+        if (korg1212->sharedBufferPtr) {
+                snd_free_pci_pages(korg1212->pci, (u32) sizeof(KorgSharedBuffer),
+                                   korg1212->sharedBufferPtr, (dma_addr_t)korg1212->sharedBufferPhy);
+                korg1212->sharedBufferPhy = 0;
+                korg1212->sharedBufferPtr = NULL;
+        }
+        
+        snd_magic_kfree(korg1212);
+        return 0;
+}
+
+static int snd_korg1212_dev_free(snd_device_t *device)
+{
+        korg1212_t *korg1212 = snd_magic_cast(korg1212_t, device->device_data, return -ENXIO);
+#if K1212_DEBUG_LEVEL > 0
+        K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing device\n");
+#endif
+        return snd_korg1212_free(korg1212);
+}
+
+static int __devinit snd_korg1212_create(snd_card_t * card, struct pci_dev *pci,
+                                         korg1212_t ** rchip)
+
+{
         int err;
-        int i;
+        unsigned int i;
         unsigned ioport_size, iomem_size, iomem2_size;
         dma_addr_t phys_addr;
+        korg1212_t * korg1212;
+
+        static snd_device_ops_t ops = {
+                .dev_free = snd_korg1212_dev_free,
+        };
+
+        * rchip = NULL;
+        if ((err = pci_enable_device(pci)) < 0)
+                return err;
+
+        korg1212 = snd_magic_kcalloc(korg1212_t, 0, GFP_KERNEL);
+        if (korg1212 == NULL)
+                return -ENOMEM;
+
+        korg1212->card = card;
+        korg1212->pci = pci;
+
+        init_waitqueue_head(&korg1212->wait);
+        spin_lock_init(&korg1212->lock);
 
         korg1212->irq = -1;
@@ -1925 +2157 @@
         korg1212->inIRQ = 0;
         korg1212->running = 0;
+        korg1212->opencnt = 0;
+        korg1212->playcnt = 0;
+        korg1212->setcnt = 0;
         snd_korg1212_setCardState(korg1212, K1212_STATE_UNINITIALIZED);
         korg1212->idleMonitorOn = 0;
@@ -1933 +2168 @@
         for (i=0; i<kAudioChannels; i++)
                 korg1212->volumePhase[i] = 0;
-
-        if ((err = pci_enable_device(pci)) < 0)
-                return err;
 
         korg1212->iomem = pci_resource_start(korg1212->pci, 0);
@@ -1959 +2191 @@
         korg1212->res_iomem = request_mem_region(korg1212->iomem, iomem_size, "korg1212");
         if (korg1212->res_iomem == NULL) {
-                snd_printk("unable to grab region 0x%lx-0x%lx\n",
+                snd_printk(KERN_ERR "unable to grab region 0x%lx-0x%lx\n",
                            korg1212->iomem, korg1212->iomem + iomem_size - 1);
                 return -EBUSY;
@@ -1966 +2198 @@
         korg1212->res_ioport = request_region(korg1212->ioport, ioport_size, "korg1212");
         if (korg1212->res_ioport == NULL) {
-                snd_printk("unable to grab region 0x%lx-0x%lx\n",
+                snd_printk(KERN_ERR "unable to grab region 0x%lx-0x%lx\n",
                            korg1212->ioport, korg1212->ioport + ioport_size - 1);
                 return -EBUSY;
@@ -1973 +2205 @@
         korg1212->res_iomem2 = request_mem_region(korg1212->iomem2, iomem2_size, "korg1212");
         if (korg1212->res_iomem2 == NULL) {
-                snd_printk("unable to grab region 0x%lx-0x%lx\n",
+                snd_printk(KERN_ERR "unable to grab region 0x%lx-0x%lx\n",
                            korg1212->iomem2, korg1212->iomem2 + iomem2_size - 1);
                 return -EBUSY;
@@ -1979 +2211 @@
 
         if ((korg1212->iobase = (unsigned long) ioremap(korg1212->iomem, iomem_size)) == 0) {
-                snd_printk("unable to remap memory region 0x%lx-0x%lx\n", korg1212->iobase,
+                snd_printk(KERN_ERR "unable to remap memory region 0x%lx-0x%lx\n", korg1212->iobase,
                            korg1212->iobase + iomem_size - 1);
                 return -EBUSY;
@@ -1989 +2221 @@
 
         if (err) {
-                snd_printk("unable to grab IRQ %d\n", pci->irq);
+                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                 return -EBUSY;
         }
@@ -1995 +2227 @@
         korg1212->irq = pci->irq;
 
-        init_waitqueue_head(&korg1212->wait);
-        spin_lock_init(&korg1212->lock);
         pci_set_master(korg1212->pci);
 
@@ -2040 +2270 @@
 
         if (korg1212->sharedBufferPtr == NULL) {
-                snd_printk("can not allocate shared buffer memory (%d bytes)\n", sizeof(KorgSharedBuffer));
+                snd_printk(KERN_ERR "can not allocate shared buffer memory (%d bytes)\n", sizeof(KorgSharedBuffer));
                 return -ENOMEM;
         }
@@ -2056 +2286 @@
 
         if (korg1212->playDataBufsPtr == NULL) {
-                snd_printk("can not allocate play data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
+                snd_printk(KERN_ERR "can not allocate play data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
                 return -ENOMEM;
         }
@@ -2069 +2299 @@
 
         if (korg1212->recordDataBufsPtr == NULL) {
-                snd_printk("can not allocate record data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
+                snd_printk(KERN_ERR "can not allocate record data buffer memory (%d bytes)\n", korg1212->DataBufsSize);
                 return -ENOMEM;
         }
@@ -2097 +2327 @@
 
         if (korg1212->dspMemPtr == NULL) {
-                snd_printk("can not allocate dsp code memory (%d bytes)\n", korg1212->dspCodeSize);
+                snd_printk(KERN_ERR "can not allocate dsp code memory (%d bytes)\n", korg1212->dspCodeSize);
                 return -ENOMEM;
         }
@@ -2117 +2347 @@
         mdelay(CARD_BOOT_DELAY_IN_MS);
 
-        if (snd_korg1212_downloadDSPCode(korg1212))
+        if (snd_korg1212_downloadDSPCode(korg1212)) 
                 return -EBUSY;
 
@@ -2133 +2363 @@
                korg1212->AdatTimeCodePhy, LowerWordSwap(korg1212->AdatTimeCodePhy));
 
-        if ((err = snd_pcm_new(korg1212->card, "korg1212", 0, 1, 1, &korg1212->pcm16)) < 0)
+        if ((err = snd_pcm_new(korg1212->card, "korg1212", 0, 1, 1, &korg1212->pcm)) < 0)
                 return err;
 
-        korg1212->pcm16->private_data = korg1212;
-        korg1212->pcm16->private_free = snd_korg1212_free_pcm;
-        strcpy(korg1212->pcm16->name, "korg1212");
-
-        snd_pcm_set_ops(korg1212->pcm16, SNDRV_PCM_STREAM_PLAYBACK, &snd_korg1212_playback_ops);
-        snd_pcm_set_ops(korg1212->pcm16, SNDRV_PCM_STREAM_CAPTURE, &snd_korg1212_capture_ops);
-
-        korg1212->pcm16->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
+        korg1212->pcm->private_data = korg1212;
+        korg1212->pcm->private_free = snd_korg1212_free_pcm;
+        strcpy(korg1212->pcm->name, "korg1212");
+
+        snd_pcm_set_ops(korg1212->pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_korg1212_playback_ops);
+        
+        snd_pcm_set_ops(korg1212->pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_korg1212_capture_ops);
+
+        korg1212->pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;
+
+        //snd_pcm_lib_preallocate_pages_for_all(korg1212->pcm,
+        //                      K1212_MAX_BUF_SIZE, K1212_MAX_BUF_SIZE, GFP_KERNEL);
 
         for (i = 0; i < K1212_CONTROL_ELEMENTS; i++) {
@@ -2153 +2387 @@
         snd_korg1212_proc_init(korg1212);
 
+        if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, korg1212, &ops)) < 0) {
+                snd_korg1212_free(korg1212);
+                return err;
+        }
+        
+        * rchip = korg1212;
         return 0;
 
-}
-
-static void
-snd_korg1212_free(void *private_data)
-{
-        korg1212_t *korg1212 = (korg1212_t *)private_data;
-
-        if (korg1212 == NULL) {
-                return;
-        }
-
-        snd_korg1212_proc_done(korg1212);
-
-        snd_korg1212_TurnOffIdleMonitor(korg1212);
-
-        snd_korg1212_DisableCardInterrupts(korg1212);
-
-        if (korg1212->irq >= 0) {
-                free_irq(korg1212->irq, (void *)korg1212);
-                korg1212->irq = -1;
-        }
-        if (korg1212->iobase != 0) {
-                iounmap((void *)korg1212->iobase);
-                korg1212->iobase = 0;
-        }
-        if (korg1212->res_iomem != NULL) {
-                release_resource(korg1212->res_iomem);
-                kfree_nocheck(korg1212->res_iomem);
-                korg1212->res_iomem = NULL;
-        }
-        if (korg1212->res_ioport != NULL) {
-                release_resource(korg1212->res_ioport);
-                kfree_nocheck(korg1212->res_ioport);
-                korg1212->res_ioport = NULL;
-        }
-        if (korg1212->res_iomem2 != NULL) {
-                release_resource(korg1212->res_iomem2);
-                kfree_nocheck(korg1212->res_iomem2);
-                korg1212->res_iomem2 = NULL;
-        }
-
-        // ----------------------------------------------------
-        // free up memory resources used for the DSP download.
-        // ----------------------------------------------------
-        if (korg1212->dspMemPtr) {
-                snd_free_pci_pages(korg1212->pci, korg1212->dspCodeSize,
-                                   korg1212->dspMemPtr, (dma_addr_t)korg1212->dspMemPhy);
-                korg1212->dspMemPhy = 0;
-                korg1212->dspMemPtr = 0;
-                korg1212->dspCodeSize = 0;
-        }
-
-#ifndef K1212_LARGEALLOC
-
-        // ------------------------------------------------------
-        // free up memory resources used for the Play/Rec Buffers
-        // ------------------------------------------------------
-        if (korg1212->playDataBufsPtr) {
-                snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
-                                   korg1212->playDataBufsPtr, (dma_addr_t)korg1212->PlayDataPhy);
-                korg1212->PlayDataPhy = 0;
-                korg1212->playDataBufsPtr = NULL;
-        }
-
-        if (korg1212->recordDataBufsPtr) {
-                snd_free_pci_pages(korg1212->pci, korg1212->DataBufsSize,
-                                   korg1212->recordDataBufsPtr, (dma_addr_t)korg1212->RecDataPhy);
-                korg1212->RecDataPhy = 0;
-                korg1212->recordDataBufsPtr = NULL;
-        }
-
-#endif
-
-        // ----------------------------------------------------
-        // free up memory resources used for the Shared Buffers
-        // ----------------------------------------------------
-        if (korg1212->sharedBufferPtr) {
-                snd_free_pci_pages(korg1212->pci, (u32) sizeof(KorgSharedBuffer),
-                                   korg1212->sharedBufferPtr, (dma_addr_t)korg1212->sharedBufferPhy);
-                korg1212->sharedBufferPhy = 0;
-                korg1212->sharedBufferPtr = NULL;
-        }
 }
 
@@ -2242 +2400 @@
  * Card initialisation
  */
-
-static void snd_korg1212_card_free(snd_card_t *card)
-{
-#if K1212_DEBUG_LEVEL > 0
-        K1212_DEBUG_PRINTK("K1212_DEBUG: Freeing card\n");
-#endif
-        snd_korg1212_free(card->private_data);
-}
 
 static int __devinit
@@ -2267 +2417 @@
                 return -ENOENT;
         }
-        if ((card = snd_card_new(index[dev], id[dev], THIS_MODULE,
-                                 sizeof(korg1212_t))) == NULL)
+        card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
+        if (card == NULL)
                 return -ENOMEM;
 
-        card->private_free = snd_korg1212_card_free;
-        korg1212 = (korg1212_t *)card->private_data;
-        korg1212->card = card;
-        korg1212->pci = pci;
-
-        if ((err = snd_korg1212_create(korg1212)) < 0) {
+        if ((err = snd_korg1212_create(card, pci, &korg1212)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -2294 +2439 @@
                 return err;
         }
-        pci_set_drvdata(pci, card);
+        pci_set_drvdata(pci, korg1212);
         dev++;
         return 0;
@@ -2301 +2446 @@
 static void __devexit snd_korg1212_remove(struct pci_dev *pci)
 {
-        snd_card_free(pci_get_drvdata(pci));
+        korg1212_t *korg1212 = pci_get_drvdata(pci);
+        snd_card_free(korg1212->card);
         pci_set_drvdata(pci, NULL);
 }

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

@@ -25 +25 @@
 
 #include <sound/driver.h>
-#include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
+
 #include <sound/core.h>
 #include <sound/info.h>
@@ -38 +39 @@
 #define SNDRV_GET_ID
 #include <sound/initval.h>
+
+#include <asm/io.h>
 
 /* note, two last pcis should be equal, it is not a bug */
@@ -255 +258 @@
         snd_pcm_t          *adat_pcm; 
         struct pci_dev     *pci;
-        snd_info_entry_t   *proc_entry;
         snd_kcontrol_t     *spdif_ctl;
 } rme96_t;
@@ -303 +305 @@
 snd_rme96_capture_pointer(snd_pcm_substream_t *substream);
 
-static void __init 
+static void __devinit 
 snd_rme96_proc_init(rme96_t *rme96);
-
-static void
-snd_rme96_proc_done(rme96_t *rme96);
 
 static int
@@ -313 +312 @@
                           rme96_t *rme96);
 
+static int
+snd_rme96_getinputtype(rme96_t *rme96);
+
 static inline unsigned int
 snd_rme96_playback_ptr(rme96_t *rme96)
@@ -325 +327 @@
         return (readl(rme96->iobase + RME96_IO_GET_REC_POS)
                 & RME96_RCR_AUDIO_ADDR_MASK) >> rme96->capture_frlog;
+}
+
+static int
+snd_rme96_ratecode(int rate)
+{
+    switch (rate) {
+    case 32000: return SNDRV_PCM_RATE_32000;
+    case 44100: return SNDRV_PCM_RATE_44100;
+    case 48000: return SNDRV_PCM_RATE_48000;
+    case 64000: return SNDRV_PCM_RATE_64000;
+    case 88200: return SNDRV_PCM_RATE_88200;
+    case 96000: return SNDRV_PCM_RATE_96000;
+    }
+    return 0;
 }
 
@@ -667 +683 @@
 
         if (!(rme96->wcreg & RME96_WCR_MASTER) &&
+            snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
             (rate = snd_rme96_capture_getrate(rme96, &dummy)) > 0)
         {
@@ -972 +989 @@
                              snd_pcm_hw_params_t *params)
 {
-        unsigned long flags;
+        unsigned long flags;        
         rme96_t *rme96 = _snd_pcm_substream_chip(substream);
-        int err;
+        int err, rate, dummy;
 
         if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params))) < 0)
                 return err;
         spin_lock_irqsave(&rme96->lock, flags);
-        if ((err = snd_rme96_playback_setrate(rme96, params_rate(params))) < 0) {
+        if (!(rme96->wcreg & RME96_WCR_MASTER) &&
+            snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
+            (rate = snd_rme96_capture_getrate(rme96, &dummy)) > 0)
+        {
+                /* slave clock */
+                if ((int)params_rate(params) != rate) {
+                        spin_unlock_irqrestore(&rme96->lock, flags);
+                        return -EIO;                    
+                }
+        } else if ((err = snd_rme96_playback_setrate(rme96, params_rate(params))) < 0) {
                 spin_unlock_irqrestore(&rme96->lock, flags);
                 return err;
@@ -1022 +1048 @@
         unsigned long flags;
         rme96_t *rme96 = _snd_pcm_substream_chip(substream);
-        int err, isadat;
+        snd_pcm_runtime_t *runtime = substream->runtime;
+        int err, isadat, rate;
         
         if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params))) < 0)
@@ -1038 +1065 @@
                         return err;
                 }
-        } else if (params_rate(params) != snd_rme96_capture_getrate(rme96, &isadat)) {
-                spin_unlock_irqrestore(&rme96->lock, flags);
-                return -EBUSY;
+        } else if ((rate = snd_rme96_capture_getrate(rme96, &isadat)) > 0) {
+                if ((int)params_rate(params) != rate) {
+                        spin_unlock_irqrestore(&rme96->lock, flags);
+                        return -EIO;                    
+                }
+                if ((isadat && runtime->hw.channels_min == 2) ||
+                    (!isadat && runtime->hw.channels_min == 8))
+                {
+                        spin_unlock_irqrestore(&rme96->lock, flags);
+                        return -EIO;
+                }
         }
         snd_rme96_setframelog(rme96, params_channels(params), 0);
@@ -1160 +1195 @@
 {
         unsigned long flags;
+        int rate, dummy;
         rme96_t *rme96 = _snd_pcm_substream_chip(substream);
         snd_pcm_runtime_t *runtime = substream->runtime;
@@ -1166 +1202 @@
 
         spin_lock_irqsave(&rme96->lock, flags); 
+        if (rme96->playback_substream != NULL) {
+                spin_unlock_irqrestore(&rme96->lock, flags);
+                return -EBUSY;
+        }
         rme96->wcreg &= ~RME96_WCR_ADAT;
         writel(rme96->wcreg, rme96->iobase + RME96_IO_CONTROL_REGISTER);
@@ -1173 +1213 @@
         spin_unlock_irqrestore(&rme96->lock, flags);
 
-        runtime->hw = snd_rme96_playback_spdif_info;    
+        runtime->hw = snd_rme96_playback_spdif_info;
+        if (!(rme96->wcreg & RME96_WCR_MASTER) &&
+            snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
+            (rate = snd_rme96_capture_getrate(rme96, &dummy)) > 0)
+        {
+                /* slave clock */
+                runtime->hw.rates = snd_rme96_ratecode(rate);
+                runtime->hw.rate_min = rate;
+                runtime->hw.rate_max = rate;
+        }        
         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
@@ -1188 +1237 @@
 {
         unsigned long flags;
-        int isadat;
+        int isadat, rate;
         rme96_t *rme96 = _snd_pcm_substream_chip(substream);
         snd_pcm_runtime_t *runtime = substream->runtime;
 
-        rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER);
-        if (snd_rme96_capture_getrate(rme96, &isadat) < 0) {
-                /* no input */
-                return -EIO;
-        }
-        if (isadat) {
-                /* ADAT input */
-                return -EBUSY;
-        }
         snd_pcm_set_sync(substream);
 
-        spin_lock_irqsave(&rme96->lock, flags); 
+        runtime->hw = snd_rme96_capture_spdif_info;
+        if (snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
+            (rate = snd_rme96_capture_getrate(rme96, &isadat)) > 0)
+        {
+                if (isadat) {
+                        return -EIO;
+                }
+                runtime->hw.rates = snd_rme96_ratecode(rate);
+                runtime->hw.rate_min = rate;
+                runtime->hw.rate_max = rate;
+        }
+        
+        spin_lock_irqsave(&rme96->lock, flags);
+        if (rme96->capture_substream != NULL) {
+                spin_unlock_irqrestore(&rme96->lock, flags);
+                return -EBUSY;
+        }
         rme96->capture_substream = substream;
         rme96->capture_ptr = 0;
         spin_unlock_irqrestore(&rme96->lock, flags);
         
-        runtime->hw = snd_rme96_capture_spdif_info;
-        
         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
@@ -1220 +1274 @@
 {
         unsigned long flags;
+        int rate, dummy;
         rme96_t *rme96 = _snd_pcm_substream_chip(substream);
-        snd_pcm_runtime_t *runtime = substream->runtime;
+        snd_pcm_runtime_t *runtime = substream->runtime;        
         
         snd_pcm_set_sync(substream);
 
         spin_lock_irqsave(&rme96->lock, flags); 
+        if (rme96->playback_substream != NULL) {
+                spin_unlock_irqrestore(&rme96->lock, flags);
+                return -EBUSY;
+        }
         rme96->wcreg |= RME96_WCR_ADAT;
         writel(rme96->wcreg, rme96->iobase + RME96_IO_CONTROL_REGISTER);
@@ -1234 +1293 @@
         
         runtime->hw = snd_rme96_playback_adat_info;
+        if (!(rme96->wcreg & RME96_WCR_MASTER) &&
+            snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG &&
+            (rate = snd_rme96_capture_getrate(rme96, &dummy)) > 0)
+        {
+                /* slave clock */
+                runtime->hw.rates = snd_rme96_ratecode(rate);
+                runtime->hw.rate_min = rate;
+                runtime->hw.rate_max = rate;
+        }        
         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
@@ -1243 +1311 @@
 {
         unsigned long flags;
-        int isadat;
+        int isadat, rate;
         rme96_t *rme96 = _snd_pcm_substream_chip(substream);
         snd_pcm_runtime_t *runtime = substream->runtime;
 
-        rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER);
-        if (snd_rme96_capture_getrate(rme96, &isadat) < 0) {
-                /* no input */
-                return -EIO;
-        }
-        if (!isadat) {
-                /* S/PDIF input */
-                return -EBUSY;
-        }
         snd_pcm_set_sync(substream);
 
+        runtime->hw = snd_rme96_capture_adat_info;
+        if (snd_rme96_getinputtype(rme96) != RME96_INPUT_ANALOG) {
+                /* makes no sense to use analog input. Note that analog
+                   expension cards AEB4/8-I are RME96_INPUT_INTERNAL */
+                return -EIO;
+        }
+        if ((rate = snd_rme96_capture_getrate(rme96, &isadat)) > 0) {
+                if (!isadat) {
+                        return -EIO;
+                }
+                runtime->hw.rates = snd_rme96_ratecode(rate);
+                runtime->hw.rate_min = rate;
+                runtime->hw.rate_max = rate;
+        }
+        
         spin_lock_irqsave(&rme96->lock, flags); 
+        if (rme96->capture_substream != NULL) {
+                spin_unlock_irqrestore(&rme96->lock, flags);
+                return -EBUSY;
+        }
         rme96->capture_substream = substream;
         rme96->capture_ptr = 0;
         spin_unlock_irqrestore(&rme96->lock, flags);
 
-        runtime->hw = snd_rme96_capture_adat_info;
         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_BYTES, RME96_BUFFER_SIZE, RME96_BUFFER_SIZE);
         snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, &hw_constraints_period_bytes);
@@ -1277 +1354 @@
 
         spin_lock_irqsave(&rme96->lock, flags); 
+        if (RME96_ISPLAYING(rme96)) {
+                snd_rme96_playback_stop(rme96);
+        }
         rme96->playback_substream = NULL;
         rme96->playback_periodsize = 0;
@@ -1296 +1376 @@
         
         spin_lock_irqsave(&rme96->lock, flags); 
+        if (RME96_ISRECORDING(rme96)) {
+                snd_rme96_capture_stop(rme96);
+        }
         rme96->capture_substream = NULL;
         rme96->capture_periodsize = 0;
@@ -1556 +1639 @@
                 rme96->areg &= ~RME96_AR_DAC_EN;
                 writel(rme96->areg, rme96->iobase + RME96_IO_ADDITIONAL_REG);
-                snd_rme96_proc_done(rme96);
                 free_irq(rme96->irq, (void *)rme96);
                 rme96->irq = -1;
@@ -1587 +1669 @@
 }
 
-static int __init
+static int __devinit
 snd_rme96_create(rme96_t *rme96)
 {
@@ -1783 +1865 @@
         } else if (rme96->wcreg & RME96_WCR_MASTER) {
                 snd_iprintf(buffer, "  clock mode: master\n");
+        } else if (snd_rme96_getinputtype(rme96) == RME96_INPUT_ANALOG) {
+                snd_iprintf(buffer, "  clock mode: slave (master anyway due to analog input setting)\n");
+        } else if (snd_rme96_capture_getrate(rme96, &n) < 0) {
+                snd_iprintf(buffer, "  clock mode: slave (master anyway due to no valid signal)\n");
         } else {
                 snd_iprintf(buffer, "  clock mode: slave\n");
@@ -1836 +1922 @@
 }
 
-static void __init 
+static void __devinit 
 snd_rme96_proc_init(rme96_t *rme96)
 {
         snd_info_entry_t *entry;
 
-        if ((entry = snd_info_create_card_entry(rme96->card, "rme96", rme96->card->proc_root)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = rme96;
-                entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 256;
-                entry->c.text.read = snd_rme96_proc_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        rme96->proc_entry = entry;
-}
-
-static void
-snd_rme96_proc_done(rme96_t * rme96)
-{
-        if (rme96->proc_entry) {
-                snd_info_unregister(rme96->proc_entry);
-                rme96->proc_entry = NULL;
-        }
+        if (! snd_card_proc_new(rme96->card, "rme96", &entry))
+                snd_info_set_text_ops(entry, rme96, snd_rme96_proc_read);
 }
 
@@ -1953 +2020 @@
         rme96_t *rme96 = _snd_kcontrol_chip(kcontrol);
         unsigned long flags;
-        int items = 3;
+        unsigned int items = 3;
         
         spin_lock_irqsave(&rme96->lock, flags);
@@ -2025 +2092 @@
         
         spin_lock_irqsave(&rme96->lock, flags);
-        change = val != snd_rme96_getinputtype(rme96);
+        change = (int)val != snd_rme96_getinputtype(rme96);
         snd_rme96_setinputtype(rme96, val);
         spin_unlock_irqrestore(&rme96->lock, flags);
@@ -2066 +2133 @@
         val = ucontrol->value.enumerated.item[0] % 3;
         spin_lock_irqsave(&rme96->lock, flags);
-        change = val != snd_rme96_getclockmode(rme96);
+        change = (int)val != snd_rme96_getclockmode(rme96);
         snd_rme96_setclockmode(rme96, val);
         spin_unlock_irqrestore(&rme96->lock, flags);
@@ -2107 +2174 @@
         val = ucontrol->value.enumerated.item[0] % 4;
         spin_lock_irqsave(&rme96->lock, flags);
-        change = val != snd_rme96_getattenuation(rme96);
+
+        change = (int)val != snd_rme96_getattenuation(rme96);
         snd_rme96_setattenuation(rme96, val);
         spin_unlock_irqrestore(&rme96->lock, flags);
@@ -2148 +2216 @@
         val = ucontrol->value.enumerated.item[0] % 4;
         spin_lock_irqsave(&rme96->lock, flags);
-        change = val != snd_rme96_getmontracks(rme96);
+        change = (int)val != snd_rme96_getmontracks(rme96);
         snd_rme96_setmontracks(rme96, val);
         spin_unlock_irqrestore(&rme96->lock, flags);

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

@@ -26 +26 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 
-    hammerfall_mem.c,v 1.5 2002/11/04 09:11:42 perex Exp
+    hammerfall_mem.c,v 1.8 2003/02/25 13:35:44 perex Exp
 
 
@@ -156 +156 @@
                         rbuf->flags |= HAMMERFALL_BUF_USED;
                         rbuf->pci = pcidev;
-                        MOD_INC_USE_COUNT;
                         *dmaaddr = rbuf->addr;
                         return rbuf->buf;
@@ -173 +172 @@
                 rbuf = &hammerfall_buffers[i];
                 if (rbuf->buf == addr && rbuf->pci == pcidev) {
-                        MOD_DEC_USE_COUNT;
                         rbuf->flags &= ~HAMMERFALL_BUF_USED;
                         return;
@@ -182 +180 @@
 }
 
-static void __exit hammerfall_free_buffers (void)
+static void hammerfall_free_buffers (void)
 
 {

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

@@ -68 +68 @@
 MODULE_LICENSE("GPL");
 MODULE_CLASSES("{sound}");
-MODULE_DEVICES("{{RME,Hammerfall-DSP},");
+MODULE_DEVICES("{{RME,Hammerfall-DSP}}");
 
 typedef enum {
@@ -455 +455 @@
         
         for (i = 0; i < timeout; i++)
-                if ((hdsp_read (hdsp, HDSP_fifoStatus) & 0xff) <= count)
+                if ((int)(hdsp_read (hdsp, HDSP_fifoStatus) & 0xff) <= count)
                         return 0;
 
@@ -839 +839 @@
                 if (!snd_rawmidi_transmit_empty (hmidi->output)) {
                         if ((n_pending = snd_hdsp_midi_output_possible (hmidi->hdsp, hmidi->id)) > 0) {
-                                if (n_pending > sizeof (buf))
+                                if (n_pending > (int)sizeof (buf))
                                         n_pending = sizeof (buf);
                                 
@@ -873 +873 @@
         if ((n_pending = snd_hdsp_midi_input_available (hmidi->hdsp, hmidi->id)) > 0) {
                 if (hmidi->input) {
-                        if (n_pending > sizeof (buf)) {
+                        if (n_pending > (int)sizeof (buf)) {
                                 n_pending = sizeof (buf);
                         }
@@ -1279 +1279 @@
         val = ucontrol->value.integer.value[0] & 1;
         spin_lock_irqsave(&hdsp->lock, flags);
-        change = val != hdsp_spdif_out(hdsp);
+        change = (int)val != hdsp_spdif_out(hdsp);
         hdsp_set_spdif_output(hdsp, val);
         spin_unlock_irqrestore(&hdsp->lock, flags);
@@ -1394 +1394 @@
         val = ucontrol->value.enumerated.item[0] % max;
         spin_lock_irqsave(&hdsp->lock, flags);
-        change = val != hdsp_sync_pref(hdsp);
+        change = (int)val != hdsp_sync_pref(hdsp);
         hdsp_set_sync_pref(hdsp, val);
         spin_unlock_irqrestore(&hdsp->lock, flags);
@@ -1498 +1498 @@
         val = ucontrol->value.integer.value[0] & 1;
         spin_lock_irqsave(&hdsp->lock, flags);
-        change = val != hdsp_line_out(hdsp);
+        change = (int)val != hdsp_line_out(hdsp);
         hdsp_set_line_output(hdsp, val);
         spin_unlock_irqrestore(&hdsp->lock, flags);
@@ -1567 +1567 @@
 
         spin_lock_irqsave(&hdsp->lock, flags);
-        if ((change = gain != hdsp_read_gain(hdsp, addr)))
+        change = gain != hdsp_read_gain(hdsp, addr);
+        if (change)
                 hdsp_write_gain(hdsp, addr, gain);
         spin_unlock_irqrestore(&hdsp->lock, flags);
@@ -1629 +1630 @@
 
         spin_lock_irqsave(&hdsp->lock, flags);
-        if ((change = gain != hdsp_read_gain(hdsp, addr)))
+        change = gain != hdsp_read_gain(hdsp, addr);
+        if (change)
                 hdsp_write_gain(hdsp, addr, gain);
         spin_unlock_irqrestore(&hdsp->lock, flags);
@@ -1801 +1803 @@
 int snd_hdsp_create_controls(snd_card_t *card, hdsp_t *hdsp)
 {
-        int idx, err, limit;
+        unsigned int idx, limit;
+        int err;
         snd_kcontrol_t *kctl;
 
@@ -2300 +2303 @@
         channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
         snd_assert(channel_buf != NULL, return -EIO);
-        copy_from_user(channel_buf + pos * 4, src, count * 4);
+        if (copy_from_user(channel_buf + pos * 4, src, count * 4))
+                return -EFAULT;
         return count;
 }
@@ -2314 +2318 @@
         channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
         snd_assert(channel_buf != NULL, return -EIO);
-        copy_to_user(dst, channel_buf + pos * 4, count * 4);
+        if (copy_to_user(dst, channel_buf + pos * 4, count * 4))
+                return -EFAULT;
         return count;
 }
@@ -2388 +2393 @@
                  */
 
-                if (params_rate(params) != hdsp_system_sample_rate(hdsp)) {
+                if ((int)params_rate(params) != hdsp_system_sample_rate(hdsp)) {
                         spin_unlock_irq(&hdsp->lock);
                         _snd_pcm_hw_param_setempty(params, SNDRV_PCM_HW_PARAM_RATE);
@@ -2564 +2569 @@
         .channels_min =         10,
         .channels_max =         HDSP_MAX_CHANNELS,
-        .buffer_bytes_max =     1024*1024,
-        .period_bytes_min =     1,
-        .period_bytes_max =     1024*1024,
+        .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
+        .period_bytes_min =     (64 * 4) *10,
+        .period_bytes_max =     (8192 * 4) * HDSP_MAX_CHANNELS,
         .periods_min =          2,
         .periods_max =          2,
@@ -2589 +2594 @@
         .channels_min =         10,
         .channels_max =         HDSP_MAX_CHANNELS,
-        .buffer_bytes_max =     1024*1024,
-        .period_bytes_min =     1,
-        .period_bytes_max =     1024*1024,
+        .buffer_bytes_max =     HDSP_CHANNEL_BUFFER_BYTES * HDSP_MAX_CHANNELS,
+        .period_bytes_min =     (64 * 4) * 10,
+        .period_bytes_max =     (8192 * 4) * HDSP_MAX_CHANNELS,
         .periods_min =          2,
         .periods_max =          2,
@@ -2624 +2629 @@
         if (r->min > 48000) {
                 snd_interval_t t = {
-                        min: hdsp->ds_channels,
-                        max: hdsp->ds_channels,
-                        integer: 1,
+                        .min = hdsp->ds_channels,
+                        .max = hdsp->ds_channels,
+                        .integer = 1,
                 };
                 return snd_interval_refine(c, &t);
         } else if (r->max < 64000) {
                 snd_interval_t t = {
-                        min: hdsp->ss_channels,
-                        max: hdsp->ss_channels,
-                        integer: 1,
+                        .min = hdsp->ss_channels,
+                        .max = hdsp->ss_channels,
+                        .integer = 1,
                 };
                 return snd_interval_refine(c, &t);
@@ -2648 +2653 @@
         if (c->min >= hdsp->ss_channels) {
                 snd_interval_t t = {
-                        min: 32000,
-                        max: 48000,
-                        integer: 1,
+                        .min = 32000,
+                        .max = 48000,
+                        .integer = 1,
                 };
                 return snd_interval_refine(r, &t);
         } else if (c->max <= hdsp->ds_channels) {
                 snd_interval_t t = {
-                        min: 64000,
-                        max: 96000,
-                        integer: 1,
+                        .min = 64000,
+                        .max = 96000,
+                        .integer = 1,
                 };
                 return snd_interval_refine(r, &t);
@@ -2967 +2972 @@
         switch (rev & 0xff) {
         case 0xa:
+        case 0xb:
+        case 0x64:
                 /* hdsp_initialize_firmware() will reset this */
                 hdsp->card_name = "RME Hammerfall DSP";

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

@@ -22 +22 @@
 
 #include <sound/driver.h>
-#include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
+
 #include <sound/core.h>
 #include <sound/control.h>
@@ -34 +35 @@
 #define SNDRV_GET_ID
 #include <sound/initval.h>
+
+#include <asm/current.h>
+#include <asm/io.h>
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
@@ -260 +264 @@
         snd_pcm_t *pcm;
         struct pci_dev *pci;
-        snd_info_entry_t *proc_entry;
         snd_kcontrol_t *spdif_ctl;
 
@@ -312 +315 @@
 
 static struct pci_device_id snd_rme9652_ids[] __devinitdata = {
-        {0x10ee, 0x3fc4, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0,},     /* RME Digi9652 */
-        {0,}
+        {
+                .vendor    = 0x10ee,
+                .device    = 0x3fc4,
+                .subvendor = PCI_ANY_ID,
+                .subdevice = PCI_ANY_ID,
+        },      /* RME Digi9652 */
+        { 0, },
 };
 
@@ -367 +375 @@
 {
         int status;
-        int offset, frag;
+        unsigned int offset, frag;
         snd_pcm_uframes_t period_size = rme9652->period_bytes / 4;
         snd_pcm_sframes_t delta;
@@ -382 +390 @@
         delta = rme9652->prev_hw_offset - offset;
         delta &= 0xffff;
-        if (delta <= rme9652->max_jitter * 4)
+        if (delta <= (snd_pcm_sframes_t)rme9652->max_jitter * 4)
                 offset = rme9652->prev_hw_offset;
         else
@@ -1094 +1102 @@
         val = ucontrol->value.integer.value[0] & 1;
         spin_lock_irqsave(&rme9652->lock, flags);
-        change = val != rme9652_spdif_out(rme9652);
+        change = (int)val != rme9652_spdif_out(rme9652);
         rme9652_set_spdif_output(rme9652, val);
         spin_unlock_irqrestore(&rme9652->lock, flags);
@@ -1181 +1189 @@
         val = ucontrol->value.enumerated.item[0] % 3;
         spin_lock_irqsave(&rme9652->lock, flags);
-        change = val != rme9652_sync_mode(rme9652);
+        change = (int)val != rme9652_sync_mode(rme9652);
         rme9652_set_sync_mode(rme9652, val);
         spin_unlock_irqrestore(&rme9652->lock, flags);
@@ -1278 +1286 @@
         val = ucontrol->value.enumerated.item[0] % max;
         spin_lock_irqsave(&rme9652->lock, flags);
-        change = val != rme9652_sync_pref(rme9652);
+        change = (int)val != rme9652_sync_pref(rme9652);
         rme9652_set_sync_pref(rme9652, val);
         spin_unlock_irqrestore(&rme9652->lock, flags);
@@ -1592 +1600 @@
 int snd_rme9652_create_controls(snd_card_t *card, rme9652_t *rme9652)
 {
-        int idx, err;
+        unsigned int idx;
+        int err;
         snd_kcontrol_t *kctl;
 
@@ -1790 +1799 @@
 }
 
-static void __init snd_rme9652_proc_init(rme9652_t *rme9652)
+static void __devinit snd_rme9652_proc_init(rme9652_t *rme9652)
 {
         snd_info_entry_t *entry;
 
-        if ((entry = snd_info_create_card_entry(rme9652->card, "rme9652", rme9652->card->proc_root)) !=
-            NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = rme9652;
-                entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 256;
-                entry->c.text.read = snd_rme9652_proc_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        rme9652->proc_entry = entry;
-}
-
-static void snd_rme9652_proc_done(rme9652_t *rme9652)
-{
-        if (rme9652->proc_entry) {
-                snd_info_unregister(rme9652->proc_entry);
-                rme9652->proc_entry = NULL;
-        }
+        if (! snd_card_proc_new(rme9652->card, "rme9652", &entry))
+                snd_info_set_text_ops(entry, rme9652, snd_rme9652_proc_read);
 }
 
@@ -1846 +1836 @@
         if (rme9652->irq >= 0)
                 rme9652_stop(rme9652);
-        snd_rme9652_proc_done(rme9652);
         snd_rme9652_free_buffers(rme9652);
 
@@ -1860 +1849 @@
 }
 
-static int __init snd_rme9652_initialize_memory(rme9652_t *rme9652)
+static int __devinit snd_rme9652_initialize_memory(rme9652_t *rme9652)
 {
         void *pb, *cb;
@@ -2105 +2094 @@
                  */
 
-                if (params_rate(params) !=
+                if ((int)params_rate(params) !=
                     rme9652_adat_sample_rate(rme9652)) {
                         spin_unlock_irq(&rme9652->lock);
@@ -2276 +2265 @@
         .channels_min =         10,
         .channels_max =         26,
-        .buffer_bytes_max =     1024*1024,
-        .period_bytes_min =     1,
-        .period_bytes_max =     1024*1024,
+        .buffer_bytes_max =     RME9652_CHANNEL_BUFFER_BYTES * 26,
+        .period_bytes_min =     (64 * 4) * 10,
+        .period_bytes_max =     (8192 * 4) * 26,
         .periods_min =          2,
         .periods_max =          2,
@@ -2299 +2288 @@
         .channels_min =         10,
         .channels_max =         26,
-        .buffer_bytes_max =     1024*1024,
-        .period_bytes_min =     1,
-        .period_bytes_max =     1024*1024,
+        .buffer_bytes_max =     RME9652_CHANNEL_BUFFER_BYTES *26,
+        .period_bytes_min =     (64 * 4) * 10,
+        .period_bytes_max =     (8192 * 4) * 26,
         .periods_min =          2,
         .periods_max =          2,
@@ -2338 +2327 @@
         snd_interval_t *r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
         if (r->min > 48000) {
-#ifdef TARGET_OS2
-                snd_interval_t t = {0};
-                t.min = rme9652->ds_channels;
-                t.max = rme9652->ds_channels;
-                t.integer = 1;
-#else
                 snd_interval_t t = {
-                        min: rme9652->ds_channels,
-                        max: rme9652->ds_channels,
-                        integer: 1,
+                        .min = rme9652->ds_channels,
+                        .max = rme9652->ds_channels,
+                        .integer = 1,
                 };
-#endif
                 return snd_interval_refine(c, &t);
         } else if (r->max < 88200) {
-#ifdef TARGET_OS2
-                snd_interval_t t = {0};
-                t.min = rme9652->ss_channels;
-                t.max = rme9652->ss_channels;
-                t.integer = 1;
-#else
                 snd_interval_t t = {
-                        min: rme9652->ss_channels,
-                        max: rme9652->ss_channels,
-                        integer: 1,
+                        .min = rme9652->ss_channels,
+                        .max = rme9652->ss_channels,
+                        .integer = 1,
                 };
-#endif
                 return snd_interval_refine(c, &t);
         }
@@ -2377 +2352 @@
         if (c->min >= rme9652->ss_channels) {
                 snd_interval_t t = {
-#ifdef TARGET_OS2
-                        44100,
-                        48000,
-                        0, 0, 1, 0,
-#else
-                        min: 44100,
-                        max: 48000,
-                        integer: 1,
-#endif
+                        .min = 44100,
+                        .max = 48000,
+                        .integer = 1,
                 };
                 return snd_interval_refine(r, &t);
         } else if (c->max <= rme9652->ds_channels) {
                 snd_interval_t t = {
-#ifdef TARGET_OS2
-                        88200,
-                        96000,
-                        0, 0, 1, 0,
-#else
-                        min: 88200,
-                        max: 96000,
-                        integer: 1,
-#endif
+                        .min = 88200,
+                        .max = 96000,
+                        .integer = 1,
                 };
                 return snd_interval_refine(r, &t);
@@ -2542 +2505 @@
 };
 
-static int __init snd_rme9652_create_pcm(snd_card_t *card,
+static int __devinit snd_rme9652_create_pcm(snd_card_t *card,
                                          rme9652_t *rme9652)
 {
@@ -2566 +2529 @@
 }
 
-static int __init snd_rme9652_create(snd_card_t *card,
+static int __devinit snd_rme9652_create(snd_card_t *card,
                                      rme9652_t *rme9652,
                                      int precise_ptr)
@@ -2761 +2724 @@
 
 static struct pci_driver driver = {
-        .name ="RME Digi9652 (Hammerfall)",
+        .name     = "RME Digi9652 (Hammerfall)",
         .id_table = snd_rme9652_ids,
-        .probe = snd_rme9652_probe,
-        .remove = __devexit_p(snd_rme9652_remove),
+        .probe    = snd_rme9652_probe,
+        .remove   = __devexit_p(snd_rme9652_remove),
 };
 

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

@@ -24 +24 @@
 
 #include <sound/driver.h>
-#include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
+#include <linux/gameport.h>
+
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -37 +39 @@
 #define SNDRV_GET_ID
 #include <sound/initval.h>
-#ifndef LINUX_2_2
-#include <linux/gameport.h>
-#endif
+
+#include <asm/io.h>
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
@@ -252 +253 @@
 
         spinlock_t reg_lock;
-        snd_info_entry_t *proc_entry;
 
         unsigned int p_dma_size;
@@ -260 +260 @@
         snd_kcontrol_t *master_volume;
 
-#ifndef LINUX_2_2
+#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
         struct gameport gameport;
 #endif
@@ -272 +272 @@
 MODULE_DEVICE_TABLE(pci, snd_sonic_ids);
 
-#ifdef TARGET_OS2
 static ratden_t sonicvibes_adc_clock = {
-        4000 * 65536,
-        48000UL * 65536,
-        1,
-        65536,
+        .num_min = 4000 * 65536,
+        .num_max = 48000UL * 65536,
+        .num_step = 1,
+        .den = 65536,
 };
 static snd_pcm_hw_constraint_ratdens_t snd_sonicvibes_hw_constraints_adc_clock = {
-        1,
-        &sonicvibes_adc_clock,
+        .nrats = 1,
+        .rats = &sonicvibes_adc_clock,
 };
-#else
-static ratden_t sonicvibes_adc_clock = {
-        num_min: 4000 * 65536,
-        num_max: 48000UL * 65536,
-        num_step: 1,
-        den: 65536,
-};
-static snd_pcm_hw_constraint_ratdens_t snd_sonicvibes_hw_constraints_adc_clock = {
-        nrats: 1,
-        rats: &sonicvibes_adc_clock,
-};
-#endif
 
 /*
@@ -1137 +1124 @@
         snd_card_t *card;
         snd_kcontrol_t *kctl;
-        int idx, err;
+        unsigned int idx;
+        int err;
 
         snd_assert(sonic != NULL && sonic->card != NULL, return -EINVAL);
@@ -1192 +1180 @@
         snd_info_entry_t *entry;
 
-        if ((entry = snd_info_create_card_entry(sonic->card, "sonicvibes", sonic->card->proc_root)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = sonic;
-                entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-                entry->c.text.read_size = 256;
-                entry->c.text.read = snd_sonicvibes_proc_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        sonic->proc_entry = entry;
-}
-
-static void snd_sonicvibes_proc_done(sonicvibes_t * sonic)
-{
-        if (sonic->proc_entry) {
-                snd_info_unregister(sonic->proc_entry);
-                sonic->proc_entry = NULL;
-        }
+        if (! snd_card_proc_new(sonic->card, "sonicvibes", &entry))
+                snd_info_set_text_ops(entry, sonic, snd_sonicvibes_proc_read);
 }
 
@@ -1223 +1193 @@
 static int snd_sonicvibes_free(sonicvibes_t *sonic)
 {
-#ifndef LINUX_2_2
+#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
         if (sonic->gameport.io)
                 gameport_unregister_port(&sonic->gameport);
 #endif
-        snd_sonicvibes_proc_done(sonic);
         pci_write_config_dword(sonic->pci, 0x40, sonic->dmaa_port);
         pci_write_config_dword(sonic->pci, 0x48, sonic->dmac_port);
@@ -1455 +1424 @@
         snd_card_t *card = sonic->card;
         snd_rawmidi_str_t *dir;
-        int idx, err;
+        unsigned int idx;
+        int err;
 
         mpu->private_data = sonic;
@@ -1527 +1497 @@
                 return err;
         }
-#ifndef LINUX_2_2
+#if defined(CONFIG_GAMEPORT) || defined(CONFIG_GAMEPORT_MODULE)
         sonic->gameport.io = sonic->game_port;
         gameport_register_port(&sonic->gameport);

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

@@ -29 +29 @@
 
 #include <sound/driver.h>
-#include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
+#ifndef TARGET_OS2 //TODO: Implement linux/gameport.h
+#include <linux/gameport.h>
+#endif /* !TARGET_OS2 */
+
 #include <sound/core.h>
 #include <sound/info.h>
@@ -40 +44 @@
 #include <sound/trident.h>
 #include <sound/asoundef.h>
+
+#include <asm/io.h>
+
+#define chip_t trident_t
 
 static int snd_trident_pcm_mixer_build(struct snd_trident *trident, struct snd_trident_voice* voice, snd_pcm_substream_t *substream);
@@ -1015 +1023 @@
     if (voice->memblk)
         voice->LBA = voice->memblk->offset;
+        else
+                voice->LBA = runtime->dma_addr;
+        outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
 
     // set ESO
@@ -2419 +2430 @@
 static snd_kcontrol_new_t snd_trident_spdif_default __devinitdata =
 {
-        .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
-        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
         .info =         snd_trident_spdif_default_info,
         .get =          snd_trident_spdif_default_get,
@@ -3995 +4006 @@
 EXPORT_SYMBOL(snd_trident_write_voice_regs);
 EXPORT_SYMBOL(snd_trident_clear_voices);
+#ifdef CONFIG_PM
+EXPORT_SYMBOL(snd_trident_suspend);
+EXPORT_SYMBOL(snd_trident_resume);
+#endif
 /* trident_memory.c symbols */
 EXPORT_SYMBOL(snd_trident_synth_alloc);

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

@@ -26 +26 @@
 
 #include <sound/driver.h>
-#include <asm/io.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/pci.h>
+#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
+
 #include <sound/core.h>
 #include <sound/control.h>
@@ -38 +40 @@
 #include <sound/asoundef.h>
 #include <sound/mpu401.h>
+
+#include <asm/io.h>
+
 #ifdef TARGET_OS2
 #include <sound/timer.h>
@@ -1316 +1321 @@
 {
         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
-        .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
-        .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
+        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
+        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
         .info =         snd_ymfpci_spdif_mask_info,
         .get =          snd_ymfpci_spdif_mask_get,