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

Timestamp:

Jul 16, 2007, 2:45:34 AM (18 years ago)

Author:

Brendan Oakley

Message:

Merged to Alsa 0.9.0rc6

Location:

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

Files:

• ac97/bin (deleted)
• ali5451/bin (deleted)
• au88x0/CVS (deleted)
• au88x0/bin (deleted)
• au88x0/diff.cmd (deleted)
• au88x0/diff1.cmd (deleted)
• au88x0/test/CVS (deleted)
• bin (deleted)
• ca0106/CVS (deleted)
• ca0106/bin (deleted)
• cs46xx/bin (deleted)
• cs46xx/dsp_spos_scb_lib.c (modified) (3 diffs)
• emu10k1/bin (deleted)
• hda/CVS (deleted)
• hda/bin (deleted)
• ice1712/ak4524.c (modified) (16 diffs)
• ice1712/delta.c (modified) (11 diffs)
• ice1712/delta.h (modified) (3 diffs)
• ice1712/ews.c (modified) (3 diffs)
• ice1712/ice1712.c (modified) (17 diffs)
• ice1712/ice1712.h (modified) (2 diffs)
• nm256/bin (deleted)
• rme9652/bin (deleted)
• rme9652/hammerfall_mem.c (modified) (2 diffs, 1 prop)
• rme9652/hdsp.c (modified) (1 diff, 1 prop)
• trident/bin (deleted)
• ymfpci/bin (deleted)

GPL/branches/alsa-resync1/alsa-kernel/pci/cs46xx/dsp_spos_scb_lib.c

@@ -792 +792 @@
                 {
                         /* E */ 0x8000,0x8000,
-                        /* F */ 0x8000,0x8000
+                        /* F */ 0xffff,0xffff
                 }
         };
@@ -981 +981 @@
                 0x18000000,                     /* Phi increment for approx 32k operation */
                 0x8000,0x8000,                  /* Volume controls are unused at this time */
-                0x8000,0x8000
+                0xffff,0xffff
         };
   
@@ -1358 +1358 @@
                 }
 
-                /* cs46xx_dsp_set_src_sample_rate(chip,src_scb,sample_rate); */
+                if (pcm_channel_id != DSP_IEC958_CHANNEL ||
+                    !(ins->spdif_status_out & DSP_SPDIF_STATUS_AC3_MODE))
+                        cs46xx_dsp_set_src_sample_rate(chip,src_scb,sample_rate);
 
                 ins->nsrc_scb ++;

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

@@ -2 +2 @@
  *   ALSA driver for ICEnsemble ICE1712 (Envy24)
  *
- *   AK4524 / AK4528 interface
+ *   AK4524 / AK4528 / AK4529 interface
  *
  *      Copyright (c) 2000 Jaroslav Kysela <perex@suse.cz>
@@ -68 +68 @@
         addr &= 0x07;
         /* build I2C address + data byte */
+        /* assume C1=1, C0=0 */
         addrdata = 0xa000 | (addr << 8) | data;
         for (idx = 15; idx >= 0; idx--) {
@@ -81 +82 @@
         }
 
+        if (ak->type == SND_AK4524) {
         if ((addr != 0x04 && addr != 0x05) || (data & 0x80) == 0)
                 ak->images[chip][addr] = data;
         else
                 ak->ipga_gain[chip][addr-4] = data;
+        }
 
         if (ak->cs_mask == ak->cs_addr) {
@@ -113 +116 @@
         ak4524_t *ak = &ice->ak4524;
         
+        switch (ak->type) {
+        case SND_AK4524:
+        case SND_AK4528:
         for (chip = 0; chip < ak->num_dacs/2; chip++) {
                 snd_ice1712_ak4524_write(ice, chip, 0x01, state ? 0x00 : 0x03);
                 if (state)
                         continue;
-                for (reg = 0x04; reg < (ak->is_ak4528 ? 0x06 : 0x08); reg++)
+                        /* DAC volumes */
+                        for (reg = 0x04; reg < (ak->type == SND_AK4528 ? 0x06 : 0x08); reg++)
                         snd_ice1712_ak4524_write(ice, chip, reg, ak->images[chip][reg]);
-                if (ak->is_ak4528)
+                        if (ak->type == SND_AK4528)
                         continue;
+                        /* IPGA */
                 for (reg = 0x04; reg < 0x06; reg++)
                         snd_ice1712_ak4524_write(ice, chip, reg, ak->ipga_gain[chip][reg-4]);
+                }
+                break;
+        case SND_AK4529:
+                /* FIXME: needed for ak4529? */
+                break;
         }
 }
