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

Timestamp:

May 2, 2007, 9:13:43 AM (19 years ago)

Author:

Brendan Oakley

Message:

Merged 0.9.0beta6 to 0.9.0beta12. Fixed a few compilation errors.
Left include/sound/driver.h at beta9 until I figure out why it contains
so many modifications to sections that were removed in beta10.
Does not yet build. Needs more fixing.
Added a few new files that were in the copy Paul gave me to work from.

Location:

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

Files:

• ali5451/ali5451.c (modified) (2 diffs)
• als4000.c (modified) (3 diffs)
• emu10k1/emu10k1_main.c (modified) (3 diffs)
• emu10k1/tina2.h (added)
• es1968.c (modified) (5 diffs)
• hda/Makefile (added)
• hda/patch_analog.c (modified) (2 diffs)
• hda/patch_conexant.c (added)
• hda/patch_via.c (added)
• ice1712.c (modified) (115 diffs)
• maestro3.c (modified) (1 diff)
• rme96.c (modified) (23 diffs)
• rme9652/rme9652.c (modified) (23 diffs)
• trident/trident.c (modified) (3 diffs)
• ymfpci/ymfpci.c (modified) (4 diffs)

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

@@ -27 +27 @@
 
 #define __SNDRV_OSS_COMPAT__
-#define SNDRV_MAIN_OBJECT_FILE
-
-#include "sound/driver.h"
-#include "sound/pcm.h"
-#include "sound/info.h"
-#include "sound/ac97_codec.h"
-#include "sound/mpu401.h"
+
+#include <sound/driver.h>
+#include <asm/io.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/info.h>
+#include <sound/ac97_codec.h>
+#include <sound/mpu401.h>
 #define SNDRV_GET_ID
-#include "sound/initval.h"
+#include <sound/initval.h>
 
 MODULE_AUTHOR("Matt Wu <Matt_Wu@acersoftech.com.cn>");
@@ -2323 +2328 @@
     if ((err = pci_module_init(&driver)) < 0) {
 #ifdef MODULE
-        //              snd_printk("ALi pci audio not found or device busy.\n");
+//              snd_printk(KERN_ERR "ALi pci audio not found or device busy.\n");
 #endif
         return err;

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

@@ -731 +731 @@
                                    &chip->rmidi)) < 0) {
         snd_card_free(card);
-        snd_printk("no MPU-401device at 0x%lx ?\n", gcr+0x30);
+                printk(KERN_ERR "als4000: no MPU-401device at 0x%lx ?\n", gcr+0x30);
         return err;
     }
@@ -746 +746 @@
     if (snd_opl3_create(card, gcr+0x10, gcr+0x12,
                         OPL3_HW_AUTO, 1, &opl3) < 0) {
-        snd_printk("no OPL device at 0x%lx-0x%lx ?\n",
+                printk(KERN_ERR "als4000: no OPL device at 0x%lx-0x%lx ?\n",
                    gcr+0x10, gcr+0x12 );
     } else {
@@ -797 +797 @@
     if ((err = pci_module_init(&driver)) < 0) {
 #ifdef MODULE
-        //              snd_printk("no ALS4000 based soundcards found or device busy\n");
+//              snd_printk(KERN_ERR "no ALS4000 based soundcards found or device busy\n");
 #endif
         return err;

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

@@ -39 +39 @@
 #include <sound/core.h>
 #include <sound/emu10k1.h>
-#include <sound/firmware.h>
+#include <linux/firmware.h>
 #include "p16v.h"
 #include "tina2.h"
@@ -597 +597 @@
     return 0;
 }
+
 
 static int snd_emu1010_load_firmware(struct snd_emu10k1 * emu, const char * filename)
@@ -1020 +1021 @@
     return 0;
 }
-
 
 /*

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

@@ -1606 +1606 @@
     es->substream = substream;
     es->mode = ESM_MODE_PLAY;
+        INIT_LIST_HEAD(&es->list);
 
     runtime->private_data = es;
@@ -1657 +1658 @@
     es->substream = substream;
     es->mode = ESM_MODE_CAPTURE;
+        INIT_LIST_HEAD(&es->list);
 
     /* get mixbuffer */
@@ -1717 +1719 @@
     return 0;
 }
