Changeset 77 for GPL/trunk/alsa-kernel/pci/ac97

Timestamp:

Jul 23, 2006, 11:54:27 AM (19 years ago)

Author:

vladest

Message:

Provide sources to latest exist binary. See changelog for changes

Location:

GPL/trunk/alsa-kernel/pci/ac97

Files:

• ac97_codec.c (modified) (21 diffs)
• ac97_patch.c (modified) (7 diffs)
• ac97_patch.h (modified) (1 diff)
• ac97_pcm.c (modified) (4 diffs)

GPL/trunk/alsa-kernel/pci/ac97/ac97_codec.c

@@ -47 +47 @@
 MODULE_PARM_DESC(enable_loopback, "Enable AC97 ADC/DAC Loopback Control");
 
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+static int power_save = 1;
+//module_param(power_save, bool, 0644);
+MODULE_PARM_DESC(power_save, "Enable AC97 power-saving control");
+#endif
 /*
 
@@ -152 +157 @@
 { 0x4e534350, 0xffffffff, "LM4550",             NULL,           NULL },
 { 0x4e534350, 0xffffffff, "LM4550",             patch_lm4550,   NULL }, // volume wrap fix
-{ 0x50534304, 0xffffffff, "UCB1400",            NULL,           NULL },
+{ 0x50534304, 0xffffffff, "UCB1400",            patch_ucb1400,  NULL },
 { 0x53494c20, 0xffffffe0, "Si3036,8",           mpatch_si3036,  mpatch_si3036, AC97_MODEM_PATCH },
 { 0x54524102, 0xffffffff, "TR28022",            NULL,           NULL },
@@ -186 +191 @@
 };
 
+static void update_power_regs(struct snd_ac97 *ac97);
 
 /*
@@ -543 +549 @@
         }
         err = snd_ac97_update_bits(ac97, reg, val_mask, val);
-        snd_ac97_page_restore(ac97, page_save);
+        snd_ac97_page_restore(ac97, page_save);
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+        /* check analog mixer power-down */
+        if ((val_mask & 0x8000) &&
+            (kcontrol->private_value & (1<<30))) {
+                if (val & 0x8000)
+                        ac97->power_up &= ~(1 << (reg>>1));
+                else
+                        ac97->power_up |= 1 << (reg>>1);
+                if (power_save)
+                        update_power_regs(ac97);
+        }
+#endif
         return err;
 }
@@ -951 +969 @@
 static int snd_ac97_free(struct snd_ac97 *ac97)
 {
-        if (ac97) {
-                snd_ac97_proc_done(ac97);
-                if (ac97->bus)
-                        ac97->bus->codec[ac97->num] = NULL;
-                if (ac97->private_free)
-                        ac97->private_free(ac97);
-                kfree(ac97);
-        }
-        return 0;
+    if (ac97) {
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+        if (ac97->power_workq)
+            destroy_workqueue(ac97->power_workq);
+#endif
+        snd_ac97_proc_done(ac97);
+        if (ac97->bus)
+            ac97->bus->codec[ac97->num] = NULL;
+        if (ac97->private_free)
+            ac97->private_free(ac97);
+        kfree(ac97);
+    }
+    return 0;
 }
 
@@ -1107 +1129 @@
  * create mute switch(es) for normal stereo controls
  */