@@ -131 +144 @@
 void __devinit snd_ice1712_ak4524_init(ice1712_t *ice)
 {
-        static unsigned char inits[] = {
+        static unsigned char inits_ak4524[] = {
                 0x00, 0x07, /* 0: all power up */
                 0x01, 0x00, /* 1: ADC/DAC reset */
@@ -145 +158 @@
                 0xff, 0xff
         };
-        int chip, idx;
-        unsigned char *ptr, reg, data;
+        static unsigned char inits_ak4528[] = {
+                0x00, 0x07, /* 0: all power up */
+                0x01, 0x00, /* 1: ADC/DAC reset */
+                0x02, 0x60, /* 2: 24bit I2S */
+                0x03, 0x0d, /* 3: deemphasis off, turn LR highpass filters on */
+                0x01, 0x03, /* 1: ADC/DAC enable */
+                0x04, 0x00, /* 4: ADC left muted */
+                0x05, 0x00, /* 5: ADC right muted */
+                0xff, 0xff
+        };
+        static unsigned char inits_ak4529[] = {
+                0x09, 0x01, /* 9: ATS=0, RSTN=1 */
+                0x0a, 0x3f, /* A: all power up, no zero/overflow detection */
+                0x00, 0x08, /* 0: TDM=0, 24bit I2S, SMUTE=0 */
+                0x01, 0x00, /* 1: ACKS=0, ADC, loop off */
+                0x02, 0xff, /* 2: LOUT1 muted */
+                0x03, 0xff, /* 3: ROUT1 muted */
+                0x04, 0xff, /* 4: LOUT2 muted */
+                0x05, 0xff, /* 5: ROUT2 muted */
+                0x06, 0xff, /* 6: LOUT3 muted */
+                0x07, 0xff, /* 7: ROUT3 muted */
+                0x0b, 0xff, /* B: LOUT4 muted */
+                0x0c, 0xff, /* C: ROUT4 muted */
+                0x08, 0x55, /* 8: deemphasis all off */
+                0xff, 0xff
+        };
+        int chip, num_chips;
+        unsigned char *ptr, reg, data, *inits;
         ak4524_t *ak = &ice->ak4524;
 
-        for (chip = idx = 0; chip < ak->num_dacs/2; chip++) {
+        switch (ak->type) {
+        case SND_AK4524:
+                inits = inits_ak4524;
+                num_chips = ak->num_dacs / 2;
+                break;
+        case SND_AK4528:
+                inits = inits_ak4528;
+                num_chips = ak->num_dacs / 2;
+                break;
+        case SND_AK4529:
+        default:
+                inits = inits_ak4529;
+                num_chips = 1;
+                break;
+        }
+
+        for (chip = 0; chip < num_chips; chip++) {
                 ptr = inits;
                 while (*ptr != 0xff) {
                         reg = *ptr++;
                         data = *ptr++;
-                        if (ak->is_ak4528) {
-                                if (reg > 5)
-                                        continue;
-                                if (reg >= 4 && (data & 0x80))
-                                        continue;
-                        }
-                        if (reg == 0x03 && ak->is_ak4528)
-                                data = 0x0d;    /* deemphasis off, turn LR highpass filters on */
                         snd_ice1712_ak4524_write(ice, chip, reg, data);
                 }
         }
 }
+
+
+#define AK_GET_CHIP(val)                (((val) >> 8) & 0xff)
+#define AK_GET_ADDR(val)                ((val) & 0xff)
+#define AK_GET_SHIFT(val)               (((val) >> 16) & 0xff)
+#define AK_COMPOSE(chip,addr,shift)     (((chip) << 8) | (addr) | ((shift) << 16))
 
 static int snd_ice1712_ak4524_volume_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
@@ -179 +232 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int chip = kcontrol->private_value / 8;
-        int addr = kcontrol->private_value % 8;
+        int chip = AK_GET_CHIP(kcontrol->private_value);
+        int addr = AK_GET_ADDR(kcontrol->private_value);
         ucontrol->value.integer.value[0] = ice->ak4524.images[chip][addr];
         return 0;
@@ -188 +241 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int chip = kcontrol->private_value / 8;
-        int addr = kcontrol->private_value % 8;
+        int chip = AK_GET_CHIP(kcontrol->private_value);
+        int addr = AK_GET_ADDR(kcontrol->private_value);
         unsigned char nval = ucontrol->value.integer.value[0];
         int change = ice->ak4524.images[chip][addr] != nval;
@@ -209 +262 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int chip = kcontrol->private_value / 8;
-        int addr = kcontrol->private_value % 8;
+        int chip = AK_GET_CHIP(kcontrol->private_value);
+        int addr = AK_GET_ADDR(kcontrol->private_value);
         ucontrol->value.integer.value[0] = ice->ak4524.ipga_gain[chip][addr-4] & 0x7f;
         return 0;
@@ -218 +271 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int chip = kcontrol->private_value / 8;
-        int addr = kcontrol->private_value % 8;
+        int chip = AK_GET_CHIP(kcontrol->private_value);
+        int addr = AK_GET_ADDR(kcontrol->private_value);
         unsigned char nval = (ucontrol->value.integer.value[0] % 37) | 0x80;
         int change = ice->ak4524.ipga_gain[chip][addr] != nval;
@@ -244 +297 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int chip = kcontrol->id.index;
-        ucontrol->value.enumerated.item[0] = ice->ak4524.images[chip][3] & 3;
+        int chip = AK_GET_CHIP(kcontrol->private_value);
+        int addr = AK_GET_ADDR(kcontrol->private_value);
+        int shift = AK_GET_SHIFT(kcontrol->private_value);
+        ucontrol->value.enumerated.item[0] = (ice->ak4524.images[chip][addr] >> shift) & 3;
         return 0;
 }
@@ -252 +307 @@
 {
         ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int chip = kcontrol->id.index;
-        unsigned char nval = ucontrol->value.enumerated.item[0];
+        int chip = AK_GET_CHIP(kcontrol->private_value);
+        int addr = AK_GET_ADDR(kcontrol->private_value);
+        int shift = AK_GET_SHIFT(kcontrol->private_value);
+        unsigned char nval = ucontrol->value.enumerated.item[0] & 3;
         int change;
-        nval |= (nval & 3) | (ice->ak4524.images[chip][3] & ~3);
-        change = ice->ak4524.images[chip][3] != nval;
+        
+        nval = (nval << shift) | (ice->ak4524.images[chip][addr] & ~(3 << shift));
+        change = ice->ak4524.images[chip][addr] != nval;
         if (change)
-                snd_ice1712_ak4524_write(ice, chip, 3, nval);
+                snd_ice1712_ak4524_write(ice, chip, addr, nval);
         return change;
 }
@@ -281 +339 @@
                         ctl.get = snd_ice1712_ak4524_volume_get;
                         ctl.put = snd_ice1712_ak4524_volume_put;
-                if (ak->is_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 */
+                switch (ak->type) {
+                case SND_AK4524:
+                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 6, 0); /* register 6 & 7 */
+                        break;
+                case SND_AK4528:
+                        ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
+                        break;
+                case SND_AK4529: {
+                        int val = idx < 6 ? idx + 2 : (idx - 6) + 0xb; /* registers 2-7 and b,c */
+                        ctl.private_value = AK_COMPOSE(0, val, 0);
+                        break;
+                }
+                }
                         ctl.private_data = ice;
                         if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
                                 return err;
                 }
