Showing error 1908

User: Jiri Slaby
Error type: Invalid Pointer Dereference
Error type description: A pointer which is invalid is being dereferenced
File location: sound/pci/hda/patch_realtek.c
Line in file: 2752
Project: Linux Kernel
Project version: 2.6.28
Tools: Smatch (1.59)
Entered: 2013-09-11 08:47:26 UTC


Source:

    1/*
    2 * Universal Interface for Intel High Definition Audio Codec
    3 *
    4 * HD audio interface patch for ALC 260/880/882 codecs
    5 *
    6 * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
    7 *                    PeiSen Hou <pshou@realtek.com.tw>
    8 *                    Takashi Iwai <tiwai@suse.de>
    9 *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
   10 *
   11 *  This driver is free software; you can redistribute it and/or modify
   12 *  it under the terms of the GNU General Public License as published by
   13 *  the Free Software Foundation; either version 2 of the License, or
   14 *  (at your option) any later version.
   15 *
   16 *  This driver is distributed in the hope that it will be useful,
   17 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   18 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   19 *  GNU General Public License for more details.
   20 *
   21 *  You should have received a copy of the GNU General Public License
   22 *  along with this program; if not, write to the Free Software
   23 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
   24 */
   25
   26#include <linux/init.h>
   27#include <linux/delay.h>
   28#include <linux/slab.h>
   29#include <linux/pci.h>
   30#include <sound/core.h>
   31#include "hda_codec.h"
   32#include "hda_local.h"
   33#include "hda_patch.h"
   34
   35#define ALC880_FRONT_EVENT                0x01
   36#define ALC880_DCVOL_EVENT                0x02
   37#define ALC880_HP_EVENT                        0x04
   38#define ALC880_MIC_EVENT                0x08
   39
   40/* ALC880 board config type */
   41enum {
   42        ALC880_3ST,
   43        ALC880_3ST_DIG,
   44        ALC880_5ST,
   45        ALC880_5ST_DIG,
   46        ALC880_W810,
   47        ALC880_Z71V,
   48        ALC880_6ST,
   49        ALC880_6ST_DIG,
   50        ALC880_F1734,
   51        ALC880_ASUS,
   52        ALC880_ASUS_DIG,
   53        ALC880_ASUS_W1V,
   54        ALC880_ASUS_DIG2,
   55        ALC880_FUJITSU,
   56        ALC880_UNIWILL_DIG,
   57        ALC880_UNIWILL,
   58        ALC880_UNIWILL_P53,
   59        ALC880_CLEVO,
   60        ALC880_TCL_S700,
   61        ALC880_LG,
   62        ALC880_LG_LW,
   63        ALC880_MEDION_RIM,
   64#ifdef CONFIG_SND_DEBUG
   65        ALC880_TEST,
   66#endif
   67        ALC880_AUTO,
   68        ALC880_MODEL_LAST /* last tag */
   69};
   70
   71/* ALC260 models */
   72enum {
   73        ALC260_BASIC,
   74        ALC260_HP,
   75        ALC260_HP_DC7600,
   76        ALC260_HP_3013,
   77        ALC260_FUJITSU_S702X,
   78        ALC260_ACER,
   79        ALC260_WILL,
   80        ALC260_REPLACER_672V,
   81#ifdef CONFIG_SND_DEBUG
   82        ALC260_TEST,
   83#endif
   84        ALC260_AUTO,
   85        ALC260_MODEL_LAST /* last tag */
   86};
   87
   88/* ALC262 models */
   89enum {
   90        ALC262_BASIC,
   91        ALC262_HIPPO,
   92        ALC262_HIPPO_1,
   93        ALC262_FUJITSU,
   94        ALC262_HP_BPC,
   95        ALC262_HP_BPC_D7000_WL,
   96        ALC262_HP_BPC_D7000_WF,
   97        ALC262_HP_TC_T5735,
   98        ALC262_HP_RP5700,
   99        ALC262_BENQ_ED8,
  100        ALC262_SONY_ASSAMD,
  101        ALC262_BENQ_T31,
  102        ALC262_ULTRA,
  103        ALC262_LENOVO_3000,
  104        ALC262_NEC,
  105        ALC262_TOSHIBA_S06,
  106        ALC262_TOSHIBA_RX1,
  107        ALC262_AUTO,
  108        ALC262_MODEL_LAST /* last tag */
  109};
  110
  111/* ALC268 models */
  112enum {
  113        ALC267_QUANTA_IL1,
  114        ALC268_3ST,
  115        ALC268_TOSHIBA,
  116        ALC268_ACER,
  117        ALC268_ACER_ASPIRE_ONE,
  118        ALC268_DELL,
  119        ALC268_ZEPTO,
  120#ifdef CONFIG_SND_DEBUG
  121        ALC268_TEST,
  122#endif
  123        ALC268_AUTO,
  124        ALC268_MODEL_LAST /* last tag */
  125};
  126
  127/* ALC269 models */
  128enum {
  129        ALC269_BASIC,
  130        ALC269_QUANTA_FL1,
  131        ALC269_ASUS_EEEPC_P703,
  132        ALC269_ASUS_EEEPC_P901,
  133        ALC269_AUTO,
  134        ALC269_MODEL_LAST /* last tag */
  135};
  136
  137/* ALC861 models */
  138enum {
  139        ALC861_3ST,
  140        ALC660_3ST,
  141        ALC861_3ST_DIG,
  142        ALC861_6ST_DIG,
  143        ALC861_UNIWILL_M31,
  144        ALC861_TOSHIBA,
  145        ALC861_ASUS,
  146        ALC861_ASUS_LAPTOP,
  147        ALC861_AUTO,
  148        ALC861_MODEL_LAST,
  149};
  150
  151/* ALC861-VD models */
  152enum {
  153        ALC660VD_3ST,
  154        ALC660VD_3ST_DIG,
  155        ALC861VD_3ST,
  156        ALC861VD_3ST_DIG,
  157        ALC861VD_6ST_DIG,
  158        ALC861VD_LENOVO,
  159        ALC861VD_DALLAS,
  160        ALC861VD_HP,
  161        ALC861VD_AUTO,
  162        ALC861VD_MODEL_LAST,
  163};
  164
  165/* ALC662 models */
  166enum {
  167        ALC662_3ST_2ch_DIG,
  168        ALC662_3ST_6ch_DIG,
  169        ALC662_3ST_6ch,
  170        ALC662_5ST_DIG,
  171        ALC662_LENOVO_101E,
  172        ALC662_ASUS_EEEPC_P701,
  173        ALC662_ASUS_EEEPC_EP20,
  174        ALC663_ASUS_M51VA,
  175        ALC663_ASUS_G71V,
  176        ALC663_ASUS_H13,
  177        ALC663_ASUS_G50V,
  178        ALC662_ECS,
  179        ALC663_ASUS_MODE1,
  180        ALC662_ASUS_MODE2,
  181        ALC663_ASUS_MODE3,
  182        ALC663_ASUS_MODE4,
  183        ALC663_ASUS_MODE5,
  184        ALC663_ASUS_MODE6,
  185        ALC662_AUTO,
  186        ALC662_MODEL_LAST,
  187};
  188
  189/* ALC882 models */
  190enum {
  191        ALC882_3ST_DIG,
  192        ALC882_6ST_DIG,
  193        ALC882_ARIMA,
  194        ALC882_W2JC,
  195        ALC882_TARGA,
  196        ALC882_ASUS_A7J,
  197        ALC882_ASUS_A7M,
  198        ALC885_MACPRO,
  199        ALC885_MBP3,
  200        ALC885_IMAC24,
  201        ALC882_AUTO,
  202        ALC882_MODEL_LAST,
  203};
  204
  205/* ALC883 models */
  206enum {
  207        ALC883_3ST_2ch_DIG,
  208        ALC883_3ST_6ch_DIG,
  209        ALC883_3ST_6ch,
  210        ALC883_6ST_DIG,
  211        ALC883_TARGA_DIG,
  212        ALC883_TARGA_2ch_DIG,
  213        ALC883_ACER,
  214        ALC883_ACER_ASPIRE,
  215        ALC883_MEDION,
  216        ALC883_MEDION_MD2,
  217        ALC883_LAPTOP_EAPD,
  218        ALC883_LENOVO_101E_2ch,
  219        ALC883_LENOVO_NB0763,
  220        ALC888_LENOVO_MS7195_DIG,
  221        ALC888_LENOVO_SKY,
  222        ALC883_HAIER_W66,
  223        ALC888_3ST_HP,
  224        ALC888_6ST_DELL,
  225        ALC883_MITAC,
  226        ALC883_CLEVO_M720,
  227        ALC883_FUJITSU_PI2515,
  228        ALC883_3ST_6ch_INTEL,
  229        ALC888_ASUS_M90V,
  230        ALC888_ASUS_EEE1601,
  231        ALC883_AUTO,
  232        ALC883_MODEL_LAST,
  233};
  234
  235/* for GPIO Poll */
  236#define GPIO_MASK        0x03
  237
  238struct alc_spec {
  239        /* codec parameterization */
  240        struct snd_kcontrol_new *mixers[5];        /* mixer arrays */
  241        unsigned int num_mixers;
  242
  243        const struct hda_verb *init_verbs[5];        /* initialization verbs
  244                                                 * don't forget NULL
  245                                                 * termination!
  246                                                 */
  247        unsigned int num_init_verbs;
  248
  249        char *stream_name_analog;        /* analog PCM stream */
  250        struct hda_pcm_stream *stream_analog_playback;
  251        struct hda_pcm_stream *stream_analog_capture;
  252        struct hda_pcm_stream *stream_analog_alt_playback;
  253        struct hda_pcm_stream *stream_analog_alt_capture;
  254
  255        char *stream_name_digital;        /* digital PCM stream */
  256        struct hda_pcm_stream *stream_digital_playback;
  257        struct hda_pcm_stream *stream_digital_capture;
  258
  259        /* playback */
  260        struct hda_multi_out multiout;        /* playback set-up
  261                                         * max_channels, dacs must be set
  262                                         * dig_out_nid and hp_nid are optional
  263                                         */
  264        hda_nid_t alt_dac_nid;
  265
  266        /* capture */
  267        unsigned int num_adc_nids;
  268        hda_nid_t *adc_nids;
  269        hda_nid_t *capsrc_nids;
  270        hda_nid_t dig_in_nid;                /* digital-in NID; optional */
  271
  272        /* capture source */
  273        unsigned int num_mux_defs;
  274        const struct hda_input_mux *input_mux;
  275        unsigned int cur_mux[3];
  276
  277        /* channel model */
  278        const struct hda_channel_mode *channel_mode;
  279        int num_channel_mode;
  280        int need_dac_fix;
  281
  282        /* PCM information */
  283        struct hda_pcm pcm_rec[3];        /* used in alc_build_pcms() */
  284
  285        /* dynamic controls, init_verbs and input_mux */
  286        struct auto_pin_cfg autocfg;
  287        unsigned int num_kctl_alloc, num_kctl_used;
  288        struct snd_kcontrol_new *kctl_alloc;
  289        struct hda_input_mux private_imux;
  290        hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
  291
  292        /* hooks */
  293        void (*init_hook)(struct hda_codec *codec);
  294        void (*unsol_event)(struct hda_codec *codec, unsigned int res);
  295
  296        /* for pin sensing */
  297        unsigned int sense_updated: 1;
  298        unsigned int jack_present: 1;
  299        unsigned int master_sw: 1;
  300
  301        /* for virtual master */
  302        hda_nid_t vmaster_nid;
  303#ifdef CONFIG_SND_HDA_POWER_SAVE
  304        struct hda_loopback_check loopback;
  305#endif
  306
  307        /* for PLL fix */
  308        hda_nid_t pll_nid;
  309        unsigned int pll_coef_idx, pll_coef_bit;
  310
  311#ifdef SND_HDA_NEEDS_RESUME
  312#define ALC_MAX_PINS        16
  313        unsigned int num_pins;
  314        hda_nid_t pin_nids[ALC_MAX_PINS];
  315        unsigned int pin_cfgs[ALC_MAX_PINS];
  316#endif
  317};
  318
  319/*
  320 * configuration template - to be copied to the spec instance
  321 */
  322struct alc_config_preset {
  323        struct snd_kcontrol_new *mixers[5]; /* should be identical size
  324                                             * with spec
  325                                             */
  326        const struct hda_verb *init_verbs[5];
  327        unsigned int num_dacs;
  328        hda_nid_t *dac_nids;
  329        hda_nid_t dig_out_nid;                /* optional */
  330        hda_nid_t hp_nid;                /* optional */
  331        unsigned int num_adc_nids;
  332        hda_nid_t *adc_nids;
  333        hda_nid_t *capsrc_nids;
  334        hda_nid_t dig_in_nid;
  335        unsigned int num_channel_mode;
  336        const struct hda_channel_mode *channel_mode;
  337        int need_dac_fix;
  338        unsigned int num_mux_defs;
  339        const struct hda_input_mux *input_mux;
  340        void (*unsol_event)(struct hda_codec *, unsigned int);
  341        void (*init_hook)(struct hda_codec *);
  342#ifdef CONFIG_SND_HDA_POWER_SAVE
  343        struct hda_amp_list *loopbacks;
  344#endif
  345};
  346
  347
  348/*
  349 * input MUX handling
  350 */
  351static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
  352                             struct snd_ctl_elem_info *uinfo)
  353{
  354        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  355        struct alc_spec *spec = codec->spec;
  356        unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
  357        if (mux_idx >= spec->num_mux_defs)
  358                mux_idx = 0;
  359        return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
  360}
  361
  362static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
  363                            struct snd_ctl_elem_value *ucontrol)
  364{
  365        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  366        struct alc_spec *spec = codec->spec;
  367        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
  368
  369        ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
  370        return 0;
  371}
  372
  373static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
  374                            struct snd_ctl_elem_value *ucontrol)
  375{
  376        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  377        struct alc_spec *spec = codec->spec;
  378        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
  379        unsigned int mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
  380        hda_nid_t nid = spec->capsrc_nids ?
  381                spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
  382        return snd_hda_input_mux_put(codec, &spec->input_mux[mux_idx], ucontrol,
  383                                     nid, &spec->cur_mux[adc_idx]);
  384}
  385
  386
  387/*
  388 * channel mode setting
  389 */
  390static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
  391                            struct snd_ctl_elem_info *uinfo)
  392{
  393        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  394        struct alc_spec *spec = codec->spec;
  395        return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
  396                                    spec->num_channel_mode);
  397}
  398
  399static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
  400                           struct snd_ctl_elem_value *ucontrol)
  401{
  402        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  403        struct alc_spec *spec = codec->spec;
  404        return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
  405                                   spec->num_channel_mode,
  406                                   spec->multiout.max_channels);
  407}
  408
  409static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
  410                           struct snd_ctl_elem_value *ucontrol)
  411{
  412        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  413        struct alc_spec *spec = codec->spec;
  414        int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
  415                                      spec->num_channel_mode,
  416                                      &spec->multiout.max_channels);
  417        if (err >= 0 && spec->need_dac_fix)
  418                spec->multiout.num_dacs = spec->multiout.max_channels / 2;
  419        return err;
  420}
  421
  422/*
  423 * Control the mode of pin widget settings via the mixer.  "pc" is used
  424 * instead of "%" to avoid consequences of accidently treating the % as
  425 * being part of a format specifier.  Maximum allowed length of a value is
  426 * 63 characters plus NULL terminator.
  427 *
  428 * Note: some retasking pin complexes seem to ignore requests for input
  429 * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
  430 * are requested.  Therefore order this list so that this behaviour will not
  431 * cause problems when mixer clients move through the enum sequentially.
  432 * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
  433 * March 2006.
  434 */
  435static char *alc_pin_mode_names[] = {
  436        "Mic 50pc bias", "Mic 80pc bias",
  437        "Line in", "Line out", "Headphone out",
  438};
  439static unsigned char alc_pin_mode_values[] = {
  440        PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
  441};
  442/* The control can present all 5 options, or it can limit the options based
  443 * in the pin being assumed to be exclusively an input or an output pin.  In
  444 * addition, "input" pins may or may not process the mic bias option
  445 * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
  446 * accept requests for bias as of chip versions up to March 2006) and/or
  447 * wiring in the computer.
  448 */
  449#define ALC_PIN_DIR_IN              0x00
  450#define ALC_PIN_DIR_OUT             0x01
  451#define ALC_PIN_DIR_INOUT           0x02
  452#define ALC_PIN_DIR_IN_NOMICBIAS    0x03
  453#define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
  454
  455/* Info about the pin modes supported by the different pin direction modes.
  456 * For each direction the minimum and maximum values are given.
  457 */
  458static signed char alc_pin_mode_dir_info[5][2] = {
  459        { 0, 2 },    /* ALC_PIN_DIR_IN */
  460        { 3, 4 },    /* ALC_PIN_DIR_OUT */
  461        { 0, 4 },    /* ALC_PIN_DIR_INOUT */
  462        { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
  463        { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
  464};
  465#define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
  466#define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
  467#define alc_pin_mode_n_items(_dir) \
  468        (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
  469
  470static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
  471                             struct snd_ctl_elem_info *uinfo)
  472{
  473        unsigned int item_num = uinfo->value.enumerated.item;
  474        unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
  475
  476        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
  477        uinfo->count = 1;
  478        uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
  479
  480        if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
  481                item_num = alc_pin_mode_min(dir);
  482        strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
  483        return 0;
  484}
  485
  486static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
  487                            struct snd_ctl_elem_value *ucontrol)
  488{
  489        unsigned int i;
  490        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  491        hda_nid_t nid = kcontrol->private_value & 0xffff;
  492        unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
  493        long *valp = ucontrol->value.integer.value;
  494        unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
  495                                                 AC_VERB_GET_PIN_WIDGET_CONTROL,
  496                                                 0x00);
  497
  498        /* Find enumerated value for current pinctl setting */
  499        i = alc_pin_mode_min(dir);
  500        while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
  501                i++;
  502        *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
  503        return 0;
  504}
  505
  506static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
  507                            struct snd_ctl_elem_value *ucontrol)
  508{
  509        signed int change;
  510        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  511        hda_nid_t nid = kcontrol->private_value & 0xffff;
  512        unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
  513        long val = *ucontrol->value.integer.value;
  514        unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
  515                                                 AC_VERB_GET_PIN_WIDGET_CONTROL,
  516                                                 0x00);
  517
  518        if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
  519                val = alc_pin_mode_min(dir);
  520
  521        change = pinctl != alc_pin_mode_values[val];
  522        if (change) {
  523                /* Set pin mode to that requested */
  524                snd_hda_codec_write_cache(codec, nid, 0,
  525                                          AC_VERB_SET_PIN_WIDGET_CONTROL,
  526                                          alc_pin_mode_values[val]);
  527
  528                /* Also enable the retasking pin's input/output as required
  529                 * for the requested pin mode.  Enum values of 2 or less are
  530                 * input modes.
  531                 *
  532                 * Dynamically switching the input/output buffers probably
  533                 * reduces noise slightly (particularly on input) so we'll
  534                 * do it.  However, having both input and output buffers
  535                 * enabled simultaneously doesn't seem to be problematic if
  536                 * this turns out to be necessary in the future.
  537                 */
  538                if (val <= 2) {
  539                        snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
  540                                                 HDA_AMP_MUTE, HDA_AMP_MUTE);
  541                        snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
  542                                                 HDA_AMP_MUTE, 0);
  543                } else {
  544                        snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
  545                                                 HDA_AMP_MUTE, HDA_AMP_MUTE);
  546                        snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
  547                                                 HDA_AMP_MUTE, 0);
  548                }
  549        }
  550        return change;
  551}
  552
  553#define ALC_PIN_MODE(xname, nid, dir) \
  554        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
  555          .info = alc_pin_mode_info, \
  556          .get = alc_pin_mode_get, \
  557          .put = alc_pin_mode_put, \
  558          .private_value = nid | (dir<<16) }
  559
  560/* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
  561 * together using a mask with more than one bit set.  This control is
  562 * currently used only by the ALC260 test model.  At this stage they are not
  563 * needed for any "production" models.
  564 */
  565#ifdef CONFIG_SND_DEBUG
  566#define alc_gpio_data_info        snd_ctl_boolean_mono_info
  567
  568static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
  569                             struct snd_ctl_elem_value *ucontrol)
  570{
  571        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  572        hda_nid_t nid = kcontrol->private_value & 0xffff;
  573        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
  574        long *valp = ucontrol->value.integer.value;
  575        unsigned int val = snd_hda_codec_read(codec, nid, 0,
  576                                              AC_VERB_GET_GPIO_DATA, 0x00);
  577
  578        *valp = (val & mask) != 0;
  579        return 0;
  580}
  581static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
  582                             struct snd_ctl_elem_value *ucontrol)
  583{
  584        signed int change;
  585        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  586        hda_nid_t nid = kcontrol->private_value & 0xffff;
  587        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
  588        long val = *ucontrol->value.integer.value;
  589        unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
  590                                                    AC_VERB_GET_GPIO_DATA,
  591                                                    0x00);
  592
  593        /* Set/unset the masked GPIO bit(s) as needed */
  594        change = (val == 0 ? 0 : mask) != (gpio_data & mask);
  595        if (val == 0)
  596                gpio_data &= ~mask;
  597        else
  598                gpio_data |= mask;
  599        snd_hda_codec_write_cache(codec, nid, 0,
  600                                  AC_VERB_SET_GPIO_DATA, gpio_data);
  601
  602        return change;
  603}
  604#define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
  605        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
  606          .info = alc_gpio_data_info, \
  607          .get = alc_gpio_data_get, \
  608          .put = alc_gpio_data_put, \
  609          .private_value = nid | (mask<<16) }
  610#endif   /* CONFIG_SND_DEBUG */
  611
  612/* A switch control to allow the enabling of the digital IO pins on the
  613 * ALC260.  This is incredibly simplistic; the intention of this control is
  614 * to provide something in the test model allowing digital outputs to be
  615 * identified if present.  If models are found which can utilise these
  616 * outputs a more complete mixer control can be devised for those models if
  617 * necessary.
  618 */
  619#ifdef CONFIG_SND_DEBUG
  620#define alc_spdif_ctrl_info        snd_ctl_boolean_mono_info
  621
  622static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
  623                              struct snd_ctl_elem_value *ucontrol)
  624{
  625        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  626        hda_nid_t nid = kcontrol->private_value & 0xffff;
  627        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
  628        long *valp = ucontrol->value.integer.value;
  629        unsigned int val = snd_hda_codec_read(codec, nid, 0,
  630                                              AC_VERB_GET_DIGI_CONVERT_1, 0x00);
  631
  632        *valp = (val & mask) != 0;
  633        return 0;
  634}
  635static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
  636                              struct snd_ctl_elem_value *ucontrol)
  637{
  638        signed int change;
  639        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  640        hda_nid_t nid = kcontrol->private_value & 0xffff;
  641        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
  642        long val = *ucontrol->value.integer.value;
  643        unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
  644                                                    AC_VERB_GET_DIGI_CONVERT_1,
  645                                                    0x00);
  646
  647        /* Set/unset the masked control bit(s) as needed */
  648        change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
  649        if (val==0)
  650                ctrl_data &= ~mask;
  651        else
  652                ctrl_data |= mask;
  653        snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
  654                                  ctrl_data);
  655
  656        return change;
  657}
  658#define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
  659        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
  660          .info = alc_spdif_ctrl_info, \
  661          .get = alc_spdif_ctrl_get, \
  662          .put = alc_spdif_ctrl_put, \
  663          .private_value = nid | (mask<<16) }
  664#endif   /* CONFIG_SND_DEBUG */
  665
  666/* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
  667 * Again, this is only used in the ALC26x test models to help identify when
  668 * the EAPD line must be asserted for features to work.
  669 */
  670#ifdef CONFIG_SND_DEBUG
  671#define alc_eapd_ctrl_info        snd_ctl_boolean_mono_info
  672
  673static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
  674                              struct snd_ctl_elem_value *ucontrol)
  675{
  676        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  677        hda_nid_t nid = kcontrol->private_value & 0xffff;
  678        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
  679        long *valp = ucontrol->value.integer.value;
  680        unsigned int val = snd_hda_codec_read(codec, nid, 0,
  681                                              AC_VERB_GET_EAPD_BTLENABLE, 0x00);
  682
  683        *valp = (val & mask) != 0;
  684        return 0;
  685}
  686
  687static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
  688                              struct snd_ctl_elem_value *ucontrol)
  689{
  690        int change;
  691        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
  692        hda_nid_t nid = kcontrol->private_value & 0xffff;
  693        unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
  694        long val = *ucontrol->value.integer.value;
  695        unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
  696                                                    AC_VERB_GET_EAPD_BTLENABLE,
  697                                                    0x00);
  698
  699        /* Set/unset the masked control bit(s) as needed */
  700        change = (!val ? 0 : mask) != (ctrl_data & mask);
  701        if (!val)
  702                ctrl_data &= ~mask;
  703        else
  704                ctrl_data |= mask;
  705        snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
  706                                  ctrl_data);
  707
  708        return change;
  709}
  710
  711#define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
  712        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
  713          .info = alc_eapd_ctrl_info, \
  714          .get = alc_eapd_ctrl_get, \
  715          .put = alc_eapd_ctrl_put, \
  716          .private_value = nid | (mask<<16) }
  717#endif   /* CONFIG_SND_DEBUG */
  718
  719/*
  720 * set up from the preset table
  721 */
  722static void setup_preset(struct alc_spec *spec,
  723                         const struct alc_config_preset *preset)
  724{
  725        int i;
  726
  727        for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
  728                spec->mixers[spec->num_mixers++] = preset->mixers[i];
  729        for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
  730             i++)
  731                spec->init_verbs[spec->num_init_verbs++] =
  732                        preset->init_verbs[i];
  733
  734        spec->channel_mode = preset->channel_mode;
  735        spec->num_channel_mode = preset->num_channel_mode;
  736        spec->need_dac_fix = preset->need_dac_fix;
  737
  738        spec->multiout.max_channels = spec->channel_mode[0].channels;
  739
  740        spec->multiout.num_dacs = preset->num_dacs;
  741        spec->multiout.dac_nids = preset->dac_nids;
  742        spec->multiout.dig_out_nid = preset->dig_out_nid;
  743        spec->multiout.hp_nid = preset->hp_nid;
  744
  745        spec->num_mux_defs = preset->num_mux_defs;
  746        if (!spec->num_mux_defs)
  747                spec->num_mux_defs = 1;
  748        spec->input_mux = preset->input_mux;
  749
  750        spec->num_adc_nids = preset->num_adc_nids;
  751        spec->adc_nids = preset->adc_nids;
  752        spec->capsrc_nids = preset->capsrc_nids;
  753        spec->dig_in_nid = preset->dig_in_nid;
  754
  755        spec->unsol_event = preset->unsol_event;
  756        spec->init_hook = preset->init_hook;
  757#ifdef CONFIG_SND_HDA_POWER_SAVE
  758        spec->loopback.amplist = preset->loopbacks;
  759#endif
  760}
  761
  762/* Enable GPIO mask and set output */
  763static struct hda_verb alc_gpio1_init_verbs[] = {
  764        {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
  765        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
  766        {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
  767        { }
  768};
  769
  770static struct hda_verb alc_gpio2_init_verbs[] = {
  771        {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
  772        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
  773        {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
  774        { }
  775};
  776
  777static struct hda_verb alc_gpio3_init_verbs[] = {
  778        {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
  779        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
  780        {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
  781        { }
  782};
  783
  784/*
  785 * Fix hardware PLL issue
  786 * On some codecs, the analog PLL gating control must be off while
  787 * the default value is 1.
  788 */
  789static void alc_fix_pll(struct hda_codec *codec)
  790{
  791        struct alc_spec *spec = codec->spec;
  792        unsigned int val;
  793
  794        if (!spec->pll_nid)
  795                return;
  796        snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
  797                            spec->pll_coef_idx);
  798        val = snd_hda_codec_read(codec, spec->pll_nid, 0,
  799                                 AC_VERB_GET_PROC_COEF, 0);
  800        snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
  801                            spec->pll_coef_idx);
  802        snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
  803                            val & ~(1 << spec->pll_coef_bit));
  804}
  805
  806static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
  807                             unsigned int coef_idx, unsigned int coef_bit)
  808{
  809        struct alc_spec *spec = codec->spec;
  810        spec->pll_nid = nid;
  811        spec->pll_coef_idx = coef_idx;
  812        spec->pll_coef_bit = coef_bit;
  813        alc_fix_pll(codec);
  814}
  815
  816static void alc_sku_automute(struct hda_codec *codec)
  817{
  818        struct alc_spec *spec = codec->spec;
  819        unsigned int present;
  820        unsigned int hp_nid = spec->autocfg.hp_pins[0];
  821        unsigned int sp_nid = spec->autocfg.speaker_pins[0];
  822
  823        /* need to execute and sync at first */
  824        snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
  825        present = snd_hda_codec_read(codec, hp_nid, 0,
  826                                     AC_VERB_GET_PIN_SENSE, 0);
  827        spec->jack_present = (present & 0x80000000) != 0;
  828        snd_hda_codec_write(codec, sp_nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
  829                            spec->jack_present ? 0 : PIN_OUT);
  830}
  831
  832#if 0 /* it's broken in some acses -- temporarily disabled */
  833static void alc_mic_automute(struct hda_codec *codec)
  834{
  835        struct alc_spec *spec = codec->spec;
  836        unsigned int present;
  837        unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
  838        unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
  839        unsigned int mix_nid = spec->capsrc_nids[0];
  840        unsigned int capsrc_idx_mic, capsrc_idx_fmic;
  841
  842        capsrc_idx_mic = mic_nid - 0x18;
  843        capsrc_idx_fmic = fmic_nid - 0x18;
  844        present = snd_hda_codec_read(codec, mic_nid, 0,
  845                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
  846        snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
  847                    0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
  848        snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
  849                    0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
  850        snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
  851                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
  852}
  853#else
  854#define alc_mic_automute(codec) /* NOP */
  855#endif /* disabled */
  856
  857/* unsolicited event for HP jack sensing */
  858static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
  859{
  860        if (codec->vendor_id == 0x10ec0880)
  861                res >>= 28;
  862        else
  863                res >>= 26;
  864        if (res == ALC880_HP_EVENT)
  865                alc_sku_automute(codec);
  866
  867        if (res == ALC880_MIC_EVENT)
  868                alc_mic_automute(codec);
  869}
  870
  871static void alc_inithook(struct hda_codec *codec)
  872{
  873        alc_sku_automute(codec);
  874        alc_mic_automute(codec);
  875}
  876
  877/* additional initialization for ALC888 variants */
  878static void alc888_coef_init(struct hda_codec *codec)
  879{
  880        unsigned int tmp;
  881
  882        snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
  883        tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
  884        snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
  885        if ((tmp & 0xf0) == 2)
  886                /* alc888S-VC */
  887                snd_hda_codec_read(codec, 0x20, 0,
  888                                   AC_VERB_SET_PROC_COEF, 0x830);
  889         else
  890                 /* alc888-VB */
  891                 snd_hda_codec_read(codec, 0x20, 0,
  892                                    AC_VERB_SET_PROC_COEF, 0x3030);
  893}
  894
  895/* 32-bit subsystem ID for BIOS loading in HD Audio codec.
  896 *        31 ~ 16 :        Manufacture ID
  897 *        15 ~ 8        :        SKU ID
  898 *        7  ~ 0        :        Assembly ID
  899 *        port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
  900 */
  901static void alc_subsystem_id(struct hda_codec *codec,
  902                             unsigned int porta, unsigned int porte,
  903                             unsigned int portd)
  904{
  905        unsigned int ass, tmp, i;
  906        unsigned nid;
  907        struct alc_spec *spec = codec->spec;
  908
  909        ass = codec->subsystem_id & 0xffff;
  910        if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
  911                goto do_sku;
  912
  913        /*
  914         * 31~30        : port conetcivity
  915         * 29~21        : reserve
  916         * 20                : PCBEEP input
  917         * 19~16        : Check sum (15:1)
  918         * 15~1                : Custom
  919         * 0                : override
  920        */
  921        nid = 0x1d;
  922        if (codec->vendor_id == 0x10ec0260)
  923                nid = 0x17;
  924        ass = snd_hda_codec_read(codec, nid, 0,
  925                                 AC_VERB_GET_CONFIG_DEFAULT, 0);
  926        if (!(ass & 1) && !(ass & 0x100000))
  927                return;
  928        if ((ass >> 30) != 1)        /* no physical connection */
  929                return;
  930
  931        /* check sum */
  932        tmp = 0;
  933        for (i = 1; i < 16; i++) {
  934                if ((ass >> i) & 1)
  935                        tmp++;
  936        }
  937        if (((ass >> 16) & 0xf) != tmp)
  938                return;
  939do_sku:
  940        /*
  941         * 0 : override
  942         * 1 :        Swap Jack
  943         * 2 : 0 --> Desktop, 1 --> Laptop
  944         * 3~5 : External Amplifier control
  945         * 7~6 : Reserved
  946        */
  947        tmp = (ass & 0x38) >> 3;        /* external Amp control */
  948        switch (tmp) {
  949        case 1:
  950                snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
  951                break;
  952        case 3:
  953                snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
  954                break;
  955        case 7:
  956                snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
  957                break;
  958        case 5:        /* set EAPD output high */
  959                switch (codec->vendor_id) {
  960                case 0x10ec0260:
  961                        snd_hda_codec_write(codec, 0x0f, 0,
  962                                            AC_VERB_SET_EAPD_BTLENABLE, 2);
  963                        snd_hda_codec_write(codec, 0x10, 0,
  964                                            AC_VERB_SET_EAPD_BTLENABLE, 2);
  965                        break;
  966                case 0x10ec0262:
  967                case 0x10ec0267:
  968                case 0x10ec0268:
  969                case 0x10ec0269:
  970                case 0x10ec0660:
  971                case 0x10ec0662:
  972                case 0x10ec0663:
  973                case 0x10ec0862:
  974                case 0x10ec0889:
  975                        snd_hda_codec_write(codec, 0x14, 0,
  976                                            AC_VERB_SET_EAPD_BTLENABLE, 2);
  977                        snd_hda_codec_write(codec, 0x15, 0,
  978                                            AC_VERB_SET_EAPD_BTLENABLE, 2);
  979                        break;
  980                }
  981                switch (codec->vendor_id) {
  982                case 0x10ec0260:
  983                        snd_hda_codec_write(codec, 0x1a, 0,
  984                                            AC_VERB_SET_COEF_INDEX, 7);
  985                        tmp = snd_hda_codec_read(codec, 0x1a, 0,
  986                                                 AC_VERB_GET_PROC_COEF, 0);
  987                        snd_hda_codec_write(codec, 0x1a, 0,
  988                                            AC_VERB_SET_COEF_INDEX, 7);
  989                        snd_hda_codec_write(codec, 0x1a, 0,
  990                                            AC_VERB_SET_PROC_COEF,
  991                                            tmp | 0x2010);
  992                        break;
  993                case 0x10ec0262:
  994                case 0x10ec0880:
  995                case 0x10ec0882:
  996                case 0x10ec0883:
  997                case 0x10ec0885:
  998                case 0x10ec0889:
  999                        snd_hda_codec_write(codec, 0x20, 0,
 1000                                            AC_VERB_SET_COEF_INDEX, 7);
 1001                        tmp = snd_hda_codec_read(codec, 0x20, 0,
 1002                                                 AC_VERB_GET_PROC_COEF, 0);
 1003                        snd_hda_codec_write(codec, 0x20, 0,
 1004                                            AC_VERB_SET_COEF_INDEX, 7);
 1005                        snd_hda_codec_write(codec, 0x20, 0,
 1006                                            AC_VERB_SET_PROC_COEF,
 1007                                            tmp | 0x2010);
 1008                        break;
 1009                case 0x10ec0888:
 1010                        /*alc888_coef_init(codec);*/ /* called in alc_init() */
 1011                        break;
 1012                case 0x10ec0267:
 1013                case 0x10ec0268:
 1014                        snd_hda_codec_write(codec, 0x20, 0,
 1015                                            AC_VERB_SET_COEF_INDEX, 7);
 1016                        tmp = snd_hda_codec_read(codec, 0x20, 0,
 1017                                                 AC_VERB_GET_PROC_COEF, 0);
 1018                        snd_hda_codec_write(codec, 0x20, 0,
 1019                                            AC_VERB_SET_COEF_INDEX, 7);
 1020                        snd_hda_codec_write(codec, 0x20, 0,
 1021                                            AC_VERB_SET_PROC_COEF,
 1022                                            tmp | 0x3000);
 1023                        break;
 1024                }
 1025        default:
 1026                break;
 1027        }
 1028
 1029        /* is laptop or Desktop and enable the function "Mute internal speaker
 1030         * when the external headphone out jack is plugged"
 1031         */
 1032        if (!(ass & 0x8000))
 1033                return;
 1034        /*
 1035         * 10~8 : Jack location
 1036         * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
 1037         * 14~13: Resvered
 1038         * 15   : 1 --> enable the function "Mute internal speaker
 1039         *                when the external headphone out jack is plugged"
 1040         */
 1041        if (!spec->autocfg.speaker_pins[0]) {
 1042                if (spec->autocfg.line_out_pins[0])
 1043                        spec->autocfg.speaker_pins[0] =
 1044                                spec->autocfg.line_out_pins[0];
 1045                else
 1046                        return;
 1047        }
 1048
 1049        if (!spec->autocfg.hp_pins[0]) {
 1050                tmp = (ass >> 11) & 0x3;        /* HP to chassis */
 1051                if (tmp == 0)
 1052                        spec->autocfg.hp_pins[0] = porta;
 1053                else if (tmp == 1)
 1054                        spec->autocfg.hp_pins[0] = porte;
 1055                else if (tmp == 2)
 1056                        spec->autocfg.hp_pins[0] = portd;
 1057                else
 1058                        return;
 1059        }
 1060        if (spec->autocfg.hp_pins[0])
 1061                snd_hda_codec_write(codec, spec->autocfg.hp_pins[0], 0,
 1062                        AC_VERB_SET_UNSOLICITED_ENABLE,
 1063                        AC_USRSP_EN | ALC880_HP_EVENT);
 1064
 1065#if 0 /* it's broken in some acses -- temporarily disabled */
 1066        if (spec->autocfg.input_pins[AUTO_PIN_MIC] &&
 1067                spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC])
 1068                snd_hda_codec_write(codec,
 1069                        spec->autocfg.input_pins[AUTO_PIN_MIC], 0,
 1070                        AC_VERB_SET_UNSOLICITED_ENABLE,
 1071                        AC_USRSP_EN | ALC880_MIC_EVENT);
 1072#endif /* disabled */
 1073
 1074        spec->unsol_event = alc_sku_unsol_event;
 1075}
 1076
 1077/*
 1078 * Fix-up pin default configurations
 1079 */
 1080
 1081struct alc_pincfg {
 1082        hda_nid_t nid;
 1083        u32 val;
 1084};
 1085
 1086static void alc_fix_pincfg(struct hda_codec *codec,
 1087                           const struct snd_pci_quirk *quirk,
 1088                           const struct alc_pincfg **pinfix)
 1089{
 1090        const struct alc_pincfg *cfg;
 1091
 1092        quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
 1093        if (!quirk)
 1094                return;
 1095
 1096        cfg = pinfix[quirk->value];
 1097        for (; cfg->nid; cfg++) {
 1098                int i;
 1099                u32 val = cfg->val;
 1100                for (i = 0; i < 4; i++) {
 1101                        snd_hda_codec_write(codec, cfg->nid, 0,
 1102                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_0 + i,
 1103                                    val & 0xff);
 1104                        val >>= 8;
 1105                }
 1106        }
 1107}
 1108
 1109/*
 1110 * ALC880 3-stack model
 1111 *
 1112 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
 1113 * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
 1114 *                 F-Mic = 0x1b, HP = 0x19
 1115 */
 1116
 1117static hda_nid_t alc880_dac_nids[4] = {
 1118        /* front, rear, clfe, rear_surr */
 1119        0x02, 0x05, 0x04, 0x03
 1120};
 1121
 1122static hda_nid_t alc880_adc_nids[3] = {
 1123        /* ADC0-2 */
 1124        0x07, 0x08, 0x09,
 1125};
 1126
 1127/* The datasheet says the node 0x07 is connected from inputs,
 1128 * but it shows zero connection in the real implementation on some devices.
 1129 * Note: this is a 915GAV bug, fixed on 915GLV
 1130 */
 1131static hda_nid_t alc880_adc_nids_alt[2] = {
 1132        /* ADC1-2 */
 1133        0x08, 0x09,
 1134};
 1135
 1136#define ALC880_DIGOUT_NID        0x06
 1137#define ALC880_DIGIN_NID        0x0a
 1138
 1139static struct hda_input_mux alc880_capture_source = {
 1140        .num_items = 4,
 1141        .items = {
 1142                { "Mic", 0x0 },
 1143                { "Front Mic", 0x3 },
 1144                { "Line", 0x2 },
 1145                { "CD", 0x4 },
 1146        },
 1147};
 1148
 1149/* channel source setting (2/6 channel selection for 3-stack) */
 1150/* 2ch mode */
 1151static struct hda_verb alc880_threestack_ch2_init[] = {
 1152        /* set line-in to input, mute it */
 1153        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 1154        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 1155        /* set mic-in to input vref 80%, mute it */
 1156        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 1157        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 1158        { } /* end */
 1159};
 1160
 1161/* 6ch mode */
 1162static struct hda_verb alc880_threestack_ch6_init[] = {
 1163        /* set line-in to output, unmute it */
 1164        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 1165        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 1166        /* set mic-in to output, unmute it */
 1167        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 1168        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 1169        { } /* end */
 1170};
 1171
 1172static struct hda_channel_mode alc880_threestack_modes[2] = {
 1173        { 2, alc880_threestack_ch2_init },
 1174        { 6, alc880_threestack_ch6_init },
 1175};
 1176
 1177static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
 1178        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1179        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 1180        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 1181        HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
 1182        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 1183        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 1184        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 1185        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 1186        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 1187        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 1188        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 1189        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 1190        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 1191        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 1192        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
 1193        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
 1194        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 1195        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 1196        HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
 1197        {
 1198                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 1199                .name = "Channel Mode",
 1200                .info = alc_ch_mode_info,
 1201                .get = alc_ch_mode_get,
 1202                .put = alc_ch_mode_put,
 1203        },
 1204        { } /* end */
 1205};
 1206
 1207/* capture mixer elements */
 1208static struct snd_kcontrol_new alc880_capture_mixer[] = {
 1209        HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
 1210        HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
 1211        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
 1212        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
 1213        HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
 1214        HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
 1215        {
 1216                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 1217                /* The multiple "Capture Source" controls confuse alsamixer
 1218                 * So call somewhat different..
 1219                 */
 1220                /* .name = "Capture Source", */
 1221                .name = "Input Source",
 1222                .count = 3,
 1223                .info = alc_mux_enum_info,
 1224                .get = alc_mux_enum_get,
 1225                .put = alc_mux_enum_put,
 1226        },
 1227        { } /* end */
 1228};
 1229
 1230/* capture mixer elements (in case NID 0x07 not available) */
 1231static struct snd_kcontrol_new alc880_capture_alt_mixer[] = {
 1232        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
 1233        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
 1234        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
 1235        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
 1236        {
 1237                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 1238                /* The multiple "Capture Source" controls confuse alsamixer
 1239                 * So call somewhat different..
 1240                 */
 1241                /* .name = "Capture Source", */
 1242                .name = "Input Source",
 1243                .count = 2,
 1244                .info = alc_mux_enum_info,
 1245                .get = alc_mux_enum_get,
 1246                .put = alc_mux_enum_put,
 1247        },
 1248        { } /* end */
 1249};
 1250
 1251
 1252
 1253/*
 1254 * ALC880 5-stack model
 1255 *
 1256 * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
 1257 *      Side = 0x02 (0xd)
 1258 * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
 1259 *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
 1260 */
 1261
 1262/* additional mixers to alc880_three_stack_mixer */
 1263static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
 1264        HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 1265        HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
 1266        { } /* end */
 1267};
 1268
 1269/* channel source setting (6/8 channel selection for 5-stack) */
 1270/* 6ch mode */
 1271static struct hda_verb alc880_fivestack_ch6_init[] = {
 1272        /* set line-in to input, mute it */
 1273        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 1274        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 1275        { } /* end */
 1276};
 1277
 1278/* 8ch mode */
 1279static struct hda_verb alc880_fivestack_ch8_init[] = {
 1280        /* set line-in to output, unmute it */
 1281        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 1282        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 1283        { } /* end */
 1284};
 1285
 1286static struct hda_channel_mode alc880_fivestack_modes[2] = {
 1287        { 6, alc880_fivestack_ch6_init },
 1288        { 8, alc880_fivestack_ch8_init },
 1289};
 1290
 1291
 1292/*
 1293 * ALC880 6-stack model
 1294 *
 1295 * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
 1296 *      Side = 0x05 (0x0f)
 1297 * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
 1298 *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
 1299 */
 1300
 1301static hda_nid_t alc880_6st_dac_nids[4] = {
 1302        /* front, rear, clfe, rear_surr */
 1303        0x02, 0x03, 0x04, 0x05
 1304};
 1305
 1306static struct hda_input_mux alc880_6stack_capture_source = {
 1307        .num_items = 4,
 1308        .items = {
 1309                { "Mic", 0x0 },
 1310                { "Front Mic", 0x1 },
 1311                { "Line", 0x2 },
 1312                { "CD", 0x4 },
 1313        },
 1314};
 1315
 1316/* fixed 8-channels */
 1317static struct hda_channel_mode alc880_sixstack_modes[1] = {
 1318        { 8, NULL },
 1319};
 1320
 1321static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
 1322        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1323        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 1324        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 1325        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 1326        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 1327        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 1328        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 1329        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 1330        HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 1331        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
 1332        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 1333        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 1334        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 1335        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 1336        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 1337        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 1338        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 1339        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 1340        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 1341        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 1342        {
 1343                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 1344                .name = "Channel Mode",
 1345                .info = alc_ch_mode_info,
 1346                .get = alc_ch_mode_get,
 1347                .put = alc_ch_mode_put,
 1348        },
 1349        { } /* end */
 1350};
 1351
 1352
 1353/*
 1354 * ALC880 W810 model
 1355 *
 1356 * W810 has rear IO for:
 1357 * Front (DAC 02)
 1358 * Surround (DAC 03)
 1359 * Center/LFE (DAC 04)
 1360 * Digital out (06)
 1361 *
 1362 * The system also has a pair of internal speakers, and a headphone jack.
 1363 * These are both connected to Line2 on the codec, hence to DAC 02.
 1364 *
 1365 * There is a variable resistor to control the speaker or headphone
 1366 * volume. This is a hardware-only device without a software API.
 1367 *
 1368 * Plugging headphones in will disable the internal speakers. This is
 1369 * implemented in hardware, not via the driver using jack sense. In
 1370 * a similar fashion, plugging into the rear socket marked "front" will
 1371 * disable both the speakers and headphones.
 1372 *
 1373 * For input, there's a microphone jack, and an "audio in" jack.
 1374 * These may not do anything useful with this driver yet, because I
 1375 * haven't setup any initialization verbs for these yet...
 1376 */
 1377
 1378static hda_nid_t alc880_w810_dac_nids[3] = {
 1379        /* front, rear/surround, clfe */
 1380        0x02, 0x03, 0x04
 1381};
 1382
 1383/* fixed 6 channels */
 1384static struct hda_channel_mode alc880_w810_modes[1] = {
 1385        { 6, NULL }
 1386};
 1387
 1388/* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
 1389static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
 1390        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1391        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 1392        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 1393        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 1394        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 1395        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 1396        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 1397        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 1398        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 1399        { } /* end */
 1400};
 1401
 1402
 1403/*
 1404 * Z710V model
 1405 *
 1406 * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
 1407 * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
 1408 *                 Line = 0x1a
 1409 */
 1410
 1411static hda_nid_t alc880_z71v_dac_nids[1] = {
 1412        0x02
 1413};
 1414#define ALC880_Z71V_HP_DAC        0x03
 1415
 1416/* fixed 2 channels */
 1417static struct hda_channel_mode alc880_2_jack_modes[1] = {
 1418        { 2, NULL }
 1419};
 1420
 1421static struct snd_kcontrol_new alc880_z71v_mixer[] = {
 1422        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1423        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 1424        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 1425        HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
 1426        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 1427        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 1428        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 1429        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 1430        { } /* end */
 1431};
 1432
 1433
 1434/*
 1435 * ALC880 F1734 model
 1436 *
 1437 * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
 1438 * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
 1439 */
 1440
 1441static hda_nid_t alc880_f1734_dac_nids[1] = {
 1442        0x03
 1443};
 1444#define ALC880_F1734_HP_DAC        0x02
 1445
 1446static struct snd_kcontrol_new alc880_f1734_mixer[] = {
 1447        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1448        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
 1449        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 1450        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
 1451        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 1452        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 1453        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 1454        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 1455        { } /* end */
 1456};
 1457
 1458static struct hda_input_mux alc880_f1734_capture_source = {
 1459        .num_items = 2,
 1460        .items = {
 1461                { "Mic", 0x1 },
 1462                { "CD", 0x4 },
 1463        },
 1464};
 1465
 1466
 1467/*
 1468 * ALC880 ASUS model
 1469 *
 1470 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
 1471 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
 1472 *  Mic = 0x18, Line = 0x1a
 1473 */
 1474
 1475#define alc880_asus_dac_nids        alc880_w810_dac_nids        /* identical with w810 */
 1476#define alc880_asus_modes        alc880_threestack_modes        /* 2/6 channel mode */
 1477
 1478static struct snd_kcontrol_new alc880_asus_mixer[] = {
 1479        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1480        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 1481        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 1482        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 1483        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 1484        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 1485        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 1486        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 1487        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 1488        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 1489        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 1490        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 1491        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 1492        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 1493        {
 1494                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 1495                .name = "Channel Mode",
 1496                .info = alc_ch_mode_info,
 1497                .get = alc_ch_mode_get,
 1498                .put = alc_ch_mode_put,
 1499        },
 1500        { } /* end */
 1501};
 1502
 1503/*
 1504 * ALC880 ASUS W1V model
 1505 *
 1506 * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
 1507 * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
 1508 *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
 1509 */
 1510
 1511/* additional mixers to alc880_asus_mixer */
 1512static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
 1513        HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
 1514        HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
 1515        { } /* end */
 1516};
 1517
 1518/* additional mixers to alc880_asus_mixer */
 1519static struct snd_kcontrol_new alc880_pcbeep_mixer[] = {
 1520        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 1521        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 1522        { } /* end */
 1523};
 1524
 1525/* TCL S700 */
 1526static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
 1527        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1528        HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 1529        HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
 1530        HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
 1531        HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
 1532        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
 1533        HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
 1534        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
 1535        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
 1536        {
 1537                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 1538                /* The multiple "Capture Source" controls confuse alsamixer
 1539                 * So call somewhat different..
 1540                 */
 1541                /* .name = "Capture Source", */
 1542                .name = "Input Source",
 1543                .count = 1,
 1544                .info = alc_mux_enum_info,
 1545                .get = alc_mux_enum_get,
 1546                .put = alc_mux_enum_put,
 1547        },
 1548        { } /* end */
 1549};
 1550
 1551/* Uniwill */
 1552static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
 1553        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1554        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
 1555        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 1556        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
 1557        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 1558        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 1559        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 1560        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 1561        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 1562        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 1563        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 1564        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 1565        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 1566        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 1567        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 1568        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 1569        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 1570        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 1571        {
 1572                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 1573                .name = "Channel Mode",
 1574                .info = alc_ch_mode_info,
 1575                .get = alc_ch_mode_get,
 1576                .put = alc_ch_mode_put,
 1577        },
 1578        { } /* end */
 1579};
 1580
 1581static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
 1582        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1583        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
 1584        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 1585        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
 1586        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 1587        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 1588        HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 1589        HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 1590        HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 1591        HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 1592        { } /* end */
 1593};
 1594
 1595static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
 1596        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 1597        HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
 1598        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 1599        HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
 1600        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 1601        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 1602        { } /* end */
 1603};
 1604
 1605/*
 1606 * virtual master controls
 1607 */
 1608
 1609/*
 1610 * slave controls for virtual master
 1611 */
 1612static const char *alc_slave_vols[] = {
 1613        "Front Playback Volume",
 1614        "Surround Playback Volume",
 1615        "Center Playback Volume",
 1616        "LFE Playback Volume",
 1617        "Side Playback Volume",
 1618        "Headphone Playback Volume",
 1619        "Speaker Playback Volume",
 1620        "Mono Playback Volume",
 1621        "Line-Out Playback Volume",
 1622        NULL,
 1623};
 1624
 1625static const char *alc_slave_sws[] = {
 1626        "Front Playback Switch",
 1627        "Surround Playback Switch",
 1628        "Center Playback Switch",
 1629        "LFE Playback Switch",
 1630        "Side Playback Switch",
 1631        "Headphone Playback Switch",
 1632        "Speaker Playback Switch",
 1633        "Mono Playback Switch",
 1634        "IEC958 Playback Switch",
 1635        NULL,
 1636};
 1637
 1638/*
 1639 * build control elements
 1640 */
 1641static int alc_build_controls(struct hda_codec *codec)
 1642{
 1643        struct alc_spec *spec = codec->spec;
 1644        int err;
 1645        int i;
 1646
 1647        for (i = 0; i < spec->num_mixers; i++) {
 1648                err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
 1649                if (err < 0)
 1650                        return err;
 1651        }
 1652
 1653        if (spec->multiout.dig_out_nid) {
 1654                err = snd_hda_create_spdif_out_ctls(codec,
 1655                                                    spec->multiout.dig_out_nid);
 1656                if (err < 0)
 1657                        return err;
 1658                err = snd_hda_create_spdif_share_sw(codec,
 1659                                                    &spec->multiout);
 1660                if (err < 0)
 1661                        return err;
 1662                spec->multiout.share_spdif = 1;
 1663        }
 1664        if (spec->dig_in_nid) {
 1665                err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
 1666                if (err < 0)
 1667                        return err;
 1668        }
 1669
 1670        /* if we have no master control, let's create it */
 1671        if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
 1672                unsigned int vmaster_tlv[4];
 1673                snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
 1674                                        HDA_OUTPUT, vmaster_tlv);
 1675                err = snd_hda_add_vmaster(codec, "Master Playback Volume",
 1676                                          vmaster_tlv, alc_slave_vols);
 1677                if (err < 0)
 1678                        return err;
 1679        }
 1680        if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
 1681                err = snd_hda_add_vmaster(codec, "Master Playback Switch",
 1682                                          NULL, alc_slave_sws);
 1683                if (err < 0)
 1684                        return err;
 1685        }
 1686
 1687        return 0;
 1688}
 1689
 1690
 1691/*
 1692 * initialize the codec volumes, etc
 1693 */
 1694
 1695/*
 1696 * generic initialization of ADC, input mixers and output mixers
 1697 */
 1698static struct hda_verb alc880_volume_init_verbs[] = {
 1699        /*
 1700         * Unmute ADC0-2 and set the default input to mic-in
 1701         */
 1702        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 1703        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 1704        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
 1705        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 1706        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 1707        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 1708
 1709        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
 1710         * mixer widget
 1711         * Note: PASD motherboards uses the Line In 2 as the input for front
 1712         * panel mic (mic 2)
 1713         */
 1714        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
 1715        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 1716        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 1717        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 1718        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 1719        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 1720        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
 1721        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
 1722
 1723        /*
 1724         * Set up output mixers (0x0c - 0x0f)
 1725         */
 1726        /* set vol=0 to output mixers */
 1727        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 1728        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 1729        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 1730        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 1731        /* set up input amps for analog loopback */
 1732        /* Amp Indices: DAC = 0, mixer = 1 */
 1733        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 1734        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 1735        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 1736        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 1737        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 1738        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 1739        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 1740        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 1741
 1742        { }
 1743};
 1744
 1745/*
 1746 * 3-stack pin configuration:
 1747 * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
 1748 */
 1749static struct hda_verb alc880_pin_3stack_init_verbs[] = {
 1750        /*
 1751         * preset connection lists of input pins
 1752         * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
 1753         */
 1754        {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
 1755        {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 1756        {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
 1757
 1758        /*
 1759         * Set pin mode and muting
 1760         */
 1761        /* set front pin widgets 0x14 for output */
 1762        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1763        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1764        /* Mic1 (rear panel) pin widget for input and vref at 80% */
 1765        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1766        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1767        /* Mic2 (as headphone out) for HP output */
 1768        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1769        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1770        /* Line In pin widget for input */
 1771        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1772        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1773        /* Line2 (as front mic) pin widget for input and vref at 80% */
 1774        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1775        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1776        /* CD pin widget for input */
 1777        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1778
 1779        { }
 1780};
 1781
 1782/*
 1783 * 5-stack pin configuration:
 1784 * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
 1785 * line-in/side = 0x1a, f-mic = 0x1b
 1786 */
 1787static struct hda_verb alc880_pin_5stack_init_verbs[] = {
 1788        /*
 1789         * preset connection lists of input pins
 1790         * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
 1791         */
 1792        {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 1793        {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
 1794
 1795        /*
 1796         * Set pin mode and muting
 1797         */
 1798        /* set pin widgets 0x14-0x17 for output */
 1799        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1800        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1801        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1802        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1803        /* unmute pins for output (no gain on this amp) */
 1804        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1805        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1806        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1807        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1808
 1809        /* Mic1 (rear panel) pin widget for input and vref at 80% */
 1810        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1811        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1812        /* Mic2 (as headphone out) for HP output */
 1813        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1814        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1815        /* Line In pin widget for input */
 1816        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1817        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1818        /* Line2 (as front mic) pin widget for input and vref at 80% */
 1819        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1820        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1821        /* CD pin widget for input */
 1822        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1823
 1824        { }
 1825};
 1826
 1827/*
 1828 * W810 pin configuration:
 1829 * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
 1830 */
 1831static struct hda_verb alc880_pin_w810_init_verbs[] = {
 1832        /* hphone/speaker input selector: front DAC */
 1833        {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
 1834
 1835        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1836        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1837        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1838        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1839        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1840        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1841
 1842        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1843        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1844
 1845        { }
 1846};
 1847
 1848/*
 1849 * Z71V pin configuration:
 1850 * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
 1851 */
 1852static struct hda_verb alc880_pin_z71v_init_verbs[] = {
 1853        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1854        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1855        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1856        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1857
 1858        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1859        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1860        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1861        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1862
 1863        { }
 1864};
 1865
 1866/*
 1867 * 6-stack pin configuration:
 1868 * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
 1869 * f-mic = 0x19, line = 0x1a, HP = 0x1b
 1870 */
 1871static struct hda_verb alc880_pin_6stack_init_verbs[] = {
 1872        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 1873
 1874        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1875        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1876        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1877        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1878        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1879        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1880        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1881        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1882
 1883        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1884        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1885        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1886        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1887        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1888        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1889        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1890        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1891        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1892
 1893        { }
 1894};
 1895
 1896/*
 1897 * Uniwill pin configuration:
 1898 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
 1899 * line = 0x1a
 1900 */
 1901static struct hda_verb alc880_uniwill_init_verbs[] = {
 1902        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 1903
 1904        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1905        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1906        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1907        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1908        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1909        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1910        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 1911        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1912        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 1913        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 1914        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 1915        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 1916        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 1917        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 1918
 1919        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1920        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1921        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1922        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1923        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1924        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1925        /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
 1926        /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
 1927        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1928
 1929        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
 1930        {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
 1931
 1932        { }
 1933};
 1934
 1935/*
 1936* Uniwill P53
 1937* HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
 1938 */
 1939static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
 1940        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 1941
 1942        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1943        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1944        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1945        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1946        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 1947        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 1948        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 1949        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 1950        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 1951        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 1952        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 1953        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 1954
 1955        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1956        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1957        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 1958        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1959        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 1960        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 1961
 1962        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
 1963        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
 1964
 1965        { }
 1966};
 1967
 1968static struct hda_verb alc880_beep_init_verbs[] = {
 1969        { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
 1970        { }
 1971};
 1972
 1973/* toggle speaker-output according to the hp-jack state */
 1974static void alc880_uniwill_hp_automute(struct hda_codec *codec)
 1975{
 1976         unsigned int present;
 1977        unsigned char bits;
 1978
 1979         present = snd_hda_codec_read(codec, 0x14, 0,
 1980                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 1981        bits = present ? HDA_AMP_MUTE : 0;
 1982        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
 1983                                 HDA_AMP_MUTE, bits);
 1984        snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
 1985                                 HDA_AMP_MUTE, bits);
 1986}
 1987
 1988/* auto-toggle front mic */
 1989static void alc880_uniwill_mic_automute(struct hda_codec *codec)
 1990{
 1991         unsigned int present;
 1992        unsigned char bits;
 1993
 1994        present = snd_hda_codec_read(codec, 0x18, 0,
 1995                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 1996        bits = present ? HDA_AMP_MUTE : 0;
 1997        snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
 1998}
 1999
 2000static void alc880_uniwill_automute(struct hda_codec *codec)
 2001{
 2002        alc880_uniwill_hp_automute(codec);
 2003        alc880_uniwill_mic_automute(codec);
 2004}
 2005
 2006static void alc880_uniwill_unsol_event(struct hda_codec *codec,
 2007                                       unsigned int res)
 2008{
 2009        /* Looks like the unsol event is incompatible with the standard
 2010         * definition.  4bit tag is placed at 28 bit!
 2011         */
 2012        switch (res >> 28) {
 2013        case ALC880_HP_EVENT:
 2014                alc880_uniwill_hp_automute(codec);
 2015                break;
 2016        case ALC880_MIC_EVENT:
 2017                alc880_uniwill_mic_automute(codec);
 2018                break;
 2019        }
 2020}
 2021
 2022static void alc880_uniwill_p53_hp_automute(struct hda_codec *codec)
 2023{
 2024         unsigned int present;
 2025        unsigned char bits;
 2026
 2027         present = snd_hda_codec_read(codec, 0x14, 0,
 2028                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 2029        bits = present ? HDA_AMP_MUTE : 0;
 2030        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0, HDA_AMP_MUTE, bits);
 2031}
 2032
 2033static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
 2034{
 2035        unsigned int present;
 2036
 2037        present = snd_hda_codec_read(codec, 0x21, 0,
 2038                                     AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
 2039        present &= HDA_AMP_VOLMASK;
 2040        snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
 2041                                 HDA_AMP_VOLMASK, present);
 2042        snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
 2043                                 HDA_AMP_VOLMASK, present);
 2044}
 2045
 2046static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
 2047                                           unsigned int res)
 2048{
 2049        /* Looks like the unsol event is incompatible with the standard
 2050         * definition.  4bit tag is placed at 28 bit!
 2051         */
 2052        if ((res >> 28) == ALC880_HP_EVENT)
 2053                alc880_uniwill_p53_hp_automute(codec);
 2054        if ((res >> 28) == ALC880_DCVOL_EVENT)
 2055                alc880_uniwill_p53_dcvol_automute(codec);
 2056}
 2057
 2058/*
 2059 * F1734 pin configuration:
 2060 * HP = 0x14, speaker-out = 0x15, mic = 0x18
 2061 */
 2062static struct hda_verb alc880_pin_f1734_init_verbs[] = {
 2063        {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
 2064        {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
 2065        {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
 2066        {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
 2067        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
 2068
 2069        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2070        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2071        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2072        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2073
 2074        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2075        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 2076        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
 2077        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 2078        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2079        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2080        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2081        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2082        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 2083
 2084        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
 2085        {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
 2086
 2087        { }
 2088};
 2089
 2090/*
 2091 * ASUS pin configuration:
 2092 * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
 2093 */
 2094static struct hda_verb alc880_pin_asus_init_verbs[] = {
 2095        {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
 2096        {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
 2097        {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
 2098        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
 2099
 2100        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2101        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2102        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2103        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2104        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2105        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2106        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2107        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2108
 2109        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2110        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 2111        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2112        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 2113        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 2114        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 2115        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2116        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2117        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 2118
 2119        { }
 2120};
 2121
 2122/* Enable GPIO mask and set output */
 2123#define alc880_gpio1_init_verbs        alc_gpio1_init_verbs
 2124#define alc880_gpio2_init_verbs        alc_gpio2_init_verbs
 2125
 2126/* Clevo m520g init */
 2127static struct hda_verb alc880_pin_clevo_init_verbs[] = {
 2128        /* headphone output */
 2129        {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
 2130        /* line-out */
 2131        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2132        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2133        /* Line-in */
 2134        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 2135        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2136        /* CD */
 2137        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 2138        {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2139        /* Mic1 (rear panel) */
 2140        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2141        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2142        /* Mic2 (front panel) */
 2143        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2144        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2145        /* headphone */
 2146        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2147        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2148        /* change to EAPD mode */
 2149        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 2150        {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
 2151
 2152        { }
 2153};
 2154
 2155static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
 2156        /* change to EAPD mode */
 2157        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 2158        {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
 2159
 2160        /* Headphone output */
 2161        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2162        /* Front output*/
 2163        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2164        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
 2165
 2166        /* Line In pin widget for input */
 2167        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 2168        /* CD pin widget for input */
 2169        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 2170        /* Mic1 (rear panel) pin widget for input and vref at 80% */
 2171        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2172
 2173        /* change to EAPD mode */
 2174        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 2175        {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
 2176
 2177        { }
 2178};
 2179
 2180/*
 2181 * LG m1 express dual
 2182 *
 2183 * Pin assignment:
 2184 *   Rear Line-In/Out (blue): 0x14
 2185 *   Build-in Mic-In: 0x15
 2186 *   Speaker-out: 0x17
 2187 *   HP-Out (green): 0x1b
 2188 *   Mic-In/Out (red): 0x19
 2189 *   SPDIF-Out: 0x1e
 2190 */
 2191
 2192/* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
 2193static hda_nid_t alc880_lg_dac_nids[3] = {
 2194        0x05, 0x02, 0x03
 2195};
 2196
 2197/* seems analog CD is not working */
 2198static struct hda_input_mux alc880_lg_capture_source = {
 2199        .num_items = 3,
 2200        .items = {
 2201                { "Mic", 0x1 },
 2202                { "Line", 0x5 },
 2203                { "Internal Mic", 0x6 },
 2204        },
 2205};
 2206
 2207/* 2,4,6 channel modes */
 2208static struct hda_verb alc880_lg_ch2_init[] = {
 2209        /* set line-in and mic-in to input */
 2210        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 2211        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 2212        { }
 2213};
 2214
 2215static struct hda_verb alc880_lg_ch4_init[] = {
 2216        /* set line-in to out and mic-in to input */
 2217        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
 2218        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 2219        { }
 2220};
 2221
 2222static struct hda_verb alc880_lg_ch6_init[] = {
 2223        /* set line-in and mic-in to output */
 2224        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
 2225        { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
 2226        { }
 2227};
 2228
 2229static struct hda_channel_mode alc880_lg_ch_modes[3] = {
 2230        { 2, alc880_lg_ch2_init },
 2231        { 4, alc880_lg_ch4_init },
 2232        { 6, alc880_lg_ch6_init },
 2233};
 2234
 2235static struct snd_kcontrol_new alc880_lg_mixer[] = {
 2236        HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 2237        HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
 2238        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 2239        HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
 2240        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
 2241        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
 2242        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
 2243        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
 2244        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 2245        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 2246        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
 2247        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
 2248        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
 2249        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
 2250        {
 2251                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 2252                .name = "Channel Mode",
 2253                .info = alc_ch_mode_info,
 2254                .get = alc_ch_mode_get,
 2255                .put = alc_ch_mode_put,
 2256        },
 2257        { } /* end */
 2258};
 2259
 2260static struct hda_verb alc880_lg_init_verbs[] = {
 2261        /* set capture source to mic-in */
 2262        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 2263        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 2264        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 2265        /* mute all amp mixer inputs */
 2266        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
 2267        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
 2268        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
 2269        /* line-in to input */
 2270        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 2271        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2272        /* built-in mic */
 2273        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2274        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2275        /* speaker-out */
 2276        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2277        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2278        /* mic-in to input */
 2279        {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
 2280        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2281        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2282        /* HP-out */
 2283        {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
 2284        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2285        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2286        /* jack sense */
 2287        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
 2288        { }
 2289};
 2290
 2291/* toggle speaker-output according to the hp-jack state */
 2292static void alc880_lg_automute(struct hda_codec *codec)
 2293{
 2294        unsigned int present;
 2295        unsigned char bits;
 2296
 2297        present = snd_hda_codec_read(codec, 0x1b, 0,
 2298                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 2299        bits = present ? HDA_AMP_MUTE : 0;
 2300        snd_hda_codec_amp_stereo(codec, 0x17, HDA_OUTPUT, 0,
 2301                                 HDA_AMP_MUTE, bits);
 2302}
 2303
 2304static void alc880_lg_unsol_event(struct hda_codec *codec, unsigned int res)
 2305{
 2306        /* Looks like the unsol event is incompatible with the standard
 2307         * definition.  4bit tag is placed at 28 bit!
 2308         */
 2309        if ((res >> 28) == 0x01)
 2310                alc880_lg_automute(codec);
 2311}
 2312
 2313/*
 2314 * LG LW20
 2315 *
 2316 * Pin assignment:
 2317 *   Speaker-out: 0x14
 2318 *   Mic-In: 0x18
 2319 *   Built-in Mic-In: 0x19
 2320 *   Line-In: 0x1b
 2321 *   HP-Out: 0x1a
 2322 *   SPDIF-Out: 0x1e
 2323 */
 2324
 2325static struct hda_input_mux alc880_lg_lw_capture_source = {
 2326        .num_items = 3,
 2327        .items = {
 2328                { "Mic", 0x0 },
 2329                { "Internal Mic", 0x1 },
 2330                { "Line In", 0x2 },
 2331        },
 2332};
 2333
 2334#define alc880_lg_lw_modes alc880_threestack_modes
 2335
 2336static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
 2337        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 2338        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 2339        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 2340        HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
 2341        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 2342        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 2343        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 2344        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 2345        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 2346        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 2347        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 2348        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 2349        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
 2350        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
 2351        {
 2352                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 2353                .name = "Channel Mode",
 2354                .info = alc_ch_mode_info,
 2355                .get = alc_ch_mode_get,
 2356                .put = alc_ch_mode_put,
 2357        },
 2358        { } /* end */
 2359};
 2360
 2361static struct hda_verb alc880_lg_lw_init_verbs[] = {
 2362        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 2363        {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
 2364        {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
 2365
 2366        /* set capture source to mic-in */
 2367        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 2368        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 2369        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 2370        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
 2371        /* speaker-out */
 2372        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2373        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2374        /* HP-out */
 2375        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2376        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2377        /* mic-in to input */
 2378        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2379        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2380        /* built-in mic */
 2381        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2382        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2383        /* jack sense */
 2384        {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | 0x1},
 2385        { }
 2386};
 2387
 2388/* toggle speaker-output according to the hp-jack state */
 2389static void alc880_lg_lw_automute(struct hda_codec *codec)
 2390{
 2391        unsigned int present;
 2392        unsigned char bits;
 2393
 2394        present = snd_hda_codec_read(codec, 0x1b, 0,
 2395                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 2396        bits = present ? HDA_AMP_MUTE : 0;
 2397        snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
 2398                                 HDA_AMP_MUTE, bits);
 2399}
 2400
 2401static void alc880_lg_lw_unsol_event(struct hda_codec *codec, unsigned int res)
 2402{
 2403        /* Looks like the unsol event is incompatible with the standard
 2404         * definition.  4bit tag is placed at 28 bit!
 2405         */
 2406        if ((res >> 28) == 0x01)
 2407                alc880_lg_lw_automute(codec);
 2408}
 2409
 2410static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
 2411        HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 2412        HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
 2413        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 2414        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 2415        HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 2416        HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
 2417        { } /* end */
 2418};
 2419
 2420static struct hda_input_mux alc880_medion_rim_capture_source = {
 2421        .num_items = 2,
 2422        .items = {
 2423                { "Mic", 0x0 },
 2424                { "Internal Mic", 0x1 },
 2425        },
 2426};
 2427
 2428static struct hda_verb alc880_medion_rim_init_verbs[] = {
 2429        {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 2430
 2431        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2432        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2433
 2434        /* Mic1 (rear panel) pin widget for input and vref at 80% */
 2435        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 2436        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 2437        /* Mic2 (as headphone out) for HP output */
 2438        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 2439        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 2440        /* Internal Speaker */
 2441        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 2442        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 2443
 2444        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 2445        {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
 2446
 2447        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
 2448        { }
 2449};
 2450
 2451/* toggle speaker-output according to the hp-jack state */
 2452static void alc880_medion_rim_automute(struct hda_codec *codec)
 2453{
 2454        unsigned int present;
 2455        unsigned char bits;
 2456
 2457        present = snd_hda_codec_read(codec, 0x14, 0,
 2458                                     AC_VERB_GET_PIN_SENSE, 0)
 2459                & AC_PINSENSE_PRESENCE;
 2460        bits = present ? HDA_AMP_MUTE : 0;
 2461        snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
 2462                                 HDA_AMP_MUTE, bits);
 2463        if (present)
 2464                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
 2465        else
 2466                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
 2467}
 2468
 2469static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
 2470                                          unsigned int res)
 2471{
 2472        /* Looks like the unsol event is incompatible with the standard
 2473         * definition.  4bit tag is placed at 28 bit!
 2474         */
 2475        if ((res >> 28) == ALC880_HP_EVENT)
 2476                alc880_medion_rim_automute(codec);
 2477}
 2478
 2479#ifdef CONFIG_SND_HDA_POWER_SAVE
 2480static struct hda_amp_list alc880_loopbacks[] = {
 2481        { 0x0b, HDA_INPUT, 0 },
 2482        { 0x0b, HDA_INPUT, 1 },
 2483        { 0x0b, HDA_INPUT, 2 },
 2484        { 0x0b, HDA_INPUT, 3 },
 2485        { 0x0b, HDA_INPUT, 4 },
 2486        { } /* end */
 2487};
 2488
 2489static struct hda_amp_list alc880_lg_loopbacks[] = {
 2490        { 0x0b, HDA_INPUT, 1 },
 2491        { 0x0b, HDA_INPUT, 6 },
 2492        { 0x0b, HDA_INPUT, 7 },
 2493        { } /* end */
 2494};
 2495#endif
 2496
 2497/*
 2498 * Common callbacks
 2499 */
 2500
 2501static int alc_init(struct hda_codec *codec)
 2502{
 2503        struct alc_spec *spec = codec->spec;
 2504        unsigned int i;
 2505
 2506        alc_fix_pll(codec);
 2507        if (codec->vendor_id == 0x10ec0888)
 2508                alc888_coef_init(codec);
 2509
 2510        for (i = 0; i < spec->num_init_verbs; i++)
 2511                snd_hda_sequence_write(codec, spec->init_verbs[i]);
 2512
 2513        if (spec->init_hook)
 2514                spec->init_hook(codec);
 2515
 2516        return 0;
 2517}
 2518
 2519static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
 2520{
 2521        struct alc_spec *spec = codec->spec;
 2522
 2523        if (spec->unsol_event)
 2524                spec->unsol_event(codec, res);
 2525}
 2526
 2527#ifdef CONFIG_SND_HDA_POWER_SAVE
 2528static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
 2529{
 2530        struct alc_spec *spec = codec->spec;
 2531        return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
 2532}
 2533#endif
 2534
 2535/*
 2536 * Analog playback callbacks
 2537 */
 2538static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
 2539                                    struct hda_codec *codec,
 2540                                    struct snd_pcm_substream *substream)
 2541{
 2542        struct alc_spec *spec = codec->spec;
 2543        return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
 2544                                             hinfo);
 2545}
 2546
 2547static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 2548                                       struct hda_codec *codec,
 2549                                       unsigned int stream_tag,
 2550                                       unsigned int format,
 2551                                       struct snd_pcm_substream *substream)
 2552{
 2553        struct alc_spec *spec = codec->spec;
 2554        return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
 2555                                                stream_tag, format, substream);
 2556}
 2557
 2558static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 2559                                       struct hda_codec *codec,
 2560                                       struct snd_pcm_substream *substream)
 2561{
 2562        struct alc_spec *spec = codec->spec;
 2563        return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
 2564}
 2565
 2566/*
 2567 * Digital out
 2568 */
 2569static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
 2570                                        struct hda_codec *codec,
 2571                                        struct snd_pcm_substream *substream)
 2572{
 2573        struct alc_spec *spec = codec->spec;
 2574        return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 2575}
 2576
 2577static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 2578                                           struct hda_codec *codec,
 2579                                           unsigned int stream_tag,
 2580                                           unsigned int format,
 2581                                           struct snd_pcm_substream *substream)
 2582{
 2583        struct alc_spec *spec = codec->spec;
 2584        return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
 2585                                             stream_tag, format, substream);
 2586}
 2587
 2588static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
 2589                                         struct hda_codec *codec,
 2590                                         struct snd_pcm_substream *substream)
 2591{
 2592        struct alc_spec *spec = codec->spec;
 2593        return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 2594}
 2595
 2596/*
 2597 * Analog capture
 2598 */
 2599static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
 2600                                      struct hda_codec *codec,
 2601                                      unsigned int stream_tag,
 2602                                      unsigned int format,
 2603                                      struct snd_pcm_substream *substream)
 2604{
 2605        struct alc_spec *spec = codec->spec;
 2606
 2607        snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
 2608                                   stream_tag, 0, format);
 2609        return 0;
 2610}
 2611
 2612static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 2613                                      struct hda_codec *codec,
 2614                                      struct snd_pcm_substream *substream)
 2615{
 2616        struct alc_spec *spec = codec->spec;
 2617
 2618        snd_hda_codec_cleanup_stream(codec,
 2619                                     spec->adc_nids[substream->number + 1]);
 2620        return 0;
 2621}
 2622
 2623
 2624/*
 2625 */
 2626static struct hda_pcm_stream alc880_pcm_analog_playback = {
 2627        .substreams = 1,
 2628        .channels_min = 2,
 2629        .channels_max = 8,
 2630        /* NID is set in alc_build_pcms */
 2631        .ops = {
 2632                .open = alc880_playback_pcm_open,
 2633                .prepare = alc880_playback_pcm_prepare,
 2634                .cleanup = alc880_playback_pcm_cleanup
 2635        },
 2636};
 2637
 2638static struct hda_pcm_stream alc880_pcm_analog_capture = {
 2639        .substreams = 1,
 2640        .channels_min = 2,
 2641        .channels_max = 2,
 2642        /* NID is set in alc_build_pcms */
 2643};
 2644
 2645static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
 2646        .substreams = 1,
 2647        .channels_min = 2,
 2648        .channels_max = 2,
 2649        /* NID is set in alc_build_pcms */
 2650};
 2651
 2652static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
 2653        .substreams = 2, /* can be overridden */
 2654        .channels_min = 2,
 2655        .channels_max = 2,
 2656        /* NID is set in alc_build_pcms */
 2657        .ops = {
 2658                .prepare = alc880_alt_capture_pcm_prepare,
 2659                .cleanup = alc880_alt_capture_pcm_cleanup
 2660        },
 2661};
 2662
 2663static struct hda_pcm_stream alc880_pcm_digital_playback = {
 2664        .substreams = 1,
 2665        .channels_min = 2,
 2666        .channels_max = 2,
 2667        /* NID is set in alc_build_pcms */
 2668        .ops = {
 2669                .open = alc880_dig_playback_pcm_open,
 2670                .close = alc880_dig_playback_pcm_close,
 2671                .prepare = alc880_dig_playback_pcm_prepare
 2672        },
 2673};
 2674
 2675static struct hda_pcm_stream alc880_pcm_digital_capture = {
 2676        .substreams = 1,
 2677        .channels_min = 2,
 2678        .channels_max = 2,
 2679        /* NID is set in alc_build_pcms */
 2680};
 2681
 2682/* Used by alc_build_pcms to flag that a PCM has no playback stream */
 2683static struct hda_pcm_stream alc_pcm_null_stream = {
 2684        .substreams = 0,
 2685        .channels_min = 0,
 2686        .channels_max = 0,
 2687};
 2688
 2689static int alc_build_pcms(struct hda_codec *codec)
 2690{
 2691        struct alc_spec *spec = codec->spec;
 2692        struct hda_pcm *info = spec->pcm_rec;
 2693        int i;
 2694
 2695        codec->num_pcms = 1;
 2696        codec->pcm_info = info;
 2697
 2698        info->name = spec->stream_name_analog;
 2699        if (spec->stream_analog_playback) {
 2700                if (snd_BUG_ON(!spec->multiout.dac_nids))
 2701                        return -EINVAL;
 2702                info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
 2703                info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
 2704        }
 2705        if (spec->stream_analog_capture) {
 2706                if (snd_BUG_ON(!spec->adc_nids))
 2707                        return -EINVAL;
 2708                info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
 2709                info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
 2710        }
 2711
 2712        if (spec->channel_mode) {
 2713                info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
 2714                for (i = 0; i < spec->num_channel_mode; i++) {
 2715                        if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
 2716                                info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
 2717                        }
 2718                }
 2719        }
 2720
 2721        /* SPDIF for stream index #1 */
 2722        if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
 2723                codec->num_pcms = 2;
 2724                info = spec->pcm_rec + 1;
 2725                info->name = spec->stream_name_digital;
 2726                info->pcm_type = HDA_PCM_TYPE_SPDIF;
 2727                if (spec->multiout.dig_out_nid &&
 2728                    spec->stream_digital_playback) {
 2729                        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
 2730                        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
 2731                }
 2732                if (spec->dig_in_nid &&
 2733                    spec->stream_digital_capture) {
 2734                        info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
 2735                        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
 2736                }
 2737                /* FIXME: do we need this for all Realtek codec models? */
 2738                codec->spdif_status_reset = 1;
 2739        }
 2740
 2741        /* If the use of more than one ADC is requested for the current
 2742         * model, configure a second analog capture-only PCM.
 2743         */
 2744        /* Additional Analaog capture for index #2 */
 2745        if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
 2746            (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
 2747                codec->num_pcms = 3;
 2748                info = spec->pcm_rec + 2;
 2749                info->name = spec->stream_name_analog;
 2750                if (spec->alt_dac_nid) {
 2751                        info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
 2752                                *spec->stream_analog_alt_playback;
 2753                        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
 2754                                spec->alt_dac_nid;
 2755                } else {
 2756                        info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
 2757                                alc_pcm_null_stream;
 2758                        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
 2759                }
 2760                if (spec->num_adc_nids > 1) {
 2761                        info->stream[SNDRV_PCM_STREAM_CAPTURE] =
 2762                                *spec->stream_analog_alt_capture;
 2763                        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
 2764                                spec->adc_nids[1];
 2765                        info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
 2766                                spec->num_adc_nids - 1;
 2767                } else {
 2768                        info->stream[SNDRV_PCM_STREAM_CAPTURE] =
 2769                                alc_pcm_null_stream;
 2770                        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
 2771                }
 2772        }
 2773
 2774        return 0;
 2775}
 2776
 2777static void alc_free(struct hda_codec *codec)
 2778{
 2779        struct alc_spec *spec = codec->spec;
 2780        unsigned int i;
 2781
 2782        if (!spec)
 2783                return;
 2784
 2785        if (spec->kctl_alloc) {
 2786                for (i = 0; i < spec->num_kctl_used; i++)
 2787                        kfree(spec->kctl_alloc[i].name);
 2788                kfree(spec->kctl_alloc);
 2789        }
 2790        kfree(spec);
 2791        codec->spec = NULL; /* to be sure */
 2792}
 2793
 2794#ifdef SND_HDA_NEEDS_RESUME
 2795static void store_pin_configs(struct hda_codec *codec)
 2796{
 2797        struct alc_spec *spec = codec->spec;
 2798        hda_nid_t nid, end_nid;
 2799
 2800        end_nid = codec->start_nid + codec->num_nodes;
 2801        for (nid = codec->start_nid; nid < end_nid; nid++) {
 2802                unsigned int wid_caps = get_wcaps(codec, nid);
 2803                unsigned int wid_type =
 2804                        (wid_caps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 2805                if (wid_type != AC_WID_PIN)
 2806                        continue;
 2807                if (spec->num_pins >= ARRAY_SIZE(spec->pin_nids))
 2808                        break;
 2809                spec->pin_nids[spec->num_pins] = nid;
 2810                spec->pin_cfgs[spec->num_pins] =
 2811                        snd_hda_codec_read(codec, nid, 0,
 2812                                           AC_VERB_GET_CONFIG_DEFAULT, 0);
 2813                spec->num_pins++;
 2814        }
 2815}
 2816
 2817static void resume_pin_configs(struct hda_codec *codec)
 2818{
 2819        struct alc_spec *spec = codec->spec;
 2820        int i;
 2821
 2822        for (i = 0; i < spec->num_pins; i++) {
 2823                hda_nid_t pin_nid = spec->pin_nids[i];
 2824                unsigned int pin_config = spec->pin_cfgs[i];
 2825                snd_hda_codec_write(codec, pin_nid, 0,
 2826                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
 2827                                    pin_config & 0x000000ff);
 2828                snd_hda_codec_write(codec, pin_nid, 0,
 2829                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
 2830                                    (pin_config & 0x0000ff00) >> 8);
 2831                snd_hda_codec_write(codec, pin_nid, 0,
 2832                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
 2833                                    (pin_config & 0x00ff0000) >> 16);
 2834                snd_hda_codec_write(codec, pin_nid, 0,
 2835                                    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
 2836                                    pin_config >> 24);
 2837        }
 2838}
 2839
 2840static int alc_resume(struct hda_codec *codec)
 2841{
 2842        resume_pin_configs(codec);
 2843        codec->patch_ops.init(codec);
 2844        snd_hda_codec_resume_amp(codec);
 2845        snd_hda_codec_resume_cache(codec);
 2846        return 0;
 2847}
 2848#else
 2849#define store_pin_configs(codec)
 2850#endif
 2851
 2852/*
 2853 */
 2854static struct hda_codec_ops alc_patch_ops = {
 2855        .build_controls = alc_build_controls,
 2856        .build_pcms = alc_build_pcms,
 2857        .init = alc_init,
 2858        .free = alc_free,
 2859        .unsol_event = alc_unsol_event,
 2860#ifdef SND_HDA_NEEDS_RESUME
 2861        .resume = alc_resume,
 2862#endif
 2863#ifdef CONFIG_SND_HDA_POWER_SAVE
 2864        .check_power_status = alc_check_power_status,
 2865#endif
 2866};
 2867
 2868
 2869/*
 2870 * Test configuration for debugging
 2871 *
 2872 * Almost all inputs/outputs are enabled.  I/O pins can be configured via
 2873 * enum controls.
 2874 */
 2875#ifdef CONFIG_SND_DEBUG
 2876static hda_nid_t alc880_test_dac_nids[4] = {
 2877        0x02, 0x03, 0x04, 0x05
 2878};
 2879
 2880static struct hda_input_mux alc880_test_capture_source = {
 2881        .num_items = 7,
 2882        .items = {
 2883                { "In-1", 0x0 },
 2884                { "In-2", 0x1 },
 2885                { "In-3", 0x2 },
 2886                { "In-4", 0x3 },
 2887                { "CD", 0x4 },
 2888                { "Front", 0x5 },
 2889                { "Surround", 0x6 },
 2890        },
 2891};
 2892
 2893static struct hda_channel_mode alc880_test_modes[4] = {
 2894        { 2, NULL },
 2895        { 4, NULL },
 2896        { 6, NULL },
 2897        { 8, NULL },
 2898};
 2899
 2900static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
 2901                                 struct snd_ctl_elem_info *uinfo)
 2902{
 2903        static char *texts[] = {
 2904                "N/A", "Line Out", "HP Out",
 2905                "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
 2906        };
 2907        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 2908        uinfo->count = 1;
 2909        uinfo->value.enumerated.items = 8;
 2910        if (uinfo->value.enumerated.item >= 8)
 2911                uinfo->value.enumerated.item = 7;
 2912        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 2913        return 0;
 2914}
 2915
 2916static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
 2917                                struct snd_ctl_elem_value *ucontrol)
 2918{
 2919        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 2920        hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
 2921        unsigned int pin_ctl, item = 0;
 2922
 2923        pin_ctl = snd_hda_codec_read(codec, nid, 0,
 2924                                     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 2925        if (pin_ctl & AC_PINCTL_OUT_EN) {
 2926                if (pin_ctl & AC_PINCTL_HP_EN)
 2927                        item = 2;
 2928                else
 2929                        item = 1;
 2930        } else if (pin_ctl & AC_PINCTL_IN_EN) {
 2931                switch (pin_ctl & AC_PINCTL_VREFEN) {
 2932                case AC_PINCTL_VREF_HIZ: item = 3; break;
 2933                case AC_PINCTL_VREF_50:  item = 4; break;
 2934                case AC_PINCTL_VREF_GRD: item = 5; break;
 2935                case AC_PINCTL_VREF_80:  item = 6; break;
 2936                case AC_PINCTL_VREF_100: item = 7; break;
 2937                }
 2938        }
 2939        ucontrol->value.enumerated.item[0] = item;
 2940        return 0;
 2941}
 2942
 2943static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
 2944                                struct snd_ctl_elem_value *ucontrol)
 2945{
 2946        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 2947        hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
 2948        static unsigned int ctls[] = {
 2949                0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
 2950                AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
 2951                AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
 2952                AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
 2953                AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
 2954                AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
 2955        };
 2956        unsigned int old_ctl, new_ctl;
 2957
 2958        old_ctl = snd_hda_codec_read(codec, nid, 0,
 2959                                     AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 2960        new_ctl = ctls[ucontrol->value.enumerated.item[0]];
 2961        if (old_ctl != new_ctl) {
 2962                int val;
 2963                snd_hda_codec_write_cache(codec, nid, 0,
 2964                                          AC_VERB_SET_PIN_WIDGET_CONTROL,
 2965                                          new_ctl);
 2966                val = ucontrol->value.enumerated.item[0] >= 3 ?
 2967                        HDA_AMP_MUTE : 0;
 2968                snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 2969                                         HDA_AMP_MUTE, val);
 2970                return 1;
 2971        }
 2972        return 0;
 2973}
 2974
 2975static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
 2976                                 struct snd_ctl_elem_info *uinfo)
 2977{
 2978        static char *texts[] = {
 2979                "Front", "Surround", "CLFE", "Side"
 2980        };
 2981        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 2982        uinfo->count = 1;
 2983        uinfo->value.enumerated.items = 4;
 2984        if (uinfo->value.enumerated.item >= 4)
 2985                uinfo->value.enumerated.item = 3;
 2986        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
 2987        return 0;
 2988}
 2989
 2990static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
 2991                                struct snd_ctl_elem_value *ucontrol)
 2992{
 2993        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 2994        hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
 2995        unsigned int sel;
 2996
 2997        sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
 2998        ucontrol->value.enumerated.item[0] = sel & 3;
 2999        return 0;
 3000}
 3001
 3002static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
 3003                                struct snd_ctl_elem_value *ucontrol)
 3004{
 3005        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 3006        hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
 3007        unsigned int sel;
 3008
 3009        sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
 3010        if (ucontrol->value.enumerated.item[0] != sel) {
 3011                sel = ucontrol->value.enumerated.item[0] & 3;
 3012                snd_hda_codec_write_cache(codec, nid, 0,
 3013                                          AC_VERB_SET_CONNECT_SEL, sel);
 3014                return 1;
 3015        }
 3016        return 0;
 3017}
 3018
 3019#define PIN_CTL_TEST(xname,nid) {                        \
 3020                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,        \
 3021                        .name = xname,                       \
 3022                        .info = alc_test_pin_ctl_info, \
 3023                        .get = alc_test_pin_ctl_get,   \
 3024                        .put = alc_test_pin_ctl_put,   \
 3025                        .private_value = nid               \
 3026                        }
 3027
 3028#define PIN_SRC_TEST(xname,nid) {                        \
 3029                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,        \
 3030                        .name = xname,                       \
 3031                        .info = alc_test_pin_src_info, \
 3032                        .get = alc_test_pin_src_get,   \
 3033                        .put = alc_test_pin_src_put,   \
 3034                        .private_value = nid               \
 3035                        }
 3036
 3037static struct snd_kcontrol_new alc880_test_mixer[] = {
 3038        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 3039        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 3040        HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
 3041        HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 3042        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 3043        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 3044        HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
 3045        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
 3046        PIN_CTL_TEST("Front Pin Mode", 0x14),
 3047        PIN_CTL_TEST("Surround Pin Mode", 0x15),
 3048        PIN_CTL_TEST("CLFE Pin Mode", 0x16),
 3049        PIN_CTL_TEST("Side Pin Mode", 0x17),
 3050        PIN_CTL_TEST("In-1 Pin Mode", 0x18),
 3051        PIN_CTL_TEST("In-2 Pin Mode", 0x19),
 3052        PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
 3053        PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
 3054        PIN_SRC_TEST("In-1 Pin Source", 0x18),
 3055        PIN_SRC_TEST("In-2 Pin Source", 0x19),
 3056        PIN_SRC_TEST("In-3 Pin Source", 0x1a),
 3057        PIN_SRC_TEST("In-4 Pin Source", 0x1b),
 3058        HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
 3059        HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
 3060        HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
 3061        HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
 3062        HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
 3063        HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
 3064        HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
 3065        HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
 3066        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
 3067        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
 3068        {
 3069                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 3070                .name = "Channel Mode",
 3071                .info = alc_ch_mode_info,
 3072                .get = alc_ch_mode_get,
 3073                .put = alc_ch_mode_put,
 3074        },
 3075        { } /* end */
 3076};
 3077
 3078static struct hda_verb alc880_test_init_verbs[] = {
 3079        /* Unmute inputs of 0x0c - 0x0f */
 3080        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 3081        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 3082        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 3083        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 3084        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 3085        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 3086        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 3087        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 3088        /* Vol output for 0x0c-0x0f */
 3089        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 3090        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 3091        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 3092        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 3093        /* Set output pins 0x14-0x17 */
 3094        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 3095        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 3096        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 3097        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 3098        /* Unmute output pins 0x14-0x17 */
 3099        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 3100        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 3101        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 3102        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 3103        /* Set input pins 0x18-0x1c */
 3104        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 3105        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 3106        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 3107        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 3108        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 3109        /* Mute input pins 0x18-0x1b */
 3110        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 3111        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 3112        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 3113        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 3114        /* ADC set up */
 3115        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 3116        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 3117        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 3118        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
 3119        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 3120        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 3121        /* Analog input/passthru */
 3122        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 3123        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 3124        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 3125        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 3126        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 3127        { }
 3128};
 3129#endif
 3130
 3131/*
 3132 */
 3133
 3134static const char *alc880_models[ALC880_MODEL_LAST] = {
 3135        [ALC880_3ST]                = "3stack",
 3136        [ALC880_TCL_S700]        = "tcl",
 3137        [ALC880_3ST_DIG]        = "3stack-digout",
 3138        [ALC880_CLEVO]                = "clevo",
 3139        [ALC880_5ST]                = "5stack",
 3140        [ALC880_5ST_DIG]        = "5stack-digout",
 3141        [ALC880_W810]                = "w810",
 3142        [ALC880_Z71V]                = "z71v",
 3143        [ALC880_6ST]                = "6stack",
 3144        [ALC880_6ST_DIG]        = "6stack-digout",
 3145        [ALC880_ASUS]                = "asus",
 3146        [ALC880_ASUS_W1V]        = "asus-w1v",
 3147        [ALC880_ASUS_DIG]        = "asus-dig",
 3148        [ALC880_ASUS_DIG2]        = "asus-dig2",
 3149        [ALC880_UNIWILL_DIG]        = "uniwill",
 3150        [ALC880_UNIWILL_P53]        = "uniwill-p53",
 3151        [ALC880_FUJITSU]        = "fujitsu",
 3152        [ALC880_F1734]                = "F1734",
 3153        [ALC880_LG]                = "lg",
 3154        [ALC880_LG_LW]                = "lg-lw",
 3155        [ALC880_MEDION_RIM]        = "medion",
 3156#ifdef CONFIG_SND_DEBUG
 3157        [ALC880_TEST]                = "test",
 3158#endif
 3159        [ALC880_AUTO]                = "auto",
 3160};
 3161
 3162static struct snd_pci_quirk alc880_cfg_tbl[] = {
 3163        SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
 3164        SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
 3165        SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
 3166        SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
 3167        SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
 3168        SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
 3169        SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
 3170        SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
 3171        SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
 3172        SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
 3173        SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
 3174        SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
 3175        SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
 3176        SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
 3177        SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
 3178        SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
 3179        SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
 3180        SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
 3181        /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
 3182        SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
 3183        SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
 3184        SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
 3185        SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
 3186        SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
 3187        SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
 3188        SND_PCI_QUIRK(0x1043, 0, "ASUS", ALC880_ASUS), /* default ASUS */
 3189        SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
 3190        SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
 3191        SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
 3192        SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
 3193        SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
 3194        SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
 3195        SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
 3196        SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
 3197        SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
 3198        SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
 3199        SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
 3200        SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
 3201        SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
 3202        SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
 3203        SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
 3204        SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
 3205        SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
 3206        SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
 3207        SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
 3208        SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
 3209        SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
 3210        SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
 3211        SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
 3212        SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
 3213        SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
 3214        SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
 3215        SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
 3216        SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
 3217        SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
 3218        SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
 3219        SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
 3220        SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
 3221        SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
 3222        SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
 3223        SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
 3224        SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
 3225        SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
 3226        SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
 3227        SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
 3228        SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
 3229        SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
 3230        SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
 3231        SND_PCI_QUIRK(0x8086, 0, "Intel mobo", ALC880_3ST), /* default Intel */
 3232        SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
 3233        SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
 3234        {}
 3235};
 3236
 3237/*
 3238 * ALC880 codec presets
 3239 */
 3240static struct alc_config_preset alc880_presets[] = {
 3241        [ALC880_3ST] = {
 3242                .mixers = { alc880_three_stack_mixer },
 3243                .init_verbs = { alc880_volume_init_verbs,
 3244                                alc880_pin_3stack_init_verbs },
 3245                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
 3246                .dac_nids = alc880_dac_nids,
 3247                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
 3248                .channel_mode = alc880_threestack_modes,
 3249                .need_dac_fix = 1,
 3250                .input_mux = &alc880_capture_source,
 3251        },
 3252        [ALC880_3ST_DIG] = {
 3253                .mixers = { alc880_three_stack_mixer },
 3254                .init_verbs = { alc880_volume_init_verbs,
 3255                                alc880_pin_3stack_init_verbs },
 3256                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
 3257                .dac_nids = alc880_dac_nids,
 3258                .dig_out_nid = ALC880_DIGOUT_NID,
 3259                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
 3260                .channel_mode = alc880_threestack_modes,
 3261                .need_dac_fix = 1,
 3262                .input_mux = &alc880_capture_source,
 3263        },
 3264        [ALC880_TCL_S700] = {
 3265                .mixers = { alc880_tcl_s700_mixer },
 3266                .init_verbs = { alc880_volume_init_verbs,
 3267                                alc880_pin_tcl_S700_init_verbs,
 3268                                alc880_gpio2_init_verbs },
 3269                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
 3270                .dac_nids = alc880_dac_nids,
 3271                .hp_nid = 0x03,
 3272                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
 3273                .channel_mode = alc880_2_jack_modes,
 3274                .input_mux = &alc880_capture_source,
 3275        },
 3276        [ALC880_5ST] = {
 3277                .mixers = { alc880_three_stack_mixer,
 3278                            alc880_five_stack_mixer},
 3279                .init_verbs = { alc880_volume_init_verbs,
 3280                                alc880_pin_5stack_init_verbs },
 3281                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
 3282                .dac_nids = alc880_dac_nids,
 3283                .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
 3284                .channel_mode = alc880_fivestack_modes,
 3285                .input_mux = &alc880_capture_source,
 3286        },
 3287        [ALC880_5ST_DIG] = {
 3288                .mixers = { alc880_three_stack_mixer,
 3289                            alc880_five_stack_mixer },
 3290                .init_verbs = { alc880_volume_init_verbs,
 3291                                alc880_pin_5stack_init_verbs },
 3292                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
 3293                .dac_nids = alc880_dac_nids,
 3294                .dig_out_nid = ALC880_DIGOUT_NID,
 3295                .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
 3296                .channel_mode = alc880_fivestack_modes,
 3297                .input_mux = &alc880_capture_source,
 3298        },
 3299        [ALC880_6ST] = {
 3300                .mixers = { alc880_six_stack_mixer },
 3301                .init_verbs = { alc880_volume_init_verbs,
 3302                                alc880_pin_6stack_init_verbs },
 3303                .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
 3304                .dac_nids = alc880_6st_dac_nids,
 3305                .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
 3306                .channel_mode = alc880_sixstack_modes,
 3307                .input_mux = &alc880_6stack_capture_source,
 3308        },
 3309        [ALC880_6ST_DIG] = {
 3310                .mixers = { alc880_six_stack_mixer },
 3311                .init_verbs = { alc880_volume_init_verbs,
 3312                                alc880_pin_6stack_init_verbs },
 3313                .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
 3314                .dac_nids = alc880_6st_dac_nids,
 3315                .dig_out_nid = ALC880_DIGOUT_NID,
 3316                .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
 3317                .channel_mode = alc880_sixstack_modes,
 3318                .input_mux = &alc880_6stack_capture_source,
 3319        },
 3320        [ALC880_W810] = {
 3321                .mixers = { alc880_w810_base_mixer },
 3322                .init_verbs = { alc880_volume_init_verbs,
 3323                                alc880_pin_w810_init_verbs,
 3324                                alc880_gpio2_init_verbs },
 3325                .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
 3326                .dac_nids = alc880_w810_dac_nids,
 3327                .dig_out_nid = ALC880_DIGOUT_NID,
 3328                .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
 3329                .channel_mode = alc880_w810_modes,
 3330                .input_mux = &alc880_capture_source,
 3331        },
 3332        [ALC880_Z71V] = {
 3333                .mixers = { alc880_z71v_mixer },
 3334                .init_verbs = { alc880_volume_init_verbs,
 3335                                alc880_pin_z71v_init_verbs },
 3336                .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
 3337                .dac_nids = alc880_z71v_dac_nids,
 3338                .dig_out_nid = ALC880_DIGOUT_NID,
 3339                .hp_nid = 0x03,
 3340                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
 3341                .channel_mode = alc880_2_jack_modes,
 3342                .input_mux = &alc880_capture_source,
 3343        },
 3344        [ALC880_F1734] = {
 3345                .mixers = { alc880_f1734_mixer },
 3346                .init_verbs = { alc880_volume_init_verbs,
 3347                                alc880_pin_f1734_init_verbs },
 3348                .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
 3349                .dac_nids = alc880_f1734_dac_nids,
 3350                .hp_nid = 0x02,
 3351                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
 3352                .channel_mode = alc880_2_jack_modes,
 3353                .input_mux = &alc880_f1734_capture_source,
 3354                .unsol_event = alc880_uniwill_p53_unsol_event,
 3355                .init_hook = alc880_uniwill_p53_hp_automute,
 3356        },
 3357        [ALC880_ASUS] = {
 3358                .mixers = { alc880_asus_mixer },
 3359                .init_verbs = { alc880_volume_init_verbs,
 3360                                alc880_pin_asus_init_verbs,
 3361                                alc880_gpio1_init_verbs },
 3362                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
 3363                .dac_nids = alc880_asus_dac_nids,
 3364                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
 3365                .channel_mode = alc880_asus_modes,
 3366                .need_dac_fix = 1,
 3367                .input_mux = &alc880_capture_source,
 3368        },
 3369        [ALC880_ASUS_DIG] = {
 3370                .mixers = { alc880_asus_mixer },
 3371                .init_verbs = { alc880_volume_init_verbs,
 3372                                alc880_pin_asus_init_verbs,
 3373                                alc880_gpio1_init_verbs },
 3374                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
 3375                .dac_nids = alc880_asus_dac_nids,
 3376                .dig_out_nid = ALC880_DIGOUT_NID,
 3377                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
 3378                .channel_mode = alc880_asus_modes,
 3379                .need_dac_fix = 1,
 3380                .input_mux = &alc880_capture_source,
 3381        },
 3382        [ALC880_ASUS_DIG2] = {
 3383                .mixers = { alc880_asus_mixer },
 3384                .init_verbs = { alc880_volume_init_verbs,
 3385                                alc880_pin_asus_init_verbs,
 3386                                alc880_gpio2_init_verbs }, /* use GPIO2 */
 3387                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
 3388                .dac_nids = alc880_asus_dac_nids,
 3389                .dig_out_nid = ALC880_DIGOUT_NID,
 3390                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
 3391                .channel_mode = alc880_asus_modes,
 3392                .need_dac_fix = 1,
 3393                .input_mux = &alc880_capture_source,
 3394        },
 3395        [ALC880_ASUS_W1V] = {
 3396                .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
 3397                .init_verbs = { alc880_volume_init_verbs,
 3398                                alc880_pin_asus_init_verbs,
 3399                                alc880_gpio1_init_verbs },
 3400                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
 3401                .dac_nids = alc880_asus_dac_nids,
 3402                .dig_out_nid = ALC880_DIGOUT_NID,
 3403                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
 3404                .channel_mode = alc880_asus_modes,
 3405                .need_dac_fix = 1,
 3406                .input_mux = &alc880_capture_source,
 3407        },
 3408        [ALC880_UNIWILL_DIG] = {
 3409                .mixers = { alc880_asus_mixer, alc880_pcbeep_mixer },
 3410                .init_verbs = { alc880_volume_init_verbs,
 3411                                alc880_pin_asus_init_verbs },
 3412                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
 3413                .dac_nids = alc880_asus_dac_nids,
 3414                .dig_out_nid = ALC880_DIGOUT_NID,
 3415                .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
 3416                .channel_mode = alc880_asus_modes,
 3417                .need_dac_fix = 1,
 3418                .input_mux = &alc880_capture_source,
 3419        },
 3420        [ALC880_UNIWILL] = {
 3421                .mixers = { alc880_uniwill_mixer },
 3422                .init_verbs = { alc880_volume_init_verbs,
 3423                                alc880_uniwill_init_verbs },
 3424                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
 3425                .dac_nids = alc880_asus_dac_nids,
 3426                .dig_out_nid = ALC880_DIGOUT_NID,
 3427                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
 3428                .channel_mode = alc880_threestack_modes,
 3429                .need_dac_fix = 1,
 3430                .input_mux = &alc880_capture_source,
 3431                .unsol_event = alc880_uniwill_unsol_event,
 3432                .init_hook = alc880_uniwill_automute,
 3433        },
 3434        [ALC880_UNIWILL_P53] = {
 3435                .mixers = { alc880_uniwill_p53_mixer },
 3436                .init_verbs = { alc880_volume_init_verbs,
 3437                                alc880_uniwill_p53_init_verbs },
 3438                .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
 3439                .dac_nids = alc880_asus_dac_nids,
 3440                .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
 3441                .channel_mode = alc880_threestack_modes,
 3442                .input_mux = &alc880_capture_source,
 3443                .unsol_event = alc880_uniwill_p53_unsol_event,
 3444                .init_hook = alc880_uniwill_p53_hp_automute,
 3445        },
 3446        [ALC880_FUJITSU] = {
 3447                .mixers = { alc880_fujitsu_mixer,
 3448                            alc880_pcbeep_mixer, },
 3449                .init_verbs = { alc880_volume_init_verbs,
 3450                                alc880_uniwill_p53_init_verbs,
 3451                                       alc880_beep_init_verbs },
 3452                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
 3453                .dac_nids = alc880_dac_nids,
 3454                .dig_out_nid = ALC880_DIGOUT_NID,
 3455                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
 3456                .channel_mode = alc880_2_jack_modes,
 3457                .input_mux = &alc880_capture_source,
 3458                .unsol_event = alc880_uniwill_p53_unsol_event,
 3459                .init_hook = alc880_uniwill_p53_hp_automute,
 3460        },
 3461        [ALC880_CLEVO] = {
 3462                .mixers = { alc880_three_stack_mixer },
 3463                .init_verbs = { alc880_volume_init_verbs,
 3464                                alc880_pin_clevo_init_verbs },
 3465                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
 3466                .dac_nids = alc880_dac_nids,
 3467                .hp_nid = 0x03,
 3468                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
 3469                .channel_mode = alc880_threestack_modes,
 3470                .need_dac_fix = 1,
 3471                .input_mux = &alc880_capture_source,
 3472        },
 3473        [ALC880_LG] = {
 3474                .mixers = { alc880_lg_mixer },
 3475                .init_verbs = { alc880_volume_init_verbs,
 3476                                alc880_lg_init_verbs },
 3477                .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
 3478                .dac_nids = alc880_lg_dac_nids,
 3479                .dig_out_nid = ALC880_DIGOUT_NID,
 3480                .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
 3481                .channel_mode = alc880_lg_ch_modes,
 3482                .need_dac_fix = 1,
 3483                .input_mux = &alc880_lg_capture_source,
 3484                .unsol_event = alc880_lg_unsol_event,
 3485                .init_hook = alc880_lg_automute,
 3486#ifdef CONFIG_SND_HDA_POWER_SAVE
 3487                .loopbacks = alc880_lg_loopbacks,
 3488#endif
 3489        },
 3490        [ALC880_LG_LW] = {
 3491                .mixers = { alc880_lg_lw_mixer },
 3492                .init_verbs = { alc880_volume_init_verbs,
 3493                                alc880_lg_lw_init_verbs },
 3494                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
 3495                .dac_nids = alc880_dac_nids,
 3496                .dig_out_nid = ALC880_DIGOUT_NID,
 3497                .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
 3498                .channel_mode = alc880_lg_lw_modes,
 3499                .input_mux = &alc880_lg_lw_capture_source,
 3500                .unsol_event = alc880_lg_lw_unsol_event,
 3501                .init_hook = alc880_lg_lw_automute,
 3502        },
 3503        [ALC880_MEDION_RIM] = {
 3504                .mixers = { alc880_medion_rim_mixer },
 3505                .init_verbs = { alc880_volume_init_verbs,
 3506                                alc880_medion_rim_init_verbs,
 3507                                alc_gpio2_init_verbs },
 3508                .num_dacs = ARRAY_SIZE(alc880_dac_nids),
 3509                .dac_nids = alc880_dac_nids,
 3510                .dig_out_nid = ALC880_DIGOUT_NID,
 3511                .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
 3512                .channel_mode = alc880_2_jack_modes,
 3513                .input_mux = &alc880_medion_rim_capture_source,
 3514                .unsol_event = alc880_medion_rim_unsol_event,
 3515                .init_hook = alc880_medion_rim_automute,
 3516        },
 3517#ifdef CONFIG_SND_DEBUG
 3518        [ALC880_TEST] = {
 3519                .mixers = { alc880_test_mixer },
 3520                .init_verbs = { alc880_test_init_verbs },
 3521                .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
 3522                .dac_nids = alc880_test_dac_nids,
 3523                .dig_out_nid = ALC880_DIGOUT_NID,
 3524                .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
 3525                .channel_mode = alc880_test_modes,
 3526                .input_mux = &alc880_test_capture_source,
 3527        },
 3528#endif
 3529};
 3530
 3531/*
 3532 * Automatic parse of I/O pins from the BIOS configuration
 3533 */
 3534
 3535#define NUM_CONTROL_ALLOC        32
 3536#define NUM_VERB_ALLOC                32
 3537
 3538enum {
 3539        ALC_CTL_WIDGET_VOL,
 3540        ALC_CTL_WIDGET_MUTE,
 3541        ALC_CTL_BIND_MUTE,
 3542};
 3543static struct snd_kcontrol_new alc880_control_templates[] = {
 3544        HDA_CODEC_VOLUME(NULL, 0, 0, 0),
 3545        HDA_CODEC_MUTE(NULL, 0, 0, 0),
 3546        HDA_BIND_MUTE(NULL, 0, 0, 0),
 3547};
 3548
 3549/* add dynamic controls */
 3550static int add_control(struct alc_spec *spec, int type, const char *name,
 3551                       unsigned long val)
 3552{
 3553        struct snd_kcontrol_new *knew;
 3554
 3555        if (spec->num_kctl_used >= spec->num_kctl_alloc) {
 3556                int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC;
 3557
 3558                /* array + terminator */
 3559                knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL);
 3560                if (!knew)
 3561                        return -ENOMEM;
 3562                if (spec->kctl_alloc) {
 3563                        memcpy(knew, spec->kctl_alloc,
 3564                               sizeof(*knew) * spec->num_kctl_alloc);
 3565                        kfree(spec->kctl_alloc);
 3566                }
 3567                spec->kctl_alloc = knew;
 3568                spec->num_kctl_alloc = num;
 3569        }
 3570
 3571        knew = &spec->kctl_alloc[spec->num_kctl_used];
 3572        *knew = alc880_control_templates[type];
 3573        knew->name = kstrdup(name, GFP_KERNEL);
 3574        if (!knew->name)
 3575                return -ENOMEM;
 3576        knew->private_value = val;
 3577        spec->num_kctl_used++;
 3578        return 0;
 3579}
 3580
 3581#define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
 3582#define alc880_fixed_pin_idx(nid)        ((nid) - 0x14)
 3583#define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
 3584#define alc880_multi_pin_idx(nid)        ((nid) - 0x18)
 3585#define alc880_is_input_pin(nid)        ((nid) >= 0x18)
 3586#define alc880_input_pin_idx(nid)        ((nid) - 0x18)
 3587#define alc880_idx_to_dac(nid)                ((nid) + 0x02)
 3588#define alc880_dac_to_idx(nid)                ((nid) - 0x02)
 3589#define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
 3590#define alc880_idx_to_selector(nid)        ((nid) + 0x10)
 3591#define ALC880_PIN_CD_NID                0x1c
 3592
 3593/* fill in the dac_nids table from the parsed pin configuration */
 3594static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
 3595                                     const struct auto_pin_cfg *cfg)
 3596{
 3597        hda_nid_t nid;
 3598        int assigned[4];
 3599        int i, j;
 3600
 3601        memset(assigned, 0, sizeof(assigned));
 3602        spec->multiout.dac_nids = spec->private_dac_nids;
 3603
 3604        /* check the pins hardwired to audio widget */
 3605        for (i = 0; i < cfg->line_outs; i++) {
 3606                nid = cfg->line_out_pins[i];
 3607                if (alc880_is_fixed_pin(nid)) {
 3608                        int idx = alc880_fixed_pin_idx(nid);
 3609                        spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
 3610                        assigned[idx] = 1;
 3611                }
 3612        }
 3613        /* left pins can be connect to any audio widget */
 3614        for (i = 0; i < cfg->line_outs; i++) {
 3615                nid = cfg->line_out_pins[i];
 3616                if (alc880_is_fixed_pin(nid))
 3617                        continue;
 3618                /* search for an empty channel */
 3619                for (j = 0; j < cfg->line_outs; j++) {
 3620                        if (!assigned[j]) {
 3621                                spec->multiout.dac_nids[i] =
 3622                                        alc880_idx_to_dac(j);
 3623                                assigned[j] = 1;
 3624                                break;
 3625                        }
 3626                }
 3627        }
 3628        spec->multiout.num_dacs = cfg->line_outs;
 3629        return 0;
 3630}
 3631
 3632/* add playback controls from the parsed DAC table */
 3633static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
 3634                                             const struct auto_pin_cfg *cfg)
 3635{
 3636        char name[32];
 3637        static const char *chname[4] = {
 3638                "Front", "Surround", NULL /*CLFE*/, "Side"
 3639        };
 3640        hda_nid_t nid;
 3641        int i, err;
 3642
 3643        for (i = 0; i < cfg->line_outs; i++) {
 3644                if (!spec->multiout.dac_nids[i])
 3645                        continue;
 3646                nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
 3647                if (i == 2) {
 3648                        /* Center/LFE */
 3649                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
 3650                                          "Center Playback Volume",
 3651                                          HDA_COMPOSE_AMP_VAL(nid, 1, 0,
 3652                                                              HDA_OUTPUT));
 3653                        if (err < 0)
 3654                                return err;
 3655                        err = add_control(spec, ALC_CTL_WIDGET_VOL,
 3656                                          "LFE Playback Volume",
 3657                                          HDA_COMPOSE_AMP_VAL(nid, 2, 0,
 3658                                                              HDA_OUTPUT));
 3659                        if (err < 0)
 3660                                return err;
 3661                        err = add_control(spec, ALC_CTL_BIND_MUTE,
 3662                                          "Center Playback Switch",
 3663                                          HDA_COMPOSE_AMP_VAL(nid, 1, 2,
 3664                                                              HDA_INPUT));
 3665                        if (err < 0)
 3666                                return err;
 3667                        err = add_control(spec, ALC_CTL_BIND_MUTE,
 3668                                          "LFE Playback Switch",
 3669                                          HDA_COMPOSE_AMP_VAL(nid, 2, 2,
 3670                                                              HDA_INPUT));
 3671                        if (err < 0)
 3672                                return err;
 3673                } else {
 3674                        sprintf(name, "%s Playback Volume", chname[i]);
 3675                        err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
 3676                                          HDA_COMPOSE_AMP_VAL(nid, 3, 0,
 3677                                                              HDA_OUTPUT));
 3678                        if (err < 0)
 3679                                return err;
 3680                        sprintf(name, "%s Playback Switch", chname[i]);
 3681                        err = add_control(spec, ALC_CTL_BIND_MUTE, name,
 3682                                          HDA_COMPOSE_AMP_VAL(nid, 3, 2,
 3683                                                              HDA_INPUT));
 3684                        if (err < 0)
 3685                                return err;
 3686                }
 3687        }
 3688        return 0;
 3689}
 3690
 3691/* add playback controls for speaker and HP outputs */
 3692static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
 3693                                        const char *pfx)
 3694{
 3695        hda_nid_t nid;
 3696        int err;
 3697        char name[32];
 3698
 3699        if (!pin)
 3700                return 0;
 3701
 3702        if (alc880_is_fixed_pin(pin)) {
 3703                nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
 3704                /* specify the DAC as the extra output */
 3705                if (!spec->multiout.hp_nid)
 3706                        spec->multiout.hp_nid = nid;
 3707                else
 3708                        spec->multiout.extra_out_nid[0] = nid;
 3709                /* control HP volume/switch on the output mixer amp */
 3710                nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
 3711                sprintf(name, "%s Playback Volume", pfx);
 3712                err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
 3713                                  HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
 3714                if (err < 0)
 3715                        return err;
 3716                sprintf(name, "%s Playback Switch", pfx);
 3717                err = add_control(spec, ALC_CTL_BIND_MUTE, name,
 3718                                  HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
 3719                if (err < 0)
 3720                        return err;
 3721        } else if (alc880_is_multi_pin(pin)) {
 3722                /* set manual connection */
 3723                /* we have only a switch on HP-out PIN */
 3724                sprintf(name, "%s Playback Switch", pfx);
 3725                err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
 3726                                  HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
 3727                if (err < 0)
 3728                        return err;
 3729        }
 3730        return 0;
 3731}
 3732
 3733/* create input playback/capture controls for the given pin */
 3734static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
 3735                            const char *ctlname,
 3736                            int idx, hda_nid_t mix_nid)
 3737{
 3738        char name[32];
 3739        int err;
 3740
 3741        sprintf(name, "%s Playback Volume", ctlname);
 3742        err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
 3743                          HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 3744        if (err < 0)
 3745                return err;
 3746        sprintf(name, "%s Playback Switch", ctlname);
 3747        err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
 3748                          HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
 3749        if (err < 0)
 3750                return err;
 3751        return 0;
 3752}
 3753
 3754/* create playback/capture controls for input pins */
 3755static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
 3756                                                const struct auto_pin_cfg *cfg)
 3757{
 3758        struct hda_input_mux *imux = &spec->private_imux;
 3759        int i, err, idx;
 3760
 3761        for (i = 0; i < AUTO_PIN_LAST; i++) {
 3762                if (alc880_is_input_pin(cfg->input_pins[i])) {
 3763                        idx = alc880_input_pin_idx(cfg->input_pins[i]);
 3764                        err = new_analog_input(spec, cfg->input_pins[i],
 3765                                               auto_pin_cfg_labels[i],
 3766                                               idx, 0x0b);
 3767                        if (err < 0)
 3768                                return err;
 3769                        imux->items[imux->num_items].label =
 3770                                auto_pin_cfg_labels[i];
 3771                        imux->items[imux->num_items].index =
 3772                                alc880_input_pin_idx(cfg->input_pins[i]);
 3773                        imux->num_items++;
 3774                }
 3775        }
 3776        return 0;
 3777}
 3778
 3779static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
 3780                               unsigned int pin_type)
 3781{
 3782        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 3783                            pin_type);
 3784        /* unmute pin */
 3785        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 3786                            AMP_OUT_UNMUTE);
 3787}
 3788
 3789static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
 3790                                              hda_nid_t nid, int pin_type,
 3791                                              int dac_idx)
 3792{
 3793        alc_set_pin_output(codec, nid, pin_type);
 3794        /* need the manual connection? */
 3795        if (alc880_is_multi_pin(nid)) {
 3796                struct alc_spec *spec = codec->spec;
 3797                int idx = alc880_multi_pin_idx(nid);
 3798                snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
 3799                                    AC_VERB_SET_CONNECT_SEL,
 3800                                    alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
 3801        }
 3802}
 3803
 3804static int get_pin_type(int line_out_type)
 3805{
 3806        if (line_out_type == AUTO_PIN_HP_OUT)
 3807                return PIN_HP;
 3808        else
 3809                return PIN_OUT;
 3810}
 3811
 3812static void alc880_auto_init_multi_out(struct hda_codec *codec)
 3813{
 3814        struct alc_spec *spec = codec->spec;
 3815        int i;
 3816
 3817        alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
 3818        for (i = 0; i < spec->autocfg.line_outs; i++) {
 3819                hda_nid_t nid = spec->autocfg.line_out_pins[i];
 3820                int pin_type = get_pin_type(spec->autocfg.line_out_type);
 3821                alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
 3822        }
 3823}
 3824
 3825static void alc880_auto_init_extra_out(struct hda_codec *codec)
 3826{
 3827        struct alc_spec *spec = codec->spec;
 3828        hda_nid_t pin;
 3829
 3830        pin = spec->autocfg.speaker_pins[0];
 3831        if (pin) /* connect to front */
 3832                alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
 3833        pin = spec->autocfg.hp_pins[0];
 3834        if (pin) /* connect to front */
 3835                alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
 3836}
 3837
 3838static void alc880_auto_init_analog_input(struct hda_codec *codec)
 3839{
 3840        struct alc_spec *spec = codec->spec;
 3841        int i;
 3842
 3843        for (i = 0; i < AUTO_PIN_LAST; i++) {
 3844                hda_nid_t nid = spec->autocfg.input_pins[i];
 3845                if (alc880_is_input_pin(nid)) {
 3846                        snd_hda_codec_write(codec, nid, 0,
 3847                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
 3848                                            i <= AUTO_PIN_FRONT_MIC ?
 3849                                            PIN_VREF80 : PIN_IN);
 3850                        if (nid != ALC880_PIN_CD_NID)
 3851                                snd_hda_codec_write(codec, nid, 0,
 3852                                                    AC_VERB_SET_AMP_GAIN_MUTE,
 3853                                                    AMP_OUT_MUTE);
 3854                }
 3855        }
 3856}
 3857
 3858/* parse the BIOS configuration and set up the alc_spec */
 3859/* return 1 if successful, 0 if the proper config is not found,
 3860 * or a negative error code
 3861 */
 3862static int alc880_parse_auto_config(struct hda_codec *codec)
 3863{
 3864        struct alc_spec *spec = codec->spec;
 3865        int err;
 3866        static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
 3867
 3868        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
 3869                                           alc880_ignore);
 3870        if (err < 0)
 3871                return err;
 3872        if (!spec->autocfg.line_outs)
 3873                return 0; /* can't find valid BIOS pin config */
 3874
 3875        err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
 3876        if (err < 0)
 3877                return err;
 3878        err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
 3879        if (err < 0)
 3880                return err;
 3881        err = alc880_auto_create_extra_out(spec,
 3882                                           spec->autocfg.speaker_pins[0],
 3883                                           "Speaker");
 3884        if (err < 0)
 3885                return err;
 3886        err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
 3887                                           "Headphone");
 3888        if (err < 0)
 3889                return err;
 3890        err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
 3891        if (err < 0)
 3892                return err;
 3893
 3894        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
 3895
 3896        if (spec->autocfg.dig_out_pin)
 3897                spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
 3898        if (spec->autocfg.dig_in_pin)
 3899                spec->dig_in_nid = ALC880_DIGIN_NID;
 3900
 3901        if (spec->kctl_alloc)
 3902                spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
 3903
 3904        spec->init_verbs[spec->num_init_verbs++] = alc880_volume_init_verbs;
 3905
 3906        spec->num_mux_defs = 1;
 3907        spec->input_mux = &spec->private_imux;
 3908
 3909        store_pin_configs(codec);
 3910        return 1;
 3911}
 3912
 3913/* additional initialization for auto-configuration model */
 3914static void alc880_auto_init(struct hda_codec *codec)
 3915{
 3916        struct alc_spec *spec = codec->spec;
 3917        alc880_auto_init_multi_out(codec);
 3918        alc880_auto_init_extra_out(codec);
 3919        alc880_auto_init_analog_input(codec);
 3920        if (spec->unsol_event)
 3921                alc_inithook(codec);
 3922}
 3923
 3924/*
 3925 * OK, here we have finally the patch for ALC880
 3926 */
 3927
 3928static int patch_alc880(struct hda_codec *codec)
 3929{
 3930        struct alc_spec *spec;
 3931        int board_config;
 3932        int err;
 3933
 3934        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 3935        if (spec == NULL)
 3936                return -ENOMEM;
 3937
 3938        codec->spec = spec;
 3939
 3940        board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
 3941                                                  alc880_models,
 3942                                                  alc880_cfg_tbl);
 3943        if (board_config < 0) {
 3944                printk(KERN_INFO "hda_codec: Unknown model for ALC880, "
 3945                       "trying auto-probe from BIOS...\n");
 3946                board_config = ALC880_AUTO;
 3947        }
 3948
 3949        if (board_config == ALC880_AUTO) {
 3950                /* automatic parse from the BIOS config */
 3951                err = alc880_parse_auto_config(codec);
 3952                if (err < 0) {
 3953                        alc_free(codec);
 3954                        return err;
 3955                } else if (!err) {
 3956                        printk(KERN_INFO
 3957                               "hda_codec: Cannot set up configuration "
 3958                               "from BIOS.  Using 3-stack mode...\n");
 3959                        board_config = ALC880_3ST;
 3960                }
 3961        }
 3962
 3963        if (board_config != ALC880_AUTO)
 3964                setup_preset(spec, &alc880_presets[board_config]);
 3965
 3966        spec->stream_name_analog = "ALC880 Analog";
 3967        spec->stream_analog_playback = &alc880_pcm_analog_playback;
 3968        spec->stream_analog_capture = &alc880_pcm_analog_capture;
 3969        spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
 3970
 3971        spec->stream_name_digital = "ALC880 Digital";
 3972        spec->stream_digital_playback = &alc880_pcm_digital_playback;
 3973        spec->stream_digital_capture = &alc880_pcm_digital_capture;
 3974
 3975        if (!spec->adc_nids && spec->input_mux) {
 3976                /* check whether NID 0x07 is valid */
 3977                unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
 3978                /* get type */
 3979                wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 3980                if (wcap != AC_WID_AUD_IN) {
 3981                        spec->adc_nids = alc880_adc_nids_alt;
 3982                        spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
 3983                        spec->mixers[spec->num_mixers] =
 3984                                alc880_capture_alt_mixer;
 3985                        spec->num_mixers++;
 3986                } else {
 3987                        spec->adc_nids = alc880_adc_nids;
 3988                        spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
 3989                        spec->mixers[spec->num_mixers] = alc880_capture_mixer;
 3990                        spec->num_mixers++;
 3991                }
 3992        }
 3993
 3994        spec->vmaster_nid = 0x0c;
 3995
 3996        codec->patch_ops = alc_patch_ops;
 3997        if (board_config == ALC880_AUTO)
 3998                spec->init_hook = alc880_auto_init;
 3999#ifdef CONFIG_SND_HDA_POWER_SAVE
 4000        if (!spec->loopback.amplist)
 4001                spec->loopback.amplist = alc880_loopbacks;
 4002#endif
 4003
 4004        return 0;
 4005}
 4006
 4007
 4008/*
 4009 * ALC260 support
 4010 */
 4011
 4012static hda_nid_t alc260_dac_nids[1] = {
 4013        /* front */
 4014        0x02,
 4015};
 4016
 4017static hda_nid_t alc260_adc_nids[1] = {
 4018        /* ADC0 */
 4019        0x04,
 4020};
 4021
 4022static hda_nid_t alc260_adc_nids_alt[1] = {
 4023        /* ADC1 */
 4024        0x05,
 4025};
 4026
 4027static hda_nid_t alc260_hp_adc_nids[2] = {
 4028        /* ADC1, 0 */
 4029        0x05, 0x04
 4030};
 4031
 4032/* NIDs used when simultaneous access to both ADCs makes sense.  Note that
 4033 * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
 4034 */
 4035static hda_nid_t alc260_dual_adc_nids[2] = {
 4036        /* ADC0, ADC1 */
 4037        0x04, 0x05
 4038};
 4039
 4040#define ALC260_DIGOUT_NID        0x03
 4041#define ALC260_DIGIN_NID        0x06
 4042
 4043static struct hda_input_mux alc260_capture_source = {
 4044        .num_items = 4,
 4045        .items = {
 4046                { "Mic", 0x0 },
 4047                { "Front Mic", 0x1 },
 4048                { "Line", 0x2 },
 4049                { "CD", 0x4 },
 4050        },
 4051};
 4052
 4053/* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
 4054 * headphone jack and the internal CD lines since these are the only pins at
 4055 * which audio can appear.  For flexibility, also allow the option of
 4056 * recording the mixer output on the second ADC (ADC0 doesn't have a
 4057 * connection to the mixer output).
 4058 */
 4059static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
 4060        {
 4061                .num_items = 3,
 4062                .items = {
 4063                        { "Mic/Line", 0x0 },
 4064                        { "CD", 0x4 },
 4065                        { "Headphone", 0x2 },
 4066                },
 4067        },
 4068        {
 4069                .num_items = 4,
 4070                .items = {
 4071                        { "Mic/Line", 0x0 },
 4072                        { "CD", 0x4 },
 4073                        { "Headphone", 0x2 },
 4074                        { "Mixer", 0x5 },
 4075                },
 4076        },
 4077
 4078};
 4079
 4080/* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
 4081 * the Fujitsu S702x, but jacks are marked differently.
 4082 */
 4083static struct hda_input_mux alc260_acer_capture_sources[2] = {
 4084        {
 4085                .num_items = 4,
 4086                .items = {
 4087                        { "Mic", 0x0 },
 4088                        { "Line", 0x2 },
 4089                        { "CD", 0x4 },
 4090                        { "Headphone", 0x5 },
 4091                },
 4092        },
 4093        {
 4094                .num_items = 5,
 4095                .items = {
 4096                        { "Mic", 0x0 },
 4097                        { "Line", 0x2 },
 4098                        { "CD", 0x4 },
 4099                        { "Headphone", 0x6 },
 4100                        { "Mixer", 0x5 },
 4101                },
 4102        },
 4103};
 4104/*
 4105 * This is just place-holder, so there's something for alc_build_pcms to look
 4106 * at when it calculates the maximum number of channels. ALC260 has no mixer
 4107 * element which allows changing the channel mode, so the verb list is
 4108 * never used.
 4109 */
 4110static struct hda_channel_mode alc260_modes[1] = {
 4111        { 2, NULL },
 4112};
 4113
 4114
 4115/* Mixer combinations
 4116 *
 4117 * basic: base_output + input + pc_beep + capture
 4118 * HP: base_output + input + capture_alt
 4119 * HP_3013: hp_3013 + input + capture
 4120 * fujitsu: fujitsu + capture
 4121 * acer: acer + capture
 4122 */
 4123
 4124static struct snd_kcontrol_new alc260_base_output_mixer[] = {
 4125        HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
 4126        HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
 4127        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
 4128        HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
 4129        HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
 4130        HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
 4131        { } /* end */
 4132};
 4133
 4134static struct snd_kcontrol_new alc260_input_mixer[] = {
 4135        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
 4136        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
 4137        HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
 4138        HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
 4139        HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
 4140        HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
 4141        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
 4142        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
 4143        { } /* end */
 4144};
 4145
 4146static struct snd_kcontrol_new alc260_pc_beep_mixer[] = {
 4147        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x07, 0x05, HDA_INPUT),
 4148        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x07, 0x05, HDA_INPUT),
 4149        { } /* end */
 4150};
 4151
 4152/* update HP, line and mono out pins according to the master switch */
 4153static void alc260_hp_master_update(struct hda_codec *codec,
 4154                                    hda_nid_t hp, hda_nid_t line,
 4155                                    hda_nid_t mono)
 4156{
 4157        struct alc_spec *spec = codec->spec;
 4158        unsigned int val = spec->master_sw ? PIN_HP : 0;
 4159        /* change HP and line-out pins */
 4160        snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 4161                            val);
 4162        snd_hda_codec_write(codec, 0x10, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 4163                            val);
 4164        /* mono (speaker) depending on the HP jack sense */
 4165        val = (val && !spec->jack_present) ? PIN_OUT : 0;
 4166        snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 4167                            val);
 4168}
 4169
 4170static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
 4171                                   struct snd_ctl_elem_value *ucontrol)
 4172{
 4173        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 4174        struct alc_spec *spec = codec->spec;
 4175        *ucontrol->value.integer.value = spec->master_sw;
 4176        return 0;
 4177}
 4178
 4179static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
 4180                                   struct snd_ctl_elem_value *ucontrol)
 4181{
 4182        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 4183        struct alc_spec *spec = codec->spec;
 4184        int val = !!*ucontrol->value.integer.value;
 4185        hda_nid_t hp, line, mono;
 4186
 4187        if (val == spec->master_sw)
 4188                return 0;
 4189        spec->master_sw = val;
 4190        hp = (kcontrol->private_value >> 16) & 0xff;
 4191        line = (kcontrol->private_value >> 8) & 0xff;
 4192        mono = kcontrol->private_value & 0xff;
 4193        alc260_hp_master_update(codec, hp, line, mono);
 4194        return 1;
 4195}
 4196
 4197static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
 4198        {
 4199                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 4200                .name = "Master Playback Switch",
 4201                .info = snd_ctl_boolean_mono_info,
 4202                .get = alc260_hp_master_sw_get,
 4203                .put = alc260_hp_master_sw_put,
 4204                .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
 4205        },
 4206        HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
 4207        HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
 4208        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
 4209        HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
 4210        HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
 4211                              HDA_OUTPUT),
 4212        HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
 4213        { } /* end */
 4214};
 4215
 4216static struct hda_verb alc260_hp_unsol_verbs[] = {
 4217        {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
 4218        {},
 4219};
 4220
 4221static void alc260_hp_automute(struct hda_codec *codec)
 4222{
 4223        struct alc_spec *spec = codec->spec;
 4224        unsigned int present;
 4225
 4226        present = snd_hda_codec_read(codec, 0x10, 0,
 4227                                     AC_VERB_GET_PIN_SENSE, 0);
 4228        spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
 4229        alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
 4230}
 4231
 4232static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
 4233{
 4234        if ((res >> 26) == ALC880_HP_EVENT)
 4235                alc260_hp_automute(codec);
 4236}
 4237
 4238static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
 4239        {
 4240                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 4241                .name = "Master Playback Switch",
 4242                .info = snd_ctl_boolean_mono_info,
 4243                .get = alc260_hp_master_sw_get,
 4244                .put = alc260_hp_master_sw_put,
 4245                .private_value = (0x10 << 16) | (0x15 << 8) | 0x11
 4246        },
 4247        HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
 4248        HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
 4249        HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
 4250        HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
 4251        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
 4252        HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 4253        HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
 4254        HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
 4255        { } /* end */
 4256};
 4257
 4258static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
 4259        .ops = &snd_hda_bind_vol,
 4260        .values = {
 4261                HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
 4262                HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
 4263                HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
 4264                0
 4265        },
 4266};
 4267
 4268static struct hda_bind_ctls alc260_dc7600_bind_switch = {
 4269        .ops = &snd_hda_bind_sw,
 4270        .values = {
 4271                HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
 4272                HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
 4273                0
 4274        },
 4275};
 4276
 4277static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
 4278        HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
 4279        HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
 4280        HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
 4281        HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
 4282        { } /* end */
 4283};
 4284
 4285static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
 4286        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
 4287        {},
 4288};
 4289
 4290static void alc260_hp_3013_automute(struct hda_codec *codec)
 4291{
 4292        struct alc_spec *spec = codec->spec;
 4293        unsigned int present;
 4294
 4295        present = snd_hda_codec_read(codec, 0x15, 0,
 4296                                     AC_VERB_GET_PIN_SENSE, 0);
 4297        spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
 4298        alc260_hp_master_update(codec, 0x10, 0x15, 0x11);
 4299}
 4300
 4301static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
 4302                                       unsigned int res)
 4303{
 4304        if ((res >> 26) == ALC880_HP_EVENT)
 4305                alc260_hp_3013_automute(codec);
 4306}
 4307
 4308static void alc260_hp_3012_automute(struct hda_codec *codec)
 4309{
 4310        unsigned int present, bits;
 4311
 4312        present = snd_hda_codec_read(codec, 0x10, 0,
 4313                        AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
 4314
 4315        bits = present ? 0 : PIN_OUT;
 4316        snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 4317                            bits);
 4318        snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 4319                            bits);
 4320        snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
 4321                            bits);
 4322}
 4323
 4324static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
 4325                                       unsigned int res)
 4326{
 4327        if ((res >> 26) == ALC880_HP_EVENT)
 4328                alc260_hp_3012_automute(codec);
 4329}
 4330
 4331/* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
 4332 * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
 4333 */
 4334static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
 4335        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
 4336        HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
 4337        ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
 4338        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
 4339        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
 4340        HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
 4341        HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
 4342        ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
 4343        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
 4344        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
 4345        HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
 4346        HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
 4347        { } /* end */
 4348};
 4349
 4350/* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
 4351 * versions of the ALC260 don't act on requests to enable mic bias from NID
 4352 * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
 4353 * datasheet doesn't mention this restriction.  At this stage it's not clear
 4354 * whether this behaviour is intentional or is a hardware bug in chip
 4355 * revisions available in early 2006.  Therefore for now allow the
 4356 * "Headphone Jack Mode" control to span all choices, but if it turns out
 4357 * that the lack of mic bias for this NID is intentional we could change the
 4358 * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
 4359 *
 4360 * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
 4361 * don't appear to make the mic bias available from the "line" jack, even
 4362 * though the NID used for this jack (0x14) can supply it.  The theory is
 4363 * that perhaps Acer have included blocking capacitors between the ALC260
 4364 * and the output jack.  If this turns out to be the case for all such
 4365 * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
 4366 * to ALC_PIN_DIR_INOUT_NOMICBIAS.
 4367 *
 4368 * The C20x Tablet series have a mono internal speaker which is controlled
 4369 * via the chip's Mono sum widget and pin complex, so include the necessary
 4370 * controls for such models.  On models without a "mono speaker" the control
 4371 * won't do anything.
 4372 */
 4373static struct snd_kcontrol_new alc260_acer_mixer[] = {
 4374        HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
 4375        HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
 4376        ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
 4377        HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
 4378                              HDA_OUTPUT),
 4379        HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
 4380                           HDA_INPUT),
 4381        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
 4382        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
 4383        HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
 4384        HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
 4385        ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
 4386        HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
 4387        HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
 4388        ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
 4389        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
 4390        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
 4391        { } /* end */
 4392};
 4393
 4394/* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
 4395 * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
 4396 */
 4397static struct snd_kcontrol_new alc260_will_mixer[] = {
 4398        HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
 4399        HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
 4400        HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
 4401        HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
 4402        ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
 4403        HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
 4404        HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
 4405        ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
 4406        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
 4407        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
 4408        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
 4409        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
 4410        { } /* end */
 4411};
 4412
 4413/* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
 4414 * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
 4415 */
 4416static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
 4417        HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
 4418        HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
 4419        HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
 4420        HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
 4421        ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
 4422        HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
 4423        HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
 4424        HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
 4425        HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
 4426        ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
 4427        { } /* end */
 4428};
 4429
 4430/* capture mixer elements */
 4431static struct snd_kcontrol_new alc260_capture_mixer[] = {
 4432        HDA_CODEC_VOLUME("Capture Volume", 0x04, 0x0, HDA_INPUT),
 4433        HDA_CODEC_MUTE("Capture Switch", 0x04, 0x0, HDA_INPUT),
 4434        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x05, 0x0, HDA_INPUT),
 4435        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x05, 0x0, HDA_INPUT),
 4436        {
 4437                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 4438                /* The multiple "Capture Source" controls confuse alsamixer
 4439                 * So call somewhat different..
 4440                 */
 4441                /* .name = "Capture Source", */
 4442                .name = "Input Source",
 4443                .count = 2,
 4444                .info = alc_mux_enum_info,
 4445                .get = alc_mux_enum_get,
 4446                .put = alc_mux_enum_put,
 4447        },
 4448        { } /* end */
 4449};
 4450
 4451static struct snd_kcontrol_new alc260_capture_alt_mixer[] = {
 4452        HDA_CODEC_VOLUME("Capture Volume", 0x05, 0x0, HDA_INPUT),
 4453        HDA_CODEC_MUTE("Capture Switch", 0x05, 0x0, HDA_INPUT),
 4454        {
 4455                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 4456                /* The multiple "Capture Source" controls confuse alsamixer
 4457                 * So call somewhat different..
 4458                 */
 4459                /* .name = "Capture Source", */
 4460                .name = "Input Source",
 4461                .count = 1,
 4462                .info = alc_mux_enum_info,
 4463                .get = alc_mux_enum_get,
 4464                .put = alc_mux_enum_put,
 4465        },
 4466        { } /* end */
 4467};
 4468
 4469/*
 4470 * initialization verbs
 4471 */
 4472static struct hda_verb alc260_init_verbs[] = {
 4473        /* Line In pin widget for input */
 4474        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 4475        /* CD pin widget for input */
 4476        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 4477        /* Mic1 (rear panel) pin widget for input and vref at 80% */
 4478        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 4479        /* Mic2 (front panel) pin widget for input and vref at 80% */
 4480        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 4481        /* LINE-2 is used for line-out in rear */
 4482        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4483        /* select line-out */
 4484        {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
 4485        /* LINE-OUT pin */
 4486        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4487        /* enable HP */
 4488        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 4489        /* enable Mono */
 4490        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4491        /* mute capture amp left and right */
 4492        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 4493        /* set connection select to line in (default select for this ADC) */
 4494        {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
 4495        /* mute capture amp left and right */
 4496        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 4497        /* set connection select to line in (default select for this ADC) */
 4498        {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
 4499        /* set vol=0 Line-Out mixer amp left and right */
 4500        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 4501        /* unmute pin widget amp left and right (no gain on this amp) */
 4502        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 4503        /* set vol=0 HP mixer amp left and right */
 4504        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 4505        /* unmute pin widget amp left and right (no gain on this amp) */
 4506        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 4507        /* set vol=0 Mono mixer amp left and right */
 4508        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 4509        /* unmute pin widget amp left and right (no gain on this amp) */
 4510        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 4511        /* unmute LINE-2 out pin */
 4512        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 4513        /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
 4514         * Line In 2 = 0x03
 4515         */
 4516        /* mute analog inputs */
 4517        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4518        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4519        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 4520        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 4521        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 4522        /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
 4523        /* mute Front out path */
 4524        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4525        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4526        /* mute Headphone out path */
 4527        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4528        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4529        /* mute Mono out path */
 4530        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4531        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4532        { }
 4533};
 4534
 4535#if 0 /* should be identical with alc260_init_verbs? */
 4536static struct hda_verb alc260_hp_init_verbs[] = {
 4537        /* Headphone and output */
 4538        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
 4539        /* mono output */
 4540        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 4541        /* Mic1 (rear panel) pin widget for input and vref at 80% */
 4542        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 4543        /* Mic2 (front panel) pin widget for input and vref at 80% */
 4544        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 4545        /* Line In pin widget for input */
 4546        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 4547        /* Line-2 pin widget for output */
 4548        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 4549        /* CD pin widget for input */
 4550        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 4551        /* unmute amp left and right */
 4552        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
 4553        /* set connection select to line in (default select for this ADC) */
 4554        {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
 4555        /* unmute Line-Out mixer amp left and right (volume = 0) */
 4556        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 4557        /* mute pin widget amp left and right (no gain on this amp) */
 4558        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 4559        /* unmute HP mixer amp left and right (volume = 0) */
 4560        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 4561        /* mute pin widget amp left and right (no gain on this amp) */
 4562        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 4563        /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
 4564         * Line In 2 = 0x03
 4565         */
 4566        /* mute analog inputs */
 4567        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4568        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4569        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 4570        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 4571        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 4572        /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
 4573        /* Unmute Front out path */
 4574        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 4575        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 4576        /* Unmute Headphone out path */
 4577        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 4578        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 4579        /* Unmute Mono out path */
 4580        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 4581        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 4582        { }
 4583};
 4584#endif
 4585
 4586static struct hda_verb alc260_hp_3013_init_verbs[] = {
 4587        /* Line out and output */
 4588        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 4589        /* mono output */
 4590        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
 4591        /* Mic1 (rear panel) pin widget for input and vref at 80% */
 4592        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 4593        /* Mic2 (front panel) pin widget for input and vref at 80% */
 4594        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
 4595        /* Line In pin widget for input */
 4596        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 4597        /* Headphone pin widget for output */
 4598        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
 4599        /* CD pin widget for input */
 4600        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
 4601        /* unmute amp left and right */
 4602        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
 4603        /* set connection select to line in (default select for this ADC) */
 4604        {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
 4605        /* unmute Line-Out mixer amp left and right (volume = 0) */
 4606        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 4607        /* mute pin widget amp left and right (no gain on this amp) */
 4608        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 4609        /* unmute HP mixer amp left and right (volume = 0) */
 4610        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 4611        /* mute pin widget amp left and right (no gain on this amp) */
 4612        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
 4613        /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
 4614         * Line In 2 = 0x03
 4615         */
 4616        /* mute analog inputs */
 4617        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4618        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4619        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 4620        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 4621        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 4622        /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
 4623        /* Unmute Front out path */
 4624        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 4625        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 4626        /* Unmute Headphone out path */
 4627        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 4628        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 4629        /* Unmute Mono out path */
 4630        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 4631        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
 4632        { }
 4633};
 4634
 4635/* Initialisation sequence for ALC260 as configured in Fujitsu S702x
 4636 * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
 4637 * audio = 0x16, internal speaker = 0x10.
 4638 */
 4639static struct hda_verb alc260_fujitsu_init_verbs[] = {
 4640        /* Disable all GPIOs */
 4641        {0x01, AC_VERB_SET_GPIO_MASK, 0},
 4642        /* Internal speaker is connected to headphone pin */
 4643        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 4644        /* Headphone/Line-out jack connects to Line1 pin; make it an output */
 4645        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4646        /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
 4647        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 4648        /* Ensure all other unused pins are disabled and muted. */
 4649        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 4650        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4651        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 4652        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4653        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 4654        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4655        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 4656        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4657
 4658        /* Disable digital (SPDIF) pins */
 4659        {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
 4660        {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
 4661
 4662        /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
 4663         * when acting as an output.
 4664         */
 4665        {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
 4666
 4667        /* Start with output sum widgets muted and their output gains at min */
 4668        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4669        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4670        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 4671        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4672        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4673        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 4674        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4675        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4676        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 4677
 4678        /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
 4679        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 4680        /* Unmute Line1 pin widget output buffer since it starts as an output.
 4681         * If the pin mode is changed by the user the pin mode control will
 4682         * take care of enabling the pin's input/output buffers as needed.
 4683         * Therefore there's no need to enable the input buffer at this
 4684         * stage.
 4685         */
 4686        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 4687        /* Unmute input buffer of pin widget used for Line-in (no equiv
 4688         * mixer ctrl)
 4689         */
 4690        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 4691
 4692        /* Mute capture amp left and right */
 4693        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4694        /* Set ADC connection select to match default mixer setting - line
 4695         * in (on mic1 pin)
 4696         */
 4697        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
 4698
 4699        /* Do the same for the second ADC: mute capture input amp and
 4700         * set ADC connection to line in (on mic1 pin)
 4701         */
 4702        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4703        {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
 4704
 4705        /* Mute all inputs to mixer widget (even unconnected ones) */
 4706        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
 4707        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
 4708        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
 4709        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
 4710        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
 4711        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
 4712        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
 4713        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
 4714
 4715        { }
 4716};
 4717
 4718/* Initialisation sequence for ALC260 as configured in Acer TravelMate and
 4719 * similar laptops (adapted from Fujitsu init verbs).
 4720 */
 4721static struct hda_verb alc260_acer_init_verbs[] = {
 4722        /* On TravelMate laptops, GPIO 0 enables the internal speaker and
 4723         * the headphone jack.  Turn this on and rely on the standard mute
 4724         * methods whenever the user wants to turn these outputs off.
 4725         */
 4726        {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 4727        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 4728        {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 4729        /* Internal speaker/Headphone jack is connected to Line-out pin */
 4730        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 4731        /* Internal microphone/Mic jack is connected to Mic1 pin */
 4732        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
 4733        /* Line In jack is connected to Line1 pin */
 4734        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 4735        /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
 4736        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 4737        /* Ensure all other unused pins are disabled and muted. */
 4738        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 4739        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4740        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 4741        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4742        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
 4743        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4744        /* Disable digital (SPDIF) pins */
 4745        {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
 4746        {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
 4747
 4748        /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
 4749         * bus when acting as outputs.
 4750         */
 4751        {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
 4752        {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
 4753
 4754        /* Start with output sum widgets muted and their output gains at min */
 4755        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4756        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4757        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 4758        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4759        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4760        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 4761        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4762        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 4763        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 4764
 4765        /* Unmute Line-out pin widget amp left and right
 4766         * (no equiv mixer ctrl)
 4767         */
 4768        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 4769        /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
 4770        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 4771        /* Unmute Mic1 and Line1 pin widget input buffers since they start as
 4772         * inputs. If the pin mode is changed by the user the pin mode control
 4773         * will take care of enabling the pin's input/output buffers as needed.
 4774         * Therefore there's no need to enable the input buffer at this
 4775         * stage.
 4776         */
 4777        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 4778        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 4779
 4780        /* Mute capture amp left and right */
 4781        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4782        /* Set ADC connection select to match default mixer setting - mic
 4783         * (on mic1 pin)
 4784         */
 4785        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
 4786
 4787        /* Do similar with the second ADC: mute capture input amp and
 4788         * set ADC connection to mic to match ALSA's default state.
 4789         */
 4790        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 4791        {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
 4792
 4793        /* Mute all inputs to mixer widget (even unconnected ones) */
 4794        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
 4795        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
 4796        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
 4797        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
 4798        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
 4799        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
 4800        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
 4801        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
 4802
 4803        { }
 4804};
 4805
 4806static struct hda_verb alc260_will_verbs[] = {
 4807        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 4808        {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
 4809        {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
 4810        {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
 4811        {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
 4812        {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
 4813        {}
 4814};
 4815
 4816static struct hda_verb alc260_replacer_672v_verbs[] = {
 4817        {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
 4818        {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
 4819        {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
 4820
 4821        {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 4822        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 4823        {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
 4824
 4825        {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
 4826        {}
 4827};
 4828
 4829/* toggle speaker-output according to the hp-jack state */
 4830static void alc260_replacer_672v_automute(struct hda_codec *codec)
 4831{
 4832        unsigned int present;
 4833
 4834        /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
 4835        present = snd_hda_codec_read(codec, 0x0f, 0,
 4836                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 4837        if (present) {
 4838                snd_hda_codec_write_cache(codec, 0x01, 0,
 4839                                          AC_VERB_SET_GPIO_DATA, 1);
 4840                snd_hda_codec_write_cache(codec, 0x0f, 0,
 4841                                          AC_VERB_SET_PIN_WIDGET_CONTROL,
 4842                                          PIN_HP);
 4843        } else {
 4844                snd_hda_codec_write_cache(codec, 0x01, 0,
 4845                                          AC_VERB_SET_GPIO_DATA, 0);
 4846                snd_hda_codec_write_cache(codec, 0x0f, 0,
 4847                                          AC_VERB_SET_PIN_WIDGET_CONTROL,
 4848                                          PIN_OUT);
 4849        }
 4850}
 4851
 4852static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
 4853                                       unsigned int res)
 4854{
 4855        if ((res >> 26) == ALC880_HP_EVENT)
 4856                alc260_replacer_672v_automute(codec);
 4857}
 4858
 4859static struct hda_verb alc260_hp_dc7600_verbs[] = {
 4860        {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
 4861        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
 4862        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4863        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 4864        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4865        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4866        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 4867        {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
 4868        {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
 4869        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
 4870        {}
 4871};
 4872
 4873/* Test configuration for debugging, modelled after the ALC880 test
 4874 * configuration.
 4875 */
 4876#ifdef CONFIG_SND_DEBUG
 4877static hda_nid_t alc260_test_dac_nids[1] = {
 4878        0x02,
 4879};
 4880static hda_nid_t alc260_test_adc_nids[2] = {
 4881        0x04, 0x05,
 4882};
 4883/* For testing the ALC260, each input MUX needs its own definition since
 4884 * the signal assignments are different.  This assumes that the first ADC
 4885 * is NID 0x04.
 4886 */
 4887static struct hda_input_mux alc260_test_capture_sources[2] = {
 4888        {
 4889                .num_items = 7,
 4890                .items = {
 4891                        { "MIC1 pin", 0x0 },
 4892                        { "MIC2 pin", 0x1 },
 4893                        { "LINE1 pin", 0x2 },
 4894                        { "LINE2 pin", 0x3 },
 4895                        { "CD pin", 0x4 },
 4896                        { "LINE-OUT pin", 0x5 },
 4897                        { "HP-OUT pin", 0x6 },
 4898                },
 4899        },
 4900        {
 4901                .num_items = 8,
 4902                .items = {
 4903                        { "MIC1 pin", 0x0 },
 4904                        { "MIC2 pin", 0x1 },
 4905                        { "LINE1 pin", 0x2 },
 4906                        { "LINE2 pin", 0x3 },
 4907                        { "CD pin", 0x4 },
 4908                        { "Mixer", 0x5 },
 4909                        { "LINE-OUT pin", 0x6 },
 4910                        { "HP-OUT pin", 0x7 },
 4911                },
 4912        },
 4913};
 4914static struct snd_kcontrol_new alc260_test_mixer[] = {
 4915        /* Output driver widgets */
 4916        HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
 4917        HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
 4918        HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
 4919        HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
 4920        HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
 4921        HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
 4922
 4923        /* Modes for retasking pin widgets
 4924         * Note: the ALC260 doesn't seem to act on requests to enable mic
 4925         * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
 4926         * mention this restriction.  At this stage it's not clear whether
 4927         * this behaviour is intentional or is a hardware bug in chip
 4928         * revisions available at least up until early 2006.  Therefore for
 4929         * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
 4930         * choices, but if it turns out that the lack of mic bias for these
 4931         * NIDs is intentional we could change their modes from
 4932         * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
 4933         */
 4934        ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
 4935        ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
 4936        ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
 4937        ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
 4938        ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
 4939        ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
 4940
 4941        /* Loopback mixer controls */
 4942        HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
 4943        HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
 4944        HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
 4945        HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
 4946        HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
 4947        HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
 4948        HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
 4949        HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
 4950        HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
 4951        HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
 4952        HDA_CODEC_VOLUME("Beep Playback Volume", 0x07, 0x05, HDA_INPUT),
 4953        HDA_CODEC_MUTE("Beep Playback Switch", 0x07, 0x05, HDA_INPUT),
 4954        HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
 4955        HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
 4956        HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
 4957        HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
 4958
 4959        /* Controls for GPIO pins, assuming they are configured as outputs */
 4960        ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
 4961        ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
 4962        ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
 4963        ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
 4964
 4965        /* Switches to allow the digital IO pins to be enabled.  The datasheet
 4966         * is ambigious as to which NID is which; testing on laptops which
 4967         * make this output available should provide clarification.
 4968         */
 4969        ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
 4970        ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
 4971
 4972        /* A switch allowing EAPD to be enabled.  Some laptops seem to use
 4973         * this output to turn on an external amplifier.
 4974         */
 4975        ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
 4976        ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
 4977
 4978        { } /* end */
 4979};
 4980static struct hda_verb alc260_test_init_verbs[] = {
 4981        /* Enable all GPIOs as outputs with an initial value of 0 */
 4982        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
 4983        {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
 4984        {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
 4985
 4986        /* Enable retasking pins as output, initially without power amp */
 4987        {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4988        {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4989        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4990        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4991        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4992        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 4993
 4994        /* Disable digital (SPDIF) pins initially, but users can enable
 4995         * them via a mixer switch.  In the case of SPDIF-out, this initverb
 4996         * payload also sets the generation to 0, output to be in "consumer"
 4997         * PCM format, copyright asserted, no pre-emphasis and no validity
 4998         * control.
 4999         */
 5000        {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
 5001        {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
 5002
 5003        /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
 5004         * OUT1 sum bus when acting as an output.
 5005         */
 5006        {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
 5007        {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
 5008        {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
 5009        {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
 5010
 5011        /* Start with output sum widgets muted and their output gains at min */
 5012        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5013        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5014        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5015        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5016        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5017        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5018        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5019        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5020        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5021
 5022        /* Unmute retasking pin widget output buffers since the default
 5023         * state appears to be output.  As the pin mode is changed by the
 5024         * user the pin mode control will take care of enabling the pin's
 5025         * input/output buffers as needed.
 5026         */
 5027        {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5028        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5029        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5030        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5031        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5032        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5033        /* Also unmute the mono-out pin widget */
 5034        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5035
 5036        /* Mute capture amp left and right */
 5037        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5038        /* Set ADC connection select to match default mixer setting (mic1
 5039         * pin)
 5040         */
 5041        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
 5042
 5043        /* Do the same for the second ADC: mute capture input amp and
 5044         * set ADC connection to mic1 pin
 5045         */
 5046        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5047        {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
 5048
 5049        /* Mute all inputs to mixer widget (even unconnected ones) */
 5050        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
 5051        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
 5052        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
 5053        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
 5054        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
 5055        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
 5056        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
 5057        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
 5058
 5059        { }
 5060};
 5061#endif
 5062
 5063#define alc260_pcm_analog_playback        alc880_pcm_analog_alt_playback
 5064#define alc260_pcm_analog_capture        alc880_pcm_analog_capture
 5065
 5066#define alc260_pcm_digital_playback        alc880_pcm_digital_playback
 5067#define alc260_pcm_digital_capture        alc880_pcm_digital_capture
 5068
 5069/*
 5070 * for BIOS auto-configuration
 5071 */
 5072
 5073static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
 5074                                        const char *pfx, int *vol_bits)
 5075{
 5076        hda_nid_t nid_vol;
 5077        unsigned long vol_val, sw_val;
 5078        char name[32];
 5079        int err;
 5080
 5081        if (nid >= 0x0f && nid < 0x11) {
 5082                nid_vol = nid - 0x7;
 5083                vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
 5084                sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
 5085        } else if (nid == 0x11) {
 5086                nid_vol = nid - 0x7;
 5087                vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
 5088                sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
 5089        } else if (nid >= 0x12 && nid <= 0x15) {
 5090                nid_vol = 0x08;
 5091                vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
 5092                sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
 5093        } else
 5094                return 0; /* N/A */
 5095
 5096        if (!(*vol_bits & (1 << nid_vol))) {
 5097                /* first control for the volume widget */
 5098                snprintf(name, sizeof(name), "%s Playback Volume", pfx);
 5099                err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
 5100                if (err < 0)
 5101                        return err;
 5102                *vol_bits |= (1 << nid_vol);
 5103        }
 5104        snprintf(name, sizeof(name), "%s Playback Switch", pfx);
 5105        err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
 5106        if (err < 0)
 5107                return err;
 5108        return 1;
 5109}
 5110
 5111/* add playback controls from the parsed DAC table */
 5112static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
 5113                                             const struct auto_pin_cfg *cfg)
 5114{
 5115        hda_nid_t nid;
 5116        int err;
 5117        int vols = 0;
 5118
 5119        spec->multiout.num_dacs = 1;
 5120        spec->multiout.dac_nids = spec->private_dac_nids;
 5121        spec->multiout.dac_nids[0] = 0x02;
 5122
 5123        nid = cfg->line_out_pins[0];
 5124        if (nid) {
 5125                err = alc260_add_playback_controls(spec, nid, "Front", &vols);
 5126                if (err < 0)
 5127                        return err;
 5128        }
 5129
 5130        nid = cfg->speaker_pins[0];
 5131        if (nid) {
 5132                err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
 5133                if (err < 0)
 5134                        return err;
 5135        }
 5136
 5137        nid = cfg->hp_pins[0];
 5138        if (nid) {
 5139                err = alc260_add_playback_controls(spec, nid, "Headphone",
 5140                                                   &vols);
 5141                if (err < 0)
 5142                        return err;
 5143        }
 5144        return 0;
 5145}
 5146
 5147/* create playback/capture controls for input pins */
 5148static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
 5149                                                const struct auto_pin_cfg *cfg)
 5150{
 5151        struct hda_input_mux *imux = &spec->private_imux;
 5152        int i, err, idx;
 5153
 5154        for (i = 0; i < AUTO_PIN_LAST; i++) {
 5155                if (cfg->input_pins[i] >= 0x12) {
 5156                        idx = cfg->input_pins[i] - 0x12;
 5157                        err = new_analog_input(spec, cfg->input_pins[i],
 5158                                               auto_pin_cfg_labels[i], idx,
 5159                                               0x07);
 5160                        if (err < 0)
 5161                                return err;
 5162                        imux->items[imux->num_items].label =
 5163                                auto_pin_cfg_labels[i];
 5164                        imux->items[imux->num_items].index = idx;
 5165                        imux->num_items++;
 5166                }
 5167                if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
 5168                        idx = cfg->input_pins[i] - 0x09;
 5169                        err = new_analog_input(spec, cfg->input_pins[i],
 5170                                               auto_pin_cfg_labels[i], idx,
 5171                                               0x07);
 5172                        if (err < 0)
 5173                                return err;
 5174                        imux->items[imux->num_items].label =
 5175                                auto_pin_cfg_labels[i];
 5176                        imux->items[imux->num_items].index = idx;
 5177                        imux->num_items++;
 5178                }
 5179        }
 5180        return 0;
 5181}
 5182
 5183static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
 5184                                              hda_nid_t nid, int pin_type,
 5185                                              int sel_idx)
 5186{
 5187        alc_set_pin_output(codec, nid, pin_type);
 5188        /* need the manual connection? */
 5189        if (nid >= 0x12) {
 5190                int idx = nid - 0x12;
 5191                snd_hda_codec_write(codec, idx + 0x0b, 0,
 5192                                    AC_VERB_SET_CONNECT_SEL, sel_idx);
 5193        }
 5194}
 5195
 5196static void alc260_auto_init_multi_out(struct hda_codec *codec)
 5197{
 5198        struct alc_spec *spec = codec->spec;
 5199        hda_nid_t nid;
 5200
 5201        alc_subsystem_id(codec, 0x10, 0x15, 0x0f);
 5202        nid = spec->autocfg.line_out_pins[0];
 5203        if (nid) {
 5204                int pin_type = get_pin_type(spec->autocfg.line_out_type);
 5205                alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
 5206        }
 5207
 5208        nid = spec->autocfg.speaker_pins[0];
 5209        if (nid)
 5210                alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
 5211
 5212        nid = spec->autocfg.hp_pins[0];
 5213        if (nid)
 5214                alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
 5215}
 5216
 5217#define ALC260_PIN_CD_NID                0x16
 5218static void alc260_auto_init_analog_input(struct hda_codec *codec)
 5219{
 5220        struct alc_spec *spec = codec->spec;
 5221        int i;
 5222
 5223        for (i = 0; i < AUTO_PIN_LAST; i++) {
 5224                hda_nid_t nid = spec->autocfg.input_pins[i];
 5225                if (nid >= 0x12) {
 5226                        snd_hda_codec_write(codec, nid, 0,
 5227                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
 5228                                            i <= AUTO_PIN_FRONT_MIC ?
 5229                                            PIN_VREF80 : PIN_IN);
 5230                        if (nid != ALC260_PIN_CD_NID)
 5231                                snd_hda_codec_write(codec, nid, 0,
 5232                                                    AC_VERB_SET_AMP_GAIN_MUTE,
 5233                                                    AMP_OUT_MUTE);
 5234                }
 5235        }
 5236}
 5237
 5238/*
 5239 * generic initialization of ADC, input mixers and output mixers
 5240 */
 5241static struct hda_verb alc260_volume_init_verbs[] = {
 5242        /*
 5243         * Unmute ADC0-1 and set the default input to mic-in
 5244         */
 5245        {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
 5246        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5247        {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
 5248        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5249
 5250        /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
 5251         * mixer widget
 5252         * Note: PASD motherboards uses the Line In 2 as the input for
 5253         * front panel mic (mic 2)
 5254         */
 5255        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
 5256        /* mute analog inputs */
 5257        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5258        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5259        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 5260        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 5261        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 5262
 5263        /*
 5264         * Set up output mixers (0x08 - 0x0a)
 5265         */
 5266        /* set vol=0 to output mixers */
 5267        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5268        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5269        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5270        /* set up input amps for analog loopback */
 5271        /* Amp Indices: DAC = 0, mixer = 1 */
 5272        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5273        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 5274        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5275        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 5276        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5277        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 5278
 5279        { }
 5280};
 5281
 5282static int alc260_parse_auto_config(struct hda_codec *codec)
 5283{
 5284        struct alc_spec *spec = codec->spec;
 5285        unsigned int wcap;
 5286        int err;
 5287        static hda_nid_t alc260_ignore[] = { 0x17, 0 };
 5288
 5289        err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
 5290                                           alc260_ignore);
 5291        if (err < 0)
 5292                return err;
 5293        err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
 5294        if (err < 0)
 5295                return err;
 5296        if (!spec->kctl_alloc)
 5297                return 0; /* can't find valid BIOS pin config */
 5298        err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
 5299        if (err < 0)
 5300                return err;
 5301
 5302        spec->multiout.max_channels = 2;
 5303
 5304        if (spec->autocfg.dig_out_pin)
 5305                spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
 5306        if (spec->kctl_alloc)
 5307                spec->mixers[spec->num_mixers++] = spec->kctl_alloc;
 5308
 5309        spec->init_verbs[spec->num_init_verbs++] = alc260_volume_init_verbs;
 5310
 5311        spec->num_mux_defs = 1;
 5312        spec->input_mux = &spec->private_imux;
 5313
 5314        /* check whether NID 0x04 is valid */
 5315        wcap = get_wcaps(codec, 0x04);
 5316        wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; /* get type */
 5317        if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
 5318                spec->adc_nids = alc260_adc_nids_alt;
 5319                spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
 5320                spec->mixers[spec->num_mixers] = alc260_capture_alt_mixer;
 5321        } else {
 5322                spec->adc_nids = alc260_adc_nids;
 5323                spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
 5324                spec->mixers[spec->num_mixers] = alc260_capture_mixer;
 5325        }
 5326        spec->num_mixers++;
 5327
 5328        store_pin_configs(codec);
 5329        return 1;
 5330}
 5331
 5332/* additional initialization for auto-configuration model */
 5333static void alc260_auto_init(struct hda_codec *codec)
 5334{
 5335        struct alc_spec *spec = codec->spec;
 5336        alc260_auto_init_multi_out(codec);
 5337        alc260_auto_init_analog_input(codec);
 5338        if (spec->unsol_event)
 5339                alc_inithook(codec);
 5340}
 5341
 5342#ifdef CONFIG_SND_HDA_POWER_SAVE
 5343static struct hda_amp_list alc260_loopbacks[] = {
 5344        { 0x07, HDA_INPUT, 0 },
 5345        { 0x07, HDA_INPUT, 1 },
 5346        { 0x07, HDA_INPUT, 2 },
 5347        { 0x07, HDA_INPUT, 3 },
 5348        { 0x07, HDA_INPUT, 4 },
 5349        { } /* end */
 5350};
 5351#endif
 5352
 5353/*
 5354 * ALC260 configurations
 5355 */
 5356static const char *alc260_models[ALC260_MODEL_LAST] = {
 5357        [ALC260_BASIC]                = "basic",
 5358        [ALC260_HP]                = "hp",
 5359        [ALC260_HP_3013]        = "hp-3013",
 5360        [ALC260_HP_DC7600]        = "hp-dc7600",
 5361        [ALC260_FUJITSU_S702X]        = "fujitsu",
 5362        [ALC260_ACER]                = "acer",
 5363        [ALC260_WILL]                = "will",
 5364        [ALC260_REPLACER_672V]        = "replacer",
 5365#ifdef CONFIG_SND_DEBUG
 5366        [ALC260_TEST]                = "test",
 5367#endif
 5368        [ALC260_AUTO]                = "auto",
 5369};
 5370
 5371static struct snd_pci_quirk alc260_cfg_tbl[] = {
 5372        SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
 5373        SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
 5374        SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
 5375        SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
 5376        SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
 5377        SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
 5378        SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
 5379        SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
 5380        SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
 5381        SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
 5382        SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
 5383        SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
 5384        SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
 5385        SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
 5386        SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
 5387        SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
 5388        SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
 5389        SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
 5390        {}
 5391};
 5392
 5393static struct alc_config_preset alc260_presets[] = {
 5394        [ALC260_BASIC] = {
 5395                .mixers = { alc260_base_output_mixer,
 5396                            alc260_input_mixer,
 5397                            alc260_pc_beep_mixer,
 5398                            alc260_capture_mixer },
 5399                .init_verbs = { alc260_init_verbs },
 5400                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
 5401                .dac_nids = alc260_dac_nids,
 5402                .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
 5403                .adc_nids = alc260_adc_nids,
 5404                .num_channel_mode = ARRAY_SIZE(alc260_modes),
 5405                .channel_mode = alc260_modes,
 5406                .input_mux = &alc260_capture_source,
 5407        },
 5408        [ALC260_HP] = {
 5409                .mixers = { alc260_hp_output_mixer,
 5410                            alc260_input_mixer,
 5411                            alc260_capture_alt_mixer },
 5412                .init_verbs = { alc260_init_verbs,
 5413                                alc260_hp_unsol_verbs },
 5414                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
 5415                .dac_nids = alc260_dac_nids,
 5416                .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
 5417                .adc_nids = alc260_hp_adc_nids,
 5418                .num_channel_mode = ARRAY_SIZE(alc260_modes),
 5419                .channel_mode = alc260_modes,
 5420                .input_mux = &alc260_capture_source,
 5421                .unsol_event = alc260_hp_unsol_event,
 5422                .init_hook = alc260_hp_automute,
 5423        },
 5424        [ALC260_HP_DC7600] = {
 5425                .mixers = { alc260_hp_dc7600_mixer,
 5426                            alc260_input_mixer,
 5427                            alc260_capture_alt_mixer },
 5428                .init_verbs = { alc260_init_verbs,
 5429                                alc260_hp_dc7600_verbs },
 5430                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
 5431                .dac_nids = alc260_dac_nids,
 5432                .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
 5433                .adc_nids = alc260_hp_adc_nids,
 5434                .num_channel_mode = ARRAY_SIZE(alc260_modes),
 5435                .channel_mode = alc260_modes,
 5436                .input_mux = &alc260_capture_source,
 5437                .unsol_event = alc260_hp_3012_unsol_event,
 5438                .init_hook = alc260_hp_3012_automute,
 5439        },
 5440        [ALC260_HP_3013] = {
 5441                .mixers = { alc260_hp_3013_mixer,
 5442                            alc260_input_mixer,
 5443                            alc260_capture_alt_mixer },
 5444                .init_verbs = { alc260_hp_3013_init_verbs,
 5445                                alc260_hp_3013_unsol_verbs },
 5446                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
 5447                .dac_nids = alc260_dac_nids,
 5448                .num_adc_nids = ARRAY_SIZE(alc260_hp_adc_nids),
 5449                .adc_nids = alc260_hp_adc_nids,
 5450                .num_channel_mode = ARRAY_SIZE(alc260_modes),
 5451                .channel_mode = alc260_modes,
 5452                .input_mux = &alc260_capture_source,
 5453                .unsol_event = alc260_hp_3013_unsol_event,
 5454                .init_hook = alc260_hp_3013_automute,
 5455        },
 5456        [ALC260_FUJITSU_S702X] = {
 5457                .mixers = { alc260_fujitsu_mixer,
 5458                            alc260_capture_mixer },
 5459                .init_verbs = { alc260_fujitsu_init_verbs },
 5460                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
 5461                .dac_nids = alc260_dac_nids,
 5462                .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
 5463                .adc_nids = alc260_dual_adc_nids,
 5464                .num_channel_mode = ARRAY_SIZE(alc260_modes),
 5465                .channel_mode = alc260_modes,
 5466                .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
 5467                .input_mux = alc260_fujitsu_capture_sources,
 5468        },
 5469        [ALC260_ACER] = {
 5470                .mixers = { alc260_acer_mixer,
 5471                            alc260_capture_mixer },
 5472                .init_verbs = { alc260_acer_init_verbs },
 5473                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
 5474                .dac_nids = alc260_dac_nids,
 5475                .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
 5476                .adc_nids = alc260_dual_adc_nids,
 5477                .num_channel_mode = ARRAY_SIZE(alc260_modes),
 5478                .channel_mode = alc260_modes,
 5479                .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
 5480                .input_mux = alc260_acer_capture_sources,
 5481        },
 5482        [ALC260_WILL] = {
 5483                .mixers = { alc260_will_mixer,
 5484                            alc260_capture_mixer },
 5485                .init_verbs = { alc260_init_verbs, alc260_will_verbs },
 5486                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
 5487                .dac_nids = alc260_dac_nids,
 5488                .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
 5489                .adc_nids = alc260_adc_nids,
 5490                .dig_out_nid = ALC260_DIGOUT_NID,
 5491                .num_channel_mode = ARRAY_SIZE(alc260_modes),
 5492                .channel_mode = alc260_modes,
 5493                .input_mux = &alc260_capture_source,
 5494        },
 5495        [ALC260_REPLACER_672V] = {
 5496                .mixers = { alc260_replacer_672v_mixer,
 5497                            alc260_capture_mixer },
 5498                .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
 5499                .num_dacs = ARRAY_SIZE(alc260_dac_nids),
 5500                .dac_nids = alc260_dac_nids,
 5501                .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
 5502                .adc_nids = alc260_adc_nids,
 5503                .dig_out_nid = ALC260_DIGOUT_NID,
 5504                .num_channel_mode = ARRAY_SIZE(alc260_modes),
 5505                .channel_mode = alc260_modes,
 5506                .input_mux = &alc260_capture_source,
 5507                .unsol_event = alc260_replacer_672v_unsol_event,
 5508                .init_hook = alc260_replacer_672v_automute,
 5509        },
 5510#ifdef CONFIG_SND_DEBUG
 5511        [ALC260_TEST] = {
 5512                .mixers = { alc260_test_mixer,
 5513                            alc260_capture_mixer },
 5514                .init_verbs = { alc260_test_init_verbs },
 5515                .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
 5516                .dac_nids = alc260_test_dac_nids,
 5517                .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
 5518                .adc_nids = alc260_test_adc_nids,
 5519                .num_channel_mode = ARRAY_SIZE(alc260_modes),
 5520                .channel_mode = alc260_modes,
 5521                .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
 5522                .input_mux = alc260_test_capture_sources,
 5523        },
 5524#endif
 5525};
 5526
 5527static int patch_alc260(struct hda_codec *codec)
 5528{
 5529        struct alc_spec *spec;
 5530        int err, board_config;
 5531
 5532        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 5533        if (spec == NULL)
 5534                return -ENOMEM;
 5535
 5536        codec->spec = spec;
 5537
 5538        board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
 5539                                                  alc260_models,
 5540                                                  alc260_cfg_tbl);
 5541        if (board_config < 0) {
 5542                snd_printd(KERN_INFO "hda_codec: Unknown model for ALC260, "
 5543                           "trying auto-probe from BIOS...\n");
 5544                board_config = ALC260_AUTO;
 5545        }
 5546
 5547        if (board_config == ALC260_AUTO) {
 5548                /* automatic parse from the BIOS config */
 5549                err = alc260_parse_auto_config(codec);
 5550                if (err < 0) {
 5551                        alc_free(codec);
 5552                        return err;
 5553                } else if (!err) {
 5554                        printk(KERN_INFO
 5555                               "hda_codec: Cannot set up configuration "
 5556                               "from BIOS.  Using base mode...\n");
 5557                        board_config = ALC260_BASIC;
 5558                }
 5559        }
 5560
 5561        if (board_config != ALC260_AUTO)
 5562                setup_preset(spec, &alc260_presets[board_config]);
 5563
 5564        spec->stream_name_analog = "ALC260 Analog";
 5565        spec->stream_analog_playback = &alc260_pcm_analog_playback;
 5566        spec->stream_analog_capture = &alc260_pcm_analog_capture;
 5567
 5568        spec->stream_name_digital = "ALC260 Digital";
 5569        spec->stream_digital_playback = &alc260_pcm_digital_playback;
 5570        spec->stream_digital_capture = &alc260_pcm_digital_capture;
 5571
 5572        spec->vmaster_nid = 0x08;
 5573
 5574        codec->patch_ops = alc_patch_ops;
 5575        if (board_config == ALC260_AUTO)
 5576                spec->init_hook = alc260_auto_init;
 5577#ifdef CONFIG_SND_HDA_POWER_SAVE
 5578        if (!spec->loopback.amplist)
 5579                spec->loopback.amplist = alc260_loopbacks;
 5580#endif
 5581
 5582        return 0;
 5583}
 5584
 5585
 5586/*
 5587 * ALC882 support
 5588 *
 5589 * ALC882 is almost identical with ALC880 but has cleaner and more flexible
 5590 * configuration.  Each pin widget can choose any input DACs and a mixer.
 5591 * Each ADC is connected from a mixer of all inputs.  This makes possible
 5592 * 6-channel independent captures.
 5593 *
 5594 * In addition, an independent DAC for the multi-playback (not used in this
 5595 * driver yet).
 5596 */
 5597#define ALC882_DIGOUT_NID        0x06
 5598#define ALC882_DIGIN_NID        0x0a
 5599
 5600static struct hda_channel_mode alc882_ch_modes[1] = {
 5601        { 8, NULL }
 5602};
 5603
 5604static hda_nid_t alc882_dac_nids[4] = {
 5605        /* front, rear, clfe, rear_surr */
 5606        0x02, 0x03, 0x04, 0x05
 5607};
 5608
 5609/* identical with ALC880 */
 5610#define alc882_adc_nids                alc880_adc_nids
 5611#define alc882_adc_nids_alt        alc880_adc_nids_alt
 5612
 5613static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
 5614static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
 5615
 5616/* input MUX */
 5617/* FIXME: should be a matrix-type input source selection */
 5618
 5619static struct hda_input_mux alc882_capture_source = {
 5620        .num_items = 4,
 5621        .items = {
 5622                { "Mic", 0x0 },
 5623                { "Front Mic", 0x1 },
 5624                { "Line", 0x2 },
 5625                { "CD", 0x4 },
 5626        },
 5627};
 5628#define alc882_mux_enum_info alc_mux_enum_info
 5629#define alc882_mux_enum_get alc_mux_enum_get
 5630
 5631static int alc882_mux_enum_put(struct snd_kcontrol *kcontrol,
 5632                               struct snd_ctl_elem_value *ucontrol)
 5633{
 5634        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 5635        struct alc_spec *spec = codec->spec;
 5636        const struct hda_input_mux *imux = spec->input_mux;
 5637        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 5638        hda_nid_t nid = spec->capsrc_nids ?
 5639                spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 5640        unsigned int *cur_val = &spec->cur_mux[adc_idx];
 5641        unsigned int i, idx;
 5642
 5643        idx = ucontrol->value.enumerated.item[0];
 5644        if (idx >= imux->num_items)
 5645                idx = imux->num_items - 1;
 5646        if (*cur_val == idx)
 5647                return 0;
 5648        for (i = 0; i < imux->num_items; i++) {
 5649                unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 5650                snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 5651                                         imux->items[i].index,
 5652                                         HDA_AMP_MUTE, v);
 5653        }
 5654        *cur_val = idx;
 5655        return 1;
 5656}
 5657
 5658/*
 5659 * 2ch mode
 5660 */
 5661static struct hda_verb alc882_3ST_ch2_init[] = {
 5662        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
 5663        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 5664        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 5665        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 5666        { } /* end */
 5667};
 5668
 5669/*
 5670 * 6ch mode
 5671 */
 5672static struct hda_verb alc882_3ST_ch6_init[] = {
 5673        { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5674        { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 5675        { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
 5676        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5677        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
 5678        { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
 5679        { } /* end */
 5680};
 5681
 5682static struct hda_channel_mode alc882_3ST_6ch_modes[2] = {
 5683        { 2, alc882_3ST_ch2_init },
 5684        { 6, alc882_3ST_ch6_init },
 5685};
 5686
 5687/*
 5688 * 6ch mode
 5689 */
 5690static struct hda_verb alc882_sixstack_ch6_init[] = {
 5691        { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
 5692        { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5693        { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5694        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5695        { } /* end */
 5696};
 5697
 5698/*
 5699 * 8ch mode
 5700 */
 5701static struct hda_verb alc882_sixstack_ch8_init[] = {
 5702        { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5703        { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5704        { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5705        { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5706        { } /* end */
 5707};
 5708
 5709static struct hda_channel_mode alc882_sixstack_modes[2] = {
 5710        { 6, alc882_sixstack_ch6_init },
 5711        { 8, alc882_sixstack_ch8_init },
 5712};
 5713
 5714/*
 5715 * macbook pro ALC885 can switch LineIn to LineOut without loosing Mic
 5716 */
 5717
 5718/*
 5719 * 2ch mode
 5720 */
 5721static struct hda_verb alc885_mbp_ch2_init[] = {
 5722        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
 5723        { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5724        { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5725        { } /* end */
 5726};
 5727
 5728/*
 5729 * 6ch mode
 5730 */
 5731static struct hda_verb alc885_mbp_ch6_init[] = {
 5732        { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
 5733        { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5734        { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
 5735        { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5736        { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 5737        { } /* end */
 5738};
 5739
 5740static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
 5741        { 2, alc885_mbp_ch2_init },
 5742        { 6, alc885_mbp_ch6_init },
 5743};
 5744
 5745
 5746/* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
 5747 *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
 5748 */
 5749static struct snd_kcontrol_new alc882_base_mixer[] = {
 5750        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 5751        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 5752        HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
 5753        HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
 5754        HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
 5755        HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
 5756        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
 5757        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
 5758        HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
 5759        HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
 5760        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 5761        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 5762        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 5763        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 5764        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 5765        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 5766        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
 5767        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 5768        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 5769        HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
 5770        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 5771        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 5772        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 5773        { } /* end */
 5774};
 5775
 5776static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
 5777        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
 5778        HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
 5779        HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
 5780        HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
 5781        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 5782        HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 5783        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
 5784        HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
 5785        HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
 5786        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
 5787        { } /* end */
 5788};
 5789static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
 5790        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 5791        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 5792        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 5793        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 5794        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 5795        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 5796        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 5797        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
 5798        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 5799        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 5800        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 5801        { } /* end */
 5802};
 5803
 5804static struct snd_kcontrol_new alc882_targa_mixer[] = {
 5805        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 5806        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 5807        HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
 5808        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 5809        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 5810        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 5811        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 5812        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 5813        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 5814        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
 5815        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
 5816        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
 5817        HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
 5818        { } /* end */
 5819};
 5820
 5821/* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
 5822 *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
 5823 */
 5824static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
 5825        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 5826        HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
 5827        HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 5828        HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
 5829        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 5830        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 5831        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 5832        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 5833        HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
 5834        HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
 5835        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 5836        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 5837        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
 5838        { } /* end */
 5839};
 5840
 5841static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
 5842        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 5843        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 5844        HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
 5845        HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
 5846        HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
 5847        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
 5848        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
 5849        HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
 5850        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
 5851        HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
 5852        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x05, HDA_INPUT),
 5853        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x05, HDA_INPUT),
 5854        { } /* end */
 5855};
 5856
 5857static struct snd_kcontrol_new alc882_chmode_mixer[] = {
 5858        {
 5859                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 5860                .name = "Channel Mode",
 5861                .info = alc_ch_mode_info,
 5862                .get = alc_ch_mode_get,
 5863                .put = alc_ch_mode_put,
 5864        },
 5865        { } /* end */
 5866};
 5867
 5868static struct hda_verb alc882_init_verbs[] = {
 5869        /* Front mixer: unmute input/output amp left and right (volume = 0) */
 5870        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5871        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5872        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5873        /* Rear mixer */
 5874        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5875        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5876        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5877        /* CLFE mixer */
 5878        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5879        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5880        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5881        /* Side mixer */
 5882        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5883        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5884        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5885
 5886        /* Front Pin: output 0 (0x0c) */
 5887        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 5888        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5889        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
 5890        /* Rear Pin: output 1 (0x0d) */
 5891        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 5892        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5893        {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
 5894        /* CLFE Pin: output 2 (0x0e) */
 5895        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 5896        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5897        {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
 5898        /* Side Pin: output 3 (0x0f) */
 5899        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 5900        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5901        {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
 5902        /* Mic (rear) pin: input vref at 80% */
 5903        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 5904        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 5905        /* Front Mic pin: input vref at 80% */
 5906        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 5907        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 5908        /* Line In pin: input */
 5909        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 5910        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 5911        /* Line-2 In: Headphone output (output 0 - 0x0c) */
 5912        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 5913        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5914        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
 5915        /* CD pin widget for input */
 5916        {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 5917
 5918        /* FIXME: use matrix-type input source selection */
 5919        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
 5920        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
 5921        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5922        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 5923        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 5924        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 5925        /* Input mixer2 */
 5926        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5927        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 5928        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 5929        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 5930        /* Input mixer3 */
 5931        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5932        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 5933        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 5934        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 5935        /* ADC1: mute amp left and right */
 5936        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5937        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 5938        /* ADC2: mute amp left and right */
 5939        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5940        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
 5941        /* ADC3: mute amp left and right */
 5942        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5943        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 5944
 5945        { }
 5946};
 5947
 5948static struct hda_verb alc882_eapd_verbs[] = {
 5949        /* change to EAPD mode */
 5950        {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
 5951        {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
 5952        { }
 5953};
 5954
 5955/* Mac Pro test */
 5956static struct snd_kcontrol_new alc882_macpro_mixer[] = {
 5957        HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
 5958        HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
 5959        HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
 5960        HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
 5961        HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
 5962        HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
 5963        HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
 5964        { } /* end */
 5965};
 5966
 5967static struct hda_verb alc882_macpro_init_verbs[] = {
 5968        /* Front mixer: unmute input/output amp left and right (volume = 0) */
 5969        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 5970        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 5971        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 5972        /* Front Pin: output 0 (0x0c) */
 5973        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 5974        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5975        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
 5976        /* Front Mic pin: input vref at 80% */
 5977        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 5978        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 5979        /* Speaker:  output */
 5980        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 5981        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5982        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
 5983        /* Headphone output (output 0 - 0x0c) */
 5984        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 5985        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 5986        {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
 5987
 5988        /* FIXME: use matrix-type input source selection */
 5989        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
 5990        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
 5991        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5992        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 5993        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 5994        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 5995        /* Input mixer2 */
 5996        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 5997        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 5998        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 5999        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 6000        /* Input mixer3 */
 6001        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6002        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 6003        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 6004        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 6005        /* ADC1: mute amp left and right */
 6006        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 6007        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 6008        /* ADC2: mute amp left and right */
 6009        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 6010        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
 6011        /* ADC3: mute amp left and right */
 6012        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 6013        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 6014
 6015        { }
 6016};
 6017
 6018/* Macbook Pro rev3 */
 6019static struct hda_verb alc885_mbp3_init_verbs[] = {
 6020        /* Front mixer: unmute input/output amp left and right (volume = 0) */
 6021        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 6022        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 6023        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 6024        /* Rear mixer */
 6025        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 6026        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 6027        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 6028        /* Front Pin: output 0 (0x0c) */
 6029        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 6030        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 6031        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
 6032        /* HP Pin: output 0 (0x0d) */
 6033        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
 6034        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 6035        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
 6036        {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
 6037        /* Mic (rear) pin: input vref at 80% */
 6038        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 6039        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 6040        /* Front Mic pin: input vref at 80% */
 6041        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 6042        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 6043        /* Line In pin: use output 1 when in LineOut mode */
 6044        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 6045        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 6046        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
 6047
 6048        /* FIXME: use matrix-type input source selection */
 6049        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
 6050        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
 6051        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6052        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 6053        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 6054        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 6055        /* Input mixer2 */
 6056        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6057        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 6058        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 6059        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 6060        /* Input mixer3 */
 6061        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6062        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 6063        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 6064        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 6065        /* ADC1: mute amp left and right */
 6066        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 6067        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 6068        /* ADC2: mute amp left and right */
 6069        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 6070        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
 6071        /* ADC3: mute amp left and right */
 6072        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 6073        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 6074
 6075        { }
 6076};
 6077
 6078/* iMac 24 mixer. */
 6079static struct snd_kcontrol_new alc885_imac24_mixer[] = {
 6080        HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
 6081        HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
 6082        { } /* end */
 6083};
 6084
 6085/* iMac 24 init verbs. */
 6086static struct hda_verb alc885_imac24_init_verbs[] = {
 6087        /* Internal speakers: output 0 (0x0c) */
 6088        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 6089        {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 6090        {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
 6091        /* Internal speakers: output 0 (0x0c) */
 6092        {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 6093        {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 6094        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
 6095        /* Headphone: output 0 (0x0c) */
 6096        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 6097        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 6098        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
 6099        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
 6100        /* Front Mic: input vref at 80% */
 6101        {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 6102        {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 6103        { }
 6104};
 6105
 6106/* Toggle speaker-output according to the hp-jack state */
 6107static void alc885_imac24_automute(struct hda_codec *codec)
 6108{
 6109         unsigned int present;
 6110
 6111         present = snd_hda_codec_read(codec, 0x14, 0,
 6112                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 6113        snd_hda_codec_amp_stereo(codec, 0x18, HDA_OUTPUT, 0,
 6114                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 6115        snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
 6116                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 6117}
 6118
 6119/* Processes unsolicited events. */
 6120static void alc885_imac24_unsol_event(struct hda_codec *codec,
 6121                                      unsigned int res)
 6122{
 6123        /* Headphone insertion or removal. */
 6124        if ((res >> 26) == ALC880_HP_EVENT)
 6125                alc885_imac24_automute(codec);
 6126}
 6127
 6128static void alc885_mbp3_automute(struct hda_codec *codec)
 6129{
 6130         unsigned int present;
 6131
 6132         present = snd_hda_codec_read(codec, 0x15, 0,
 6133                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 6134        snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
 6135                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 6136        snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
 6137                                 HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
 6138
 6139}
 6140static void alc885_mbp3_unsol_event(struct hda_codec *codec,
 6141                                    unsigned int res)
 6142{
 6143        /* Headphone insertion or removal. */
 6144        if ((res >> 26) == ALC880_HP_EVENT)
 6145                alc885_mbp3_automute(codec);
 6146}
 6147
 6148
 6149static struct hda_verb alc882_targa_verbs[] = {
 6150        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6151        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 6152
 6153        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 6154        {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 6155
 6156        {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
 6157        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
 6158        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 6159
 6160        {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
 6161        {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 6162        {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 6163        {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 6164        { } /* end */
 6165};
 6166
 6167/* toggle speaker-output according to the hp-jack state */
 6168static void alc882_targa_automute(struct hda_codec *codec)
 6169{
 6170         unsigned int present;
 6171
 6172         present = snd_hda_codec_read(codec, 0x14, 0,
 6173                                     AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 6174        snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
 6175                                 HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 6176        snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
 6177                                  present ? 1 : 3);
 6178}
 6179
 6180static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
 6181{
 6182        /* Looks like the unsol event is incompatible with the standard
 6183         * definition.  4bit tag is placed at 26 bit!
 6184         */
 6185        if (((res >> 26) == ALC880_HP_EVENT)) {
 6186                alc882_targa_automute(codec);
 6187        }
 6188}
 6189
 6190static struct hda_verb alc882_asus_a7j_verbs[] = {
 6191        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6192        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 6193
 6194        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 6195        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 6196        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 6197
 6198        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
 6199        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 6200        {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
 6201
 6202        {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
 6203        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
 6204        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 6205        { } /* end */
 6206};
 6207
 6208static struct hda_verb alc882_asus_a7m_verbs[] = {
 6209        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6210        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 6211
 6212        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 6213        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 6214        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 6215
 6216        {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
 6217        {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 6218        {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
 6219
 6220        {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
 6221        {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
 6222        {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
 6223         { } /* end */
 6224};
 6225
 6226static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
 6227{
 6228        unsigned int gpiostate, gpiomask, gpiodir;
 6229
 6230        gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
 6231                                       AC_VERB_GET_GPIO_DATA, 0);
 6232
 6233        if (!muted)
 6234                gpiostate |= (1 << pin);
 6235        else
 6236                gpiostate &= ~(1 << pin);
 6237
 6238        gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
 6239                                      AC_VERB_GET_GPIO_MASK, 0);
 6240        gpiomask |= (1 << pin);
 6241
 6242        gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
 6243                                     AC_VERB_GET_GPIO_DIRECTION, 0);
 6244        gpiodir |= (1 << pin);
 6245
 6246
 6247        snd_hda_codec_write(codec, codec->afg, 0,
 6248                            AC_VERB_SET_GPIO_MASK, gpiomask);
 6249        snd_hda_codec_write(codec, codec->afg, 0,
 6250                            AC_VERB_SET_GPIO_DIRECTION, gpiodir);
 6251
 6252        msleep(1);
 6253
 6254        snd_hda_codec_write(codec, codec->afg, 0,
 6255                            AC_VERB_SET_GPIO_DATA, gpiostate);
 6256}
 6257
 6258/* set up GPIO at initialization */
 6259static void alc885_macpro_init_hook(struct hda_codec *codec)
 6260{
 6261        alc882_gpio_mute(codec, 0, 0);
 6262        alc882_gpio_mute(codec, 1, 0);
 6263}
 6264
 6265/* set up GPIO and update auto-muting at initialization */
 6266static void alc885_imac24_init_hook(struct hda_codec *codec)
 6267{
 6268        alc885_macpro_init_hook(codec);
 6269        alc885_imac24_automute(codec);
 6270}
 6271
 6272/*
 6273 * generic initialization of ADC, input mixers and output mixers
 6274 */
 6275static struct hda_verb alc882_auto_init_verbs[] = {
 6276        /*
 6277         * Unmute ADC0-2 and set the default input to mic-in
 6278         */
 6279        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 6280        {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6281        {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
 6282        {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6283        {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
 6284        {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6285
 6286        /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
 6287         * mixer widget
 6288         * Note: PASD motherboards uses the Line In 2 as the input for
 6289         * front panel mic (mic 2)
 6290         */
 6291        /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
 6292        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 6293        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 6294        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
 6295        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
 6296        {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
 6297
 6298        /*
 6299         * Set up output mixers (0x0c - 0x0f)
 6300         */
 6301        /* set vol=0 to output mixers */
 6302        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 6303        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 6304        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 6305        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 6306        /* set up input amps for analog loopback */
 6307        /* Amp Indices: DAC = 0, mixer = 1 */
 6308        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6309        {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 6310        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6311        {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 6312        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6313        {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 6314        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6315        {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 6316        {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 6317        {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
 6318
 6319        /* FIXME: use matrix-type input source selection */
 6320        /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
 6321        /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
 6322        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 6323        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
 6324        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
 6325        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
 6326        /* Input mixer2 */
 6327        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 6328        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
 6329        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
 6330        {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
 6331        /* Input mixer3 */
 6332        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
 6333        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
 6334        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
 6335        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
 6336
 6337        { }
 6338};
 6339
 6340/* capture mixer elements */
 6341static struct snd_kcontrol_new alc882_capture_alt_mixer[] = {
 6342        HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
 6343        HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
 6344        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x09, 0x0, HDA_INPUT),
 6345        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x09, 0x0, HDA_INPUT),
 6346        {
 6347                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 6348                /* The multiple "Capture Source" controls confuse alsamixer
 6349                 * So call somewhat different..
 6350                 */
 6351                /* .name = "Capture Source", */
 6352                .name = "Input Source",
 6353                .count = 2,
 6354                .info = alc882_mux_enum_info,
 6355                .get = alc882_mux_enum_get,
 6356                .put = alc882_mux_enum_put,
 6357        },
 6358        { } /* end */
 6359};
 6360
 6361static struct snd_kcontrol_new alc882_capture_mixer[] = {
 6362        HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
 6363        HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
 6364        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT),
 6365        HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT),
 6366        HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT),
 6367        HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT),
 6368        {
 6369                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 6370                /* The multiple "Capture Source" controls confuse alsamixer
 6371                 * So call somewhat different..
 6372                 */
 6373                /* .name = "Capture Source", */
 6374                .name = "Input Source",
 6375                .count = 3,
 6376                .info = alc882_mux_enum_info,
 6377                .get = alc882_mux_enum_get,
 6378                .put = alc882_mux_enum_put,
 6379        },
 6380        { } /* end */
 6381};
 6382
 6383#ifdef CONFIG_SND_HDA_POWER_SAVE
 6384#define alc882_loopbacks        alc880_loopbacks
 6385#endif
 6386
 6387/* pcm configuration: identiacal with ALC880 */
 6388#define alc882_pcm_analog_playback        alc880_pcm_analog_playback
 6389#define alc882_pcm_analog_capture        alc880_pcm_analog_capture
 6390#define alc882_pcm_digital_playback        alc880_pcm_digital_playback
 6391#define alc882_pcm_digital_capture        alc880_pcm_digital_capture
 6392
 6393/*
 6394 * configuration and preset
 6395 */
 6396static const char *alc882_models[ALC882_MODEL_LAST] = {
 6397        [ALC882_3ST_DIG]        = "3stack-dig",
 6398        [ALC882_6ST_DIG]        = "6stack-dig",
 6399        [ALC882_ARIMA]                = "arima",
 6400        [ALC882_W2JC]                = "w2jc",
 6401        [ALC882_TARGA]                = "targa",
 6402        [ALC882_ASUS_A7J]        = "asus-a7j",
 6403        [ALC882_ASUS_A7M]        = "asus-a7m",
 6404        [ALC885_MACPRO]                = "macpro",
 6405        [ALC885_MBP3]                = "mbp3",
 6406        [ALC885_IMAC24]                = "imac24",
 6407        [ALC882_AUTO]                = "auto",
 6408};
 6409
 6410static struct snd_pci_quirk alc882_cfg_tbl[] = {
 6411        SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
 6412        SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
 6413        SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
 6414        SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
 6415        SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
 6416        SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
 6417        SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
 6418        SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
 6419        SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
 6420        SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
 6421        SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
 6422        SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA),
 6423        {}
 6424};
 6425
 6426static struct alc_config_preset alc882_presets[] = {
 6427        [ALC882_3ST_DIG] = {
 6428                .mixers = { alc882_base_mixer },
 6429                .init_verbs = { alc882_init_verbs },
 6430                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6431                .dac_nids = alc882_dac_nids,
 6432                .dig_out_nid = ALC882_DIGOUT_NID,
 6433                .dig_in_nid = ALC882_DIGIN_NID,
 6434                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
 6435                .channel_mode = alc882_ch_modes,
 6436                .need_dac_fix = 1,
 6437                .input_mux = &alc882_capture_source,
 6438        },
 6439        [ALC882_6ST_DIG] = {
 6440                .mixers = { alc882_base_mixer, alc882_chmode_mixer },
 6441                .init_verbs = { alc882_init_verbs },
 6442                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6443                .dac_nids = alc882_dac_nids,
 6444                .dig_out_nid = ALC882_DIGOUT_NID,
 6445                .dig_in_nid = ALC882_DIGIN_NID,
 6446                .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
 6447                .channel_mode = alc882_sixstack_modes,
 6448                .input_mux = &alc882_capture_source,
 6449        },
 6450        [ALC882_ARIMA] = {
 6451                .mixers = { alc882_base_mixer, alc882_chmode_mixer },
 6452                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs },
 6453                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6454                .dac_nids = alc882_dac_nids,
 6455                .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
 6456                .channel_mode = alc882_sixstack_modes,
 6457                .input_mux = &alc882_capture_source,
 6458        },
 6459        [ALC882_W2JC] = {
 6460                .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
 6461                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
 6462                                alc880_gpio1_init_verbs },
 6463                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6464                .dac_nids = alc882_dac_nids,
 6465                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
 6466                .channel_mode = alc880_threestack_modes,
 6467                .need_dac_fix = 1,
 6468                .input_mux = &alc882_capture_source,
 6469                .dig_out_nid = ALC882_DIGOUT_NID,
 6470        },
 6471        [ALC885_MBP3] = {
 6472                .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
 6473                .init_verbs = { alc885_mbp3_init_verbs,
 6474                                alc880_gpio1_init_verbs },
 6475                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6476                .dac_nids = alc882_dac_nids,
 6477                .channel_mode = alc885_mbp_6ch_modes,
 6478                .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
 6479                .input_mux = &alc882_capture_source,
 6480                .dig_out_nid = ALC882_DIGOUT_NID,
 6481                .dig_in_nid = ALC882_DIGIN_NID,
 6482                .unsol_event = alc885_mbp3_unsol_event,
 6483                .init_hook = alc885_mbp3_automute,
 6484        },
 6485        [ALC885_MACPRO] = {
 6486                .mixers = { alc882_macpro_mixer },
 6487                .init_verbs = { alc882_macpro_init_verbs },
 6488                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6489                .dac_nids = alc882_dac_nids,
 6490                .dig_out_nid = ALC882_DIGOUT_NID,
 6491                .dig_in_nid = ALC882_DIGIN_NID,
 6492                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
 6493                .channel_mode = alc882_ch_modes,
 6494                .input_mux = &alc882_capture_source,
 6495                .init_hook = alc885_macpro_init_hook,
 6496        },
 6497        [ALC885_IMAC24] = {
 6498                .mixers = { alc885_imac24_mixer },
 6499                .init_verbs = { alc885_imac24_init_verbs },
 6500                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6501                .dac_nids = alc882_dac_nids,
 6502                .dig_out_nid = ALC882_DIGOUT_NID,
 6503                .dig_in_nid = ALC882_DIGIN_NID,
 6504                .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
 6505                .channel_mode = alc882_ch_modes,
 6506                .input_mux = &alc882_capture_source,
 6507                .unsol_event = alc885_imac24_unsol_event,
 6508                .init_hook = alc885_imac24_init_hook,
 6509        },
 6510        [ALC882_TARGA] = {
 6511                .mixers = { alc882_targa_mixer, alc882_chmode_mixer,
 6512                            alc882_capture_mixer },
 6513                .init_verbs = { alc882_init_verbs, alc882_targa_verbs},
 6514                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6515                .dac_nids = alc882_dac_nids,
 6516                .dig_out_nid = ALC882_DIGOUT_NID,
 6517                .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
 6518                .adc_nids = alc882_adc_nids,
 6519                .capsrc_nids = alc882_capsrc_nids,
 6520                .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
 6521                .channel_mode = alc882_3ST_6ch_modes,
 6522                .need_dac_fix = 1,
 6523                .input_mux = &alc882_capture_source,
 6524                .unsol_event = alc882_targa_unsol_event,
 6525                .init_hook = alc882_targa_automute,
 6526        },
 6527        [ALC882_ASUS_A7J] = {
 6528                .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer,
 6529                            alc882_capture_mixer },
 6530                .init_verbs = { alc882_init_verbs, alc882_asus_a7j_verbs},
 6531                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6532                .dac_nids = alc882_dac_nids,
 6533                .dig_out_nid = ALC882_DIGOUT_NID,
 6534                .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
 6535                .adc_nids = alc882_adc_nids,
 6536                .capsrc_nids = alc882_capsrc_nids,
 6537                .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
 6538                .channel_mode = alc882_3ST_6ch_modes,
 6539                .need_dac_fix = 1,
 6540                .input_mux = &alc882_capture_source,
 6541        },
 6542        [ALC882_ASUS_A7M] = {
 6543                .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
 6544                .init_verbs = { alc882_init_verbs, alc882_eapd_verbs,
 6545                                alc880_gpio1_init_verbs,
 6546                                alc882_asus_a7m_verbs },
 6547                .num_dacs = ARRAY_SIZE(alc882_dac_nids),
 6548                .dac_nids = alc882_dac_nids,
 6549                .dig_out_nid = ALC882_DIGOUT_NID,
 6550                .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
 6551                .channel_mode = alc880_threestack_modes,
 6552                .need_dac_fix = 1,
 6553                .input_mux = &alc882_capture_source,
 6554        },
 6555};
 6556
 6557
 6558/*
 6559 * Pin config fixes
 6560 */
 6561enum {
 6562        PINFIX_ABIT_AW9D_MAX
 6563};
 6564
 6565static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
 6566        { 0x15, 0x01080104 }, /* side */
 6567        { 0x16, 0x01011012 }, /* rear */
 6568        { 0x17, 0x01016011 }, /* clfe */
 6569        { }
 6570};
 6571
 6572static const struct alc_pincfg *alc882_pin_fixes[] = {
 6573        [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
 6574};
 6575
 6576static struct snd_pci_quirk alc882_pinfix_tbl[] = {
 6577        SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
 6578        {}
 6579};
 6580
 6581/*
 6582 * BIOS auto configuration
 6583 */
 6584static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
 6585                                              hda_nid_t nid, int pin_type,
 6586                                              int dac_idx)
 6587{
 6588        /* set as output */
 6589        struct alc_spec *spec = codec->spec;
 6590        int idx;
 6591
 6592        alc_set_pin_output(codec, nid, pin_type);
 6593        if (spec->multiout.dac_nids[dac_idx] == 0x25)
 6594                idx = 4;
 6595        else
 6596                idx = spec->multiout.dac_nids[dac_idx] - 2;
 6597        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
 6598
 6599}
 6600
 6601static void alc882_auto_init_multi_out(struct hda_codec *codec)
 6602{
 6603        struct alc_spec *spec = codec->spec;
 6604        int i;
 6605
 6606        alc_subsystem_id(codec, 0x15, 0x1b, 0x14);
 6607        for (i = 0; i <= HDA_SIDE; i++) {
 6608                hda_nid_t nid = spec->autocfg.line_out_pins[i];
 6609                int pin_type = get_pin_type(spec->autocfg.line_out_type);
 6610                if (nid)
 6611                        alc882_auto_set_output_and_unmute(codec, nid, pin_type,
 6612                                                          i);
 6613        }
 6614}
 6615
 6616static void alc882_auto_init_hp_out(struct hda_codec *codec)
 6617{
 6618        struct alc_spec *spec = codec->spec;
 6619        hda_nid_t pin;
 6620
 6621        pin = spec->autocfg.hp_pins[0];
 6622        if (pin) /* connect to front */
 6623                /* use dac 0 */
 6624                alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
 6625        pin = spec->autocfg.speaker_pins[0];
 6626        if (pin)
 6627                alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
 6628}
 6629
 6630#define alc882_is_input_pin(nid)        alc880_is_input_pin(nid)
 6631#define ALC882_PIN_CD_NID                ALC880_PIN_CD_NID
 6632
 6633static void alc882_auto_init_analog_input(struct hda_codec *codec)
 6634{
 6635        struct alc_spec *spec = codec->spec;
 6636        int i;
 6637
 6638        for (i = 0; i < AUTO_PIN_LAST; i++) {
 6639                hda_nid_t nid = spec->autocfg.input_pins[i];
 6640                unsigned int vref;
 6641                if (!nid)
 6642                        continue;
 6643                vref = PIN_IN;
 6644                if (1 /*i <= AUTO_PIN_FRONT_MIC*/) {
 6645                        unsigned int pincap;
 6646                        pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
 6647                        if ((pincap >> AC_PINCAP_VREF_SHIFT) &
 6648                            AC_PINCAP_VREF_80)
 6649                                vref = PIN_VREF80;
 6650                }
 6651                snd_hda_codec_write(codec, nid, 0,
 6652                                    AC_VERB_SET_PIN_WIDGET_CONTROL, vref);
 6653                if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
 6654                        snd_hda_codec_write(codec, nid, 0,
 6655                                            AC_VERB_SET_AMP_GAIN_MUTE,
 6656                                            AMP_OUT_MUTE);
 6657        }
 6658}
 6659
 6660static void alc882_auto_init_input_src(struct hda_codec *codec)