pci/hda/patch_sigmatel.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Universal Interface for Intel High Definition Audio Codec
0004  *
0005  * HD audio interface patch for SigmaTel STAC92xx
0006  *
0007  * Copyright (c) 2005 Embedded Alley Solutions, Inc.
0008  * Matt Porter <mporter@embeddedalley.com>
0009  *
0010  * Based on patch_cmedia.c and patch_realtek.c
0011  * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
0012  */
0013
0014 #include <linux/init.h>
0015 #include <linux/delay.h>
0016 #include <linux/slab.h>
0017 #include <linux/pci.h>
0018 #include <linux/dmi.h>
0019 #include <linux/module.h>
0020 #include <sound/core.h>
0021 #include <sound/jack.h>
0022 #include <sound/hda_codec.h>
0023 #include "hda_local.h"
0024 #include "hda_auto_parser.h"
0025 #include "hda_beep.h"
0026 #include "hda_jack.h"
0027 #include "hda_generic.h"
0028
0029 enum {
0030     STAC_REF,
0031     STAC_9200_OQO,
0032     STAC_9200_DELL_D21,
0033     STAC_9200_DELL_D22,
0034     STAC_9200_DELL_D23,
0035     STAC_9200_DELL_M21,
0036     STAC_9200_DELL_M22,
0037     STAC_9200_DELL_M23,
0038     STAC_9200_DELL_M24,
0039     STAC_9200_DELL_M25,
0040     STAC_9200_DELL_M26,
0041     STAC_9200_DELL_M27,
0042     STAC_9200_M4,
0043     STAC_9200_M4_2,
0044     STAC_9200_PANASONIC,
0045     STAC_9200_EAPD_INIT,
0046     STAC_9200_MODELS
0047 };
0048
0049 enum {
0050     STAC_9205_REF,
0051     STAC_9205_DELL_M42,
0052     STAC_9205_DELL_M43,
0053     STAC_9205_DELL_M44,
0054     STAC_9205_EAPD,
0055     STAC_9205_MODELS
0056 };
0057
0058 enum {
0059     STAC_92HD73XX_NO_JD, /* no jack-detection */
0060     STAC_92HD73XX_REF,
0061     STAC_92HD73XX_INTEL,
0062     STAC_DELL_M6_AMIC,
0063     STAC_DELL_M6_DMIC,
0064     STAC_DELL_M6_BOTH,
0065     STAC_DELL_EQ,
0066     STAC_ALIENWARE_M17X,
0067     STAC_ELO_VUPOINT_15MX,
0068     STAC_92HD89XX_HP_FRONT_JACK,
0069     STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK,
0070     STAC_92HD73XX_ASUS_MOBO,
0071     STAC_92HD73XX_MODELS
0072 };
0073
0074 enum {
0075     STAC_92HD83XXX_REF,
0076     STAC_92HD83XXX_PWR_REF,
0077     STAC_DELL_S14,
0078     STAC_DELL_VOSTRO_3500,
0079     STAC_92HD83XXX_HP_cNB11_INTQUAD,
0080     STAC_HP_DV7_4000,
0081     STAC_HP_ZEPHYR,
0082     STAC_92HD83XXX_HP_LED,
0083     STAC_92HD83XXX_HP_INV_LED,
0084     STAC_92HD83XXX_HP_MIC_LED,
0085     STAC_HP_LED_GPIO10,
0086     STAC_92HD83XXX_HEADSET_JACK,
0087     STAC_92HD83XXX_HP,
0088     STAC_HP_ENVY_BASS,
0089     STAC_HP_BNB13_EQ,
0090     STAC_HP_ENVY_TS_BASS,
0091     STAC_HP_ENVY_TS_DAC_BIND,
0092     STAC_92HD83XXX_GPIO10_EAPD,
0093     STAC_92HD83XXX_MODELS
0094 };
0095
0096 enum {
0097     STAC_92HD71BXX_REF,
0098     STAC_DELL_M4_1,
0099     STAC_DELL_M4_2,
0100     STAC_DELL_M4_3,
0101     STAC_HP_M4,
0102     STAC_HP_DV4,
0103     STAC_HP_DV5,
0104     STAC_HP_HDX,
0105     STAC_92HD71BXX_HP,
0106     STAC_92HD71BXX_NO_DMIC,
0107     STAC_92HD71BXX_NO_SMUX,
0108     STAC_92HD71BXX_MODELS
0109 };
0110
0111 enum {
0112     STAC_92HD95_HP_LED,
0113     STAC_92HD95_HP_BASS,
0114     STAC_92HD95_MODELS
0115 };
0116
0117 enum {
0118     STAC_925x_REF,
0119     STAC_M1,
0120     STAC_M1_2,
0121     STAC_M2,
0122     STAC_M2_2,
0123     STAC_M3,
0124     STAC_M5,
0125     STAC_M6,
0126     STAC_925x_MODELS
0127 };
0128
0129 enum {
0130     STAC_D945_REF,
0131     STAC_D945GTP3,
0132     STAC_D945GTP5,
0133     STAC_INTEL_MAC_V1,
0134     STAC_INTEL_MAC_V2,
0135     STAC_INTEL_MAC_V3,
0136     STAC_INTEL_MAC_V4,
0137     STAC_INTEL_MAC_V5,
0138     STAC_INTEL_MAC_AUTO,
0139     STAC_ECS_202,
0140     STAC_922X_DELL_D81,
0141     STAC_922X_DELL_D82,
0142     STAC_922X_DELL_M81,
0143     STAC_922X_DELL_M82,
0144     STAC_922X_INTEL_MAC_GPIO,
0145     STAC_922X_MODELS
0146 };
0147
0148 enum {
0149     STAC_D965_REF_NO_JD, /* no jack-detection */
0150     STAC_D965_REF,
0151     STAC_D965_3ST,
0152     STAC_D965_5ST,
0153     STAC_D965_5ST_NO_FP,
0154     STAC_D965_VERBS,
0155     STAC_DELL_3ST,
0156     STAC_DELL_BIOS,
0157     STAC_NEMO_DEFAULT,
0158     STAC_DELL_BIOS_AMIC,
0159     STAC_DELL_BIOS_SPDIF,
0160     STAC_927X_DELL_DMIC,
0161     STAC_927X_VOLKNOB,
0162     STAC_927X_MODELS
0163 };
0164
0165 enum {
0166     STAC_9872_VAIO,
0167     STAC_9872_MODELS
0168 };
0169
0170 struct sigmatel_spec {
0171     struct hda_gen_spec gen;
0172
0173     unsigned int eapd_switch: 1;
0174     unsigned int linear_tone_beep:1;
0175     unsigned int headset_jack:1; /* 4-pin headset jack (hp + mono mic) */
0176     unsigned int volknob_init:1; /* special volume-knob initialization */
0177     unsigned int powerdown_adcs:1;
0178     unsigned int have_spdif_mux:1;
0179
0180     /* gpio lines */
0181     unsigned int eapd_mask;
0182     unsigned int gpio_mask;
0183     unsigned int gpio_dir;
0184     unsigned int gpio_data;
0185     unsigned int gpio_mute;
0186     unsigned int gpio_led;
0187     unsigned int gpio_led_polarity;
0188     unsigned int vref_mute_led_nid; /* pin NID for mute-LED vref control */
0189     unsigned int vref_led;
0190     int default_polarity;
0191
0192     unsigned int mic_mute_led_gpio; /* capture mute LED GPIO */
0193     unsigned int mic_enabled; /* current mic mute state (bitmask) */
0194
0195     /* stream */
0196     unsigned int stream_delay;
0197
0198     /* analog loopback */
0199     const struct snd_kcontrol_new *aloopback_ctl;
0200     unsigned int aloopback;
0201     unsigned char aloopback_mask;
0202     unsigned char aloopback_shift;
0203
0204     /* power management */
0205     unsigned int power_map_bits;
0206     unsigned int num_pwrs;
0207     const hda_nid_t *pwr_nids;
0208     unsigned int active_adcs;
0209
0210     /* beep widgets */
0211     hda_nid_t anabeep_nid;
0212     bool beep_power_on;
0213
0214     /* SPDIF-out mux */
0215     const char * const *spdif_labels;
0216     struct hda_input_mux spdif_mux;
0217     unsigned int cur_smux[2];
0218 };
0219
0220 #define AC_VERB_IDT_SET_POWER_MAP   0x7ec
0221 #define AC_VERB_IDT_GET_POWER_MAP   0xfec
0222
0223 static const hda_nid_t stac92hd73xx_pwr_nids[8] = {
0224     0x0a, 0x0b, 0x0c, 0xd, 0x0e,
0225     0x0f, 0x10, 0x11
0226 };
0227
0228 static const hda_nid_t stac92hd83xxx_pwr_nids[7] = {
0229     0x0a, 0x0b, 0x0c, 0xd, 0x0e,
0230     0x0f, 0x10
0231 };
0232
0233 static const hda_nid_t stac92hd71bxx_pwr_nids[3] = {
0234     0x0a, 0x0d, 0x0f
0235 };
0236
0237
0238 /*
0239  * PCM hooks
0240  */
0241 static void stac_playback_pcm_hook(struct hda_pcm_stream *hinfo,
0242                    struct hda_codec *codec,
0243                    struct snd_pcm_substream *substream,
0244                    int action)
0245 {
0246     struct sigmatel_spec *spec = codec->spec;
0247     if (action == HDA_GEN_PCM_ACT_OPEN && spec->stream_delay)
0248         msleep(spec->stream_delay);
0249 }
0250
0251 static void stac_capture_pcm_hook(struct hda_pcm_stream *hinfo,
0252                   struct hda_codec *codec,
0253                   struct snd_pcm_substream *substream,
0254                   int action)
0255 {
0256     struct sigmatel_spec *spec = codec->spec;
0257     int i, idx = 0;
0258
0259     if (!spec->powerdown_adcs)
0260         return;
0261
0262     for (i = 0; i < spec->gen.num_all_adcs; i++) {
0263         if (spec->gen.all_adcs[i] == hinfo->nid) {
0264             idx = i;
0265             break;
0266         }
0267     }
0268
0269     switch (action) {
0270     case HDA_GEN_PCM_ACT_OPEN:
0271         msleep(40);
0272         snd_hda_codec_write(codec, hinfo->nid, 0,
0273                     AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
0274         spec->active_adcs |= (1 << idx);
0275         break;
0276     case HDA_GEN_PCM_ACT_CLOSE:
0277         snd_hda_codec_write(codec, hinfo->nid, 0,
0278                     AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
0279         spec->active_adcs &= ~(1 << idx);
0280         break;
0281     }
0282 }
0283
0284 /*
0285  * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
0286  * funky external mute control using GPIO pins.
0287  */
0288
0289 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
0290               unsigned int dir_mask, unsigned int data)
0291 {
0292     unsigned int gpiostate, gpiomask, gpiodir;
0293     hda_nid_t fg = codec->core.afg;
0294
0295     codec_dbg(codec, "%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data);
0296
0297     gpiostate = snd_hda_codec_read(codec, fg, 0,
0298                        AC_VERB_GET_GPIO_DATA, 0);
0299     gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
0300
0301     gpiomask = snd_hda_codec_read(codec, fg, 0,
0302                       AC_VERB_GET_GPIO_MASK, 0);
0303     gpiomask |= mask;
0304
0305     gpiodir = snd_hda_codec_read(codec, fg, 0,
0306                      AC_VERB_GET_GPIO_DIRECTION, 0);
0307     gpiodir |= dir_mask;
0308
0309     /* Configure GPIOx as CMOS */
0310     snd_hda_codec_write(codec, fg, 0, 0x7e7, 0);
0311
0312     snd_hda_codec_write(codec, fg, 0,
0313                 AC_VERB_SET_GPIO_MASK, gpiomask);
0314     snd_hda_codec_read(codec, fg, 0,
0315                AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
0316
0317     msleep(1);
0318
0319     snd_hda_codec_read(codec, fg, 0,
0320                AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
0321 }
0322
0323 /* hook for controlling mic-mute LED GPIO */
0324 static int stac_capture_led_update(struct led_classdev *led_cdev,
0325                    enum led_brightness brightness)
0326 {
0327     struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
0328     struct sigmatel_spec *spec = codec->spec;
0329
0330     if (brightness)
0331         spec->gpio_data |= spec->mic_mute_led_gpio;
0332     else
0333         spec->gpio_data &= ~spec->mic_mute_led_gpio;
0334     stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
0335     return 0;
0336 }
0337
0338 static int stac_vrefout_set(struct hda_codec *codec,
0339                     hda_nid_t nid, unsigned int new_vref)
0340 {
0341     int error, pinctl;
0342
0343     codec_dbg(codec, "%s, nid %x ctl %x\n", __func__, nid, new_vref);
0344     pinctl = snd_hda_codec_read(codec, nid, 0,
0345                 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
0346
0347     if (pinctl < 0)
0348         return pinctl;
0349
0350     pinctl &= 0xff;
0351     pinctl &= ~AC_PINCTL_VREFEN;
0352     pinctl |= (new_vref & AC_PINCTL_VREFEN);
0353
0354     error = snd_hda_set_pin_ctl_cache(codec, nid, pinctl);
0355     if (error < 0)
0356         return error;
0357
0358     return 1;
0359 }
0360
0361 /* prevent codec AFG to D3 state when vref-out pin is used for mute LED */
0362 /* this hook is set in stac_setup_gpio() */
0363 static unsigned int stac_vref_led_power_filter(struct hda_codec *codec,
0364                            hda_nid_t nid,
0365                            unsigned int power_state)
0366 {
0367     if (nid == codec->core.afg && power_state == AC_PWRST_D3)
0368         return AC_PWRST_D1;
0369     return snd_hda_gen_path_power_filter(codec, nid, power_state);
0370 }
0371
0372 /* update mute-LED accoring to the master switch */
0373 static void stac_update_led_status(struct hda_codec *codec, bool muted)
0374 {
0375     struct sigmatel_spec *spec = codec->spec;
0376
0377     if (!spec->gpio_led)
0378         return;
0379
0380     /* LED state is inverted on these systems */
0381     if (spec->gpio_led_polarity)
0382         muted = !muted;
0383
0384     if (!spec->vref_mute_led_nid) {
0385         if (muted)
0386             spec->gpio_data |= spec->gpio_led;
0387         else
0388             spec->gpio_data &= ~spec->gpio_led;
0389         stac_gpio_set(codec, spec->gpio_mask,
0390                 spec->gpio_dir, spec->gpio_data);
0391     } else {
0392         spec->vref_led = muted ? AC_PINCTL_VREF_50 : AC_PINCTL_VREF_GRD;
0393         stac_vrefout_set(codec, spec->vref_mute_led_nid,
0394                  spec->vref_led);
0395     }
0396 }
0397
0398 /* vmaster hook to update mute LED */
0399 static int stac_vmaster_hook(struct led_classdev *led_cdev,
0400                  enum led_brightness brightness)
0401 {
0402     struct hda_codec *codec = dev_to_hda_codec(led_cdev->dev->parent);
0403
0404     stac_update_led_status(codec, brightness);
0405     return 0;
0406 }
0407
0408 /* automute hook to handle GPIO mute and EAPD updates */
0409 static void stac_update_outputs(struct hda_codec *codec)
0410 {
0411     struct sigmatel_spec *spec = codec->spec;
0412
0413     if (spec->gpio_mute)
0414         spec->gen.master_mute =
0415             !(snd_hda_codec_read(codec, codec->core.afg, 0,
0416                 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
0417
0418     snd_hda_gen_update_outputs(codec);
0419
0420     if (spec->eapd_mask && spec->eapd_switch) {
0421         unsigned int val = spec->gpio_data;
0422         if (spec->gen.speaker_muted)
0423             val &= ~spec->eapd_mask;
0424         else
0425             val |= spec->eapd_mask;
0426         if (spec->gpio_data != val) {
0427             spec->gpio_data = val;
0428             stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir,
0429                       val);
0430         }
0431     }
0432 }
0433
0434 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
0435                   bool enable, bool do_write)
0436 {
0437     struct sigmatel_spec *spec = codec->spec;
0438     unsigned int idx, val;
0439
0440     for (idx = 0; idx < spec->num_pwrs; idx++) {
0441         if (spec->pwr_nids[idx] == nid)
0442             break;
0443     }
0444     if (idx >= spec->num_pwrs)
0445         return;
0446
0447     idx = 1 << idx;
0448
0449     val = spec->power_map_bits;
0450     if (enable)
0451         val &= ~idx;
0452     else
0453         val |= idx;
0454
0455     /* power down unused output ports */
0456     if (val != spec->power_map_bits) {
0457         spec->power_map_bits = val;
0458         if (do_write)
0459             snd_hda_codec_write(codec, codec->core.afg, 0,
0460                         AC_VERB_IDT_SET_POWER_MAP, val);
0461     }
0462 }
0463
0464 /* update power bit per jack plug/unplug */
0465 static void jack_update_power(struct hda_codec *codec,
0466                   struct hda_jack_callback *jack)
0467 {
0468     struct sigmatel_spec *spec = codec->spec;
0469     int i;
0470
0471     if (!spec->num_pwrs)
0472         return;
0473
0474     if (jack && jack->nid) {
0475         stac_toggle_power_map(codec, jack->nid,
0476                       snd_hda_jack_detect(codec, jack->nid),
0477                       true);
0478         return;
0479     }
0480
0481     /* update all jacks */
0482     for (i = 0; i < spec->num_pwrs; i++) {
0483         hda_nid_t nid = spec->pwr_nids[i];
0484         if (!snd_hda_jack_tbl_get(codec, nid))
0485             continue;
0486         stac_toggle_power_map(codec, nid,
0487                       snd_hda_jack_detect(codec, nid),
0488                       false);
0489     }
0490
0491     snd_hda_codec_write(codec, codec->core.afg, 0,
0492                 AC_VERB_IDT_SET_POWER_MAP,
0493                 spec->power_map_bits);
0494 }
0495
0496 static void stac_vref_event(struct hda_codec *codec,
0497                 struct hda_jack_callback *event)
0498 {
0499     unsigned int data;
0500
0501     data = snd_hda_codec_read(codec, codec->core.afg, 0,
0502                   AC_VERB_GET_GPIO_DATA, 0);
0503     /* toggle VREF state based on GPIOx status */
0504     snd_hda_codec_write(codec, codec->core.afg, 0, 0x7e0,
0505                 !!(data & (1 << event->private_data)));
0506 }
0507
0508 /* initialize the power map and enable the power event to jacks that
0509  * haven't been assigned to automute
0510  */
0511 static void stac_init_power_map(struct hda_codec *codec)
0512 {
0513     struct sigmatel_spec *spec = codec->spec;
0514     int i;
0515
0516     for (i = 0; i < spec->num_pwrs; i++)  {
0517         hda_nid_t nid = spec->pwr_nids[i];
0518         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
0519         def_conf = get_defcfg_connect(def_conf);
0520         if (def_conf == AC_JACK_PORT_COMPLEX &&
0521             spec->vref_mute_led_nid != nid &&
0522             is_jack_detectable(codec, nid)) {
0523             snd_hda_jack_detect_enable_callback(codec, nid,
0524                                 jack_update_power);
0525         } else {
0526             if (def_conf == AC_JACK_PORT_NONE)
0527                 stac_toggle_power_map(codec, nid, false, false);
0528             else
0529                 stac_toggle_power_map(codec, nid, true, false);
0530         }
0531     }
0532 }
0533
0534 /*
0535  */
0536
0537 static inline bool get_int_hint(struct hda_codec *codec, const char *key,
0538                 int *valp)
0539 {
0540     return !snd_hda_get_int_hint(codec, key, valp);
0541 }
0542
0543 /* override some hints from the hwdep entry */
0544 static void stac_store_hints(struct hda_codec *codec)
0545 {
0546     struct sigmatel_spec *spec = codec->spec;
0547     int val;
0548
0549     if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
0550         spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
0551             spec->gpio_mask;
0552     }
0553     if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
0554         spec->gpio_dir &= spec->gpio_mask;
0555     if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
0556         spec->gpio_data &= spec->gpio_mask;
0557     if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
0558         spec->eapd_mask &= spec->gpio_mask;
0559     if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
0560         spec->gpio_mute &= spec->gpio_mask;
0561     val = snd_hda_get_bool_hint(codec, "eapd_switch");
0562     if (val >= 0)
0563         spec->eapd_switch = val;
0564 }
0565
0566 /*
0567  * loopback controls
0568  */
0569
0570 #define stac_aloopback_info snd_ctl_boolean_mono_info
0571
0572 static int stac_aloopback_get(struct snd_kcontrol *kcontrol,
0573                   struct snd_ctl_elem_value *ucontrol)
0574 {
0575     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
0576     unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
0577     struct sigmatel_spec *spec = codec->spec;
0578
0579     ucontrol->value.integer.value[0] = !!(spec->aloopback &
0580                           (spec->aloopback_mask << idx));
0581     return 0;
0582 }
0583
0584 static int stac_aloopback_put(struct snd_kcontrol *kcontrol,
0585                   struct snd_ctl_elem_value *ucontrol)
0586 {
0587     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
0588     struct sigmatel_spec *spec = codec->spec;
0589     unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
0590     unsigned int dac_mode;
0591     unsigned int val, idx_val;
0592
0593     idx_val = spec->aloopback_mask << idx;
0594     if (ucontrol->value.integer.value[0])
0595         val = spec->aloopback | idx_val;
0596     else
0597         val = spec->aloopback & ~idx_val;
0598     if (spec->aloopback == val)
0599         return 0;
0600
0601     spec->aloopback = val;
0602
0603     /* Only return the bits defined by the shift value of the
0604      * first two bytes of the mask
0605      */
0606     dac_mode = snd_hda_codec_read(codec, codec->core.afg, 0,
0607                       kcontrol->private_value & 0xFFFF, 0x0);
0608     dac_mode >>= spec->aloopback_shift;
0609
0610     if (spec->aloopback & idx_val) {
0611         snd_hda_power_up(codec);
0612         dac_mode |= idx_val;
0613     } else {
0614         snd_hda_power_down(codec);
0615         dac_mode &= ~idx_val;
0616     }
0617
0618     snd_hda_codec_write_cache(codec, codec->core.afg, 0,
0619         kcontrol->private_value >> 16, dac_mode);
0620
0621     return 1;
0622 }
0623
0624 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
0625     { \
0626         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
0627         .name  = "Analog Loopback", \
0628         .count = cnt, \
0629         .info  = stac_aloopback_info, \
0630         .get   = stac_aloopback_get, \
0631         .put   = stac_aloopback_put, \
0632         .private_value = verb_read | (verb_write << 16), \
0633     }
0634
0635 /*
0636  * Mute LED handling on HP laptops
0637  */
0638
0639 /* check whether it's a HP laptop with a docking port */
0640 static bool hp_bnb2011_with_dock(struct hda_codec *codec)
0641 {
0642     if (codec->core.vendor_id != 0x111d7605 &&
0643         codec->core.vendor_id != 0x111d76d1)
0644         return false;
0645
0646     switch (codec->core.subsystem_id) {
0647     case 0x103c1618:
0648     case 0x103c1619:
0649     case 0x103c161a:
0650     case 0x103c161b:
0651     case 0x103c161c:
0652     case 0x103c161d:
0653     case 0x103c161e:
0654     case 0x103c161f:
0655
0656     case 0x103c162a:
0657     case 0x103c162b:
0658
0659     case 0x103c1630:
0660     case 0x103c1631:
0661
0662     case 0x103c1633:
0663     case 0x103c1634:
0664     case 0x103c1635:
0665
0666     case 0x103c3587:
0667     case 0x103c3588:
0668     case 0x103c3589:
0669     case 0x103c358a:
0670
0671     case 0x103c3667:
0672     case 0x103c3668:
0673     case 0x103c3669:
0674
0675         return true;
0676     }
0677     return false;
0678 }
0679
0680 static bool hp_blike_system(u32 subsystem_id)
0681 {
0682     switch (subsystem_id) {
0683     case 0x103c1473: /* HP ProBook 6550b */
0684     case 0x103c1520:
0685     case 0x103c1521:
0686     case 0x103c1523:
0687     case 0x103c1524:
0688     case 0x103c1525:
0689     case 0x103c1722:
0690     case 0x103c1723:
0691     case 0x103c1724:
0692     case 0x103c1725:
0693     case 0x103c1726:
0694     case 0x103c1727:
0695     case 0x103c1728:
0696     case 0x103c1729:
0697     case 0x103c172a:
0698     case 0x103c172b:
0699     case 0x103c307e:
0700     case 0x103c307f:
0701     case 0x103c3080:
0702     case 0x103c3081:
0703     case 0x103c7007:
0704     case 0x103c7008:
0705         return true;
0706     }
0707     return false;
0708 }
0709
0710 static void set_hp_led_gpio(struct hda_codec *codec)
0711 {
0712     struct sigmatel_spec *spec = codec->spec;
0713     unsigned int gpio;
0714
0715     if (spec->gpio_led)
0716         return;
0717
0718     gpio = snd_hda_param_read(codec, codec->core.afg, AC_PAR_GPIO_CAP);
0719     gpio &= AC_GPIO_IO_COUNT;
0720     if (gpio > 3)
0721         spec->gpio_led = 0x08; /* GPIO 3 */
0722     else
0723         spec->gpio_led = 0x01; /* GPIO 0 */
0724 }
0725
0726 /*
0727  * This method searches for the mute LED GPIO configuration
0728  * provided as OEM string in SMBIOS. The format of that string
0729  * is HP_Mute_LED_P_G or HP_Mute_LED_P
0730  * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
0731  * that corresponds to the NOT muted state of the master volume
0732  * and G is the index of the GPIO to use as the mute LED control (0..9)
0733  * If _G portion is missing it is assigned based on the codec ID
0734  *
0735  * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
0736  * or  HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
0737  *
0738  *
0739  * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
0740  * SMBIOS - at least the ones I have seen do not have them - which include
0741  * my own system (HP Pavilion dv6-1110ax) and my cousin's
0742  * HP Pavilion dv9500t CTO.
0743  * Need more information on whether it is true across the entire series.
0744  * -- kunal
0745  */
0746 static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity)
0747 {
0748     struct sigmatel_spec *spec = codec->spec;
0749     const struct dmi_device *dev = NULL;
0750
0751     if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
0752         get_int_hint(codec, "gpio_led_polarity",
0753                  &spec->gpio_led_polarity);
0754         return 1;
0755     }
0756
0757     while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
0758         if (sscanf(dev->name, "HP_Mute_LED_%u_%x",
0759                &spec->gpio_led_polarity,
0760                &spec->gpio_led) == 2) {
0761             unsigned int max_gpio;
0762             max_gpio = snd_hda_param_read(codec, codec->core.afg,
0763                               AC_PAR_GPIO_CAP);
0764             max_gpio &= AC_GPIO_IO_COUNT;
0765             if (spec->gpio_led < max_gpio)
0766                 spec->gpio_led = 1 << spec->gpio_led;
0767             else
0768                 spec->vref_mute_led_nid = spec->gpio_led;
0769             return 1;
0770         }
0771         if (sscanf(dev->name, "HP_Mute_LED_%u",
0772                &spec->gpio_led_polarity) == 1) {
0773             set_hp_led_gpio(codec);
0774             return 1;
0775         }
0776         /* BIOS bug: unfilled OEM string */
0777         if (strstr(dev->name, "HP_Mute_LED_P_G")) {
0778             set_hp_led_gpio(codec);
0779             if (default_polarity >= 0)
0780                 spec->gpio_led_polarity = default_polarity;
0781             else
0782                 spec->gpio_led_polarity = 1;
0783             return 1;
0784         }
0785     }
0786
0787     /*
0788      * Fallback case - if we don't find the DMI strings,
0789      * we statically set the GPIO - if not a B-series system
0790      * and default polarity is provided
0791      */
0792     if (!hp_blike_system(codec->core.subsystem_id) &&
0793         (default_polarity == 0 || default_polarity == 1)) {
0794         set_hp_led_gpio(codec);
0795         spec->gpio_led_polarity = default_polarity;
0796         return 1;
0797     }
0798     return 0;
0799 }
0800
0801 /* check whether a built-in speaker is included in parsed pins */
0802 static bool has_builtin_speaker(struct hda_codec *codec)
0803 {
0804     struct sigmatel_spec *spec = codec->spec;
0805     const hda_nid_t *nid_pin;
0806     int nids, i;
0807
0808     if (spec->gen.autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) {
0809         nid_pin = spec->gen.autocfg.line_out_pins;
0810         nids = spec->gen.autocfg.line_outs;
0811     } else {
0812         nid_pin = spec->gen.autocfg.speaker_pins;
0813         nids = spec->gen.autocfg.speaker_outs;
0814     }
0815
0816     for (i = 0; i < nids; i++) {
0817         unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid_pin[i]);
0818         if (snd_hda_get_input_pin_attr(def_conf) == INPUT_PIN_ATTR_INT)
0819             return true;
0820     }
0821     return false;
0822 }
0823
0824 /*
0825  * PC beep controls
0826  */
0827
0828 /* create PC beep volume controls */
0829 static int stac_auto_create_beep_ctls(struct hda_codec *codec,
0830                         hda_nid_t nid)
0831 {
0832     struct sigmatel_spec *spec = codec->spec;
0833     u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
0834     struct snd_kcontrol_new *knew;
0835     static const struct snd_kcontrol_new abeep_mute_ctl =
0836         HDA_CODEC_MUTE(NULL, 0, 0, 0);
0837     static const struct snd_kcontrol_new dbeep_mute_ctl =
0838         HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0);
0839     static const struct snd_kcontrol_new beep_vol_ctl =
0840         HDA_CODEC_VOLUME(NULL, 0, 0, 0);
0841
0842     /* check for mute support for the amp */
0843     if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
0844         const struct snd_kcontrol_new *temp;
0845         if (spec->anabeep_nid == nid)
0846             temp = &abeep_mute_ctl;
0847         else
0848             temp = &dbeep_mute_ctl;
0849         knew = snd_hda_gen_add_kctl(&spec->gen,
0850                         "Beep Playback Switch", temp);
0851         if (!knew)
0852             return -ENOMEM;
0853         knew->private_value =
0854             HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT);
0855     }
0856
0857     /* check to see if there is volume support for the amp */
0858     if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
0859         knew = snd_hda_gen_add_kctl(&spec->gen,
0860                         "Beep Playback Volume",
0861                         &beep_vol_ctl);
0862         if (!knew)
0863             return -ENOMEM;
0864         knew->private_value =
0865             HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT);
0866     }
0867     return 0;
0868 }
0869
0870 #ifdef CONFIG_SND_HDA_INPUT_BEEP
0871 #define stac_dig_beep_switch_info snd_ctl_boolean_mono_info
0872
0873 static int stac_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
0874                     struct snd_ctl_elem_value *ucontrol)
0875 {
0876     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
0877     ucontrol->value.integer.value[0] = codec->beep->enabled;
0878     return 0;
0879 }
0880
0881 static int stac_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
0882                     struct snd_ctl_elem_value *ucontrol)
0883 {
0884     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
0885     return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
0886 }
0887
0888 static const struct snd_kcontrol_new stac_dig_beep_ctrl = {
0889     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0890     .name = "Beep Playback Switch",
0891     .info = stac_dig_beep_switch_info,
0892     .get = stac_dig_beep_switch_get,
0893     .put = stac_dig_beep_switch_put,
0894 };
0895
0896 static int stac_beep_switch_ctl(struct hda_codec *codec)
0897 {
0898     struct sigmatel_spec *spec = codec->spec;
0899
0900     if (!snd_hda_gen_add_kctl(&spec->gen, NULL, &stac_dig_beep_ctrl))
0901         return -ENOMEM;
0902     return 0;
0903 }
0904 #endif
0905
0906 /*
0907  * SPDIF-out mux controls
0908  */
0909
0910 static int stac_smux_enum_info(struct snd_kcontrol *kcontrol,
0911                    struct snd_ctl_elem_info *uinfo)
0912 {
0913     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
0914     struct sigmatel_spec *spec = codec->spec;
0915     return snd_hda_input_mux_info(&spec->spdif_mux, uinfo);
0916 }
0917
0918 static int stac_smux_enum_get(struct snd_kcontrol *kcontrol,
0919                   struct snd_ctl_elem_value *ucontrol)
0920 {
0921     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
0922     struct sigmatel_spec *spec = codec->spec;
0923     unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
0924
0925     ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
0926     return 0;
0927 }
0928
0929 static int stac_smux_enum_put(struct snd_kcontrol *kcontrol,
0930                   struct snd_ctl_elem_value *ucontrol)
0931 {
0932     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
0933     struct sigmatel_spec *spec = codec->spec;
0934     unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
0935
0936     return snd_hda_input_mux_put(codec, &spec->spdif_mux, ucontrol,
0937                      spec->gen.autocfg.dig_out_pins[smux_idx],
0938                      &spec->cur_smux[smux_idx]);
0939 }
0940
0941 static const struct snd_kcontrol_new stac_smux_mixer = {
0942     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0943     .name = "IEC958 Playback Source",
0944     /* count set later */
0945     .info = stac_smux_enum_info,
0946     .get = stac_smux_enum_get,
0947     .put = stac_smux_enum_put,
0948 };
0949
0950 static const char * const stac_spdif_labels[] = {
0951     "Digital Playback", "Analog Mux 1", "Analog Mux 2", NULL
0952 };
0953
0954 static int stac_create_spdif_mux_ctls(struct hda_codec *codec)
0955 {
0956     struct sigmatel_spec *spec = codec->spec;
0957     struct auto_pin_cfg *cfg = &spec->gen.autocfg;
0958     const char * const *labels = spec->spdif_labels;
0959     struct snd_kcontrol_new *kctl;
0960     int i, num_cons;
0961
0962     if (cfg->dig_outs < 1)
0963         return 0;
0964
0965     num_cons = snd_hda_get_num_conns(codec, cfg->dig_out_pins[0]);
0966     if (num_cons <= 1)
0967         return 0;
0968
0969     if (!labels)
0970         labels = stac_spdif_labels;
0971     for (i = 0; i < num_cons; i++) {
0972         if (snd_BUG_ON(!labels[i]))
0973             return -EINVAL;
0974         snd_hda_add_imux_item(codec, &spec->spdif_mux, labels[i], i, NULL);
0975     }
0976
0977     kctl = snd_hda_gen_add_kctl(&spec->gen, NULL, &stac_smux_mixer);
0978     if (!kctl)
0979         return -ENOMEM;
0980     kctl->count = cfg->dig_outs;
0981
0982     return 0;
0983 }
0984
0985 static const struct hda_verb stac9200_eapd_init[] = {
0986     /* set dac0mux for dac converter */
0987     {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
0988     {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
0989     {}
0990 };
0991
0992 static const struct hda_verb dell_eq_core_init[] = {
0993     /* set master volume to max value without distortion
0994      * and direct control */
0995     { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
0996     {}
0997 };
0998
0999 static const struct hda_verb stac92hd73xx_core_init[] = {
1000     /* set master volume and direct control */
1001     { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
1002     {}
1003 };
1004
1005 static const struct hda_verb stac92hd83xxx_core_init[] = {
1006     /* power state controls amps */
1007     { 0x01, AC_VERB_SET_EAPD, 1 << 2},
1008     {}
1009 };
1010
1011 static const struct hda_verb stac92hd83xxx_hp_zephyr_init[] = {
1012     { 0x22, 0x785, 0x43 },
1013     { 0x22, 0x782, 0xe0 },
1014     { 0x22, 0x795, 0x00 },
1015     {}
1016 };
1017
1018 static const struct hda_verb stac92hd71bxx_core_init[] = {
1019     /* set master volume and direct control */
1020     { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
1021     {}
1022 };
1023
1024 static const hda_nid_t stac92hd71bxx_unmute_nids[] = {
1025     /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
1026     0x0f, 0x0a, 0x0d, 0
1027 };
1028
1029 static const struct hda_verb stac925x_core_init[] = {
1030     /* set dac0mux for dac converter */
1031     { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
1032     /* mute the master volume */
1033     { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1034     {}
1035 };
1036
1037 static const struct hda_verb stac922x_core_init[] = {
1038     /* set master volume and direct control */
1039     { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
1040     {}
1041 };
1042
1043 static const struct hda_verb d965_core_init[] = {
1044     /* unmute node 0x1b */
1045     { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1046     /* select node 0x03 as DAC */
1047     { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
1048     {}
1049 };
1050
1051 static const struct hda_verb dell_3st_core_init[] = {
1052     /* don't set delta bit */
1053     {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
1054     /* unmute node 0x1b */
1055     {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
1056     /* select node 0x03 as DAC */
1057     {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
1058     {}
1059 };
1060
1061 static const struct hda_verb stac927x_core_init[] = {
1062     /* set master volume and direct control */
1063     { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
1064     /* enable analog pc beep path */
1065     { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
1066     {}
1067 };
1068
1069 static const struct hda_verb stac927x_volknob_core_init[] = {
1070     /* don't set delta bit */
1071     {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
1072     /* enable analog pc beep path */
1073     {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
1074     {}
1075 };
1076
1077 static const struct hda_verb stac9205_core_init[] = {
1078     /* set master volume and direct control */
1079     { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
1080     /* enable analog pc beep path */
1081     { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
1082     {}
1083 };
1084
1085 static const struct snd_kcontrol_new stac92hd73xx_6ch_loopback =
1086     STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3);
1087
1088 static const struct snd_kcontrol_new stac92hd73xx_8ch_loopback =
1089     STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4);
1090
1091 static const struct snd_kcontrol_new stac92hd73xx_10ch_loopback =
1092     STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5);
1093
1094 static const struct snd_kcontrol_new stac92hd71bxx_loopback =
1095     STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2);
1096
1097 static const struct snd_kcontrol_new stac9205_loopback =
1098     STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1);
1099
1100 static const struct snd_kcontrol_new stac927x_loopback =
1101     STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1);
1102
1103 static const struct hda_pintbl ref9200_pin_configs[] = {
1104     { 0x08, 0x01c47010 },
1105     { 0x09, 0x01447010 },
1106     { 0x0d, 0x0221401f },
1107     { 0x0e, 0x01114010 },
1108     { 0x0f, 0x02a19020 },
1109     { 0x10, 0x01a19021 },
1110     { 0x11, 0x90100140 },
1111     { 0x12, 0x01813122 },
1112     {}
1113 };
1114
1115 static const struct hda_pintbl gateway9200_m4_pin_configs[] = {
1116     { 0x08, 0x400000fe },
1117     { 0x09, 0x404500f4 },
1118     { 0x0d, 0x400100f0 },
1119     { 0x0e, 0x90110010 },
1120     { 0x0f, 0x400100f1 },
1121     { 0x10, 0x02a1902e },
1122     { 0x11, 0x500000f2 },
1123     { 0x12, 0x500000f3 },
1124     {}
1125 };
1126
1127 static const struct hda_pintbl gateway9200_m4_2_pin_configs[] = {
1128     { 0x08, 0x400000fe },
1129     { 0x09, 0x404500f4 },
1130     { 0x0d, 0x400100f0 },
1131     { 0x0e, 0x90110010 },
1132     { 0x0f, 0x400100f1 },
1133     { 0x10, 0x02a1902e },
1134     { 0x11, 0x500000f2 },
1135     { 0x12, 0x500000f3 },
1136     {}
1137 };
1138
1139 /*
1140     STAC 9200 pin configs for
1141     102801A8
1142     102801DE
1143     102801E8
1144 */
1145 static const struct hda_pintbl dell9200_d21_pin_configs[] = {
1146     { 0x08, 0x400001f0 },
1147     { 0x09, 0x400001f1 },
1148     { 0x0d, 0x02214030 },
1149     { 0x0e, 0x01014010 },
1150     { 0x0f, 0x02a19020 },
1151     { 0x10, 0x01a19021 },
1152     { 0x11, 0x90100140 },
1153     { 0x12, 0x01813122 },
1154     {}
1155 };
1156
1157 /*
1158     STAC 9200 pin configs for
1159     102801C0
1160     102801C1
1161 */
1162 static const struct hda_pintbl dell9200_d22_pin_configs[] = {
1163     { 0x08, 0x400001f0 },
1164     { 0x09, 0x400001f1 },
1165     { 0x0d, 0x0221401f },
1166     { 0x0e, 0x01014010 },
1167     { 0x0f, 0x01813020 },
1168     { 0x10, 0x02a19021 },
1169     { 0x11, 0x90100140 },
1170     { 0x12, 0x400001f2 },
1171     {}
1172 };
1173
1174 /*
1175     STAC 9200 pin configs for
1176     102801C4 (Dell Dimension E310)
1177     102801C5
1178     102801C7
1179     102801D9
1180     102801DA
1181     102801E3
1182 */
1183 static const struct hda_pintbl dell9200_d23_pin_configs[] = {
1184     { 0x08, 0x400001f0 },
1185     { 0x09, 0x400001f1 },
1186     { 0x0d, 0x0221401f },
1187     { 0x0e, 0x01014010 },
1188     { 0x0f, 0x01813020 },
1189     { 0x10, 0x01a19021 },
1190     { 0x11, 0x90100140 },
1191     { 0x12, 0x400001f2 },
1192     {}
1193 };
1194
1195
1196 /*
1197     STAC 9200-32 pin configs for
1198     102801B5 (Dell Inspiron 630m)
1199     102801D8 (Dell Inspiron 640m)
1200 */
1201 static const struct hda_pintbl dell9200_m21_pin_configs[] = {
1202     { 0x08, 0x40c003fa },
1203     { 0x09, 0x03441340 },
1204     { 0x0d, 0x0321121f },
1205     { 0x0e, 0x90170310 },
1206     { 0x0f, 0x408003fb },
1207     { 0x10, 0x03a11020 },
1208     { 0x11, 0x401003fc },
1209     { 0x12, 0x403003fd },
1210     {}
1211 };
1212
1213 /*
1214     STAC 9200-32 pin configs for
1215     102801C2 (Dell Latitude D620)
1216     102801C8
1217     102801CC (Dell Latitude D820)
1218     102801D4
1219     102801D6
1220 */
1221 static const struct hda_pintbl dell9200_m22_pin_configs[] = {
1222     { 0x08, 0x40c003fa },
1223     { 0x09, 0x0144131f },
1224     { 0x0d, 0x0321121f },
1225     { 0x0e, 0x90170310 },
1226     { 0x0f, 0x90a70321 },
1227     { 0x10, 0x03a11020 },
1228     { 0x11, 0x401003fb },
1229     { 0x12, 0x40f000fc },
1230     {}
1231 };
1232
1233 /*
1234     STAC 9200-32 pin configs for
1235     102801CE (Dell XPS M1710)
1236     102801CF (Dell Precision M90)
1237 */
1238 static const struct hda_pintbl dell9200_m23_pin_configs[] = {
1239     { 0x08, 0x40c003fa },
1240     { 0x09, 0x01441340 },
1241     { 0x0d, 0x0421421f },
1242     { 0x0e, 0x90170310 },
1243     { 0x0f, 0x408003fb },
1244     { 0x10, 0x04a1102e },
1245     { 0x11, 0x90170311 },
1246     { 0x12, 0x403003fc },
1247     {}
1248 };
1249
1250 /*
1251     STAC 9200-32 pin configs for
1252     102801C9
1253     102801CA
1254     102801CB (Dell Latitude 120L)
1255     102801D3
1256 */
1257 static const struct hda_pintbl dell9200_m24_pin_configs[] = {
1258     { 0x08, 0x40c003fa },
1259     { 0x09, 0x404003fb },
1260     { 0x0d, 0x0321121f },
1261     { 0x0e, 0x90170310 },
1262     { 0x0f, 0x408003fc },
1263     { 0x10, 0x03a11020 },
1264     { 0x11, 0x401003fd },
1265     { 0x12, 0x403003fe },
1266     {}
1267 };
1268
1269 /*
1270     STAC 9200-32 pin configs for
1271     102801BD (Dell Inspiron E1505n)
1272     102801EE
1273     102801EF
1274 */
1275 static const struct hda_pintbl dell9200_m25_pin_configs[] = {
1276     { 0x08, 0x40c003fa },
1277     { 0x09, 0x01441340 },
1278     { 0x0d, 0x0421121f },
1279     { 0x0e, 0x90170310 },
1280     { 0x0f, 0x408003fb },
1281     { 0x10, 0x04a11020 },
1282     { 0x11, 0x401003fc },
1283     { 0x12, 0x403003fd },
1284     {}
1285 };
1286
1287 /*
1288     STAC 9200-32 pin configs for
1289     102801F5 (Dell Inspiron 1501)
1290     102801F6
1291 */
1292 static const struct hda_pintbl dell9200_m26_pin_configs[] = {
1293     { 0x08, 0x40c003fa },
1294     { 0x09, 0x404003fb },
1295     { 0x0d, 0x0421121f },
1296     { 0x0e, 0x90170310 },
1297     { 0x0f, 0x408003fc },
1298     { 0x10, 0x04a11020 },
1299     { 0x11, 0x401003fd },
1300     { 0x12, 0x403003fe },
1301     {}
1302 };
1303
1304 /*
1305     STAC 9200-32
1306     102801CD (Dell Inspiron E1705/9400)
1307 */
1308 static const struct hda_pintbl dell9200_m27_pin_configs[] = {
1309     { 0x08, 0x40c003fa },
1310     { 0x09, 0x01441340 },
1311     { 0x0d, 0x0421121f },
1312     { 0x0e, 0x90170310 },
1313     { 0x0f, 0x90170310 },
1314     { 0x10, 0x04a11020 },
1315     { 0x11, 0x90170310 },
1316     { 0x12, 0x40f003fc },
1317     {}
1318 };
1319
1320 static const struct hda_pintbl oqo9200_pin_configs[] = {
1321     { 0x08, 0x40c000f0 },
1322     { 0x09, 0x404000f1 },
1323     { 0x0d, 0x0221121f },
1324     { 0x0e, 0x02211210 },
1325     { 0x0f, 0x90170111 },
1326     { 0x10, 0x90a70120 },
1327     { 0x11, 0x400000f2 },
1328     { 0x12, 0x400000f3 },
1329     {}
1330 };
1331
1332 /*
1333  *  STAC 92HD700
1334  *  18881000 Amigaone X1000
1335  */
1336 static const struct hda_pintbl nemo_pin_configs[] = {
1337     { 0x0a, 0x02214020 },   /* Front panel HP socket */
1338     { 0x0b, 0x02a19080 },   /* Front Mic */
1339     { 0x0c, 0x0181304e },   /* Line in */
1340     { 0x0d, 0x01014010 },   /* Line out */
1341     { 0x0e, 0x01a19040 },   /* Rear Mic */
1342     { 0x0f, 0x01011012 },   /* Rear speakers */
1343     { 0x10, 0x01016011 },   /* Center speaker */
1344     { 0x11, 0x01012014 },   /* Side speakers (7.1) */
1345     { 0x12, 0x103301f0 },   /* Motherboard CD line in connector */
1346     { 0x13, 0x411111f0 },   /* Unused */
1347     { 0x14, 0x411111f0 },   /* Unused */
1348     { 0x21, 0x01442170 },   /* S/PDIF line out */
1349     { 0x22, 0x411111f0 },   /* Unused */
1350     { 0x23, 0x411111f0 },   /* Unused */
1351     {}
1352 };
1353
1354 static void stac9200_fixup_panasonic(struct hda_codec *codec,
1355                      const struct hda_fixup *fix, int action)
1356 {
1357     struct sigmatel_spec *spec = codec->spec;
1358
1359     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1360         spec->gpio_mask = spec->gpio_dir = 0x09;
1361         spec->gpio_data = 0x00;
1362         /* CF-74 has no headphone detection, and the driver should *NOT*
1363          * do detection and HP/speaker toggle because the hardware does it.
1364          */
1365         spec->gen.suppress_auto_mute = 1;
1366     }
1367 }
1368
1369
1370 static const struct hda_fixup stac9200_fixups[] = {
1371     [STAC_REF] = {
1372         .type = HDA_FIXUP_PINS,
1373         .v.pins = ref9200_pin_configs,
1374     },
1375     [STAC_9200_OQO] = {
1376         .type = HDA_FIXUP_PINS,
1377         .v.pins = oqo9200_pin_configs,
1378         .chained = true,
1379         .chain_id = STAC_9200_EAPD_INIT,
1380     },
1381     [STAC_9200_DELL_D21] = {
1382         .type = HDA_FIXUP_PINS,
1383         .v.pins = dell9200_d21_pin_configs,
1384     },
1385     [STAC_9200_DELL_D22] = {
1386         .type = HDA_FIXUP_PINS,
1387         .v.pins = dell9200_d22_pin_configs,
1388     },
1389     [STAC_9200_DELL_D23] = {
1390         .type = HDA_FIXUP_PINS,
1391         .v.pins = dell9200_d23_pin_configs,
1392     },
1393     [STAC_9200_DELL_M21] = {
1394         .type = HDA_FIXUP_PINS,
1395         .v.pins = dell9200_m21_pin_configs,
1396     },
1397     [STAC_9200_DELL_M22] = {
1398         .type = HDA_FIXUP_PINS,
1399         .v.pins = dell9200_m22_pin_configs,
1400     },
1401     [STAC_9200_DELL_M23] = {
1402         .type = HDA_FIXUP_PINS,
1403         .v.pins = dell9200_m23_pin_configs,
1404     },
1405     [STAC_9200_DELL_M24] = {
1406         .type = HDA_FIXUP_PINS,
1407         .v.pins = dell9200_m24_pin_configs,
1408     },
1409     [STAC_9200_DELL_M25] = {
1410         .type = HDA_FIXUP_PINS,
1411         .v.pins = dell9200_m25_pin_configs,
1412     },
1413     [STAC_9200_DELL_M26] = {
1414         .type = HDA_FIXUP_PINS,
1415         .v.pins = dell9200_m26_pin_configs,
1416     },
1417     [STAC_9200_DELL_M27] = {
1418         .type = HDA_FIXUP_PINS,
1419         .v.pins = dell9200_m27_pin_configs,
1420     },
1421     [STAC_9200_M4] = {
1422         .type = HDA_FIXUP_PINS,
1423         .v.pins = gateway9200_m4_pin_configs,
1424         .chained = true,
1425         .chain_id = STAC_9200_EAPD_INIT,
1426     },
1427     [STAC_9200_M4_2] = {
1428         .type = HDA_FIXUP_PINS,
1429         .v.pins = gateway9200_m4_2_pin_configs,
1430         .chained = true,
1431         .chain_id = STAC_9200_EAPD_INIT,
1432     },
1433     [STAC_9200_PANASONIC] = {
1434         .type = HDA_FIXUP_FUNC,
1435         .v.func = stac9200_fixup_panasonic,
1436     },
1437     [STAC_9200_EAPD_INIT] = {
1438         .type = HDA_FIXUP_VERBS,
1439         .v.verbs = (const struct hda_verb[]) {
1440             {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1441             {}
1442         },
1443     },
1444 };
1445
1446 static const struct hda_model_fixup stac9200_models[] = {
1447     { .id = STAC_REF, .name = "ref" },
1448     { .id = STAC_9200_OQO, .name = "oqo" },
1449     { .id = STAC_9200_DELL_D21, .name = "dell-d21" },
1450     { .id = STAC_9200_DELL_D22, .name = "dell-d22" },
1451     { .id = STAC_9200_DELL_D23, .name = "dell-d23" },
1452     { .id = STAC_9200_DELL_M21, .name = "dell-m21" },
1453     { .id = STAC_9200_DELL_M22, .name = "dell-m22" },
1454     { .id = STAC_9200_DELL_M23, .name = "dell-m23" },
1455     { .id = STAC_9200_DELL_M24, .name = "dell-m24" },
1456     { .id = STAC_9200_DELL_M25, .name = "dell-m25" },
1457     { .id = STAC_9200_DELL_M26, .name = "dell-m26" },
1458     { .id = STAC_9200_DELL_M27, .name = "dell-m27" },
1459     { .id = STAC_9200_M4, .name = "gateway-m4" },
1460     { .id = STAC_9200_M4_2, .name = "gateway-m4-2" },
1461     { .id = STAC_9200_PANASONIC, .name = "panasonic" },
1462     {}
1463 };
1464
1465 static const struct snd_pci_quirk stac9200_fixup_tbl[] = {
1466     /* SigmaTel reference board */
1467     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1468               "DFI LanParty", STAC_REF),
1469     SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1470               "DFI LanParty", STAC_REF),
1471     /* Dell laptops have BIOS problem */
1472     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1473               "unknown Dell", STAC_9200_DELL_D21),
1474     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1475               "Dell Inspiron 630m", STAC_9200_DELL_M21),
1476     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1477               "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1478     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1479               "unknown Dell", STAC_9200_DELL_D22),
1480     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1481               "unknown Dell", STAC_9200_DELL_D22),
1482     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1483               "Dell Latitude D620", STAC_9200_DELL_M22),
1484     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1485               "unknown Dell", STAC_9200_DELL_D23),
1486     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1487               "unknown Dell", STAC_9200_DELL_D23),
1488     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1489               "unknown Dell", STAC_9200_DELL_M22),
1490     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1491               "unknown Dell", STAC_9200_DELL_M24),
1492     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1493               "unknown Dell", STAC_9200_DELL_M24),
1494     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1495               "Dell Latitude 120L", STAC_9200_DELL_M24),
1496     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1497               "Dell Latitude D820", STAC_9200_DELL_M22),
1498     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1499               "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1500     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1501               "Dell XPS M1710", STAC_9200_DELL_M23),
1502     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1503               "Dell Precision M90", STAC_9200_DELL_M23),
1504     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1505               "unknown Dell", STAC_9200_DELL_M22),
1506     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1507               "unknown Dell", STAC_9200_DELL_M22),
1508     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1509               "unknown Dell", STAC_9200_DELL_M22),
1510     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1511               "Dell Inspiron 640m", STAC_9200_DELL_M21),
1512     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1513               "unknown Dell", STAC_9200_DELL_D23),
1514     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1515               "unknown Dell", STAC_9200_DELL_D23),
1516     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1517               "unknown Dell", STAC_9200_DELL_D21),
1518     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1519               "unknown Dell", STAC_9200_DELL_D23),
1520     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1521               "unknown Dell", STAC_9200_DELL_D21),
1522     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1523               "unknown Dell", STAC_9200_DELL_M25),
1524     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1525               "unknown Dell", STAC_9200_DELL_M25),
1526     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1527               "Dell Inspiron 1501", STAC_9200_DELL_M26),
1528     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1529               "unknown Dell", STAC_9200_DELL_M26),
1530     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0201,
1531               "Dell Latitude D430", STAC_9200_DELL_M22),
1532     /* Panasonic */
1533     SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1534     /* Gateway machines needs EAPD to be set on resume */
1535     SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1536     SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1537     SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1538     /* OQO Mobile */
1539     SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1540     {} /* terminator */
1541 };
1542
1543 static const struct hda_pintbl ref925x_pin_configs[] = {
1544     { 0x07, 0x40c003f0 },
1545     { 0x08, 0x424503f2 },
1546     { 0x0a, 0x01813022 },
1547     { 0x0b, 0x02a19021 },
1548     { 0x0c, 0x90a70320 },
1549     { 0x0d, 0x02214210 },
1550     { 0x10, 0x01019020 },
1551     { 0x11, 0x9033032e },
1552     {}
1553 };
1554
1555 static const struct hda_pintbl stac925xM1_pin_configs[] = {
1556     { 0x07, 0x40c003f4 },
1557     { 0x08, 0x424503f2 },
1558     { 0x0a, 0x400000f3 },
1559     { 0x0b, 0x02a19020 },
1560     { 0x0c, 0x40a000f0 },
1561     { 0x0d, 0x90100210 },
1562     { 0x10, 0x400003f1 },
1563     { 0x11, 0x9033032e },
1564     {}
1565 };
1566
1567 static const struct hda_pintbl stac925xM1_2_pin_configs[] = {
1568     { 0x07, 0x40c003f4 },
1569     { 0x08, 0x424503f2 },
1570     { 0x0a, 0x400000f3 },
1571     { 0x0b, 0x02a19020 },
1572     { 0x0c, 0x40a000f0 },
1573     { 0x0d, 0x90100210 },
1574     { 0x10, 0x400003f1 },
1575     { 0x11, 0x9033032e },
1576     {}
1577 };
1578
1579 static const struct hda_pintbl stac925xM2_pin_configs[] = {
1580     { 0x07, 0x40c003f4 },
1581     { 0x08, 0x424503f2 },
1582     { 0x0a, 0x400000f3 },
1583     { 0x0b, 0x02a19020 },
1584     { 0x0c, 0x40a000f0 },
1585     { 0x0d, 0x90100210 },
1586     { 0x10, 0x400003f1 },
1587     { 0x11, 0x9033032e },
1588     {}
1589 };
1590
1591 static const struct hda_pintbl stac925xM2_2_pin_configs[] = {
1592     { 0x07, 0x40c003f4 },
1593     { 0x08, 0x424503f2 },
1594     { 0x0a, 0x400000f3 },
1595     { 0x0b, 0x02a19020 },
1596     { 0x0c, 0x40a000f0 },
1597     { 0x0d, 0x90100210 },
1598     { 0x10, 0x400003f1 },
1599     { 0x11, 0x9033032e },
1600     {}
1601 };
1602
1603 static const struct hda_pintbl stac925xM3_pin_configs[] = {
1604     { 0x07, 0x40c003f4 },
1605     { 0x08, 0x424503f2 },
1606     { 0x0a, 0x400000f3 },
1607     { 0x0b, 0x02a19020 },
1608     { 0x0c, 0x40a000f0 },
1609     { 0x0d, 0x90100210 },
1610     { 0x10, 0x400003f1 },
1611     { 0x11, 0x503303f3 },
1612     {}
1613 };
1614
1615 static const struct hda_pintbl stac925xM5_pin_configs[] = {
1616     { 0x07, 0x40c003f4 },
1617     { 0x08, 0x424503f2 },
1618     { 0x0a, 0x400000f3 },
1619     { 0x0b, 0x02a19020 },
1620     { 0x0c, 0x40a000f0 },
1621     { 0x0d, 0x90100210 },
1622     { 0x10, 0x400003f1 },
1623     { 0x11, 0x9033032e },
1624     {}
1625 };
1626
1627 static const struct hda_pintbl stac925xM6_pin_configs[] = {
1628     { 0x07, 0x40c003f4 },
1629     { 0x08, 0x424503f2 },
1630     { 0x0a, 0x400000f3 },
1631     { 0x0b, 0x02a19020 },
1632     { 0x0c, 0x40a000f0 },
1633     { 0x0d, 0x90100210 },
1634     { 0x10, 0x400003f1 },
1635     { 0x11, 0x90330320 },
1636     {}
1637 };
1638
1639 static const struct hda_fixup stac925x_fixups[] = {
1640     [STAC_REF] = {
1641         .type = HDA_FIXUP_PINS,
1642         .v.pins = ref925x_pin_configs,
1643     },
1644     [STAC_M1] = {
1645         .type = HDA_FIXUP_PINS,
1646         .v.pins = stac925xM1_pin_configs,
1647     },
1648     [STAC_M1_2] = {
1649         .type = HDA_FIXUP_PINS,
1650         .v.pins = stac925xM1_2_pin_configs,
1651     },
1652     [STAC_M2] = {
1653         .type = HDA_FIXUP_PINS,
1654         .v.pins = stac925xM2_pin_configs,
1655     },
1656     [STAC_M2_2] = {
1657         .type = HDA_FIXUP_PINS,
1658         .v.pins = stac925xM2_2_pin_configs,
1659     },
1660     [STAC_M3] = {
1661         .type = HDA_FIXUP_PINS,
1662         .v.pins = stac925xM3_pin_configs,
1663     },
1664     [STAC_M5] = {
1665         .type = HDA_FIXUP_PINS,
1666         .v.pins = stac925xM5_pin_configs,
1667     },
1668     [STAC_M6] = {
1669         .type = HDA_FIXUP_PINS,
1670         .v.pins = stac925xM6_pin_configs,
1671     },
1672 };
1673
1674 static const struct hda_model_fixup stac925x_models[] = {
1675     { .id = STAC_REF, .name = "ref" },
1676     { .id = STAC_M1, .name = "m1" },
1677     { .id = STAC_M1_2, .name = "m1-2" },
1678     { .id = STAC_M2, .name = "m2" },
1679     { .id = STAC_M2_2, .name = "m2-2" },
1680     { .id = STAC_M3, .name = "m3" },
1681     { .id = STAC_M5, .name = "m5" },
1682     { .id = STAC_M6, .name = "m6" },
1683     {}
1684 };
1685
1686 static const struct snd_pci_quirk stac925x_fixup_tbl[] = {
1687     /* SigmaTel reference board */
1688     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1689     SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1690     SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1691
1692     /* Default table for unknown ID */
1693     SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1694
1695     /* gateway machines are checked via codec ssid */
1696     SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1697     SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1698     SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1699     SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1700     SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1701     /* Not sure about the brand name for those */
1702     SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1703     SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1704     SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1705     SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1706     {} /* terminator */
1707 };
1708
1709 static const struct hda_pintbl ref92hd73xx_pin_configs[] = {
1710     { 0x0a, 0x02214030 },
1711     { 0x0b, 0x02a19040 },
1712     { 0x0c, 0x01a19020 },
1713     { 0x0d, 0x02214030 },
1714     { 0x0e, 0x0181302e },
1715     { 0x0f, 0x01014010 },
1716     { 0x10, 0x01014020 },
1717     { 0x11, 0x01014030 },
1718     { 0x12, 0x02319040 },
1719     { 0x13, 0x90a000f0 },
1720     { 0x14, 0x90a000f0 },
1721     { 0x22, 0x01452050 },
1722     { 0x23, 0x01452050 },
1723     {}
1724 };
1725
1726 static const struct hda_pintbl dell_m6_pin_configs[] = {
1727     { 0x0a, 0x0321101f },
1728     { 0x0b, 0x4f00000f },
1729     { 0x0c, 0x4f0000f0 },
1730     { 0x0d, 0x90170110 },
1731     { 0x0e, 0x03a11020 },
1732     { 0x0f, 0x0321101f },
1733     { 0x10, 0x4f0000f0 },
1734     { 0x11, 0x4f0000f0 },
1735     { 0x12, 0x4f0000f0 },
1736     { 0x13, 0x90a60160 },
1737     { 0x14, 0x4f0000f0 },
1738     { 0x22, 0x4f0000f0 },
1739     { 0x23, 0x4f0000f0 },
1740     {}
1741 };
1742
1743 static const struct hda_pintbl alienware_m17x_pin_configs[] = {
1744     { 0x0a, 0x0321101f },
1745     { 0x0b, 0x0321101f },
1746     { 0x0c, 0x03a11020 },
1747     { 0x0d, 0x03014020 },
1748     { 0x0e, 0x90170110 },
1749     { 0x0f, 0x4f0000f0 },
1750     { 0x10, 0x4f0000f0 },
1751     { 0x11, 0x4f0000f0 },
1752     { 0x12, 0x4f0000f0 },
1753     { 0x13, 0x90a60160 },
1754     { 0x14, 0x4f0000f0 },
1755     { 0x22, 0x4f0000f0 },
1756     { 0x23, 0x904601b0 },
1757     {}
1758 };
1759
1760 static const struct hda_pintbl intel_dg45id_pin_configs[] = {
1761     { 0x0a, 0x02214230 },
1762     { 0x0b, 0x02A19240 },
1763     { 0x0c, 0x01013214 },
1764     { 0x0d, 0x01014210 },
1765     { 0x0e, 0x01A19250 },
1766     { 0x0f, 0x01011212 },
1767     { 0x10, 0x01016211 },
1768     {}
1769 };
1770
1771 static const struct hda_pintbl stac92hd89xx_hp_front_jack_pin_configs[] = {
1772     { 0x0a, 0x02214030 },
1773     { 0x0b, 0x02A19010 },
1774     {}
1775 };
1776
1777 static const struct hda_pintbl stac92hd89xx_hp_z1_g2_right_mic_jack_pin_configs[] = {
1778     { 0x0e, 0x400000f0 },
1779     {}
1780 };
1781
1782 static void stac92hd73xx_fixup_ref(struct hda_codec *codec,
1783                    const struct hda_fixup *fix, int action)
1784 {
1785     struct sigmatel_spec *spec = codec->spec;
1786
1787     if (action != HDA_FIXUP_ACT_PRE_PROBE)
1788         return;
1789
1790     snd_hda_apply_pincfgs(codec, ref92hd73xx_pin_configs);
1791     spec->gpio_mask = spec->gpio_dir = spec->gpio_data = 0;
1792 }
1793
1794 static void stac92hd73xx_fixup_dell(struct hda_codec *codec)
1795 {
1796     struct sigmatel_spec *spec = codec->spec;
1797
1798     snd_hda_apply_pincfgs(codec, dell_m6_pin_configs);
1799     spec->eapd_switch = 0;
1800 }
1801
1802 static void stac92hd73xx_fixup_dell_eq(struct hda_codec *codec,
1803                        const struct hda_fixup *fix, int action)
1804 {
1805     struct sigmatel_spec *spec = codec->spec;
1806
1807     if (action != HDA_FIXUP_ACT_PRE_PROBE)
1808         return;
1809
1810     stac92hd73xx_fixup_dell(codec);
1811     snd_hda_add_verbs(codec, dell_eq_core_init);
1812     spec->volknob_init = 1;
1813 }
1814
1815 /* Analog Mics */
1816 static void stac92hd73xx_fixup_dell_m6_amic(struct hda_codec *codec,
1817                     const struct hda_fixup *fix, int action)
1818 {
1819     if (action != HDA_FIXUP_ACT_PRE_PROBE)
1820         return;
1821
1822     stac92hd73xx_fixup_dell(codec);
1823     snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
1824 }
1825
1826 /* Digital Mics */
1827 static void stac92hd73xx_fixup_dell_m6_dmic(struct hda_codec *codec,
1828                     const struct hda_fixup *fix, int action)
1829 {
1830     if (action != HDA_FIXUP_ACT_PRE_PROBE)
1831         return;
1832
1833     stac92hd73xx_fixup_dell(codec);
1834     snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
1835 }
1836
1837 /* Both */
1838 static void stac92hd73xx_fixup_dell_m6_both(struct hda_codec *codec,
1839                     const struct hda_fixup *fix, int action)
1840 {
1841     if (action != HDA_FIXUP_ACT_PRE_PROBE)
1842         return;
1843
1844     stac92hd73xx_fixup_dell(codec);
1845     snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
1846     snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
1847 }
1848
1849 static void stac92hd73xx_fixup_alienware_m17x(struct hda_codec *codec,
1850                     const struct hda_fixup *fix, int action)
1851 {
1852     struct sigmatel_spec *spec = codec->spec;
1853
1854     if (action != HDA_FIXUP_ACT_PRE_PROBE)
1855         return;
1856
1857     snd_hda_apply_pincfgs(codec, alienware_m17x_pin_configs);
1858     spec->eapd_switch = 0;
1859 }
1860
1861 static void stac92hd73xx_fixup_no_jd(struct hda_codec *codec,
1862                      const struct hda_fixup *fix, int action)
1863 {
1864     if (action == HDA_FIXUP_ACT_PRE_PROBE)
1865         codec->no_jack_detect = 1;
1866 }
1867
1868
1869 static void stac92hd73xx_disable_automute(struct hda_codec *codec,
1870                      const struct hda_fixup *fix, int action)
1871 {
1872     struct sigmatel_spec *spec = codec->spec;
1873
1874     if (action != HDA_FIXUP_ACT_PRE_PROBE)
1875         return;
1876
1877     spec->gen.suppress_auto_mute = 1;
1878 }
1879
1880 static const struct hda_fixup stac92hd73xx_fixups[] = {
1881     [STAC_92HD73XX_REF] = {
1882         .type = HDA_FIXUP_FUNC,
1883         .v.func = stac92hd73xx_fixup_ref,
1884     },
1885     [STAC_DELL_M6_AMIC] = {
1886         .type = HDA_FIXUP_FUNC,
1887         .v.func = stac92hd73xx_fixup_dell_m6_amic,
1888     },
1889     [STAC_DELL_M6_DMIC] = {
1890         .type = HDA_FIXUP_FUNC,
1891         .v.func = stac92hd73xx_fixup_dell_m6_dmic,
1892     },
1893     [STAC_DELL_M6_BOTH] = {
1894         .type = HDA_FIXUP_FUNC,
1895         .v.func = stac92hd73xx_fixup_dell_m6_both,
1896     },
1897     [STAC_DELL_EQ]  = {
1898         .type = HDA_FIXUP_FUNC,
1899         .v.func = stac92hd73xx_fixup_dell_eq,
1900     },
1901     [STAC_ALIENWARE_M17X] = {
1902         .type = HDA_FIXUP_FUNC,
1903         .v.func = stac92hd73xx_fixup_alienware_m17x,
1904     },
1905     [STAC_ELO_VUPOINT_15MX] = {
1906         .type = HDA_FIXUP_FUNC,
1907         .v.func = stac92hd73xx_disable_automute,
1908     },
1909     [STAC_92HD73XX_INTEL] = {
1910         .type = HDA_FIXUP_PINS,
1911         .v.pins = intel_dg45id_pin_configs,
1912     },
1913     [STAC_92HD73XX_NO_JD] = {
1914         .type = HDA_FIXUP_FUNC,
1915         .v.func = stac92hd73xx_fixup_no_jd,
1916     },
1917     [STAC_92HD89XX_HP_FRONT_JACK] = {
1918         .type = HDA_FIXUP_PINS,
1919         .v.pins = stac92hd89xx_hp_front_jack_pin_configs,
1920     },
1921     [STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK] = {
1922         .type = HDA_FIXUP_PINS,
1923         .v.pins = stac92hd89xx_hp_z1_g2_right_mic_jack_pin_configs,
1924     },
1925     [STAC_92HD73XX_ASUS_MOBO] = {
1926         .type = HDA_FIXUP_PINS,
1927         .v.pins = (const struct hda_pintbl[]) {
1928             /* enable 5.1 and SPDIF out */
1929             { 0x0c, 0x01014411 },
1930             { 0x0d, 0x01014410 },
1931             { 0x0e, 0x01014412 },
1932             { 0x22, 0x014b1180 },
1933             { }
1934         }
1935     },
1936 };
1937
1938 static const struct hda_model_fixup stac92hd73xx_models[] = {
1939     { .id = STAC_92HD73XX_NO_JD, .name = "no-jd" },
1940     { .id = STAC_92HD73XX_REF, .name = "ref" },
1941     { .id = STAC_92HD73XX_INTEL, .name = "intel" },
1942     { .id = STAC_DELL_M6_AMIC, .name = "dell-m6-amic" },
1943     { .id = STAC_DELL_M6_DMIC, .name = "dell-m6-dmic" },
1944     { .id = STAC_DELL_M6_BOTH, .name = "dell-m6" },
1945     { .id = STAC_DELL_EQ, .name = "dell-eq" },
1946     { .id = STAC_ALIENWARE_M17X, .name = "alienware" },
1947     { .id = STAC_ELO_VUPOINT_15MX, .name = "elo-vupoint-15mx" },
1948     { .id = STAC_92HD73XX_ASUS_MOBO, .name = "asus-mobo" },
1949     {}
1950 };
1951
1952 static const struct snd_pci_quirk stac92hd73xx_fixup_tbl[] = {
1953     /* SigmaTel reference board */
1954     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1955                 "DFI LanParty", STAC_92HD73XX_REF),
1956     SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1957                 "DFI LanParty", STAC_92HD73XX_REF),
1958     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1959                 "Intel DG45ID", STAC_92HD73XX_INTEL),
1960     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1961                 "Intel DG45FC", STAC_92HD73XX_INTEL),
1962     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1963                 "Dell Studio 1535", STAC_DELL_M6_DMIC),
1964     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1965                 "unknown Dell", STAC_DELL_M6_DMIC),
1966     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1967                 "unknown Dell", STAC_DELL_M6_BOTH),
1968     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1969                 "unknown Dell", STAC_DELL_M6_BOTH),
1970     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1971                 "unknown Dell", STAC_DELL_M6_AMIC),
1972     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1973                 "unknown Dell", STAC_DELL_M6_AMIC),
1974     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1975                 "unknown Dell", STAC_DELL_M6_DMIC),
1976     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1977                 "unknown Dell", STAC_DELL_M6_DMIC),
1978     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1979                 "Dell Studio 1537", STAC_DELL_M6_DMIC),
1980     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1981                 "Dell Studio 17", STAC_DELL_M6_DMIC),
1982     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1983                 "Dell Studio 1555", STAC_DELL_M6_DMIC),
1984     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1985                 "Dell Studio 1557", STAC_DELL_M6_DMIC),
1986     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1987                 "Dell Studio XPS 1645", STAC_DELL_M6_DMIC),
1988     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1989                 "Dell Studio 1558", STAC_DELL_M6_DMIC),
1990     /* codec SSID matching */
1991     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1992               "Alienware M17x", STAC_ALIENWARE_M17X),
1993     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
1994               "Alienware M17x", STAC_ALIENWARE_M17X),
1995     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0490,
1996               "Alienware M17x R3", STAC_DELL_EQ),
1997     SND_PCI_QUIRK(0x1059, 0x1011,
1998               "ELO VuPoint 15MX", STAC_ELO_VUPOINT_15MX),
1999     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1927,
2000                 "HP Z1 G2", STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK),
2001     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2b17,
2002                 "unknown HP", STAC_92HD89XX_HP_FRONT_JACK),
2003     SND_PCI_QUIRK(PCI_VENDOR_ID_ASUSTEK, 0x83f8, "ASUS AT4NM10",
2004               STAC_92HD73XX_ASUS_MOBO),
2005     {} /* terminator */
2006 };
2007
2008 static const struct hda_pintbl ref92hd83xxx_pin_configs[] = {
2009     { 0x0a, 0x02214030 },
2010     { 0x0b, 0x02211010 },
2011     { 0x0c, 0x02a19020 },
2012     { 0x0d, 0x02170130 },
2013     { 0x0e, 0x01014050 },
2014     { 0x0f, 0x01819040 },
2015     { 0x10, 0x01014020 },
2016     { 0x11, 0x90a3014e },
2017     { 0x1f, 0x01451160 },
2018     { 0x20, 0x98560170 },
2019     {}
2020 };
2021
2022 static const struct hda_pintbl dell_s14_pin_configs[] = {
2023     { 0x0a, 0x0221403f },
2024     { 0x0b, 0x0221101f },
2025     { 0x0c, 0x02a19020 },
2026     { 0x0d, 0x90170110 },
2027     { 0x0e, 0x40f000f0 },
2028     { 0x0f, 0x40f000f0 },
2029     { 0x10, 0x40f000f0 },
2030     { 0x11, 0x90a60160 },
2031     { 0x1f, 0x40f000f0 },
2032     { 0x20, 0x40f000f0 },
2033     {}
2034 };
2035
2036 static const struct hda_pintbl dell_vostro_3500_pin_configs[] = {
2037     { 0x0a, 0x02a11020 },
2038     { 0x0b, 0x0221101f },
2039     { 0x0c, 0x400000f0 },
2040     { 0x0d, 0x90170110 },
2041     { 0x0e, 0x400000f1 },
2042     { 0x0f, 0x400000f2 },
2043     { 0x10, 0x400000f3 },
2044     { 0x11, 0x90a60160 },
2045     { 0x1f, 0x400000f4 },
2046     { 0x20, 0x400000f5 },
2047     {}
2048 };
2049
2050 static const struct hda_pintbl hp_dv7_4000_pin_configs[] = {
2051     { 0x0a, 0x03a12050 },
2052     { 0x0b, 0x0321201f },
2053     { 0x0c, 0x40f000f0 },
2054     { 0x0d, 0x90170110 },
2055     { 0x0e, 0x40f000f0 },
2056     { 0x0f, 0x40f000f0 },
2057     { 0x10, 0x90170110 },
2058     { 0x11, 0xd5a30140 },
2059     { 0x1f, 0x40f000f0 },
2060     { 0x20, 0x40f000f0 },
2061     {}
2062 };
2063
2064 static const struct hda_pintbl hp_zephyr_pin_configs[] = {
2065     { 0x0a, 0x01813050 },
2066     { 0x0b, 0x0421201f },
2067     { 0x0c, 0x04a1205e },
2068     { 0x0d, 0x96130310 },
2069     { 0x0e, 0x96130310 },
2070     { 0x0f, 0x0101401f },
2071     { 0x10, 0x1111611f },
2072     { 0x11, 0xd5a30130 },
2073     {}
2074 };
2075
2076 static const struct hda_pintbl hp_cNB11_intquad_pin_configs[] = {
2077     { 0x0a, 0x40f000f0 },
2078     { 0x0b, 0x0221101f },
2079     { 0x0c, 0x02a11020 },
2080     { 0x0d, 0x92170110 },
2081     { 0x0e, 0x40f000f0 },
2082     { 0x0f, 0x92170110 },
2083     { 0x10, 0x40f000f0 },
2084     { 0x11, 0xd5a30130 },
2085     { 0x1f, 0x40f000f0 },
2086     { 0x20, 0x40f000f0 },
2087     {}
2088 };
2089
2090 static void stac92hd83xxx_fixup_hp(struct hda_codec *codec,
2091                    const struct hda_fixup *fix, int action)
2092 {
2093     struct sigmatel_spec *spec = codec->spec;
2094
2095     if (action != HDA_FIXUP_ACT_PRE_PROBE)
2096         return;
2097
2098     if (hp_bnb2011_with_dock(codec)) {
2099         snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f);
2100         snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e);
2101     }
2102
2103     if (find_mute_led_cfg(codec, spec->default_polarity))
2104         codec_dbg(codec, "mute LED gpio %d polarity %d\n",
2105                 spec->gpio_led,
2106                 spec->gpio_led_polarity);
2107
2108     /* allow auto-switching of dock line-in */
2109     spec->gen.line_in_auto_switch = true;
2110 }
2111
2112 static void stac92hd83xxx_fixup_hp_zephyr(struct hda_codec *codec,
2113                    const struct hda_fixup *fix, int action)
2114 {
2115     if (action != HDA_FIXUP_ACT_PRE_PROBE)
2116         return;
2117
2118     snd_hda_apply_pincfgs(codec, hp_zephyr_pin_configs);
2119     snd_hda_add_verbs(codec, stac92hd83xxx_hp_zephyr_init);
2120 }
2121
2122 static void stac92hd83xxx_fixup_hp_led(struct hda_codec *codec,
2123                    const struct hda_fixup *fix, int action)
2124 {
2125     struct sigmatel_spec *spec = codec->spec;
2126
2127     if (action == HDA_FIXUP_ACT_PRE_PROBE)
2128         spec->default_polarity = 0;
2129 }
2130
2131 static void stac92hd83xxx_fixup_hp_inv_led(struct hda_codec *codec,
2132                    const struct hda_fixup *fix, int action)
2133 {
2134     struct sigmatel_spec *spec = codec->spec;
2135
2136     if (action == HDA_FIXUP_ACT_PRE_PROBE)
2137         spec->default_polarity = 1;
2138 }
2139
2140 static void stac92hd83xxx_fixup_hp_mic_led(struct hda_codec *codec,
2141                    const struct hda_fixup *fix, int action)
2142 {
2143     struct sigmatel_spec *spec = codec->spec;
2144
2145     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2146         spec->mic_mute_led_gpio = 0x08; /* GPIO3 */
2147 #ifdef CONFIG_PM
2148         /* resetting controller clears GPIO, so we need to keep on */
2149         codec->core.power_caps &= ~AC_PWRST_CLKSTOP;
2150 #endif
2151     }
2152 }
2153
2154 static void stac92hd83xxx_fixup_hp_led_gpio10(struct hda_codec *codec,
2155                    const struct hda_fixup *fix, int action)
2156 {
2157     struct sigmatel_spec *spec = codec->spec;
2158
2159     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
2160         spec->gpio_led = 0x10; /* GPIO4 */
2161         spec->default_polarity = 0;
2162     }
2163 }
2164
2165 static void stac92hd83xxx_fixup_headset_jack(struct hda_codec *codec,
2166                    const struct hda_fixup *fix, int action)
2167 {
2168     struct sigmatel_spec *spec = codec->spec;
2169
2170     if (action == HDA_FIXUP_ACT_PRE_PROBE)
2171         spec->headset_jack = 1;
2172 }
2173
2174 static void stac92hd83xxx_fixup_gpio10_eapd(struct hda_codec *codec,
2175                         const struct hda_fixup *fix,
2176                         int action)
2177 {
2178     struct sigmatel_spec *spec = codec->spec;
2179
2180     if (action != HDA_FIXUP_ACT_PRE_PROBE)
2181         return;
2182     spec->eapd_mask = spec->gpio_mask = spec->gpio_dir =
2183         spec->gpio_data = 0x10;
2184     spec->eapd_switch = 0;
2185 }
2186
2187 static void hp_envy_ts_fixup_dac_bind(struct hda_codec *codec,
2188                         const struct hda_fixup *fix,
2189                         int action)
2190 {
2191     struct sigmatel_spec *spec = codec->spec;
2192     static const hda_nid_t preferred_pairs[] = {
2193         0xd, 0x13,
2194         0
2195     };
2196
2197     if (action != HDA_FIXUP_ACT_PRE_PROBE)
2198         return;
2199
2200     spec->gen.preferred_dacs = preferred_pairs;
2201 }
2202
2203 static const struct hda_verb hp_bnb13_eq_verbs[] = {
2204     /* 44.1KHz base */
2205     { 0x22, 0x7A6, 0x3E },
2206     { 0x22, 0x7A7, 0x68 },
2207     { 0x22, 0x7A8, 0x17 },
2208     { 0x22, 0x7A9, 0x3E },
2209     { 0x22, 0x7AA, 0x68 },
2210     { 0x22, 0x7AB, 0x17 },
2211     { 0x22, 0x7AC, 0x00 },
2212     { 0x22, 0x7AD, 0x80 },
2213     { 0x22, 0x7A6, 0x83 },
2214     { 0x22, 0x7A7, 0x2F },
2215     { 0x22, 0x7A8, 0xD1 },
2216     { 0x22, 0x7A9, 0x83 },
2217     { 0x22, 0x7AA, 0x2F },
2218     { 0x22, 0x7AB, 0xD1 },
2219     { 0x22, 0x7AC, 0x01 },
2220     { 0x22, 0x7AD, 0x80 },
2221     { 0x22, 0x7A6, 0x3E },
2222     { 0x22, 0x7A7, 0x68 },
2223     { 0x22, 0x7A8, 0x17 },
2224     { 0x22, 0x7A9, 0x3E },
2225     { 0x22, 0x7AA, 0x68 },
2226     { 0x22, 0x7AB, 0x17 },
2227     { 0x22, 0x7AC, 0x02 },
2228     { 0x22, 0x7AD, 0x80 },
2229     { 0x22, 0x7A6, 0x7C },
2230     { 0x22, 0x7A7, 0xC6 },
2231     { 0x22, 0x7A8, 0x0C },
2232     { 0x22, 0x7A9, 0x7C },
2233     { 0x22, 0x7AA, 0xC6 },
2234     { 0x22, 0x7AB, 0x0C },
2235     { 0x22, 0x7AC, 0x03 },
2236     { 0x22, 0x7AD, 0x80 },
2237     { 0x22, 0x7A6, 0xC3 },
2238     { 0x22, 0x7A7, 0x25 },
2239     { 0x22, 0x7A8, 0xAF },
2240     { 0x22, 0x7A9, 0xC3 },
2241     { 0x22, 0x7AA, 0x25 },
2242     { 0x22, 0x7AB, 0xAF },
2243     { 0x22, 0x7AC, 0x04 },
2244     { 0x22, 0x7AD, 0x80 },
2245     { 0x22, 0x7A6, 0x3E },
2246     { 0x22, 0x7A7, 0x85 },
2247     { 0x22, 0x7A8, 0x73 },
2248     { 0x22, 0x7A9, 0x3E },
2249     { 0x22, 0x7AA, 0x85 },
2250     { 0x22, 0x7AB, 0x73 },
2251     { 0x22, 0x7AC, 0x05 },
2252     { 0x22, 0x7AD, 0x80 },
2253     { 0x22, 0x7A6, 0x85 },
2254     { 0x22, 0x7A7, 0x39 },
2255     { 0x22, 0x7A8, 0xC7 },
2256     { 0x22, 0x7A9, 0x85 },
2257     { 0x22, 0x7AA, 0x39 },
2258     { 0x22, 0x7AB, 0xC7 },
2259     { 0x22, 0x7AC, 0x06 },
2260     { 0x22, 0x7AD, 0x80 },
2261     { 0x22, 0x7A6, 0x3C },
2262     { 0x22, 0x7A7, 0x90 },
2263     { 0x22, 0x7A8, 0xB0 },
2264     { 0x22, 0x7A9, 0x3C },
2265     { 0x22, 0x7AA, 0x90 },
2266     { 0x22, 0x7AB, 0xB0 },
2267     { 0x22, 0x7AC, 0x07 },
2268     { 0x22, 0x7AD, 0x80 },
2269     { 0x22, 0x7A6, 0x7A },
2270     { 0x22, 0x7A7, 0xC6 },
2271     { 0x22, 0x7A8, 0x39 },
2272     { 0x22, 0x7A9, 0x7A },
2273     { 0x22, 0x7AA, 0xC6 },
2274     { 0x22, 0x7AB, 0x39 },
2275     { 0x22, 0x7AC, 0x08 },
2276     { 0x22, 0x7AD, 0x80 },
2277     { 0x22, 0x7A6, 0xC4 },
2278     { 0x22, 0x7A7, 0xE9 },
2279     { 0x22, 0x7A8, 0xDC },
2280     { 0x22, 0x7A9, 0xC4 },
2281     { 0x22, 0x7AA, 0xE9 },
2282     { 0x22, 0x7AB, 0xDC },
2283     { 0x22, 0x7AC, 0x09 },
2284     { 0x22, 0x7AD, 0x80 },
2285     { 0x22, 0x7A6, 0x3D },
2286     { 0x22, 0x7A7, 0xE1 },
2287     { 0x22, 0x7A8, 0x0D },
2288     { 0x22, 0x7A9, 0x3D },
2289     { 0x22, 0x7AA, 0xE1 },
2290     { 0x22, 0x7AB, 0x0D },
2291     { 0x22, 0x7AC, 0x0A },
2292     { 0x22, 0x7AD, 0x80 },
2293     { 0x22, 0x7A6, 0x89 },
2294     { 0x22, 0x7A7, 0xB6 },
2295     { 0x22, 0x7A8, 0xEB },
2296     { 0x22, 0x7A9, 0x89 },
2297     { 0x22, 0x7AA, 0xB6 },
2298     { 0x22, 0x7AB, 0xEB },
2299     { 0x22, 0x7AC, 0x0B },
2300     { 0x22, 0x7AD, 0x80 },
2301     { 0x22, 0x7A6, 0x39 },
2302     { 0x22, 0x7A7, 0x9D },
2303     { 0x22, 0x7A8, 0xFE },
2304     { 0x22, 0x7A9, 0x39 },
2305     { 0x22, 0x7AA, 0x9D },
2306     { 0x22, 0x7AB, 0xFE },
2307     { 0x22, 0x7AC, 0x0C },
2308     { 0x22, 0x7AD, 0x80 },
2309     { 0x22, 0x7A6, 0x76 },
2310     { 0x22, 0x7A7, 0x49 },
2311     { 0x22, 0x7A8, 0x15 },
2312     { 0x22, 0x7A9, 0x76 },
2313     { 0x22, 0x7AA, 0x49 },
2314     { 0x22, 0x7AB, 0x15 },
2315     { 0x22, 0x7AC, 0x0D },
2316     { 0x22, 0x7AD, 0x80 },
2317     { 0x22, 0x7A6, 0xC8 },
2318     { 0x22, 0x7A7, 0x80 },
2319     { 0x22, 0x7A8, 0xF5 },
2320     { 0x22, 0x7A9, 0xC8 },
2321     { 0x22, 0x7AA, 0x80 },
2322     { 0x22, 0x7AB, 0xF5 },
2323     { 0x22, 0x7AC, 0x0E },
2324     { 0x22, 0x7AD, 0x80 },
2325     { 0x22, 0x7A6, 0x40 },
2326     { 0x22, 0x7A7, 0x00 },
2327     { 0x22, 0x7A8, 0x00 },
2328     { 0x22, 0x7A9, 0x40 },
2329     { 0x22, 0x7AA, 0x00 },
2330     { 0x22, 0x7AB, 0x00 },
2331     { 0x22, 0x7AC, 0x0F },
2332     { 0x22, 0x7AD, 0x80 },
2333     { 0x22, 0x7A6, 0x90 },
2334     { 0x22, 0x7A7, 0x68 },
2335     { 0x22, 0x7A8, 0xF1 },
2336     { 0x22, 0x7A9, 0x90 },
2337     { 0x22, 0x7AA, 0x68 },
2338     { 0x22, 0x7AB, 0xF1 },
2339     { 0x22, 0x7AC, 0x10 },
2340     { 0x22, 0x7AD, 0x80 },
2341     { 0x22, 0x7A6, 0x34 },
2342     { 0x22, 0x7A7, 0x47 },
2343     { 0x22, 0x7A8, 0x6C },
2344     { 0x22, 0x7A9, 0x34 },
2345     { 0x22, 0x7AA, 0x47 },
2346     { 0x22, 0x7AB, 0x6C },
2347     { 0x22, 0x7AC, 0x11 },
2348     { 0x22, 0x7AD, 0x80 },
2349     { 0x22, 0x7A6, 0x6F },
2350     { 0x22, 0x7A7, 0x97 },
2351     { 0x22, 0x7A8, 0x0F },
2352     { 0x22, 0x7A9, 0x6F },
2353     { 0x22, 0x7AA, 0x97 },
2354     { 0x22, 0x7AB, 0x0F },
2355     { 0x22, 0x7AC, 0x12 },
2356     { 0x22, 0x7AD, 0x80 },
2357     { 0x22, 0x7A6, 0xCB },
2358     { 0x22, 0x7A7, 0xB8 },
2359     { 0x22, 0x7A8, 0x94 },
2360     { 0x22, 0x7A9, 0xCB },
2361     { 0x22, 0x7AA, 0xB8 },
2362     { 0x22, 0x7AB, 0x94 },
2363     { 0x22, 0x7AC, 0x13 },
2364     { 0x22, 0x7AD, 0x80 },
2365     { 0x22, 0x7A6, 0x40 },
2366     { 0x22, 0x7A7, 0x00 },
2367     { 0x22, 0x7A8, 0x00 },
2368     { 0x22, 0x7A9, 0x40 },
2369     { 0x22, 0x7AA, 0x00 },
2370     { 0x22, 0x7AB, 0x00 },
2371     { 0x22, 0x7AC, 0x14 },
2372     { 0x22, 0x7AD, 0x80 },
2373     { 0x22, 0x7A6, 0x95 },
2374     { 0x22, 0x7A7, 0x76 },
2375     { 0x22, 0x7A8, 0x5B },
2376     { 0x22, 0x7A9, 0x95 },
2377     { 0x22, 0x7AA, 0x76 },
2378     { 0x22, 0x7AB, 0x5B },
2379     { 0x22, 0x7AC, 0x15 },
2380     { 0x22, 0x7AD, 0x80 },
2381     { 0x22, 0x7A6, 0x31 },
2382     { 0x22, 0x7A7, 0xAC },
2383     { 0x22, 0x7A8, 0x31 },
2384     { 0x22, 0x7A9, 0x31 },
2385     { 0x22, 0x7AA, 0xAC },
2386     { 0x22, 0x7AB, 0x31 },
2387     { 0x22, 0x7AC, 0x16 },
2388     { 0x22, 0x7AD, 0x80 },
2389     { 0x22, 0x7A6, 0x6A },
2390     { 0x22, 0x7A7, 0x89 },
2391     { 0x22, 0x7A8, 0xA5 },
2392     { 0x22, 0x7A9, 0x6A },
2393     { 0x22, 0x7AA, 0x89 },
2394     { 0x22, 0x7AB, 0xA5 },
2395     { 0x22, 0x7AC, 0x17 },
2396     { 0x22, 0x7AD, 0x80 },
2397     { 0x22, 0x7A6, 0xCE },
2398     { 0x22, 0x7A7, 0x53 },
2399     { 0x22, 0x7A8, 0xCF },
2400     { 0x22, 0x7A9, 0xCE },
2401     { 0x22, 0x7AA, 0x53 },
2402     { 0x22, 0x7AB, 0xCF },
2403     { 0x22, 0x7AC, 0x18 },
2404     { 0x22, 0x7AD, 0x80 },
2405     { 0x22, 0x7A6, 0x40 },
2406     { 0x22, 0x7A7, 0x00 },
2407     { 0x22, 0x7A8, 0x00 },
2408     { 0x22, 0x7A9, 0x40 },
2409     { 0x22, 0x7AA, 0x00 },
2410     { 0x22, 0x7AB, 0x00 },
2411     { 0x22, 0x7AC, 0x19 },
2412     { 0x22, 0x7AD, 0x80 },
2413     /* 48KHz base */
2414     { 0x22, 0x7A6, 0x3E },
2415     { 0x22, 0x7A7, 0x88 },
2416     { 0x22, 0x7A8, 0xDC },
2417     { 0x22, 0x7A9, 0x3E },
2418     { 0x22, 0x7AA, 0x88 },
2419     { 0x22, 0x7AB, 0xDC },
2420     { 0x22, 0x7AC, 0x1A },
2421     { 0x22, 0x7AD, 0x80 },
2422     { 0x22, 0x7A6, 0x82 },
2423     { 0x22, 0x7A7, 0xEE },
2424     { 0x22, 0x7A8, 0x46 },
2425     { 0x22, 0x7A9, 0x82 },
2426     { 0x22, 0x7AA, 0xEE },
2427     { 0x22, 0x7AB, 0x46 },
2428     { 0x22, 0x7AC, 0x1B },
2429     { 0x22, 0x7AD, 0x80 },
2430     { 0x22, 0x7A6, 0x3E },
2431     { 0x22, 0x7A7, 0x88 },
2432     { 0x22, 0x7A8, 0xDC },
2433     { 0x22, 0x7A9, 0x3E },
2434     { 0x22, 0x7AA, 0x88 },
2435     { 0x22, 0x7AB, 0xDC },
2436     { 0x22, 0x7AC, 0x1C },
2437     { 0x22, 0x7AD, 0x80 },
2438     { 0x22, 0x7A6, 0x7D },
2439     { 0x22, 0x7A7, 0x09 },
2440     { 0x22, 0x7A8, 0x28 },
2441     { 0x22, 0x7A9, 0x7D },
2442     { 0x22, 0x7AA, 0x09 },
2443     { 0x22, 0x7AB, 0x28 },
2444     { 0x22, 0x7AC, 0x1D },
2445     { 0x22, 0x7AD, 0x80 },
2446     { 0x22, 0x7A6, 0xC2 },
2447     { 0x22, 0x7A7, 0xE5 },
2448     { 0x22, 0x7A8, 0xB4 },
2449     { 0x22, 0x7A9, 0xC2 },
2450     { 0x22, 0x7AA, 0xE5 },
2451     { 0x22, 0x7AB, 0xB4 },
2452     { 0x22, 0x7AC, 0x1E },
2453     { 0x22, 0x7AD, 0x80 },
2454     { 0x22, 0x7A6, 0x3E },
2455     { 0x22, 0x7A7, 0xA3 },
2456     { 0x22, 0x7A8, 0x1F },
2457     { 0x22, 0x7A9, 0x3E },
2458     { 0x22, 0x7AA, 0xA3 },
2459     { 0x22, 0x7AB, 0x1F },
2460     { 0x22, 0x7AC, 0x1F },
2461     { 0x22, 0x7AD, 0x80 },
2462     { 0x22, 0x7A6, 0x84 },
2463     { 0x22, 0x7A7, 0xCA },
2464     { 0x22, 0x7A8, 0xF1 },
2465     { 0x22, 0x7A9, 0x84 },
2466     { 0x22, 0x7AA, 0xCA },
2467     { 0x22, 0x7AB, 0xF1 },
2468     { 0x22, 0x7AC, 0x20 },
2469     { 0x22, 0x7AD, 0x80 },
2470     { 0x22, 0x7A6, 0x3C },
2471     { 0x22, 0x7A7, 0xD5 },
2472     { 0x22, 0x7A8, 0x9C },
2473     { 0x22, 0x7A9, 0x3C },
2474     { 0x22, 0x7AA, 0xD5 },
2475     { 0x22, 0x7AB, 0x9C },
2476     { 0x22, 0x7AC, 0x21 },
2477     { 0x22, 0x7AD, 0x80 },
2478     { 0x22, 0x7A6, 0x7B },
2479     { 0x22, 0x7A7, 0x35 },
2480     { 0x22, 0x7A8, 0x0F },
2481     { 0x22, 0x7A9, 0x7B },
2482     { 0x22, 0x7AA, 0x35 },
2483     { 0x22, 0x7AB, 0x0F },
2484     { 0x22, 0x7AC, 0x22 },
2485     { 0x22, 0x7AD, 0x80 },
2486     { 0x22, 0x7A6, 0xC4 },
2487     { 0x22, 0x7A7, 0x87 },
2488     { 0x22, 0x7A8, 0x45 },
2489     { 0x22, 0x7A9, 0xC4 },
2490     { 0x22, 0x7AA, 0x87 },
2491     { 0x22, 0x7AB, 0x45 },
2492     { 0x22, 0x7AC, 0x23 },
2493     { 0x22, 0x7AD, 0x80 },
2494     { 0x22, 0x7A6, 0x3E },
2495     { 0x22, 0x7A7, 0x0A },
2496     { 0x22, 0x7A8, 0x78 },
2497     { 0x22, 0x7A9, 0x3E },
2498     { 0x22, 0x7AA, 0x0A },
2499     { 0x22, 0x7AB, 0x78 },
2500     { 0x22, 0x7AC, 0x24 },
2501     { 0x22, 0x7AD, 0x80 },
2502     { 0x22, 0x7A6, 0x88 },
2503     { 0x22, 0x7A7, 0xE2 },
2504     { 0x22, 0x7A8, 0x05 },
2505     { 0x22, 0x7A9, 0x88 },
2506     { 0x22, 0x7AA, 0xE2 },
2507     { 0x22, 0x7AB, 0x05 },
2508     { 0x22, 0x7AC, 0x25 },
2509     { 0x22, 0x7AD, 0x80 },
2510     { 0x22, 0x7A6, 0x3A },
2511     { 0x22, 0x7A7, 0x1A },
2512     { 0x22, 0x7A8, 0xA3 },
2513     { 0x22, 0x7A9, 0x3A },
2514     { 0x22, 0x7AA, 0x1A },
2515     { 0x22, 0x7AB, 0xA3 },
2516     { 0x22, 0x7AC, 0x26 },
2517     { 0x22, 0x7AD, 0x80 },
2518     { 0x22, 0x7A6, 0x77 },
2519     { 0x22, 0x7A7, 0x1D },
2520     { 0x22, 0x7A8, 0xFB },
2521     { 0x22, 0x7A9, 0x77 },
2522     { 0x22, 0x7AA, 0x1D },
2523     { 0x22, 0x7AB, 0xFB },
2524     { 0x22, 0x7AC, 0x27 },
2525     { 0x22, 0x7AD, 0x80 },
2526     { 0x22, 0x7A6, 0xC7 },
2527     { 0x22, 0x7A7, 0xDA },
2528     { 0x22, 0x7A8, 0xE5 },
2529     { 0x22, 0x7A9, 0xC7 },
2530     { 0x22, 0x7AA, 0xDA },
2531     { 0x22, 0x7AB, 0xE5 },
2532     { 0x22, 0x7AC, 0x28 },
2533     { 0x22, 0x7AD, 0x80 },
2534     { 0x22, 0x7A6, 0x40 },
2535     { 0x22, 0x7A7, 0x00 },
2536     { 0x22, 0x7A8, 0x00 },
2537     { 0x22, 0x7A9, 0x40 },
2538     { 0x22, 0x7AA, 0x00 },
2539     { 0x22, 0x7AB, 0x00 },
2540     { 0x22, 0x7AC, 0x29 },
2541     { 0x22, 0x7AD, 0x80 },
2542     { 0x22, 0x7A6, 0x8E },
2543     { 0x22, 0x7A7, 0xD7 },
2544     { 0x22, 0x7A8, 0x22 },
2545     { 0x22, 0x7A9, 0x8E },
2546     { 0x22, 0x7AA, 0xD7 },
2547     { 0x22, 0x7AB, 0x22 },
2548     { 0x22, 0x7AC, 0x2A },
2549     { 0x22, 0x7AD, 0x80 },
2550     { 0x22, 0x7A6, 0x35 },
2551     { 0x22, 0x7A7, 0x26 },
2552     { 0x22, 0x7A8, 0xC6 },
2553     { 0x22, 0x7A9, 0x35 },
2554     { 0x22, 0x7AA, 0x26 },
2555     { 0x22, 0x7AB, 0xC6 },
2556     { 0x22, 0x7AC, 0x2B },
2557     { 0x22, 0x7AD, 0x80 },
2558     { 0x22, 0x7A6, 0x71 },
2559     { 0x22, 0x7A7, 0x28 },
2560     { 0x22, 0x7A8, 0xDE },
2561     { 0x22, 0x7A9, 0x71 },
2562     { 0x22, 0x7AA, 0x28 },
2563     { 0x22, 0x7AB, 0xDE },
2564     { 0x22, 0x7AC, 0x2C },
2565     { 0x22, 0x7AD, 0x80 },
2566     { 0x22, 0x7A6, 0xCA },
2567     { 0x22, 0x7A7, 0xD9 },
2568     { 0x22, 0x7A8, 0x3A },
2569     { 0x22, 0x7A9, 0xCA },
2570     { 0x22, 0x7AA, 0xD9 },
2571     { 0x22, 0x7AB, 0x3A },
2572     { 0x22, 0x7AC, 0x2D },
2573     { 0x22, 0x7AD, 0x80 },
2574     { 0x22, 0x7A6, 0x40 },
2575     { 0x22, 0x7A7, 0x00 },
2576     { 0x22, 0x7A8, 0x00 },
2577     { 0x22, 0x7A9, 0x40 },
2578     { 0x22, 0x7AA, 0x00 },
2579     { 0x22, 0x7AB, 0x00 },
2580     { 0x22, 0x7AC, 0x2E },
2581     { 0x22, 0x7AD, 0x80 },
2582     { 0x22, 0x7A6, 0x93 },
2583     { 0x22, 0x7A7, 0x5E },
2584     { 0x22, 0x7A8, 0xD8 },
2585     { 0x22, 0x7A9, 0x93 },
2586     { 0x22, 0x7AA, 0x5E },
2587     { 0x22, 0x7AB, 0xD8 },
2588     { 0x22, 0x7AC, 0x2F },
2589     { 0x22, 0x7AD, 0x80 },
2590     { 0x22, 0x7A6, 0x32 },
2591     { 0x22, 0x7A7, 0xB7 },
2592     { 0x22, 0x7A8, 0xB1 },
2593     { 0x22, 0x7A9, 0x32 },
2594     { 0x22, 0x7AA, 0xB7 },
2595     { 0x22, 0x7AB, 0xB1 },
2596     { 0x22, 0x7AC, 0x30 },
2597     { 0x22, 0x7AD, 0x80 },
2598     { 0x22, 0x7A6, 0x6C },
2599     { 0x22, 0x7A7, 0xA1 },
2600     { 0x22, 0x7A8, 0x28 },
2601     { 0x22, 0x7A9, 0x6C },
2602     { 0x22, 0x7AA, 0xA1 },
2603     { 0x22, 0x7AB, 0x28 },
2604     { 0x22, 0x7AC, 0x31 },
2605     { 0x22, 0x7AD, 0x80 },
2606     { 0x22, 0x7A6, 0xCD },
2607     { 0x22, 0x7A7, 0x48 },
2608     { 0x22, 0x7A8, 0x4F },
2609     { 0x22, 0x7A9, 0xCD },
2610     { 0x22, 0x7AA, 0x48 },
2611     { 0x22, 0x7AB, 0x4F },
2612     { 0x22, 0x7AC, 0x32 },
2613     { 0x22, 0x7AD, 0x80 },
2614     { 0x22, 0x7A6, 0x40 },
2615     { 0x22, 0x7A7, 0x00 },
2616     { 0x22, 0x7A8, 0x00 },
2617     { 0x22, 0x7A9, 0x40 },
2618     { 0x22, 0x7AA, 0x00 },
2619     { 0x22, 0x7AB, 0x00 },
2620     { 0x22, 0x7AC, 0x33 },
2621     { 0x22, 0x7AD, 0x80 },
2622     /* common */
2623     { 0x22, 0x782, 0xC1 },
2624     { 0x22, 0x771, 0x2C },
2625     { 0x22, 0x772, 0x2C },
2626     { 0x22, 0x788, 0x04 },
2627     { 0x01, 0x7B0, 0x08 },
2628     {}
2629 };
2630
2631 static const struct hda_fixup stac92hd83xxx_fixups[] = {
2632     [STAC_92HD83XXX_REF] = {
2633         .type = HDA_FIXUP_PINS,
2634         .v.pins = ref92hd83xxx_pin_configs,
2635     },
2636     [STAC_92HD83XXX_PWR_REF] = {
2637         .type = HDA_FIXUP_PINS,
2638         .v.pins = ref92hd83xxx_pin_configs,
2639     },
2640     [STAC_DELL_S14] = {
2641         .type = HDA_FIXUP_PINS,
2642         .v.pins = dell_s14_pin_configs,
2643     },
2644     [STAC_DELL_VOSTRO_3500] = {
2645         .type = HDA_FIXUP_PINS,
2646         .v.pins = dell_vostro_3500_pin_configs,
2647     },
2648     [STAC_92HD83XXX_HP_cNB11_INTQUAD] = {
2649         .type = HDA_FIXUP_PINS,
2650         .v.pins = hp_cNB11_intquad_pin_configs,
2651         .chained = true,
2652         .chain_id = STAC_92HD83XXX_HP,
2653     },
2654     [STAC_92HD83XXX_HP] = {
2655         .type = HDA_FIXUP_FUNC,
2656         .v.func = stac92hd83xxx_fixup_hp,
2657     },
2658     [STAC_HP_DV7_4000] = {
2659         .type = HDA_FIXUP_PINS,
2660         .v.pins = hp_dv7_4000_pin_configs,
2661         .chained = true,
2662         .chain_id = STAC_92HD83XXX_HP,
2663     },
2664     [STAC_HP_ZEPHYR] = {
2665         .type = HDA_FIXUP_FUNC,
2666         .v.func = stac92hd83xxx_fixup_hp_zephyr,
2667         .chained = true,
2668         .chain_id = STAC_92HD83XXX_HP,
2669     },
2670     [STAC_92HD83XXX_HP_LED] = {
2671         .type = HDA_FIXUP_FUNC,
2672         .v.func = stac92hd83xxx_fixup_hp_led,
2673         .chained = true,
2674         .chain_id = STAC_92HD83XXX_HP,
2675     },
2676     [STAC_92HD83XXX_HP_INV_LED] = {
2677         .type = HDA_FIXUP_FUNC,
2678         .v.func = stac92hd83xxx_fixup_hp_inv_led,
2679         .chained = true,
2680         .chain_id = STAC_92HD83XXX_HP,
2681     },
2682     [STAC_92HD83XXX_HP_MIC_LED] = {
2683         .type = HDA_FIXUP_FUNC,
2684         .v.func = stac92hd83xxx_fixup_hp_mic_led,
2685         .chained = true,
2686         .chain_id = STAC_92HD83XXX_HP,
2687     },
2688     [STAC_HP_LED_GPIO10] = {
2689         .type = HDA_FIXUP_FUNC,
2690         .v.func = stac92hd83xxx_fixup_hp_led_gpio10,
2691         .chained = true,
2692         .chain_id = STAC_92HD83XXX_HP,
2693     },
2694     [STAC_92HD83XXX_HEADSET_JACK] = {
2695         .type = HDA_FIXUP_FUNC,
2696         .v.func = stac92hd83xxx_fixup_headset_jack,
2697     },
2698     [STAC_HP_ENVY_BASS] = {
2699         .type = HDA_FIXUP_PINS,
2700         .v.pins = (const struct hda_pintbl[]) {
2701             { 0x0f, 0x90170111 },
2702             {}
2703         },
2704     },
2705     [STAC_HP_BNB13_EQ] = {
2706         .type = HDA_FIXUP_VERBS,
2707         .v.verbs = hp_bnb13_eq_verbs,
2708         .chained = true,
2709         .chain_id = STAC_92HD83XXX_HP_MIC_LED,
2710     },
2711     [STAC_HP_ENVY_TS_BASS] = {
2712         .type = HDA_FIXUP_PINS,
2713         .v.pins = (const struct hda_pintbl[]) {
2714             { 0x10, 0x92170111 },
2715             {}
2716         },
2717     },
2718     [STAC_HP_ENVY_TS_DAC_BIND] = {
2719         .type = HDA_FIXUP_FUNC,
2720         .v.func = hp_envy_ts_fixup_dac_bind,
2721         .chained = true,
2722         .chain_id = STAC_HP_ENVY_TS_BASS,
2723     },
2724     [STAC_92HD83XXX_GPIO10_EAPD] = {
2725         .type = HDA_FIXUP_FUNC,
2726         .v.func = stac92hd83xxx_fixup_gpio10_eapd,
2727     },
2728 };
2729
2730 static const struct hda_model_fixup stac92hd83xxx_models[] = {
2731     { .id = STAC_92HD83XXX_REF, .name = "ref" },
2732     { .id = STAC_92HD83XXX_PWR_REF, .name = "mic-ref" },
2733     { .id = STAC_DELL_S14, .name = "dell-s14" },
2734     { .id = STAC_DELL_VOSTRO_3500, .name = "dell-vostro-3500" },
2735     { .id = STAC_92HD83XXX_HP_cNB11_INTQUAD, .name = "hp_cNB11_intquad" },
2736     { .id = STAC_HP_DV7_4000, .name = "hp-dv7-4000" },
2737     { .id = STAC_HP_ZEPHYR, .name = "hp-zephyr" },
2738     { .id = STAC_92HD83XXX_HP_LED, .name = "hp-led" },
2739     { .id = STAC_92HD83XXX_HP_INV_LED, .name = "hp-inv-led" },
2740     { .id = STAC_92HD83XXX_HP_MIC_LED, .name = "hp-mic-led" },
2741     { .id = STAC_92HD83XXX_HEADSET_JACK, .name = "headset-jack" },
2742     { .id = STAC_HP_ENVY_BASS, .name = "hp-envy-bass" },
2743     { .id = STAC_HP_BNB13_EQ, .name = "hp-bnb13-eq" },
2744     { .id = STAC_HP_ENVY_TS_BASS, .name = "hp-envy-ts-bass" },
2745     {}
2746 };
2747
2748 static const struct snd_pci_quirk stac92hd83xxx_fixup_tbl[] = {
2749     /* SigmaTel reference board */
2750     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2751               "DFI LanParty", STAC_92HD83XXX_REF),
2752     SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2753               "DFI LanParty", STAC_92HD83XXX_REF),
2754     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
2755               "unknown Dell", STAC_DELL_S14),
2756     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0532,
2757               "Dell Latitude E6230", STAC_92HD83XXX_HEADSET_JACK),
2758     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0533,
2759               "Dell Latitude E6330", STAC_92HD83XXX_HEADSET_JACK),
2760     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0534,
2761               "Dell Latitude E6430", STAC_92HD83XXX_HEADSET_JACK),
2762     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0535,
2763               "Dell Latitude E6530", STAC_92HD83XXX_HEADSET_JACK),
2764     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x053c,
2765               "Dell Latitude E5430", STAC_92HD83XXX_HEADSET_JACK),
2766     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x053d,
2767               "Dell Latitude E5530", STAC_92HD83XXX_HEADSET_JACK),
2768     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0549,
2769               "Dell Latitude E5430", STAC_92HD83XXX_HEADSET_JACK),
2770     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x057d,
2771               "Dell Latitude E6430s", STAC_92HD83XXX_HEADSET_JACK),
2772     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0584,
2773               "Dell Latitude E6430U", STAC_92HD83XXX_HEADSET_JACK),
2774     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x1028,
2775               "Dell Vostro 3500", STAC_DELL_VOSTRO_3500),
2776     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1656,
2777               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2778     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1657,
2779               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2780     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1658,
2781               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2782     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1659,
2783               "HP Pavilion dv7", STAC_HP_DV7_4000),
2784     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165A,
2785               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2786     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165B,
2787               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2788     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1888,
2789               "HP Envy Spectre", STAC_HP_ENVY_BASS),
2790     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1899,
2791               "HP Folio 13", STAC_HP_LED_GPIO10),
2792     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x18df,
2793               "HP Folio", STAC_HP_BNB13_EQ),
2794     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x18F8,
2795               "HP bNB13", STAC_HP_BNB13_EQ),
2796     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1909,
2797               "HP bNB13", STAC_HP_BNB13_EQ),
2798     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x190A,
2799               "HP bNB13", STAC_HP_BNB13_EQ),
2800     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x190e,
2801               "HP ENVY TS", STAC_HP_ENVY_TS_BASS),
2802     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1967,
2803               "HP ENVY TS", STAC_HP_ENVY_TS_DAC_BIND),
2804     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1940,
2805               "HP bNB13", STAC_HP_BNB13_EQ),
2806     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1941,
2807               "HP bNB13", STAC_HP_BNB13_EQ),
2808     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1942,
2809               "HP bNB13", STAC_HP_BNB13_EQ),
2810     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1943,
2811               "HP bNB13", STAC_HP_BNB13_EQ),
2812     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1944,
2813               "HP bNB13", STAC_HP_BNB13_EQ),
2814     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1945,
2815               "HP bNB13", STAC_HP_BNB13_EQ),
2816     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1946,
2817               "HP bNB13", STAC_HP_BNB13_EQ),
2818     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1948,
2819               "HP bNB13", STAC_HP_BNB13_EQ),
2820     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1949,
2821               "HP bNB13", STAC_HP_BNB13_EQ),
2822     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194A,
2823               "HP bNB13", STAC_HP_BNB13_EQ),
2824     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194B,
2825               "HP bNB13", STAC_HP_BNB13_EQ),
2826     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194C,
2827               "HP bNB13", STAC_HP_BNB13_EQ),
2828     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194E,
2829               "HP bNB13", STAC_HP_BNB13_EQ),
2830     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x194F,
2831               "HP bNB13", STAC_HP_BNB13_EQ),
2832     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1950,
2833               "HP bNB13", STAC_HP_BNB13_EQ),
2834     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1951,
2835               "HP bNB13", STAC_HP_BNB13_EQ),
2836     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x195A,
2837               "HP bNB13", STAC_HP_BNB13_EQ),
2838     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x195B,
2839               "HP bNB13", STAC_HP_BNB13_EQ),
2840     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x195C,
2841               "HP bNB13", STAC_HP_BNB13_EQ),
2842     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1991,
2843               "HP bNB13", STAC_HP_BNB13_EQ),
2844     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2103,
2845               "HP bNB13", STAC_HP_BNB13_EQ),
2846     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2104,
2847               "HP bNB13", STAC_HP_BNB13_EQ),
2848     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2105,
2849               "HP bNB13", STAC_HP_BNB13_EQ),
2850     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2106,
2851               "HP bNB13", STAC_HP_BNB13_EQ),
2852     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2107,
2853               "HP bNB13", STAC_HP_BNB13_EQ),
2854     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2108,
2855               "HP bNB13", STAC_HP_BNB13_EQ),
2856     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2109,
2857               "HP bNB13", STAC_HP_BNB13_EQ),
2858     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x210A,
2859               "HP bNB13", STAC_HP_BNB13_EQ),
2860     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x210B,
2861               "HP bNB13", STAC_HP_BNB13_EQ),
2862     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x211C,
2863               "HP bNB13", STAC_HP_BNB13_EQ),
2864     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x211D,
2865               "HP bNB13", STAC_HP_BNB13_EQ),
2866     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x211E,
2867               "HP bNB13", STAC_HP_BNB13_EQ),
2868     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x211F,
2869               "HP bNB13", STAC_HP_BNB13_EQ),
2870     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2120,
2871               "HP bNB13", STAC_HP_BNB13_EQ),
2872     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2121,
2873               "HP bNB13", STAC_HP_BNB13_EQ),
2874     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2122,
2875               "HP bNB13", STAC_HP_BNB13_EQ),
2876     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2123,
2877               "HP bNB13", STAC_HP_BNB13_EQ),
2878     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x213E,
2879               "HP bNB13", STAC_HP_BNB13_EQ),
2880     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x213F,
2881               "HP bNB13", STAC_HP_BNB13_EQ),
2882     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2140,
2883               "HP bNB13", STAC_HP_BNB13_EQ),
2884     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x21B2,
2885               "HP bNB13", STAC_HP_BNB13_EQ),
2886     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x21B3,
2887               "HP bNB13", STAC_HP_BNB13_EQ),
2888     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x21B5,
2889               "HP bNB13", STAC_HP_BNB13_EQ),
2890     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x21B6,
2891               "HP bNB13", STAC_HP_BNB13_EQ),
2892     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x1900,
2893               "HP", STAC_92HD83XXX_HP_MIC_LED),
2894     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x2000,
2895               "HP", STAC_92HD83XXX_HP_MIC_LED),
2896     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x2100,
2897               "HP", STAC_92HD83XXX_HP_MIC_LED),
2898     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3388,
2899               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2900     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3389,
2901               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2902     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355B,
2903               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2904     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355C,
2905               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2906     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355D,
2907               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2908     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355E,
2909               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2910     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355F,
2911               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2912     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3560,
2913               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2914     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358B,
2915               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2916     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358C,
2917               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2918     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358D,
2919               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2920     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3591,
2921               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2922     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3592,
2923               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2924     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3593,
2925               "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2926     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561,
2927               "HP", STAC_HP_ZEPHYR),
2928     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3660,
2929               "HP Mini", STAC_92HD83XXX_HP_LED),
2930     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x144E,
2931               "HP Pavilion dv5", STAC_92HD83XXX_HP_INV_LED),
2932     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x148a,
2933               "HP Mini", STAC_92HD83XXX_HP_LED),
2934     SND_PCI_QUIRK_VENDOR(PCI_VENDOR_ID_HP, "HP", STAC_92HD83XXX_HP),
2935     /* match both for 0xfa91 and 0xfa93 */
2936     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_TOSHIBA, 0xfffd, 0xfa91,
2937               "Toshiba Satellite S50D", STAC_92HD83XXX_GPIO10_EAPD),
2938     {} /* terminator */
2939 };
2940
2941 /* HP dv7 bass switch - GPIO5 */
2942 #define stac_hp_bass_gpio_info  snd_ctl_boolean_mono_info
2943 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
2944                  struct snd_ctl_elem_value *ucontrol)
2945 {
2946     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2947     struct sigmatel_spec *spec = codec->spec;
2948     ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
2949     return 0;
2950 }
2951
2952 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
2953                  struct snd_ctl_elem_value *ucontrol)
2954 {
2955     struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2956     struct sigmatel_spec *spec = codec->spec;
2957     unsigned int gpio_data;
2958
2959     gpio_data = (spec->gpio_data & ~0x20) |
2960         (ucontrol->value.integer.value[0] ? 0x20 : 0);
2961     if (gpio_data == spec->gpio_data)
2962         return 0;
2963     spec->gpio_data = gpio_data;
2964     stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
2965     return 1;
2966 }
2967
2968 static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
2969     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2970     .info = stac_hp_bass_gpio_info,
2971     .get = stac_hp_bass_gpio_get,
2972     .put = stac_hp_bass_gpio_put,
2973 };
2974
2975 static int stac_add_hp_bass_switch(struct hda_codec *codec)
2976 {
2977     struct sigmatel_spec *spec = codec->spec;
2978
2979     if (!snd_hda_gen_add_kctl(&spec->gen, "Bass Speaker Playback Switch",
2980                   &stac_hp_bass_sw_ctrl))
2981         return -ENOMEM;
2982
2983     spec->gpio_mask |= 0x20;
2984     spec->gpio_dir |= 0x20;
2985     spec->gpio_data |= 0x20;
2986     return 0;
2987 }
2988
2989 static const struct hda_pintbl ref92hd71bxx_pin_configs[] = {
2990     { 0x0a, 0x02214030 },
2991     { 0x0b, 0x02a19040 },
2992     { 0x0c, 0x01a19020 },
2993     { 0x0d, 0x01014010 },
2994     { 0x0e, 0x0181302e },
2995     { 0x0f, 0x01014010 },
2996     { 0x14, 0x01019020 },
2997     { 0x18, 0x90a000f0 },
2998     { 0x19, 0x90a000f0 },
2999     { 0x1e, 0x01452050 },
3000     { 0x1f, 0x01452050 },
3001     {}
3002 };
3003
3004 static const struct hda_pintbl dell_m4_1_pin_configs[] = {
3005     { 0x0a, 0x0421101f },
3006     { 0x0b, 0x04a11221 },
3007     { 0x0c, 0x40f000f0 },
3008     { 0x0d, 0x90170110 },
3009     { 0x0e, 0x23a1902e },
3010     { 0x0f, 0x23014250 },
3011     { 0x14, 0x40f000f0 },
3012     { 0x18, 0x90a000f0 },
3013     { 0x19, 0x40f000f0 },
3014     { 0x1e, 0x4f0000f0 },
3015     { 0x1f, 0x4f0000f0 },
3016     {}
3017 };
3018
3019 static const struct hda_pintbl dell_m4_2_pin_configs[] = {
3020     { 0x0a, 0x0421101f },
3021     { 0x0b, 0x04a11221 },
3022     { 0x0c, 0x90a70330 },
3023     { 0x0d, 0x90170110 },
3024     { 0x0e, 0x23a1902e },
3025     { 0x0f, 0x23014250 },
3026     { 0x14, 0x40f000f0 },
3027     { 0x18, 0x40f000f0 },
3028     { 0x19, 0x40f000f0 },
3029     { 0x1e, 0x044413b0 },
3030     { 0x1f, 0x044413b0 },
3031     {}
3032 };
3033
3034 static const struct hda_pintbl dell_m4_3_pin_configs[] = {
3035     { 0x0a, 0x0421101f },
3036     { 0x0b, 0x04a11221 },
3037     { 0x0c, 0x90a70330 },
3038     { 0x0d, 0x90170110 },
3039     { 0x0e, 0x40f000f0 },
3040     { 0x0f, 0x40f000f0 },
3041     { 0x14, 0x40f000f0 },
3042     { 0x18, 0x90a000f0 },
3043     { 0x19, 0x40f000f0 },
3044     { 0x1e, 0x044413b0 },
3045     { 0x1f, 0x044413b0 },
3046     {}
3047 };
3048
3049 static void stac92hd71bxx_fixup_ref(struct hda_codec *codec,
3050                     const struct hda_fixup *fix, int action)
3051 {
3052     struct sigmatel_spec *spec = codec->spec;
3053
3054     if (action != HDA_FIXUP_ACT_PRE_PROBE)
3055         return;
3056
3057     snd_hda_apply_pincfgs(codec, ref92hd71bxx_pin_configs);
3058     spec->gpio_mask = spec->gpio_dir = spec->gpio_data = 0;
3059 }
3060
3061 static void stac92hd71bxx_fixup_hp_m4(struct hda_codec *codec,
3062                       const struct hda_fixup *fix, int action)
3063 {
3064     struct sigmatel_spec *spec = codec->spec;
3065     struct hda_jack_callback *jack;
3066
3067     if (action != HDA_FIXUP_ACT_PRE_PROBE)
3068         return;
3069
3070     /* Enable VREF power saving on GPIO1 detect */
3071     snd_hda_codec_write_cache(codec, codec->core.afg, 0,
3072                   AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
3073     jack = snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
3074                            stac_vref_event);
3075     if (!IS_ERR(jack))
3076         jack->private_data = 0x02;
3077
3078     spec->gpio_mask |= 0x02;
3079
3080     /* enable internal microphone */
3081     snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
3082 }
3083
3084 static void stac92hd71bxx_fixup_hp_dv4(struct hda_codec *codec,
3085                        const struct hda_fixup *fix, int action)
3086 {
3087     struct sigmatel_spec *spec = codec->spec;
3088
3089     if (action != HDA_FIXUP_ACT_PRE_PROBE)
3090         return;
3091     spec->gpio_led = 0x01;
3092 }
3093
3094 static void stac92hd71bxx_fixup_hp_dv5(struct hda_codec *codec,
3095                        const struct hda_fixup *fix, int action)
3096 {
3097     unsigned int cap;
3098
3099     switch (action) {
3100     case HDA_FIXUP_ACT_PRE_PROBE:
3101         snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
3102         break;
3103
3104     case HDA_FIXUP_ACT_PROBE:
3105         /* enable bass on HP dv7 */
3106         cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
3107         cap &= AC_GPIO_IO_COUNT;
3108         if (cap >= 6)
3109             stac_add_hp_bass_switch(codec);
3110         break;
3111     }
3112 }
3113
3114 static void stac92hd71bxx_fixup_hp_hdx(struct hda_codec *codec,
3115                        const struct hda_fixup *fix, int action)
3116 {
3117     struct sigmatel_spec *spec = codec->spec;
3118
3119     if (action != HDA_FIXUP_ACT_PRE_PROBE)
3120         return;
3121     spec->gpio_led = 0x08;
3122 }
3123
3124 static bool is_hp_output(struct hda_codec *codec, hda_nid_t pin)
3125 {
3126     unsigned int pin_cfg = snd_hda_codec_get_pincfg(codec, pin);
3127
3128     /* count line-out, too, as BIOS sets often so */
3129     return get_defcfg_connect(pin_cfg) != AC_JACK_PORT_NONE &&
3130         (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
3131          get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT);
3132 }
3133
3134 static void fixup_hp_headphone(struct hda_codec *codec, hda_nid_t pin)
3135 {
3136     unsigned int pin_cfg = snd_hda_codec_get_pincfg(codec, pin);
3137
3138     /* It was changed in the BIOS to just satisfy MS DTM.
3139      * Lets turn it back into follower HP
3140      */
3141     pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE)) |
3142         (AC_JACK_HP_OUT << AC_DEFCFG_DEVICE_SHIFT);
3143     pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC | AC_DEFCFG_SEQUENCE))) |
3144         0x1f;
3145     snd_hda_codec_set_pincfg(codec, pin, pin_cfg);
3146 }
3147
3148 static void stac92hd71bxx_fixup_hp(struct hda_codec *codec,
3149                    const struct hda_fixup *fix, int action)
3150 {
3151     struct sigmatel_spec *spec = codec->spec;
3152
3153     if (action != HDA_FIXUP_ACT_PRE_PROBE)
3154         return;
3155
3156     /* when both output A and F are assigned, these are supposedly
3157      * dock and built-in headphones; fix both pin configs
3158      */
3159     if (is_hp_output(codec, 0x0a) && is_hp_output(codec, 0x0f)) {
3160         fixup_hp_headphone(codec, 0x0a);
3161         fixup_hp_headphone(codec, 0x0f);
3162     }
3163
3164     if (find_mute_led_cfg(codec, 1))
3165         codec_dbg(codec, "mute LED gpio %d polarity %d\n",
3166                 spec->gpio_led,
3167                 spec->gpio_led_polarity);
3168
3169 }
3170
3171 static const struct hda_fixup stac92hd71bxx_fixups[] = {
3172     [STAC_92HD71BXX_REF] = {
3173         .type = HDA_FIXUP_FUNC,
3174         .v.func = stac92hd71bxx_fixup_ref,
3175     },
3176     [STAC_DELL_M4_1] = {
3177         .type = HDA_FIXUP_PINS,
3178         .v.pins = dell_m4_1_pin_configs,
3179     },
3180     [STAC_DELL_M4_2] = {
3181         .type = HDA_FIXUP_PINS,
3182         .v.pins = dell_m4_2_pin_configs,
3183     },
3184     [STAC_DELL_M4_3] = {
3185         .type = HDA_FIXUP_PINS,
3186         .v.pins = dell_m4_3_pin_configs,
3187     },
3188     [STAC_HP_M4] = {
3189         .type = HDA_FIXUP_FUNC,
3190         .v.func = stac92hd71bxx_fixup_hp_m4,
3191         .chained = true,
3192         .chain_id = STAC_92HD71BXX_HP,
3193     },
3194     [STAC_HP_DV4] = {
3195         .type = HDA_FIXUP_FUNC,
3196         .v.func = stac92hd71bxx_fixup_hp_dv4,
3197         .chained = true,
3198         .chain_id = STAC_HP_DV5,
3199     },
3200     [STAC_HP_DV5] = {
3201         .type = HDA_FIXUP_FUNC,
3202         .v.func = stac92hd71bxx_fixup_hp_dv5,
3203         .chained = true,
3204         .chain_id = STAC_92HD71BXX_HP,
3205     },
3206     [STAC_HP_HDX] = {
3207         .type = HDA_FIXUP_FUNC,
3208         .v.func = stac92hd71bxx_fixup_hp_hdx,
3209         .chained = true,
3210         .chain_id = STAC_92HD71BXX_HP,
3211     },
3212     [STAC_92HD71BXX_HP] = {
3213         .type = HDA_FIXUP_FUNC,
3214         .v.func = stac92hd71bxx_fixup_hp,
3215     },
3216 };
3217
3218 static const struct hda_model_fixup stac92hd71bxx_models[] = {
3219     { .id = STAC_92HD71BXX_REF, .name = "ref" },
3220     { .id = STAC_DELL_M4_1, .name = "dell-m4-1" },
3221     { .id = STAC_DELL_M4_2, .name = "dell-m4-2" },
3222     { .id = STAC_DELL_M4_3, .name = "dell-m4-3" },
3223     { .id = STAC_HP_M4, .name = "hp-m4" },
3224     { .id = STAC_HP_DV4, .name = "hp-dv4" },
3225     { .id = STAC_HP_DV5, .name = "hp-dv5" },
3226     { .id = STAC_HP_HDX, .name = "hp-hdx" },
3227     { .id = STAC_HP_DV4, .name = "hp-dv4-1222nr" },
3228     {}
3229 };
3230
3231 static const struct snd_pci_quirk stac92hd71bxx_fixup_tbl[] = {
3232     /* SigmaTel reference board */
3233     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
3234               "DFI LanParty", STAC_92HD71BXX_REF),
3235     SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
3236               "DFI LanParty", STAC_92HD71BXX_REF),
3237     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
3238               "HP", STAC_HP_DV5),
3239     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
3240               "HP", STAC_HP_DV5),
3241     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
3242               "HP dv4-7", STAC_HP_DV4),
3243     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
3244               "HP dv4-7", STAC_HP_DV5),
3245     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
3246               "HP HDX", STAC_HP_HDX),  /* HDX18 */
3247     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
3248               "HP mini 1000", STAC_HP_M4),
3249     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
3250               "HP HDX", STAC_HP_HDX),  /* HDX16 */
3251     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
3252               "HP dv6", STAC_HP_DV5),
3253     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
3254               "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
3255     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e,
3256               "HP DV6", STAC_HP_DV5),
3257     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
3258               "HP", STAC_HP_DV5),
3259     SND_PCI_QUIRK_VENDOR(PCI_VENDOR_ID_HP, "HP", STAC_92HD71BXX_HP),
3260     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
3261                 "unknown Dell", STAC_DELL_M4_1),
3262     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
3263                 "unknown Dell", STAC_DELL_M4_1),
3264     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
3265                 "unknown Dell", STAC_DELL_M4_1),
3266     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
3267                 "unknown Dell", STAC_DELL_M4_1),
3268     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
3269                 "unknown Dell", STAC_DELL_M4_1),
3270     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
3271                 "unknown Dell", STAC_DELL_M4_1),
3272     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
3273                 "unknown Dell", STAC_DELL_M4_1),
3274     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
3275                 "unknown Dell", STAC_DELL_M4_2),
3276     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
3277                 "unknown Dell", STAC_DELL_M4_2),
3278     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
3279                 "unknown Dell", STAC_DELL_M4_2),
3280     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
3281                 "unknown Dell", STAC_DELL_M4_2),
3282     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
3283                 "unknown Dell", STAC_DELL_M4_3),
3284     {} /* terminator */
3285 };
3286
3287 static const struct hda_pintbl ref922x_pin_configs[] = {
3288     { 0x0a, 0x01014010 },
3289     { 0x0b, 0x01016011 },
3290     { 0x0c, 0x01012012 },
3291     { 0x0d, 0x0221401f },
3292     { 0x0e, 0x01813122 },
3293     { 0x0f, 0x01011014 },
3294     { 0x10, 0x01441030 },
3295     { 0x11, 0x01c41030 },
3296     { 0x15, 0x40000100 },
3297     { 0x1b, 0x40000100 },
3298     {}
3299 };
3300
3301 /*
3302     STAC 922X pin configs for
3303     102801A7
3304     102801AB
3305     102801A9
3306     102801D1
3307     102801D2
3308 */
3309 static const struct hda_pintbl dell_922x_d81_pin_configs[] = {
3310     { 0x0a, 0x02214030 },
3311     { 0x0b, 0x01a19021 },
3312     { 0x0c, 0x01111012 },
3313     { 0x0d, 0x01114010 },
3314     { 0x0e, 0x02a19020 },
3315     { 0x0f, 0x01117011 },
3316     { 0x10, 0x400001f0 },
3317     { 0x11, 0x400001f1 },
3318     { 0x15, 0x01813122 },
3319     { 0x1b, 0x400001f2 },
3320     {}
3321 };
3322
3323 /*
3324     STAC 922X pin configs for
3325     102801AC
3326     102801D0
3327 */
3328 static const struct hda_pintbl dell_922x_d82_pin_configs[] = {
3329     { 0x0a, 0x02214030 },
3330     { 0x0b, 0x01a19021 },
3331     { 0x0c, 0x01111012 },
3332     { 0x0d, 0x01114010 },
3333     { 0x0e, 0x02a19020 },
3334     { 0x0f, 0x01117011 },
3335     { 0x10, 0x01451140 },
3336     { 0x11, 0x400001f0 },
3337     { 0x15, 0x01813122 },
3338     { 0x1b, 0x400001f1 },
3339     {}
3340 };
3341
3342 /*
3343     STAC 922X pin configs for
3344     102801BF
3345 */
3346 static const struct hda_pintbl dell_922x_m81_pin_configs[] = {
3347     { 0x0a, 0x0321101f },
3348     { 0x0b, 0x01112024 },
3349     { 0x0c, 0x01111222 },
3350     { 0x0d, 0x91174220 },
3351     { 0x0e, 0x03a11050 },
3352     { 0x0f, 0x01116221 },
3353     { 0x10, 0x90a70330 },
3354     { 0x11, 0x01452340 },
3355     { 0x15, 0x40C003f1 },
3356     { 0x1b, 0x405003f0 },
3357     {}
3358 };
3359
3360 /*
3361     STAC 9221 A1 pin configs for
3362     102801D7 (Dell XPS M1210)
3363 */
3364 static const struct hda_pintbl dell_922x_m82_pin_configs[] = {
3365     { 0x0a, 0x02211211 },
3366     { 0x0b, 0x408103ff },
3367     { 0x0c, 0x02a1123e },
3368     { 0x0d, 0x90100310 },
3369     { 0x0e, 0x408003f1 },
3370     { 0x0f, 0x0221121f },
3371     { 0x10, 0x03451340 },
3372     { 0x11, 0x40c003f2 },
3373     { 0x15, 0x508003f3 },
3374     { 0x1b, 0x405003f4 },
3375     {}
3376 };
3377
3378 static const struct hda_pintbl d945gtp3_pin_configs[] = {
3379     { 0x0a, 0x0221401f },
3380     { 0x0b, 0x01a19022 },
3381     { 0x0c, 0x01813021 },
3382     { 0x0d, 0x01014010 },
3383     { 0x0e, 0x40000100 },
3384     { 0x0f, 0x40000100 },
3385     { 0x10, 0x40000100 },
3386     { 0x11, 0x40000100 },
3387     { 0x15, 0x02a19120 },
3388     { 0x1b, 0x40000100 },
3389     {}
3390 };
3391
3392 static const struct hda_pintbl d945gtp5_pin_configs[] = {
3393     { 0x0a, 0x0221401f },
3394     { 0x0b, 0x01011012 },
3395     { 0x0c, 0x01813024 },
3396     { 0x0d, 0x01014010 },
3397     { 0x0e, 0x01a19021 },
3398     { 0x0f, 0x01016011 },
3399     { 0x10, 0x01452130 },
3400     { 0x11, 0x40000100 },
3401     { 0x15, 0x02a19320 },
3402     { 0x1b, 0x40000100 },
3403     {}
3404 };
3405
3406 static const struct hda_pintbl intel_mac_v1_pin_configs[] = {
3407     { 0x0a, 0x0121e21f },
3408     { 0x0b, 0x400000ff },
3409     { 0x0c, 0x9017e110 },
3410     { 0x0d, 0x400000fd },
3411     { 0x0e, 0x400000fe },
3412     { 0x0f, 0x0181e020 },
3413     { 0x10, 0x1145e030 },
3414     { 0x11, 0x11c5e240 },
3415     { 0x15, 0x400000fc },
3416     { 0x1b, 0x400000fb },
3417     {}
3418 };
3419
3420 static const struct hda_pintbl intel_mac_v2_pin_configs[] = {
3421     { 0x0a, 0x0121e21f },
3422     { 0x0b, 0x90a7012e },
3423     { 0x0c, 0x9017e110 },
3424     { 0x0d, 0x400000fd },
3425     { 0x0e, 0x400000fe },
3426     { 0x0f, 0x0181e020 },
3427     { 0x10, 0x1145e230 },
3428     { 0x11, 0x500000fa },
3429     { 0x15, 0x400000fc },
3430     { 0x1b, 0x400000fb },
3431     {}
3432 };
3433
3434 static const struct hda_pintbl intel_mac_v3_pin_configs[] = {
3435     { 0x0a, 0x0121e21f },
3436     { 0x0b, 0x90a7012e },
3437     { 0x0c, 0x9017e110 },
3438     { 0x0d, 0x400000fd },
3439     { 0x0e, 0x400000fe },
3440     { 0x0f, 0x0181e020 },
3441     { 0x10, 0x1145e230 },
3442     { 0x11, 0x11c5e240 },
3443     { 0x15, 0x400000fc },
3444     { 0x1b, 0x400000fb },
3445     {}
3446 };
3447
3448 static const struct hda_pintbl intel_mac_v4_pin_configs[] = {
3449     { 0x0a, 0x0321e21f },
3450     { 0x0b, 0x03a1e02e },
3451     { 0x0c, 0x9017e110 },
3452     { 0x0d, 0x9017e11f },
3453     { 0x0e, 0x400000fe },
3454     { 0x0f, 0x0381e020 },
3455     { 0x10, 0x1345e230 },
3456     { 0x11, 0x13c5e240 },
3457     { 0x15, 0x400000fc },
3458     { 0x1b, 0x400000fb },
3459     {}
3460 };
3461
3462 static const struct hda_pintbl intel_mac_v5_pin_configs[] = {
3463     { 0x0a, 0x0321e21f },
3464     { 0x0b, 0x03a1e02e },
3465     { 0x0c, 0x9017e110 },
3466     { 0x0d, 0x9017e11f },
3467     { 0x0e, 0x400000fe },
3468     { 0x0f, 0x0381e020 },
3469     { 0x10, 0x1345e230 },
3470     { 0x11, 0x13c5e240 },
3471     { 0x15, 0x400000fc },
3472     { 0x1b, 0x400000fb },
3473     {}
3474 };
3475
3476 static const struct hda_pintbl ecs202_pin_configs[] = {
3477     { 0x0a, 0x0221401f },
3478     { 0x0b, 0x02a19020 },
3479     { 0x0c, 0x01a19020 },
3480     { 0x0d, 0x01114010 },
3481     { 0x0e, 0x408000f0 },
3482     { 0x0f, 0x01813022 },
3483     { 0x10, 0x074510a0 },
3484     { 0x11, 0x40c400f1 },
3485     { 0x15, 0x9037012e },
3486     { 0x1b, 0x40e000f2 },
3487     {}
3488 };
3489
3490 /* codec SSIDs for Intel Mac sharing the same PCI SSID 8384:7680 */
3491 static const struct snd_pci_quirk stac922x_intel_mac_fixup_tbl[] = {
3492     SND_PCI_QUIRK(0x0000, 0x0100, "Mac Mini", STAC_INTEL_MAC_V3),
3493     SND_PCI_QUIRK(0x106b, 0x0800, "Mac", STAC_INTEL_MAC_V1),
3494     SND_PCI_QUIRK(0x106b, 0x0600, "Mac", STAC_INTEL_MAC_V2),
3495     SND_PCI_QUIRK(0x106b, 0x0700, "Mac", STAC_INTEL_MAC_V2),
3496     SND_PCI_QUIRK(0x106b, 0x0e00, "Mac", STAC_INTEL_MAC_V3),
3497     SND_PCI_QUIRK(0x106b, 0x0f00, "Mac", STAC_INTEL_MAC_V3),
3498     SND_PCI_QUIRK(0x106b, 0x1600, "Mac", STAC_INTEL_MAC_V3),
3499     SND_PCI_QUIRK(0x106b, 0x1700, "Mac", STAC_INTEL_MAC_V3),
3500     SND_PCI_QUIRK(0x106b, 0x0200, "Mac", STAC_INTEL_MAC_V3),
3501     SND_PCI_QUIRK(0x106b, 0x1e00, "Mac", STAC_INTEL_MAC_V3),
3502     SND_PCI_QUIRK(0x106b, 0x1a00, "Mac", STAC_INTEL_MAC_V4),
3503     SND_PCI_QUIRK(0x106b, 0x0a00, "Mac", STAC_INTEL_MAC_V5),
3504     SND_PCI_QUIRK(0x106b, 0x2200, "Mac", STAC_INTEL_MAC_V5),
3505     {}
3506 };
3507
3508 static const struct hda_fixup stac922x_fixups[];
3509
3510 /* remap the fixup from codec SSID and apply it */
3511 static void stac922x_fixup_intel_mac_auto(struct hda_codec *codec,
3512                       const struct hda_fixup *fix,
3513                       int action)
3514 {
3515     if (action != HDA_FIXUP_ACT_PRE_PROBE)
3516         return;
3517
3518     codec->fixup_id = HDA_FIXUP_ID_NOT_SET;
3519     snd_hda_pick_fixup(codec, NULL, stac922x_intel_mac_fixup_tbl,
3520                stac922x_fixups);
3521     if (codec->fixup_id != HDA_FIXUP_ID_NOT_SET)
3522         snd_hda_apply_fixup(codec, action);
3523 }
3524
3525 static void stac922x_fixup_intel_mac_gpio(struct hda_codec *codec,
3526                       const struct hda_fixup *fix,
3527                       int action)
3528 {
3529     struct sigmatel_spec *spec = codec->spec;
3530
3531     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3532         spec->gpio_mask = spec->gpio_dir = 0x03;
3533         spec->gpio_data = 0x03;
3534     }
3535 }
3536
3537 static const struct hda_fixup stac922x_fixups[] = {
3538     [STAC_D945_REF] = {
3539         .type = HDA_FIXUP_PINS,
3540         .v.pins = ref922x_pin_configs,
3541     },
3542     [STAC_D945GTP3] = {
3543         .type = HDA_FIXUP_PINS,
3544         .v.pins = d945gtp3_pin_configs,
3545     },
3546     [STAC_D945GTP5] = {
3547         .type = HDA_FIXUP_PINS,
3548         .v.pins = d945gtp5_pin_configs,
3549     },
3550     [STAC_INTEL_MAC_AUTO] = {
3551         .type = HDA_FIXUP_FUNC,
3552         .v.func = stac922x_fixup_intel_mac_auto,
3553     },
3554     [STAC_INTEL_MAC_V1] = {
3555         .type = HDA_FIXUP_PINS,
3556         .v.pins = intel_mac_v1_pin_configs,
3557         .chained = true,
3558         .chain_id = STAC_922X_INTEL_MAC_GPIO,
3559     },
3560     [STAC_INTEL_MAC_V2] = {
3561         .type = HDA_FIXUP_PINS,
3562         .v.pins = intel_mac_v2_pin_configs,
3563         .chained = true,
3564         .chain_id = STAC_922X_INTEL_MAC_GPIO,
3565     },
3566     [STAC_INTEL_MAC_V3] = {
3567         .type = HDA_FIXUP_PINS,
3568         .v.pins = intel_mac_v3_pin_configs,
3569         .chained = true,
3570         .chain_id = STAC_922X_INTEL_MAC_GPIO,
3571     },
3572     [STAC_INTEL_MAC_V4] = {
3573         .type = HDA_FIXUP_PINS,
3574         .v.pins = intel_mac_v4_pin_configs,
3575         .chained = true,
3576         .chain_id = STAC_922X_INTEL_MAC_GPIO,
3577     },
3578     [STAC_INTEL_MAC_V5] = {
3579         .type = HDA_FIXUP_PINS,
3580         .v.pins = intel_mac_v5_pin_configs,
3581         .chained = true,
3582         .chain_id = STAC_922X_INTEL_MAC_GPIO,
3583     },
3584     [STAC_922X_INTEL_MAC_GPIO] = {
3585         .type = HDA_FIXUP_FUNC,
3586         .v.func = stac922x_fixup_intel_mac_gpio,
3587     },
3588     [STAC_ECS_202] = {
3589         .type = HDA_FIXUP_PINS,
3590         .v.pins = ecs202_pin_configs,
3591     },
3592     [STAC_922X_DELL_D81] = {
3593         .type = HDA_FIXUP_PINS,
3594         .v.pins = dell_922x_d81_pin_configs,
3595     },
3596     [STAC_922X_DELL_D82] = {
3597         .type = HDA_FIXUP_PINS,
3598         .v.pins = dell_922x_d82_pin_configs,
3599     },
3600     [STAC_922X_DELL_M81] = {
3601         .type = HDA_FIXUP_PINS,
3602         .v.pins = dell_922x_m81_pin_configs,
3603     },
3604     [STAC_922X_DELL_M82] = {
3605         .type = HDA_FIXUP_PINS,
3606         .v.pins = dell_922x_m82_pin_configs,
3607     },
3608 };
3609
3610 static const struct hda_model_fixup stac922x_models[] = {
3611     { .id = STAC_D945_REF, .name = "ref" },
3612     { .id = STAC_D945GTP5, .name = "5stack" },
3613     { .id = STAC_D945GTP3, .name = "3stack" },
3614     { .id = STAC_INTEL_MAC_V1, .name = "intel-mac-v1" },
3615     { .id = STAC_INTEL_MAC_V2, .name = "intel-mac-v2" },
3616     { .id = STAC_INTEL_MAC_V3, .name = "intel-mac-v3" },
3617     { .id = STAC_INTEL_MAC_V4, .name = "intel-mac-v4" },
3618     { .id = STAC_INTEL_MAC_V5, .name = "intel-mac-v5" },
3619     { .id = STAC_INTEL_MAC_AUTO, .name = "intel-mac-auto" },
3620     { .id = STAC_ECS_202, .name = "ecs202" },
3621     { .id = STAC_922X_DELL_D81, .name = "dell-d81" },
3622     { .id = STAC_922X_DELL_D82, .name = "dell-d82" },
3623     { .id = STAC_922X_DELL_M81, .name = "dell-m81" },
3624     { .id = STAC_922X_DELL_M82, .name = "dell-m82" },
3625     /* for backward compatibility */
3626     { .id = STAC_INTEL_MAC_V3, .name = "macmini" },
3627     { .id = STAC_INTEL_MAC_V5, .name = "macbook" },
3628     { .id = STAC_INTEL_MAC_V3, .name = "macbook-pro-v1" },
3629     { .id = STAC_INTEL_MAC_V3, .name = "macbook-pro" },
3630     { .id = STAC_INTEL_MAC_V2, .name = "imac-intel" },
3631     { .id = STAC_INTEL_MAC_V3, .name = "imac-intel-20" },
3632     {}
3633 };
3634
3635 static const struct snd_pci_quirk stac922x_fixup_tbl[] = {
3636     /* SigmaTel reference board */
3637     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
3638               "DFI LanParty", STAC_D945_REF),
3639     SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
3640               "DFI LanParty", STAC_D945_REF),
3641     /* Intel 945G based systems */
3642     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
3643               "Intel D945G", STAC_D945GTP3),
3644     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
3645               "Intel D945G", STAC_D945GTP3),
3646     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
3647               "Intel D945G", STAC_D945GTP3),
3648     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
3649               "Intel D945G", STAC_D945GTP3),
3650     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
3651               "Intel D945G", STAC_D945GTP3),
3652     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
3653               "Intel D945G", STAC_D945GTP3),
3654     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
3655               "Intel D945G", STAC_D945GTP3),
3656     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
3657               "Intel D945G", STAC_D945GTP3),
3658     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
3659               "Intel D945G", STAC_D945GTP3),
3660     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
3661               "Intel D945G", STAC_D945GTP3),
3662     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
3663               "Intel D945G", STAC_D945GTP3),
3664     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
3665               "Intel D945G", STAC_D945GTP3),
3666     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
3667               "Intel D945G", STAC_D945GTP3),
3668     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
3669               "Intel D945G", STAC_D945GTP3),
3670     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
3671               "Intel D945G", STAC_D945GTP3),
3672     /* Intel D945G 5-stack systems */
3673     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
3674               "Intel D945G", STAC_D945GTP5),
3675     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
3676               "Intel D945G", STAC_D945GTP5),
3677     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
3678               "Intel D945G", STAC_D945GTP5),
3679     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
3680               "Intel D945G", STAC_D945GTP5),
3681     /* Intel 945P based systems */
3682     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
3683               "Intel D945P", STAC_D945GTP3),
3684     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
3685               "Intel D945P", STAC_D945GTP3),
3686     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
3687               "Intel D945P", STAC_D945GTP3),
3688     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
3689               "Intel D945P", STAC_D945GTP3),
3690     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
3691               "Intel D945P", STAC_D945GTP3),
3692     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
3693               "Intel D945P", STAC_D945GTP5),
3694     /* other intel */
3695     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
3696               "Intel D945", STAC_D945_REF),
3697     /* other systems  */
3698
3699     /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
3700     SND_PCI_QUIRK(0x8384, 0x7680, "Mac", STAC_INTEL_MAC_AUTO),
3701
3702     /* Dell systems  */
3703     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
3704               "unknown Dell", STAC_922X_DELL_D81),
3705     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
3706               "unknown Dell", STAC_922X_DELL_D81),
3707     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
3708               "unknown Dell", STAC_922X_DELL_D81),
3709     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
3710               "unknown Dell", STAC_922X_DELL_D82),
3711     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
3712               "unknown Dell", STAC_922X_DELL_M81),
3713     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
3714               "unknown Dell", STAC_922X_DELL_D82),
3715     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
3716               "unknown Dell", STAC_922X_DELL_D81),
3717     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
3718               "unknown Dell", STAC_922X_DELL_D81),
3719     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
3720               "Dell XPS M1210", STAC_922X_DELL_M82),
3721     /* ECS/PC Chips boards */
3722     SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
3723               "ECS/PC chips", STAC_ECS_202),
3724     {} /* terminator */
3725 };
3726
3727 static const struct hda_pintbl ref927x_pin_configs[] = {
3728     { 0x0a, 0x02214020 },
3729     { 0x0b, 0x02a19080 },
3730     { 0x0c, 0x0181304e },
3731     { 0x0d, 0x01014010 },
3732     { 0x0e, 0x01a19040 },
3733     { 0x0f, 0x01011012 },
3734     { 0x10, 0x01016011 },
3735     { 0x11, 0x0101201f },
3736     { 0x12, 0x183301f0 },
3737     { 0x13, 0x18a001f0 },
3738     { 0x14, 0x18a001f0 },
3739     { 0x21, 0x01442070 },
3740     { 0x22, 0x01c42190 },
3741     { 0x23, 0x40000100 },
3742     {}
3743 };
3744
3745 static const struct hda_pintbl d965_3st_pin_configs[] = {
3746     { 0x0a, 0x0221401f },
3747     { 0x0b, 0x02a19120 },
3748     { 0x0c, 0x40000100 },
3749     { 0x0d, 0x01014011 },
3750     { 0x0e, 0x01a19021 },
3751     { 0x0f, 0x01813024 },
3752     { 0x10, 0x40000100 },
3753     { 0x11, 0x40000100 },
3754     { 0x12, 0x40000100 },
3755     { 0x13, 0x40000100 },
3756     { 0x14, 0x40000100 },
3757     { 0x21, 0x40000100 },
3758     { 0x22, 0x40000100 },
3759     { 0x23, 0x40000100 },
3760     {}
3761 };
3762
3763 static const struct hda_pintbl d965_5st_pin_configs[] = {
3764     { 0x0a, 0x02214020 },
3765     { 0x0b, 0x02a19080 },
3766     { 0x0c, 0x0181304e },
3767     { 0x0d, 0x01014010 },
3768     { 0x0e, 0x01a19040 },
3769     { 0x0f, 0x01011012 },
3770     { 0x10, 0x01016011 },
3771     { 0x11, 0x40000100 },
3772     { 0x12, 0x40000100 },
3773     { 0x13, 0x40000100 },
3774     { 0x14, 0x40000100 },
3775     { 0x21, 0x01442070 },
3776     { 0x22, 0x40000100 },
3777     { 0x23, 0x40000100 },
3778     {}
3779 };
3780
3781 static const struct hda_pintbl d965_5st_no_fp_pin_configs[] = {
3782     { 0x0a, 0x40000100 },
3783     { 0x0b, 0x40000100 },
3784     { 0x0c, 0x0181304e },
3785     { 0x0d, 0x01014010 },
3786     { 0x0e, 0x01a19040 },
3787     { 0x0f, 0x01011012 },
3788     { 0x10, 0x01016011 },
3789     { 0x11, 0x40000100 },
3790     { 0x12, 0x40000100 },
3791     { 0x13, 0x40000100 },
3792     { 0x14, 0x40000100 },
3793     { 0x21, 0x01442070 },
3794     { 0x22, 0x40000100 },
3795     { 0x23, 0x40000100 },
3796     {}
3797 };
3798
3799 static const struct hda_pintbl dell_3st_pin_configs[] = {
3800     { 0x0a, 0x02211230 },
3801     { 0x0b, 0x02a11220 },
3802     { 0x0c, 0x01a19040 },
3803     { 0x0d, 0x01114210 },
3804     { 0x0e, 0x01111212 },
3805     { 0x0f, 0x01116211 },
3806     { 0x10, 0x01813050 },
3807     { 0x11, 0x01112214 },
3808     { 0x12, 0x403003fa },
3809     { 0x13, 0x90a60040 },
3810     { 0x14, 0x90a60040 },
3811     { 0x21, 0x404003fb },
3812     { 0x22, 0x40c003fc },
3813     { 0x23, 0x40000100 },
3814     {}
3815 };
3816
3817 static void stac927x_fixup_ref_no_jd(struct hda_codec *codec,
3818                      const struct hda_fixup *fix, int action)
3819 {
3820     /* no jack detecion for ref-no-jd model */
3821     if (action == HDA_FIXUP_ACT_PRE_PROBE)
3822         codec->no_jack_detect = 1;
3823 }
3824
3825 static void stac927x_fixup_ref(struct hda_codec *codec,
3826                    const struct hda_fixup *fix, int action)
3827 {
3828     struct sigmatel_spec *spec = codec->spec;
3829
3830     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3831         snd_hda_apply_pincfgs(codec, ref927x_pin_configs);
3832         spec->eapd_mask = spec->gpio_mask = 0;
3833         spec->gpio_dir = spec->gpio_data = 0;
3834     }
3835 }
3836
3837 static void stac927x_fixup_dell_dmic(struct hda_codec *codec,
3838                      const struct hda_fixup *fix, int action)
3839 {
3840     struct sigmatel_spec *spec = codec->spec;
3841
3842     if (action != HDA_FIXUP_ACT_PRE_PROBE)
3843         return;
3844
3845     if (codec->core.subsystem_id != 0x1028022f) {
3846         /* GPIO2 High = Enable EAPD */
3847         spec->eapd_mask = spec->gpio_mask = 0x04;
3848         spec->gpio_dir = spec->gpio_data = 0x04;
3849     }
3850
3851     snd_hda_add_verbs(codec, dell_3st_core_init);
3852     spec->volknob_init = 1;
3853 }
3854
3855 static void stac927x_fixup_volknob(struct hda_codec *codec,
3856                    const struct hda_fixup *fix, int action)
3857 {
3858     struct sigmatel_spec *spec = codec->spec;
3859
3860     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
3861         snd_hda_add_verbs(codec, stac927x_volknob_core_init);
3862         spec->volknob_init = 1;
3863     }
3864 }
3865
3866 static const struct hda_fixup stac927x_fixups[] = {
3867     [STAC_D965_REF_NO_JD] = {
3868         .type = HDA_FIXUP_FUNC,
3869         .v.func = stac927x_fixup_ref_no_jd,
3870         .chained = true,
3871         .chain_id = STAC_D965_REF,
3872     },
3873     [STAC_D965_REF] = {
3874         .type = HDA_FIXUP_FUNC,
3875         .v.func = stac927x_fixup_ref,
3876     },
3877     [STAC_D965_3ST] = {
3878         .type = HDA_FIXUP_PINS,
3879         .v.pins = d965_3st_pin_configs,
3880         .chained = true,
3881         .chain_id = STAC_D965_VERBS,
3882     },
3883     [STAC_D965_5ST] = {
3884         .type = HDA_FIXUP_PINS,
3885         .v.pins = d965_5st_pin_configs,
3886         .chained = true,
3887         .chain_id = STAC_D965_VERBS,
3888     },
3889     [STAC_D965_VERBS] = {
3890         .type = HDA_FIXUP_VERBS,
3891         .v.verbs = d965_core_init,
3892     },
3893     [STAC_D965_5ST_NO_FP] = {
3894         .type = HDA_FIXUP_PINS,
3895         .v.pins = d965_5st_no_fp_pin_configs,
3896     },
3897     [STAC_NEMO_DEFAULT] = {
3898         .type = HDA_FIXUP_PINS,
3899         .v.pins = nemo_pin_configs,
3900     },
3901     [STAC_DELL_3ST] = {
3902         .type = HDA_FIXUP_PINS,
3903         .v.pins = dell_3st_pin_configs,
3904         .chained = true,
3905         .chain_id = STAC_927X_DELL_DMIC,
3906     },
3907     [STAC_DELL_BIOS] = {
3908         .type = HDA_FIXUP_PINS,
3909         .v.pins = (const struct hda_pintbl[]) {
3910             /* correct the front output jack as a hp out */
3911             { 0x0f, 0x0221101f },
3912             /* correct the front input jack as a mic */
3913             { 0x0e, 0x02a79130 },
3914             {}
3915         },
3916         .chained = true,
3917         .chain_id = STAC_927X_DELL_DMIC,
3918     },
3919     [STAC_DELL_BIOS_AMIC] = {
3920         .type = HDA_FIXUP_PINS,
3921         .v.pins = (const struct hda_pintbl[]) {
3922             /* configure the analog microphone on some laptops */
3923             { 0x0c, 0x90a79130 },
3924             {}
3925         },
3926         .chained = true,
3927         .chain_id = STAC_DELL_BIOS,
3928     },
3929     [STAC_DELL_BIOS_SPDIF] = {
3930         .type = HDA_FIXUP_PINS,
3931         .v.pins = (const struct hda_pintbl[]) {
3932             /* correct the device field to SPDIF out */
3933             { 0x21, 0x01442070 },
3934             {}
3935         },
3936         .chained = true,
3937         .chain_id = STAC_DELL_BIOS,
3938     },
3939     [STAC_927X_DELL_DMIC] = {
3940         .type = HDA_FIXUP_FUNC,
3941         .v.func = stac927x_fixup_dell_dmic,
3942     },
3943     [STAC_927X_VOLKNOB] = {
3944         .type = HDA_FIXUP_FUNC,
3945         .v.func = stac927x_fixup_volknob,
3946     },
3947 };
3948
3949 static const struct hda_model_fixup stac927x_models[] = {
3950     { .id = STAC_D965_REF_NO_JD, .name = "ref-no-jd" },
3951     { .id = STAC_D965_REF, .name = "ref" },
3952     { .id = STAC_D965_3ST, .name = "3stack" },
3953     { .id = STAC_D965_5ST, .name = "5stack" },
3954     { .id = STAC_D965_5ST_NO_FP, .name = "5stack-no-fp" },
3955     { .id = STAC_DELL_3ST, .name = "dell-3stack" },
3956     { .id = STAC_DELL_BIOS, .name = "dell-bios" },
3957     { .id = STAC_NEMO_DEFAULT, .name = "nemo-default" },
3958     { .id = STAC_DELL_BIOS_AMIC, .name = "dell-bios-amic" },
3959     { .id = STAC_927X_VOLKNOB, .name = "volknob" },
3960     {}
3961 };
3962
3963 static const struct snd_pci_quirk stac927x_fixup_tbl[] = {
3964     /* SigmaTel reference board */
3965     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
3966               "DFI LanParty", STAC_D965_REF),
3967     SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
3968               "DFI LanParty", STAC_D965_REF),
3969      /* Intel 946 based systems */
3970     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
3971     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
3972     /* 965 based 3 stack systems */
3973     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
3974                "Intel D965", STAC_D965_3ST),
3975     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
3976                "Intel D965", STAC_D965_3ST),
3977     /* Dell 3 stack systems */
3978     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
3979     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
3980     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
3981     /* Dell 3 stack systems with verb table in BIOS */
3982     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
3983     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
3984     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
3985     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS_SPDIF),
3986     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
3987     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
3988     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
3989     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
3990     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS_SPDIF),
3991     /* 965 based 5 stack systems */
3992     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
3993                "Intel D965", STAC_D965_5ST),
3994     SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
3995                "Intel D965", STAC_D965_5ST),
3996     /* Nemo */
3997     SND_PCI_QUIRK(0x1888, 0x1000, "AmigaOne X1000", STAC_NEMO_DEFAULT),
3998     /* volume-knob fixes */
3999     SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
4000     {} /* terminator */
4001 };
4002
4003 static const struct hda_pintbl ref9205_pin_configs[] = {
4004     { 0x0a, 0x40000100 },
4005     { 0x0b, 0x40000100 },
4006     { 0x0c, 0x01016011 },
4007     { 0x0d, 0x01014010 },
4008     { 0x0e, 0x01813122 },
4009     { 0x0f, 0x01a19021 },
4010     { 0x14, 0x01019020 },
4011     { 0x16, 0x40000100 },
4012     { 0x17, 0x90a000f0 },
4013     { 0x18, 0x90a000f0 },
4014     { 0x21, 0x01441030 },
4015     { 0x22, 0x01c41030 },
4016     {}
4017 };
4018
4019 /*
4020     STAC 9205 pin configs for
4021     102801F1
4022     102801F2
4023     102801FC
4024     102801FD
4025     10280204
4026     1028021F
4027     10280228 (Dell Vostro 1500)
4028     10280229 (Dell Vostro 1700)
4029 */
4030 static const struct hda_pintbl dell_9205_m42_pin_configs[] = {
4031     { 0x0a, 0x0321101F },
4032     { 0x0b, 0x03A11020 },
4033     { 0x0c, 0x400003FA },
4034     { 0x0d, 0x90170310 },
4035     { 0x0e, 0x400003FB },
4036     { 0x0f, 0x400003FC },
4037     { 0x14, 0x400003FD },
4038     { 0x16, 0x40F000F9 },
4039     { 0x17, 0x90A60330 },
4040     { 0x18, 0x400003FF },
4041     { 0x21, 0x0144131F },
4042     { 0x22, 0x40C003FE },
4043     {}
4044 };
4045
4046 /*
4047     STAC 9205 pin configs for
4048     102801F9
4049     102801FA
4050     102801FE
4051     102801FF (Dell Precision M4300)
4052     10280206
4053     10280200
4054     10280201
4055 */
4056 static const struct hda_pintbl dell_9205_m43_pin_configs[] = {
4057     { 0x0a, 0x0321101f },
4058     { 0x0b, 0x03a11020 },
4059     { 0x0c, 0x90a70330 },
4060     { 0x0d, 0x90170310 },
4061     { 0x0e, 0x400000fe },
4062     { 0x0f, 0x400000ff },
4063     { 0x14, 0x400000fd },
4064     { 0x16, 0x40f000f9 },
4065     { 0x17, 0x400000fa },
4066     { 0x18, 0x400000fc },
4067     { 0x21, 0x0144131f },
4068     { 0x22, 0x40c003f8 },
4069     /* Enable SPDIF in/out */
4070     { 0x1f, 0x01441030 },
4071     { 0x20, 0x1c410030 },
4072     {}
4073 };
4074
4075 static const struct hda_pintbl dell_9205_m44_pin_configs[] = {
4076     { 0x0a, 0x0421101f },
4077     { 0x0b, 0x04a11020 },
4078     { 0x0c, 0x400003fa },
4079     { 0x0d, 0x90170310 },
4080     { 0x0e, 0x400003fb },
4081     { 0x0f, 0x400003fc },
4082     { 0x14, 0x400003fd },
4083     { 0x16, 0x400003f9 },
4084     { 0x17, 0x90a60330 },
4085     { 0x18, 0x400003ff },
4086     { 0x21, 0x01441340 },
4087     { 0x22, 0x40c003fe },
4088     {}
4089 };
4090
4091 static void stac9205_fixup_ref(struct hda_codec *codec,
4092                    const struct hda_fixup *fix, int action)
4093 {
4094     struct sigmatel_spec *spec = codec->spec;
4095
4096     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4097         snd_hda_apply_pincfgs(codec, ref9205_pin_configs);
4098         /* SPDIF-In enabled */
4099         spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0;
4100     }
4101 }
4102
4103 static void stac9205_fixup_dell_m43(struct hda_codec *codec,
4104                     const struct hda_fixup *fix, int action)
4105 {
4106     struct sigmatel_spec *spec = codec->spec;
4107     struct hda_jack_callback *jack;
4108
4109     if (action == HDA_FIXUP_ACT_PRE_PROBE) {
4110         snd_hda_apply_pincfgs(codec, dell_9205_m43_pin_configs);
4111
4112         /* Enable unsol response for GPIO4/Dock HP connection */
4113         snd_hda_codec_write_cache(codec, codec->core.afg, 0,
4114             AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
4115         jack = snd_hda_jack_detect_enable_callback(codec, codec->core.afg,
4116                                stac_vref_event);
4117         if (!IS_ERR(jack))
4118             jack->private_data = 0x01;
4119
4120         spec->gpio_dir = 0x0b;
4121         spec->eapd_mask = 0x01;
4122         spec->gpio_mask = 0x1b;
4123         spec->gpio_mute = 0x10;
4124         /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
4125          * GPIO3 Low = DRM
4126          */
4127         spec->gpio_data = 0x01;
4128     }
4129 }
4130
4131 static void stac9205_fixup_eapd(struct hda_codec *codec,
4132                 const struct hda_fixup *fix, int action)
4133 {
4134     struct sigmatel_spec *spec = codec->spec;
4135
4136     if (action == HDA_FIXUP_ACT_PRE_PROBE)
4137         spec->eapd_switch = 0;
4138 }
4139
4140 static const struct hda_fixup stac9205_fixups[] = {
4141     [STAC_9205_REF] = {
4142         .type = HDA_FIXUP_FUNC,
4143         .v.func = stac9205_fixup_ref,
4144     },
4145     [STAC_9205_DELL_M42] = {
4146         .type = HDA_FIXUP_PINS,
4147         .v.pins = dell_9205_m42_pin_configs,
4148     },
4149     [STAC_9205_DELL_M43] = {
4150         .type = HDA_FIXUP_FUNC,
4151         .v.func = stac9205_fixup_dell_m43,
4152     },
4153     [STAC_9205_DELL_M44] = {
4154         .type = HDA_FIXUP_PINS,
4155         .v.pins = dell_9205_m44_pin_configs,
4156     },
4157     [STAC_9205_EAPD] = {
4158         .type = HDA_FIXUP_FUNC,
4159         .v.func = stac9205_fixup_eapd,
4160     },
4161     {}
4162 };
4163
4164 static const struct hda_model_fixup stac9205_models[] = {
4165     { .id = STAC_9205_REF, .name = "ref" },
4166     { .id = STAC_9205_DELL_M42, .name = "dell-m42" },
4167     { .id = STAC_9205_DELL_M43, .name = "dell-m43" },
4168     { .id = STAC_9205_DELL_M44, .name = "dell-m44" },
4169     { .id = STAC_9205_EAPD, .name = "eapd" },
4170     {}
4171 };
4172
4173 static const struct snd_pci_quirk stac9205_fixup_tbl[] = {
4174     /* SigmaTel reference board */
4175     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
4176               "DFI LanParty", STAC_9205_REF),
4177     SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
4178               "SigmaTel", STAC_9205_REF),
4179     SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
4180               "DFI LanParty", STAC_9205_REF),
4181     /* Dell */
4182     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
4183               "unknown Dell", STAC_9205_DELL_M42),
4184     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
4185               "unknown Dell", STAC_9205_DELL_M42),
4186     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
4187               "Dell Precision", STAC_9205_DELL_M43),
4188     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
4189               "Dell Precision", STAC_9205_DELL_M43),
4190     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
4191               "Dell Precision", STAC_9205_DELL_M43),
4192     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
4193               "unknown Dell", STAC_9205_DELL_M42),
4194     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
4195               "unknown Dell", STAC_9205_DELL_M42),
4196     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
4197               "Dell Precision", STAC_9205_DELL_M43),
4198     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
4199               "Dell Precision M4300", STAC_9205_DELL_M43),
4200     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
4201               "unknown Dell", STAC_9205_DELL_M42),
4202     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
4203               "Dell Precision", STAC_9205_DELL_M43),
4204     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
4205               "Dell Precision", STAC_9205_DELL_M43),
4206     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
4207               "Dell Precision", STAC_9205_DELL_M43),
4208     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
4209               "Dell Inspiron", STAC_9205_DELL_M44),
4210     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
4211               "Dell Vostro 1500", STAC_9205_DELL_M42),
4212     SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
4213               "Dell Vostro 1700", STAC_9205_DELL_M42),
4214     /* Gateway */
4215     SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
4216     SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
4217     {} /* terminator */
4218 };
4219
4220 static void stac92hd95_fixup_hp_led(struct hda_codec *codec,
4221                     const struct hda_fixup *fix, int action)
4222 {
4223     struct sigmatel_spec *spec = codec->spec;
4224
4225     if (action != HDA_FIXUP_ACT_PRE_PROBE)
4226         return;
4227
4228     if (find_mute_led_cfg(codec, spec->default_polarity))
4229         codec_dbg(codec, "mute LED gpio %d polarity %d\n",
4230                 spec->gpio_led,
4231                 spec->gpio_led_polarity);
4232 }
4233
4234 static const struct hda_fixup stac92hd95_fixups[] = {
4235     [STAC_92HD95_HP_LED] = {
4236         .type = HDA_FIXUP_FUNC,
4237         .v.func = stac92hd95_fixup_hp_led,
4238     },
4239     [STAC_92HD95_HP_BASS] = {
4240         .type = HDA_FIXUP_VERBS,
4241         .v.verbs = (const struct hda_verb[]) {
4242             {0x1a, 0x795, 0x00}, /* HPF to 100Hz */
4243             {}
4244         },
4245         .chained = true,
4246         .chain_id = STAC_92HD95_HP_LED,
4247     },
4248 };
4249
4250 static const struct snd_pci_quirk stac92hd95_fixup_tbl[] = {
4251     SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1911, "HP Spectre 13", STAC_92HD95_HP_BASS),
4252     {} /* terminator */
4253 };
4254
4255 static const struct hda_model_fixup stac92hd95_models[] = {
4256     { .id = STAC_92HD95_HP_LED, .name = "hp-led" },
4257     { .id = STAC_92HD95_HP_BASS, .name = "hp-bass" },
4258     {}
4259 };
4260
4261
4262 static int stac_parse_auto_config(struct hda_codec *codec)
4263 {
4264     struct sigmatel_spec *spec = codec->spec;
4265     int err;
4266     int flags = 0;
4267
4268     if (spec->headset_jack)
4269         flags |= HDA_PINCFG_HEADSET_MIC;
4270
4271     err = snd_hda_parse_pin_defcfg(codec, &spec->gen.autocfg, NULL, flags);
4272     if (err < 0)
4273         return err;
4274
4275     /* add hooks */
4276     spec->gen.pcm_playback_hook = stac_playback_pcm_hook;
4277     spec->gen.pcm_capture_hook = stac_capture_pcm_hook;
4278
4279     spec->gen.automute_hook = stac_update_outputs;
4280
4281     if (spec->gpio_led)
4282         snd_hda_gen_add_mute_led_cdev(codec, stac_vmaster_hook);
4283
4284     err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
4285     if (err < 0)
4286         return err;
4287
4288     if (spec->vref_mute_led_nid) {
4289         err = snd_hda_gen_fix_pin_power(codec, spec->vref_mute_led_nid);
4290         if (err < 0)
4291             return err;
4292     }
4293
4294     /* setup analog beep controls */
4295     if (spec->anabeep_nid > 0) {
4296         err = stac_auto_create_beep_ctls(codec,
4297                          spec->anabeep_nid);
4298         if (err < 0)
4299             return err;
4300     }
4301
4302     /* setup digital beep controls and input device */
4303 #ifdef CONFIG_SND_HDA_INPUT_BEEP
4304     if (spec->gen.beep_nid) {
4305         hda_nid_t nid = spec->gen.beep_nid;
4306         unsigned int caps;
4307
4308         err = stac_auto_create_beep_ctls(codec, nid);
4309         if (err < 0)
4310             return err;
4311         if (codec->beep) {
4312             /* IDT/STAC codecs have linear beep tone parameter */
4313             codec->beep->linear_tone = spec->linear_tone_beep;
4314             /* if no beep switch is available, make its own one */
4315             caps = query_amp_caps(codec, nid, HDA_OUTPUT);
4316             if (!(caps & AC_AMPCAP_MUTE)) {
4317                 err = stac_beep_switch_ctl(codec);
4318                 if (err < 0)
4319                     return err;
4320             }
4321         }
4322     }
4323 #endif
4324
4325     if (spec->aloopback_ctl &&
4326         snd_hda_get_bool_hint(codec, "loopback") == 1) {
4327         unsigned int wr_verb =
4328             spec->aloopback_ctl->private_value >> 16;
4329         if (snd_hdac_regmap_add_vendor_verb(&codec->core, wr_verb))
4330             return -ENOMEM;
4331         if (!snd_hda_gen_add_kctl(&spec->gen, NULL, spec->aloopback_ctl))
4332             return -ENOMEM;
4333     }
4334
4335     if (spec->have_spdif_mux) {
4336         err = stac_create_spdif_mux_ctls(codec);
4337         if (err < 0)
4338             return err;
4339     }
4340
4341     stac_init_power_map(codec);
4342
4343     return 0;
4344 }
4345
4346 static int stac_init(struct hda_codec *codec)
4347 {
4348     struct sigmatel_spec *spec = codec->spec;
4349     int i;
4350
4351     /* override some hints */
4352     stac_store_hints(codec);
4353
4354     /* set up GPIO */
4355     /* turn on EAPD statically when spec->eapd_switch isn't set.
4356      * otherwise, unsol event will turn it on/off dynamically
4357      */
4358     if (!spec->eapd_switch)
4359         spec->gpio_data |= spec->eapd_mask;
4360     stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
4361
4362     snd_hda_gen_init(codec);
4363
4364     /* sync the power-map */
4365     if (spec->num_pwrs)
4366         snd_hda_codec_write(codec, codec->core.afg, 0,
4367                     AC_VERB_IDT_SET_POWER_MAP,
4368                     spec->power_map_bits);
4369
4370     /* power down inactive ADCs */
4371     if (spec->powerdown_adcs) {
4372         for (i = 0; i < spec->gen.num_all_adcs; i++) {
4373             if (spec->active_adcs & (1 << i))
4374                 continue;
4375             snd_hda_codec_write(codec, spec->gen.all_adcs[i], 0,
4376                         AC_VERB_SET_POWER_STATE,
4377                         AC_PWRST_D3);
4378         }
4379     }
4380
4381     return 0;
4382 }
4383
4384 #define stac_free   snd_hda_gen_free
4385
4386 #ifdef CONFIG_SND_PROC_FS
4387 static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4388                    struct hda_codec *codec, hda_nid_t nid)
4389 {
4390     if (nid == codec->core.afg)
4391         snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4392                 snd_hda_codec_read(codec, nid, 0,
4393                            AC_VERB_IDT_GET_POWER_MAP, 0));
4394 }
4395
4396 static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4397                   struct hda_codec *codec,
4398                   unsigned int verb)
4399 {
4400     snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4401             snd_hda_codec_read(codec, codec->core.afg, 0, verb, 0));
4402 }
4403
4404 /* stac92hd71bxx, stac92hd73xx */
4405 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4406                  struct hda_codec *codec, hda_nid_t nid)
4407 {
4408     stac92hd_proc_hook(buffer, codec, nid);
4409     if (nid == codec->core.afg)
4410         analog_loop_proc_hook(buffer, codec, 0xfa0);
4411 }
4412
4413 static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4414                    struct hda_codec *codec, hda_nid_t nid)
4415 {
4416     if (nid == codec->core.afg)
4417         analog_loop_proc_hook(buffer, codec, 0xfe0);
4418 }
4419
4420 static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4421                    struct hda_codec *codec, hda_nid_t nid)
4422 {
4423     if (nid == codec->core.afg)
4424         analog_loop_proc_hook(buffer, codec, 0xfeb);
4425 }
4426 #else
4427 #define stac92hd_proc_hook  NULL
4428 #define stac92hd7x_proc_hook    NULL
4429 #define stac9205_proc_hook  NULL
4430 #define stac927x_proc_hook  NULL
4431 #endif
4432
4433 #ifdef CONFIG_PM
4434 static int stac_suspend(struct hda_codec *codec)
4435 {
4436     struct sigmatel_spec *spec = codec->spec;
4437
4438     snd_hda_shutup_pins(codec);
4439
4440     if (spec->eapd_mask)
4441         stac_gpio_set(codec, spec->gpio_mask,
4442                 spec->gpio_dir, spec->gpio_data &
4443                 ~spec->eapd_mask);
4444
4445     return 0;
4446 }
4447
4448 static int stac_check_power_status(struct hda_codec *codec, hda_nid_t nid)
4449 {
4450 #ifdef CONFIG_SND_HDA_INPUT_BEEP
4451     struct sigmatel_spec *spec = codec->spec;
4452 #endif
4453     int ret = snd_hda_gen_check_power_status(codec, nid);
4454
4455 #ifdef CONFIG_SND_HDA_INPUT_BEEP
4456     if (nid == spec->gen.beep_nid && codec->beep) {
4457         if (codec->beep->enabled != spec->beep_power_on) {
4458             spec->beep_power_on = codec->beep->enabled;
4459             if (spec->beep_power_on)
4460                 snd_hda_power_up_pm(codec);
4461             else
4462                 snd_hda_power_down_pm(codec);
4463         }
4464         ret |= spec->beep_power_on;
4465     }
4466 #endif
4467     return ret;
4468 }
4469 #else
4470 #define stac_suspend        NULL
4471 #endif /* CONFIG_PM */
4472
4473 static const struct hda_codec_ops stac_patch_ops = {
4474     .build_controls = snd_hda_gen_build_controls,
4475     .build_pcms = snd_hda_gen_build_pcms,
4476     .init = stac_init,
4477     .free = stac_free,
4478     .unsol_event = snd_hda_jack_unsol_event,
4479 #ifdef CONFIG_PM
4480     .suspend = stac_suspend,
4481     .check_power_status = stac_check_power_status,
4482 #endif
4483 };
4484
4485 static int alloc_stac_spec(struct hda_codec *codec)
4486 {
4487     struct sigmatel_spec *spec;
4488
4489     spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4490     if (!spec)
4491         return -ENOMEM;
4492     snd_hda_gen_spec_init(&spec->gen);
4493     codec->spec = spec;
4494     codec->no_trigger_sense = 1; /* seems common with STAC/IDT codecs */
4495     spec->gen.dac_min_mute = true;
4496     codec->patch_ops = stac_patch_ops;
4497     return 0;
4498 }
4499
4500 static int patch_stac9200(struct hda_codec *codec)
4501 {
4502     struct sigmatel_spec *spec;
4503     int err;
4504
4505     err = alloc_stac_spec(codec);
4506     if (err < 0)
4507         return err;
4508
4509     spec = codec->spec;
4510     spec->linear_tone_beep = 1;
4511     spec->gen.own_eapd_ctl = 1;
4512
4513     codec->power_filter = snd_hda_codec_eapd_power_filter;
4514
4515     snd_hda_add_verbs(codec, stac9200_eapd_init);
4516
4517     snd_hda_pick_fixup(codec, stac9200_models, stac9200_fixup_tbl,
4518                stac9200_fixups);
4519     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4520
4521     err = stac_parse_auto_config(codec);
4522     if (err < 0) {
4523         stac_free(codec);
4524         return err;
4525     }
4526
4527     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4528
4529     return 0;
4530 }
4531
4532 static int patch_stac925x(struct hda_codec *codec)
4533 {
4534     struct sigmatel_spec *spec;
4535     int err;
4536
4537     err = alloc_stac_spec(codec);
4538     if (err < 0)
4539         return err;
4540
4541     spec = codec->spec;
4542     spec->linear_tone_beep = 1;
4543     spec->gen.own_eapd_ctl = 1;
4544
4545     snd_hda_add_verbs(codec, stac925x_core_init);
4546
4547     snd_hda_pick_fixup(codec, stac925x_models, stac925x_fixup_tbl,
4548                stac925x_fixups);
4549     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4550
4551     err = stac_parse_auto_config(codec);
4552     if (err < 0) {
4553         stac_free(codec);
4554         return err;
4555     }
4556
4557     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4558
4559     return 0;
4560 }
4561
4562 static int patch_stac92hd73xx(struct hda_codec *codec)
4563 {
4564     struct sigmatel_spec *spec;
4565     int err;
4566     int num_dacs;
4567
4568     err = alloc_stac_spec(codec);
4569     if (err < 0)
4570         return err;
4571
4572     spec = codec->spec;
4573     /* enable power_save_node only for new 92HD89xx chips, as it causes
4574      * click noises on old 92HD73xx chips.
4575      */
4576     if ((codec->core.vendor_id & 0xfffffff0) != 0x111d7670)
4577         codec->power_save_node = 1;
4578     spec->linear_tone_beep = 0;
4579     spec->gen.mixer_nid = 0x1d;
4580     spec->have_spdif_mux = 1;
4581
4582     num_dacs = snd_hda_get_num_conns(codec, 0x0a) - 1;
4583     if (num_dacs < 3 || num_dacs > 5) {
4584         codec_warn(codec,
4585                "Could not determine number of channels defaulting to DAC count\n");
4586         num_dacs = 5;
4587     }
4588
4589     switch (num_dacs) {
4590     case 0x3: /* 6 Channel */
4591         spec->aloopback_ctl = &stac92hd73xx_6ch_loopback;
4592         break;
4593     case 0x4: /* 8 Channel */
4594         spec->aloopback_ctl = &stac92hd73xx_8ch_loopback;
4595         break;
4596     case 0x5: /* 10 Channel */
4597         spec->aloopback_ctl = &stac92hd73xx_10ch_loopback;
4598         break;
4599     }
4600
4601     spec->aloopback_mask = 0x01;
4602     spec->aloopback_shift = 8;
4603
4604     spec->gen.beep_nid = 0x1c; /* digital beep */
4605
4606     /* GPIO0 High = Enable EAPD */
4607     spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4608     spec->gpio_data = 0x01;
4609
4610     spec->eapd_switch = 1;
4611
4612     spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
4613     spec->pwr_nids = stac92hd73xx_pwr_nids;
4614
4615     spec->gen.own_eapd_ctl = 1;
4616     spec->gen.power_down_unused = 1;
4617
4618     snd_hda_pick_fixup(codec, stac92hd73xx_models, stac92hd73xx_fixup_tbl,
4619                stac92hd73xx_fixups);
4620     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4621
4622     if (!spec->volknob_init)
4623         snd_hda_add_verbs(codec, stac92hd73xx_core_init);
4624
4625     err = stac_parse_auto_config(codec);
4626     if (err < 0) {
4627         stac_free(codec);
4628         return err;
4629     }
4630
4631     /* Don't GPIO-mute speakers if there are no internal speakers, because
4632      * the GPIO might be necessary for Headphone
4633      */
4634     if (spec->eapd_switch && !has_builtin_speaker(codec))
4635         spec->eapd_switch = 0;
4636
4637     codec->proc_widget_hook = stac92hd7x_proc_hook;
4638
4639     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4640
4641     return 0;
4642 }
4643
4644 static void stac_setup_gpio(struct hda_codec *codec)
4645 {
4646     struct sigmatel_spec *spec = codec->spec;
4647
4648     spec->gpio_mask |= spec->eapd_mask;
4649     if (spec->gpio_led) {
4650         if (!spec->vref_mute_led_nid) {
4651             spec->gpio_mask |= spec->gpio_led;
4652             spec->gpio_dir |= spec->gpio_led;
4653             spec->gpio_data |= spec->gpio_led;
4654         } else {
4655             codec->power_filter = stac_vref_led_power_filter;
4656         }
4657     }
4658
4659     if (spec->mic_mute_led_gpio) {
4660         spec->gpio_mask |= spec->mic_mute_led_gpio;
4661         spec->gpio_dir |= spec->mic_mute_led_gpio;
4662         spec->mic_enabled = 0;
4663         spec->gpio_data |= spec->mic_mute_led_gpio;
4664         snd_hda_gen_add_micmute_led_cdev(codec, stac_capture_led_update);
4665     }
4666 }
4667
4668 static int patch_stac92hd83xxx(struct hda_codec *codec)
4669 {
4670     struct sigmatel_spec *spec;
4671     int err;
4672
4673     err = alloc_stac_spec(codec);
4674     if (err < 0)
4675         return err;
4676
4677     /* longer delay needed for D3 */
4678     codec->core.power_caps &= ~AC_PWRST_EPSS;
4679
4680     spec = codec->spec;
4681     codec->power_save_node = 1;
4682     spec->linear_tone_beep = 0;
4683     spec->gen.own_eapd_ctl = 1;
4684     spec->gen.power_down_unused = 1;
4685     spec->gen.mixer_nid = 0x1b;
4686
4687     spec->gen.beep_nid = 0x21; /* digital beep */
4688     spec->pwr_nids = stac92hd83xxx_pwr_nids;
4689     spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4690     spec->default_polarity = -1; /* no default cfg */
4691
4692     snd_hda_add_verbs(codec, stac92hd83xxx_core_init);
4693
4694     snd_hda_pick_fixup(codec, stac92hd83xxx_models, stac92hd83xxx_fixup_tbl,
4695                stac92hd83xxx_fixups);
4696     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4697
4698     stac_setup_gpio(codec);
4699
4700     err = stac_parse_auto_config(codec);
4701     if (err < 0) {
4702         stac_free(codec);
4703         return err;
4704     }
4705
4706     codec->proc_widget_hook = stac92hd_proc_hook;
4707
4708     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4709
4710     return 0;
4711 }
4712
4713 static const hda_nid_t stac92hd95_pwr_nids[] = {
4714     0x0a, 0x0b, 0x0c, 0x0d
4715 };
4716
4717 static int patch_stac92hd95(struct hda_codec *codec)
4718 {
4719     struct sigmatel_spec *spec;
4720     int err;
4721
4722     err = alloc_stac_spec(codec);
4723     if (err < 0)
4724         return err;
4725
4726     /* longer delay needed for D3 */
4727     codec->core.power_caps &= ~AC_PWRST_EPSS;
4728
4729     spec = codec->spec;
4730     codec->power_save_node = 1;
4731     spec->linear_tone_beep = 0;
4732     spec->gen.own_eapd_ctl = 1;
4733     spec->gen.power_down_unused = 1;
4734
4735     spec->gen.beep_nid = 0x19; /* digital beep */
4736     spec->pwr_nids = stac92hd95_pwr_nids;
4737     spec->num_pwrs = ARRAY_SIZE(stac92hd95_pwr_nids);
4738     spec->default_polarity = 0;
4739
4740     snd_hda_pick_fixup(codec, stac92hd95_models, stac92hd95_fixup_tbl,
4741                stac92hd95_fixups);
4742     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4743
4744     stac_setup_gpio(codec);
4745
4746     err = stac_parse_auto_config(codec);
4747     if (err < 0) {
4748         stac_free(codec);
4749         return err;
4750     }
4751
4752     codec->proc_widget_hook = stac92hd_proc_hook;
4753
4754     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4755
4756     return 0;
4757 }
4758
4759 static int patch_stac92hd71bxx(struct hda_codec *codec)
4760 {
4761     struct sigmatel_spec *spec;
4762     const hda_nid_t *unmute_nids = stac92hd71bxx_unmute_nids;
4763     int err;
4764
4765     err = alloc_stac_spec(codec);
4766     if (err < 0)
4767         return err;
4768
4769     spec = codec->spec;
4770     /* disabled power_save_node since it causes noises on a Dell machine */
4771     /* codec->power_save_node = 1; */
4772     spec->linear_tone_beep = 0;
4773     spec->gen.own_eapd_ctl = 1;
4774     spec->gen.power_down_unused = 1;
4775     spec->gen.mixer_nid = 0x17;
4776     spec->have_spdif_mux = 1;
4777
4778     /* GPIO0 = EAPD */
4779     spec->gpio_mask = 0x01;
4780     spec->gpio_dir = 0x01;
4781     spec->gpio_data = 0x01;
4782
4783     switch (codec->core.vendor_id) {
4784     case 0x111d76b6: /* 4 Port without Analog Mixer */
4785     case 0x111d76b7:
4786         unmute_nids++;
4787         break;
4788     case 0x111d7608: /* 5 Port with Analog Mixer */
4789         if ((codec->core.revision_id & 0xf) == 0 ||
4790             (codec->core.revision_id & 0xf) == 1)
4791             spec->stream_delay = 40; /* 40 milliseconds */
4792
4793         /* disable VSW */
4794         unmute_nids++;
4795         snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
4796         snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
4797         break;
4798     case 0x111d7603: /* 6 Port with Analog Mixer */
4799         if ((codec->core.revision_id & 0xf) == 1)
4800             spec->stream_delay = 40; /* 40 milliseconds */
4801
4802         break;
4803     }
4804
4805     if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB)
4806         snd_hda_add_verbs(codec, stac92hd71bxx_core_init);
4807
4808     if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP) {
4809         const hda_nid_t *p;
4810         for (p = unmute_nids; *p; p++)
4811             snd_hda_codec_amp_init_stereo(codec, *p, HDA_INPUT, 0,
4812                               0xff, 0x00);
4813     }
4814
4815     spec->aloopback_ctl = &stac92hd71bxx_loopback;
4816     spec->aloopback_mask = 0x50;
4817     spec->aloopback_shift = 0;
4818
4819     spec->powerdown_adcs = 1;
4820     spec->gen.beep_nid = 0x26; /* digital beep */
4821     spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4822     spec->pwr_nids = stac92hd71bxx_pwr_nids;
4823
4824     snd_hda_pick_fixup(codec, stac92hd71bxx_models, stac92hd71bxx_fixup_tbl,
4825                stac92hd71bxx_fixups);
4826     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4827
4828     stac_setup_gpio(codec);
4829
4830     err = stac_parse_auto_config(codec);
4831     if (err < 0) {
4832         stac_free(codec);
4833         return err;
4834     }
4835
4836     codec->proc_widget_hook = stac92hd7x_proc_hook;
4837
4838     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4839
4840     return 0;
4841 }
4842
4843 static int patch_stac922x(struct hda_codec *codec)
4844 {
4845     struct sigmatel_spec *spec;
4846     int err;
4847
4848     err = alloc_stac_spec(codec);
4849     if (err < 0)
4850         return err;
4851
4852     spec = codec->spec;
4853     spec->linear_tone_beep = 1;
4854     spec->gen.own_eapd_ctl = 1;
4855
4856     snd_hda_add_verbs(codec, stac922x_core_init);
4857
4858     /* Fix Mux capture level; max to 2 */
4859     snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
4860                   (0 << AC_AMPCAP_OFFSET_SHIFT) |
4861                   (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
4862                   (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
4863                   (0 << AC_AMPCAP_MUTE_SHIFT));
4864
4865     snd_hda_pick_fixup(codec, stac922x_models, stac922x_fixup_tbl,
4866                stac922x_fixups);
4867     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4868
4869     err = stac_parse_auto_config(codec);
4870     if (err < 0) {
4871         stac_free(codec);
4872         return err;
4873     }
4874
4875     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4876
4877     return 0;
4878 }
4879
4880 static const char * const stac927x_spdif_labels[] = {
4881     "Digital Playback", "ADAT", "Analog Mux 1",
4882     "Analog Mux 2", "Analog Mux 3", NULL
4883 };
4884
4885 static int patch_stac927x(struct hda_codec *codec)
4886 {
4887     struct sigmatel_spec *spec;
4888     int err;
4889
4890     err = alloc_stac_spec(codec);
4891     if (err < 0)
4892         return err;
4893
4894     spec = codec->spec;
4895     spec->linear_tone_beep = 1;
4896     spec->gen.own_eapd_ctl = 1;
4897     spec->have_spdif_mux = 1;
4898     spec->spdif_labels = stac927x_spdif_labels;
4899
4900     spec->gen.beep_nid = 0x23; /* digital beep */
4901
4902     /* GPIO0 High = Enable EAPD */
4903     spec->eapd_mask = spec->gpio_mask = 0x01;
4904     spec->gpio_dir = spec->gpio_data = 0x01;
4905
4906     spec->aloopback_ctl = &stac927x_loopback;
4907     spec->aloopback_mask = 0x40;
4908     spec->aloopback_shift = 0;
4909     spec->eapd_switch = 1;
4910
4911     snd_hda_pick_fixup(codec, stac927x_models, stac927x_fixup_tbl,
4912                stac927x_fixups);
4913     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4914
4915     if (!spec->volknob_init)
4916         snd_hda_add_verbs(codec, stac927x_core_init);
4917
4918     err = stac_parse_auto_config(codec);
4919     if (err < 0) {
4920         stac_free(codec);
4921         return err;
4922     }
4923
4924     codec->proc_widget_hook = stac927x_proc_hook;
4925
4926     /*
4927      * !!FIXME!!
4928      * The STAC927x seem to require fairly long delays for certain
4929      * command sequences.  With too short delays (even if the answer
4930      * is set to RIRB properly), it results in the silence output
4931      * on some hardwares like Dell.
4932      *
4933      * The below flag enables the longer delay (see get_response
4934      * in hda_intel.c).
4935      */
4936     codec->bus->core.needs_damn_long_delay = 1;
4937
4938     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4939
4940     return 0;
4941 }
4942
4943 static int patch_stac9205(struct hda_codec *codec)
4944 {
4945     struct sigmatel_spec *spec;
4946     int err;
4947
4948     err = alloc_stac_spec(codec);
4949     if (err < 0)
4950         return err;
4951
4952     spec = codec->spec;
4953     spec->linear_tone_beep = 1;
4954     spec->gen.own_eapd_ctl = 1;
4955     spec->have_spdif_mux = 1;
4956
4957     spec->gen.beep_nid = 0x23; /* digital beep */
4958
4959     snd_hda_add_verbs(codec, stac9205_core_init);
4960     spec->aloopback_ctl = &stac9205_loopback;
4961
4962     spec->aloopback_mask = 0x40;
4963     spec->aloopback_shift = 0;
4964
4965     /* GPIO0 High = EAPD */
4966     spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4967     spec->gpio_data = 0x01;
4968
4969     /* Turn on/off EAPD per HP plugging */
4970     spec->eapd_switch = 1;
4971
4972     snd_hda_pick_fixup(codec, stac9205_models, stac9205_fixup_tbl,
4973                stac9205_fixups);
4974     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
4975
4976     err = stac_parse_auto_config(codec);
4977     if (err < 0) {
4978         stac_free(codec);
4979         return err;
4980     }
4981
4982     codec->proc_widget_hook = stac9205_proc_hook;
4983
4984     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
4985
4986     return 0;
4987 }
4988
4989 /*
4990  * STAC9872 hack
4991  */
4992
4993 static const struct hda_verb stac9872_core_init[] = {
4994     {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
4995     {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
4996     {}
4997 };
4998
4999 static const struct hda_pintbl stac9872_vaio_pin_configs[] = {
5000     { 0x0a, 0x03211020 },
5001     { 0x0b, 0x411111f0 },
5002     { 0x0c, 0x411111f0 },
5003     { 0x0d, 0x03a15030 },
5004     { 0x0e, 0x411111f0 },
5005     { 0x0f, 0x90170110 },
5006     { 0x11, 0x411111f0 },
5007     { 0x13, 0x411111f0 },
5008     { 0x14, 0x90a7013e },
5009     {}
5010 };
5011
5012 static const struct hda_model_fixup stac9872_models[] = {
5013     { .id = STAC_9872_VAIO, .name = "vaio" },
5014     {}
5015 };
5016
5017 static const struct hda_fixup stac9872_fixups[] = {
5018     [STAC_9872_VAIO] = {
5019         .type = HDA_FIXUP_PINS,
5020         .v.pins = stac9872_vaio_pin_configs,
5021     },
5022 };
5023
5024 static const struct snd_pci_quirk stac9872_fixup_tbl[] = {
5025     SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
5026                "Sony VAIO F/S", STAC_9872_VAIO),
5027     {} /* terminator */
5028 };
5029
5030 static int patch_stac9872(struct hda_codec *codec)
5031 {
5032     struct sigmatel_spec *spec;
5033     int err;
5034
5035     err = alloc_stac_spec(codec);
5036     if (err < 0)
5037         return err;
5038
5039     spec = codec->spec;
5040     spec->linear_tone_beep = 1;
5041     spec->gen.own_eapd_ctl = 1;
5042
5043     snd_hda_add_verbs(codec, stac9872_core_init);
5044
5045     snd_hda_pick_fixup(codec, stac9872_models, stac9872_fixup_tbl,
5046                stac9872_fixups);
5047     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5048
5049     err = stac_parse_auto_config(codec);
5050     if (err < 0) {
5051         stac_free(codec);
5052         return -EINVAL;
5053     }
5054
5055     snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
5056
5057     return 0;
5058 }
5059
5060
5061 /*
5062  * patch entries
5063  */
5064 static const struct hda_device_id snd_hda_id_sigmatel[] = {
5065     HDA_CODEC_ENTRY(0x83847690, "STAC9200", patch_stac9200),
5066     HDA_CODEC_ENTRY(0x83847882, "STAC9220 A1", patch_stac922x),
5067     HDA_CODEC_ENTRY(0x83847680, "STAC9221 A1", patch_stac922x),
5068     HDA_CODEC_ENTRY(0x83847880, "STAC9220 A2", patch_stac922x),
5069     HDA_CODEC_ENTRY(0x83847681, "STAC9220D/9223D A2", patch_stac922x),
5070     HDA_CODEC_ENTRY(0x83847682, "STAC9221 A2", patch_stac922x),
5071     HDA_CODEC_ENTRY(0x83847683, "STAC9221D A2", patch_stac922x),
5072     HDA_CODEC_ENTRY(0x83847618, "STAC9227", patch_stac927x),
5073     HDA_CODEC_ENTRY(0x83847619, "STAC9227", patch_stac927x),
5074     HDA_CODEC_ENTRY(0x83847638, "STAC92HD700", patch_stac927x),
5075     HDA_CODEC_ENTRY(0x83847616, "STAC9228", patch_stac927x),
5076     HDA_CODEC_ENTRY(0x83847617, "STAC9228", patch_stac927x),
5077     HDA_CODEC_ENTRY(0x83847614, "STAC9229", patch_stac927x),
5078     HDA_CODEC_ENTRY(0x83847615, "STAC9229", patch_stac927x),
5079     HDA_CODEC_ENTRY(0x83847620, "STAC9274", patch_stac927x),
5080     HDA_CODEC_ENTRY(0x83847621, "STAC9274D", patch_stac927x),
5081     HDA_CODEC_ENTRY(0x83847622, "STAC9273X", patch_stac927x),
5082     HDA_CODEC_ENTRY(0x83847623, "STAC9273D", patch_stac927x),
5083     HDA_CODEC_ENTRY(0x83847624, "STAC9272X", patch_stac927x),
5084     HDA_CODEC_ENTRY(0x83847625, "STAC9272D", patch_stac927x),
5085     HDA_CODEC_ENTRY(0x83847626, "STAC9271X", patch_stac927x),
5086     HDA_CODEC_ENTRY(0x83847627, "STAC9271D", patch_stac927x),
5087     HDA_CODEC_ENTRY(0x83847628, "STAC9274X5NH", patch_stac927x),
5088     HDA_CODEC_ENTRY(0x83847629, "STAC9274D5NH", patch_stac927x),
5089     HDA_CODEC_ENTRY(0x83847632, "STAC9202",  patch_stac925x),
5090     HDA_CODEC_ENTRY(0x83847633, "STAC9202D", patch_stac925x),
5091     HDA_CODEC_ENTRY(0x83847634, "STAC9250", patch_stac925x),
5092     HDA_CODEC_ENTRY(0x83847635, "STAC9250D", patch_stac925x),
5093     HDA_CODEC_ENTRY(0x83847636, "STAC9251", patch_stac925x),
5094     HDA_CODEC_ENTRY(0x83847637, "STAC9250D", patch_stac925x),
5095     HDA_CODEC_ENTRY(0x83847645, "92HD206X", patch_stac927x),
5096     HDA_CODEC_ENTRY(0x83847646, "92HD206D", patch_stac927x),
5097     /* The following does not take into account .id=0x83847661 when subsys =
5098      * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
5099      * currently not fully supported.
5100      */
5101     HDA_CODEC_ENTRY(0x83847661, "CXD9872RD/K", patch_stac9872),
5102     HDA_CODEC_ENTRY(0x83847662, "STAC9872AK", patch_stac9872),
5103     HDA_CODEC_ENTRY(0x83847664, "CXD9872AKD", patch_stac9872),
5104     HDA_CODEC_ENTRY(0x83847698, "STAC9205", patch_stac9205),
5105     HDA_CODEC_ENTRY(0x838476a0, "STAC9205", patch_stac9205),
5106     HDA_CODEC_ENTRY(0x838476a1, "STAC9205D", patch_stac9205),
5107     HDA_CODEC_ENTRY(0x838476a2, "STAC9204", patch_stac9205),
5108     HDA_CODEC_ENTRY(0x838476a3, "STAC9204D", patch_stac9205),
5109     HDA_CODEC_ENTRY(0x838476a4, "STAC9255", patch_stac9205),
5110     HDA_CODEC_ENTRY(0x838476a5, "STAC9255D", patch_stac9205),
5111     HDA_CODEC_ENTRY(0x838476a6, "STAC9254", patch_stac9205),
5112     HDA_CODEC_ENTRY(0x838476a7, "STAC9254D", patch_stac9205),
5113     HDA_CODEC_ENTRY(0x111d7603, "92HD75B3X5", patch_stac92hd71bxx),
5114     HDA_CODEC_ENTRY(0x111d7604, "92HD83C1X5", patch_stac92hd83xxx),
5115     HDA_CODEC_ENTRY(0x111d76d4, "92HD83C1C5", patch_stac92hd83xxx),
5116     HDA_CODEC_ENTRY(0x111d7605, "92HD81B1X5", patch_stac92hd83xxx),
5117     HDA_CODEC_ENTRY(0x111d76d5, "92HD81B1C5", patch_stac92hd83xxx),
5118     HDA_CODEC_ENTRY(0x111d76d1, "92HD87B1/3", patch_stac92hd83xxx),
5119     HDA_CODEC_ENTRY(0x111d76d9, "92HD87B2/4", patch_stac92hd83xxx),
5120     HDA_CODEC_ENTRY(0x111d7666, "92HD88B3", patch_stac92hd83xxx),
5121     HDA_CODEC_ENTRY(0x111d7667, "92HD88B1", patch_stac92hd83xxx),
5122     HDA_CODEC_ENTRY(0x111d7668, "92HD88B2", patch_stac92hd83xxx),
5123     HDA_CODEC_ENTRY(0x111d7669, "92HD88B4", patch_stac92hd83xxx),
5124     HDA_CODEC_ENTRY(0x111d7608, "92HD75B2X5", patch_stac92hd71bxx),
5125     HDA_CODEC_ENTRY(0x111d7674, "92HD73D1X5", patch_stac92hd73xx),
5126     HDA_CODEC_ENTRY(0x111d7675, "92HD73C1X5", patch_stac92hd73xx),
5127     HDA_CODEC_ENTRY(0x111d7676, "92HD73E1X5", patch_stac92hd73xx),
5128     HDA_CODEC_ENTRY(0x111d7695, "92HD95", patch_stac92hd95),
5129     HDA_CODEC_ENTRY(0x111d76b0, "92HD71B8X", patch_stac92hd71bxx),
5130     HDA_CODEC_ENTRY(0x111d76b1, "92HD71B8X", patch_stac92hd71bxx),
5131     HDA_CODEC_ENTRY(0x111d76b2, "92HD71B7X", patch_stac92hd71bxx),
5132     HDA_CODEC_ENTRY(0x111d76b3, "92HD71B7X", patch_stac92hd71bxx),
5133     HDA_CODEC_ENTRY(0x111d76b4, "92HD71B6X", patch_stac92hd71bxx),
5134     HDA_CODEC_ENTRY(0x111d76b5, "92HD71B6X", patch_stac92hd71bxx),
5135     HDA_CODEC_ENTRY(0x111d76b6, "92HD71B5X", patch_stac92hd71bxx),
5136     HDA_CODEC_ENTRY(0x111d76b7, "92HD71B5X", patch_stac92hd71bxx),
5137     HDA_CODEC_ENTRY(0x111d76c0, "92HD89C3", patch_stac92hd73xx),
5138     HDA_CODEC_ENTRY(0x111d76c1, "92HD89C2", patch_stac92hd73xx),
5139     HDA_CODEC_ENTRY(0x111d76c2, "92HD89C1", patch_stac92hd73xx),
5140     HDA_CODEC_ENTRY(0x111d76c3, "92HD89B3", patch_stac92hd73xx),
5141     HDA_CODEC_ENTRY(0x111d76c4, "92HD89B2", patch_stac92hd73xx),
5142     HDA_CODEC_ENTRY(0x111d76c5, "92HD89B1", patch_stac92hd73xx),
5143     HDA_CODEC_ENTRY(0x111d76c6, "92HD89E3", patch_stac92hd73xx),
5144     HDA_CODEC_ENTRY(0x111d76c7, "92HD89E2", patch_stac92hd73xx),
5145     HDA_CODEC_ENTRY(0x111d76c8, "92HD89E1", patch_stac92hd73xx),
5146     HDA_CODEC_ENTRY(0x111d76c9, "92HD89D3", patch_stac92hd73xx),
5147     HDA_CODEC_ENTRY(0x111d76ca, "92HD89D2", patch_stac92hd73xx),
5148     HDA_CODEC_ENTRY(0x111d76cb, "92HD89D1", patch_stac92hd73xx),
5149     HDA_CODEC_ENTRY(0x111d76cc, "92HD89F3", patch_stac92hd73xx),
5150     HDA_CODEC_ENTRY(0x111d76cd, "92HD89F2", patch_stac92hd73xx),
5151     HDA_CODEC_ENTRY(0x111d76ce, "92HD89F1", patch_stac92hd73xx),
5152     HDA_CODEC_ENTRY(0x111d76df, "92HD93BXX", patch_stac92hd83xxx),
5153     HDA_CODEC_ENTRY(0x111d76e0, "92HD91BXX", patch_stac92hd83xxx),
5154     HDA_CODEC_ENTRY(0x111d76e3, "92HD98BXX", patch_stac92hd83xxx),
5155     HDA_CODEC_ENTRY(0x111d76e5, "92HD99BXX", patch_stac92hd83xxx),
5156     HDA_CODEC_ENTRY(0x111d76e7, "92HD90BXX", patch_stac92hd83xxx),
5157     HDA_CODEC_ENTRY(0x111d76e8, "92HD66B1X5", patch_stac92hd83xxx),
5158     HDA_CODEC_ENTRY(0x111d76e9, "92HD66B2X5", patch_stac92hd83xxx),
5159     HDA_CODEC_ENTRY(0x111d76ea, "92HD66B3X5", patch_stac92hd83xxx),
5160     HDA_CODEC_ENTRY(0x111d76eb, "92HD66C1X5", patch_stac92hd83xxx),
5161     HDA_CODEC_ENTRY(0x111d76ec, "92HD66C2X5", patch_stac92hd83xxx),
5162     HDA_CODEC_ENTRY(0x111d76ed, "92HD66C3X5", patch_stac92hd83xxx),
5163     HDA_CODEC_ENTRY(0x111d76ee, "92HD66B1X3", patch_stac92hd83xxx),
5164     HDA_CODEC_ENTRY(0x111d76ef, "92HD66B2X3", patch_stac92hd83xxx),
5165     HDA_CODEC_ENTRY(0x111d76f0, "92HD66B3X3", patch_stac92hd83xxx),
5166     HDA_CODEC_ENTRY(0x111d76f1, "92HD66C1X3", patch_stac92hd83xxx),
5167     HDA_CODEC_ENTRY(0x111d76f2, "92HD66C2X3", patch_stac92hd83xxx),
5168     HDA_CODEC_ENTRY(0x111d76f3, "92HD66C3/65", patch_stac92hd83xxx),
5169     {} /* terminator */
5170 };
5171 MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_sigmatel);
5172
5173 MODULE_LICENSE("GPL");
5174 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
5175
5176 static struct hda_codec_driver sigmatel_driver = {
5177     .id = snd_hda_id_sigmatel,
5178 };
5179
5180 module_hda_codec_driver(sigmatel_driver);