+
 static snd_pcm_ops_t snd_es1968_playback_ops = {
     /*  open:     */    snd_es1968_playback_open,
@@ -2005 +2008 @@
 
     if (event & ESM_SOUND_IRQ) {
-        struct list_head *p;
+                struct list_head *p, *n;
         spin_lock(&chip->substream_lock);
-        list_for_each(p, &chip->substream_list) {
+                /* we need to use list_for_each_safe here since the substream
+                 * can be deleted in period_elapsed().
+                 */
+                list_for_each_safe(p, n, &chip->substream_list) {
             esschan_t *es = list_entry(p, esschan_t, list);
             if (es->running)
@@ -2841 +2847 @@
     if ((err = pci_module_init(&driver)) < 0) {
 #ifdef MODULE
-        //              snd_printk("ESS Maestro soundcard not found or device busy\n");
+//              snd_printk(KERN_ERR "ESS Maestro soundcard not found or device busy\n");
 #endif
         return err;

GPL/branches/alsa-resync1/alsa-kernel/pci/hda/patch_analog.c

@@ -2619 +2619 @@
         if (is_rev2(codec))
                 snd_printk(KERN_INFO "patch_analog: AD1988A rev.2 is detected, enable workarounds\n");
-
+//paul
+                snd_printk(KERN_INFO "patch_analog: Vendor Id: 0x%x\n", codec->vendor_id);
+                snd_printk(KERN_INFO "patch_analog: Subsystem Id: 0x%x\n", codec->subsystem_id);
+                snd_printk(KERN_INFO "patch_analog: Revision Id: 0x%x\n", codec->revision_id);
+                snd_printk(KERN_INFO "patch_analog: Model Name: %s\n", codec->bus->modelname);
+//endpaul
         board_config = snd_hda_check_board_config(codec, AD1988_MODEL_LAST,
                                                   ad1988_models, NULL);
@@ -2638 +2643 @@
                 }
         }
-
+//paul
+        snd_printk(KERN_INFO "patch_analog: board_config: %d\n", board_config);
+        board_config = AD1988_3STACK_DIG;
+        snd_printk(KERN_INFO "patch_analog: kludged board_config: %d\n", board_config);
+//endpaul
         switch (board_config) {
         case AD1988_6STACK:

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

@@ -16 +16 @@
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
  */      
@@ -22 +22 @@
 /*
   NOTES:
-  - spdif nonaudio consumer mode does not work (at least with my 
+  - spdif nonaudio consumer mode does not work (at least with my
     Sony STR-DB830)
 */
 
-#define SNDRV_MAIN_OBJECT_FILE
-
 #include <sound/driver.h>
+#include <asm/io.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <sound/core.h>
 #include <sound/control.h>
 #include <sound/pcm.h>
 #include <sound/ac97_codec.h>
 #include <sound/mpu401.h>
+#include <sound/i2c.h>
+#include <sound/cs8427.h>
 #include <sound/info.h>
 #define SNDRV_GET_ID
 #include <sound/initval.h>
 
+#include <sound/asoundef.h>
+
+#define SND_CS8403
+#define SND_CS8404
+#include <sound/cs8403.h>
+
 EXPORT_NO_SYMBOLS;
+
+MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
 MODULE_DESCRIPTION("ICEnsemble ICE1712 (Envy24)");
+MODULE_LICENSE("GPL");
 MODULE_CLASSES("{sound}");
 MODULE_DEVICES("{{Hoontech SoundTrack DSP 24},"
@@ -49 +64 @@
                 "{TerraTec,EWS 88MT},"
                 "{TerraTec,EWS 88D},"
+                "{TerraTec,DMX 6Fire},"
                 "{ICEnsemble,Generic ICE1712},"
                 "{ICEnsemble,Generic Envy24}}");
-MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
 
 static int snd_index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;  /* Index 0-MAX */
 static char *snd_id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;   /* ID for this card */
-static int snd_enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;      /* Enable this card */
+static int snd_enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;          /* Enable this card */
+static int snd_omni[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS-1)] = 0};       /* Delta44 & 66 Omni I/O support */
 
 MODULE_PARM(snd_index, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
@@ -66 +82 @@
 MODULE_PARM_DESC(snd_enable, "Enable ICE1712 soundcard.");
 MODULE_PARM_SYNTAX(snd_enable, SNDRV_ENABLE_DESC);
+MODULE_PARM(snd_omni, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
+MODULE_PARM_DESC(snd_omni, "Enable Midiman M-Audio Delta Omni I/O support.");
+MODULE_PARM_SYNTAX(snd_omni, SNDRV_ENABLED "," SNDRV_ENABLE_DESC);
 
 #ifndef PCI_VENDOR_ID_ICE
@@ -83 +102 @@
 #define ICE1712_SUBDEVICE_EWS88MT       0x3b151511
 #define ICE1712_SUBDEVICE_EWS88D        0x3b152b11
+#define ICE1712_SUBDEVICE_DMX6FIRE      0x3b153811
 
 /*
@@ -256 +276 @@
 #define ICE1712_CFG_SPDIF_OUT   0x01    /* S/PDIF output is present */
 
-/* MidiMan Delta GPIO definitions */
-
-#define ICE1712_DELTA_DFS       0x01    /* fast/slow sample rate mode */
+/*
+ *  MidiMan M-Audio Delta GPIO definitions
+ */
+
+/* MidiMan M-Audio Delta1010 */
+#define ICE1712_DELTA_DFS 0x01          /* fast/slow sample rate mode */
                                         /* (>48kHz must be 1) */
-                                        /* all cards */
 #define ICE1712_DELTA_SPDIF_IN_STAT 0x02
                                         /* S/PDIF input status */
@@ -275 +297 @@
                                         /* all except Delta44 */
                                         /* look to CS8404A datasheet */
+/* MidiMan M-Audio DeltaDiO */
+/* 0x01 = DFS */
+/* 0x02 = SPDIF_IN_STAT */
+/* 0x04 = SPDIF_OUT_STAT_CLOCK */
+/* 0x08 = SPDIF_OUT_STAT_DATA */
 #define ICE1712_DELTA_SPDIF_INPUT_SELECT 0x10
                                         /* coaxial (0), optical (1) */
                                         /* S/PDIF input select*/
-                                        /* DeltaDiO only */
+
+/* MidiMan M-Audio Delta1010 */
+/* 0x01 = DFS */
+/* 0x02 = SPDIF_IN_STAT */
+/* 0x04 = SPDIF_OUT_STAT_CLOCK */
+/* 0x08 = SPDIF_OUT_STAT_DATA */
 #define ICE1712_DELTA_WORD_CLOCK_SELECT 0x10
                                         /* 1 - clock are taken from S/PDIF input */
                                         /* 0 - clock are taken from Word Clock input */
-                                        /* Delta1010 only (affected SPMCLKIN pin of Envy24) */
+                                        /* affected SPMCLKIN pin of Envy24 */
+#define ICE1712_DELTA_WORD_CLOCK_STATUS 0x20
+                                        /* 0 = valid word clock signal is present */
+
+/* MidiMan M-Audio Delta66 */
+/* 0x01 = DFS */
+/* 0x02 = SPDIF_IN_STAT */
+/* 0x04 = SPDIF_OUT_STAT_CLOCK */
+/* 0x08 = SPDIF_OUT_STAT_DATA */
 #define ICE1712_DELTA_CODEC_SERIAL_DATA 0x10
                                         /* AKM4524 serial data */
-                                        /* Delta66 and Delta44 */
-#define ICE1712_DELTA_WORD_CLOCK_STATUS 0x20
-                                        /* 0 = valid word clock signal is present */
-                                        /* Delta1010 only */
 #define ICE1712_DELTA_CODEC_SERIAL_CLOCK 0x20
                                         /* AKM4524 serial clock */
                                         /* (writting on rising edge - 0->1 */
-                                        /* Delta66 and Delta44 */
 #define ICE1712_DELTA_CODEC_CHIP_A      0x40
 #define ICE1712_DELTA_CODEC_CHIP_B      0x80
                                         /* 1 - select chip A or B */
-                                        /* Delta66 and Delta44 */
-
-/* M-Audio Audiophile definitions */
+
+/* MidiMan M-Audio Delta44 */
 /* 0x01 = DFS */
-#define ICE1712_DELTA_AP_CCLK   0x02    /* AudioPhile only */
-                                        /* SPI clock */
+/* 0x10 = CODEC_SERIAL_DATA */
+/* 0x20 = CODEC_SERIAL_CLOCK */
+/* 0x40 = CODEC_CHIP_A */
+/* 0x80 = CODEC_CHIP_B */
+
+/* MidiMan M-Audio Audiophile definitions */
+/* 0x01 = DFS */
+#define ICE1712_DELTA_AP_CCLK   0x02    /* SPI clock */
                                         /* (clocking on rising edge - 0->1) */
-#define ICE1712_DELTA_AP_DIN    0x04    /* AudioPhile only - data input */
-#define ICE1712_DELTA_AP_DOUT   0x08    /* AudioPhile only - data output */
-#define ICE1712_DELTA_AP_CS_DIGITAL 0x10 /* AudioPhile only - CS8427 chip select */
+#define ICE1712_DELTA_AP_DIN    0x04    /* data input */
+#define ICE1712_DELTA_AP_DOUT   0x08    /* data output */
+#define ICE1712_DELTA_AP_CS_DIGITAL 0x10 /* CS8427 chip select */
                                         /* low signal = select */
-#define ICE1712_DELTA_AP_CS_CODEC 0x20  /* AudioPhile only - AK4528 chip select */
+#define ICE1712_DELTA_AP_CS_CODEC 0x20  /* AK4528 chip select */
                                         /* low signal = select */
 
@@ -353 +393 @@
 /* TerraTec EWS 88MT/D configuration definitions */
 /* RW, SDA snd SCLK are identical with EWX24/96 */
-
 #define ICE1712_EWS88_CS8414_RATE       0x07    /* CS8414 sample rate: gpio 0-2 */
 #define ICE1712_EWS88_RW                0x08    /* read/write switch for i2c; high = write  */
@@ -362 +401 @@
 
 /* i2c address */
-#define ICE1712_EWS88MT_CS8404_ADDR     0x40
-#define ICE1712_EWS88MT_INPUT_ADDR      0x46
-#define ICE1712_EWS88MT_OUTPUT_ADDR     0x48
+#define ICE1712_EWS88MT_CS8404_ADDR     (0x40>>1)
+#define ICE1712_EWS88MT_INPUT_ADDR      (0x46>>1)
+#define ICE1712_EWS88MT_OUTPUT_ADDR     (0x48>>1)
 #define ICE1712_EWS88MT_OUTPUT_SENSE    0x40    /* mask */
-#define ICE1712_EWS88D_PCF_ADDR         0x40
+#define ICE1712_EWS88D_PCF_ADDR         (0x40>>1)
+
+/* TerraTec DMX 6Fire configuration definitions */
+#define ICE1712_6FIRE_AK4524_CS_MASK    0x07    /* AK4524 chip select #1-#3 */
+#define ICE1712_6FIRE_RW                0x08    /* read/write switch for i2c; high = write  */
+#define ICE1712_6FIRE_SERIAL_DATA       0x10    /* i2c & ak4524 data */
+#define ICE1712_6FIRE_SERIAL_CLOCK      0x20    /* i2c & ak4524 clock */
+#define ICE1712_6FIRE_TX2               0x40    /* MIDI2 */
+#define ICE1712_6FIRE_RX2               0x80    /* MIDI2 */
+
+#define ICE1712_6FIRE_CS8427_ADDR       (0x22>>1) /* ?? */
 
 /*
@@ -381 +430 @@
 
 typedef struct _snd_ice1712 ice1712_t;
-
-typedef struct {
-        void (*write)(ice1712_t *ice, unsigned char reg, unsigned char data);
-        unsigned char (*read)(ice1712_t *ice, unsigned char reg);
-        void (*write_bytes)(ice1712_t *ice, unsigned char reg, int bytes, unsigned char *data);
-        void (*read_bytes)(ice1712_t *ice, unsigned char reg, int bytes, unsigned char *data);
-} ice1712_cs8427_ops_t;
 
 typedef struct {
@@ -453 +495 @@
 
         unsigned int pro_volumes[20];
-        int num_adcs;
-        int num_dacs;
+        int ak4528: 1,                  /* AK4524 or AK4528 */
+            omni: 1;                    /* Delta Omni I/O */
+        int num_adcs;                   /* AK4524 or AK4528 ADCs */
+        int num_dacs;                   /* AK4524 or AK4528 DACs */
+        int num_total_dacs;             /* total DACs */
         unsigned char ak4524_images[4][8];
+        unsigned char ak4524_ipga_gain[4][2];
         unsigned char hoontech_boxbits[4];
         unsigned int hoontech_config;
         unsigned short hoontech_boxconfig[4];
 
+        snd_i2c_bus_t *i2c;             /* I2C bus */
+        snd_i2c_device_t *cs8404;       /* CS8404A I2C device */
+        snd_i2c_device_t *cs8427;       /* CS8427 I2C device */
+        snd_i2c_device_t *pcf8574[2];   /* PCF8574 Output/Input (EWS88MT) */
+        snd_i2c_device_t *pcf8575;      /* PCF8575 (EWS88D) */
+        
         unsigned char cs8403_spdif_bits;
         unsigned char cs8403_spdif_stream_bits;
         snd_kcontrol_t *spdif_stream_ctl;
-
-        unsigned char cs8427_spdif_status[5];
-        unsigned char cs8427_spdif_stream_status[5];
-        ice1712_cs8427_ops_t *cs8427_ops;
 
         unsigned char gpio_direction, gpio_write_mask;
@@ -651 +699 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_mixer_digmix_route_ac97 = {
+static snd_kcontrol_new_t snd_ice1712_mixer_digmix_route_ac97 __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -670 +718 @@
 /*
  */
+
 static void snd_ice1712_delta_cs8403_spdif_write(ice1712_t *ice, unsigned char bits)
 {
@@ -694 +743 @@
 }
 
-static void snd_ice1712_decode_cs8403_spdif_bits(snd_aes_iec958_t *diga,
-                                                 unsigned char bits)
-{
-        if (bits & 0x01) {      /* consumer */
-                if (!(bits & 0x02))
-                        diga->status[0] |= IEC958_AES0_NONAUDIO;
-                if (!(bits & 0x08))
-                        diga->status[0] |= IEC958_AES0_CON_NOT_COPYRIGHT;
-                switch (bits & 0x10) {
-                case 0x10: diga->status[0] |= IEC958_AES0_CON_EMPHASIS_NONE; break;
-                case 0x00: diga->status[0] |= IEC958_AES0_CON_EMPHASIS_5015; break;
-                }
-                if (!(bits & 0x80))
-                        diga->status[1] |= IEC958_AES1_CON_ORIGINAL;
-                switch (bits & 0x60) {
-                case 0x00: diga->status[1] |= IEC958_AES1_CON_MAGNETIC_ID; break;
-                case 0x20: diga->status[1] |= IEC958_AES1_CON_DIGDIGCONV_ID; break;
-                case 0x40: diga->status[1] |= IEC958_AES1_CON_LASEROPT_ID; break;
-                case 0x60: diga->status[1] |= IEC958_AES1_CON_GENERAL; break;
-                }
-                switch (bits & 0x06) {
-                case 0x00: diga->status[3] |= IEC958_AES3_CON_FS_44100; break;
-                case 0x02: diga->status[3] |= IEC958_AES3_CON_FS_48000; break;
-                case 0x04: diga->status[3] |= IEC958_AES3_CON_FS_32000; break;
-                }
-        } else {
-                diga->status[0] = IEC958_AES0_PROFESSIONAL;
-                switch (bits & 0x18) {
-                case 0x00: diga->status[0] |= IEC958_AES0_PRO_FS_32000; break;
-                case 0x10: diga->status[0] |= IEC958_AES0_PRO_FS_44100; break;
-                case 0x08: diga->status[0] |= IEC958_AES0_PRO_FS_48000; break;
-                case 0x18: diga->status[0] |= IEC958_AES0_PRO_FS_NOTID; break;
-                }
-                switch (bits & 0x60) {
-                case 0x20: diga->status[0] |= IEC958_AES0_PRO_EMPHASIS_NONE; break;
-                case 0x40: diga->status[0] |= IEC958_AES0_PRO_EMPHASIS_5015; break;
-                case 0x00: diga->status[0] |= IEC958_AES0_PRO_EMPHASIS_CCITT; break;
-                case 0x60: diga->status[0] |= IEC958_AES0_PRO_EMPHASIS_NOTID; break;
-                }
-                if (bits & 0x80)
-                        diga->status[1] |= IEC958_AES1_PRO_MODE_STEREOPHONIC;
-        }
-}
-
-static unsigned char snd_ice1712_encode_cs8403_spdif_bits(snd_aes_iec958_t *diga)
-{
-        unsigned char bits;
-
-        if (!(diga->status[0] & IEC958_AES0_PROFESSIONAL)) {
-                bits = 0x01;    /* consumer mode */
-                if (diga->status[0] & IEC958_AES0_NONAUDIO)
-                        bits &= ~0x02;
-                else
-                        bits |= 0x02;
-                if (diga->status[0] & IEC958_AES0_CON_NOT_COPYRIGHT)
-                        bits &= ~0x08;
-                else
-                        bits |= 0x08;
-                switch (diga->status[0] & IEC958_AES0_CON_EMPHASIS) {
-                default:
-                case IEC958_AES0_CON_EMPHASIS_NONE: bits |= 0x10; break;
-                case IEC958_AES0_CON_EMPHASIS_5015: bits |= 0x00; break;
-                }
-                if (diga->status[1] & IEC958_AES1_CON_ORIGINAL)
-                        bits &= ~0x80;
-                else
-                        bits |= 0x80;
-                if ((diga->status[1] & IEC958_AES1_CON_CATEGORY) == IEC958_AES1_CON_GENERAL)
-                        bits |= 0x60;
-                else {
-                        switch(diga->status[1] & IEC958_AES1_CON_MAGNETIC_MASK) {
-                        case IEC958_AES1_CON_MAGNETIC_ID:
-                                bits |= 0x00; break;
-                        case IEC958_AES1_CON_DIGDIGCONV_ID:
-                                bits |= 0x20; break;
-                        default:
-                        case IEC958_AES1_CON_LASEROPT_ID:
-                                bits |= 0x40; break;
-                        }
-                }
-                switch (diga->status[3] & IEC958_AES3_CON_FS) {
-                default:
-                case IEC958_AES3_CON_FS_44100: bits |= 0x00; break;
-                case IEC958_AES3_CON_FS_48000: bits |= 0x02; break;
-                case IEC958_AES3_CON_FS_32000: bits |= 0x04; break;
-                }
-        } else {
-                bits = 0x00;    /* professional mode */
-                if (diga->status[0] & IEC958_AES0_NONAUDIO)
-                        bits &= ~0x02;
-                else
-                        bits |= 0x02;
-                /* CHECKME: I'm not sure about the bit order in val here */
-                switch (diga->status[0] & IEC958_AES0_PRO_FS) {
-                case IEC958_AES0_PRO_FS_32000:  bits |= 0x00; break;
-                case IEC958_AES0_PRO_FS_44100:  bits |= 0x10; break;    /* 44.1kHz */
-                case IEC958_AES0_PRO_FS_48000:  bits |= 0x08; break;    /* 48kHz */
-                default:
-                case IEC958_AES0_PRO_FS_NOTID: bits |= 0x18; break;
-                }
-                switch (diga->status[0] & IEC958_AES0_PRO_EMPHASIS) {
-                case IEC958_AES0_PRO_EMPHASIS_NONE: bits |= 0x20; break;
-                case IEC958_AES0_PRO_EMPHASIS_5015: bits |= 0x40; break;
-                case IEC958_AES0_PRO_EMPHASIS_CCITT: bits |= 0x00; break;
-                default:
-                case IEC958_AES0_PRO_EMPHASIS_NOTID: bits |= 0x60; break;
-                }
-                switch (diga->status[1] & IEC958_AES1_PRO_MODE) {
-                case IEC958_AES1_PRO_MODE_TWO:
-                case IEC958_AES1_PRO_MODE_STEREOPHONIC: bits |= 0x00; break;
-                default: bits |= 0x80; break;
-                }
-        }
-        return bits;
-}
-
 
 /*
@@ -841 +774 @@
 
 /*
- * CS8427 via SPI mode (for Audiophile)
+ * CS8427 via SPI mode (for Audiophile), emulated I2C
  */
 
@@ -899 +832 @@
 }
 
-/* write a register */
-static void snd_ice1712_ap_cs8427_write(ice1712_t *ice, unsigned char reg, unsigned char data)
-{
+/* sequential write */
+static int ap_cs8427_sendbytes(snd_i2c_device_t *device, unsigned char *bytes, int count)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, device->bus->private_data, return -EIO);
+        int res = count;
         unsigned char tmp;
+
         down(&ice->gpio_mutex);
         tmp = ap_cs8427_codec_select(ice);
-        ap_cs8427_write_byte(ice, 0x20, tmp); /* address + write mode */
-        ap_cs8427_write_byte(ice, reg, tmp);
-        ap_cs8427_write_byte(ice, data, tmp);
+        ap_cs8427_write_byte(ice, (device->addr << 1) | 0, tmp); /* address + write mode */
+        while (count-- > 0)
+                ap_cs8427_write_byte(ice, *bytes++, tmp);
         ap_cs8427_codec_deassert(ice, tmp);
         up(&ice->gpio_mutex);
-}
-
-/* read a register */
-static unsigned char snd_ice1712_ap_cs8427_read(ice1712_t *ice, unsigned char reg)
-{
-        unsigned char tmp, data;
+        return res;
+}
+
+/* sequential read */
+static int ap_cs8427_readbytes(snd_i2c_device_t *device, unsigned char *bytes, int count)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, device->bus->private_data, return -EIO);
+        int res = count;
+        unsigned char tmp;
 
         down(&ice->gpio_mutex);
         tmp = ap_cs8427_codec_select(ice);
-        ap_cs8427_write_byte(ice, 0x20, tmp); /* address + write mode */
-        ap_cs8427_write_byte(ice, reg, tmp);
-        ap_cs8427_codec_deassert(ice, tmp);
-        udelay(5);
-        tmp = ap_cs8427_codec_select(ice);
-        ap_cs8427_write_byte(ice, 0x21, tmp); /* address + read mode */
-        data = ap_cs8427_read_byte(ice, tmp);
+        ap_cs8427_write_byte(ice, (device->addr << 1) | 1, tmp); /* address + read mode */
+        while (count-- > 0)
+                *bytes++ = ap_cs8427_read_byte(ice, tmp);
         ap_cs8427_codec_deassert(ice, tmp);
         up(&ice->gpio_mutex);
-        return data;
-}
-
-/* sequential write */
-static void snd_ice1712_ap_cs8427_write_bytes(ice1712_t *ice, unsigned char reg, int bytes, unsigned char *data)
-{
-#if 1
-        unsigned char tmp;
-        down(&ice->gpio_mutex);
-        tmp = ap_cs8427_codec_select(ice);
-        ap_cs8427_write_byte(ice, 0x20, tmp); /* address + write mode */
-        ap_cs8427_write_byte(ice, reg | 0x80, tmp); /* incremental mode */
-        while (bytes-- > 0)
-                ap_cs8427_write_byte(ice, *data++, tmp);
-        ap_cs8427_codec_deassert(ice, tmp);
-        up(&ice->gpio_mutex);
-#else
-        while (bytes-- > 0)
-                snd_ice1712_ap_cs8427_write(ice, reg++, *data++);
-#endif
-}
-
-/* sequential read */
-static void snd_ice1712_ap_cs8427_read_bytes(ice1712_t *ice, unsigned char reg, int bytes, unsigned char *data)
-{
-#if 0 // is this working?  -- ti
-        unsigned char tmp;
-        
-        down(&ice->gpio_mutex);
-        tmp = ap_cs8427_codec_select(ice);
-        ap_cs8427_write_byte(ice, 0x20, tmp); /* address + write mode */
-        ap_cs8427_write_byte(ice, reg | 0x80, tmp); /* incremental mode */
-        ap_cs8427_codec_deassert(ice, tmp);
-        udelay(5);
-        tmp = ap_cs8427_codec_select(ice);
-        ap_cs8427_write_byte(ice, 0x21, tmp); /* address + read mode */
-        while (bytes-- > 0)
-                *data++ = ap_cs8427_read_byte(ice, tmp);
-        ap_cs8427_codec_deassert(ice, tmp);
-        up(&ice->gpio_mutex);
-#else
-        while (bytes-- > 0)
-                *data++ = snd_ice1712_ap_cs8427_read(ice, reg++); 
-#endif
+        return res;
+}
+
+static int ap_cs8427_probeaddr(snd_i2c_bus_t *bus, unsigned short addr)
+{
+        if (addr == 0x10)
+                return 1;
+        return -ENOENT;
 }
 
 #ifdef TARGET_OS2
 static ice1712_cs8427_ops_t snd_ice1712_ap_cs8427_ops = {
-        snd_ice1712_ap_cs8427_write,
-        snd_ice1712_ap_cs8427_read,
-        snd_ice1712_ap_cs8427_write_bytes,
-        snd_ice1712_ap_cs8427_read_bytes
+        ap_cs8427_sendbytes,
+        ap_cs8427_readbytes,
+        ap_cs8427_probeaddr,
 };
 #else
-static ice1712_cs8427_ops_t snd_ice1712_ap_cs8427_ops = {
-        write: snd_ice1712_ap_cs8427_write,
-        read: snd_ice1712_ap_cs8427_read,
-        write_bytes: snd_ice1712_ap_cs8427_write_bytes,
-        read_bytes: snd_ice1712_ap_cs8427_read_bytes,
+static snd_i2c_ops_t ap_cs8427_i2c_ops = {
+        sendbytes: ap_cs8427_sendbytes,
+        readbytes: ap_cs8427_readbytes,
+        probeaddr: ap_cs8427_probeaddr,
 };
 #endif
-
 
 /*
@@ -996 +892 @@
 
 /* send SDA and SCL */
-static void ewx_i2c_set(ice1712_t *ice, int clk, int data)
-{
+static void ewx_i2c_setlines(snd_i2c_bus_t *bus, int clk, int data)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, bus->private_data, return);
         unsigned char tmp = 0;
         if (clk)
@@ -1007 +904 @@
 }
 
-/* send one bit */
-static void ewx_i2c_send(ice1712_t *ice, int data)
-{
-        ewx_i2c_set(ice, 0, data);
-        ewx_i2c_set(ice, 1, data);
-        ewx_i2c_set(ice, 0, data);
-}
-
-/* start i2c */
-static void ewx_i2c_start(ice1712_t *ice)
-{
-        ewx_i2c_set(ice, 0, 1);
-        ewx_i2c_set(ice, 1, 1);
-        ewx_i2c_set(ice, 1, 0);
-        ewx_i2c_set(ice, 0, 0);
-}
-
-/* stop i2c */
-static void ewx_i2c_stop(ice1712_t *ice)
-{
-        ewx_i2c_set(ice, 0, 0);
-        ewx_i2c_set(ice, 1, 0);
-        ewx_i2c_set(ice, 1, 1);
-}
-
-/* send a byte and get ack */
-static void ewx_i2c_write(ice1712_t *ice, unsigned char val)
-{
-        int i;
-        for (i = 7; i >= 0; i--)
-                ewx_i2c_send(ice, val & (1 << i));
-        ewx_i2c_send(ice, 1); /* ack */
-}
-
-/* prepare for write and send i2c_start */
-static void ewx_i2c_write_prepare(ice1712_t *ice)
-{
-        /* set RW high */
-        unsigned char mask = ICE1712_EWX2496_RW;
-        if (ice->eeprom.subvendor == ICE1712_SUBDEVICE_EWX2496)
-                mask |= ICE1712_EWX2496_AK4524_CS; /* CS high also */
-        snd_ice1712_gpio_write_bits(ice, mask, mask);
-        /* set direction both SDA and SCL write */
-        ice->gpio_direction |= ICE1712_EWX2496_SERIAL_CLOCK|ICE1712_EWX2496_SERIAL_DATA;
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->gpio_direction);
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~(ICE1712_EWX2496_SERIAL_CLOCK|ICE1712_EWX2496_SERIAL_DATA));
-                          
-        ewx_i2c_start(ice);
-}
-
-/* read a bit from serial data;
-   this changes write mask
-   SDA direction must be set to low
-*/
-static int ewx_i2c_read_bit(ice1712_t *ice)
-{
-        int data;
+static int ewx_i2c_getclock(snd_i2c_bus_t *bus)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, bus->private_data, return -EIO);
+        return snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ICE1712_EWX2496_SERIAL_CLOCK ? 1 : 0;
+}
+
+static int ewx_i2c_getdata(snd_i2c_bus_t *bus, int ack)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, bus->private_data, return -EIO);
+        int bit;
         /* set RW pin to low */
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~ICE1712_EWX2496_RW);
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, 0);
-        data = (snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ICE1712_EWX2496_SERIAL_DATA) ? 1 : 0;
+        if (ack)
+                udelay(5);
+        bit = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ICE1712_EWX2496_SERIAL_DATA ? 1 : 0;
         /* set RW pin to high */
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, ICE1712_EWX2496_RW);
-        return data;
-}
-
-static void ewx_i2c_read_prepare(ice1712_t *ice)
-{
-        /* set SCL - write, SDA - read */
-        ice->gpio_direction |= ICE1712_EWX2496_SERIAL_CLOCK;
-        ice->gpio_direction &= ~ICE1712_EWX2496_SERIAL_DATA;
+        /* reset write mask */
+        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~ICE1712_EWX2496_SERIAL_CLOCK);
+        return bit;
+}
+
+static void ewx_i2c_start(snd_i2c_bus_t *bus)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, bus->private_data, return);
+        unsigned char mask;
+
+        save_gpio_status(ice, (unsigned char *)&bus->private_value);
+        /* set RW high */
+        mask = ICE1712_EWX2496_RW;
+        switch (ice->eeprom.subvendor) {
+        case ICE1712_SUBDEVICE_EWX2496:
+                mask |= ICE1712_EWX2496_AK4524_CS; /* CS high also */
+                break;
+        case ICE1712_SUBDEVICE_DMX6FIRE:
+                mask |= ICE1712_6FIRE_AK4524_CS_MASK; /* CS high also */
+                break;
+        }
+        snd_ice1712_gpio_write_bits(ice, mask, mask);
+}
+
+static void ewx_i2c_stop(snd_i2c_bus_t *bus)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, bus->private_data, return);
+        restore_gpio_status(ice, (unsigned char *)&bus->private_value);
+}
+
+static void ewx_i2c_direction(snd_i2c_bus_t *bus, int clock, int data)
+{
+        ice1712_t *ice = snd_magic_cast(ice1712_t, bus->private_data, return);
+        unsigned char mask = 0;
+
+        if (clock)
+                mask |= ICE1712_EWX2496_SERIAL_CLOCK; /* write SCL */
+        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);
-        /* set write mask only to SCL */
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~ICE1712_EWX2496_SERIAL_CLOCK);
-}
-
-static void ewx_i2c_read_post(ice1712_t *ice)
-{
-        /* reset direction both SDA and SCL to write */
-        ice->gpio_direction |= ICE1712_EWX2496_SERIAL_CLOCK|ICE1712_EWX2496_SERIAL_DATA;
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION, ice->gpio_direction);
-        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~(ICE1712_EWX2496_SERIAL_CLOCK|ICE1712_EWX2496_SERIAL_DATA));
-}
-
-/* read a byte (and ack bit) */
-static unsigned char ewx_i2c_read(ice1712_t *ice)
-{
-        int i;
-        unsigned char data = 0;
-
-        for (i = 7; i >= 0; i--) {
-                ewx_i2c_set(ice, 1, 0);
-                data |= ewx_i2c_read_bit(ice) << i;
-                /* reset write mask */
-                snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK,
-                                  ~ICE1712_EWX2496_SERIAL_CLOCK);
-                ewx_i2c_set(ice, 0, 0);
-        }
-        /* reset write mask */
-        ewx_i2c_read_post(ice);
-        ewx_i2c_send(ice, 1); /* ack */
-        return data;
-}
-
-
-/*
- * CS8427 on EWX 24/96; Address 0x20
- */
-/* write a register */
-static void snd_ice1712_ewx_cs8427_write(ice1712_t *ice, unsigned char reg, unsigned char data)
-{
-        unsigned char saved[2];
-
-        save_gpio_status(ice, saved);
-        ewx_i2c_write_prepare(ice);
-        ewx_i2c_write(ice, 0x20);  /* address + write */
-        ewx_i2c_write(ice, reg); /* MAP */
-        ewx_i2c_write(ice, data);
-        ewx_i2c_stop(ice);
-        restore_gpio_status(ice, saved);
-}
-
-/* sequential write */
-static void snd_ice1712_ewx_cs8427_write_bytes(ice1712_t *ice, unsigned char reg, int bytes, unsigned char *data)
-{
-        unsigned char saved[2];
-
-        save_gpio_status(ice, saved);
-        ewx_i2c_write_prepare(ice);
-        ewx_i2c_write(ice, 0x20);  /* address + write */
-        ewx_i2c_write(ice, reg | 0x80); /* MAP incremental mode */
-        while (bytes-- > 0)
-                ewx_i2c_write(ice, *data++);
-        ewx_i2c_stop(ice);
-        restore_gpio_status(ice, saved);
-}
-
-/* read a register */
-static unsigned char snd_ice1712_ewx_cs8427_read(ice1712_t *ice, unsigned char reg)
-{
-        unsigned char saved[2];
-        unsigned char data;
-
-        save_gpio_status(ice, saved);
-        ewx_i2c_write_prepare(ice);
-        ewx_i2c_write(ice, 0x20);  /* address + write */
-        ewx_i2c_write(ice, reg); /* MAP */
-        /* we set up the address first but without data */
-        ewx_i2c_stop(ice);
-
-        /* now read */
-        ewx_i2c_start(ice);
-        ewx_i2c_write(ice, 0x21);  /* address + read */
-        ewx_i2c_read_prepare(ice);
-        data = ewx_i2c_read(ice);
-        ewx_i2c_read_post(ice);
-        ewx_i2c_stop(ice);
-
-        restore_gpio_status(ice, saved);
-        return data;
-}
-
-/* sequential read  */
-static void snd_ice1712_ewx_cs8427_read_bytes(ice1712_t *ice, unsigned char reg, int bytes, unsigned char *data)
-{
-#if 0 // the sequential read seems not working (yet)..
-        unsigned char saved[2];
-
-        save_gpio_status(ice, saved);
-        ewx_i2c_write_prepare(ice);
-        ewx_i2c_write(ice, 0x20);  /* address + write */
-        ewx_i2c_write(ice, reg | 0x80); /* MAP incremental mode */
-        /* we set up the address first but without data */
-        ewx_i2c_stop(ice);
-
-        /* now read */
-        ewx_i2c_start(ice);
-        ewx_i2c_write(ice, 0x21);  /* address + read */
-        ewx_i2c_read_prepare(ice);
-        while (bytes-- > 0)
-                *data++ = ewx_i2c_read(ice);
-        ewx_i2c_read_post(ice);
-        ewx_i2c_stop(ice);
-        restore_gpio_status(ice, saved);
-#else
-        while (bytes-- > 0)
-                *data++ = snd_ice1712_ewx_cs8427_read(ice, reg++); 
-#endif
+        snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK, ~mask);
 }
 
 #ifdef TARGET_OS2