-        for (idx = 0; idx < ak->num_adcs && !ak->is_ak4528; ++idx) {
+        for (idx = 0; idx < ak->num_adcs && ak->type == SND_AK4524; ++idx) {
                         snd_kcontrol_t ctl;
                         memset(&ctl, 0, sizeof(ctl));
@@ -299 +366 @@
                         ctl.get = snd_ice1712_ak4524_volume_get;
                         ctl.put = snd_ice1712_ak4524_volume_put;
-                        ctl.private_value = (idx / 2) * 8 + (idx % 2) + 4; /* register 4 & 5 */
+                ctl.private_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
                         ctl.private_data = ice;
                         if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
@@ -311 +378 @@
                         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_value = AK_COMPOSE(idx/2, (idx%2) + 4, 0); /* register 4 & 5 */
                         ctl.private_data = ice;
                         if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)
@@ -326 +393 @@
                         ctl.get = snd_ice1712_ak4524_deemphasis_get;
                         ctl.put = snd_ice1712_ak4524_deemphasis_put;
+                switch (ak->type) {
+                case SND_AK4524:
+                case SND_AK4528:
+                        ctl.private_value = AK_COMPOSE(idx, 3, 0); /* register 3 */
+                        break;
+                case SND_AK4529: {
+                        int shift = idx == 3 ? 6 : (2 - idx) * 2;
+                        ctl.private_value = AK_COMPOSE(0, 8, shift); /* register 8 with shift */
+                        break;
+                }
+                }
                         ctl.private_data = ice;
                         if ((err = snd_ctl_add(ice->card, snd_ctl_new(&ctl))) < 0)

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

@@ -258 +258 @@
  * change the rate of AK4524 on Delta 44/66, AP, 1010LT
  */
-static void delta_ak4524_set_rate_val(ice1712_t *ice, unsigned char val)
+static void delta_ak4524_set_rate_val(ice1712_t *ice, unsigned int rate)
 {
         unsigned char tmp, tmp2;
+
+        if (rate == 0)  /* no hint - S/PDIF input is master, simply return */
+                return;
 
         /* check before reset ak4524 to avoid unnecessary clicks */
@@ -268 +271 @@
         tmp2 = tmp;
         tmp2 &= ~ICE1712_DELTA_DFS; 
-        if (val == 15 || val == 11 || val == 7)
+        if (rate > 48000)
                 tmp2 |= ICE1712_DELTA_DFS;
         if (tmp == tmp2)
@@ -276 +279 @@
         snd_ice1712_ak4524_reset(ice, 1);
         down(&ice->gpio_mutex);
-        tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA);
-        if (val == 15 || val == 11 || val == 7) {
+        tmp = snd_ice1712_read(ice, ICE1712_IREG_GPIO_DATA) & ~ICE1712_DELTA_DFS;
+        if (rate > 48000)
                 tmp |= ICE1712_DELTA_DFS;
-        } else {
-                tmp &= ~ICE1712_DELTA_DFS;
-        }
         snd_ice1712_write(ice, ICE1712_IREG_GPIO_DATA, tmp);
         up(&ice->gpio_mutex);
@@ -338 +338 @@
                 ice->num_total_dacs = 2;
                 break;
+        case ICE1712_SUBDEVICE_DELTA410:
+                ice->num_total_dacs = 8;
+                break;
         case ICE1712_SUBDEVICE_DELTA44:
         case ICE1712_SUBDEVICE_DELTA66:
@@ -351 +354 @@
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_AUDIOPHILE:
+        case ICE1712_SUBDEVICE_DELTA410:
         case ICE1712_SUBDEVICE_DELTA1010LT:
                 if ((err = snd_i2c_bus_create(ice->card, "ICE1712 GPIO 1", NULL, &ice->i2c)) < 0) {
@@ -379 +383 @@
         switch (ice->eeprom.subvendor) {
         case ICE1712_SUBDEVICE_AUDIOPHILE:
+        case ICE1712_SUBDEVICE_DELTA410:
                 ak->num_adcs = ak->num_dacs = 2;
-                ak->is_ak4528 = 1;
-                ak->cif = 0; /* the default level of the CIF pin from AK4524 */
+                ak->type = SND_AK4528;
+                if (ice->eeprom.subvendor == ICE1712_SUBDEVICE_DELTA410) {
+                        ak->num_dacs = 8;
+                        ak->type = SND_AK4529;
+                }
+                ak->cif = 0; /* the default level of the CIF pin from AK4528/4529 */
                 ak->data_mask = ICE1712_DELTA_AP_DOUT;
                 ak->clk_mask = ICE1712_DELTA_AP_CCLK;
-                ak->cs_mask = ak->cs_addr = ICE1712_DELTA_AP_CS_CODEC; /* select AK4528 codec */
+                ak->cs_mask = ak->cs_addr = ICE1712_DELTA_AP_CS_CODEC; /* select AK4528/4529 codec */
                 ak->cs_none = 0;
                 ak->add_flags = ICE1712_DELTA_AP_CS_DIGITAL; /* assert digital high */
@@ -393 +402 @@
         case ICE1712_SUBDEVICE_DELTA1010LT:
                 ak->num_adcs = ak->num_dacs = 8;
+                ak->type = SND_AK4524;
                 ak->cif = 0; /* the default level of the CIF pin from AK4524 */
                 ak->data_mask = ICE1712_DELTA_1010LT_DOUT;
@@ -407 +417 @@
         case ICE1712_SUBDEVICE_DELTA44:
                 ak->num_adcs = ak->num_dacs = 4;
+                ak->type = SND_AK4524;
                 ak->cif = 0; /* the default level of the CIF pin from AK4524 */
                 ak->data_mask = ICE1712_DELTA_CODEC_SERIAL_DATA;
@@ -472 +483 @@
         case ICE1712_SUBDEVICE_DELTA66:
         case ICE1712_SUBDEVICE_AUDIOPHILE:
+        case ICE1712_SUBDEVICE_DELTA410:
+        case ICE1712_SUBDEVICE_DELTA1010LT:
                 err = snd_ice1712_spdif_build_controls(ice);
                 if (err < 0)
@@ -491 +504 @@
         /* ak4524 controls */
         switch (ice->eeprom.subvendor) {
+        case ICE1712_SUBDEVICE_DELTA1010LT:
         case ICE1712_SUBDEVICE_AUDIOPHILE:
+        case ICE1712_SUBDEVICE_DELTA410:
         case ICE1712_SUBDEVICE_DELTA44:
         case ICE1712_SUBDEVICE_DELTA66:
@@ -539 +554 @@
         },
         {
+                ICE1712_SUBDEVICE_DELTA410,
+                "M Audio Delta 410",
+                snd_ice1712_delta_init,
+                snd_ice1712_delta_add_controls,
+        },
+        {
                 ICE1712_SUBDEVICE_DELTA1010LT,
                 "M Audio Delta 1010LT",

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

@@ -38 +38 @@
 #define ICE1712_SUBDEVICE_DELTA44       0x121433d6
 #define ICE1712_SUBDEVICE_AUDIOPHILE    0x121434d6
+#define ICE1712_SUBDEVICE_DELTA410      0x121438d6
 #define ICE1712_SUBDEVICE_DELTA1010LT   0x12143bd6
 
@@ -107 +108 @@
 /* 0x80 = CODEC_CHIP_B */
 
-/* MidiMan M-Audio Audiophile definitions */
+/* MidiMan M-Audio Audiophile/Delta410 definitions */
+/* thanks to Kristof Pelckmans <Kristof.Pelckmans@antwerpen.be> for Delta410 info */
 /* 0x01 = DFS */
 #define ICE1712_DELTA_AP_CCLK   0x02    /* SPI clock */
@@ -115 +117 @@
 #define ICE1712_DELTA_AP_CS_DIGITAL 0x10 /* CS8427 chip select */
                                         /* low signal = select */
-#define ICE1712_DELTA_AP_CS_CODEC 0x20  /* AK4528 chip select */
+#define ICE1712_DELTA_AP_CS_CODEC 0x20  /* AK4528 (audiophile), AK4529 (Delta410) chip select */
                                         /* low signal = select */
 

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

@@ -407 +407 @@
         case ICE1712_SUBDEVICE_EWS88MT:
                 ak->num_adcs = ak->num_dacs = 8;
+                ak->type = SND_AK4524;
                 ak->cif = 1; /* CIF high */
                 ak->data_mask = ICE1712_EWS88_SERIAL_DATA;
@@ -419 +420 @@
         case ICE1712_SUBDEVICE_EWX2496:
                 ak->num_adcs = ak->num_dacs = 2;
+                ak->type = SND_AK4524;
                 ak->cif = 1; /* CIF high */
                 ak->data_mask = ICE1712_EWS88_SERIAL_DATA;
@@ -431 +433 @@
         case ICE1712_SUBDEVICE_DMX6FIRE:
                 ak->num_adcs = ak->num_dacs = 6;
+                ak->type = SND_AK4524;
                 ak->cif = 1; /* CIF high */
                 ak->data_mask = ICE1712_6FIRE_SERIAL_DATA;

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

@@ -105 +105 @@
 static int snd_ice1712_build_controls(ice1712_t *ice);
 
+static int PRO_RATE_LOCKED = 0;
+static int PRO_RATE_RESET = 1;
+static unsigned int PRO_RATE_DEFAULT = 44100;
+
 /*
  *  Basic I/O
  */
+ 
+static inline int is_spdif_master(ice1712_t *ice)
+{
+        return (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER) ? 1 : 0;
+}
+
+static inline int is_pro_rate_locked(ice1712_t *ice)
+{
+        return is_spdif_master(ice) || PRO_RATE_LOCKED;
+}
 
 static inline void snd_ice1712_ds_write(ice1712_t * ice, u8 channel, u8 addr, u32 data)
@@ -981 +995 @@
 /*
  */
-static void snd_ice1712_set_pro_rate(ice1712_t *ice, snd_pcm_substream_t *substream)
+static void snd_ice1712_set_pro_rate(ice1712_t *ice, unsigned int rate, int do_not_lock)
 {
         unsigned long flags;
-        unsigned int rate;
         unsigned char val;
+        int old_lock_value;
 
         spin_lock_irqsave(&ice->reg_lock, flags);
-        if ((inb(ICEMT(ice, PLAYBACK_CONTROL)) & (ICE1712_CAPTURE_START_SHADOW|
+        old_lock_value = PRO_RATE_LOCKED;
+        if (do_not_lock)
+                PRO_RATE_LOCKED = 0;
+        if (inb(ICEMT(ice, PLAYBACK_CONTROL)) & (ICE1712_CAPTURE_START_SHADOW|
                                                   ICE1712_PLAYBACK_PAUSE|
-                                                  ICE1712_PLAYBACK_START)) ||
-            (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER)) {
+                                                 ICE1712_PLAYBACK_START)) {
                 spin_unlock_irqrestore(&ice->reg_lock, flags);
                 return;
         }
-        rate = substream->runtime->rate;
+        if (!is_pro_rate_locked(ice))
+                goto __unlock;
+
         switch (rate) {
         case 8000: val = 6; break;
@@ -1016 +1034 @@
         }
         outb(val, ICEMT(ice, RATE));
+        PRO_RATE_LOCKED = old_lock_value;
+
+      __unlock:
         spin_unlock_irqrestore(&ice->reg_lock, flags);
 
         if (ice->ak4524.ops.set_rate_val)
-                ice->ak4524.ops.set_rate_val(ice, val);
+                ice->ak4524.ops.set_rate_val(ice, rate);
 }
 
@@ -1028 +1049 @@
 
         ice->playback_pro_size = snd_pcm_lib_buffer_bytes(substream);
-        snd_ice1712_set_pro_rate(ice, substream);
+        snd_ice1712_set_pro_rate(ice, substream->runtime->rate, 0);
         spin_lock_irqsave(&ice->reg_lock, flags);
         outl(substream->runtime->dma_addr, ICEMT(ice, PLAYBACK_ADDR));
@@ -1047 +1068 @@
 
         ice->capture_pro_size = snd_pcm_lib_buffer_bytes(substream);
-        snd_ice1712_set_pro_rate(ice, substream);
+        snd_ice1712_set_pro_rate(ice, substream->runtime->rate, 0);
         spin_lock_irqsave(&ice->reg_lock, flags);
         outl(substream->runtime->dma_addr, ICEMT(ice, CAPTURE_ADDR));
@@ -1152 +1173 @@
         ice1712_t *ice = snd_pcm_substream_chip(substream);
 
+        if (PRO_RATE_RESET)
+                snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 0);
         ice->playback_pro_substream = NULL;
         if (ice->spdif.ops.close)
@@ -1163 +1186 @@
         ice1712_t *ice = snd_pcm_substream_chip(substream);
 
+        if (PRO_RATE_RESET)
+                snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 0);
         ice->capture_pro_substream = NULL;
         return 0;
@@ -1496 +1521 @@
 }
 
-static void __exit snd_ice1712_proc_done(ice1712_t * ice)
+static void snd_ice1712_proc_done(ice1712_t * ice)
 {
         if (ice->proc_entry) {
@@ -1533 +1558 @@
 /*
  */
-static int snd_ice1712_spdif_default_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_ice1712_spdif_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
@@ -1562 +1587 @@
         .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
-        .info =         snd_ice1712_spdif_default_info,
+        .info =         snd_ice1712_spdif_info,
         .get =          snd_ice1712_spdif_default_get,
         .put =          snd_ice1712_spdif_default_put
 };
-
-static int snd_ice1712_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
-        uinfo->count = 1;
-        return 0;
-}
 
 static int snd_ice1712_spdif_maskc_get(snd_kcontrol_t * kcontrol,
@@ -1621 +1639 @@
         .iface =                SNDRV_CTL_ELEM_IFACE_MIXER,
         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
-        .info =         snd_ice1712_spdif_mask_info,
+        .info =         snd_ice1712_spdif_info,
         .get =          snd_ice1712_spdif_maskc_get,
 };
@@ -1630 +1648 @@
         .iface =                SNDRV_CTL_ELEM_IFACE_MIXER,
         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,PRO_MASK),
-        .info =         snd_ice1712_spdif_mask_info,
+        .info =         snd_ice1712_spdif_info,
         .get =          snd_ice1712_spdif_maskp_get,
 };