-static int snd_ac97_cmute_new_stereo(struct snd_card *card, char *name, int reg, int check_stereo, struct snd_ac97 *ac97)
+static int snd_ac97_cmute_new_stereo(struct snd_card *card, char *name, int reg,
+                                     int check_stereo, int check_amix,
+                                     struct snd_ac97 *ac97)
 {
         struct snd_kcontrol *kctl;
@@ -1135 +1159 @@
         if (mute_mask == 0x8080) {
             tmp.private_value = reg | (15 << 8) | (7 << 12) | (1 << 16) | (1 << 24);
+            if (check_amix)
+                tmp.private_value |= (1 << 30);
         } else {
             tmp.private_value = reg | (15 << 8) | (1 << 16) | (1 << 24);
+            if (check_amix)
+                tmp.private_value |= (1 << 30);
         }
         kctl = snd_ctl_new1(&tmp, ac97);
@@ -1212 +1240 @@
  * create a mute-switch and a volume for normal stereo/mono controls
  */
-static int snd_ac97_cmix_new_stereo(struct snd_card *card, const char *pfx, int reg, int check_stereo, struct snd_ac97 *ac97)
+static int snd_ac97_cmix_new_stereo(struct snd_card *card, const char *pfx,
+                                    int reg, int check_stereo, int check_amix,
+                                    struct snd_ac97 *ac97)
 {
         int err;
@@ -1222 +1252 @@
 
         if (snd_ac97_try_bit(ac97, reg, 15)) {
-                sprintf(name, "%s Switch", pfx);
-                if ((err = snd_ac97_cmute_new_stereo(card, name, reg, check_stereo, ac97)) < 0)
+            sprintf(name, "%s Switch", pfx);
+            if ((err = snd_ac97_cmute_new_stereo(card, name, reg,
+                                                 check_stereo, check_amix,
+                                                 ac97)) < 0)
                         return err;
         }
@@ -1235 +1267 @@
 }
 
-#define snd_ac97_cmix_new(card, pfx, reg, ac97) snd_ac97_cmix_new_stereo(card, pfx, reg, 0, ac97)
-#define snd_ac97_cmute_new(card, name, reg, ac97)       snd_ac97_cmute_new_stereo(card, name, reg, 0, ac97)
+#define snd_ac97_cmix_new(card, pfx, reg, acheck, ac97) \
+        snd_ac97_cmix_new_stereo(card, pfx, reg, 0, acheck, ac97)
+#define snd_ac97_cmute_new(card, name, reg, acheck, ac97) \
+        snd_ac97_cmute_new_stereo(card, name, reg, 0, acheck, ac97)
 
 static unsigned int snd_ac97_determine_spdif_rates(struct snd_ac97 *ac97);
@@ -1252 +1286 @@
         if (snd_ac97_try_volume_mix(ac97, AC97_MASTER)) {
 #ifndef TARGET_OS2
-                if (ac97->flags & AC97_HAS_NO_MASTER_VOL)
-                        err = snd_ac97_cmute_new(card, "Master Playback Switch", AC97_MASTER, ac97);
-                else
+            if (ac97->flags & AC97_HAS_NO_MASTER_VOL)
+                err = snd_ac97_cmute_new(card, "Master Playback Switch",
+                                         AC97_MASTER, 0, ac97);
+            else
 #endif
-                        err = snd_ac97_cmix_new(card, "Master Playback", AC97_MASTER, ac97);
-                if (err < 0)
-                        return err;
+                err = snd_ac97_cmix_new(card, "Master Playback",
+                                        AC97_MASTER, 0, ac97);
+            if (err < 0)
+                return err;
         }
 
         ac97->regs[AC97_CENTER_LFE_MASTER] = 0x8080;
 
-        /* build center controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER)) {
+        /* build center controls */
+        if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER))
+            && !(ac97->flags & AC97_AD_MULTI)) {
                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_center[0], ac97))) < 0)
                         return err;
@@ -1275 +1312 @@
         }
 
-        /* build LFE controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER+1)) {
+        /* build LFE controls */
+        if ((snd_ac97_try_volume_mix(ac97, AC97_CENTER_LFE_MASTER+1))
+            && !(ac97->flags & AC97_AD_MULTI)) {
                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_lfe[0], ac97))) < 0)
                         return err;
@@ -1287 +1325 @@
         }
 