-static ice1712_cs8427_ops_t snd_ice1712_ewx_cs8427_ops = {
-        snd_ice1712_ewx_cs8427_write,
-        snd_ice1712_ewx_cs8427_read,
-        snd_ice1712_ewx_cs8427_write_bytes,
-        snd_ice1712_ewx_cs8427_read_bytes,
+static snd_i2c_bit_ops_t snd_ice1712_ewx_cs8427_bit_ops = {
+        ewx_i2c_start,
+        ewx_i2c_stop,
+        ewx_i2c_direction,
+        ewx_i2c_setlines,
+        ewx_i2c_getclock,
+        ewx_i2c_getdata,
 };
 #else
-static ice1712_cs8427_ops_t snd_ice1712_ewx_cs8427_ops = {
-        write: snd_ice1712_ewx_cs8427_write,
-        read: snd_ice1712_ewx_cs8427_read,
-        write_bytes: snd_ice1712_ewx_cs8427_write_bytes,
-        read_bytes: snd_ice1712_ewx_cs8427_read_bytes,
+static snd_i2c_bit_ops_t snd_ice1712_ewx_cs8427_bit_ops = {
+        start: ewx_i2c_start,
+        stop: ewx_i2c_stop,
+        direction: ewx_i2c_direction,
+        setlines: ewx_i2c_setlines,
+        getclock: ewx_i2c_getclock,
+        getdata: ewx_i2c_getdata,
 };
 #endif
 
-/*
- * PCF8574 on EWS88MT
- */
-static void snd_ice1712_ews88mt_pcf8574_write(ice1712_t *ice, unsigned char addr, unsigned char data)
-{
-        ewx_i2c_write_prepare(ice);
-        ewx_i2c_write(ice, addr); /* address + write */
-        ewx_i2c_write(ice, data);
-        ewx_i2c_stop(ice);
-}
-
-static unsigned char snd_ice1712_ews88mt_pcf8574_read(ice1712_t *ice, unsigned char addr)
-{
-        unsigned char data;
-        ewx_i2c_write_prepare(ice);
-        ewx_i2c_write(ice, addr | 0x01);  /* address + read */
-        ewx_i2c_read_prepare(ice);
-        data = ewx_i2c_read(ice);
-        ewx_i2c_read_post(ice);
-        ewx_i2c_stop(ice);
-        return data;
-}
-
 /* AK4524 chip select; address 0x48 bit 0-3 */
 static void snd_ice1712_ews88mt_chip_select(ice1712_t *ice, int chip_mask)
@@ -1242 +993 @@
 
         snd_assert(chip_mask >= 0 && chip_mask <= 0x0f, return);
-        data = snd_ice1712_ews88mt_pcf8574_read(ice, ICE1712_EWS88MT_OUTPUT_ADDR);
+        snd_i2c_lock(ice->i2c);
+        snd_runtime_check(snd_i2c_readbytes(ice->pcf8574[1], &data, 1) == 1, snd_i2c_unlock(ice->i2c); return);
         ndata = (data & 0xf0) | chip_mask;
         if (ndata != data)
-                snd_ice1712_ews88mt_pcf8574_write(ice, ICE1712_EWS88MT_OUTPUT_ADDR, ndata);
-}
-
-
-/*
- * PCF8575 on EWS88D (16bit)
- */
-static void snd_ice1712_ews88d_pcf8575_write(ice1712_t *ice, unsigned char addr, unsigned short data)
-{
-        ewx_i2c_write_prepare(ice);
-        ewx_i2c_write(ice, addr); /* address + write */
-        ewx_i2c_write(ice, data & 0xff);
-        ewx_i2c_write(ice, (data >> 8) & 0xff);
-        ewx_i2c_stop(ice);
-}
-
-static unsigned short snd_ice1712_ews88d_pcf8575_read(ice1712_t *ice, unsigned char addr)
-{
-        unsigned short data;
-        ewx_i2c_write_prepare(ice);
-        ewx_i2c_write(ice, addr | 0x01);  /* address + read */
-        ewx_i2c_read_prepare(ice);
-        data = ewx_i2c_read(ice);
-        data |= (unsigned short)ewx_i2c_read(ice) << 8;
-        //printk("pcf: read = 0x%x\n", data);
-        ewx_i2c_read_post(ice);
-        ewx_i2c_stop(ice);
-        return data;
+                snd_runtime_check(snd_i2c_sendbytes(ice->pcf8574[1], &ndata, 1) == 1, snd_i2c_unlock(ice->i2c); return);
+        snd_i2c_unlock(ice->i2c);
 }
 
@@ -1286 +1012 @@
         unsigned int addrdata;
 
-        snd_assert(chip >=0 && chip < 4, return);
+        snd_assert(chip >= 0 && chip < 4, return);
+
         if (ice->eeprom.subvendor == ICE1712_SUBDEVICE_EWS88MT) {
                 /* assert AK4524 CS */
@@ -1327 +1054 @@
                                   ~(data_mask | clk_mask |
                                     codecs_mask | ICE1712_EWS88_RW));
+                cif = 1; /* CIF high */
+                break;
+        case ICE1712_SUBDEVICE_DMX6FIRE:
+                data_mask = ICE1712_6FIRE_SERIAL_DATA;
+                clk_mask = ICE1712_6FIRE_SERIAL_CLOCK;
+                codecs_mask = (1 << chip) & ICE1712_6FIRE_AK4524_CS_MASK;
+                tmp |= ICE1712_6FIRE_RW; /* set rw bit high */
+                snd_ice1712_write(ice, ICE1712_IREG_GPIO_DIRECTION,
+                                  ice->gpio_direction | data_mask | clk_mask |
+                                  codecs_mask | ICE1712_6FIRE_RW);
+                snd_ice1712_write(ice, ICE1712_IREG_GPIO_WRITE_MASK,
+                                  ~(data_mask | clk_mask |
+                                    codecs_mask | ICE1712_6FIRE_RW));
                 cif = 1; /* CIF high */
                 break;
@@ -1360 +1100 @@
 
         if (ice->eeprom.subvendor == ICE1712_SUBDEVICE_EWS88MT) {
+                restore_gpio_status(ice, saved);
                 //snd_ice1712_ews88mt_chip_select(ice, ~(1 << chip) & 0x0f);
                 udelay(1);
@@ -1373 +1114 @@
                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
                 udelay(1);
-        }
-
+                restore_gpio_status(ice, saved);
+        }
+
+        if ((addr != 0x04 && addr != 0x05) || (data & 0x80) == 0)
         ice->ak4524_images[chip][addr] = data;
-        restore_gpio_status(ice, saved);
-}
-
-
-/*
- * decode/encode channel status bits from CS8404A on EWS88MT&D
- */
-static void snd_ice1712_ews_decode_cs8404_spdif_bits(snd_aes_iec958_t *diga,
-                                                     unsigned char bits)
-{
-        if (bits & 0x10) {      /* consumer */
-                if (!(bits & 0x20))
-                        diga->status[0] |= IEC958_AES0_CON_NOT_COPYRIGHT;
-                if (!(bits & 0x40))
-                        diga->status[0] |= IEC958_AES0_CON_EMPHASIS_5015;
-                if (!(bits & 0x80))
-                        diga->status[1] |= IEC958_AES1_CON_ORIGINAL;
-                switch (bits & 0x03) {
-                case 0x00: diga->status[1] |= IEC958_AES1_CON_DAT; break;
-                case 0x03: diga->status[1] |= IEC958_AES1_CON_GENERAL; break;
-                }
-                switch (bits & 0x06) {
-                case 0x02: diga->status[3] |= IEC958_AES3_CON_FS_32000; break;
-                case 0x04: diga->status[3] |= IEC958_AES3_CON_FS_48000; break;
-                case 0x06: diga->status[3] |= IEC958_AES3_CON_FS_44100; break;
-                }
-        } else {
-                diga->status[0] = IEC958_AES0_PROFESSIONAL;
-                if (!(bits & 0x04))
-                        diga->status[0] |= IEC958_AES0_NONAUDIO;
-                switch (bits & 0x60) {
-                case 0x00: diga->status[0] |= IEC958_AES0_PRO_FS_32000; break;
-                case 0x40: diga->status[0] |= IEC958_AES0_PRO_FS_44100; break;
-                case 0x20: diga->status[0] |= IEC958_AES0_PRO_FS_48000; break;
-                case 0x60: diga->status[0] |= IEC958_AES0_PRO_FS_NOTID; break;
-                }
-                switch (bits & 0x03) {
-                case 0x02: diga->status[0] |= IEC958_AES0_PRO_EMPHASIS_NONE; break;
-                case 0x01: diga->status[0] |= IEC958_AES0_PRO_EMPHASIS_5015; break;
-                case 0x00: diga->status[0] |= IEC958_AES0_PRO_EMPHASIS_CCITT; break;
-                case 0x03: diga->status[0] |= IEC958_AES0_PRO_EMPHASIS_NOTID; break;
-                }
-                if (!(bits & 0x80))
-                        diga->status[1] |= IEC958_AES1_PRO_MODE_STEREOPHONIC;
-        }
-}
-
-static unsigned char snd_ice1712_ews_encode_cs8404_spdif_bits(snd_aes_iec958_t *diga)
-{
-        unsigned char bits;
-
-        if (!(diga->status[0] & IEC958_AES0_PROFESSIONAL)) {
-                bits = 0x10;    /* consumer mode */
-                if (!(diga->status[0] & IEC958_AES0_CON_NOT_COPYRIGHT))
-                        bits |= 0x20;
-                if ((diga->status[0] & IEC958_AES0_CON_EMPHASIS) == IEC958_AES0_CON_EMPHASIS_NONE)
-                        bits |= 0x40;
-                if (!(diga->status[1] & IEC958_AES1_CON_ORIGINAL))
-                        bits |= 0x80;
-                if ((diga->status[1] & IEC958_AES1_CON_CATEGORY) == IEC958_AES1_CON_GENERAL)
-                        bits |= 0x03;
-                switch (diga->status[3] & IEC958_AES3_CON_FS) {
-                default:
-                case IEC958_AES3_CON_FS_44100: bits |= 0x06; break;
-                case IEC958_AES3_CON_FS_48000: bits |= 0x04; break;
-                case IEC958_AES3_CON_FS_32000: bits |= 0x02; break;
-                }
-        } else {
-                bits = 0x00;    /* professional mode */
-                if (!(diga->status[0] & IEC958_AES0_NONAUDIO))
-                        bits |= 0x04;
-                switch (diga->status[0] & IEC958_AES0_PRO_FS) {
-                case IEC958_AES0_PRO_FS_32000:  bits |= 0x00; break;
-                case IEC958_AES0_PRO_FS_44100:  bits |= 0x40; break;    /* 44.1kHz */
-                case IEC958_AES0_PRO_FS_48000:  bits |= 0x20; break;    /* 48kHz */
-                default:
-                case IEC958_AES0_PRO_FS_NOTID:  bits |= 0x00; break;
-                }
-                switch (diga->status[0] & IEC958_AES0_PRO_EMPHASIS) {
-                case IEC958_AES0_PRO_EMPHASIS_NONE: bits |= 0x02; break;
-                case IEC958_AES0_PRO_EMPHASIS_5015: bits |= 0x01; break;
-                case IEC958_AES0_PRO_EMPHASIS_CCITT: bits |= 0x00; break;
-                default:
-                case IEC958_AES0_PRO_EMPHASIS_NOTID: bits |= 0x03; break;
-                }
-                switch (diga->status[1] & IEC958_AES1_PRO_MODE) {
-                case IEC958_AES1_PRO_MODE_TWO:
-                case IEC958_AES1_PRO_MODE_STEREOPHONIC: bits |= 0x00; break;
-                default: bits |= 0x80; break;
-                }
-        }
-        return bits;
-}
-
-/* write on i2c address 0x40 */
+        else
+                ice->ak4524_ipga_gain[chip][addr-4] = data;
+}
+
+static void snd_ice1712_ak4524_reset(ice1712_t *ice, int state)
+{
+        int chip;
+        unsigned char reg;
+        
+        for (chip = 0; chip < ice->num_dacs/2; chip++) {
+                snd_ice1712_ak4524_write(ice, chip, 0x01, state ? 0x00 : 0x03);
+                if (state)
+                        continue;
+                for (reg = 0x04; reg < (ice->ak4528 ? 0x06 : 0x08); reg++)
+                        snd_ice1712_ak4524_write(ice, chip, reg, ice->ak4524_images[chip][reg]);
+                if (ice->ak4528)
+                        continue;
+                for (reg = 0x04; reg < 0x06; reg++)
+                        snd_ice1712_ak4524_write(ice, chip, reg, ice->ak4524_ipga_gain[chip][reg-4]);
+        }
+}
+
 static void snd_ice1712_ews_cs8404_spdif_write(ice1712_t *ice, unsigned char bits)
 {
-        unsigned short val, nval;
-
+        unsigned char bytes[2];
+
+        snd_i2c_lock(ice->i2c);
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_EWS88MT:
-                snd_ice1712_ews88mt_pcf8574_write(ice, ICE1712_EWS88MT_CS8404_ADDR, bits);
+                snd_runtime_check(snd_i2c_sendbytes(ice->cs8404, &bits, 1) == 1, snd_i2c_unlock(ice->i2c); return);
                 break;
         case ICE1712_SUBDEVICE_EWS88D:
-                val = snd_ice1712_ews88d_pcf8575_read(ice, ICE1712_EWS88D_PCF_ADDR);
-                nval = val & 0xff;
-                nval |= bits << 8;
-                if (val != nval)
-                        snd_ice1712_ews88d_pcf8575_write(ice, ICE1712_EWS88D_PCF_ADDR, nval);
-                break;
-        }
+                snd_runtime_check(snd_i2c_readbytes(ice->pcf8575, bytes, 2) == 2, snd_i2c_unlock(ice->i2c); return);
+                if (bits != bytes[1]) {
+                        bytes[1] = bits;
+                        snd_runtime_check(snd_i2c_readbytes(ice->pcf8575, bytes, 2) == 2, snd_i2c_unlock(ice->i2c); return);
+                }
+                break;
+        }
+        snd_i2c_unlock(ice->i2c);
 }
 