-
-static int snd_ice1712_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
-{
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
-        uinfo->count = 1;
-        return 0;
-}
 
 static int snd_ice1712_spdif_stream_get(snd_kcontrol_t * kcontrol,
@@ -1664 +1675 @@
         .iface =                SNDRV_CTL_ELEM_IFACE_PCM,
         .name =           SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
-        .info =         snd_ice1712_spdif_stream_info,
+        .info =         snd_ice1712_spdif_info,
         .get =          snd_ice1712_spdif_stream_get,
         .put =          snd_ice1712_spdif_stream_put
@@ -1710 +1721 @@
 }
 
-static int snd_ice1712_pro_spdif_master_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+/*
+ *  rate
+ */
+static int snd_ice1712_pro_internal_clock_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+{
+        static char *texts[] = {
+                "8000",         /* 0: 6 */
+                "9600",         /* 1: 3 */
+                "11025",        /* 2: 10 */
+                "12000",        /* 3: 2 */
+                "16000",        /* 4: 5 */
+                "22050",        /* 5: 9 */
+                "24000",        /* 6: 1 */
+                "32000",        /* 7: 4 */
+                "44100",        /* 8: 8 */
+                "48000",        /* 9: 0 */
+                "64000",        /* 10: 15 */
+                "88200",        /* 11: 11 */
+                "96000",        /* 12: 7 */
+                "IEC958 Input", /* 13: -- */
+        };
+        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+        uinfo->count = 1;
+        uinfo->value.enumerated.items = 14;
+        if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
+                uinfo->value.enumerated.item = uinfo->value.enumerated.items - 1;
+        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
+        return 0;
+}
+
+static int snd_ice1712_pro_internal_clock_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+        static unsigned char xlate[16] = {
+                9, 6, 3, 1, 7, 4, 0, 12, 8, 5, 2, 11, 255, 255, 255, 10
+        };
+        unsigned char val;
+        
+        spin_lock_irq(&ice->reg_lock);
+        if (is_spdif_master(ice)) {
+                ucontrol->value.enumerated.item[0] = 13;
+        } else {
+                val = xlate[inb(ICEMT(ice, RATE)) & 15];
+                if (val == 255) {
+                        snd_BUG();
+                        val = 0;
+                }
+                ucontrol->value.enumerated.item[0] = val;
+        }
+        spin_unlock_irq(&ice->reg_lock);
+        return 0;
+}
+
+static int snd_ice1712_pro_internal_clock_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
+        static unsigned int xrate[13] = {
+                8000, 9600, 11025, 12000, 1600, 22050, 24000,
+                32000, 44100, 48000, 64000, 88200, 96000
+        };
+        unsigned char oval;
+        int change = 0;
+
+        spin_lock_irq(&ice->reg_lock);
+        oval = inb(ICEMT(ice, RATE));
+        if (ucontrol->value.enumerated.item[0] == 13) {
+                outb(oval | ICE1712_SPDIF_MASTER, ICEMT(ice, RATE));
+        } else {
+                PRO_RATE_DEFAULT = xrate[ucontrol->value.integer.value[0] % 13];
+                snd_ice1712_set_pro_rate(ice, PRO_RATE_DEFAULT, 1);
+        }
+        change = inb(ICEMT(ice, RATE)) != oval;
+
+        if ((oval & ICE1712_SPDIF_MASTER) != (inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER)) {
+                /* change CS8427 clock source too */
+                if (ice->cs8427) {
+                        snd_ice1712_cs8427_set_input_clock(ice, is_spdif_master(ice));
+                }
+                /* notify ak4524 chip as well */
+                if (is_spdif_master(ice) && ice->ak4524.ops.set_rate_val)
+                        ice->ak4524.ops.set_rate_val(ice, 0);
+        }
+
+        return change;
+}
+
+static snd_kcontrol_new_t snd_ice1712_pro_internal_clock = __devinitdata {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Multi Track Internal Clock",
+        .info = snd_ice1712_pro_internal_clock_info,
+        .get = snd_ice1712_pro_internal_clock_get,
+        .put = snd_ice1712_pro_internal_clock_put
+};
+
+static int snd_ice1712_pro_rate_locking_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
@@ -1719 +1824 @@
 }
 