-        /* build surround controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_SURROUND_MASTER)) {
-                /* Surround Master (0x38) is with stereo mutes */
-                if ((err = snd_ac97_cmix_new_stereo(card, "Surround Playback", AC97_SURROUND_MASTER, 1, ac97)) < 0)
+        /* build surround controls */
+        if ((snd_ac97_try_volume_mix(ac97, AC97_SURROUND_MASTER))
+            && !(ac97->flags & AC97_AD_MULTI)) {
+            /* Surround Master (0x38) is with stereo mutes */
+            if ((err = snd_ac97_cmix_new_stereo(card, "Surround Playback",
+                                                AC97_SURROUND_MASTER, 1, 0,
+                                                ac97)) < 0)
                         return err;
         }
 
         /* build headphone controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_HEADPHONE)) {
-                if ((err = snd_ac97_cmix_new(card, "Headphone Playback", AC97_HEADPHONE, ac97)) < 0)
-                        return err;
+        if (snd_ac97_try_volume_mix(ac97, AC97_HEADPHONE)) {
+            if ((err = snd_ac97_cmix_new(card, "Headphone Playback",
+                                         AC97_HEADPHONE, 0, ac97)) < 0)
+                return err;
         }
 
         /* build master mono controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_MONO)) {
-                if ((err = snd_ac97_cmix_new(card, "Master Mono Playback", AC97_MASTER_MONO, ac97)) < 0)
-                        return err;
+        if (snd_ac97_try_volume_mix(ac97, AC97_MASTER_MONO)) {
+            if ((err = snd_ac97_cmix_new(card, "Master Mono Playback",
+                                         AC97_MASTER_MONO, 0, ac97)) < 0)
+                return err;
         }
 
@@ -1334 +1377 @@
         /* build Phone controls */
         if (!(ac97->flags & AC97_HAS_NO_PHONE)) {
-                if (snd_ac97_try_volume_mix(ac97, AC97_PHONE)) {
-                        if ((err = snd_ac97_cmix_new(card, "Phone Playback", AC97_PHONE, ac97)) < 0)
-                                return err;
-                }
-        }
+            if (snd_ac97_try_volume_mix(ac97, AC97_PHONE)) {
+                if ((err = snd_ac97_cmix_new(card, "Phone Playback",
+                                             AC97_PHONE, 1, ac97)) < 0)
+                    return err;
+            }
+        }
 
         /* build MIC controls */
         if (!(ac97->flags & AC97_HAS_NO_MIC)) {
-                if (snd_ac97_try_volume_mix(ac97, AC97_MIC)) {
-                        if ((err = snd_ac97_cmix_new(card, "Mic Playback", AC97_MIC, ac97)) < 0)
-                                return err;
-                        if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_mic_boost, ac97))) < 0)
-                                return err;
-                }
-        }
+            if (snd_ac97_try_volume_mix(ac97, AC97_MIC)) {
+                if ((err = snd_ac97_cmix_new(card, "Mic Playback",
+                                             AC97_MIC, 1, ac97)) < 0)
+                    return err;
+                if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_controls_mic_boost, ac97))) < 0)
+                    return err;
+            }
+        }
 
         /* build Line controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_LINE)) {
-                if ((err = snd_ac97_cmix_new(card, "Line Playback", AC97_LINE, ac97)) < 0)
-                        return err;
+        if (snd_ac97_try_volume_mix(ac97, AC97_LINE)) {
+            if ((err = snd_ac97_cmix_new(card, "Line Playback",
+                                         AC97_LINE, 1, ac97)) < 0)
+                return err;
         }
 
         /* build CD controls */
         if (!(ac97->flags & AC97_HAS_NO_CD)) {
-                if (snd_ac97_try_volume_mix(ac97, AC97_CD)) {
-                        if ((err = snd_ac97_cmix_new(card, "CD Playback", AC97_CD, ac97)) < 0)
-                                return err;
-                }
-        }
+            if (snd_ac97_try_volume_mix(ac97, AC97_CD)) {
+                if ((err = snd_ac97_cmix_new(card, "CD Playback",
+                                             AC97_CD, 1, ac97)) < 0)
+                    return err;
+            }
+        }
 
         /* build Video controls */
         if (!(ac97->flags & AC97_HAS_NO_VIDEO)) {
-                if (snd_ac97_try_volume_mix(ac97, AC97_VIDEO)) {
-                        if ((err = snd_ac97_cmix_new(card, "Video Playback", AC97_VIDEO, ac97)) < 0)
-                                return err;
-                }
-        }
-
-        /* build Aux controls */
-        if (snd_ac97_try_volume_mix(ac97, AC97_AUX)) {
-                if ((err = snd_ac97_cmix_new(card, "Aux Playback", AC97_AUX, ac97)) < 0)
-                        return err;
+            if (snd_ac97_try_volume_mix(ac97, AC97_VIDEO)) {
+                if ((err = snd_ac97_cmix_new(card, "Video Playback",
+                                             AC97_VIDEO, 1, ac97)) < 0)
+                    return err;
+            }
+        }
+
+        /* build Aux controls */
+        if (!(ac97->flags & AC97_HAS_NO_AUX)) {
+            if (snd_ac97_try_volume_mix(ac97, AC97_AUX)) {
+                if ((err = snd_ac97_cmix_new(card, "Aux Playback",
+                                             AC97_AUX, 1, ac97)) < 0)
+                    return err;
+            }
         }
 