@@ -1496 +1168 @@
 static int snd_ice1712_cs8427_set_input_clock(ice1712_t *ice, int spdif_clock)
 {
+        unsigned char reg[2] = { 0x80 | 4, 0 };   /* CS8427 auto increment | register number 4 + data */
         unsigned char val, nval;
-        val = ice->cs8427_ops->read(ice, 4);
+        snd_i2c_lock(ice->i2c);
+        if (snd_i2c_sendbytes(ice->cs8427, reg, 1) != 1) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
+        if (snd_i2c_readbytes(ice->cs8427, &val, 1) != 1) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
         nval = val & 0xf0;
         if (spdif_clock)
@@ -1504 +1185 @@
                 nval |= 0x04;
         if (val != nval) {
-                ice->cs8427_ops->write(ice, 4, nval);
+                if (snd_i2c_sendbytes(ice->cs8427, reg, 2) != 2) {
+                        snd_i2c_unlock(ice->i2c);
+                        return -EREMOTE;
+                }
                 return 1;
         }
-        return 0;
-}
-
-#if 0 // we change clock selection automatically according to the ice1712 clock source
-static int snd_ice1712_cs8427_clock_select_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
-        uinfo->count = 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = 1;
-        return 0;
-}
-
-static int snd_ice1712_cs8427_clock_select_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int val;
-        val = ice->cs8427_ops->read(ice, 4);
-        ucontrol->value.integer.value[0] = (val & 0x01) ? 1 : 0;
-        return 0;
-}
-
-static int snd_ice1712_cs8427_clock_select_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        return snd_ice1712_cs8427_set_input_clock(ice, ucontrol->value.integer.value[0]);
-}
-
-static snd_kcontrol_new_t snd_ice1712_cs8427_clock_select = {
-        iface: SNDRV_CTL_ELEM_IFACE_MIXER,
-        name: "CS8427 Clock Select",
-        info: snd_ice1712_cs8427_clock_select_info,
-        get: snd_ice1712_cs8427_clock_select_get,
-        put: snd_ice1712_cs8427_clock_select_put,
-};
-#endif
-
-
-/*
- */
-static int snd_ice1712_cs8427_in_status_info(snd_kcontrol_t *kcontrol,
-                                             snd_ctl_elem_info_t *uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-        uinfo->count = 1;
-        uinfo->value.integer.min = 0;
-        uinfo->value.integer.max = 255;
-        return 0;
-}
-
-static int snd_ice1712_cs8427_in_status_get(snd_kcontrol_t *kcontrol,
-                                            snd_ctl_elem_value_t *ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        ucontrol->value.integer.value[0] = ice->cs8427_ops->read(ice, 15);
-        return 0;
-}
-
-static snd_kcontrol_new_t snd_ice1712_cs8427_in_status = {
-#ifdef TARGET_OS2
-        SNDRV_CTL_ELEM_IFACE_PCM,0,0,
-        "IEC958 Input Status",0,
-        SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
-        snd_ice1712_cs8427_in_status_info,
-        snd_ice1712_cs8427_in_status_get,0,0
-#else
-        iface: SNDRV_CTL_ELEM_IFACE_PCM,
-        info: snd_ice1712_cs8427_in_status_info,
-        name: "IEC958 Input Status",
-        access: SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
-        get: snd_ice1712_cs8427_in_status_get,
-#endif
-};
-
+        snd_i2c_unlock(ice->i2c);
+        return 0;
+}
 
 /*
@@ -1624 +1237 @@
         case ICE1712_SUBDEVICE_DELTA44:
         case ICE1712_SUBDEVICE_AUDIOPHILE:
-                /* FIXME: we should put AK452x codecs to reset state
-                   when this bit is being changed */
                 spin_unlock_irqrestore(&ice->reg_lock, flags);
+                snd_ice1712_ak4524_reset(ice, 1);
                 down(&ice->gpio_mutex);
                 tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
@@ -1636 +1248 @@
                 snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
                 up(&ice->gpio_mutex);
+                snd_ice1712_ak4524_reset(ice, 0);
                 return;
         }
@@ -2197 +1810 @@
 #endif
 
-static void __exit snd_ice1712_pcm_free(snd_pcm_t *pcm)
+static void snd_ice1712_pcm_free(snd_pcm_t *pcm)
 {
         ice1712_t *ice = snd_magic_cast(ice1712_t, pcm->private_data, return);
@@ -2204 +1817 @@
 }
 
-static int __init snd_ice1712_pcm(ice1712_t * ice, int device, snd_pcm_t ** rpcm)
+static int __devinit snd_ice1712_pcm(ice1712_t * ice, int device, snd_pcm_t ** rpcm)
 {
         snd_pcm_t *pcm;
@@ -2229 +1842 @@
                 *rpcm = pcm;
 
-        printk("Consumer PCM code does not work well at the moment --jk\n");
-
-        return 0;
-}
-
-static void __exit snd_ice1712_pcm_free_ds(snd_pcm_t *pcm)
+        printk(KERN_WARNING "Consumer PCM code does not work well at the moment --jk\n");
+
+        return 0;
+}
+
+static void snd_ice1712_pcm_free_ds(snd_pcm_t *pcm)
 {
         ice1712_t *ice = snd_magic_cast(ice1712_t, pcm->private_data, return);
@@ -2241 +1854 @@
 }
 
-static int __init snd_ice1712_pcm_ds(ice1712_t * ice, int device, snd_pcm_t ** rpcm)
+static int __devinit snd_ice1712_pcm_ds(ice1712_t * ice, int device, snd_pcm_t ** rpcm)
 {
         snd_pcm_t *pcm;
@@ -2384 +1997 @@
 }
 
-static void snd_ice1712_cs8427_set_status(ice1712_t *ice, snd_pcm_runtime_t *runtime,
-                                          unsigned char *status)
-{
-        if (status[0] & IEC958_AES0_PROFESSIONAL) {
-                status[0] &= ~IEC958_AES0_PRO_FS;
-                switch (runtime->rate) {
-                case 32000: status[0] |= IEC958_AES0_PRO_FS_32000; break;
-                case 44100: status[0] |= IEC958_AES0_PRO_FS_44100; break;
-                case 48000: status[0] |= IEC958_AES0_PRO_FS_48000; break;
-                default: status[0] |= IEC958_AES0_PRO_FS_NOTID; break;
-                }
-        } else {
-                status[3] &= ~IEC958_AES3_CON_FS;
-                switch (runtime->rate) {
-                case 32000: status[3] |= IEC958_AES3_CON_FS_32000; break;
-                case 44100: status[3] |= IEC958_AES3_CON_FS_44100; break;
-                case 48000: status[3] |= IEC958_AES3_CON_FS_48000; break;
-                }
-        }
-}
-
 static int snd_ice1712_playback_pro_prepare(snd_pcm_substream_t * substream)
 {
@@ -2410 +2002 @@
         ice1712_t *ice = snd_pcm_substream_chip(substream);
         unsigned int tmp;
-        unsigned char tmpst[5];
         int change;
 
@@ -2442 +2033 @@
         case ICE1712_SUBDEVICE_EWX2496:
         case ICE1712_SUBDEVICE_AUDIOPHILE:
-                /* setup S/PDIF */
-                memcpy(tmpst, ice->cs8427_spdif_stream_status, 5);
-                snd_ice1712_cs8427_set_status(ice, substream->runtime, tmpst); 
-                change = memcmp(tmpst, ice->cs8427_spdif_stream_status, 5) != 0;
-                memcpy(ice->cs8427_spdif_stream_status, tmpst, 5);
-                spin_unlock_irqrestore(&ice->reg_lock, flags);
-                if (change) {
-                        snd_ctl_notify(ice->card, SNDRV_CTL_EVENT_MASK_VALUE, &ice->spdif_stream_ctl->id);
-                        ice->cs8427_ops->write_bytes(ice, 32, 5, tmpst);
-                }
-                return 0;
+                snd_cs8427_iec958_pcm(ice->cs8427, substream->runtime->rate);
+                break;
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88D:
@@ -2609 +2191 @@
 
         ice->cs8403_spdif_stream_bits = ice->cs8403_spdif_bits;
-        memcpy(ice->cs8427_spdif_stream_status, ice->cs8427_spdif_status, 5);
-        if (ice->spdif_stream_ctl != NULL) {
-                ice->spdif_stream_ctl->access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
-                snd_ctl_notify(ice->card, SNDRV_CTL_EVENT_MASK_VALUE |
-                               SNDRV_CTL_EVENT_MASK_INFO, &ice->spdif_stream_ctl->id);
-        }
+        if (ice->cs8427)
+                snd_cs8427_iec958_active(ice->cs8427, 1);
 
         return 0;
@@ -2637 +2215 @@
 
         ice->playback_pro_substream = NULL;
-
-        if (ice->spdif_stream_ctl != NULL) {
-                ice->spdif_stream_ctl->access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
-                snd_ctl_notify(ice->card, SNDRV_CTL_EVENT_MASK_VALUE |
-                               SNDRV_CTL_EVENT_MASK_INFO, &ice->spdif_stream_ctl->id);
-        }
+        if (ice->cs8427)
+                snd_cs8427_iec958_active(ice->cs8427, 0);
 
         return 0;
@@ -2655 +2229 @@
 }
 
-static void __exit snd_ice1712_pcm_profi_free(snd_pcm_t *pcm)
+static void snd_ice1712_pcm_profi_free(snd_pcm_t *pcm)
 {
         ice1712_t *ice = snd_magic_cast(ice1712_t, pcm->private_data, return);
@@ -2708 +2282 @@
 #endif
 
-static int __init snd_ice1712_pcm_profi(ice1712_t * ice, int device, snd_pcm_t ** rpcm)
+static int __devinit snd_ice1712_pcm_profi(ice1712_t * ice, int device, snd_pcm_t ** rpcm)
 {
         snd_pcm_t *pcm;
@@ -2733 +2307 @@
                 *rpcm = pcm;
         
+        if (ice->cs8427) {
+                /* assign channels to iec958 */
+                err = snd_cs8427_iec958_build(ice->cs8427,
+                                              pcm->streams[0].substream,
+                                              pcm->streams[1].substream);
+                if (err < 0)
+                        return err;
+        }
+
         if ((err = snd_ice1712_build_pro_mixer(ice)) < 0)
                 return err;
@@ -2858 +2441 @@
         unsigned char nval = ucontrol->value.integer.value[0];
         int change = ice->ak4524_images[chip][addr] != nval;
+        if (change)
+                snd_ice1712_ak4524_write(ice, chip, addr, nval);
+        return change;
+}
+
+static int snd_ice1712_ak4524_ipga_gain_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 36;
+        return 0;
+}
+
+static int snd_ice1712_ak4524_ipga_gain_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+{
+        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+        int chip = kcontrol->private_value / 8;
+        int addr = kcontrol->private_value % 8;
+        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);
+        int chip = kcontrol->private_value / 8;
+        int addr = kcontrol->private_value % 8;
+        unsigned char nval = (ucontrol->value.integer.value[0] % 37) | 0x80;
+        int change = ice->ak4524_ipga_gain[chip][addr] != nval;
         if (change)
                 snd_ice1712_ak4524_write(ice, chip, addr, nval);
@@ -2960 +2573 @@
         }
         
-        return 0;
-}
-
-static void /*__init*/ snd_ice1712_ac97_init(ac97_t *ac97)
+        /* initialize volumes */
+        for (idx = 0; idx < 20; idx++) {
+                ice->pro_volumes[idx] = 0x80008000;     /* mute */
+                snd_ice1712_update_volume(ice, idx);
+        }
+        return 0;
+}
+
+static void snd_ice1712_ac97_init(ac97_t *ac97)
 {
         // ice1712_t *ice = snd_magic_cast(ice1712_t, ac97->private_data, return);
@@ -2971 +2589 @@
 }
 
-static void __exit snd_ice1712_mixer_free_ac97(ac97_t *ac97)
+static void snd_ice1712_mixer_free_ac97(ac97_t *ac97)
 {
         ice1712_t *ice = snd_magic_cast(ice1712_t, ac97->private_data, return);
@@ -2977 +2595 @@
 }
 
-static int __init snd_ice1712_ac97_mixer(ice1712_t * ice)
+static int __devinit snd_ice1712_ac97_mixer(ice1712_t * ice)
 {
         int err;
@@ -2989 +2607 @@
                 ac97.private_data = ice;
                 ac97.private_free = snd_ice1712_mixer_free_ac97;
-                if ((err = snd_ac97_mixer(ice->card, &ac97, &ice->ac97)) < 0)
+                if ((err = snd_ac97_mixer(ice->card, &ac97, &ice->ac97)) < 0) {
+                        printk(KERN_WARNING "ice1712: cannot initialize ac97 for consumer, skipped\n");
+                        // return err;
+                } else {
+                if ((err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_digmix_route_ac97, ice))) < 0)
                         return err;
+                }
                 return 0;
         }
@@ -3003 +2626 @@
                 ac97.private_free = snd_ice1712_mixer_free_ac97;
                 if ((err = snd_ac97_mixer(ice->card, &ac97, &ice->ac97)) < 0)
-                        return err;
-                if ((err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_mixer_digmix_route_ac97, ice))) < 0)
                         return err;
                 return 0;
@@ -3047 +2668 @@
 }
 
-static void __init snd_ice1712_proc_init(ice1712_t * ice)
+static void __devinit snd_ice1712_proc_init(ice1712_t * ice)
 {
         snd_info_entry_t *entry;
@@ -3092 +2713 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_eeprom = {
+static snd_kcontrol_new_t snd_ice1712_eeprom __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_CARD,0,0,
@@ -3126 +2747 @@
         case ICE1712_SUBDEVICE_DELTADIO2496:
         case ICE1712_SUBDEVICE_DELTA66:
-                snd_ice1712_decode_cs8403_spdif_bits(&ucontrol->value.iec958, ice->cs8403_spdif_bits);
-                break;
-        case ICE1712_SUBDEVICE_AUDIOPHILE:
-        case ICE1712_SUBDEVICE_EWX2496:
-                memcpy(ucontrol->value.iec958.status, ice->cs8427_spdif_status, 5);
+                snd_cs8403_decode_spdif_bits(&ucontrol->value.iec958, ice->cs8403_spdif_bits);
                 break;
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88D:
-                snd_ice1712_ews_decode_cs8404_spdif_bits(&ucontrol->value.iec958, ice->cs8403_spdif_bits);
+                snd_cs8404_decode_spdif_bits(&ucontrol->value.iec958, ice->cs8403_spdif_bits);
                 break;
         }
@@ -3152 +2769 @@
         case ICE1712_SUBDEVICE_DELTADIO2496:
         case ICE1712_SUBDEVICE_DELTA66:
-                val = snd_ice1712_encode_cs8403_spdif_bits(&ucontrol->value.iec958);
+                val = snd_cs8403_encode_spdif_bits(&ucontrol->value.iec958);
                 spin_lock_irqsave(&ice->reg_lock, flags);
                 change = ice->cs8403_spdif_bits != val;
@@ -3163 +2780 @@
                 }
                 break;