-static int snd_ice1712_pro_spdif_master_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
-{
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        unsigned long flags;
-        
-        spin_lock_irqsave(&ice->reg_lock, flags);
-        ucontrol->value.integer.value[0] = inb(ICEMT(ice, RATE)) & ICE1712_SPDIF_MASTER ? 1 : 0;
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
-        return 0;
-}
-
-static int snd_ice1712_pro_spdif_master_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
-{
-        unsigned long flags;
-        ice1712_t *ice = snd_kcontrol_chip(kcontrol);
-        int nval, change;
-
-        nval = ucontrol->value.integer.value[0] ? ICE1712_SPDIF_MASTER : 0;
-        spin_lock_irqsave(&ice->reg_lock, flags);
-        nval |= inb(ICEMT(ice, RATE)) & ~ICE1712_SPDIF_MASTER;
-        change = inb(ICEMT(ice, RATE)) != nval;
-        outb(nval, ICEMT(ice, RATE));
-        spin_unlock_irqrestore(&ice->reg_lock, flags);
-
-        if (ice->cs8427) {
-                /* change CS8427 clock source too */
-                snd_ice1712_cs8427_set_input_clock(ice, ucontrol->value.integer.value[0]);
-        }
-
+static int snd_ice1712_pro_rate_locking_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        ucontrol->value.integer.value[0] = PRO_RATE_LOCKED ? 1 : 0;
+        return 0;
+}
+
+static int snd_ice1712_pro_rate_locking_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        int change = 0;
+
+        change = PRO_RATE_LOCKED ? 1 : 0 != ucontrol->value.integer.value[0] ? 1 : 0;
+        PRO_RATE_LOCKED = ucontrol->value.integer.value[0] ? 1 : 0;
         return change;
 }
 
