Changeset 402


Ignore:
Timestamp:
Nov 22, 2008, 9:25:45 PM (17 years ago)
Author:
Paul Smedley
Message:

Update ALSA code level to 1.0.18a

Location:
GPL/branches/uniaud32-2.0
Files:
33 edited

Legend:

Unmodified
Added
Removed

  • GPL/branches/uniaud32-2.0/alsa-kernel/core/control.c

    r399 r402  
    118118
    119119        ctl = file->private_data;
    120         fasync_helper(-1, file, 0, &ctl->fasync);
    121120        file->private_data = NULL;
    122121        card = ctl->card;
    … …  
    234233        kctl.id.device = ncontrol->device;
    235234        kctl.id.subdevice = ncontrol->subdevice;
    236         if (ncontrol->name)
     235        if (ncontrol->name) {
    237236                strlcpy(kctl.id.name, ncontrol->name, sizeof(kctl.id.name));
     237                if (strcmp(ncontrol->name, kctl.id.name) != 0)
     238                        snd_printk(KERN_WARNING
     239                                   "Control name '%s' truncated to '%s'\n",
     240                                   ncontrol->name, kctl.id.name);
     241        }
    238242        kctl.id.index = ncontrol->index;
    239243        kctl.count = ncontrol->count ? ncontrol->count : 1;

  • GPL/branches/uniaud32-2.0/alsa-kernel/core/init.c

    r399 r402  
    282282        spin_unlock(&shutdown_lock);
    283283
    284         if (likely(df))
     284        if (likely(df)) {
     285                if ((file->f_flags & FASYNC) && df->disconnected_f_op->fasync)
     286                        df->disconnected_f_op->fasync(-1, file, 0);
    285287                return df->disconnected_f_op->release(inode, file);
     288        }
    286289
    287290#ifndef TARGET_OS2

  • GPL/branches/uniaud32-2.0/alsa-kernel/core/pcm_native.c

    r399 r402  
    22002200                return -ENXIO;
    22012201        pcm = substream->pcm;
    2202         fasync_helper(-1, file, 0, &substream->runtime->fasync);
    22032202        mutex_lock(&pcm->open_mutex);
    22042203        snd_pcm_release_substream(substream);

  • GPL/branches/uniaud32-2.0/alsa-kernel/core/rawmidi.c

    r399 r402  
    153153static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream *substream,int up)
    154154{
     155        if (!substream->opened)
     156                return;
    155157        if (up) {
    156158                tasklet_hi_schedule(&substream->runtime->tasklet);
    … …  
    163165static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream *substream, int up)
    164166{
     167        if (!substream->opened)
     168                return;
    165169        substream->ops->trigger(substream, up);
    166170        if (!up && substream->runtime->event)
    … …  
    878882        struct snd_rawmidi_runtime *runtime = substream->runtime;
    879883
     884        if (!substream->opened)
     885                return -EBADFD;
    880886        if (runtime->buffer == NULL) {
    881887                snd_printd("snd_rawmidi_receive: input is not active!!!\n");
    … …  
    11471153                         unsigned char *buffer, int count)
    11481154{
     1155        if (!substream->opened)
     1156                return -EBADFD;
    11491157        count = snd_rawmidi_transmit_peek(substream, buffer, count);
    11501158        if (count < 0)

  • GPL/branches/uniaud32-2.0/alsa-kernel/core/seq/seq.c

    r305 r402  
    4848int seq_default_timer_card = -1;
    4949int seq_default_timer_device =
    50 #ifdef CONFIG_SND_SEQ_RTCTIMER_DEFAULT
     50#ifdef CONFIG_SND_SEQ_HRTIMER_DEFAULT
     51        SNDRV_TIMER_GLOBAL_HRTIMER
     52#elif defined(CONFIG_SND_SEQ_RTCTIMER_DEFAULT)
    5153        SNDRV_TIMER_GLOBAL_RTC
    5254#else

  • GPL/branches/uniaud32-2.0/alsa-kernel/core/timer.c

    r399 r402  
    12801280                tu = file->private_data;
    12811281                file->private_data = NULL;
    1282                 fasync_helper(-1, file, 0, &tu->fasync);
    12831282                if (tu->timeri)
    12841283                        snd_timer_close(tu->timeri);

  • GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/ac97_codec.h

    r358 r402  
    282282#define AC97_AD_TEST            0x5a    /* test register */
    283283#define AC97_AD_TEST2           0x5c    /* undocumented test register 2 */
     284#define AC97_AD_HPFD_SHIFT      12      /* High Pass Filter Disable */
    284285#define AC97_AD_CODEC_CFG       0x70    /* codec configuration */
    285286#define AC97_AD_JACK_SPDIF      0x72    /* Jack Sense & S/PDIF */
    286287#define AC97_AD_SERIAL_CFG      0x74    /* Serial Configuration */
    287288#define AC97_AD_MISC            0x76    /* Misc Control Bits */
     289#define AC97_AD_VREFD_SHIFT     2       /* V_REFOUT Disable (AD1888) */
    288290
    289291/* specific - Cirrus Logic */

  • GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/asound.h

    r399 r402  
    602602#define SNDRV_TIMER_GLOBAL_RTC          1
    603603#define SNDRV_TIMER_GLOBAL_HPET         2
     604#define SNDRV_TIMER_GLOBAL_HRTIMER      3
    604605
    605606/* info flags */

  • GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/core.h

    r399 r402  
    377377 * @fmt: format string
    378378 *
    379  * Works like print() but prints the file and the line of the caller
     379 * Works like printk() but prints the file and the line of the caller
    380380 * when configured with CONFIG_SND_VERBOSE_PRINTK.
    381381 */
    … …  
    408408#endif
    409409
     410/**
     411 * snd_BUG - give a BUG warning message and stack trace
     412 *
     413 * Calls WARN() if CONFIG_SND_DEBUG is set.
     414 * Ignored when CONFIG_SND_DEBUG is not set.
     415 */
    410416#define snd_BUG()               WARN(1, "BUG?\n")
     417
     418/**
     419 * snd_BUG_ON - debugging check macro
     420 * @cond: condition to evaluate
     421 *
     422 * When CONFIG_SND_DEBUG is set, this macro evaluates the given condition,
     423 * and call WARN() and returns the value if it's non-zero.
     424 *
     425 * When CONFIG_SND_DEBUG is not set, this just returns zero, and the given
     426 * condition is ignored.
     427 *
     428 * NOTE: the argument won't be evaluated at all when CONFIG_SND_DEBUG=n.
     429 * Thus, don't put any statement that influences on the code behavior,
     430 * such as pre/post increment, to the argument of this macro.
     431 * If you want to evaluate and give a warning, use standard WARN_ON().
     432 */
     433
    411434#define snd_BUG_ON(cond)        WARN((cond), "BUG? (%s)\n", __stringify(cond))
    412435
    … …  
    414437
    415438#ifndef TARGET_OS2
    416 #define snd_printd(fmt, args...)        /* nothing */
    417 #define snd_BUG()                       /* nothing */
    418 #define snd_BUG_ON(cond)        ({/*(void)(cond);*/ 0;})  /* always false */
     439#define snd_printd(fmt, args...)        do { } while (0)
     440#define snd_BUG()                       do { } while (0)
     441static inline int __snd_bug_on(int cond)
     442{
     443        return 0;
     444}
     445#define snd_BUG_ON(cond)        __snd_bug_on(0 && (cond))  /* always false */
    419446#else
    420447#define snd_printd snd_printk
    421 #define snd_BUG()                       /* nothing */
    422 #define snd_BUG_ON(cond)                0       /* always false */
     448#define snd_BUG()                       do { } while (0)
     449static inline int __snd_bug_on(int cond)
     450{
     451        return 0;
     452}
     453#define snd_BUG_ON(cond)        __snd_bug_on(0 && (cond))  /* always false */
    423454#endif
    424455

  • GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/soc.h

    r399 r402  
    2222#include <sound/ac97_codec.h>
    2323
    24 #define SND_SOC_VERSION "0.13.2"
    25 
    2624/*
    2725 * Convenience kcontrol builders
    … …  
    2927#define SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) \
    3028        ((unsigned long)&(struct soc_mixer_control) \
    31         {.reg = xreg, .shift = xshift, .max = xmax, .invert = xinvert})
     29        {.reg = xreg, .shift = xshift, .rshift = xshift, .max = xmax, \
     30        .invert = xinvert})
    3231#define SOC_SINGLE_VALUE_EXT(xreg, xmax, xinvert) \
    3332        ((unsigned long)&(struct soc_mixer_control) \
    … …  
    426425
    427426        /* dapm */
     427        u32 pop_time;
    428428        struct list_head dapm_widgets;
    429429        struct list_head dapm_paths;
    … …  
    517517        struct work_struct deferred_resume_work;
    518518        void *codec_data;
     519#ifdef CONFIG_DEBUG_FS
     520        struct dentry   *debugfs_root;
     521#endif
    519522};
    520523

  • GPL/branches/uniaud32-2.0/alsa-kernel/include/sound/version.h

    r399 r402  
    11/* include/version.h */
    2 #define CONFIG_SND_VERSION "1.0.18"
     2#define CONFIG_SND_VERSION "1.0.18a"
    33#define CONFIG_SND_DATE ""

  • GPL/branches/uniaud32-2.0/alsa-kernel/isa/ad1848/ad1848.c

    r399 r402  
    7171
    7272        if (port[n] == SNDRV_AUTO_PORT) {
    73                 snd_printk(KERN_ERR "%s: please specify port\n", dev->bus_id);
     73                dev_err(dev, "please specify port\n");
    7474                return 0;
    7575        }
    7676        if (irq[n] == SNDRV_AUTO_IRQ) {
    77                 snd_printk(KERN_ERR "%s: please specify irq\n", dev->bus_id);
     77                dev_err(dev, "please specify irq\n");
    7878                return 0;       
    7979        }
    8080        if (dma1[n] == SNDRV_AUTO_DMA) {
    81                 snd_printk(KERN_ERR "%s: please specify dma1\n", dev->bus_id);
     81                dev_err(dev, "please specify dma1\n");
    8282                return 0;
    8383        }

  • GPL/branches/uniaud32-2.0/alsa-kernel/isa/cs423x/cs4231.c

    r399 r402  
    7575
    7676        if (port[n] == SNDRV_AUTO_PORT) {
    77                 snd_printk(KERN_ERR "%s: please specify port\n", dev->bus_id);
     77                dev_err(dev, "please specify port\n");
    7878                return 0;
    7979        }
    8080        if (irq[n] == SNDRV_AUTO_IRQ) {
    81                 snd_printk(KERN_ERR "%s: please specify irq\n", dev->bus_id);
     81                dev_err(dev, "please specify irq\n");
    8282                return 0;
    8383        }
    8484        if (dma1[n] == SNDRV_AUTO_DMA) {
    85                 snd_printk(KERN_ERR "%s: please specify dma1\n", dev->bus_id);
     85                dev_err(dev, "please specify dma1\n");
    8686                return 0;
    8787        }
    … …  
    134134                                        mpu_irq[n] >= 0 ? IRQF_DISABLED : 0,
    135135                                        NULL) < 0)
    136                         printk(KERN_WARNING "%s: MPU401 not detected\n", dev->bus_id);
     136                        dev_warn(dev, "MPU401 not detected\n");
    137137        }
    138138

  • GPL/branches/uniaud32-2.0/alsa-kernel/isa/cs423x/cs4236.c

    r399 r402  
    489489
    490490        if (port[dev] == SNDRV_AUTO_PORT) {
    491                 snd_printk(KERN_ERR "%s: please specify port\n", pdev->bus_id);
     491                dev_err(pdev, "please specify port\n");
    492492                return 0;
    493493        }
    494494        if (cport[dev] == SNDRV_AUTO_PORT) {
    495                 snd_printk(KERN_ERR "%s: please specify cport\n", pdev->bus_id);
     495                dev_err(pdev, "please specify cport\n");
    496496                return 0;
    497497        }
    498498        if (irq[dev] == SNDRV_AUTO_IRQ) {
    499                 snd_printk(KERN_ERR "%s: please specify irq\n", pdev->bus_id);
     499                dev_err(pdev, "please specify irq\n");
    500500                return 0;
    501501        }
    502502        if (dma1[dev] == SNDRV_AUTO_DMA) {
    503                 snd_printk(KERN_ERR "%s: please specify dma1\n", pdev->bus_id);
     503                dev_err(pdev, "please specify dma1\n");
    504504                return 0;
    505505        }

  • GPL/branches/uniaud32-2.0/alsa-kernel/isa/es1688/es1688.c

    r305 r402  
    8989                irq[n] = snd_legacy_find_free_irq(possible_irqs);
    9090                if (irq[n] < 0) {
    91                         snd_printk(KERN_ERR "%s: unable to find a free IRQ\n",
    92                                 dev->bus_id);
     91                        dev_err(dev, "unable to find a free IRQ\n");
    9392                        return -EBUSY;
    9493                }
    … …  
    9796                dma8[n] = snd_legacy_find_free_dma(possible_dmas);
    9897                if (dma8[n] < 0) {
    99                         snd_printk(KERN_ERR "%s: unable to find a free DMA\n",
    100                                 dev->bus_id);
     98                        dev_err(dev, "unable to find a free DMA\n");
    10199                        return -EBUSY;
    102100                }
    … …  
    148146        if (snd_opl3_create(card, chip->port, chip->port + 2,
    149147                        OPL3_HW_OPL3, 0, &opl3) < 0)
    150                 printk(KERN_WARNING "%s: opl3 not detected at 0x%lx\n",
    151                         dev->bus_id, chip->port);
     148                dev_warn(dev, "opl3 not detected at 0x%lx\n", chip->port);
    152149        else {
    153150                error = snd_opl3_hwdep_new(opl3, 0, 1, NULL);

  • GPL/branches/uniaud32-2.0/alsa-kernel/isa/gus/gusclassic.c

    r305 r402  
    9191                irq[n] = snd_legacy_find_free_irq(possible_irqs);
    9292                if (irq[n] < 0) {
    93                         snd_printk(KERN_ERR "%s: unable to find a free IRQ\n",
    94                                 dev->bus_id);
     93                        dev_err(dev, "unable to find a free IRQ\n");
    9594                        return -EBUSY;
    9695                }
    … …  
    9998                dma1[n] = snd_legacy_find_free_dma(possible_dmas);
    10099                if (dma1[n] < 0) {
    101                         snd_printk(KERN_ERR "%s: unable to find a free DMA1\n",
    102                                 dev->bus_id);
     100                        dev_err(dev, "unable to find a free DMA1\n");
    103101                        return -EBUSY;
    104102                }
    … …  
    107105                dma2[n] = snd_legacy_find_free_dma(possible_dmas);
    108106                if (dma2[n] < 0) {
    109                         snd_printk(KERN_ERR "%s: unable to find a free DMA2\n",
    110                                 dev->bus_id);
     107                        dev_err(dev, "unable to find a free DMA2\n");
    111108                        return -EBUSY;
    112109                }
    … …  
    175172        error = -ENODEV;
    176173        if (gus->max_flag || gus->ess_flag) {
    177                 snd_printk(KERN_ERR "%s: GUS Classic or ACE soundcard was "
    178                         "not detected at 0x%lx\n", dev->bus_id, gus->gf1.port);
     174                dev_err(dev, "GUS Classic or ACE soundcard was "
     175                        "not detected at 0x%lx\n", gus->gf1.port);
    179176                goto out;
    180177        }

  • GPL/branches/uniaud32-2.0/alsa-kernel/isa/gus/gusextreme.c

    r305 r402  
    107107                irq[n] = snd_legacy_find_free_irq(possible_irqs);
    108108                if (irq[n] < 0) {
    109                         snd_printk(KERN_ERR "%s: unable to find a free IRQ "
    110                                 "for ES1688\n", dev->bus_id);
     109                        dev_err(dev, "unable to find a free IRQ for ES1688\n");
    111110                        return -EBUSY;
    112111                }
    … …  
    115114                dma8[n] = snd_legacy_find_free_dma(possible_dmas);
    116115                if (dma8[n] < 0) {
    117                         snd_printk(KERN_ERR "%s: unable to find a free DMA "
    118                                 "for ES1688\n", dev->bus_id);
     116                        dev_err(dev, "unable to find a free DMA for ES1688\n");
    119117                        return -EBUSY;
    120118                }
    … …  
    144142                gf1_irq[n] = snd_legacy_find_free_irq(possible_irqs);
    145143                if (gf1_irq[n] < 0) {
    146                         snd_printk(KERN_ERR "%s: unable to find a free IRQ "
    147                                 "for GF1\n", dev->bus_id);
     144                        dev_err(dev, "unable to find a free IRQ for GF1\n");
    148145                        return -EBUSY;
    149146                }
    … …  
    152149                dma1[n] = snd_legacy_find_free_dma(possible_dmas);
    153150                if (dma1[n] < 0) {
    154                         snd_printk(KERN_ERR "%s: unable to find a free DMA "
    155                                 "for GF1\n", dev->bus_id);
     151                        dev_err(dev, "unable to find a free DMA for GF1\n");
    156152                        return -EBUSY;
    157153                }
    … …  
    279275        error = -ENODEV;
    280276        if (!gus->ess_flag) {
    281                 snd_printk(KERN_ERR "%s: GUS Extreme soundcard was not "
    282                         "detected at 0x%lx\n", dev->bus_id, gus->gf1.port);
     277                dev_err(dev, "GUS Extreme soundcard was not "
     278                        "detected at 0x%lx\n", gus->gf1.port);
    283279                goto out;
    284280        }
    … …  
    311307        if (snd_opl3_create(card, es1688->port, es1688->port + 2,
    312308                        OPL3_HW_OPL3, 0, &opl3) < 0)
    313                 printk(KERN_ERR "%s: opl3 not detected at 0x%lx\n",
    314                         dev->bus_id, es1688->port);
     309                dev_warn(dev, "opl3 not detected at 0x%lx\n", es1688->port);
    315310        else {
    316311                error = snd_opl3_hwdep_new(opl3, 0, 2, NULL);

  • GPL/branches/uniaud32-2.0/alsa-kernel/isa/sb/sb8.c

    r305 r402  
    8686                return 0;
    8787        if (irq[dev] == SNDRV_AUTO_IRQ) {
    88                 snd_printk(KERN_ERR "%s: please specify irq\n", pdev->bus_id);
     88                dev_err(pdev, "please specify irq\n");
    8989                return 0;
    9090        }
    9191        if (dma8[dev] == SNDRV_AUTO_DMA) {
    92                 snd_printk(KERN_ERR "%s: please specify dma8\n", pdev->bus_id);
     92                dev_err(pdev, "please specify dma8\n");
    9393                return 0;
    9494        }

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/ac97/ac97_codec.c

    r399 r402  
    19671967        ac97->dev.parent = ac97->bus->card->dev;
    19681968        ac97->dev.release = ac97_device_release;
    1969         snprintf(ac97->dev.bus_id, BUS_ID_SIZE, "%d-%d:%s",
    1970                  ac97->bus->card->number, ac97->num,
    1971                  snd_ac97_get_short_name(ac97));
     1969        dev_set_name(&ac97->dev, "%d-%d:%s",
     1970                     ac97->bus->card->number, ac97->num,
     1971                     snd_ac97_get_short_name(ac97));
    19721972        if ((err = device_register(&ac97->dev)) < 0) {
    19731973                snd_printk(KERN_ERR "Can't register ac97 bus\n");

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/ac97/ac97_patch.c

    r399 r402  
    20552055                .put = snd_ac97_ad1888_lohpsel_put
    20562056        },
    2057         AC97_SINGLE("V_REFOUT Enable", AC97_AD_MISC, 2, 1, 1),
    2058         AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2, 12, 1, 1),
     2057        AC97_SINGLE("V_REFOUT Enable", AC97_AD_MISC, AC97_AD_VREFD_SHIFT, 1, 1),
     2058        AC97_SINGLE("High Pass Filter Enable", AC97_AD_TEST2,
     2059                        AC97_AD_HPFD_SHIFT, 1, 1),
    20592060        AC97_SINGLE("Spread Front to Surround and Center/LFE", AC97_AD_MISC, 7, 1, 0),
    20602061        {

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/emu10k1/emu10k1_main.c

    r399 r402  
    14741474         .spk71 = 1,
    14751475         .spdif_bug = 1,
     1476         .invert_shared_spdif = 1,      /* digital/analog switch swapped */
    14761477         .ac97_chip = 1} ,
    14771478        {.vendor = 0x1102, .device = 0x0004, .subsystem = 0x20021102,
    … …  
    14831484         .spk71 = 1,
    14841485         .spdif_bug = 1,
     1486         .invert_shared_spdif = 1,      /* digital/analog switch swapped */
    14851487         .ac97_chip = 1} ,
    14861488        {.vendor = 0x1102, .device = 0x0004, .subsystem = 0x20011102,
    … …  
    14921494         .spk71 = 1,
    14931495         .spdif_bug = 1,
     1496         .invert_shared_spdif = 1,      /* digital/analog switch swapped */
    14941497         .ac97_chip = 1} ,
    14951498        /* Audigy 2 */

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_codec.c

    r399 r402  
    6565        { 0x17e8, "Chrontel" },
    6666        { 0x1854, "LG" },
     67        { 0x1aec, "Wolfson Microelectronics" },
    6768        { 0x434d, "C-Media" },
    6869        { 0x8384, "SigmaTel" },
    … …  
    9899        snd_hda_preset_nvhdmi,
    99100#endif
     101#ifdef CONFIG_SND_HDA_CODEC_INTELHDMI
     102        snd_hda_preset_intelhdmi,
     103#endif
    100104        NULL
    101105};
    … …  
    154158}
    155159
     160/*
     161 * Compose a 32bit command word to be sent to the HD-audio controller
     162 */
     163static inline unsigned int
     164make_codec_cmd(struct hda_codec *codec, hda_nid_t nid, int direct,
     165               unsigned int verb, unsigned int parm)
     166{
     167        u32 val;
     168
     169        val = (u32)(codec->addr & 0x0f) << 28;
     170        val |= (u32)direct << 27;
     171        val |= (u32)nid << 20;
     172        val |= verb << 8;
     173        val |= parm;
     174        return val;
     175}
     176
    156177/**
    157178 * snd_hda_codec_read - send a command and get the response
    … …  
    170191                                unsigned int verb, unsigned int parm)
    171192{
     193        struct hda_bus *bus = codec->bus;
    172194        unsigned int res;
     195
     196        res = make_codec_cmd(codec, nid, direct, verb, parm);
    173197        snd_hda_power_up(codec);
    174         mutex_lock(&codec->bus->cmd_mutex);
    175         if (!codec->bus->ops.command(codec, nid, direct, verb, parm))
    176                 res = codec->bus->ops.get_response(codec);
     198        mutex_lock(&bus->cmd_mutex);
     199        if (!bus->ops.command(bus, res))
     200                res = bus->ops.get_response(bus);
    177201        else
    178202                res = (unsigned int)-1;
    179         mutex_unlock(&codec->bus->cmd_mutex);
     203        mutex_unlock(&bus->cmd_mutex);
    180204        snd_hda_power_down(codec);
    181205        return res;
    … …  
    197221                         unsigned int verb, unsigned int parm)
    198222{
     223        struct hda_bus *bus = codec->bus;
     224        unsigned int res;
    199225        int err;
     226
     227        res = make_codec_cmd(codec, nid, direct, verb, parm);
    200228        snd_hda_power_up(codec);
    201         mutex_lock(&codec->bus->cmd_mutex);
    202         err = codec->bus->ops.command(codec, nid, direct, verb, parm);
    203         mutex_unlock(&codec->bus->cmd_mutex);
     229        mutex_lock(&bus->cmd_mutex);
     230        err = bus->ops.command(bus, res);
     231        mutex_unlock(&bus->cmd_mutex);
    204232        snd_hda_power_down(codec);
    205233        return err;
    … …  
    866894        u16 idx = key % (u16)ARRAY_SIZE(cache->hash);
    867895        u16 cur = cache->hash[idx];
    868         struct hda_cache_head *info_head = cache->buf.list;
    869896        struct hda_cache_head *info;
    870897
    871898        while (cur != 0xffff) {
    872                 info = &info_head[cur];
     899                info = snd_array_elem(&cache->buf, cur);
    873900                if (info->key == key)
    874901                        return info;
    … …  
    878905        /* add a new hash entry */
    879906        info = snd_array_new(&cache->buf);
     907        if (!info)
     908                return NULL;
     909        cur = snd_array_index(&cache->buf, info);
    880910        info->key = key;
    881911        info->val = 0;
    … …  
    17031733        for (dig_mix = dig_mixes; dig_mix->name; dig_mix++) {
    17041734                kctl = snd_ctl_new1(dig_mix, codec);
     1735                if (!kctl)
     1736                        return -ENOMEM;
    17051737                kctl->id.index = idx;
    17061738                kctl->private_value = nid;
    … …  
    18871919                              int direct, unsigned int verb, unsigned int parm)
    18881920{
     1921        struct hda_bus *bus = codec->bus;
     1922        unsigned int res;
    18891923        int err;
     1924
     1925        res = make_codec_cmd(codec, nid, direct, verb, parm);
    18901926        snd_hda_power_up(codec);
    1891         mutex_lock(&codec->bus->cmd_mutex);
    1892         err = codec->bus->ops.command(codec, nid, direct, verb, parm);
     1927        mutex_lock(&bus->cmd_mutex);
     1928        err = bus->ops.command(bus, res);
    18931929        if (!err) {
    18941930                struct hda_cache_head *c;
    … …  
    18981934                        c->val = parm;
    18991935        }
    1900         mutex_unlock(&codec->bus->cmd_mutex);
     1936        mutex_unlock(&bus->cmd_mutex);
    19011937        snd_hda_power_down(codec);
    19021938        return err;
    … …  
    24162452snd_hda_attach_pcm(struct hda_codec *codec, struct hda_pcm *pcm)
    24172453{
     2454        struct hda_bus *bus = codec->bus;
    24182455        struct hda_pcm_stream *info;
    24192456        int stream, err;
    24202457
    2421         if (!pcm->name)
     2458        if (snd_BUG_ON(!pcm->name))
    24222459                return -EINVAL;
    24232460        for (stream = 0; stream < 2; stream++) {
    … …  
    24292466                }
    24302467        }
    2431         return codec->bus->ops.attach_pcm(codec, pcm);
     2468        return bus->ops.attach_pcm(bus, codec, pcm);
    24322469}
    24332470
    … …  
    24902527                        int type = cpcm->pcm_type;
    24912528                        int dev;
     2529
     2530                        if (!cpcm->stream[0].substreams &&
     2531                            !cpcm->stream[1].substreams)
     2532                                continue; /* no substreams assigned */
     2533
    24922534                        switch (type) {
    24932535                        case HDA_PCM_TYPE_AUDIO:
    … …  
    26252667        struct hda_codec *codec =
    26262668                container_of(work, struct hda_codec, power_work.work);
     2669        struct hda_bus *bus = codec->bus;
    26272670
    26282671        if (!codec->power_on || codec->power_count) {
    … …  
    26322675
    26332676        hda_call_codec_suspend(codec);
    2634         if (codec->bus->ops.pm_notify)
    2635                 codec->bus->ops.pm_notify(codec);
     2677        if (bus->ops.pm_notify)
     2678                bus->ops.pm_notify(bus);
    26362679}
    26372680
    … …  
    26442687void snd_hda_power_up(struct hda_codec *codec)
    26452688{
     2689        struct hda_bus *bus = codec->bus;
     2690
    26462691        codec->power_count++;
    26472692        if (codec->power_on || codec->power_transition)
    … …  
    26492694
    26502695        codec->power_on = 1;
    2651         if (codec->bus->ops.pm_notify)
    2652                 codec->bus->ops.pm_notify(codec);
     2696        if (bus->ops.pm_notify)
     2697                bus->ops.pm_notify(bus);
    26532698        hda_call_codec_resume(codec);
    26542699        cancel_delayed_work(&codec->power_work);
    … …  
    33623407        if (array->used >= array->alloced) {
    33633408                int num = array->alloced + array->alloc_align;
    3364                 void *nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
     3409                void *nlist;
     3410                if (snd_BUG_ON(num >= 4096))
     3411                        return NULL;
     3412                nlist = kcalloc(num + 1, array->elem_size, GFP_KERNEL);
    33653413                if (!nlist)
    33663414                        return NULL;
    … …  
    33733421                array->alloced = num;
    33743422        }
    3375         return array->list + (array->used++ * array->elem_size);
     3423        return snd_array_elem(array, array->used++);
    33763424}
    33773425

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_codec.h

    r399 r402  
    540540}
    541541
     542static inline void *snd_array_elem(struct snd_array *array, unsigned int idx)
     543{
     544        return array->list + idx * array->elem_size;
     545}
     546
     547static inline unsigned int snd_array_index(struct snd_array *array, void *ptr)
     548{
     549        return (unsigned long)(ptr - array->list) / array->elem_size;
     550}
     551
    542552/*
    543553 * Structures
    … …  
    557567struct hda_bus_ops {
    558568        /* send a single command */
    559         int (*command)(struct hda_codec *codec, hda_nid_t nid, int direct,
    560                        unsigned int verb, unsigned int parm);
     569        int (*command)(struct hda_bus *bus, unsigned int cmd);
    561570        /* get a response from the last command */
    562         unsigned int (*get_response)(struct hda_codec *codec);
     571        unsigned int (*get_response)(struct hda_bus *bus);
    563572        /* free the private data */
    564573        void (*private_free)(struct hda_bus *);
    565574        /* attach a PCM stream */
    566         int (*attach_pcm)(struct hda_codec *codec, struct hda_pcm *pcm);
     575        int (*attach_pcm)(struct hda_bus *bus, struct hda_codec *codec,
     576                          struct hda_pcm *pcm);
    567577#ifdef CONFIG_SND_HDA_POWER_SAVE
    568578        /* notify power-up/down from codec to controller */
    569         void (*pm_notify)(struct hda_codec *codec);
     579        void (*pm_notify)(struct hda_bus *bus);
    570580#endif
    571581};

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_intel.c

    r399 r402  
    4646#include <linux/pci.h>
    4747#include <linux/mutex.h>
     48#include <linux/reboot.h>
    4849#include <sound/core.h>
    4950#include <sound/initval.h>
    … …  
    411412        unsigned int irq_pending_warned :1;
    412413        unsigned int via_dmapos_patch :1; /* enable DMA-position fix for VIA */
     414        unsigned int probing :1; /* codec probing phase */
    413415
    414416        /* for debugging */
    … …  
    417419        /* for pending irqs */
    418420        struct work_struct irq_pending_work;
     421
     422        /* reboot notifier (for mysterious hangup problem at power-down) */
     423        struct notifier_block reboot_notifier;
    419424};
    420425
    … …  
    543548
    544549/* send a command */
    545 static int azx_corb_send_cmd(struct hda_codec *codec, u32 val)
    546 {
    547         struct azx *chip = codec->bus->private_data;
     550static int azx_corb_send_cmd(struct hda_bus *bus, u32 val)
     551{
     552        struct azx *chip = bus->private_data;
    548553        unsigned int wp;
    549554
    … …  
    593598
    594599/* receive a response */
    595 static unsigned int azx_rirb_get_response(struct hda_codec *codec)
    596 {
    597         struct azx *chip = codec->bus->private_data;
     600static unsigned int azx_rirb_get_response(struct hda_bus *bus)
     601{
     602        struct azx *chip = bus->private_data;
    598603        unsigned long timeout;
    599604
    … …  
    612617                if (time_after(jiffies, timeout))
    613618                        break;
    614                 if (codec->bus->needs_damn_long_delay)
     619                if (bus->needs_damn_long_delay)
    615620                        msleep(2); /* temporary workaround */
    616621                else {
    … …  
    640645        }
    641646
     647        if (chip->probing) {
     648                /* If this critical timeout happens during the codec probing
     649                 * phase, this is likely an access to a non-existing codec
     650                 * slot.  Better to return an error and reset the system.
     651                 */
     652                return -1;
     653        }
     654
    642655        snd_printk(KERN_ERR "hda_intel: azx_get_response timeout, "
    643656                   "switching to single_cmd mode: last cmd=0x%08x\n",
    … …  
    662675
    663676/* send a command */
    664 static int azx_single_send_cmd(struct hda_codec *codec, u32 val)
    665 {
    666         struct azx *chip = codec->bus->private_data;
     677static int azx_single_send_cmd(struct hda_bus *bus, u32 val)
     678{
     679        struct azx *chip = bus->private_data;
    667680        int timeout = 50;
    668681
    … …  
    687700
    688701/* receive a response */
    689 static unsigned int azx_single_get_response(struct hda_codec *codec)
    690 {
    691         struct azx *chip = codec->bus->private_data;
     702static unsigned int azx_single_get_response(struct hda_bus *bus)
     703{
     704        struct azx *chip = bus->private_data;
    692705        int timeout = 50;
    693706
    … …  
    712725
    713726/* send a command */
    714 static int azx_send_cmd(struct hda_codec *codec, hda_nid_t nid,
    715                         int direct, unsigned int verb,
    716                         unsigned int para)
    717 {
    718         struct azx *chip = codec->bus->private_data;
    719         u32 val;
    720 
    721         val = (u32)(codec->addr & 0x0f) << 28;
    722         val |= (u32)direct << 27;
    723         val |= (u32)nid << 20;
    724         val |= verb << 8;
    725         val |= para;
     727static int azx_send_cmd(struct hda_bus *bus, unsigned int val)
     728{
     729        struct azx *chip = bus->private_data;
     730
    726731        chip->last_cmd = val;
    727 
    728732        if (chip->single_cmd)
    729                 return azx_single_send_cmd(codec, val);
     733                return azx_single_send_cmd(bus, val);
    730734        else
    731                 return azx_corb_send_cmd(codec, val);
     735                return azx_corb_send_cmd(bus, val);
    732736}
    733737
    734738/* get a response */
    735 static unsigned int azx_get_response(struct hda_codec *codec)
    736 {
    737         struct azx *chip = codec->bus->private_data;
     739static unsigned int azx_get_response(struct hda_bus *bus)
     740{
     741        struct azx *chip = bus->private_data;
    738742        if (chip->single_cmd)
    739                 return azx_single_get_response(codec);
     743                return azx_single_get_response(bus);
    740744        else
    741                 return azx_rirb_get_response(codec);
     745                return azx_rirb_get_response(bus);
    742746}
    743747
    744748#ifdef CONFIG_SND_HDA_POWER_SAVE
    745 static void azx_power_notify(struct hda_codec *codec);
     749static void azx_power_notify(struct hda_bus *bus);
    746750#endif
    747751
    … …  
    12181222}
    12191223
    1220 static int azx_attach_pcm_stream(struct hda_codec *codec, struct hda_pcm *cpcm);
     1224/*
     1225 * Probe the given codec address
     1226 */
     1227static int probe_codec(struct azx *chip, int addr)
     1228{
     1229        unsigned int cmd = (addr << 28) | (AC_NODE_ROOT << 20) |
     1230                (AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID;
     1231        unsigned int res;
     1232
     1233        chip->probing = 1;
     1234        azx_send_cmd(chip->bus, cmd);
     1235        res = azx_get_response(chip->bus);
     1236        chip->probing = 0;
     1237        if (res == -1)
     1238                return -EIO;
     1239        snd_printdd("hda_intel: codec #%d probed OK\n", addr);
     1240        return 0;
     1241}
     1242
     1243static int azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
     1244                                 struct hda_pcm *cpcm);
     1245static void azx_stop_chip(struct azx *chip);
    12211246
    12221247/*
    … …  
    12291254};
    12301255
    1231 /* number of slots to probe as default
    1232  * this can be different from azx_max_codecs[] -- e.g. some boards
    1233  * report wrongly the non-existing 4th slot availability
    1234  */
    1235 static unsigned int azx_default_codecs[AZX_NUM_DRIVERS] __devinitdata = {
    1236         [AZX_DRIVER_ICH] = 3,
    1237         [AZX_DRIVER_ATI] = 3,
    1238 };
    1239 
    12401256static int __devinit azx_codec_create(struct azx *chip, const char *model,
    12411257                                      unsigned int codec_probe_mask)
    12421258{
    12431259        struct hda_bus_template bus_temp;
    1244         int c, codecs, audio_codecs, err;
    1245         int def_slots, max_slots;
     1260        int c, codecs, err;
     1261        int max_slots;
    12461262
    12471263        memset(&bus_temp, 0, sizeof(bus_temp));
    … …  
    12631279                chip->bus->needs_damn_long_delay = 1;
    12641280
    1265         codecs = audio_codecs = 0;
     1281        codecs = 0;
    12661282        max_slots = azx_max_codecs[chip->driver_type];
    12671283        if (!max_slots)
    12681284                max_slots = AZX_MAX_CODECS;
    1269         def_slots = azx_default_codecs[chip->driver_type];
    1270         if (!def_slots)
    1271                 def_slots = max_slots;
    1272         for (c = 0; c < def_slots; c++) {
     1285
     1286        /* First try to probe all given codec slots */
     1287        for (c = 0; c < max_slots; c++) {
     1288                if ((chip->codec_mask & (1 << c)) & codec_probe_mask) {
     1289                        if (probe_codec(chip, c) < 0) {
     1290                                /* Some BIOSen give you wrong codec addresses
     1291                                 * that don't exist
     1292                                 */
     1293                                snd_printk(KERN_WARNING
     1294                                           "hda_intel: Codec #%d probe error; "
     1295                                           "disabling it...\n", c);
     1296                                chip->codec_mask &= ~(1 << c);
     1297                                /* More badly, accessing to a non-existing
     1298                                 * codec often screws up the controller chip,
     1299                                 * and distrubs the further communications.
     1300                                 * Thus if an error occurs during probing,
     1301                                 * better to reset the controller chip to
     1302                                 * get back to the sanity state.
     1303                                 */
     1304                                azx_stop_chip(chip);
     1305                                azx_init_chip(chip);
     1306                        }
     1307                }
     1308        }
     1309
     1310        /* Then create codec instances */
     1311        for (c = 0; c < max_slots; c++) {
    12731312                if ((chip->codec_mask & (1 << c)) & codec_probe_mask) {
    12741313                        struct hda_codec *codec;
    … …  
    12771316                                continue;
    12781317                        codecs++;
    1279                         if (codec->afg)
    1280                                 audio_codecs++;
    1281                 }
    1282         }
    1283         if (!audio_codecs) {
    1284                 /* probe additional slots if no codec is found */
    1285                 for (; c < max_slots; c++) {
    1286                         if ((chip->codec_mask & (1 << c)) & codec_probe_mask) {
    1287                                 err = snd_hda_codec_new(chip->bus, c, NULL);
    1288                                 if (err < 0)
    1289                                         continue;
    1290                                 codecs++;
    1291                         }
    12921318                }
    12931319        }
    … …  
    17661792
    17671793static int
    1768 azx_attach_pcm_stream(struct hda_codec *codec, struct hda_pcm *cpcm)
    1769 {
    1770         struct azx *chip = codec->bus->private_data;
     1794azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
     1795                      struct hda_pcm *cpcm)
     1796{
     1797        struct azx *chip = bus->private_data;
    17711798        struct snd_pcm *pcm;
    17721799        struct azx_pcm *apcm;
    … …  
    18881915#ifdef CONFIG_SND_HDA_POWER_SAVE
    18891916/* power-up/down the controller */
    1890 static void azx_power_notify(struct hda_codec *codec)
    1891 {
    1892         struct azx *chip = codec->bus->private_data;
     1917static void azx_power_notify(struct hda_bus *bus)
     1918{
     1919        struct azx *chip = bus->private_data;
    18931920        struct hda_codec *c;
    18941921        int power_on = 0;
    18951922
    1896         list_for_each_entry(c, &codec->bus->codec_list, list, struct hda_codec) {
     1923        list_for_each_entry(c, &bus->codec_list, list, struct hda_codec) {
    18971924                if (c->power_on) {
    18981925                        power_on = 1;
    … …  
    19681995
    19691996/*
     1997 * reboot notifier for hang-up problem at power-down
     1998 */
     1999static int azx_halt(struct notifier_block *nb, unsigned long event, void *buf)
     2000{
     2001        struct azx *chip = container_of(nb, struct azx, reboot_notifier);
     2002        azx_stop_chip(chip);
     2003        return NOTIFY_OK;
     2004}
     2005
     2006static void azx_notifier_register(struct azx *chip)
     2007{
     2008        chip->reboot_notifier.notifier_call = azx_halt;
     2009        register_reboot_notifier(&chip->reboot_notifier);
     2010}
     2011
     2012static void azx_notifier_unregister(struct azx *chip)
     2013{
     2014        if (chip->reboot_notifier.notifier_call)
     2015                unregister_reboot_notifier(&chip->reboot_notifier);
     2016}
     2017
     2018/*
    19702019 * destructor
    19712020 */
    … …  
    19732022{
    19742023        int i;
     2024
     2025        azx_notifier_unregister(chip);
    19752026
    19762027        if (chip->initialized) {
    … …  
    20592110        SND_PCI_QUIRK(0x17aa, 0x2010, "Thinkpad X/T/R60", 0x01),
    20602111        SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X/T/R61", 0x01),
     2112        /* broken BIOS */
     2113        SND_PCI_QUIRK(0x1028, 0x20ac, "Dell Studio Desktop", 0x01),
    20612114        {0}
    20622115};
    … …  
    23402393        chip->running = 1;
    23412394        power_down_all_codecs(chip);
     2395        azx_notifier_register(chip);
    23422396
    23432397        dev++;

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_local.h

    r399 r402  
    371371#define AMP_IN_MUTE(idx)        (0x7080 | ((idx)<<8))
    372372#define AMP_IN_UNMUTE(idx)      (0x7000 | ((idx)<<8))
    373 #define AMP_OUT_MUTE    0xb080
    374 #define AMP_OUT_UNMUTE  0xb000
    375 #define AMP_OUT_ZERO    0xb000
     373#define AMP_OUT_MUTE            0xb080
     374#define AMP_OUT_UNMUTE          0xb000
     375#define AMP_OUT_ZERO            0xb000
    376376/* pinctl values */
    377377#define PIN_IN                  (AC_PINCTL_IN_EN)
    378 #define PIN_VREFHIZ     (AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ)
     378#define PIN_VREFHIZ             (AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ)
    379379#define PIN_VREF50              (AC_PINCTL_IN_EN | AC_PINCTL_VREF_50)
    380 #define PIN_VREFGRD     (AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD)
     380#define PIN_VREFGRD             (AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD)
    381381#define PIN_VREF80              (AC_PINCTL_IN_EN | AC_PINCTL_VREF_80)
    382 #define PIN_VREF100     (AC_PINCTL_IN_EN | AC_PINCTL_VREF_100)
    383 #define PIN_OUT         (AC_PINCTL_OUT_EN)
     382#define PIN_VREF100             (AC_PINCTL_IN_EN | AC_PINCTL_VREF_100)
     383#define PIN_OUT                 (AC_PINCTL_OUT_EN)
    384384#define PIN_HP                  (AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN)
    385385#define PIN_HP_AMP              (AC_PINCTL_HP_EN)

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_patch.h

    r399 r402  
    2121/* NVIDIA HDMI codecs */
    2222extern struct hda_codec_preset snd_hda_preset_nvhdmi[];
     23/* INTEL HDMI codecs */
     24extern struct hda_codec_preset snd_hda_preset_intelhdmi[];

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/hda_proc.c

    r399 r402  
    451451                    (gpio & AC_GPIO_WAKE) ? 1 : 0);
    452452        max = gpio & AC_GPIO_IO_COUNT;
     453        if (!max || max > 8)
     454                return;
    453455        enable = snd_hda_codec_read(codec, nid, 0,
    454456                                    AC_VERB_GET_GPIO_MASK, 0);

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/patch_analog.c

    r399 r402  
    38593859static struct snd_pci_quirk ad1884a_cfg_tbl[] = {
    38603860        SND_PCI_QUIRK(0x103c, 0x3030, "HP", AD1884A_MOBILE),
     3861        SND_PCI_QUIRK(0x103c, 0x3056, "HP", AD1884A_MOBILE),
     3862        SND_PCI_QUIRK(0x103c, 0x30e7, "HP EliteBook 8530p", AD1884A_LAPTOP),
     3863        SND_PCI_QUIRK(0x103c, 0x3614, "HP 6730s", AD1884A_LAPTOP),
    38613864        SND_PCI_QUIRK(0x17aa, 0x20ac, "Thinkpad X300", AD1884A_THINKPAD),
    38623865        {0}

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/patch_realtek.c

    r399 r402  
    115115        ALC268_TOSHIBA,
    116116        ALC268_ACER,
     117        ALC268_ACER_DMIC,
    117118        ALC268_ACER_ASPIRE_ONE,
    118119        ALC268_DELL,
    … …  
    131132        ALC269_ASUS_EEEPC_P703,
    132133        ALC269_ASUS_EEEPC_P901,
     134        ALC269_FUJITSU,
     135        ALC269_LIFEBOOK,
    133136        ALC269_AUTO,
    134137        ALC269_MODEL_LAST /* last tag */
    … …  
    153156        ALC660VD_3ST,
    154157        ALC660VD_3ST_DIG,
     158        ALC660VD_ASUS_V1S,
    155159        ALC861VD_3ST,
    156160        ALC861VD_3ST_DIG,
    … …  
    240244        struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
    241245        unsigned int num_mixers;
     246        struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
    242247
    243248        const struct hda_verb *init_verbs[5];   /* initialization verbs
    … …  
    269274        hda_nid_t *capsrc_nids;
    270275        hda_nid_t dig_in_nid;           /* digital-in NID; optional */
     276        unsigned char is_mix_capture;   /* matrix-style capture (non-mux) */
    271277
    272278        /* capture source */
    … …  
    307313        hda_nid_t pll_nid;
    308314        unsigned int pll_coef_idx, pll_coef_bit;
     315
     316#ifdef SND_HDA_NEEDS_RESUME
     317#define ALC_MAX_PINS    16
     318        unsigned int num_pins;
     319        hda_nid_t pin_nids[ALC_MAX_PINS];
     320        unsigned int pin_cfgs[ALC_MAX_PINS];
     321#endif
    309322};
    310323
    … …  
    316329                                             * with spec
    317330                                             */
     331        struct snd_kcontrol_new *cap_mixer; /* capture mixer */
    318332        const struct hda_verb *init_verbs[5];
    319333        unsigned int num_dacs;
    … …  
    368382        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
    369383        struct alc_spec *spec = codec->spec;
     384        const struct hda_input_mux *imux = spec->input_mux;
    370385        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
    371         unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
    372386        hda_nid_t nid = spec->capsrc_nids ?
    373387                spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
    374         return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
    375                                      nid, &spec->cur_mux[adc_idx]);
    376 }
    377 
     388
     389        if (spec->is_mix_capture) {
     390                /* Matrix-mixer style (e.g. ALC882) */
     391                unsigned int *cur_val = &spec->cur_mux[adc_idx];
     392                unsigned int i, idx;
     393
     394                idx = ucontrol->value.enumerated.item[0];
     395                if (idx >= imux->num_items)
     396                        idx = imux->num_items - 1;
     397                if (*cur_val == idx)
     398                        return 0;
     399                for (i = 0; i < imux->num_items; i++) {
     400                        unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
     401                        snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
     402                                                 imux->items[i].index,
     403                                                 HDA_AMP_MUTE, v);
     404                }
     405                *cur_val = idx;
     406                return 1;
     407        } else {
     408                /* MUX style (e.g. ALC880) */
     409                unsigned int mux_idx;
     410                mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
     411                return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx],
     412                                             ucontrol, nid,
     413                                             &spec->cur_mux[adc_idx]);
     414        }
     415}
    378416
    379417/*
    … …  
    710748
    711749/*
     750 */
     751static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
     752{
     753        if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
     754                return;
     755        spec->mixers[spec->num_mixers++] = mix;
     756}
     757
     758static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
     759{
     760        if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
     761                return;
     762        spec->init_verbs[spec->num_init_verbs++] = verb;
     763}
     764
     765/*
    712766 * set up from the preset table
    713767 */
    … …  
    718772
    719773        for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
    720                 spec->mixers[spec->num_mixers++] = preset->mixers[i];
     774                add_mixer(spec, preset->mixers[i]);
     775        spec->cap_mixer = preset->cap_mixer;
    721776        for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
    722777             i++)
    723                 spec->init_verbs[spec->num_init_verbs++] =
    724                         preset->init_verbs[i];
     778                add_verb(spec, preset->init_verbs[i]);
    725779
    726780        spec->channel_mode = preset->channel_mode;
    … …  
    822876}
    823877
     878#if 0 /* it's broken in some acses -- temporarily disabled */
    824879static void alc_mic_automute(struct hda_codec *codec)
    825880{
    … …  
    842897                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
    843898}
     899#else
     900#define alc_mic_automute(codec) /* NOP */
     901#endif /* disabled */
    844902
    845903/* unsolicited event for HP jack sensing */
    … …  
    10511109                        AC_USRSP_EN | ALC880_HP_EVENT);
    10521110
     1111#if 0 /* it's broken in some acses -- temporarily disabled */
    10531112        if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
    10541113                spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
    … …  
    10571116                        AC_VERB_SET_UNSOLICITED_ENABLE,
    10581117                        AC_USRSP_EN | ALC880_MIC_EVENT);
     1118#endif /* disabled */
    10591119
    10601120        spec->unsol_event = alc_sku_unsol_event;
    … …  
    11911251};
    11921252
     1253static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
     1254                            struct snd_ctl_elem_info *uinfo)
     1255{
     1256        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
     1257        struct alc_spec *spec = codec->spec;
     1258        int err;
     1259
     1260        mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1261        kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
     1262                                                      HDA_INPUT);
     1263        err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
     1264        mutex_unlock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1265        return err;
     1266}
     1267
     1268static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
     1269                           unsigned int size, unsigned int __user *tlv)
     1270{
     1271        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
     1272        struct alc_spec *spec = codec->spec;
     1273        int err;
     1274
     1275        mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1276        kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
     1277                                                      HDA_INPUT);
     1278        err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
     1279        mutex_unlock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1280        return err;
     1281}
     1282
     1283typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
     1284                             struct snd_ctl_elem_value *ucontrol);
     1285
     1286static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
     1287                                 struct snd_ctl_elem_value *ucontrol,
     1288                                 getput_call_t func)
     1289{
     1290        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
     1291        struct alc_spec *spec = codec->spec;
     1292        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
     1293        int err;
     1294
     1295        mutex_lock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1296        kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
     1297                                                      3, 0, HDA_INPUT);
     1298        err = func(kcontrol, ucontrol);
     1299        mutex_unlock(&codec->spdif_mutex); /* reuse spdif_mutex */
     1300        return err;
     1301}
     1302
     1303static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
     1304                           struct snd_ctl_elem_value *ucontrol)
     1305{
     1306        return alc_cap_getput_caller(kcontrol, ucontrol,
     1307                                     snd_hda_mixer_amp_volume_get);
     1308}
     1309
     1310static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
     1311                           struct snd_ctl_elem_value *ucontrol)
     1312{
     1313        return alc_cap_getput_caller(kcontrol, ucontrol,
     1314                                     snd_hda_mixer_amp_volume_put);
     1315}
     1316
    11931317/* capture mixer elements */
    1194 static struct snd_kcontrol_new alc880_capture_mixer[] = {
    1195         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
    1196         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
    1197         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
    1198         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
    1199         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
    1200         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
    1201         {
    1202                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    1203                 /* The multiple "Capture Source" controls confuse alsamixer
    1204                  * So call somewhat different..
    1205                  */
    1206                 /* .name = "Capture Source", */
    1207                 .name = "Input Source",
    1208                 .count = 3,
    1209                 .info = alc_mux_enum_info,
    1210                 .get = alc_mux_enum_get,
    1211                 .put = alc_mux_enum_put,
    1212         },
    1213         {0} /* end */
    1214 };
    1215 
    1216 /* capture mixer elements (in case NID 0x07 not available) */
    1217 static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
    1218         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    1219         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    1220         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    1221         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    1222         {
    1223                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    1224                 /* The multiple "Capture Source" controls confuse alsamixer
    1225                  * So call somewhat different..
    1226                  */
    1227                 /* .name = "Capture Source", */
    1228                 .name = "Input Source",
    1229                 .count = 2,
    1230                 .info = alc_mux_enum_info,
    1231                 .get = alc_mux_enum_get,
    1232                 .put = alc_mux_enum_put,
    1233         },
    1234         {0} /* end */
    1235 };
     1318#define alc_cap_sw_info         snd_ctl_boolean_stereo_info
     1319
     1320static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
     1321                          struct snd_ctl_elem_value *ucontrol)
     1322{
     1323        return alc_cap_getput_caller(kcontrol, ucontrol,
     1324                                     snd_hda_mixer_amp_switch_get);
     1325}
     1326
     1327static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
     1328                          struct snd_ctl_elem_value *ucontrol)
     1329{
     1330        return alc_cap_getput_caller(kcontrol, ucontrol,
     1331                                     snd_hda_mixer_amp_switch_put);
     1332}
     1333
     1334#define DEFINE_CAPMIX(num) \
     1335static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
     1336        { \
     1337                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
     1338                .name = "Capture Switch", \
     1339                .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
     1340                .count = num, \
     1341                .info = alc_cap_sw_info, \
     1342                .get = alc_cap_sw_get, \
     1343                .put = alc_cap_sw_put, \
     1344        }, \
     1345        { \
     1346                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
     1347                .name = "Capture Volume", \
     1348                .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
     1349                           SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
     1350                           SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
     1351                .count = num, \
     1352                .info = alc_cap_vol_info, \
     1353                .get = alc_cap_vol_get, \
     1354                .put = alc_cap_vol_put, \
     1355                .tlv = { .c = alc_cap_vol_tlv }, \
     1356        }, \
     1357        { \
     1358                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
     1359                /* .name = "Capture Source", */ \
     1360                .name = "Input Source", \
     1361                .count = num, \
     1362                .info = alc_mux_enum_info, \
     1363                .get = alc_mux_enum_get, \
     1364                .put = alc_mux_enum_put, \
     1365        }, \
     1366        {0} /* end */ \
     1367}
     1368
     1369/* up to three ADCs */
     1370DEFINE_CAPMIX(1);
     1371DEFINE_CAPMIX(2);
     1372DEFINE_CAPMIX(3);
    12361373
    12371374
    … …  
    15201657        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    15211658        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    1522         {
    1523                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    1524                 /* The multiple "Capture Source" controls confuse alsamixer
    1525                  * So call somewhat different..
    1526                  */
    1527                 /* .name = "Capture Source", */
    1528                 .name = "Input Source",
    1529                 .count = 1,
    1530                 .info = alc_mux_enum_info,
    1531                 .get = alc_mux_enum_get,
    1532                 .put = alc_mux_enum_put,
    1533         },
    15341659        {0} /* end */
    15351660};
    … …  
    16061731        "Mono Playback Volume",
    16071732        "Line-Out Playback Volume",
     1733        "PCM Playback Volume",
    16081734        NULL,
    16091735};
    … …  
    16391765                        return err;
    16401766        }
    1641 
     1767        if (spec->cap_mixer) {
     1768                err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
     1769                if (err < 0)
     1770                        return err;
     1771        }
    16421772        if (spec->multiout.dig_out_nid) {
    16431773                err = snd_hda_create_spdif_out_ctls(codec,
    … …  
    27902920}
    27912921
     2922#ifdef SND_HDA_NEEDS_RESUME
     2923static void store_pin_configs(struct hda_codec *codec)
     2924{
     2925        struct alc_spec *spec = codec->spec;
     2926        hda_nid_t nid, end_nid;
     2927
     2928        end_nid = codec->start_nid + codec->num_nodes;
     2929        for (nid = codec->start_nid; nid < end_nid; nid++) {
     2930                unsigned int wid_caps = get_wcaps(codec, nid);
     2931                unsigned int wid_type =
     2932                        (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
     2933                if (wid_type != AC_WID_PIN)
     2934                        continue;
     2935                if (spec->num_pins >= ARRAY_SIZE(spec->pin_nids))
     2936                        break;
     2937                spec->pin_nids[spec->num_pins] = nid;
     2938                spec->pin_cfgs[spec->num_pins] =
     2939                        snd_hda_codec_read(codec, nid, 0,
     2940                                           AC_VERB_GET_CONFIG_DEFAULT, 0);
     2941                spec->num_pins++;
     2942        }
     2943}
     2944
     2945static void resume_pin_configs(struct hda_codec *codec)
     2946{
     2947        struct alc_spec *spec = codec->spec;
     2948        int i;
     2949
     2950        for (i = 0; i < spec->num_pins; i++) {
     2951                hda_nid_t pin_nid = spec->pin_nids[i];
     2952                unsigned int pin_config = spec->pin_cfgs[i];
     2953                snd_hda_codec_write(codec, pin_nid, 0,
     2954                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
     2955                                    pin_config & 0x000000ff);
     2956                snd_hda_codec_write(codec, pin_nid, 0,
     2957                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
     2958                                    (pin_config & 0x0000ff00) >> 8);
     2959                snd_hda_codec_write(codec, pin_nid, 0,
     2960                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
     2961                                    (pin_config & 0x00ff0000) >> 16);
     2962                snd_hda_codec_write(codec, pin_nid, 0,
     2963                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
     2964                                    pin_config >> 24);
     2965        }
     2966}
     2967
     2968static int alc_resume(struct hda_codec *codec)
     2969{
     2970        resume_pin_configs(codec);
     2971        codec->patch_ops.init(codec);
     2972        snd_hda_codec_resume_amp(codec);
     2973        snd_hda_codec_resume_cache(codec);
     2974        return 0;
     2975}
     2976#else
     2977#define store_pin_configs(codec)
     2978#endif
     2979
    27922980/*
    27932981 */
    … …  
    27982986        .free = alc_free,
    27992987        .unsol_event = alc_unsol_event,
     2988#ifdef SND_HDA_NEEDS_RESUME
     2989        .resume = alc_resume,
     2990#endif
    28002991#ifdef CONFIG_SND_HDA_POWER_SAVE
    28012992        .check_power_status = alc_check_power_status,
    … …  
    32063397                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
    32073398                .dac_nids = alc880_dac_nids,
     3399                .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
     3400                .num_adc_nids = 1, /* single ADC */
    32083401                .hp_nid = 0x03,
    32093402                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
    … …  
    38204013
    38214014        if (spec->kctls.list)
    3822                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
    3823 
    3824         spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
     4015                add_mixer(spec, spec->kctls.list);
     4016
     4017        add_verb(spec, alc880_volume_init_verbs);
    38254018
    38264019        spec->num_mux_defs = 1;
    38274020        spec->input_mux = &spec->private_imux;
    38284021
     4022        store_pin_configs(codec);
    38294023        return 1;
    38304024}
    … …  
    38444038 * OK, here we have finally the patch for ALC880
    38454039 */
     4040
     4041static void set_capture_mixer(struct alc_spec *spec)
     4042{
     4043        static struct snd_kcontrol_new *caps[3] = {
     4044                alc_capture_mixer1,
     4045                alc_capture_mixer2,
     4046                alc_capture_mixer3,
     4047        };
     4048        if (spec->num_adc_nids > 0 && spec->num_adc_nids < 3)
     4049                spec->cap_mixer = caps[spec->num_adc_nids - 1];
     4050}
    38464051
    38474052static int patch_alc880(struct hda_codec *codec)
    … …  
    39004105                        spec->adc_nids = alc880_adc_nids_alt;
    39014106                        spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
    3902                         spec->mixers[spec->num_mixers] =
    3903                                 alc880_capture_alt_mixer;
    3904                         spec->num_mixers++;
    39054107                } else {
    39064108                        spec->adc_nids = alc880_adc_nids;
    39074109                        spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
    3908                         spec->mixers[spec->num_mixers] = alc880_capture_mixer;
    3909                         spec->num_mixers++;
    39104110                }
    39114111        }
     4112        set_capture_mixer(spec);
    39124113
    39134114        spec->vmaster_nid = 0x0c;
    … …  
    39424143        /* ADC1 */
    39434144        0x05,
    3944 };
    3945 
    3946 static hda_nid_t alc260_hp_adc_nids[2] = {
    3947         /* ADC1, 0 */
    3948         0x05, 0x04
    39494145};
    39504146
    … …  
    40774273        unsigned int val = spec->master_sw ? PIN_HP : 0;
    40784274        /* change HP and line-out pins */
    4079         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
     4275        snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
    40804276                            val);
    4081         snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
     4277        snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
    40824278                            val);
    40834279        /* mono (speaker) depending on the HP jack sense */
    40844280        val = (val && !spec->jack_present) ? PIN_OUT : 0;
    4085         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
     4281        snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
    40864282                            val);
    40874283}
    … …  
    41624358                .get = alc260_hp_master_sw_get,
    41634359                .put = alc260_hp_master_sw_put,
    4164                 .private_value = (0x10 << 16) | (0x15 << 8) | 0x11
     4360                .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
    41654361        },
    41664362        HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
    … …  
    42154411                                     AC_VERB_GET_PIN_SENSE, 0);
    42164412        spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
    4217         alc260_hp_master_update(codec, 0x10, 0x15, 0x11);
     4413        alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
    42184414}
    42194415
    … …  
    43444540        HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
    43454541        ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
    4346         {0} /* end */
    4347 };
    4348 
    4349 /* capture mixer elements */
    4350 static struct snd_kcontrol_new alc260_capture_mixer[] = {
    4351         HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
    4352         HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
    4353         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
    4354         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
    4355         {
    4356                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    4357                 /* The multiple "Capture Source" controls confuse alsamixer
    4358                  * So call somewhat different..
    4359                  */
    4360                 /* .name = "Capture Source", */
    4361                 .name = "Input Source",
    4362                 .count = 2,
    4363                 .info = alc_mux_enum_info,
    4364                 .get = alc_mux_enum_get,
    4365                 .put = alc_mux_enum_put,
    4366         },
    4367         {0} /* end */
    4368 };
    4369 
    4370 static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
    4371         HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
    4372         HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
    4373         {
    4374                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    4375                 /* The multiple "Capture Source" controls confuse alsamixer
    4376                  * So call somewhat different..
    4377                  */
    4378                 /* .name = "Capture Source", */
    4379                 .name = "Input Source",
    4380                 .count = 1,
    4381                 .info = alc_mux_enum_info,
    4382                 .get = alc_mux_enum_get,
    4383                 .put = alc_mux_enum_put,
    4384         },
    43854542        {0} /* end */
    43864543};
    … …  
    52025359{
    52035360        struct alc_spec *spec = codec->spec;
    5204         unsigned int wcap;
    52055361        int err;
    52065362        static hda_nid_t alc260_ignore[] = { 0x17, 0 };
    … …  
    52245380                spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
    52255381        if (spec->kctls.list)
    5226                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
    5227 
    5228         spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
     5382                add_mixer(spec, spec->kctls.list);
     5383
     5384        add_verb(spec, alc260_volume_init_verbs);
    52295385
    52305386        spec->num_mux_defs = 1;
    52315387        spec->input_mux = &spec->private_imux;
    52325388
    5233         /* check whether NID 0x04 is valid */
    5234         wcap = get_wcaps(codec, 0x04);
    5235         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
    5236         if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
    5237                 spec->adc_nids = alc260_adc_nids_alt;
    5238                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
    5239                 spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
    5240         } else {
    5241                 spec->adc_nids = alc260_adc_nids;
    5242                 spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
    5243                 spec->mixers[spec->num_mixers] = alc260_capture_mixer;
    5244         }
    5245         spec->num_mixers++;
    5246 
     5389        store_pin_configs(codec);
    52475390        return 1;
    52485391}
    … …  
    53135456                .mixers = { alc260_base_output_mixer,
    53145457                            alc260_input_mixer,
    5315                             alc260_pc_beep_mixer,
    5316                             alc260_capture_mixer },
     5458                            alc260_pc_beep_mixer },
    53175459                .init_verbs = { alc260_init_verbs },
    53185460                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
    53195461                .dac_nids = alc260_dac_nids,
    5320                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
     5462                .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
    53215463                .adc_nids = alc260_adc_nids,
    53225464                .num_channel_mode = ARRAY_SIZE(alc260_modes),
    … …  
    53265468        [ALC260_HP] = {
    53275469                .mixers = { alc260_hp_output_mixer,
    5328                             alc260_input_mixer,
    5329                             alc260_capture_alt_mixer },
     5470                            alc260_input_mixer },
    53305471                .init_verbs = { alc260_init_verbs,
    53315472                                alc260_hp_unsol_verbs },
    53325473                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
    53335474                .dac_nids = alc260_dac_nids,
    5334                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
    5335                 .adc_nids = alc260_hp_adc_nids,
     5475                .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
     5476                .adc_nids = alc260_adc_nids_alt,
    53365477                .num_channel_mode = ARRAY_SIZE(alc260_modes),
    53375478                .channel_mode = alc260_modes,
    … …  
    53425483        [ALC260_HP_DC7600] = {
    53435484                .mixers = { alc260_hp_dc7600_mixer,
    5344                             alc260_input_mixer,
    5345                             alc260_capture_alt_mixer },
     5485                            alc260_input_mixer },
    53465486                .init_verbs = { alc260_init_verbs,
    53475487                                alc260_hp_dc7600_verbs },
    53485488                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
    53495489                .dac_nids = alc260_dac_nids,
    5350                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
    5351                 .adc_nids = alc260_hp_adc_nids,
     5490                .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
     5491                .adc_nids = alc260_adc_nids_alt,
    53525492                .num_channel_mode = ARRAY_SIZE(alc260_modes),
    53535493                .channel_mode = alc260_modes,
    … …  
    53585498        [ALC260_HP_3013] = {
    53595499                .mixers = { alc260_hp_3013_mixer,
    5360                             alc260_input_mixer,
    5361                             alc260_capture_alt_mixer },
     5500                            alc260_input_mixer },
    53625501                .init_verbs = { alc260_hp_3013_init_verbs,
    53635502                                alc260_hp_3013_unsol_verbs },
    53645503                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
    53655504                .dac_nids = alc260_dac_nids,
    5366                 .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
    5367                 .adc_nids = alc260_hp_adc_nids,
     5505                .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
     5506                .adc_nids = alc260_adc_nids_alt,
    53685507                .num_channel_mode = ARRAY_SIZE(alc260_modes),
    53695508                .channel_mode = alc260_modes,
    … …  
    53735512        },
    53745513        [ALC260_FUJITSU_S702X] = {
    5375                 .mixers = { alc260_fujitsu_mixer,
    5376                             alc260_capture_mixer },
     5514                .mixers = { alc260_fujitsu_mixer },
    53775515                .init_verbs = { alc260_fujitsu_init_verbs },
    53785516                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
    … …  
    53865524        },
    53875525        [ALC260_ACER] = {
    5388                 .mixers = { alc260_acer_mixer,
    5389                             alc260_capture_mixer },
     5526                .mixers = { alc260_acer_mixer },
    53905527                .init_verbs = { alc260_acer_init_verbs },
    53915528                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
    … …  
    53995536        },
    54005537        [ALC260_WILL] = {
    5401                 .mixers = { alc260_will_mixer,
    5402                             alc260_capture_mixer },
     5538                .mixers = { alc260_will_mixer },
    54035539                .init_verbs = { alc260_init_verbs, alc260_will_verbs },
    54045540                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
    … …  
    54125548        },
    54135549        [ALC260_REPLACER_672V] = {
    5414                 .mixers = { alc260_replacer_672v_mixer,
    5415                             alc260_capture_mixer },
     5550                .mixers = { alc260_replacer_672v_mixer },
    54165551                .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
    54175552                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
    … …  
    54285563#ifdef CONFIG_SND_DEBUG
    54295564        [ALC260_TEST] = {
    5430                 .mixers = { alc260_test_mixer,
    5431                             alc260_capture_mixer },
     5565                .mixers = { alc260_test_mixer },
    54325566                .init_verbs = { alc260_test_init_verbs },
    54335567                .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
    … …  
    54885622        spec->stream_digital_capture = &alc260_pcm_digital_capture;
    54895623
     5624        if (!spec->adc_nids && spec->input_mux) {
     5625                /* check whether NID 0x04 is valid */
     5626                unsigned int wcap = get_wcaps(codec, 0x04);
     5627                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
     5628                /* get type */
     5629                if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
     5630                        spec->adc_nids = alc260_adc_nids_alt;
     5631                        spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
     5632                } else {
     5633                        spec->adc_nids = alc260_adc_nids;
     5634                        spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
     5635                }
     5636        }
     5637        set_capture_mixer(spec);
     5638
    54905639        spec->vmaster_nid = 0x08;
    54915640
    … …  
    55445693        },
    55455694};
    5546 #define alc882_mux_enum_info alc_mux_enum_info
    5547 #define alc882_mux_enum_get alc_mux_enum_get
    5548 
    5549 static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol,
    5550                                struct snd_ctl_elem_value *ucontrol)
    5551 {
    5552         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
    5553         struct alc_spec *spec = codec->spec;
    5554         const struct hda_input_mux *imux = spec->input_mux;
    5555         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
    5556         hda_nid_t nid = spec->capsrc_nids ?
    5557                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
    5558         unsigned int *cur_val = &spec->cur_mux[adc_idx];
    5559         unsigned int i, idx;
    5560 
    5561         idx = ucontrol->value.enumerated.item[0];
    5562         if (idx >= imux->num_items)
    5563                 idx = imux->num_items - 1;
    5564         if (*cur_val == idx)
    5565                 return 0;
    5566         for (i = 0; i < imux->num_items; i++) {
    5567                 unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
    5568                 snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
    5569                                          imux->items[i].index,
    5570                                          HDA_AMP_MUTE, v);
    5571         }
    5572         *cur_val = idx;
    5573         return 1;
    5574 }
    5575 
    55765695/*
    55775696 * 2ch mode
    … …  
    62566375};
    62576376
    6258 /* capture mixer elements */
    6259 static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
    6260         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    6261         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    6262         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    6263         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    6264         {
    6265                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    6266                 /* The multiple "Capture Source" controls confuse alsamixer
    6267                  * So call somewhat different..
    6268                  */
    6269                 /* .name = "Capture Source", */
    6270                 .name = "Input Source",
    6271                 .count = 2,
    6272                 .info = alc882_mux_enum_info,
    6273                 .get = alc882_mux_enum_get,
    6274                 .put = alc882_mux_enum_put,
    6275         },
    6276         {0} /* end */
    6277 };
    6278 
    6279 static struct snd_kcontrol_new alc882_capture_mixer[] = {
    6280         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
    6281         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
    6282         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
    6283         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
    6284         HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
    6285         HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
    6286         {
    6287                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    6288                 /* The multiple "Capture Source" controls confuse alsamixer
    6289                  * So call somewhat different..
    6290                  */
    6291                 /* .name = "Capture Source", */
    6292                 .name = "Input Source",
    6293                 .count = 3,
    6294                 .info = alc882_mux_enum_info,
    6295                 .get = alc882_mux_enum_get,
    6296                 .put = alc882_mux_enum_put,
    6297         },
    6298         {0} /* end */
    6299 };
    6300 
    63016377#ifdef CONFIG_SND_HDA_POWER_SAVE
    63026378#define alc882_loopbacks        alc880_loopbacks
    … …  
    64276503        },
    64286504        [ALC882_TARGA] = {
    6429                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer,
    6430                             alc882_capture_mixer },
     6505                .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
    64316506                .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
    64326507                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
    … …  
    64446519        },
    64456520        [ALC882_ASUS_A7J] = {
    6446                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer,
    6447                             alc882_capture_mixer },
     6521                .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
    64486522                .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
    64496523                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
    … …  
    67506824        spec->stream_digital_capture = &alc882_pcm_digital_capture;
    67516825
     6826        spec->is_mix_capture = 1; /* matrix-style capture */
    67526827        if (!spec->adc_nids && spec->input_mux) {
    67536828                /* check whether NID 0x07 is valid */
    … …  
    67596834                        spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids_alt);
    67606835                        spec->capsrc_nids = alc882_capsrc_nids_alt;
    6761                         spec->mixers[spec->num_mixers] =
    6762                                 alc882_capture_alt_mixer;
    6763                         spec->num_mixers++;
    67646836                } else {
    67656837                        spec->adc_nids = alc882_adc_nids;
    67666838                        spec->num_adc_nids = ARRAY_SIZE(alc882_adc_nids);
    67676839                        spec->capsrc_nids = alc882_capsrc_nids;
    6768                         spec->mixers[spec->num_mixers] = alc882_capture_mixer;
    6769                         spec->num_mixers++;
    67706840                }
    67716841        }
     6842        set_capture_mixer(spec);
    67726843
    67736844        spec->vmaster_nid = 0x0c;
    … …  
    68086879};
    68096880
     6881static hda_nid_t alc883_adc_nids_alt[1] = {
     6882        /* ADC1 */
     6883        0x08,
     6884};
     6885
    68106886static hda_nid_t alc883_capsrc_nids[2] = { 0x23, 0x22 };
    68116887
    … …  
    68756951        },
    68766952};
    6877 
    6878 #define alc883_mux_enum_info alc_mux_enum_info
    6879 #define alc883_mux_enum_get alc_mux_enum_get
    6880 /* ALC883 has the ALC882-type input selection */
    6881 #define alc883_mux_enum_put alc882_mux_enum_put
    68826953
    68836954/*
    … …  
    70347105        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
    70357106        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
    7036         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7037         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7038         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7039         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7040         {
    7041                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7042                 /* .name = "Capture Source", */
    7043                 .name = "Input Source",
    7044                 .count = 2,
    7045                 .info = alc883_mux_enum_info,
    7046                 .get = alc883_mux_enum_get,
    7047                 .put = alc883_mux_enum_put,
    7048         },
    70497107        {0} /* end */
    70507108};
    … …  
    70647122        HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
    70657123        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
    7066         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7067         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7068         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7069         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7070         {
    7071                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7072                 /* .name = "Capture Source", */
    7073                 .name = "Input Source",
    7074                 .count = 2,
    7075                 .info = alc883_mux_enum_info,
    7076                 .get = alc883_mux_enum_get,
    7077                 .put = alc883_mux_enum_put,
    7078         },
    70797124        {0} /* end */
    70807125};
    … …  
    70917136        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
    70927137        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
    7093         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7094         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7095         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7096         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7097         {
    7098                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7099                 /* .name = "Capture Source", */
    7100                 .name = "Input Source",
    7101                 .count = 2,
    7102                 .info = alc883_mux_enum_info,
    7103                 .get = alc883_mux_enum_get,
    7104                 .put = alc883_mux_enum_put,
    7105         },
    71067138        {0} /* end */
    71077139};
    … …  
    71187150        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
    71197151        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
    7120         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7121         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7122         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7123         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7124         {
    7125                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7126                 /* .name = "Capture Source", */
    7127                 .name = "Input Source",
    7128                 .count = 2,
    7129                 .info = alc883_mux_enum_info,
    7130                 .get = alc883_mux_enum_get,
    7131                 .put = alc883_mux_enum_put,
    7132         },
    71337152        {0} /* end */
    71347153};
    … …  
    71507169        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
    71517170        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
    7152         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7153         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7154         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7155         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7156         {
    7157                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7158                 /* .name = "Capture Source", */
    7159                 .name = "Input Source",
    7160                 .count = 2,
    7161                 .info = alc883_mux_enum_info,
    7162                 .get = alc883_mux_enum_get,
    7163                 .put = alc883_mux_enum_put,
    7164         },
    71657171        {0} /* end */
    71667172};
    … …  
    71887194        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
    71897195        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
    7190         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7191         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7192         {
    7193                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7194                 /* .name = "Capture Source", */
    7195                 .name = "Input Source",
    7196                 .count = 1,
    7197                 .info = alc883_mux_enum_info,
    7198                 .get = alc883_mux_enum_get,
    7199                 .put = alc883_mux_enum_put,
    7200         },
    72017196        {0} /* end */
    72027197};
    … …  
    72257220        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
    72267221        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
    7227         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7228         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7229         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7230         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7231         {
    7232                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7233                 /* .name = "Capture Source", */
    7234                 .name = "Input Source",
    7235                 .count = 2,
    7236                 .info = alc883_mux_enum_info,
    7237                 .get = alc883_mux_enum_get,
    7238                 .put = alc883_mux_enum_put,
    7239         },
    72407222        {0} /* end */
    72417223};
    … …  
    72637245        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
    72647246        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
    7265         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7266         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7267 
    7268         {
    7269                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7270                 /* .name = "Capture Source", */
    7271                 .name = "Input Source",
    7272                 .count = 1,
    7273                 .info = alc883_mux_enum_info,
    7274                 .get = alc883_mux_enum_get,
    7275                 .put = alc883_mux_enum_put,
    7276         },
    72777247        {0} /* end */
    72787248};
    … …  
    72957265        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
    72967266        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
    7297         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7298         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7299         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7300         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7301         {
    7302                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7303                 /* .name = "Capture Source", */
    7304                 .name = "Input Source",
    7305                 .count = 2,
    7306                 .info = alc883_mux_enum_info,
    7307                 .get = alc883_mux_enum_get,
    7308                 .put = alc883_mux_enum_put,
    7309         },
    73107267        {0} /* end */
    73117268};
    … …  
    73237280        HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
    73247281        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
    7325         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7326         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7327         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7328         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7329         {
    7330                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7331                 /* .name = "Capture Source", */
    7332                 .name = "Input Source",
    7333                 .count = 2,
    7334                 .info = alc883_mux_enum_info,
    7335                 .get = alc883_mux_enum_get,
    7336                 .put = alc883_mux_enum_put,
    7337         },
    73387282        {0} /* end */
    73397283};
    … …  
    73487292        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
    73497293        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
    7350         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7351         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7352         {
    7353                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7354                 /* .name = "Capture Source", */
    7355                 .name = "Input Source",
    7356                 .count = 1,
    7357                 .info = alc883_mux_enum_info,
    7358                 .get = alc883_mux_enum_get,
    7359                 .put = alc883_mux_enum_put,
    7360         },
    73617294        {0} /* end */
    73627295};
    … …  
    73727305        HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
    73737306        HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
    7374         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7375         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7376         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7377         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7378         {
    7379                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7380                 /* .name = "Capture Source", */
    7381                 .name = "Input Source",
    7382                 .count = 2,
    7383                 .info = alc883_mux_enum_info,
    7384                 .get = alc883_mux_enum_get,
    7385                 .put = alc883_mux_enum_put,
    7386         },
    73877307        {0} /* end */
    73887308};
    … …  
    73987318        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
    73997319        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
    7400         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7401         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7402         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7403         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7404         {
    7405                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7406                 /* .name = "Capture Source", */
    7407                 .name = "Input Source",
    7408                 .count = 2,
    7409                 .info = alc883_mux_enum_info,
    7410                 .get = alc883_mux_enum_get,
    7411                 .put = alc883_mux_enum_put,
    7412         },
    74137320        {0} /* end */
    74147321};
    … …  
    74237330        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
    74247331        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
    7425         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7426         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7427         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7428         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7429         {
    7430                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7431                 /* .name = "Capture Source", */
    7432                 .name = "Input Source",
    7433                 .count = 2,
    7434                 .info = alc883_mux_enum_info,
    7435                 .get = alc883_mux_enum_get,
    7436                 .put = alc883_mux_enum_put,
    7437         },
    74387332        {0} /* end */
    74397333};
    … …  
    74637357        HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
    74647358        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
    7465         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    7466         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    7467         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    7468         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    7469         {
    7470                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    7471                 /* .name = "Capture Source", */
    7472                 .name = "Input Source",
    7473                 .count = 2,
    7474                 .info = alc883_mux_enum_info,
    7475                 .get = alc883_mux_enum_get,
    7476                 .put = alc883_mux_enum_put,
    7477         },
    74787359        {0} /* end */
    74797360};
    … …  
    75067387        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
    75077388        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
     7389        {0} /* end */
     7390};
     7391
     7392static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
    75087393        HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
    75097394        HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
    … …  
    75137398                .name = "Input Source",
    75147399                .count = 1,
    7515                 .info = alc883_mux_enum_info,
    7516                 .get = alc883_mux_enum_get,
    7517                 .put = alc883_mux_enum_put,
     7400                .info = alc_mux_enum_info,
     7401                .get = alc_mux_enum_get,
     7402                .put = alc_mux_enum_put,
    75187403        },
    75197404        {0} /* end */
    … …  
    81708055};
    81718056
    8172 /* capture mixer elements */
    8173 static struct snd_kcontrol_new alc883_capture_mixer[] = {
    8174         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    8175         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    8176         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
    8177         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
    8178         {
    8179                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    8180                 /* The multiple "Capture Source" controls confuse alsamixer
    8181                  * So call somewhat different..
    8182                  */
    8183                 /* .name = "Capture Source", */
    8184                 .name = "Input Source",
    8185                 .count = 2,
    8186                 .info = alc882_mux_enum_info,
    8187                 .get = alc882_mux_enum_get,
    8188                 .put = alc882_mux_enum_put,
    8189         },
    8190         {0} /* end */
    8191 };
    8192 
    81938057static struct hda_verb alc888_asus_m90v_verbs[] = {
    81948058        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
    … …  
    83338197        SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC883_3ST_6ch_DIG),
    83348198        SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
     8199        SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
    83358200        SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
    83368201        SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
    … …  
    83878252        SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
    83888253        SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
     8254        SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
    83898255        SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
    83908256        SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
    … …  
    84708336                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
    84718337                .dac_nids = alc883_dac_nids,
     8338                .adc_nids = alc883_adc_nids_alt,
     8339                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
    84728340                .dig_out_nid = ALC883_DIGOUT_NID,
    84738341                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
    … …  
    85108378                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
    85118379                .dac_nids = alc883_dac_nids,
     8380                .adc_nids = alc883_adc_nids_alt,
     8381                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
    85128382                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
    85138383                .channel_mode = alc883_sixstack_modes,
    … …  
    85528422                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
    85538423                .dac_nids = alc883_dac_nids,
     8424                .adc_nids = alc883_adc_nids_alt,
     8425                .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
    85548426                .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
    85558427                .channel_mode = alc883_3ST_2ch_modes,
    … …  
    86488520                .dac_nids = alc883_dac_nids,
    86498521                .dig_out_nid = ALC883_DIGOUT_NID,
    8650                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
    8651                 .adc_nids = alc883_adc_nids,
    86528522                .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
    86538523                .channel_mode = alc883_sixstack_modes,
    … …  
    86738543        [ALC888_ASUS_EEE1601] = {
    86748544                .mixers = { alc883_asus_eee1601_mixer },
     8545                .cap_mixer = alc883_asus_eee1601_cap_mixer,
    86758546                .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
    86768547                .num_dacs = ARRAY_SIZE(alc883_dac_nids),
    … …  
    87798650        /* hack - override the init verbs */
    87808651        spec->init_verbs[0] = alc883_auto_init_verbs;
    8781         spec->mixers[spec->num_mixers] = alc883_capture_mixer;
    8782         spec->num_mixers++;
    87838652
    87848653        return 1; /* config found */
    … …  
    88638732        spec->stream_digital_capture = &alc883_pcm_digital_capture;
    88648733
    8865         spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
    8866         spec->adc_nids = alc883_adc_nids;
    8867         spec->capsrc_nids = alc883_capsrc_nids;
     8734        if (!spec->num_adc_nids) {
     8735                spec->num_adc_nids = ARRAY_SIZE(alc883_adc_nids);
     8736                spec->adc_nids = alc883_adc_nids;
     8737        }
     8738        if (!spec->capsrc_nids)
     8739                spec->capsrc_nids = alc883_capsrc_nids;
     8740        spec->is_mix_capture = 1; /* matrix-style capture */
     8741        if (!spec->cap_mixer)
     8742                set_capture_mixer(spec);
    88688743
    88698744        spec->vmaster_nid = 0x0c;
    … …  
    93569231        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
    93579232        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
    9358         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
    9359         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
    9360         {
    9361                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    9362                 /* The multiple "Capture Source" controls confuse alsamixer
    9363                  * So call somewhat different..
    9364                  */
    9365                 /* .name = "Capture Source", */
    9366                 .name = "Input Source",
    9367                 .count = 1,
    9368                 .info = alc_mux_enum_info,
    9369                 .get = alc_mux_enum_get,
    9370                 .put = alc_mux_enum_put,
    9371         },
    93729233        {0} /* end */
    93739234};
    … …  
    98869747        int ret;
    98879748
    9888         ret = alc882_mux_enum_put(kcontrol, ucontrol);
     9749        ret = alc_mux_enum_put(kcontrol, ucontrol);
    98899750        if (!ret)
    98909751                return 0;
    … …  
    99039764                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    99049765                .name = "Capture Source",
    9905                 .info = alc882_mux_enum_info,
    9906                 .get = alc882_mux_enum_get,
     9766                .info = alc_mux_enum_info,
     9767                .get = alc_mux_enum_get,
    99079768                .put = alc262_ultra_mux_enum_put,
    99089769        },
    … …  
    1029810159
    1029910160        if (spec->kctls.list)
    10300                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
    10301 
    10302         spec->init_verbs[spec->num_init_verbs++] = alc262_volume_init_verbs;
     10161                add_mixer(spec, spec->kctls.list);
     10162
     10163        add_verb(spec, alc262_volume_init_verbs);
    1030310164        spec->num_mux_defs = 1;
    1030410165        spec->input_mux = &spec->private_imux;
    … …  
    1030810169                return err;
    1030910170
     10171        store_pin_configs(codec);
    1031010172        return 1;
    1031110173}
    … …  
    1054010402        },
    1054110403        [ALC262_ULTRA] = {
    10542                 .mixers = { alc262_ultra_mixer, alc262_ultra_capture_mixer },
     10404                .mixers = { alc262_ultra_mixer },
     10405                .cap_mixer = alc262_ultra_capture_mixer,
    1054310406                .init_verbs = { alc262_ultra_verbs },
    1054410407                .num_dacs = ARRAY_SIZE(alc262_dac_nids),
    … …  
    1066610529        spec->stream_digital_capture = &alc262_pcm_digital_capture;
    1066710530
     10531        spec->is_mix_capture = 1;
    1066810532        if (!spec->adc_nids && spec->input_mux) {
    1066910533                /* check whether NID 0x07 is valid */
    … …  
    1067610540                        spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids_alt);
    1067710541                        spec->capsrc_nids = alc262_capsrc_nids_alt;
    10678                         spec->mixers[spec->num_mixers] =
    10679                                 alc262_capture_alt_mixer;
    10680                         spec->num_mixers++;
    1068110542                } else {
    1068210543                        spec->adc_nids = alc262_adc_nids;
    1068310544                        spec->num_adc_nids = ARRAY_SIZE(alc262_adc_nids);
    1068410545                        spec->capsrc_nids = alc262_capsrc_nids;
    10685                         spec->mixers[spec->num_mixers] = alc262_capture_mixer;
    10686                         spec->num_mixers++;
    1068710546                }
    1068810547        }
     10548        if (!spec->cap_mixer)
     10549                set_capture_mixer(spec);
    1068910550
    1069010551        spec->vmaster_nid = 0x0c;
    … …  
    1085810719};
    1085910720
     10721static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
     10722        /* output mixer control */
     10723        HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
     10724        {
     10725                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     10726                .name = "Master Playback Switch",
     10727                .info = snd_hda_mixer_amp_switch_info,
     10728                .get = snd_hda_mixer_amp_switch_get,
     10729                .put = alc268_acer_master_sw_put,
     10730                .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
     10731        },
     10732        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
     10733        HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
     10734        {0}
     10735};
     10736
    1086010737static struct hda_verb alc268_acer_aspire_one_verbs[] = {
    1086110738        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
    … …  
    1113411011};
    1113511012
    11136 #define alc268_mux_enum_info alc_mux_enum_info
    11137 #define alc268_mux_enum_get alc_mux_enum_get
    11138 #define alc268_mux_enum_put alc_mux_enum_put
    11139 
    1114011013static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
    1114111014        HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
    … …  
    1114911022                .name = "Input Source",
    1115011023                .count = 1,
    11151                 .info = alc268_mux_enum_info,
    11152                 .get = alc268_mux_enum_get,
    11153                 .put = alc268_mux_enum_put,
     11024                .info = alc_mux_enum_info,
     11025                .get = alc_mux_enum_get,
     11026                .put = alc_mux_enum_put,
    1115411027        },
    1115511028        {0} /* end */
    … …  
    1116911042                .name = "Input Source",
    1117011043                .count = 2,
    11171                 .info = alc268_mux_enum_info,
    11172                 .get = alc268_mux_enum_get,
    11173                 .put = alc268_mux_enum_put,
     11044                .info = alc_mux_enum_info,
     11045                .get = alc_mux_enum_get,
     11046                .put = alc_mux_enum_put,
    1117411047        },
    1117511048        {0} /* end */
    … …  
    1118711060
    1118811061static struct hda_input_mux alc268_acer_capture_source = {
     11062        .num_items = 3,
     11063        .items = {
     11064                { "Mic", 0x0 },
     11065                { "Internal Mic", 0x1 },
     11066                { "Line", 0x2 },
     11067        },
     11068};
     11069
     11070static struct hda_input_mux alc268_acer_dmic_capture_source = {
    1118911071        .num_items = 3,
    1119011072        .items = {
    … …  
    1142911311
    1143011312        if (spec->kctls.list)
    11431                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
     11313                add_mixer(spec, spec->kctls.list);
    1143211314
    1143311315        if (spec->autocfg.speaker_pins[0] != 0x1d)
    11434                 spec->mixers[spec->num_mixers++] = alc268_beep_mixer;
    11435 
    11436         spec->init_verbs[spec->num_init_verbs++] = alc268_volume_init_verbs;
     11316                add_mixer(spec, alc268_beep_mixer);
     11317
     11318        add_verb(spec, alc268_volume_init_verbs);
    1143711319        spec->num_mux_defs = 1;
    1143811320        spec->input_mux = &spec->private_imux;
    … …  
    1144211324                return err;
    1144311325
     11326        store_pin_configs(codec);
    1144411327        return 1;
    1144511328}
    … …  
    1146911352        [ALC268_TOSHIBA]        = "toshiba",
    1147011353        [ALC268_ACER]           = "acer",
     11354        [ALC268_ACER_DMIC]      = "acer-dmic",
    1147111355        [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
    1147211356        [ALC268_DELL]           = "dell",
    … …  
    1156411448                .init_hook = alc268_acer_init_hook,
    1156511449        },
     11450        [ALC268_ACER_DMIC] = {
     11451                .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
     11452                            alc268_beep_mixer },
     11453                .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
     11454                                alc268_acer_verbs },
     11455                .num_dacs = ARRAY_SIZE(alc268_dac_nids),
     11456                .dac_nids = alc268_dac_nids,
     11457                .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
     11458                .adc_nids = alc268_adc_nids_alt,
     11459                .capsrc_nids = alc268_capsrc_nids,
     11460                .hp_nid = 0x02,
     11461                .num_channel_mode = ARRAY_SIZE(alc268_modes),
     11462                .channel_mode = alc268_modes,
     11463                .input_mux = &alc268_acer_dmic_capture_source,
     11464                .unsol_event = alc268_acer_unsol_event,
     11465                .init_hook = alc268_acer_init_hook,
     11466        },
    1156611467        [ALC268_ACER_ASPIRE_ONE] = {
    1156711468                .mixers = { alc268_acer_aspire_one_mixer,
    … …  
    1170211603                        spec->adc_nids = alc268_adc_nids_alt;
    1170311604                        spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
    11704                         spec->mixers[spec->num_mixers] =
    11705                                         alc268_capture_alt_mixer;
    11706                         spec->num_mixers++;
     11605                        add_mixer(spec, alc268_capture_alt_mixer);
    1170711606                } else {
    1170811607                        spec->adc_nids = alc268_adc_nids;
    1170911608                        spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
    11710                         spec->mixers[spec->num_mixers] =
    11711                                 alc268_capture_mixer;
    11712                         spec->num_mixers++;
     11609                        add_mixer(spec, alc268_capture_mixer);
    1171311610                }
    1171411611                spec->capsrc_nids = alc268_capsrc_nids;
    … …  
    1180811705};
    1180911706
     11707static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
     11708        /* output mixer control */
     11709        HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
     11710        {
     11711                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
     11712                .name = "Master Playback Switch",
     11713                .info = snd_hda_mixer_amp_switch_info,
     11714                .get = snd_hda_mixer_amp_switch_get,
     11715                .put = alc268_acer_master_sw_put,
     11716                .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
     11717        },
     11718        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
     11719        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
     11720        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
     11721        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
     11722        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
     11723        HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
     11724        HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
     11725        HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
     11726        HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
     11727        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x04, HDA_INPUT),
     11728        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x04, HDA_INPUT),
     11729        {0}
     11730};
     11731
    1181011732/* bind volumes of both NID 0x0c and 0x0d */
    1181111733static struct hda_bind_ctls alc269_epc_bind_vol = {
    … …  
    1182611748
    1182711749/* capture mixer elements */
    11828 static struct snd_kcontrol_new alc269_capture_mixer[] = {
    11829         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    11830         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    11831         {
    11832                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    11833                 /* The multiple "Capture Source" controls confuse alsamixer
    11834                  * So call somewhat different..
    11835                  */
    11836                 /* .name = "Capture Source", */
    11837                 .name = "Input Source",
    11838                 .count = 1,
    11839                 .info = alc_mux_enum_info,
    11840                 .get = alc_mux_enum_get,
    11841                 .put = alc_mux_enum_put,
    11842         },
    11843         {0} /* end */
    11844 };
    11845 
    11846 /* capture mixer elements */
    1184711750static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
    1184811751        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    1184911752        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
     11753        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
     11754        {0} /* end */
     11755};
     11756
     11757/* FSC amilo */
     11758static struct snd_kcontrol_new alc269_fujitsu_mixer[] = {
     11759        HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
     11760        HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
     11761        HDA_BIND_VOL("PCM Playback Volume", &alc269_epc_bind_vol),
    1185011762        {0} /* end */
    1185111763};
    … …  
    1186811780};
    1186911781
     11782static struct hda_verb alc269_lifebook_verbs[] = {
     11783        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
     11784        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
     11785        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
     11786        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
     11787        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
     11788        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
     11789        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
     11790        {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
     11791        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
     11792        {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
     11793        {0}
     11794};
     11795
    1187011796/* toggle speaker-output according to the hp-jack state */
    1187111797static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
    … …  
    1189311819}
    1189411820
     11821/* toggle speaker-output according to the hp-jacks state */
     11822static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
     11823{
     11824        unsigned int present;
     11825        unsigned char bits;
     11826
     11827        /* Check laptop headphone socket */
     11828        present = snd_hda_codec_read(codec, 0x15, 0,
     11829                        AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
     11830
     11831        /* Check port replicator headphone socket */
     11832        present |= snd_hda_codec_read(codec, 0x1a, 0,
     11833                        AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
     11834
     11835        bits = present ? AMP_IN_MUTE(0) : 0;
     11836        snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
     11837                        AMP_IN_MUTE(0), bits);
     11838        snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
     11839                        AMP_IN_MUTE(0), bits);
     11840
     11841        snd_hda_codec_write(codec, 0x20, 0,
     11842                        AC_VERB_SET_COEF_INDEX, 0x0c);
     11843        snd_hda_codec_write(codec, 0x20, 0,
     11844                        AC_VERB_SET_PROC_COEF, 0x680);
     11845
     11846        snd_hda_codec_write(codec, 0x20, 0,
     11847                        AC_VERB_SET_COEF_INDEX, 0x0c);
     11848        snd_hda_codec_write(codec, 0x20, 0,
     11849                        AC_VERB_SET_PROC_COEF, 0x480);
     11850}
     11851
    1189511852static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
    1189611853{
    … …  
    1190311860}
    1190411861
     11862static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
     11863{
     11864        unsigned int present_laptop;
     11865        unsigned int present_dock;
     11866
     11867        present_laptop = snd_hda_codec_read(codec, 0x18, 0,
     11868                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
     11869
     11870        present_dock = snd_hda_codec_read(codec, 0x1b, 0,
     11871                                AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
     11872
     11873        /* Laptop mic port overrides dock mic port, design decision */
     11874        if (present_dock)
     11875                snd_hda_codec_write(codec, 0x23, 0,
     11876                                AC_VERB_SET_CONNECT_SEL, 0x3);
     11877        if (present_laptop)
     11878                snd_hda_codec_write(codec, 0x23, 0,
     11879                                AC_VERB_SET_CONNECT_SEL, 0x0);
     11880        if (!present_dock && !present_laptop)
     11881                snd_hda_codec_write(codec, 0x23, 0,
     11882                                AC_VERB_SET_CONNECT_SEL, 0x1);
     11883}
     11884
    1190511885static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
    1190611886                                    unsigned int res)
    … …  
    1191211892}
    1191311893
     11894static void alc269_lifebook_unsol_event(struct hda_codec *codec,
     11895                                        unsigned int res)
     11896{
     11897        if ((res >> 26) == ALC880_HP_EVENT)
     11898                alc269_lifebook_speaker_automute(codec);
     11899        if ((res >> 26) == ALC880_MIC_EVENT)
     11900                alc269_lifebook_mic_autoswitch(codec);
     11901}
     11902
    1191411903static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
    1191511904{
    1191611905        alc269_quanta_fl1_speaker_automute(codec);
    1191711906        alc269_quanta_fl1_mic_automute(codec);
     11907}
     11908
     11909static void alc269_lifebook_init_hook(struct hda_codec *codec)
     11910{
     11911        alc269_lifebook_speaker_automute(codec);
     11912        alc269_lifebook_mic_autoswitch(codec);
    1191811913}
    1191911914
    … …  
    1216112156}
    1216212157
    12163 #define alc269_auto_create_analog_input_ctls \
    12164         alc880_auto_create_analog_input_ctls
     12158static int alc269_auto_create_analog_input_ctls(struct alc_spec *spec,
     12159                                                const struct auto_pin_cfg *cfg)
     12160{
     12161        int err;
     12162
     12163        err = alc880_auto_create_analog_input_ctls(spec, cfg);
     12164        if (err < 0)
     12165                return err;
     12166        /* digital-mic input pin is excluded in alc880_auto_create..()
     12167         * because it's under 0x18
     12168         */
     12169        if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
     12170            cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
     12171                struct hda_input_mux *imux = &spec->private_imux;
     12172                imux->items[imux->num_items].label = "Int Mic";
     12173                imux->items[imux->num_items].index = 0x05;
     12174                imux->num_items++;
     12175        }
     12176        return 0;
     12177}
    1216512178
    1216612179#ifdef CONFIG_SND_HDA_POWER_SAVE
    … …  
    1220112214
    1220212215        if (spec->kctls.list)
    12203                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
     12216                add_mixer(spec, spec->kctls.list);
    1220412217
    1220512218        /* create a beep mixer control if the pin 0x1d isn't assigned */
    … …  
    1220812221                        break;
    1220912222        if (i >= ARRAY_SIZE(spec->autocfg.input_pins))
    12210                 spec->mixers[spec->num_mixers++] = alc269_beep_mixer;
    12211 
    12212         spec->init_verbs[spec->num_init_verbs++] = alc269_init_verbs;
     12223                add_mixer(spec, alc269_beep_mixer);
     12224
     12225        add_verb(spec, alc269_init_verbs);
    1221312226        spec->num_mux_defs = 1;
    1221412227        spec->input_mux = &spec->private_imux;
    … …  
    1222212235                return err;
    1222312236
    12224         spec->mixers[spec->num_mixers] = alc269_capture_mixer;
    12225         spec->num_mixers++;
    12226 
     12237        if (!spec->cap_mixer)
     12238                set_capture_mixer(spec);
     12239
     12240        store_pin_configs(codec);
    1222712241        return 1;
    1222812242}
    … …  
    1225112265        [ALC269_QUANTA_FL1]             = "quanta",
    1225212266        [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
    12253         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901"
     12267        [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
     12268        [ALC269_FUJITSU]                = "fujitsu",
     12269        [ALC269_LIFEBOOK]               = "lifebook"
    1225412270};
    1225512271
    … …  
    1226212278        SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
    1226312279                      ALC269_ASUS_EEEPC_P901),
     12280        SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
     12281        SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
    1226412282        {0}
    1226512283};
    … …  
    1226712285static struct alc_config_preset alc269_presets[] = {
    1226812286        [ALC269_BASIC] = {
    12269                 .mixers = { alc269_base_mixer, alc269_capture_mixer },
     12287                .mixers = { alc269_base_mixer },
    1227012288                .init_verbs = { alc269_init_verbs },
    1227112289                .num_dacs = ARRAY_SIZE(alc269_dac_nids),
    … …  
    1228912307        },
    1229012308        [ALC269_ASUS_EEEPC_P703] = {
    12291                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer },
     12309                .mixers = { alc269_eeepc_mixer },
     12310                .cap_mixer = alc269_epc_capture_mixer,
    1229212311                .init_verbs = { alc269_init_verbs,
    1229312312                                alc269_eeepc_amic_init_verbs },
    … …  
    1230212321        },
    1230312322        [ALC269_ASUS_EEEPC_P901] = {
    12304                 .mixers = { alc269_eeepc_mixer, alc269_epc_capture_mixer},
     12323                .mixers = { alc269_eeepc_mixer },
     12324                .cap_mixer = alc269_epc_capture_mixer,
    1230512325                .init_verbs = { alc269_init_verbs,
    1230612326                                alc269_eeepc_dmic_init_verbs },
    … …  
    1231312333                .unsol_event = alc269_eeepc_dmic_unsol_event,
    1231412334                .init_hook = alc269_eeepc_dmic_inithook,
     12335        },
     12336        [ALC269_FUJITSU] = {
     12337                .mixers = { alc269_fujitsu_mixer, alc269_beep_mixer },
     12338                .cap_mixer = alc269_epc_capture_mixer,
     12339                .init_verbs = { alc269_init_verbs,
     12340                                alc269_eeepc_dmic_init_verbs },
     12341                .num_dacs = ARRAY_SIZE(alc269_dac_nids),
     12342                .dac_nids = alc269_dac_nids,
     12343                .hp_nid = 0x03,
     12344                .num_channel_mode = ARRAY_SIZE(alc269_modes),
     12345                .channel_mode = alc269_modes,
     12346                .input_mux = &alc269_eeepc_dmic_capture_source,
     12347                .unsol_event = alc269_eeepc_dmic_unsol_event,
     12348                .init_hook = alc269_eeepc_dmic_inithook,
     12349        },
     12350        [ALC269_LIFEBOOK] = {
     12351                .mixers = { alc269_lifebook_mixer },
     12352                .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
     12353                .num_dacs = ARRAY_SIZE(alc269_dac_nids),
     12354                .dac_nids = alc269_dac_nids,
     12355                .hp_nid = 0x03,
     12356                .num_channel_mode = ARRAY_SIZE(alc269_modes),
     12357                .channel_mode = alc269_modes,
     12358                .input_mux = &alc269_capture_source,
     12359                .unsol_event = alc269_lifebook_unsol_event,
     12360                .init_hook = alc269_lifebook_init_hook,
    1231512361        },
    1231612362};
    … …  
    1236812414        spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
    1236912415        spec->capsrc_nids = alc269_capsrc_nids;
     12416        if (!spec->cap_mixer)
     12417                set_capture_mixer(spec);
    1237012418
    1237112419        codec->patch_ops = alc_patch_ops;
    … …  
    1250712555        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
    1250812556        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
    12509 
    12510         /* Capture mixer control */
    12511         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    12512         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    12513         {
    12514                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    12515                 .name = "Capture Source",
    12516                 .count = 1,
    12517                 .info = alc_mux_enum_info,
    12518                 .get = alc_mux_enum_get,
    12519                 .put = alc_mux_enum_put,
    12520         },
    1252112557        {0} /* end */
    1252212558};
    … …  
    1254212578        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
    1254312579
    12544         /* Capture mixer control */
    12545         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    12546         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    12547         {
    12548                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    12549                 .name = "Capture Source",
    12550                 .count = 1,
    12551                 .info = alc_mux_enum_info,
    12552                 .get = alc_mux_enum_get,
    12553                 .put = alc_mux_enum_put,
    12554         },
    1255512580        {
    1255612581                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    … …  
    1256912594        HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
    1257012595        HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
    12571 
    12572         /*Capture mixer control */
    12573         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    12574         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    12575         {
    12576                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    12577                 .name = "Capture Source",
    12578                 .count = 1,
    12579                 .info = alc_mux_enum_info,
    12580                 .get = alc_mux_enum_get,
    12581                 .put = alc_mux_enum_put,
    12582         },
    1258312596
    1258412597        {0} /* end */
    … …  
    1260512618        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
    1260612619
    12607         /* Capture mixer control */
    12608         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    12609         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    12610         {
    12611                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    12612                 .name = "Capture Source",
    12613                 .count = 1,
    12614                 .info = alc_mux_enum_info,
    12615                 .get = alc_mux_enum_get,
    12616                 .put = alc_mux_enum_put,
    12617         },
    1261812620        {
    1261912621                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    … …  
    1264712649        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
    1264812650
    12649         /* Capture mixer control */
    12650         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    12651         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    12652         {
    12653                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    12654                 .name = "Capture Source",
    12655                 .count = 1,
    12656                 .info = alc_mux_enum_info,
    12657                 .get = alc_mux_enum_get,
    12658                 .put = alc_mux_enum_put,
    12659         },
    1266012651        {
    1266112652                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    … …  
    1318913180}
    1319013181
    13191 static struct snd_kcontrol_new alc861_capture_mixer[] = {
    13192         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
    13193         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
    13194 
    13195         {
    13196                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    13197                 /* The multiple "Capture Source" controls confuse alsamixer
    13198                  * So call somewhat different..
    13199                  */
    13200                 /* .name = "Capture Source", */
    13201                 .name = "Input Source",
    13202                 .count = 1,
    13203                 .info = alc_mux_enum_info,
    13204                 .get = alc_mux_enum_get,
    13205                 .put = alc_mux_enum_put,
    13206         },
    13207         {0} /* end */
    13208 };
    13209 
    1321013182static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
    1321113183                                              hda_nid_t nid,
    … …  
    1329913271
    1330013272        if (spec->kctls.list)
    13301                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
    13302 
    13303         spec->init_verbs[spec->num_init_verbs++] = alc861_auto_init_verbs;
     13273                add_mixer(spec, spec->kctls.list);
     13274
     13275        add_verb(spec, alc861_auto_init_verbs);
    1330413276
    1330513277        spec->num_mux_defs = 1;
    … …  
    1330813280        spec->adc_nids = alc861_adc_nids;
    1330913281        spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
    13310         spec->mixers[spec->num_mixers] = alc861_capture_mixer;
    13311         spec->num_mixers++;
    13312 
     13282        set_capture_mixer(spec);
     13283
     13284        store_pin_configs(codec);
    1331313285        return 1;
    1331413286}
    … …  
    1360413576};
    1360513577
    13606 #define alc861vd_mux_enum_info alc_mux_enum_info
    13607 #define alc861vd_mux_enum_get alc_mux_enum_get
    13608 /* ALC861VD has the ALC882-type input selection (but has only one ADC) */
    13609 #define alc861vd_mux_enum_put alc882_mux_enum_put
    13610 
    1361113578/*
    1361213579 * 2ch mode
    … …  
    1365013617                .get = alc_ch_mode_get,
    1365113618                .put = alc_ch_mode_put,
    13652         },
    13653         {0} /* end */
    13654 };
    13655 
    13656 static struct snd_kcontrol_new alc861vd_capture_mixer[] = {
    13657         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
    13658         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
    13659 
    13660         {
    13661                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    13662                 /* The multiple "Capture Source" controls confuse alsamixer
    13663                  * So call somewhat different..
    13664                  */
    13665                 /* .name = "Capture Source", */
    13666                 .name = "Input Source",
    13667                 .count = 1,
    13668                 .info = alc861vd_mux_enum_info,
    13669                 .get = alc861vd_mux_enum_get,
    13670                 .put = alc861vd_mux_enum_put,
    1367113619        },
    1367213620        {0} /* end */
    … …  
    1406414012        [ALC660VD_3ST]          = "3stack-660",
    1406514013        [ALC660VD_3ST_DIG]      = "3stack-660-digout",
     14014        [ALC660VD_ASUS_V1S]     = "asus-v1s",
    1406614015        [ALC861VD_3ST]          = "3stack",
    1406714016        [ALC861VD_3ST_DIG]      = "3stack-digout",
    … …  
    1407814027        SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
    1407914028        SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
    14080         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC861VD_LENOVO),
     14029        SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
    1408114030        SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
    1408214031        SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
    … …  
    1418414133                .unsol_event = alc861vd_dallas_unsol_event,
    1418514134                .init_hook = alc861vd_dallas_automute,
     14135        },
     14136        [ALC660VD_ASUS_V1S] = {
     14137                .mixers = { alc861vd_lenovo_mixer },
     14138                .init_verbs = { alc861vd_volume_init_verbs,
     14139                                alc861vd_3stack_init_verbs,
     14140                                alc861vd_eapd_verbs,
     14141                                alc861vd_lenovo_unsol_verbs },
     14142                .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
     14143                .dac_nids = alc660vd_dac_nids,
     14144                .dig_out_nid = ALC861VD_DIGOUT_NID,
     14145                .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
     14146                .channel_mode = alc861vd_3stack_2ch_modes,
     14147                .input_mux = &alc861vd_capture_source,
     14148                .unsol_event = alc861vd_lenovo_unsol_event,
     14149                .init_hook = alc861vd_lenovo_automute,
    1418614150        },
    1418714151};
    … …  
    1441014374
    1441114375        if (spec->kctls.list)
    14412                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
    14413 
    14414         spec->init_verbs[spec->num_init_verbs++]
    14415                 = alc861vd_volume_init_verbs;
     14376                add_mixer(spec, spec->kctls.list);
     14377
     14378        add_verb(spec, alc861vd_volume_init_verbs);
    1441614379
    1441714380        spec->num_mux_defs = 1;
    … …  
    1442214385                return err;
    1442314386
     14387        store_pin_configs(codec);
    1442414388        return 1;
    1442514389}
    … …  
    1447914443                spec->stream_name_digital = "ALC660-VD Digital";
    1448014444                /* always turn on EAPD */
    14481                 spec->init_verbs[spec->num_init_verbs++] = alc660vd_eapd_verbs;
     14445                add_verb(spec, alc660vd_eapd_verbs);
    1448214446        } else {
    1448314447                spec->stream_name_analog = "ALC861VD Analog";
    … …  
    1449414458        spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
    1449514459        spec->capsrc_nids = alc861vd_capsrc_nids;
    14496 
    14497         spec->mixers[spec->num_mixers] = alc861vd_capture_mixer;
    14498         spec->num_mixers++;
     14460        spec->is_mix_capture = 1;
     14461
     14462        set_capture_mixer(spec);
    1449914463
    1450014464        spec->vmaster_nid = 0x02;
    … …  
    1458214546        },
    1458314547};
    14584 
    14585 #define alc662_mux_enum_info alc_mux_enum_info
    14586 #define alc662_mux_enum_get alc_mux_enum_get
    14587 #define alc662_mux_enum_put alc882_mux_enum_put
    1458814548
    1458914549/*
    … …  
    1517015130        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
    1517115131        {0}
    15172 };
    15173 
    15174 /* capture mixer elements */
    15175 static struct snd_kcontrol_new alc662_capture_mixer[] = {
    15176         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
    15177         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
    15178         {
    15179                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    15180                 /* The multiple "Capture Source" controls confuse alsamixer
    15181                  * So call somewhat different..
    15182                  */
    15183                 /* .name = "Capture Source", */
    15184                 .name = "Input Source",
    15185                 .count = 1,
    15186                 .info = alc662_mux_enum_info,
    15187                 .get = alc662_mux_enum_get,
    15188                 .put = alc662_mux_enum_put,
    15189         },
    15190         {0} /* end */
    1519115132};
    1519215133
    … …  
    1576215703static struct alc_config_preset alc662_presets[] = {
    1576315704        [ALC662_3ST_2ch_DIG] = {
    15764                 .mixers = { alc662_3ST_2ch_mixer, alc662_capture_mixer },
     15705                .mixers = { alc662_3ST_2ch_mixer },
    1576515706                .init_verbs = { alc662_init_verbs },
    1576615707                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
    … …  
    1577315714        },
    1577415715        [ALC662_3ST_6ch_DIG] = {
    15775                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
    15776                             alc662_capture_mixer },
     15716                .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
    1577715717                .init_verbs = { alc662_init_verbs },
    1577815718                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
    … …  
    1578615726        },
    1578715727        [ALC662_3ST_6ch] = {
    15788                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer,
    15789                             alc662_capture_mixer },
     15728                .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
    1579015729                .init_verbs = { alc662_init_verbs },
    1579115730                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
    … …  
    1579715736        },
    1579815737        [ALC662_5ST_DIG] = {
    15799                 .mixers = { alc662_base_mixer, alc662_chmode_mixer,
    15800                             alc662_capture_mixer },
     15738                .mixers = { alc662_base_mixer, alc662_chmode_mixer },
    1580115739                .init_verbs = { alc662_init_verbs },
    1580215740                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
    … …  
    1580915747        },
    1581015748        [ALC662_LENOVO_101E] = {
    15811                 .mixers = { alc662_lenovo_101e_mixer, alc662_capture_mixer },
     15749                .mixers = { alc662_lenovo_101e_mixer },
    1581215750                .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
    1581315751                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
    … …  
    1582015758        },
    1582115759        [ALC662_ASUS_EEEPC_P701] = {
    15822                 .mixers = { alc662_eeepc_p701_mixer, alc662_capture_mixer },
     15760                .mixers = { alc662_eeepc_p701_mixer },
    1582315761                .init_verbs = { alc662_init_verbs,
    1582415762                                alc662_eeepc_sue_init_verbs },
    … …  
    1583215770        },
    1583315771        [ALC662_ASUS_EEEPC_EP20] = {
    15834                 .mixers = { alc662_eeepc_ep20_mixer, alc662_capture_mixer,
     15772                .mixers = { alc662_eeepc_ep20_mixer,
    1583515773                            alc662_chmode_mixer },
    1583615774                .init_verbs = { alc662_init_verbs,
    … …  
    1584515783        },
    1584615784        [ALC662_ECS] = {
    15847                 .mixers = { alc662_ecs_mixer, alc662_capture_mixer },
     15785                .mixers = { alc662_ecs_mixer },
    1584815786                .init_verbs = { alc662_init_verbs,
    1584915787                                alc662_ecs_init_verbs },
    … …  
    1585715795        },
    1585815796        [ALC663_ASUS_M51VA] = {
    15859                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
     15797                .mixers = { alc663_m51va_mixer },
    1586015798                .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
    1586115799                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
    … …  
    1586915807        },
    1587015808        [ALC663_ASUS_G71V] = {
    15871                 .mixers = { alc663_g71v_mixer, alc662_capture_mixer},
     15809                .mixers = { alc663_g71v_mixer },
    1587215810                .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
    1587315811                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
    … …  
    1588115819        },
    1588215820        [ALC663_ASUS_H13] = {
    15883                 .mixers = { alc663_m51va_mixer, alc662_capture_mixer},
     15821                .mixers = { alc663_m51va_mixer },
    1588415822                .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
    1588515823                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
    … …  
    1589215830        },
    1589315831        [ALC663_ASUS_G50V] = {
    15894                 .mixers = { alc663_g50v_mixer, alc662_capture_mixer},
     15832                .mixers = { alc663_g50v_mixer },
    1589515833                .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
    1589615834                .num_dacs = ARRAY_SIZE(alc662_dac_nids),
    … …  
    1590415842        },
    1590515843        [ALC663_ASUS_MODE1] = {
    15906                 .mixers = { alc663_m51va_mixer, alc662_auto_capture_mixer },
     15844                .mixers = { alc663_m51va_mixer },
     15845                .cap_mixer = alc662_auto_capture_mixer,
    1590715846                .init_verbs = { alc662_init_verbs,
    1590815847                                alc663_21jd_amic_init_verbs },
    … …  
    1591815857        },
    1591915858        [ALC662_ASUS_MODE2] = {
    15920                 .mixers = { alc662_1bjd_mixer, alc662_auto_capture_mixer },
     15859                .mixers = { alc662_1bjd_mixer },
     15860                .cap_mixer = alc662_auto_capture_mixer,
    1592115861                .init_verbs = { alc662_init_verbs,
    1592215862                                alc662_1bjd_amic_init_verbs },
    … …  
    1593115871        },
    1593215872        [ALC663_ASUS_MODE3] = {
    15933                 .mixers = { alc663_two_hp_m1_mixer, alc662_auto_capture_mixer },
     15873                .mixers = { alc663_two_hp_m1_mixer },
     15874                .cap_mixer = alc662_auto_capture_mixer,
    1593415875                .init_verbs = { alc662_init_verbs,
    1593515876                                alc663_two_hp_amic_m1_init_verbs },
    … …  
    1594515886        },
    1594615887        [ALC663_ASUS_MODE4] = {
    15947                 .mixers = { alc663_asus_21jd_clfe_mixer,
    15948                                 alc662_auto_capture_mixer},
     15888                .mixers = { alc663_asus_21jd_clfe_mixer },
     15889                .cap_mixer = alc662_auto_capture_mixer,
    1594915890                .init_verbs = { alc662_init_verbs,
    1595015891                                alc663_21jd_amic_init_verbs},
    … …  
    1596015901        },
    1596115902        [ALC663_ASUS_MODE5] = {
    15962                 .mixers = { alc663_asus_15jd_clfe_mixer,
    15963                                 alc662_auto_capture_mixer },
     15903                .mixers = { alc663_asus_15jd_clfe_mixer },
     15904                .cap_mixer = alc662_auto_capture_mixer,
    1596415905                .init_verbs = { alc662_init_verbs,
    1596515906                                alc663_15jd_amic_init_verbs },
    … …  
    1597515916        },
    1597615917        [ALC663_ASUS_MODE6] = {
    15977                 .mixers = { alc663_two_hp_m2_mixer, alc662_auto_capture_mixer },
     15918                .mixers = { alc663_two_hp_m2_mixer },
     15919                .cap_mixer = alc662_auto_capture_mixer,
    1597815920                .init_verbs = { alc662_init_verbs,
    1597915921                                alc663_two_hp_amic_m2_init_verbs },
    … …  
    1623716179
    1623816180        if (spec->kctls.list)
    16239                 spec->mixers[spec->num_mixers++] = spec->kctls.list;
     16181                add_mixer(spec, spec->kctls.list);
    1624016182
    1624116183        spec->num_mux_defs = 1;
    1624216184        spec->input_mux = &spec->private_imux;
    1624316185
    16244         spec->init_verbs[spec->num_init_verbs++] = alc662_auto_init_verbs;
     16186        add_verb(spec, alc662_auto_init_verbs);
    1624516187        if (codec->vendor_id == 0x10ec0663)
    16246                 spec->init_verbs[spec->num_init_verbs++] =
    16247                         alc663_auto_init_verbs;
     16188                add_verb(spec, alc663_auto_init_verbs);
    1624816189
    1624916190        err = alc_auto_add_mic_boost(codec);
    … …  
    1625116192                return err;
    1625216193
    16253         spec->mixers[spec->num_mixers] = alc662_capture_mixer;
    16254         spec->num_mixers++;
     16194        store_pin_configs(codec);
    1625516195        return 1;
    1625616196}
    … …  
    1632716267        spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
    1632816268        spec->capsrc_nids = alc662_capsrc_nids;
     16269        spec->is_mix_capture = 1;
     16270
     16271        if (!spec->cap_mixer)
     16272                set_capture_mixer(spec);
    1632916273
    1633016274        spec->vmaster_nid = 0x02;

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/hda/patch_sigmatel.c

    r399 r402  
    7171        STAC_92HD73XX_REF,
    7272        STAC_DELL_M6,
     73        STAC_DELL_EQ,
    7374        STAC_92HD73XX_MODELS
    7475};
    … …  
    584585                if (spec->cur_smux[smux_idx] == smux->num_items - 1)
    585586                        val = AMP_OUT_MUTE;
    586                 if (smux_idx == 0)
    587                         nid = spec->multiout.dig_out_nid;
    588587                else
    589                         nid = codec->slave_dig_outs[smux_idx - 1];
     588                        val = AMP_OUT_UNMUTE;
    590589                /* un/mute SPDIF out */
    591590                snd_hda_codec_write_cache(codec, nid, 0,
    … …  
    793792
    794793static struct hda_verb dell_m6_core_init[] = {
    795         /* set master volume to max value without distortion
    796          * and direct control */
    797         { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
     794        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
    798795        /* setup audio connections */
    799796        { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
    … …  
    16231620        [STAC_92HD73XX_REF]     = ref92hd73xx_pin_configs,
    16241621        [STAC_DELL_M6]  = dell_m6_pin_configs,
     1622        [STAC_DELL_EQ]  = dell_m6_pin_configs,
    16251623};
    16261624
    … …  
    16281626        [STAC_92HD73XX_REF] = "ref",
    16291627        [STAC_DELL_M6] = "dell-m6",
     1628        [STAC_DELL_EQ] = "dell-eq",
    16301629};
    16311630
    … …  
    42754274
    42764275        switch (spec->board_config) {
     4276        case STAC_DELL_EQ:
     4277                spec->init = dell_eq_core_init;
     4278                /* fallthru */
    42774279        case STAC_DELL_M6:
    4278                 spec->init = dell_eq_core_init;
    42794280                spec->num_smuxes = 0;
    42804281                spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
    42814282                spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
    42824283                spec->num_amps = 1;
     4284
     4285                if (!spec->init)
     4286                        spec->init = dell_m6_core_init;
    42834287                switch (codec->subsystem_id) {
    42844288                case 0x1028025e: /* Analog Mics */
    … …  
    42904294                case 0x10280271: /* Digital Mics */
    42914295                case 0x10280272:
    4292                         spec->init = dell_m6_core_init;
    4293                         /* fall-through */
    42944296                case 0x10280254:
    42954297                case 0x10280255:

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/intel8x0.c

    r399 r402  
    27072707        SND_PCI_QUIRK(0x1028, 0x00be, "AD1885", 44100),
    27082708        SND_PCI_QUIRK(0x1028, 0x0177, "AD1980", 48000),
     2709        SND_PCI_QUIRK(0x1028, 0x01ad, "AD1981B", 48000),
    27092710        SND_PCI_QUIRK(0x1043, 0x80f3, "AD1985", 48000),
    27102711        {0}     /* terminator */

  • GPL/branches/uniaud32-2.0/alsa-kernel/pci/rme9652/hdsp.c

    r399 r402  
    45494549        struct hdsp *hdsp = (struct hdsp *)hw->private_data;   
    45504550        void __user *argp = (void __user *)arg;
     4551        int err;
    45514552
    45524553        switch (cmd) {
    45534554        case SNDRV_HDSP_IOCTL_GET_PEAK_RMS: {
    45544555                struct hdsp_peak_rms __user *peak_rms = (struct hdsp_peak_rms __user *)arg;
     4556
     4557                err = hdsp_check_for_iobox(hdsp);
     4558                if (err < 0)
     4559                        return err;
     4560
     4561                err = hdsp_check_for_firmware(hdsp, 1);
     4562                if (err < 0)
     4563                        return err;
    45554564
    45564565                if (!(hdsp->state & HDSP_FirmwareLoaded)) {
    … …  
    45734582                int i;
    45744583               
    4575                 if (!(hdsp->state & HDSP_FirmwareLoaded)) {
    4576                         snd_printk(KERN_ERR "Hammerfall-DSP: Firmware needs to be uploaded to the card.\n");   
    4577                         return -EINVAL;
    4578                 }
     4584                err = hdsp_check_for_iobox(hdsp);
     4585                if (err < 0)
     4586                        return err;
     4587
     4588                err = hdsp_check_for_firmware(hdsp, 1);
     4589                if (err < 0)
     4590                        return err;
     4591
    45794592                spin_lock_irqsave(&hdsp->lock, flags);
    45804593                info.pref_sync_ref = (unsigned char)hdsp_pref_sync_ref(hdsp);
    … …  
    50465059                ssleep(2);
    50475060
     5061                err = hdsp_check_for_iobox(hdsp);
     5062                if (err < 0)
     5063                        return err;
     5064
    50485065                if ((hdsp_read (hdsp, HDSP_statusRegister) & HDSP_DllError) != 0) {
    50495066#ifdef HDSP_FW_LOADER
    … …  
    50585075                                return 0;
    50595076#endif
    5060                         /* no iobox connected, we defer initialization */
     5077                        /* we defer initialization */
    50615078                        snd_printk(KERN_INFO "Hammerfall-DSP: card initialization pending : waiting for firmware\n");
    50625079                        if ((err = snd_hdsp_create_hwdep(card, hdsp)) < 0)

  • GPL/branches/uniaud32-2.0/uniaud.inc

    r400 r402  
    77# BUILDVERSION must be 3 parts, and only numbers like 5.44.108
    88# It is best that 2'nd number is always 2 digits, eg at least 10
    9 BUILDVERSION = 1.9.10
     9BUILDVERSION = 1.9.11
    1010
    1111# Fixpack version
    … …  
    1313# ex RC3  GA  FIXPACK2 beta_47
    1414# Comment out to avoid a fixpack line in bldlevel
    15 FIXPACK = SVN r400
     15FIXPACK = SVN r402
    1616
    1717# ALSA BUILD VERSION
    … …  
    2020# Leave empty or use MIXED
    2121# STRING must be max X chars
    22 ALSAVERSION = 1.0.18
     22ALSAVERSION = 1.0.18a
    2323
Note: See TracChangeset for help on using the changeset viewer.