-        case ICE1712_SUBDEVICE_AUDIOPHILE:
-        case ICE1712_SUBDEVICE_EWX2496:
-                spin_lock_irqsave(&ice->reg_lock, flags);
-                change = memcmp(ucontrol->value.iec958.status, ice->cs8427_spdif_status, 5) != 0;
-                memcpy(ice->cs8427_spdif_status, ucontrol->value.iec958.status, 5);
-                if (change && ice->playback_pro_substream == NULL) {
-                        spin_unlock_irqrestore(&ice->reg_lock, flags);
-                        ice->cs8427_ops->write_bytes(ice, 32, 5, ice->cs8427_spdif_status);
-                } else
-                        spin_unlock_irqrestore(&ice->reg_lock, flags);
-                break;
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88D:
-                val = snd_ice1712_ews_encode_cs8404_spdif_bits(&ucontrol->value.iec958);
+                val = snd_cs8404_encode_spdif_bits(&ucontrol->value.iec958);
                 spin_lock_irqsave(&ice->reg_lock, flags);
                 change = ice->cs8403_spdif_bits != val;
@@ -3193 +2799 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_spdif_default =
+static snd_kcontrol_new_t snd_ice1712_spdif_default __devinitdata =
 {
 #ifdef TARGET_OS2
@@ -3277 +2883 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_spdif_maskc =
+static snd_kcontrol_new_t snd_ice1712_spdif_maskc __devinitdata =
 {
 #ifdef TARGET_OS2
@@ -3294 +2900 @@
 };
 
-static snd_kcontrol_new_t snd_ice1712_spdif_maskp =
+static snd_kcontrol_new_t snd_ice1712_spdif_maskp __devinitdata =
 {
 #ifdef TARGET_OS2
@@ -3327 +2933 @@
         case ICE1712_SUBDEVICE_DELTADIO2496:
         case ICE1712_SUBDEVICE_DELTA66:
-                snd_ice1712_decode_cs8403_spdif_bits(&ucontrol->value.iec958, ice->cs8403_spdif_stream_bits);
-                break;
-        case ICE1712_SUBDEVICE_AUDIOPHILE:
-        case ICE1712_SUBDEVICE_EWX2496:
-                //ice->cs8427_ops->read_bytes(ice, 32, 5, ucontrol->value.iec958.status);
-                memcpy(ucontrol->value.iec958.status, ice->cs8427_spdif_stream_status, 5);
+                snd_cs8403_decode_spdif_bits(&ucontrol->value.iec958, ice->cs8403_spdif_stream_bits);
                 break;
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88D:
-                snd_ice1712_ews_decode_cs8404_spdif_bits(&ucontrol->value.iec958, ice->cs8403_spdif_stream_bits);
+                snd_cs8404_decode_spdif_bits(&ucontrol->value.iec958, ice->cs8403_spdif_stream_bits);
                 break;
         }
@@ -3354 +2955 @@
         case ICE1712_SUBDEVICE_DELTADIO2496:
         case ICE1712_SUBDEVICE_DELTA66:
-                val = snd_ice1712_encode_cs8403_spdif_bits(&ucontrol->value.iec958);
+                val = snd_cs8403_encode_spdif_bits(&ucontrol->value.iec958);
                 spin_lock_irqsave(&ice->reg_lock, flags);
                 change = ice->cs8403_spdif_stream_bits != val;
@@ -3365 +2966 @@
                 }
                 break;
-        case ICE1712_SUBDEVICE_AUDIOPHILE:
-        case ICE1712_SUBDEVICE_EWX2496:
-                spin_lock_irqsave(&ice->reg_lock, flags);
-                change = memcmp(ice->cs8427_spdif_stream_status,
-                                ucontrol->value.iec958.status, 5) != 0;
-                if (change && ice->playback_pro_substream != NULL) {
-                        memcpy(ice->cs8427_spdif_stream_status,
-                               ucontrol->value.iec958.status, 5);
-                        spin_unlock_irqrestore(&ice->reg_lock, flags);
-                        ice->cs8427_ops->write_bytes(ice, 32, 5, ucontrol->value.iec958.status);
-                } else
-                        spin_unlock_irqrestore(&ice->reg_lock, flags);
-                break;
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88D:
-                val = snd_ice1712_ews_encode_cs8404_spdif_bits(&ucontrol->value.iec958);
+                val = snd_cs8404_encode_spdif_bits(&ucontrol->value.iec958);
                 spin_lock_irqsave(&ice->reg_lock, flags);
                 change = ice->cs8403_spdif_stream_bits != val;
@@ -3397 +2985 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_spdif_stream =
+static snd_kcontrol_new_t snd_ice1712_spdif_stream __devinitdata =
 {
 #ifdef TARGET_OS2
@@ -3417 +3005 @@
 
 #ifdef TARGET_OS2
-#define ICE1712_GPIO(xiface, xname, xindex, shift, xaccess) \
+#define ICE1712_GPIO(xiface, xname, xindex, mask, invert, xaccess) \
 { xiface, 0, 0, xname, 0, xaccess, snd_ice1712_gpio_info, \
   snd_ice1712_gpio_get, snd_ice1712_gpio_put, \
-  shift }
+        mask | (invert << 24) }
 #else
-#define ICE1712_GPIO(xiface, xname, xindex, shift, xaccess) \
+#define ICE1712_GPIO(xiface, xname, xindex, mask, invert, xaccess) \
 { iface: xiface, name: xname, access: xaccess, info: snd_ice1712_gpio_info, \
   get: snd_ice1712_gpio_get, put: snd_ice1712_gpio_put, \
-  private_value: shift }
+  private_value: mask | (invert << 24) }
 #endif
 
@@ -3441 +3029 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         unsigned char mask = kcontrol->private_value & 0xff;
+        int invert = (kcontrol->private_value & (1<<24)) ? 1 : 0;
         unsigned char saved[2];
         
         save_gpio_status(ice, saved);
-        ucontrol->value.integer.value[0] = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & mask ? 1 : 0;
+        ucontrol->value.integer.value[0] = (snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & mask ? 1 : 0) ^ invert;
         restore_gpio_status(ice, saved);
         return 0;
@@ -3453 +3042 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         unsigned char mask = kcontrol->private_value & 0xff;
+        int invert = (kcontrol->private_value & (1<<24)) ? mask : 0;
         unsigned char saved[2];
         int val, nval;
@@ -3458 +3048 @@
         if (kcontrol->private_value & (1 << 31))
                 return -EPERM;
-        nval = ucontrol->value.integer.value[0] ? mask : 0;
+        nval = (ucontrol->value.integer.value[0] ? mask : 0) ^ invert;
         save_gpio_status(ice, saved);
         val = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
@@ -3467 +3057 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_delta1010_wordclock_select =
-ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_PCM, "Word Clock Sync", 0, ICE1712_DELTA_WORD_CLOCK_SELECT, 0);
-static snd_kcontrol_new_t snd_ice1712_delta1010_wordclock_status =
-ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_PCM, "Word Clock Status", 0, ICE1712_DELTA_WORD_CLOCK_STATUS, SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE);
-static snd_kcontrol_new_t snd_ice1712_deltadio2496_spdif_in_select =
-ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_PCM, "IEC958 Input Optical", 0, ICE1712_DELTA_SPDIF_INPUT_SELECT, 0);
-static snd_kcontrol_new_t snd_ice1712_delta_spdif_in_status =
-ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_PCM, "Delta IEC958 Input Status", 0, ICE1712_DELTA_SPDIF_IN_STAT, SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE);
+static snd_kcontrol_new_t snd_ice1712_delta1010_wordclock_select __devinitdata =
+ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_PCM, "Word Clock Sync", 0, ICE1712_DELTA_WORD_CLOCK_SELECT, 1, 0);
+static snd_kcontrol_new_t snd_ice1712_delta1010_wordclock_status __devinitdata =
+ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_PCM, "Word Clock Status", 0, ICE1712_DELTA_WORD_CLOCK_STATUS, 1, SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE);
+static snd_kcontrol_new_t snd_ice1712_deltadio2496_spdif_in_select __devinitdata =
+ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_PCM, "IEC958 Input Optical", 0, ICE1712_DELTA_SPDIF_INPUT_SELECT, 0, 0);
+static snd_kcontrol_new_t snd_ice1712_delta_spdif_in_status __devinitdata =
+ICE1712_GPIO(SNDRV_CTL_ELEM_IFACE_PCM, "Delta IEC958 Input Status", 0, ICE1712_DELTA_SPDIF_IN_STAT, 1, SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE);
 
 static int snd_ice1712_pro_spdif_master_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
@@ -3509 +3099 @@
         spin_unlock_irqrestore(&ice->reg_lock, flags);
 