-static snd_kcontrol_new_t snd_ice1712_pro_spdif_master __devinitdata = {
+static snd_kcontrol_new_t snd_ice1712_pro_rate_locking __devinitdata = {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "Multi Track IEC958 Master",
-        .info = snd_ice1712_pro_spdif_master_info,
-        .get = snd_ice1712_pro_spdif_master_get,
-        .put = snd_ice1712_pro_spdif_master_put
+        .name = "Multi Track Rate Locking",
+        .info = snd_ice1712_pro_rate_locking_info,
+        .get = snd_ice1712_pro_rate_locking_get,
+        .put = snd_ice1712_pro_rate_locking_put
+};
+
+static int snd_ice1712_pro_rate_reset_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_pro_rate_reset_get(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        ucontrol->value.integer.value[0] = PRO_RATE_RESET ? 1 : 0;
+        return 0;
+}
+
+static int snd_ice1712_pro_rate_reset_put(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
+{
+        int change = 0;
+
+        change = PRO_RATE_LOCKED ? 1 : 0 != ucontrol->value.integer.value[0] ? 1 : 0;
+        PRO_RATE_RESET = ucontrol->value.integer.value[0] ? 1 : 0;
+        return change;
+}
+
+static snd_kcontrol_new_t snd_ice1712_pro_rate_reset __devinitdata = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "Multi Track Rate Reset",
+        .info = snd_ice1712_pro_rate_reset_info,
+        .get = snd_ice1712_pro_rate_reset_get,
+        .put = snd_ice1712_pro_rate_reset_put
 };
 
@@ -2128 +2248 @@
         if (err < 0)
                 return err;
-        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_spdif_master, ice));
+        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_internal_clock, ice));
+        if (err < 0)
+                return err;
+        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_rate_locking, ice));
+        if (err < 0)
+                return err;
+        err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_ice1712_pro_rate_reset, ice));
         if (err < 0)
                 return err;