@@ -1408 +1459 @@
             if (!(ac97->flags & AC97_HAS_NO_STD_PCM)) {
 #ifndef TARGET_OS2
-                        if (ac97->flags & AC97_HAS_NO_PCM_VOL)
-                                err = snd_ac97_cmute_new(card, "PCM Playback Switch", AC97_PCM, ac97);
-                        else
+                if (ac97->flags & AC97_HAS_NO_PCM_VOL)
+                    err = snd_ac97_cmute_new(card,
+                                             "PCM Playback Switch",
+                                             AC97_PCM, 0, ac97);
+                else
 #endif
-                                err = snd_ac97_cmix_new(card, "PCM Playback", AC97_PCM, ac97);
-                        if (err < 0)
-                                return err;
-                }
+                    err = snd_ac97_cmix_new(card, "PCM Playback",
+                                            AC97_PCM, 0, ac97);
+                if (err < 0)
+                    return err;
+            }
         }
 
@@ -1422 +1476 @@
                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_src, ac97))) < 0)
                         return err;
-                if (snd_ac97_try_bit(ac97, AC97_REC_GAIN, 15)) {
-                        if ((err = snd_ac97_cmute_new(card, "Capture Switch", AC97_REC_GAIN, ac97)) < 0)
-                                return err;
+                if (snd_ac97_try_bit(ac97, AC97_REC_GAIN, 15)) {
+                    err = snd_ac97_cmute_new(card, "Capture Switch",
+                                             AC97_REC_GAIN, 0, ac97);
+                    if (err < 0)
+                        return err;
                 }
                 if ((err = snd_ctl_add(card, snd_ac97_cnew(&snd_ac97_control_capture_vol, ac97))) < 0)
@@ -1858 +1914 @@
 static struct snd_ac97_build_ops null_build_ops;
 
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+static void do_update_power(void *data)
+{
+    update_power_regs(data);
+}
+#endif
+
 /**
  * snd_ac97_mixer - create an Codec97 component
@@ -1912 +1975 @@
         init_MUTEX(&ac97->reg_mutex);
         init_MUTEX(&ac97->page_mutex);
-
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+        ac97->power_workq = create_workqueue("ac97");
+        INIT_WORK(&ac97->power_work, do_update_power, ac97);
+#endif
 #ifdef CONFIG_PCI
         if (ac97->pci) {
@@ -2146 +2212 @@
                 }
         }
-        /* make sure the proper powerdown bits are cleared */
-        if (ac97->scaps && ac97_is_audio(ac97)) {
-                reg = snd_ac97_read(ac97, AC97_EXTENDED_STATUS);
-                if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
-                        reg &= ~AC97_EA_PRJ;
-                if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
-                        reg &= ~(AC97_EA_PRI | AC97_EA_PRK);
-                snd_ac97_write_cache(ac97, AC97_EXTENDED_STATUS, reg);
-        }
+        /* make sure the proper powerdown bits are cleared */
+        if (ac97_is_audio(ac97))
+            update_power_regs(ac97);
         snd_ac97_proc_init(ac97);
         if ((err = snd_device_new(card, SNDRV_DEV_CODEC, ac97, &ops)) < 0) {
@@ -2181 +2241 @@
         }
 
-        power = ac97->regs[AC97_POWERDOWN] | 0x8000;    /* EAPD */
-        power |= 0x4000;        /* Headphone amplifier powerdown */
-        power |= 0x0300;        /* ADC & DAC powerdown */
+/* surround, CLFE, mic powerdown */
+        power = ac97->regs[AC97_EXTENDED_STATUS];
+        if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
+                power |= AC97_EA_PRJ;
+        if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
+                power |= AC97_EA_PRI | AC97_EA_PRK;
+        power |= AC97_EA_PRL;
+        snd_ac97_write(ac97, AC97_EXTENDED_STATUS, power);
+
+        /* powerdown external amplifier */
+        if (ac97->scaps & AC97_SCAP_INV_EAPD)
+                power = ac97->regs[AC97_POWERDOWN] & ~AC97_PD_EAPD;
+        else if (! (ac97->scaps & AC97_SCAP_EAPD_LED))
+                power = ac97->regs[AC97_POWERDOWN] | AC97_PD_EAPD;
+        power |= AC97_PD_PR6;   /* Headphone amplifier powerdown */
+        power |= AC97_PD_PR0 | AC97_PD_PR1;     /* ADC & DAC powerdown */
         snd_ac97_write(ac97, AC97_POWERDOWN, power);
         udelay(100);
-        power |= 0x0400;        /* Analog Mixer powerdown (Vref on) */
-        snd_ac97_write(ac97, AC97_POWERDOWN, power);
-        udelay(100);
-#if 0
-        /* FIXME: this causes click noises on some boards at resume */
-        power |= 0x3800;        /* AC-link powerdown, internal Clk disable */
-        snd_ac97_write(ac97, AC97_POWERDOWN, power);
+        power |= AC97_PD_PR2 | AC97_PD_PR3;     /* Analog Mixer powerdown */
+        snd_ac97_write(ac97, AC97_POWERDOWN, power);
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+        if (power_save) {
+            udelay(100);
+            /* AC-link powerdown, internal Clk disable */
+            /* FIXME: this may cause click noises on some boards */
+            power |= AC97_PD_PR4 | AC97_PD_PR5;
+            snd_ac97_write(ac97, AC97_POWERDOWN, power);
+        }
 #endif
 }
 