-        if (ice->cs8427_ops) {
+        if (ice->cs8427) {
                 /* change CS8427 clock source too */
                 snd_ice1712_cs8427_set_input_clock(ice, ucontrol->value.integer.value[0]);
@@ -3517 +3107 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_pro_spdif_master = {
+static snd_kcontrol_new_t snd_ice1712_pro_spdif_master __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -3563 +3153 @@
         val >>= ((idx % 2) * 8) + ((idx / 2) * 2);
         val &= 3;
-        cval = inw(ICEMT(ice, ROUTE_CAPTURE));
+        cval = inl(ICEMT(ice, ROUTE_CAPTURE));
         cval >>= ((idx / 2) * 8) + ((idx % 2) * 4);
         if (val == 1 && idx < 2)
@@ -3585 +3175 @@
         /* update PSDOUT */
         if (ucontrol->value.enumerated.item[0] >= 11)
-                nval = idx < 2 ? 1 : 0;
+                nval = idx < 2 ? 1 : 0; /* dig mixer (or pcm) */
         else if (ucontrol->value.enumerated.item[0] >= 9)
-                nval = 3;
+                nval = 3; /* spdif in */
         else if (ucontrol->value.enumerated.item[0] >= 1)
-                nval = 2;
+                nval = 2; /* analog in */
         else
-                nval = 0;
+                nval = 0; /* pcm */
         shift = ((idx % 2) * 8) + ((idx / 2) * 2);
         val = old_val = inw(ICEMT(ice, ROUTE_PSDOUT03));
@@ -3599 +3189 @@
         if (change)
                 outw(val, ICEMT(ice, ROUTE_PSDOUT03));
-        if (nval < 2)
+        if (nval < 2) /* dig mixer of pcm */
                 return change;
 
         /* update CAPTURE */
-        val = old_val = inw(ICEMT(ice, ROUTE_CAPTURE));
+        val = old_val = inl(ICEMT(ice, ROUTE_CAPTURE));
         shift = ((idx / 2) * 8) + ((idx % 2) * 4);
-        if (nval == 2) {
+        if (nval == 2) { /* analog in */
                 nval = ucontrol->value.enumerated.item[0] - 1;
                 val &= ~(0x07 << shift);
                 val |= nval << shift;
-        } else {
+        } else { /* spdif in */
                 nval = (ucontrol->value.enumerated.item[0] - 9) << 3;
                 val &= ~(0x08 << shift);
@@ -3616 +3206 @@
         if (val != old_val) {
                 change = 1;
-                outw(val, ICEMT(ice, ROUTE_CAPTURE));
+                outl(val, ICEMT(ice, ROUTE_CAPTURE));
         }
         return change;
@@ -3676 +3266 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_mixer_pro_analog_route = {
+static snd_kcontrol_new_t snd_ice1712_mixer_pro_analog_route __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -3692 +3282 @@
 };
 
-static snd_kcontrol_new_t snd_ice1712_mixer_pro_spdif_route = {
+static snd_kcontrol_new_t snd_ice1712_mixer_pro_spdif_route __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -3742 +3332 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_mixer_pro_volume_rate = {
+static snd_kcontrol_new_t snd_ice1712_mixer_pro_volume_rate __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -3782 +3372 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_mixer_pro_peak = {
+static snd_kcontrol_new_t snd_ice1712_mixer_pro_peak __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -3846 +3436 @@
 }
 
-static snd_kcontrol_new_t snd_ice1712_ewx_input_sense = {
+static snd_kcontrol_new_t snd_ice1712_ewx_input_sense __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -3864 +3454 @@
 };
 
-static snd_kcontrol_new_t snd_ice1712_ewx_output_sense = {
+static snd_kcontrol_new_t snd_ice1712_ewx_output_sense __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -3890 +3480 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        unsigned char saved[2];
         unsigned char data;
 
-        save_gpio_status(ice, saved);
-        data = snd_ice1712_ews88mt_pcf8574_read(ice, ICE1712_EWS88MT_OUTPUT_ADDR);
-        restore_gpio_status(ice, saved);
+        snd_i2c_lock(ice->i2c);
+        if (snd_i2c_readbytes(ice->pcf8574[1], &data, 1) != 1) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
+        snd_i2c_unlock(ice->i2c);
         ucontrol->value.enumerated.item[0] = data & ICE1712_EWS88MT_OUTPUT_SENSE ? 1 : 0; /* high = -10dBV, low = +4dBu */
         return 0;
@@ -3904 +3496 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        unsigned char saved[2];
         unsigned char data, ndata;
 
-        save_gpio_status(ice, saved);
-        data = snd_ice1712_ews88mt_pcf8574_read(ice, ICE1712_EWS88MT_OUTPUT_ADDR);
+        snd_i2c_lock(ice->i2c);
+        if (snd_i2c_readbytes(ice->pcf8574[1], &data, 1) != 1) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
         ndata = (data & ~ICE1712_EWS88MT_OUTPUT_SENSE) | (ucontrol->value.enumerated.item[0] ? ICE1712_EWS88MT_OUTPUT_SENSE : 0);
-        if (ndata != data)
-                snd_ice1712_ews88mt_pcf8574_write(ice, ICE1712_EWS88MT_OUTPUT_ADDR, ndata);
-        restore_gpio_status(ice, saved);
+        if (ndata != data && snd_i2c_sendbytes(ice->pcf8574[1], &ndata, 1) != 1) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
+        snd_i2c_unlock(ice->i2c);
         return ndata != data;
-
 }
 
@@ -3922 +3517 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         int channel = kcontrol->id.index;
-        unsigned char saved[2];
         unsigned char data;
 
         snd_assert(channel >= 0 && channel <= 7, return 0);
-        save_gpio_status(ice, saved);
-        data = snd_ice1712_ews88mt_pcf8574_read(ice, ICE1712_EWS88MT_INPUT_ADDR);
-        restore_gpio_status(ice, saved);
+        snd_i2c_lock(ice->i2c);
+        if (snd_i2c_readbytes(ice->pcf8574[0], &data, 1) != 1) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
         /* reversed; high = +4dBu, low = -10dBV */
         ucontrol->value.enumerated.item[0] = data & (1 << channel) ? 0 : 1;
@@ -3939 +3535 @@
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
         int channel = kcontrol->id.index;
-        unsigned char saved[2];
         unsigned char data, ndata;
 
         snd_assert(channel >= 0 && channel <= 7, return 0);
-        save_gpio_status(ice, saved);
-        data = snd_ice1712_ews88mt_pcf8574_read(ice, ICE1712_EWS88MT_INPUT_ADDR);
+        snd_i2c_lock(ice->i2c);
+        if (snd_i2c_readbytes(ice->pcf8574[0], &data, 1) != 1) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
         ndata = (data & ~(1 << channel)) | (ucontrol->value.enumerated.item[0] ? 0 : (1 << channel));
-        if (ndata != data)
-                snd_ice1712_ews88mt_pcf8574_write(ice, ICE1712_EWS88MT_INPUT_ADDR, ndata);
-        restore_gpio_status(ice, saved);
+        if (ndata != data && snd_i2c_sendbytes(ice->pcf8574[0], &ndata, 1) != 1) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
+        snd_i2c_unlock(ice->i2c);
         return ndata != data;
 }
 
-static snd_kcontrol_new_t snd_ice1712_ews88mt_input_sense = {
+static snd_kcontrol_new_t snd_ice1712_ews88mt_input_sense __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -3968 +3568 @@
 };
 
-static snd_kcontrol_new_t snd_ice1712_ews88mt_output_sense = {
+static snd_kcontrol_new_t snd_ice1712_ews88mt_output_sense __devinitdata = {
 #ifdef TARGET_OS2
         SNDRV_CTL_ELEM_IFACE_MIXER,0,0,
@@ -4003 +3603 @@
         int shift = kcontrol->private_value & 0xff;
         int invert = (kcontrol->private_value >> 8) & 1;
-        unsigned short data;
+        unsigned char data[2];
         
-        data = snd_ice1712_ews88d_pcf8575_read(ice, ICE1712_EWS88D_PCF_ADDR);
-        //printk("pcf: read 0x%x\n", data);
-        data = (data >> shift) & 0x01;
+        snd_i2c_lock(ice->i2c);
+        if (snd_i2c_readbytes(ice->pcf8575, data, 2) != 2) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
+        snd_i2c_unlock(ice->i2c);
+        data[0] = (data[shift >> 3] >> (shift & 7)) & 0x01;
         if (invert)
-                data ^= 0x01;
-        ucontrol->value.integer.value[0] = data;
+                data[0] ^= 0x01;
+        ucontrol->value.integer.value[0] = data[0];
         return 0;
 }
@@ -4019 +3623 @@
         int shift = kcontrol->private_value & 0xff;
         int invert = (kcontrol->private_value >> 8) & 1;
-        unsigned short data, ndata;
+        unsigned char data[2], ndata[2];
         int change;
 
-        data = snd_ice1712_ews88d_pcf8575_read(ice, ICE1712_EWS88D_PCF_ADDR);
-        ndata = data & ~(1 << shift);
+        snd_i2c_lock(ice->i2c);
+        if (snd_i2c_readbytes(ice->pcf8575, data, 2) != 2) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
+        ndata[shift >> 3] = data[shift >> 3] & ~(1 << (shift & 7));
         if (invert) {
                 if (! ucontrol->value.integer.value[0])
-                        ndata |= (1 << shift);
+                        ndata[shift >> 3] |= (1 << (shift & 7));
         } else {
                 if (ucontrol->value.integer.value[0])
-                        ndata |= (1 << shift);
-        }
-        change = (data != ndata);
-        if (change) {
-                ndata &= 0xff;
-                ndata |= (unsigned short)ice->cs8403_spdif_stream_bits << 8;
-                snd_ice1712_ews88d_pcf8575_write(ice, ICE1712_EWS88D_PCF_ADDR, ndata);
-                //printk("pcf: write 0x%x\n", ndata);
-        }
+                        ndata[shift >> 3] |= (1 << (shift & 7));
+        }
+        change = (data[shift >> 3] != ndata[shift >> 3]);
+        if (change && snd_i2c_sendbytes(ice->pcf8575, data, 2) != 2) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
+        snd_i2c_unlock(ice->i2c);
         return change;
 }
 
 #ifdef TARGET_OS2
-#define EWS88D_CONTROL(xiface, xname, xindex, xshift, xinvert, xaccess) \
+#define EWS88D_CONTROL(xiface, xname, xshift, xinvert, xaccess) \
 { xiface,0,0,\
   xname, 0,\
@@ -4052 +3659 @@
 }
 #else
-#define EWS88D_CONTROL(xiface, xname, xindex, xshift, xinvert, xaccess) \
+#define EWS88D_CONTROL(xiface, xname, xshift, xinvert, xaccess) \
 { iface: xiface,\
   name: xname,\
@@ -4063 +3670 @@
 #endif
 
-static snd_kcontrol_new_t snd_ice1712_ews88d_spdif_in_opt =
-EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "IEC958 Input Optical", 0, 0, 1, 0); /* inverted */
-static snd_kcontrol_new_t snd_ice1712_ews88d_opt_out_adat =
-EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT Output Optical", 0, 1, 0, 0);
-static snd_kcontrol_new_t snd_ice1712_ews88d_master_adat =
-EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT External Master Clock", 0, 2, 0, 0);
-static snd_kcontrol_new_t snd_ice1712_ews88d_adat_enable =
-EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "Enable ADAT", 0, 3, 0, 0);
-static snd_kcontrol_new_t snd_ice1712_ews88d_adat_through =
-EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT Through", 0, 4, 1, 0);
+static snd_kcontrol_new_t snd_ice1712_ews88d_controls[] __devinitdata = {
+        EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "IEC958 Input Optical", 0, 1, 0), /* inverted */
+        EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT Output Optical", 1, 0, 0),
+        EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT External Master Clock", 2, 0, 0),
+        EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "Enable ADAT", 3, 0, 0),
+        EWS88D_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "ADAT Through", 4, 1, 0),
+};
+
+
+/*
+ * DMX 6Fire controls
+ */
+
+#if 0 // XXX not working yet
+static int snd_ice1712_6fire_read_pca(ice1712_t *ice)
+{
+        unsigned char byte;
+        snd_i2c_lock(ice->i2c);
+        byte = 0; /* read port */
+        snd_i2c_sendbytes(ice->pcf8575, &byte, 1);
+        if (snd_i2c_readbytes(ice->pcf8575, &byte, 1) != 1) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
+        snd_i2c_unlock(ice->i2c);
+        return byte;
+}
+
+static int snd_ice1712_6fire_write_pca(ice1712_t *ice, unsigned char data)
+{
+        unsigned char bytes[2];
+        snd_i2c_lock(ice->i2c);
+        bytes[0] = 1; /* write port */
+        bytes[1] = data;
+        if (snd_i2c_sendbytes(ice->pcf8575, bytes, 2) != 2) {
+                snd_i2c_unlock(ice->i2c);
+                return -EREMOTE;
+        }
+        snd_i2c_unlock(ice->i2c);
+        return 0;
+}
+
+static int snd_ice1712_6fire_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
+{
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
+        uinfo->count = 1;
+        uinfo->value.integer.min = 0;
+        uinfo->value.integer.max = 1;
+        return 0;
+}
+
+static int snd_ice1712_6fire_control_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+{
+        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+        int shift = kcontrol->private_value & 0xff;
+        int invert = (kcontrol->private_value >> 8) & 1;
+        int data;
+        
+        if ((data = snd_ice1712_6fire_read_pca(ice)) < 0)
+                return data;
+        data = (data >> shift) & 1;
+        if (invert)
+                data ^= 1;
+        ucontrol->value.integer.value[0] = data;
+        return 0;
+}
+
+static int snd_ice1712_6fire_control_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+{
+        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+        int shift = kcontrol->private_value & 0xff;
+        int invert = (kcontrol->private_value >> 8) & 1;
+        int data, ndata;
+        
+        if ((data = snd_ice1712_6fire_read_pca(ice)) < 0)
+                return data;
+        ndata = data & ~(1 << shift);
+        if (ucontrol->value.integer.value[0])
+                ndata |= (1 << shift);
+        if (invert)
+                ndata ^= (1 << shift);
+        if (data != ndata) {
+                snd_ice1712_6fire_write_pca(ice, (unsigned char)ndata);
+                return 1;
+        }
+        return 0;
+}
+
+#define DMX6FIRE_CONTROL(xiface, xname, xshift, xinvert, xaccess) \
+{ iface: xiface,\
+  name: xname,\
+  access: xaccess,\
+  info: snd_ice1712_6fire_control_info,\
+  get: snd_ice1712_6fire_control_get,\
+  put: snd_ice1712_6fire_control_put,\
+  private_value: xshift | (xinvert << 8),\
+}
+
+static snd_kcontrol_new_t snd_ice1712_6fire_led __devinitdata =
+DMX6FIRE_CONTROL(SNDRV_CTL_ELEM_IFACE_MIXER, "Breakbox LED", 6, 0, 0);
+
+#endif // XXX not working yet
 
 
@@ -4079 +3778 @@
  */
 
-static unsigned char __init snd_ice1712_read_i2c(ice1712_t *ice,
+static unsigned char __devinit snd_ice1712_read_i2c(ice1712_t *ice,
                                                  unsigned char dev,
                                                  unsigned char addr)
@@ -4091 +3790 @@
 }
 
-static int __init snd_ice1712_read_eeprom(ice1712_t *ice)
+static int __devinit snd_ice1712_read_eeprom(ice1712_t *ice)
 {
         int dev = 0xa0;         /* EEPROM device address */
@@ -4137 +3836 @@
 }
 
-static void __init snd_ice1712_ak4524_init(ice1712_t *ice)
-{
-        static unsigned char inits[8] = {
-                0x07, /* 0: all power up */
-                0x03, /* 1: ADC/DAC reset */
-                0x60, /* 2: 24bit I2S */
-                0x19, /* 3: deemphasis off */
-                0x00, /* 4: ADC left muted */
-                0x00, /* 5: ADC right muted */
-                0x00, /* 6: DAC left muted */
-                0x00, /* 7: DAC right muted */
+static void __devinit snd_ice1712_ak4524_init(ice1712_t *ice)
+{
+        static unsigned char inits[] = {
+                0x00, 0x07, /* 0: all power up */
+                0x01, 0x00, /* 1: ADC/DAC reset */
+                0x02, 0x60, /* 2: 24bit I2S */
+                0x03, 0x19, /* 3: deemphasis off */
+                0x01, 0x03, /* 1: ADC/DAC enable */
+                0x04, 0x00, /* 4: ADC left muted */
+                0x05, 0x00, /* 5: ADC right muted */
+                0x04, 0x80, /* 4: ADC IPGA gain 0dB */
+                0x05, 0x80, /* 5: ADC IPGA gain 0dB */
+                0x06, 0x00, /* 6: DAC left muted */
+                0x07, 0x00, /* 7: DAC right muted */
+                0xff, 0xff
         };
-        int chip;
-        unsigned char reg;
-
-        for (chip = 0; chip < ice->num_dacs/2; chip++) {
-                for (reg = 0; reg < 8; ++reg)
-                        snd_ice1712_ak4524_write(ice, chip, reg, inits[reg]);
-        }
-}
-
-/* init CS8427 transciever */
-static void __init snd_ice1712_cs8427_init(ice1712_t *ice)
-{
-        static unsigned char initvals[] = {
-                /* RMCK to OMCK, no validity, disable mutes, TCBL=output */
-                0x80,
-                /* hold last valid audio sample, RMCK=256*Fs, normal stereo operation */
-                0x00,
-                /* output drivers normal operation, Tx<=serial, Rx=>serial */
-                0x0c,
-                /* Run off, CMCK=256*Fs, output time base = OMCK, input time base =
-                   covered input clock, recovered input clock source is Envy24 */
-                0x04,
-                /* Serial audio input port data format = I2S */
-                0x05, /* SIDEL=1, SILRPOL=1 */
-                /* Serial audio output port data format = I2S */
-                0x05,   /* SODEL=1, SOLRPOL=1 */
-        };
-        unsigned char buf[32];
-
-        /* verify CS8427 ID */
-        if (ice->cs8427_ops->read(ice, 127) != 0x71) {
-                snd_printk("unable to find CS8427 signature, initialization is not completed\n");
-                return;
-        }
-        /* turn off run bit while making changes to configuration */
-        ice->cs8427_ops->write(ice, 4, 0x00);
-        /* send initial values */
-        ice->cs8427_ops->write_bytes(ice, 1, 6, initvals);
-        /* Turn off CS8427 interrupt stuff that is not used in hardware */
-        memset(buf, 0, sizeof(buf));
-        /* from address 9 to 15 */
-        ice->cs8427_ops->write_bytes(ice, 9, 7, buf);
-        /* unmask the input PLL clock, V, confidence, biphase, parity status bits */
-        //buf[0] = 0x1f;
-        buf[0] = 0;
-        /* Registers 32-55 window to CS buffer
-           Inhibit D->E transfers from overwriting first 5 bytes of CS data.
-           Allow D->E transfers (all) of CS data.
-           Allow E->F transfer of CS data.
-           One byte mode; both A/B channels get same written CB data.
-           A channel info is output to chip's EMPH* pin. */
-        buf[1] = 0x10;
-        /* Use internal buffer to transmit User (U) data.
-           Chip's U pin is an output.
-           Transmit all O's for user data. */
-        //buf[2] = 0x10;
-        buf[2] = 0x00;
-        ice->cs8427_ops->write_bytes(ice, 17, 3, buf);
-        /* turn on run bit and rock'n'roll */
-        ice->cs8427_ops->write(ice, 4, initvals[3] | 0x40);
-        /* write default channel status bytes */
-        ice->cs8427_ops->write_bytes(ice, 32, 5, ice->cs8427_spdif_status);
-
-        /*
-         * add controls..
-         */
-        snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_cs8427_in_status, ice));
-#if 0
-        snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_cs8427_clock_select, ice));
-#endif
-}
-
-static void __init snd_ice1712_stdsp24_gpio_write(ice1712_t *ice, unsigned char byte)
+        int chip, idx;
+        unsigned char *ptr, reg, data;
+
+        for (chip = idx = 0; chip < ice->num_dacs/2; chip++) {
+                ptr = inits;
+                while (*ptr != 0xff) {
+                        reg = *ptr++;
+                        data = *ptr++;
+                        if (ice->ak4528) {
+                                if (reg > 5)
+                                        continue;
+                                if (reg >= 4 && (data & 0x80))
+                                        continue;
+                        }
+                        if (reg == 0x03 && ice->ak4528)
+                                data = 0x0d;    /* deemphasis off, turn LR highpass filters on */
+                        snd_ice1712_ak4524_write(ice, chip, reg, data);
+                }
+        }
+}
+
+static void __devinit snd_ice1712_stdsp24_gpio_write(ice1712_t *ice, unsigned char byte)
 {
         byte |= ICE1712_STDSP24_CLOCK_BIT;
@@ -4234 +3886 @@
 }
 
-static void __init snd_ice1712_stdsp24_darear(ice1712_t *ice, int activate)
+static void __devinit snd_ice1712_stdsp24_darear(ice1712_t *ice, int activate)
 {
         down(&ice->gpio_mutex);
@@ -4242 +3894 @@
 }
 
-static void __init snd_ice1712_stdsp24_mute(ice1712_t *ice, int activate)
+static void __devinit snd_ice1712_stdsp24_mute(ice1712_t *ice, int activate)
 {
         down(&ice->gpio_mutex);
@@ -4250 +3902 @@
 }
 
-static void __init snd_ice1712_stdsp24_insel(ice1712_t *ice, int activate)
+static void __devinit snd_ice1712_stdsp24_insel(ice1712_t *ice, int activate)
 {
         down(&ice->gpio_mutex);
@@ -4258 +3910 @@
 }
 
-static void __init snd_ice1712_stdsp24_box_channel(ice1712_t *ice, int box, int chn, int activate)
+static void __devinit snd_ice1712_stdsp24_box_channel(ice1712_t *ice, int box, int chn, int activate)
 {
         down(&ice->gpio_mutex);
@@ -4305 +3957 @@
 }
 
-static void __init snd_ice1712_stdsp24_box_midi(ice1712_t *ice, int box, int master, int slave)
+static void __devinit snd_ice1712_stdsp24_box_midi(ice1712_t *ice, int box, int master, int slave)
 {
         down(&ice->gpio_mutex);
@@ -4336 +3988 @@
 }
 
-static void __init snd_ice1712_stdsp24_init(ice1712_t *ice)
+static void __devinit snd_ice1712_stdsp24_init(ice1712_t *ice)
 {
         int box, chn;
@@ -4394 +4046 @@
 }
 
-static int __init snd_ice1712_chip_init(ice1712_t *ice)
-{
+static int __devinit snd_ice1712_chip_init(ice1712_t *ice)
+{
+        int err, has_i2c = 0;
+
         outb(ICE1712_RESET | ICE1712_NATIVE, ICEREG(ice, CONTROL));
         udelay(200);
@@ -4426 +4080 @@
         }
 
+        /* determine I2C, DACs and ADCs */
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_AUDIOPHILE:
+                ice->ak4528 = 1;
+                /* follow thru */
         case ICE1712_SUBDEVICE_EWX2496:
-                ice->num_adcs = ice->num_dacs = 2;
+                has_i2c = 1;
+                ice->num_adcs = ice->num_dacs = ice->num_total_dacs = 2;
                 break;  
         case ICE1712_SUBDEVICE_DELTA44:
         case ICE1712_SUBDEVICE_DELTA66:
-                ice->num_adcs = ice->num_dacs = 4;
+                ice->num_adcs = ice->num_dacs = ice->num_total_dacs = 4;
+                if (ice->omni)
+                        ice->num_total_dacs = 8;
                 break;
         case ICE1712_SUBDEVICE_EWS88MT:
-                ice->num_adcs = ice->num_dacs = 8;
-                break;
-        }
-
+                has_i2c = 1;
+                /* follow thru */
+        case ICE1712_SUBDEVICE_DELTA1010:
+                ice->num_adcs = ice->num_dacs = ice->num_total_dacs = 8;
+                break;
+        case ICE1712_SUBDEVICE_EWS88D:
+                has_i2c = 1;
+                break;
+        case ICE1712_SUBDEVICE_DMX6FIRE:
+                has_i2c = 1;
+                ice->num_adcs = ice->num_dacs = ice->num_total_dacs = 6;
+                break;
+        }
+
+        if (has_i2c) {
+                if ((err = snd_i2c_bus_create(ice->card, "ICE1712 GPIO 1", NULL, &ice->i2c)) < 0) {
+                        snd_printk("unable to create I2C bus\n");
+                        return err;
+                }
+                ice->i2c->private_data = ice;
+                switch (ice->eeprom.subvendor) {
+                case ICE1712_SUBDEVICE_AUDIOPHILE:
+                        ice->i2c->ops = &ap_cs8427_i2c_ops;
+                        break;
+                case ICE1712_SUBDEVICE_EWX2496:
+                case ICE1712_SUBDEVICE_EWS88MT:
+                case ICE1712_SUBDEVICE_EWS88D:
+                case ICE1712_SUBDEVICE_DMX6FIRE:
+                        ice->i2c->hw_ops.bit = &snd_ice1712_ewx_cs8427_bit_ops;
+                        break;
+                }
+                switch (ice->eeprom.subvendor) {
+                case ICE1712_SUBDEVICE_AUDIOPHILE:
+                case ICE1712_SUBDEVICE_EWX2496:
+                        if ((err = snd_cs8427_create(ice->i2c, CS8427_BASE_ADDR, &ice->cs8427)) < 0) {
+                                snd_printk("CS8427 initialization failed\n");
+                                return err;
+                        }
+                        break;
+                case ICE1712_SUBDEVICE_DMX6FIRE:
+#if 0 // XXX not working yet
+                        if ((err = snd_i2c_device_create(ice->i2c, "PCF9554", 0x40>>1, &ice->pcf8575)) < 0)
+                                return err;
+                        if ((err = snd_cs8427_create(ice->i2c, 0x11, &ice->cs8427)) < 0) {
+                                snd_printk("CS8427 initialization failed\n");
+                                return err;
+                        }
+#endif // XXX not working yet
+                        break;
+                case ICE1712_SUBDEVICE_EWS88MT:
+                        if ((err = snd_i2c_device_create(ice->i2c, "CS8404", ICE1712_EWS88MT_CS8404_ADDR, &ice->cs8404)) < 0)
+                                return err;
+                        if ((err = snd_i2c_device_create(ice->i2c, "PCF8574 (1st)", ICE1712_EWS88MT_INPUT_ADDR, &ice->pcf8574[0])) < 0)
+                                return err;
+                        if ((err = snd_i2c_device_create(ice->i2c, "PCF8574 (2nd)", ICE1712_EWS88MT_OUTPUT_ADDR, &ice->pcf8574[1])) < 0)
+                                return err;
+                        break;
+                case ICE1712_SUBDEVICE_EWS88D:
+                        if ((err = snd_i2c_device_create(ice->i2c, "PCF8575", ICE1712_EWS88D_PCF_ADDR, &ice->pcf8575)) < 0)
+                                return err;
+                        break;
+                }
+        }
+        /* second stage of initialization, analog parts and others */
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_DELTA66:
@@ -4446 +4166 @@
         case ICE1712_SUBDEVICE_EWX2496:
         case ICE1712_SUBDEVICE_EWS88MT:
+        case ICE1712_SUBDEVICE_DMX6FIRE:
                 snd_ice1712_ak4524_init(ice);
                 break;
@@ -4467 +4188 @@
                 snd_ice1712_delta_cs8403_spdif_write(ice, ice->cs8403_spdif_bits);
                 break;
+        }
+        switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_EWS88MT:
         case ICE1712_SUBDEVICE_EWS88D:
@@ -4488 +4211 @@
         if (err < 0)
                 return err;
-        for (idx = 0; idx < ice->num_dacs; idx++) {
+        for (idx = 0; idx < ice->num_total_dacs; idx++) {
                 kctl = snd_ctl_new1(&snd_ice1712_mixer_pro_analog_route, ice);
                 if (kctl == NULL)
@@ -4570 +4293 @@
         case ICE1712_SUBDEVICE_DELTA66:
         case ICE1712_SUBDEVICE_EWS88MT:
+        case ICE1712_SUBDEVICE_DMX6FIRE:
                 for (idx = 0; idx < ice->num_dacs; ++idx) {
                         snd_kcontrol_t ctl;
@@ -4580 +4304 @@
                         ctl.get = snd_ice1712_ak4524_volume_get;
                         ctl.put = snd_ice1712_ak4524_volume_put;
-                        ctl.private_value = (idx / 2) * 8 + (idx % 2) + 6; /* reigster 6 & 7 */
+                        if (ice->ak4528)
+                                ctl.private_value = (idx / 2) * 8 + (idx % 2) + 4; /* register 4 & 5 */
+                        else
+                                ctl.private_value = (idx / 2) * 8 + (idx % 2) + 6; /* register 6 & 7 */
                         ctl.private_data = ice;
                         if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
                                 return err;
                 }
-                for (idx = 0; idx < ice->num_adcs; ++idx) {
+                for (idx = 0; idx < ice->num_adcs && !ice->ak4528; ++idx) {
                         snd_kcontrol_t ctl;
                         memset(&ctl, 0, sizeof(ctl));
@@ -4595 +4322 @@
                         ctl.get = snd_ice1712_ak4524_volume_get;
                         ctl.put = snd_ice1712_ak4524_volume_put;
-                        ctl.private_value = (idx / 2) * 8 + (idx % 2) + 4; /* reigster 4 & 5 */
+                        ctl.private_value = (idx / 2) * 8 + (idx % 2) + 4; /* register 4 & 5 */
+                        ctl.private_data = ice;
+                        if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
+                                return err;
+                        memset(&ctl, 0, sizeof(ctl));
+                        strcpy(ctl.id.name, "IPGA Analog Capture Volume");
+                        ctl.id.index = idx;
+                        ctl.id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
+                        ctl.info = snd_ice1712_ak4524_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 = (idx / 2) * 8 + (idx % 2) + 4; /* register 4 & 5 */
                         ctl.private_data = ice;
                         if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
@@ -4638 +4377 @@
                 break;
         case ICE1712_SUBDEVICE_EWS88D:
-                err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88d_spdif_in_opt, ice));
+                for (idx = 0; idx < sizeof(snd_ice1712_ews88d_controls)/sizeof(snd_ice1712_ews88d_controls[0]); idx++) {
+                        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88d_controls[idx], ice));
                 if (err < 0)
                         return err;
-                err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88d_opt_out_adat, ice));
+                }
+                break;
+        case ICE1712_SUBDEVICE_DMX6FIRE:
+#if 0 // XXX not working yet
+                err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_6fire_led, ice));
                 if (err < 0)
                         return err;
-                err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88d_master_adat, ice));
-                if (err < 0)
-                        return err;
-                err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88d_adat_enable, ice));
-                if (err < 0)
-                        return err;
-                err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_ews88d_adat_through, ice));
-                if (err < 0)
-                        return err;
-                break;
-        }
-
-        return 0;
-}
-
-static int __exit snd_ice1712_free(ice1712_t *ice)
+#endif
+                break;
+        }
+
+        return 0;
+}
+
+static int snd_ice1712_free(ice1712_t *ice)
 {
         if (ice->res_port == NULL)
@@ -4672 +4408 @@
         if (ice->irq)
                 free_irq(ice->irq, (void *) ice);
-        if (ice->res_port)
+        if (ice->res_port) {
                 release_resource(ice->res_port);
-        if (ice->res_ddma_port)
+                kfree_nocheck(ice->res_port);
+        }
+        if (ice->res_ddma_port) {
                 release_resource(ice->res_ddma_port);
-        if (ice->res_dmapath_port)
+                kfree_nocheck(ice->res_ddma_port);
+        }
+        if (ice->res_dmapath_port) {
                 release_resource(ice->res_dmapath_port);
-        if (ice->res_profi_port)
+                kfree_nocheck(ice->res_dmapath_port);
+        }
+        if (ice->res_profi_port) {
                 release_resource(ice->res_profi_port);
+                kfree_nocheck(ice->res_profi_port);
+        }
         snd_magic_kfree(ice);
         return 0;
 }
 
-static int __exit snd_ice1712_dev_free(snd_device_t *device)
+static int snd_ice1712_dev_free(snd_device_t *device)
 {
         ice1712_t *ice = snd_magic_cast(ice1712_t, device->device_data, return -ENXIO);
@@ -4690 +4434 @@
 }
 
-static int __init snd_ice1712_create(snd_card_t * card,
+static int __devinit snd_ice1712_create(snd_card_t * card,
                                      struct pci_dev *pci,
+                                     int omni,
                                      ice1712_t ** r_ice1712)
 {
@@ -4705 +4450 @@
         };
 #endif
+
         *r_ice1712 = NULL;
 
@@ -4720 +4466 @@
         if (ice == NULL)
                 return -ENOMEM;
+        ice->omni = omni ? 1 : 0;
         spin_lock_init(&ice->reg_lock);
         init_MUTEX(&ice->gpio_mutex);
@@ -4726 +4473 @@
                                          0x10 | /* no emphasis */
                                          0x20); /* PCM encoder/decoder */
-        ice->cs8427_spdif_status[0] = (SNDRV_PCM_DEFAULT_CON_SPDIF >> 0) & 0xff;
-        ice->cs8427_spdif_status[1] = (SNDRV_PCM_DEFAULT_CON_SPDIF >> 8) & 0xff;
-        ice->cs8427_spdif_status[2] = (SNDRV_PCM_DEFAULT_CON_SPDIF >> 16) & 0xff;
-        ice->cs8427_spdif_status[3] = (SNDRV_PCM_DEFAULT_CON_SPDIF >> 24) & 0xff;
-        memcpy(ice->cs8427_spdif_stream_status, ice->cs8427_spdif_status, 5);
         ice->card = card;
         ice->pci = pci;
@@ -4795 +4537 @@
 }
 