@@ -2298 +2424 @@
 /*
  *
- * Registraton
+ * Registration
  *
  */

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

@@ -240 +240 @@
         int num_adcs;                   /* AK4524 or AK4528 ADCs */
         int num_dacs;                   /* AK4524 or AK4528 DACs */
-        unsigned char images[4][8];
+        unsigned char images[4][16];
         unsigned char ipga_gain[4][2];
         /* */
-        unsigned int is_ak4528: 1;      /* AK4524 or AK4528 */
+        enum {
+                SND_AK4524, SND_AK4528, SND_AK4529
+        } type;
         unsigned int cif: 1;
         unsigned char data_mask;
@@ -255 +257 @@
                 int (*start)(ice1712_t *, unsigned char *, int);
                 void (*stop)(ice1712_t *, unsigned char *);
-                void (*set_rate_val)(ice1712_t *, unsigned char);
+                void (*set_rate_val)(ice1712_t *, unsigned int);
         } ops;
 };

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

@@ -26 +26 @@
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 
-    hammerfall_mem.c,v 1.4 2002/10/21 18:28:25 perex Exp
+    hammerfall_mem.c,v 1.5 2002/11/04 09:11:42 perex Exp
 
 
@@ -38 +38 @@
 #include <sound/driver.h>
 #endif
-#include <linux/config.h>
 #include <linux/version.h>
 #include <linux/module.h>

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

@@ -950 +950 @@
         if (up) {
                 if (!hmidi->istimer) {
+                        init_timer(&hmidi->timer);
                         hmidi->timer.function = snd_hdsp_midi_output_timer;
                         hmidi->timer.data = (unsigned long) hmidi;