+
+struct ac97_power_reg {
+    unsigned short reg;
+    unsigned short power_reg;
+    unsigned short mask;
+};
+
+enum { PWIDX_ADC, PWIDX_FRONT, PWIDX_CLFE, PWIDX_SURR, PWIDX_MIC, PWIDX_SIZE };
+
+static struct ac97_power_reg power_regs[PWIDX_SIZE] = {
+    [PWIDX_ADC] = { AC97_PCM_LR_ADC_RATE, AC97_POWERDOWN, AC97_PD_PR0},
+    [PWIDX_FRONT] = { AC97_PCM_FRONT_DAC_RATE, AC97_POWERDOWN, AC97_PD_PR1},
+    [PWIDX_CLFE] = { AC97_PCM_LFE_DAC_RATE, AC97_EXTENDED_STATUS,
+    AC97_EA_PRI | AC97_EA_PRK},
+    [PWIDX_SURR] = { AC97_PCM_SURR_DAC_RATE, AC97_EXTENDED_STATUS,
+    AC97_EA_PRJ},
+    [PWIDX_MIC] = { AC97_PCM_MIC_ADC_RATE, AC97_EXTENDED_STATUS,
+    AC97_EA_PRL},
+};
+
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+/**
+ * snd_ac97_update_power - update the powerdown register
+ * @ac97: the codec instance
+ * @reg: the rate register, e.g. AC97_PCM_FRONT_DAC_RATE
+ * @powerup: non-zero when power up the part
+ *
+ * Update the AC97 powerdown register bits of the given part.
+ */
+int snd_ac97_update_power(struct snd_ac97 *ac97, int reg, int powerup)
+{
+    int i;
+
+    if (! ac97)
+        return 0;
+
+    if (reg) {
+        /* SPDIF requires DAC power, too */
+        if (reg == AC97_SPDIF)
+            reg = AC97_PCM_FRONT_DAC_RATE;
+        for (i = 0; i < PWIDX_SIZE; i++) {
+            if (power_regs[i].reg == reg) {
+                if (powerup)
+                    ac97->power_up |= (1 << i);
+                else
+                    ac97->power_up &= ~(1 << i);
+                break;
+            }
+        }
+    }
+
+    if (! power_save)
+        return 0;
+
+    if (! powerup && ac97->power_workq)
+        /* adjust power-down bits after two seconds delay
+         * (for avoiding loud click noises for many (OSS) apps
+         *  that open/close frequently)
+         */
+        queue_delayed_work(ac97->power_workq, &ac97->power_work, HZ*2);
+    else
+        update_power_regs(ac97);
+
+    return 0;
+}
+
+EXPORT_SYMBOL(snd_ac97_update_power);
+#endif /* CONFIG_SND_AC97_POWER_SAVE */
+
+static void update_power_regs(struct snd_ac97 *ac97)
+{
+    unsigned int power_up, bits;
+    int i;
+
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+    if (power_save)
+        power_up = ac97->power_up;
+    else {
+#endif
+        power_up = (1 << PWIDX_FRONT) | (1 << PWIDX_ADC);
+        power_up |= (1 << PWIDX_MIC);
+        if (ac97->scaps & AC97_SCAP_SURROUND_DAC)
+            power_up |= (1 << PWIDX_SURR);
+        if (ac97->scaps & AC97_SCAP_CENTER_LFE_DAC)
+            power_up |= (1 << PWIDX_CLFE);
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+    }
+#endif
+    if (power_up) {
+        if (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2) {
+            /* needs power-up analog mix and vref */
+            snd_ac97_update_bits(ac97, AC97_POWERDOWN,
+                                 AC97_PD_PR3, 0);
+            msleep(1);
+            snd_ac97_update_bits(ac97, AC97_POWERDOWN,
+                                 AC97_PD_PR2, 0);
+        }
+    }
+    for (i = 0; i < PWIDX_SIZE; i++) {
+        if (power_up & (1 << i))
+            bits = 0;
+        else
+            bits = power_regs[i].mask;
+        snd_ac97_update_bits(ac97, power_regs[i].power_reg,
+                             power_regs[i].mask, bits);
+    }
+    if (! power_up) {
+        if (! (ac97->regs[AC97_POWERDOWN] & AC97_PD_PR2)) {
+            /* power down analog mix and vref */
+            snd_ac97_update_bits(ac97, AC97_POWERDOWN,
+                                 AC97_PD_PR2, AC97_PD_PR2);
+            snd_ac97_update_bits(ac97, AC97_POWERDOWN,
+                                 AC97_PD_PR3, AC97_PD_PR3);
+        }
+    }
+}
 
 #ifdef CONFIG_PM