-static int __init snd_ice1712_probe(struct pci_dev *pci,
+static int __devinit snd_ice1712_probe(struct pci_dev *pci,
                                     const struct pci_device_id *id)
 {
@@ -4803 +4545 @@
         int pcm_dev = 0, err;
 
-        for ( ; dev < SNDRV_CARDS; dev++) {
+        if (dev >= SNDRV_CARDS)
+                return -ENODEV;
                 if (!snd_enable[dev]) {
                         dev++;
                         return -ENOENT;
                 }
-                break;
-        }
-        if (dev >= SNDRV_CARDS)
-                return -ENODEV;
 
         card = snd_card_new(snd_index[dev], snd_id[dev], THIS_MODULE, 0);
@@ -4817 +4556 @@
                 return -ENOMEM;
 
-        if ((err = snd_ice1712_create(card, pci, &ice)) < 0) {
+        if ((err = snd_ice1712_create(card, pci, snd_omni[dev], &ice)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -4880 +4619 @@
                 strcpy(card->shortname, "TerraTec EWS 88D");
                 break;
+        case ICE1712_SUBDEVICE_DMX6FIRE:
+                strcpy(card->shortname, "TerraTec DMX 6Fire");
+                break;
         }
 
@@ -4907 +4649 @@
                 return err;
         }
-        PCI_SET_DRIVER_DATA(pci, card);
+        pci_set_drvdata(pci, card);
         dev++;
         return 0;
 }
 
-static void __exit snd_ice1712_remove(struct pci_dev *pci)
-{
-        snd_card_free(PCI_GET_DRIVER_DATA(pci));
-        PCI_SET_DRIVER_DATA(pci, NULL);
+static void __devexit snd_ice1712_remove(struct pci_dev *pci)
+{
+        snd_card_free(pci_get_drvdata(pci));
+        pci_set_drvdata(pci, NULL);
 }
 
@@ -4930 +4672 @@
         id_table: snd_ice1712_ids,
         probe: snd_ice1712_probe,
-        remove: snd_ice1712_remove,
+        remove: __devexit_p(snd_ice1712_remove),
 };
 #endif
@@ -4940 +4682 @@
         if ((err = pci_module_init(&driver)) < 0) {
 #ifdef MODULE
-                snd_printk("ICE1712 soundcard not found or device busy\n");
+                printk(KERN_ERR "ICE1712 soundcard not found or device busy\n");
 #endif
                 return err;
@@ -4957 +4699 @@
 #ifndef MODULE
 
-/* format is: snd-card-ice1712=snd_enable,snd_index,snd_id */
+/* format is: snd-ice1712=snd_enable,snd_index,snd_id */
 
 static int __init alsa_card_ice1712_setup(char *str)
@@ -4972 +4714 @@
 }
 
-__setup("snd-card-ice1712=", alsa_card_ice1712_setup);
+__setup("snd-ice1712=", alsa_card_ice1712_setup);
 
 #endif /* ifndef MODULE */

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

@@ -2924 +2924 @@
     if ((err = pci_module_init(&driver)) < 0) {
 #ifdef MODULE
-        //              snd_printk("Maestro3/Allegro soundcard not found or device busy\n");
+                //              snd_printk(KERN_ERR "Maestro3/Allegro soundcard not found or device busy\n");
 #endif
         return err;

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

@@ -20 +20 @@
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
  */      
 
-#define SNDRV_MAIN_OBJECT_FILE
-
 #include <sound/driver.h>
+#include <asm/io.h>
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
 #include <sound/pcm.h>
+#include <sound/asoundef.h>
 #define SNDRV_GET_ID
 #include <sound/initval.h>
@@ -35 +39 @@
 /* note, two last pcis should be equal, it is not a bug */
 EXPORT_NO_SYMBOLS;
+
+MODULE_AUTHOR("Anders Torger <torger@ludd.luth.se>");
 MODULE_DESCRIPTION("RME Digi96, Digi96/8, Digi96/8 PRO, Digi96/8 PST, "
                    "Digi96/8 PAD");
+MODULE_LICENSE("GPL");
 MODULE_CLASSES("{sound}");
 MODULE_DEVICES("{{RME,Digi96},"
@@ -240 +247 @@
         size_t capture_periodsize; /* in bytes, zero if not used */
 
+        snd_pcm_uframes_t playback_last_appl_ptr;
         size_t playback_ptr;
         size_t capture_ptr;
@@ -693 +701 @@
 }
 
-
-static int
-snd_rme96_playback_getrate(rme96_t *rme96)
-{
-        int rate;
-        
-        rate = ((rme96->wcreg >> RME96_WCR_BITPOS_FREQ_0) & 1) +
-                (((rme96->wcreg >> RME96_WCR_BITPOS_FREQ_1) & 1) << 1);
-        switch (rate) {
-        case 1:
-                rate = 32000;
-                break;
-        case 2:
-                rate = 44100;
-                break;
-        case 3:
-                rate = 48000;
-                break;
-        default:
-                return -1;
-        }
-        return (rme96->wcreg & RME96_WCR_DS) ? rate << 1 : rate;
-}
-
 static int
 snd_rme96_capture_getrate(rme96_t *rme96,
@@ -781 +765 @@
 
 static int
+snd_rme96_playback_getrate(rme96_t *rme96)
+{
+        int rate, dummy;
+
+        if (!(rme96->wcreg & RME96_WCR_MASTER) &&
+            (rate = snd_rme96_capture_getrate(rme96, &dummy)) > 0)
+        {
+            /* slave clock */
+            return rate;
+        }
+        rate = ((rme96->wcreg >> RME96_WCR_BITPOS_FREQ_0) & 1) +
+                (((rme96->wcreg >> RME96_WCR_BITPOS_FREQ_1) & 1) << 1);
+        switch (rate) {
+        case 1:
+                rate = 32000;
+                break;
+        case 2:
+                rate = 44100;
+                break;
+        case 3:
+                rate = 48000;
+                break;
+        default:
+                return -1;
+        }
+        return (rme96->wcreg & RME96_WCR_DS) ? rate << 1 : rate;
+}
+
+static int
 snd_rme96_playback_setrate(rme96_t *rme96,
                            int rate)
@@ -930 +943 @@
                 break;
         case RME96_INPUT_XLR:
-                if (rme96->pci->device != PCI_DEVICE_ID_DIGI96_8_PAD_OR_PST ||
-                    rme96->pci->device != PCI_DEVICE_ID_DIGI96_8_PRO ||
+                if ((rme96->pci->device != PCI_DEVICE_ID_DIGI96_8_PAD_OR_PST &&
+                     rme96->pci->device != PCI_DEVICE_ID_DIGI96_8_PRO) ||
                     (rme96->pci->device == PCI_DEVICE_ID_DIGI96_8_PAD_OR_PST &&
                      rme96->rev > 4))
@@ -1160 +1173 @@
                          int from_pause)
 {
-        snd_pcm_runtime_t *runtime = rme96->playback_substream->runtime;
-        
         if (!from_pause) {
                 writel(0, rme96->iobase + RME96_IO_RESET_PLAY_POS);
-                if (runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
-                        memcpy_toio(rme96->iobase + RME96_IO_PLAY_BUFFER,
-                                    runtime->dma_area,
-                                    rme96->playback_periodsize);
-                        rme96->playback_ptr = rme96->playback_periodsize;
-                }
+                rme96->playback_last_appl_ptr = 0;
+                rme96->playback_ptr = 0;
         }
 
@@ -1182 +1189 @@
         if (!from_pause) {
                 writel(0, rme96->iobase + RME96_IO_RESET_REC_POS);
+                rme96->capture_ptr = 0;
         }
 
@@ -1220 +1228 @@
 {
         rme96_t *rme96 = (rme96_t *)dev_id;
-        snd_pcm_runtime_t *runtime;
 
         rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER);
@@ -1232 +1239 @@
         if (rme96->rcreg & RME96_RCR_IRQ) {
                 /* playback */
-                runtime = rme96->playback_substream->runtime;
-                if (runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
-                        memcpy_toio(rme96->iobase + RME96_IO_PLAY_BUFFER +
-                                    rme96->playback_ptr,
-                                    runtime->dma_area + rme96->playback_ptr,
-                                    rme96->playback_periodsize);
-                        rme96->playback_ptr += rme96->playback_periodsize;
-                        if (rme96->playback_ptr == RME96_BUFFER_SIZE) {
-                                rme96->playback_ptr = 0;
-                        }
-                }
                 snd_pcm_period_elapsed(rme96->playback_substream);
                 writel(0, rme96->iobase + RME96_IO_CONFIRM_PLAY_IRQ);
@@ -1248 +1244 @@
         if (rme96->rcreg & RME96_RCR_IRQ_2) {
                 /* capture */
-                runtime = rme96->capture_substream->runtime;
-                if (runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
-                        memcpy_fromio(runtime->dma_area + rme96->capture_ptr,
-                                      rme96->iobase + RME96_IO_REC_BUFFER +
-                                      rme96->capture_ptr,
-                                      rme96->capture_periodsize);
-                        rme96->capture_ptr += rme96->capture_periodsize;
-                        if (rme96->capture_ptr == RME96_BUFFER_SIZE) {
-                                rme96->capture_ptr = 0;
-                        }
-                }
                 snd_pcm_period_elapsed(rme96->capture_substream);               
                 writel(0, rme96->iobase + RME96_IO_CONFIRM_REC_IRQ);
@@ -1295 +1280 @@
         writel(rme96->wcreg, rme96->iobase + RME96_IO_CONTROL_REGISTER);
         rme96->playback_substream = substream;
+        rme96->playback_last_appl_ptr = 0;
         rme96->playback_ptr = 0;
         spin_unlock_irqrestore(&rme96->lock, flags);
@@ -1354 +1340 @@
         writel(rme96->wcreg, rme96->iobase + RME96_IO_CONTROL_REGISTER);
         rme96->playback_substream = substream;
+        rme96->playback_last_appl_ptr = 0;
         rme96->playback_ptr = 0;
         spin_unlock_irqrestore(&rme96->lock, flags);
@@ -1547 +1534 @@
 {
         rme96_t *rme96 = _snd_pcm_substream_chip(substream);
+        snd_pcm_runtime_t *runtime = substream->runtime;
+        snd_pcm_sframes_t diff;
+        size_t bytes;
+        
+        if (runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
+                diff = runtime->control->appl_ptr -
+                    rme96->playback_last_appl_ptr;
+                rme96->playback_last_appl_ptr = runtime->control->appl_ptr;
+                if (diff != 0 &&
+                    diff < -(snd_pcm_sframes_t)(runtime->boundary >> 1))
+                {
+                        diff += runtime->boundary;
+                }
+                bytes = diff << rme96->playback_frlog;
+                
+                if (bytes > RME96_BUFFER_SIZE - rme96->playback_ptr) {
+                        memcpy_toio(rme96->iobase + RME96_IO_PLAY_BUFFER +
+                                    rme96->playback_ptr,
+                                    runtime->dma_area + rme96->playback_ptr,
+                                    RME96_BUFFER_SIZE - rme96->playback_ptr);
+                        bytes -= RME96_BUFFER_SIZE - rme96->playback_ptr;
+                        if (bytes > RME96_BUFFER_SIZE) {
+                                bytes = RME96_BUFFER_SIZE;
+                        }
+                        memcpy_toio(rme96->iobase + RME96_IO_PLAY_BUFFER,
+                                    runtime->dma_area,
+                                    bytes);
+                        rme96->playback_ptr = bytes;
+                } else if (bytes != 0) {
+                        memcpy_toio(rme96->iobase + RME96_IO_PLAY_BUFFER +
+                                    rme96->playback_ptr,
+                                    runtime->dma_area + rme96->playback_ptr,
+                                    bytes);
+                        rme96->playback_ptr += bytes;
+                }
+        }
         return snd_rme96_playback_ptr(rme96);
 }
@@ -1554 +1577 @@
 {
         rme96_t *rme96 = _snd_pcm_substream_chip(substream);
-        return snd_rme96_capture_ptr(rme96);
+        snd_pcm_runtime_t *runtime = substream->runtime;
+        snd_pcm_uframes_t frameptr;
+        size_t ptr;
+
+        frameptr = snd_rme96_capture_ptr(rme96);
+        if (runtime->access == SNDRV_PCM_ACCESS_MMAP_INTERLEAVED) {
+                ptr = frameptr << rme96->capture_frlog;
+                if (ptr > rme96->capture_ptr) {
+                        memcpy_fromio(runtime->dma_area + rme96->capture_ptr,
+                                      rme96->iobase + RME96_IO_REC_BUFFER +
+                                      rme96->capture_ptr,
+                                      ptr - rme96->capture_ptr);
+                        rme96->capture_ptr += ptr - rme96->capture_ptr;
+                } else if (ptr < rme96->capture_ptr) {
+                        memcpy_fromio(runtime->dma_area + rme96->capture_ptr,
+                                      rme96->iobase + RME96_IO_REC_BUFFER +
+                                      rme96->capture_ptr,
+                                      RME96_BUFFER_SIZE - rme96->capture_ptr);
+                        memcpy_fromio(runtime->dma_area,
+                                      rme96->iobase + RME96_IO_REC_BUFFER,
+                                      ptr);
+                        rme96->capture_ptr = ptr;
+                }
+        }
+        return frameptr;
 }
 
@@ -1683 +1730 @@
         if (rme96->res_port != NULL) {
                 release_resource(rme96->res_port);
+                kfree_nocheck(rme96->res_port);
                 rme96->res_port = NULL;
         }
@@ -2614 +2662 @@
 }
 
-static int __init
+static int __devinit
 snd_rme96_probe(struct pci_dev *pci,
                 const struct pci_device_id *id)
@@ -2624 +2672 @@
         u8 val;
 
-        for ( ; dev < SNDRV_CARDS; dev++) {
+        if (dev >= SNDRV_CARDS) {
+                return -ENODEV;
+        }
                 if (!snd_enable[dev]) {
                         dev++;
                         return -ENOENT;
-                }
-                break;
-        }
-        if (dev >= SNDRV_CARDS) {
-                return -ENODEV;
         }
         if ((card = snd_card_new(snd_index[dev], snd_id[dev], THIS_MODULE,
@@ -2673 +2718 @@
                 return err;     
         }
-        PCI_SET_DRIVER_DATA(pci, card);
+        pci_set_drvdata(pci, card);
         dev++;
         return 0;
 }
 
-static void __exit snd_rme96_remove(struct pci_dev *pci)
-{
-        snd_card_free(PCI_GET_DRIVER_DATA(pci));
-        PCI_SET_DRIVER_DATA(pci, NULL);
+static void __devexit snd_rme96_remove(struct pci_dev *pci)
+{
+        snd_card_free(pci_get_drvdata(pci));
+        pci_set_drvdata(pci, NULL);
 }
 
@@ -2696 +2741 @@
         id_table: snd_rme96_ids,
         probe: snd_rme96_probe,
-        remove: snd_rme96_remove,
+        remove: __devexit_p(snd_rme96_remove),
 };
 #endif
@@ -2706 +2751 @@
         if ((err = pci_module_init(&driver)) < 0) {
 #ifdef MODULE
-//              snd_printk("No RME Digi96 cards found\n");
+//              snd_printk(KERN_ERR "No RME Digi96 cards found\n");
 #endif
                 return err;
@@ -2723 +2768 @@
 #ifndef MODULE
 
-/* format is: snd-card-rme96=snd_enable,snd_index,snd_id */
+/* format is: snd-rme96=snd_enable,snd_index,snd_id */
 
 static int __init alsa_card_rme96_setup(char *str)
@@ -2738 +2783 @@
 }
 
-__setup("snd-card-rme96=", alsa_card_rme96_setup);
+__setup("snd-rme96=", alsa_card_rme96_setup);
 
 #endif /* ifndef MODULE */

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

@@ -17 +17 @@
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
  */
 
-#define SNDRV_MAIN_OBJECT_FILE
 #include <sound/driver.h>
+#include <asm/io.h>
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <sound/core.h>
 #include <sound/control.h>
 #include <sound/pcm.h>
 #include <sound/info.h>
+#include <sound/asoundef.h>
 #define SNDRV_GET_ID
 #include <sound/initval.h>
@@ -31 +36 @@
 static int snd_index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;  /* Index 0-MAX */
 static char *snd_id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;   /* ID for this card */
-static int snd_enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE;      /* Enable this card */
+static int snd_enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;  /* Enable this card */
+static int snd_precise_ptr[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = 0 }; /* Enable precise pointer */
 
 EXPORT_NO_SYMBOLS;
@@ -43 +49 @@
 MODULE_PARM_DESC(snd_enable, "Enable/disable specific RME96{52,36} soundcards.");
 MODULE_PARM_SYNTAX(snd_enable, SNDRV_ENABLE_DESC);
+MODULE_PARM(snd_precise_ptr, "1-" __MODULE_STRING(SNDRV_CARDS) "i");
+MODULE_PARM_DESC(snd_precise_ptr, "Enable precise pointer (doesn't work reliably).");
+MODULE_PARM_SYNTAX(snd_precise_ptr, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC);
 MODULE_AUTHOR("Paul Davis <pbd@op.net>, Winfried Ritsch");
 MODULE_DESCRIPTION("RME Digi9652/Digi9636");
+MODULE_LICENSE("GPL");
 MODULE_CLASSES("{sound}");
 MODULE_DEVICES("{{RME,Hammerfall},"
@@ -206 +216 @@
         unsigned long iobase;
 
+        int precise_ptr;
+
         u32 control_register;   /* cached value */
         u32 thru_bits;          /* thru 1=on, 0=off channel 1=Bit1... channel 26= Bit26 */
@@ -349 +361 @@
         rme9652->hw_offsetmask = 
                 (rme9652->period_bytes * 2 - 1) & RME9652_buf_pos;
-        rme9652->max_jitter = 16 + (rme9652->period_bytes <= 1024 ? 32 : 64);
-}
-
-static inline snd_pcm_uframes_t rme9652_hw_pointer(rme9652_t *rme9652)
+        rme9652->max_jitter = 80;
+}
+
+static snd_pcm_uframes_t rme9652_hw_pointer(rme9652_t *rme9652)
 {
         int status;
@@ -360 +372 @@
 
         status = rme9652_read(rme9652, RME9652_status_register);
+        if (!rme9652->precise_ptr)
+                return (status & RME9652_buffer_id) ? period_size : 0;
         offset = status & RME9652_buf_pos;
 
@@ -379 +393 @@
                 if (offset > rme9652->max_jitter) {
                         if (frag)
-                                printk("Unexpected hw_pointer position (bufid == 0): status: %x offset: %d\n", status, offset);
+                                printk(KERN_ERR "Unexpected hw_pointer position (bufid == 0): status: %x offset: %d\n", status, offset);
                 } else if (!frag)
                         return 0;
@@ -388 +402 @@
                 if (offset > period_size + rme9652->max_jitter) {
                         if (!frag)
-                                printk("Unexpected hw_pointer position (bufid == 1): status: %x offset: %d\n", status, offset);
+                                printk(KERN_ERR "Unexpected hw_pointer position (bufid == 1): status: %x offset: %d\n", status, offset);
                 } else if (frag)
                         return period_size;
@@ -1732 +1746 @@
         snd_iprintf(buffer, "IRQ: %d Registers bus: 0x%lx VM: 0x%lx\n",
                     rme9652->irq, rme9652->port, rme9652->iobase);
+        snd_iprintf(buffer, "Control register: %x\n", rme9652->control_register);
 
         snd_iprintf(buffer, "\n");
@@ -1948 +1963 @@
         if (rme9652->iobase)
                 iounmap((void *) rme9652->iobase);
-        if (rme9652->res_port)
+        if (rme9652->res_port) {
                 release_resource(rme9652->res_port);
+                kfree_nocheck(rme9652->res_port);
+        }
         if (rme9652->irq >= 0)
                 free_irq(rme9652->irq, (void *)rme9652);
@@ -1985 +2002 @@
                 }
 
-                snd_printk("%s: no buffers available\n",
-                           rme9652->card_name);
+                printk(KERN_ERR "%s: no buffers available\n", rme9652->card_name);
                 return -ENOMEM;
         }
@@ -1999 +2015 @@
         /* Align to bus-space 64K boundary */
 
-        cb_bus = cb_addr;
-        cb_bus = (cb_bus + 0xFFFF) & ~0xFFFFl;
-
-        pb_bus = pb_addr;
-        pb_bus = (pb_bus + 0xFFFF) & ~0xFFFFl;
+        cb_bus = (cb_addr + 0xFFFF) & ~0xFFFFl;
+        pb_bus = (pb_addr + 0xFFFF) & ~0xFFFFl;
 
         /* Tell the card where it is */
@@ -2010 +2023 @@
         rme9652_write(rme9652, RME9652_play_buffer, pb_bus);
 
-        rme9652->capture_buffer = bus_to_virt(cb_bus);
-        rme9652->playback_buffer = bus_to_virt(pb_bus);
+        rme9652->capture_buffer = cb + (cb_bus - cb_addr);
+        rme9652->playback_buffer = pb + (pb_bus - pb_addr);
 
         return 0;
@@ -2745 +2758 @@
 
 static int __init snd_rme9652_create(snd_card_t *card,
-                                     rme9652_t *rme9652)
+                                     rme9652_t *rme9652,
+                                     int precise_ptr)
 {
         struct pci_dev *pci = rme9652->pci;
@@ -2772 +2786 @@
         rme9652->irq = pci->irq;
 
-        rme9652->iobase = (unsigned long) ioremap(rme9652->port, RME9652_IO_EXTENT);
+        rme9652->iobase = (unsigned long) ioremap_nocache(rme9652->port, RME9652_IO_EXTENT);
         if (rme9652->iobase == 0) {
                 snd_printk("unable to remap region 0x%lx-0x%lx\n", rme9652->port, rme9652->port + RME9652_IO_EXTENT - 1);
                 return -EBUSY;
         }
+
+        rme9652->precise_ptr = precise_ptr;
 
         /* Determine the h/w rev level of the card. This seems like
@@ -2871 +2887 @@
 }
 
-static int snd_rme9652_probe(struct pci_dev *pci,
+static int __devinit snd_rme9652_probe(struct pci_dev *pci,
                              const struct pci_device_id *id)
 {
@@ -2879 +2895 @@
         int err;
 
-        for (; dev < SNDRV_CARDS; dev++) {
+        if (dev >= SNDRV_CARDS)
+                return -ENODEV;
                 if (!snd_enable[dev]) {
                         dev++;
                         return -ENOENT;
                 }
-                break;
-        }
-
-        if (dev >= SNDRV_CARDS)
-                return -ENODEV;
 
         card = snd_card_new(snd_index[dev], snd_id[dev], THIS_MODULE,
@@ -2901 +2913 @@
         rme9652->pci = pci;
 
-        if ((err = snd_rme9652_create(card, rme9652)) < 0) {
+        if ((err = snd_rme9652_create(card, rme9652, snd_precise_ptr[dev])) < 0) {
                 snd_card_free(card);
                 return err;
@@ -2916 +2928 @@
                 return err;
         }
-        PCI_SET_DRIVER_DATA(pci, card);
+        pci_set_drvdata(pci, card);
         dev++;
         return 0;
 }
 
-static void __exit snd_rme9652_remove(struct pci_dev *pci)
-{
-        snd_card_free(PCI_GET_DRIVER_DATA(pci));
-        PCI_SET_DRIVER_DATA(pci, NULL);
+static void __devexit snd_rme9652_remove(struct pci_dev *pci)
+{
+        snd_card_free(pci_get_drvdata(pci));
+        pci_set_drvdata(pci, NULL);
 }
 
@@ -2939 +2951 @@
         id_table:snd_rme9652_ids,
         probe:snd_rme9652_probe,
-        remove:snd_rme9652_remove,
+        remove:__devexit_p(snd_rme9652_remove),
 };
 #endif
@@ -2947 +2959 @@
         if (pci_module_init(&driver) < 0) {
 #ifdef MODULE
-                snd_printk("RME Digi9652/Digi9636: no cards found\n");
+                printk(KERN_ERR "RME Digi9652/Digi9636: no cards found\n");
 #endif
                 return -ENODEV;
@@ -2965 +2977 @@
 #ifndef MODULE
 
-/* format is: snd-card-rme9652=snd_enable,snd_index,snd_id */
+/* format is: snd-rme9652=snd_enable,snd_index,snd_id */
 
 static int __init alsa_card_rme9652_setup(char *str)
@@ -2980 +2992 @@
 }
 
-__setup("snd-card-rme9652=", alsa_card_rme9652_setup);
+__setup("snd-rme9652=", alsa_card_rme9652_setup);
 
 #endif /* ifndef MODULE */

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

@@ -22 +22 @@
  */
 
-#define SNDRV_MAIN_OBJECT_FILE
 #include <sound/driver.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <sound/core.h>
 #include <sound/trident.h>
 #define SNDRV_GET_ID
 #include <sound/initval.h>
 
-EXPORT_NO_SYMBOLS;
 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>, <audio@tridentmicro.com>");
 MODULE_DESCRIPTION("Trident 4D-WaveDX/NX & SiS SI7018");
@@ -195 +196 @@
         if ((err = pci_module_init(&driver)) < 0) {
 #ifdef MODULE
-//              snd_printk("Trident 4DWave PCI soundcard not found or device busy\n");
+//              snd_printk(KERN_ERR "Trident 4DWave PCI soundcard not found or device busy\n");
 #endif
                 return err;
@@ -212 +213 @@
 #ifndef MODULE
 
-/* format is: snd-card-trident=snd_enable,snd_index,snd_id,
+/* format is: snd-trident=snd_enable,snd_index,snd_id,
                                snd_pcm_channels,snd_wavetable_size */
 

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

@@ -20 +20 @@
  */
 
-#define SNDRV_MAIN_OBJECT_FILE
 #include <sound/driver.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <sound/core.h>
 #include <sound/ymfpci.h>
 #include <sound/mpu401.h>
@@ -29 +31 @@
 
 EXPORT_NO_SYMBOLS;
+
 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
 MODULE_DESCRIPTION("Yamaha DS-XG PCI");
@@ -290 +293 @@
         if ((err = pci_module_init(&driver)) < 0) {
 #ifdef MODULE
-//              snd_printk("Yamaha DS-XG PCI soundcard not found or device busy\n");
+//              snd_printk(KERN_ERR "Yamaha DS-XG PCI soundcard not found or device busy\n");
 #endif
                 return err;
@@ -307 +310 @@
 #ifndef MODULE
 
-/* format is: snd-card-ymfpci=snd_enable,snd_index,snd_id,
-                              snd_fm_port,snd_mpu_port,snd_mpu_irq */
+/* format is: snd-ymfpci=snd_enable,snd_index,snd_id,
+                         snd_fm_port,snd_mpu_port */
 
 static int __init alsa_card_ymfpci_setup(char *str)