@@ -2507 +2699 @@
         msw->put = master_mute_sw_put;
         snd_ac97_remove_ctl(ac97, "External Amplifier", NULL);
-        snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000, 0x8000); /* mute LED on */
+        snd_ac97_update_bits(ac97, AC97_POWERDOWN, 0x8000, 0x8000); /* mute LED on */
+        ac97->scaps |= AC97_SCAP_EAPD_LED;
         return 0;
 }

GPL/trunk/alsa-kernel/pci/ac97/ac97_patch.c

@@ -461 +461 @@
 int patch_wolfson05(struct snd_ac97 * ac97)
 {
-        /* WM9705, WM9710 */
-        ac97->build_ops = &patch_wolfson_wm9705_ops;
-        return 0;
+    /* WM9705, WM9710 */
+    ac97->build_ops = &patch_wolfson_wm9705_ops;
+#ifdef CONFIG_TOUCHSCREEN_WM9705
+    /* WM9705 touchscreen uses AUX and VIDEO for touch */
+    ac97->flags |= AC97_HAS_NO_VIDEO | AC97_HAS_NO_AUX;
+#endif
+    return 0;
 }
 
@@ -1366 +1370 @@
         snd_ac97_restore_iec958(ac97);
 }
+
+static void ad1888_resume(struct snd_ac97 *ac97)
+{
+    ad18xx_resume(ac97);
+    snd_ac97_write_cache(ac97, AC97_CODEC_CLASS_REV, 0x8080);
+}
+
 #endif
 
@@ -1626 +1637 @@
  */
 static unsigned int ad1981_jacks_blacklist[] = {
-        0x10140554, /* Thinkpad T42p/R50p */
-        0 /* end */
+    0x10140537, /* Thinkpad T41p */
+    0x10140554, /* Thinkpad T42p/R50p */
+    0 /* end */
 };
 
@@ -1810 +1822 @@
                 .get = snd_ac97_ad1888_lohpsel_get,
                 .put = snd_ac97_ad1888_lohpsel_put
-        },
+        },
+        AC97_SINGLE("V_REFOUT Enable", AC97_AD_MISC, 2, 1, 1),
+        AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2, 12, 1, 1),
         AC97_SINGLE("Spread Front to Surround and Center/LFE", AC97_AD_MISC, 7, 1, 0),
         {
@@ -1838 +1852 @@
         .build_specific = patch_ad1888_specific,
 #ifdef CONFIG_PM
-        .resume = ad18xx_resume,
+        .resume = ad1888_resume,
 #endif
         .update_jacks = ad1888_update_jacks,
@@ -2046 +2060 @@
         /* Enable SPDIF-IN only on Rev.E and above */
         val = snd_ac97_read(ac97, AC97_ALC650_CLOCK);
-        /* SPDIF IN with pin 47 */
-        if (ac97->spec.dev_flags)
-                val |= 0x03; /* enable */
-        else
-                val &= ~0x03; /* disable */
+        /* SPDIF IN with pin 47 */
+        if (ac97->spec.dev_flags &&
+            /* ASUS A6KM requires EAPD */
+            ! (ac97->subsystem_vendor == 0x1043 &&
+               ac97->subsystem_device == 0x1103))
+            val |= 0x03; /* enable */
+        else
+            val &= ~0x03; /* disable */
         snd_ac97_write_cache(ac97, AC97_ALC650_CLOCK, val);
 
@@ -2855 +2872 @@
 }
 
+/*
+ *  UCB1400 codec (http://www.semiconductors.philips.com/acrobat_download/datasheets/UCB1400-02.pdf)
+ */
+static const struct snd_kcontrol_new snd_ac97_controls_ucb1400[] = {
+    /* enable/disable headphone driver which allows direct connection to
+     stereo headphone without the use of external DC blocking
+     capacitors */
+    AC97_SINGLE("Headphone Driver", 0x6a, 6, 1, 0),
+    /* Filter used to compensate the DC offset is added in the ADC to remove idle
+     tones from the audio band. */
+    AC97_SINGLE("DC Filter", 0x6a, 4, 1, 0),
+    /* Control smart-low-power mode feature. Allows automatic power down
+     of unused blocks in the ADC analog front end and the PLL. */
+    AC97_SINGLE("Smart Low Power Mode", 0x6c, 4, 3, 0),
+};
+
+static int patch_ucb1400_specific(struct snd_ac97 * ac97)
+{
+    int idx, err;
+    for (idx = 0; idx < ARRAY_SIZE(snd_ac97_controls_ucb1400); idx++)
+        if ((err = snd_ctl_add(ac97->bus->card, snd_ctl_new1(&snd_ac97_controls_ucb1400[idx], ac97))) < 0)
+            return err;
+    return 0;
+}
+
+static struct snd_ac97_build_ops patch_ucb1400_ops = {
+    .build_specific     = patch_ucb1400_specific,
+};
+
+int patch_ucb1400(struct snd_ac97 * ac97)
+{
+    ac97->build_ops = &patch_ucb1400_ops;
+    /* enable headphone driver and smart low power mode by default */
+    snd_ac97_write(ac97, 0x6a, 0x0050);
+    snd_ac97_write(ac97, 0x6c, 0x0030);
+    return 0;
+}

GPL/trunk/alsa-kernel/pci/ac97/ac97_patch.h

@@ -59 +59 @@
 int patch_vt1617a(struct snd_ac97 * ac97);
 int patch_it2646(struct snd_ac97 * ac97);
+int patch_ucb1400(struct snd_ac97 * ac97);
 int mpatch_si3036(struct snd_ac97 * ac97);
 int patch_lm4550(struct snd_ac97 * ac97);

GPL/trunk/alsa-kernel/pci/ac97/ac97_pcm.c

@@ -259 +259 @@
         int dbl;
         unsigned int tmp;
-        
+
         dbl = rate > 48000;
         if (dbl) {
@@ -268 +268 @@
         }
 
+        snd_ac97_update_power(ac97, reg, 1);
         switch (reg) {
         case AC97_PCM_MIC_ADC_RATE:
@@ -600 +601 @@
                         goto error;
                 }
-        }
+        }
+        pcm->cur_dbl = r;
         spin_unlock_irq(&pcm->bus->bus_lock);
         for (i = 3; i < 12; i++) {
@@ -640 +642 @@
 int snd_ac97_pcm_close(struct ac97_pcm *pcm)
 {
-        struct snd_ac97_bus *bus;
-        unsigned short slots = pcm->aslots;
-        int i, cidx;
-
-        bus = pcm->bus;
-        spin_lock_irq(&pcm->bus->bus_lock);
-        for (i = 3; i < 12; i++) {
-                if (!(slots & (1 << i)))
-                        continue;
-                for (cidx = 0; cidx < 4; cidx++)
-                        bus->used_slots[pcm->stream][cidx] &= ~(1 << i);
-        }
-        pcm->aslots = 0;
-        spin_unlock_irq(&pcm->bus->bus_lock);
-        return 0;
+    struct snd_ac97_bus *bus;
+    unsigned short slots = pcm->aslots;
+    int i, cidx;
+
+#ifdef CONFIG_SND_AC97_POWER_SAVE
+    int r = pcm->cur_dbl;
+    for (i = 3; i < 12; i++) {
+        if (!(slots & (1 << i)))
+            continue;
+        for (cidx = 0; cidx < 4; cidx++) {
+            if (pcm->r[r].rslots[cidx] & (1 << i)) {
+                int reg = get_slot_reg(pcm, cidx, i, r);
+                snd_ac97_update_power(pcm->r[r].codec[cidx],
+                                      reg, 0);
+            }
+        }
+    }
+#endif
+
+    bus = pcm->bus;
+    spin_lock_irq(&pcm->bus->bus_lock);
+    for (i = 3; i < 12; i++) {
+        if (!(slots & (1 << i)))
+            continue;
+        for (cidx = 0; cidx < 4; cidx++)
+            bus->used_slots[pcm->stream][cidx] &= ~(1 << i);
+    }
+    pcm->aslots = 0;
+    pcm->cur_dbl = 0;
+    spin_unlock_irq(&pcm->bus->bus_lock);
+    return 0;
 }