linux/sound/pci/hda/patch_conexant.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * HD audio interface patch for Conexant HDA audio codec
   4 *
   5 * Copyright (c) 2006 Pototskiy Akex <alex.pototskiy@gmail.com>
   6 *                    Takashi Iwai <tiwai@suse.de>
   7 *                    Tobin Davis  <tdavis@dsl-only.net>
   8 */
   9
  10#include <linux/init.h>
  11#include <linux/delay.h>
  12#include <linux/slab.h>
  13#include <linux/module.h>
  14#include <sound/core.h>
  15#include <sound/jack.h>
  16
  17#include <sound/hda_codec.h>
  18#include "hda_local.h"
  19#include "hda_auto_parser.h"
  20#include "hda_beep.h"
  21#include "hda_jack.h"
  22#include "hda_generic.h"
  23
  24struct conexant_spec {
  25        struct hda_gen_spec gen;
  26
  27        /* extra EAPD pins */
  28        unsigned int num_eapds;
  29        hda_nid_t eapds[4];
  30        bool dynamic_eapd;
  31        hda_nid_t mute_led_eapd;
  32
  33        unsigned int parse_flags; /* flag for snd_hda_parse_pin_defcfg() */
  34
  35        /* OPLC XO specific */
  36        bool recording;
  37        bool dc_enable;
  38        unsigned int dc_input_bias; /* offset into olpc_xo_dc_bias */
  39        struct nid_path *dc_mode_path;
  40
  41        int mute_led_polarity;
  42        unsigned int gpio_led;
  43        unsigned int gpio_mute_led_mask;
  44        unsigned int gpio_mic_led_mask;
  45
  46};
  47
  48
  49#ifdef CONFIG_SND_HDA_INPUT_BEEP
  50/* additional beep mixers; private_value will be overwritten */
  51static const struct snd_kcontrol_new cxt_beep_mixer[] = {
  52        HDA_CODEC_VOLUME_MONO("Beep Playback Volume", 0, 1, 0, HDA_OUTPUT),
  53        HDA_CODEC_MUTE_BEEP_MONO("Beep Playback Switch", 0, 1, 0, HDA_OUTPUT),
  54};
  55
  56static int set_beep_amp(struct conexant_spec *spec, hda_nid_t nid,
  57                        int idx, int dir)
  58{
  59        struct snd_kcontrol_new *knew;
  60        unsigned int beep_amp = HDA_COMPOSE_AMP_VAL(nid, 1, idx, dir);
  61        int i;
  62
  63        spec->gen.beep_nid = nid;
  64        for (i = 0; i < ARRAY_SIZE(cxt_beep_mixer); i++) {
  65                knew = snd_hda_gen_add_kctl(&spec->gen, NULL,
  66                                            &cxt_beep_mixer[i]);
  67                if (!knew)
  68                        return -ENOMEM;
  69                knew->private_value = beep_amp;
  70        }
  71        return 0;
  72}
  73
  74static int cx_auto_parse_beep(struct hda_codec *codec)
  75{
  76        struct conexant_spec *spec = codec->spec;
  77        hda_nid_t nid;
  78
  79        for_each_hda_codec_node(nid, codec)
  80                if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_BEEP)
  81                        return set_beep_amp(spec, nid, 0, HDA_OUTPUT);
  82        return 0;
  83}
  84#else
  85#define cx_auto_parse_beep(codec)       0
  86#endif
  87
  88/*
  89 * Automatic parser for CX20641 & co
  90 */
  91
  92/* parse EAPDs */
  93static void cx_auto_parse_eapd(struct hda_codec *codec)
  94{
  95        struct conexant_spec *spec = codec->spec;
  96        hda_nid_t nid;
  97
  98        for_each_hda_codec_node(nid, codec) {
  99                if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 100                        continue;
 101                if (!(snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD))
 102                        continue;
 103                spec->eapds[spec->num_eapds++] = nid;
 104                if (spec->num_eapds >= ARRAY_SIZE(spec->eapds))
 105                        break;
 106        }
 107
 108        /* NOTE: below is a wild guess; if we have more than two EAPDs,
 109         * it's a new chip, where EAPDs are supposed to be associated to
 110         * pins, and we can control EAPD per pin.
 111         * OTOH, if only one or two EAPDs are found, it's an old chip,
 112         * thus it might control over all pins.
 113         */
 114        if (spec->num_eapds > 2)
 115                spec->dynamic_eapd = 1;
 116}
 117
 118static void cx_auto_turn_eapd(struct hda_codec *codec, int num_pins,
 119                              const hda_nid_t *pins, bool on)
 120{
 121        int i;
 122        for (i = 0; i < num_pins; i++) {
 123                if (snd_hda_query_pin_caps(codec, pins[i]) & AC_PINCAP_EAPD)
 124                        snd_hda_codec_write(codec, pins[i], 0,
 125                                            AC_VERB_SET_EAPD_BTLENABLE,
 126                                            on ? 0x02 : 0);
 127        }
 128}
 129
 130/* turn on/off EAPD according to Master switch */
 131static void cx_auto_vmaster_hook(void *private_data, int enabled)
 132{
 133        struct hda_codec *codec = private_data;
 134        struct conexant_spec *spec = codec->spec;
 135
 136        cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, enabled);
 137}
 138
 139/* turn on/off EAPD according to Master switch (inversely!) for mute LED */
 140static void cx_auto_vmaster_hook_mute_led(void *private_data, int enabled)
 141{
 142        struct hda_codec *codec = private_data;
 143        struct conexant_spec *spec = codec->spec;
 144
 145        snd_hda_codec_write(codec, spec->mute_led_eapd, 0,
 146                            AC_VERB_SET_EAPD_BTLENABLE,
 147                            enabled ? 0x00 : 0x02);
 148}
 149
 150static int cx_auto_init(struct hda_codec *codec)
 151{
 152        struct conexant_spec *spec = codec->spec;
 153        snd_hda_gen_init(codec);
 154        if (!spec->dynamic_eapd)
 155                cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, true);
 156
 157        snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_INIT);
 158
 159        return 0;
 160}
 161
 162static void cx_auto_reboot_notify(struct hda_codec *codec)
 163{
 164        struct conexant_spec *spec = codec->spec;
 165
 166        /* Turn the problematic codec into D3 to avoid spurious noises
 167           from the internal speaker during (and after) reboot */
 168        cx_auto_turn_eapd(codec, spec->num_eapds, spec->eapds, false);
 169        snd_hda_gen_reboot_notify(codec);
 170}
 171
 172static void cx_auto_free(struct hda_codec *codec)
 173{
 174        cx_auto_reboot_notify(codec);
 175        snd_hda_gen_free(codec);
 176}
 177
 178static const struct hda_codec_ops cx_auto_patch_ops = {
 179        .build_controls = snd_hda_gen_build_controls,
 180        .build_pcms = snd_hda_gen_build_pcms,
 181        .init = cx_auto_init,
 182        .reboot_notify = cx_auto_reboot_notify,
 183        .free = cx_auto_free,
 184        .unsol_event = snd_hda_jack_unsol_event,
 185#ifdef CONFIG_PM
 186        .check_power_status = snd_hda_gen_check_power_status,
 187#endif
 188};
 189
 190/*
 191 * pin fix-up
 192 */
 193enum {
 194        CXT_PINCFG_LENOVO_X200,
 195        CXT_PINCFG_LENOVO_TP410,
 196        CXT_PINCFG_LEMOTE_A1004,
 197        CXT_PINCFG_LEMOTE_A1205,
 198        CXT_PINCFG_COMPAQ_CQ60,
 199        CXT_FIXUP_STEREO_DMIC,
 200        CXT_FIXUP_INC_MIC_BOOST,
 201        CXT_FIXUP_HEADPHONE_MIC_PIN,
 202        CXT_FIXUP_HEADPHONE_MIC,
 203        CXT_FIXUP_GPIO1,
 204        CXT_FIXUP_ASPIRE_DMIC,
 205        CXT_FIXUP_THINKPAD_ACPI,
 206        CXT_FIXUP_OLPC_XO,
 207        CXT_FIXUP_CAP_MIX_AMP,
 208        CXT_FIXUP_TOSHIBA_P105,
 209        CXT_FIXUP_HP_530,
 210        CXT_FIXUP_CAP_MIX_AMP_5047,
 211        CXT_FIXUP_MUTE_LED_EAPD,
 212        CXT_FIXUP_HP_DOCK,
 213        CXT_FIXUP_HP_SPECTRE,
 214        CXT_FIXUP_HP_GATE_MIC,
 215        CXT_FIXUP_MUTE_LED_GPIO,
 216        CXT_FIXUP_HEADSET_MIC,
 217        CXT_FIXUP_HP_MIC_NO_PRESENCE,
 218};
 219
 220/* for hda_fixup_thinkpad_acpi() */
 221#include "thinkpad_helper.c"
 222
 223static void cxt_fixup_stereo_dmic(struct hda_codec *codec,
 224                                  const struct hda_fixup *fix, int action)
 225{
 226        struct conexant_spec *spec = codec->spec;
 227        spec->gen.inv_dmic_split = 1;
 228}
 229
 230static void cxt5066_increase_mic_boost(struct hda_codec *codec,
 231                                   const struct hda_fixup *fix, int action)
 232{
 233        if (action != HDA_FIXUP_ACT_PRE_PROBE)
 234                return;
 235
 236        snd_hda_override_amp_caps(codec, 0x17, HDA_OUTPUT,
 237                                  (0x3 << AC_AMPCAP_OFFSET_SHIFT) |
 238                                  (0x4 << AC_AMPCAP_NUM_STEPS_SHIFT) |
 239                                  (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
 240                                  (0 << AC_AMPCAP_MUTE_SHIFT));
 241}
 242
 243static void cxt_update_headset_mode(struct hda_codec *codec)
 244{
 245        /* The verbs used in this function were tested on a Conexant CX20751/2 codec. */
 246        int i;
 247        bool mic_mode = false;
 248        struct conexant_spec *spec = codec->spec;
 249        struct auto_pin_cfg *cfg = &spec->gen.autocfg;
 250
 251        hda_nid_t mux_pin = spec->gen.imux_pins[spec->gen.cur_mux[0]];
 252
 253        for (i = 0; i < cfg->num_inputs; i++)
 254                if (cfg->inputs[i].pin == mux_pin) {
 255                        mic_mode = !!cfg->inputs[i].is_headphone_mic;
 256                        break;
 257                }
 258
 259        if (mic_mode) {
 260                snd_hda_codec_write_cache(codec, 0x1c, 0, 0x410, 0x7c); /* enable merged mode for analog int-mic */
 261                spec->gen.hp_jack_present = false;
 262        } else {
 263                snd_hda_codec_write_cache(codec, 0x1c, 0, 0x410, 0x54); /* disable merged mode for analog int-mic */
 264                spec->gen.hp_jack_present = snd_hda_jack_detect(codec, spec->gen.autocfg.hp_pins[0]);
 265        }
 266
 267        snd_hda_gen_update_outputs(codec);
 268}
 269
 270static void cxt_update_headset_mode_hook(struct hda_codec *codec,
 271                                         struct snd_kcontrol *kcontrol,
 272                                         struct snd_ctl_elem_value *ucontrol)
 273{
 274        cxt_update_headset_mode(codec);
 275}
 276
 277static void cxt_fixup_headphone_mic(struct hda_codec *codec,
 278                                    const struct hda_fixup *fix, int action)
 279{
 280        struct conexant_spec *spec = codec->spec;
 281
 282        switch (action) {
 283        case HDA_FIXUP_ACT_PRE_PROBE:
 284                spec->parse_flags |= HDA_PINCFG_HEADPHONE_MIC;
 285                snd_hdac_regmap_add_vendor_verb(&codec->core, 0x410);
 286                break;
 287        case HDA_FIXUP_ACT_PROBE:
 288                WARN_ON(spec->gen.cap_sync_hook);
 289                spec->gen.cap_sync_hook = cxt_update_headset_mode_hook;
 290                spec->gen.automute_hook = cxt_update_headset_mode;
 291                break;
 292        case HDA_FIXUP_ACT_INIT:
 293                cxt_update_headset_mode(codec);
 294                break;
 295        }
 296}
 297
 298static void cxt_fixup_headset_mic(struct hda_codec *codec,
 299                                    const struct hda_fixup *fix, int action)
 300{
 301        struct conexant_spec *spec = codec->spec;
 302
 303        switch (action) {
 304        case HDA_FIXUP_ACT_PRE_PROBE:
 305                spec->parse_flags |= HDA_PINCFG_HEADSET_MIC;
 306                break;
 307        }
 308}
 309
 310/* OPLC XO 1.5 fixup */
 311
 312/* OLPC XO-1.5 supports DC input mode (e.g. for use with analog sensors)
 313 * through the microphone jack.
 314 * When the user enables this through a mixer switch, both internal and
 315 * external microphones are disabled. Gain is fixed at 0dB. In this mode,
 316 * we also allow the bias to be configured through a separate mixer
 317 * control. */
 318
 319#define update_mic_pin(codec, nid, val)                                 \
 320        snd_hda_codec_write_cache(codec, nid, 0,                        \
 321                                   AC_VERB_SET_PIN_WIDGET_CONTROL, val)
 322
 323static const struct hda_input_mux olpc_xo_dc_bias = {
 324        .num_items = 3,
 325        .items = {
 326                { "Off", PIN_IN },
 327                { "50%", PIN_VREF50 },
 328                { "80%", PIN_VREF80 },
 329        },
 330};
 331
 332static void olpc_xo_update_mic_boost(struct hda_codec *codec)
 333{
 334        struct conexant_spec *spec = codec->spec;
 335        int ch, val;
 336
 337        for (ch = 0; ch < 2; ch++) {
 338                val = AC_AMP_SET_OUTPUT |
 339                        (ch ? AC_AMP_SET_RIGHT : AC_AMP_SET_LEFT);
 340                if (!spec->dc_enable)
 341                        val |= snd_hda_codec_amp_read(codec, 0x17, ch, HDA_OUTPUT, 0);
 342                snd_hda_codec_write(codec, 0x17, 0,
 343                                    AC_VERB_SET_AMP_GAIN_MUTE, val);
 344        }
 345}
 346
 347static void olpc_xo_update_mic_pins(struct hda_codec *codec)
 348{
 349        struct conexant_spec *spec = codec->spec;
 350        int cur_input, val;
 351        struct nid_path *path;
 352
 353        cur_input = spec->gen.input_paths[0][spec->gen.cur_mux[0]];
 354
 355        /* Set up mic pins for port-B, C and F dynamically as the recording
 356         * LED is turned on/off by these pin controls
 357         */
 358        if (!spec->dc_enable) {
 359                /* disable DC bias path and pin for port F */
 360                update_mic_pin(codec, 0x1e, 0);
 361                snd_hda_activate_path(codec, spec->dc_mode_path, false, false);
 362
 363                /* update port B (ext mic) and C (int mic) */
 364                /* OLPC defers mic widget control until when capture is
 365                 * started because the microphone LED comes on as soon as
 366                 * these settings are put in place. if we did this before
 367                 * recording, it would give the false indication that
 368                 * recording is happening when it is not.
 369                 */
 370                update_mic_pin(codec, 0x1a, spec->recording ?
 371                               snd_hda_codec_get_pin_target(codec, 0x1a) : 0);
 372                update_mic_pin(codec, 0x1b, spec->recording ?
 373                               snd_hda_codec_get_pin_target(codec, 0x1b) : 0);
 374                /* enable normal mic path */
 375                path = snd_hda_get_path_from_idx(codec, cur_input);
 376                if (path)
 377                        snd_hda_activate_path(codec, path, true, false);
 378        } else {
 379                /* disable normal mic path */
 380                path = snd_hda_get_path_from_idx(codec, cur_input);
 381                if (path)
 382                        snd_hda_activate_path(codec, path, false, false);
 383
 384                /* Even though port F is the DC input, the bias is controlled
 385                 * on port B.  We also leave that port as an active input (but
 386                 * unselected) in DC mode just in case that is necessary to
 387                 * make the bias setting take effect.
 388                 */
 389                if (spec->recording)
 390                        val = olpc_xo_dc_bias.items[spec->dc_input_bias].index;
 391                else
 392                        val = 0;
 393                update_mic_pin(codec, 0x1a, val);
 394                update_mic_pin(codec, 0x1b, 0);
 395                /* enable DC bias path and pin */
 396                update_mic_pin(codec, 0x1e, spec->recording ? PIN_IN : 0);
 397                snd_hda_activate_path(codec, spec->dc_mode_path, true, false);
 398        }
 399}
 400
 401/* mic_autoswitch hook */
 402static void olpc_xo_automic(struct hda_codec *codec,
 403                            struct hda_jack_callback *jack)
 404{
 405        struct conexant_spec *spec = codec->spec;
 406
 407        /* in DC mode, we don't handle automic */
 408        if (!spec->dc_enable)
 409                snd_hda_gen_mic_autoswitch(codec, jack);
 410        olpc_xo_update_mic_pins(codec);
 411        if (spec->dc_enable)
 412                olpc_xo_update_mic_boost(codec);
 413}
 414
 415/* pcm_capture hook */
 416static void olpc_xo_capture_hook(struct hda_pcm_stream *hinfo,
 417                                 struct hda_codec *codec,
 418                                 struct snd_pcm_substream *substream,
 419                                 int action)
 420{
 421        struct conexant_spec *spec = codec->spec;
 422
 423        /* toggle spec->recording flag and update mic pins accordingly
 424         * for turning on/off LED
 425         */
 426        switch (action) {
 427        case HDA_GEN_PCM_ACT_PREPARE:
 428                spec->recording = 1;
 429                olpc_xo_update_mic_pins(codec);
 430                break;
 431        case HDA_GEN_PCM_ACT_CLEANUP:
 432                spec->recording = 0;
 433                olpc_xo_update_mic_pins(codec);
 434                break;
 435        }
 436}
 437
 438static int olpc_xo_dc_mode_get(struct snd_kcontrol *kcontrol,
 439                               struct snd_ctl_elem_value *ucontrol)
 440{
 441        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 442        struct conexant_spec *spec = codec->spec;
 443        ucontrol->value.integer.value[0] = spec->dc_enable;
 444        return 0;
 445}
 446
 447static int olpc_xo_dc_mode_put(struct snd_kcontrol *kcontrol,
 448                               struct snd_ctl_elem_value *ucontrol)
 449{
 450        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 451        struct conexant_spec *spec = codec->spec;
 452        int dc_enable = !!ucontrol->value.integer.value[0];
 453
 454        if (dc_enable == spec->dc_enable)
 455                return 0;
 456
 457        spec->dc_enable = dc_enable;
 458        olpc_xo_update_mic_pins(codec);
 459        olpc_xo_update_mic_boost(codec);
 460        return 1;
 461}
 462
 463static int olpc_xo_dc_bias_enum_get(struct snd_kcontrol *kcontrol,
 464                                    struct snd_ctl_elem_value *ucontrol)
 465{
 466        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 467        struct conexant_spec *spec = codec->spec;
 468        ucontrol->value.enumerated.item[0] = spec->dc_input_bias;
 469        return 0;
 470}
 471
 472static int olpc_xo_dc_bias_enum_info(struct snd_kcontrol *kcontrol,
 473                                     struct snd_ctl_elem_info *uinfo)
 474{
 475        return snd_hda_input_mux_info(&olpc_xo_dc_bias, uinfo);
 476}
 477
 478static int olpc_xo_dc_bias_enum_put(struct snd_kcontrol *kcontrol,
 479                                    struct snd_ctl_elem_value *ucontrol)
 480{
 481        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 482        struct conexant_spec *spec = codec->spec;
 483        const struct hda_input_mux *imux = &olpc_xo_dc_bias;
 484        unsigned int idx;
 485
 486        idx = ucontrol->value.enumerated.item[0];
 487        if (idx >= imux->num_items)
 488                idx = imux->num_items - 1;
 489        if (spec->dc_input_bias == idx)
 490                return 0;
 491
 492        spec->dc_input_bias = idx;
 493        if (spec->dc_enable)
 494                olpc_xo_update_mic_pins(codec);
 495        return 1;
 496}
 497
 498static const struct snd_kcontrol_new olpc_xo_mixers[] = {
 499        {
 500                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 501                .name = "DC Mode Enable Switch",
 502                .info = snd_ctl_boolean_mono_info,
 503                .get = olpc_xo_dc_mode_get,
 504                .put = olpc_xo_dc_mode_put,
 505        },
 506        {
 507                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 508                .name = "DC Input Bias Enum",
 509                .info = olpc_xo_dc_bias_enum_info,
 510                .get = olpc_xo_dc_bias_enum_get,
 511                .put = olpc_xo_dc_bias_enum_put,
 512        },
 513        {}
 514};
 515
 516/* overriding mic boost put callback; update mic boost volume only when
 517 * DC mode is disabled
 518 */
 519static int olpc_xo_mic_boost_put(struct snd_kcontrol *kcontrol,
 520                                 struct snd_ctl_elem_value *ucontrol)
 521{
 522        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 523        struct conexant_spec *spec = codec->spec;
 524        int ret = snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
 525        if (ret > 0 && spec->dc_enable)
 526                olpc_xo_update_mic_boost(codec);
 527        return ret;
 528}
 529
 530static void cxt_fixup_olpc_xo(struct hda_codec *codec,
 531                                    const struct hda_fixup *fix, int action)
 532{
 533        struct conexant_spec *spec = codec->spec;
 534        struct snd_kcontrol_new *kctl;
 535        int i;
 536
 537        if (action != HDA_FIXUP_ACT_PROBE)
 538                return;
 539
 540        spec->gen.mic_autoswitch_hook = olpc_xo_automic;
 541        spec->gen.pcm_capture_hook = olpc_xo_capture_hook;
 542        spec->dc_mode_path = snd_hda_add_new_path(codec, 0x1e, 0x14, 0);
 543
 544        snd_hda_add_new_ctls(codec, olpc_xo_mixers);
 545
 546        /* OLPC's microphone port is DC coupled for use with external sensors,
 547         * therefore we use a 50% mic bias in order to center the input signal
 548         * with the DC input range of the codec.
 549         */
 550        snd_hda_codec_set_pin_target(codec, 0x1a, PIN_VREF50);
 551
 552        /* override mic boost control */
 553        snd_array_for_each(&spec->gen.kctls, i, kctl) {
 554                if (!strcmp(kctl->name, "Mic Boost Volume")) {
 555                        kctl->put = olpc_xo_mic_boost_put;
 556                        break;
 557                }
 558        }
 559}
 560
 561static void cxt_fixup_mute_led_eapd(struct hda_codec *codec,
 562                                    const struct hda_fixup *fix, int action)
 563{
 564        struct conexant_spec *spec = codec->spec;
 565
 566        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 567                spec->mute_led_eapd = 0x1b;
 568                spec->dynamic_eapd = 1;
 569                spec->gen.vmaster_mute.hook = cx_auto_vmaster_hook_mute_led;
 570        }
 571}
 572
 573/*
 574 * Fix max input level on mixer widget to 0dB
 575 * (originally it has 0x2b steps with 0dB offset 0x14)
 576 */
 577static void cxt_fixup_cap_mix_amp(struct hda_codec *codec,
 578                                  const struct hda_fixup *fix, int action)
 579{
 580        snd_hda_override_amp_caps(codec, 0x17, HDA_INPUT,
 581                                  (0x14 << AC_AMPCAP_OFFSET_SHIFT) |
 582                                  (0x14 << AC_AMPCAP_NUM_STEPS_SHIFT) |
 583                                  (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
 584                                  (1 << AC_AMPCAP_MUTE_SHIFT));
 585}
 586
 587/*
 588 * Fix max input level on mixer widget to 0dB
 589 * (originally it has 0x1e steps with 0 dB offset 0x17)
 590 */
 591static void cxt_fixup_cap_mix_amp_5047(struct hda_codec *codec,
 592                                  const struct hda_fixup *fix, int action)
 593{
 594        snd_hda_override_amp_caps(codec, 0x10, HDA_INPUT,
 595                                  (0x17 << AC_AMPCAP_OFFSET_SHIFT) |
 596                                  (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) |
 597                                  (0x05 << AC_AMPCAP_STEP_SIZE_SHIFT) |
 598                                  (1 << AC_AMPCAP_MUTE_SHIFT));
 599}
 600
 601static void cxt_fixup_hp_gate_mic_jack(struct hda_codec *codec,
 602                                       const struct hda_fixup *fix,
 603                                       int action)
 604{
 605        /* the mic pin (0x19) doesn't give an unsolicited event;
 606         * probe the mic pin together with the headphone pin (0x16)
 607         */
 608        if (action == HDA_FIXUP_ACT_PROBE)
 609                snd_hda_jack_set_gating_jack(codec, 0x19, 0x16);
 610}
 611
 612/* update LED status via GPIO */
 613static void cxt_update_gpio_led(struct hda_codec *codec, unsigned int mask,
 614                                bool led_on)
 615{
 616        struct conexant_spec *spec = codec->spec;
 617        unsigned int oldval = spec->gpio_led;
 618
 619        if (spec->mute_led_polarity)
 620                led_on = !led_on;
 621
 622        if (led_on)
 623                spec->gpio_led |= mask;
 624        else
 625                spec->gpio_led &= ~mask;
 626        codec_dbg(codec, "mask:%d enabled:%d gpio_led:%d\n",
 627                        mask, led_on, spec->gpio_led);
 628        if (spec->gpio_led != oldval)
 629                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 630                                    spec->gpio_led);
 631}
 632
 633/* turn on/off mute LED via GPIO per vmaster hook */
 634static void cxt_fixup_gpio_mute_hook(void *private_data, int enabled)
 635{
 636        struct hda_codec *codec = private_data;
 637        struct conexant_spec *spec = codec->spec;
 638        /* muted -> LED on */
 639        cxt_update_gpio_led(codec, spec->gpio_mute_led_mask, !enabled);
 640}
 641
 642/* turn on/off mic-mute LED via GPIO per capture hook */
 643static void cxt_gpio_micmute_update(struct hda_codec *codec)
 644{
 645        struct conexant_spec *spec = codec->spec;
 646
 647        cxt_update_gpio_led(codec, spec->gpio_mic_led_mask,
 648                            spec->gen.micmute_led.led_value);
 649}
 650
 651
 652static void cxt_fixup_mute_led_gpio(struct hda_codec *codec,
 653                                const struct hda_fixup *fix, int action)
 654{
 655        struct conexant_spec *spec = codec->spec;
 656        static const struct hda_verb gpio_init[] = {
 657                { 0x01, AC_VERB_SET_GPIO_MASK, 0x03 },
 658                { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03 },
 659                {}
 660        };
 661
 662        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
 663                spec->gen.vmaster_mute.hook = cxt_fixup_gpio_mute_hook;
 664                spec->gpio_led = 0;
 665                spec->mute_led_polarity = 0;
 666                spec->gpio_mute_led_mask = 0x01;
 667                spec->gpio_mic_led_mask = 0x02;
 668                snd_hda_gen_add_micmute_led(codec, cxt_gpio_micmute_update);
 669        }
 670        snd_hda_add_verbs(codec, gpio_init);
 671        if (spec->gpio_led)
 672                snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
 673                                    spec->gpio_led);
 674}
 675
 676
 677/* ThinkPad X200 & co with cxt5051 */
 678static const struct hda_pintbl cxt_pincfg_lenovo_x200[] = {
 679        { 0x16, 0x042140ff }, /* HP (seq# overridden) */
 680        { 0x17, 0x21a11000 }, /* dock-mic */
 681        { 0x19, 0x2121103f }, /* dock-HP */
 682        { 0x1c, 0x21440100 }, /* dock SPDIF out */
 683        {}
 684};
 685
 686/* ThinkPad 410/420/510/520, X201 & co with cxt5066 */
 687static const struct hda_pintbl cxt_pincfg_lenovo_tp410[] = {
 688        { 0x19, 0x042110ff }, /* HP (seq# overridden) */
 689        { 0x1a, 0x21a190f0 }, /* dock-mic */
 690        { 0x1c, 0x212140ff }, /* dock-HP */
 691        {}
 692};
 693
 694/* Lemote A1004/A1205 with cxt5066 */
 695static const struct hda_pintbl cxt_pincfg_lemote[] = {
 696        { 0x1a, 0x90a10020 }, /* Internal mic */
 697        { 0x1b, 0x03a11020 }, /* External mic */
 698        { 0x1d, 0x400101f0 }, /* Not used */
 699        { 0x1e, 0x40a701f0 }, /* Not used */
 700        { 0x20, 0x404501f0 }, /* Not used */
 701        { 0x22, 0x404401f0 }, /* Not used */
 702        { 0x23, 0x40a701f0 }, /* Not used */
 703        {}
 704};
 705
 706static const struct hda_fixup cxt_fixups[] = {
 707        [CXT_PINCFG_LENOVO_X200] = {
 708                .type = HDA_FIXUP_PINS,
 709                .v.pins = cxt_pincfg_lenovo_x200,
 710        },
 711        [CXT_PINCFG_LENOVO_TP410] = {
 712                .type = HDA_FIXUP_PINS,
 713                .v.pins = cxt_pincfg_lenovo_tp410,
 714                .chained = true,
 715                .chain_id = CXT_FIXUP_THINKPAD_ACPI,
 716        },
 717        [CXT_PINCFG_LEMOTE_A1004] = {
 718                .type = HDA_FIXUP_PINS,
 719                .chained = true,
 720                .chain_id = CXT_FIXUP_INC_MIC_BOOST,
 721                .v.pins = cxt_pincfg_lemote,
 722        },
 723        [CXT_PINCFG_LEMOTE_A1205] = {
 724                .type = HDA_FIXUP_PINS,
 725                .v.pins = cxt_pincfg_lemote,
 726        },
 727        [CXT_PINCFG_COMPAQ_CQ60] = {
 728                .type = HDA_FIXUP_PINS,
 729                .v.pins = (const struct hda_pintbl[]) {
 730                        /* 0x17 was falsely set up as a mic, it should 0x1d */
 731                        { 0x17, 0x400001f0 },
 732                        { 0x1d, 0x97a70120 },
 733                        { }
 734                }
 735        },
 736        [CXT_FIXUP_STEREO_DMIC] = {
 737                .type = HDA_FIXUP_FUNC,
 738                .v.func = cxt_fixup_stereo_dmic,
 739        },
 740        [CXT_FIXUP_INC_MIC_BOOST] = {
 741                .type = HDA_FIXUP_FUNC,
 742                .v.func = cxt5066_increase_mic_boost,
 743        },
 744        [CXT_FIXUP_HEADPHONE_MIC_PIN] = {
 745                .type = HDA_FIXUP_PINS,
 746                .chained = true,
 747                .chain_id = CXT_FIXUP_HEADPHONE_MIC,
 748                .v.pins = (const struct hda_pintbl[]) {
 749                        { 0x18, 0x03a1913d }, /* use as headphone mic, without its own jack detect */
 750                        { }
 751                }
 752        },
 753        [CXT_FIXUP_HEADPHONE_MIC] = {
 754                .type = HDA_FIXUP_FUNC,
 755                .v.func = cxt_fixup_headphone_mic,
 756        },
 757        [CXT_FIXUP_GPIO1] = {
 758                .type = HDA_FIXUP_VERBS,
 759                .v.verbs = (const struct hda_verb[]) {
 760                        { 0x01, AC_VERB_SET_GPIO_MASK, 0x01 },
 761                        { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01 },
 762                        { 0x01, AC_VERB_SET_GPIO_DATA, 0x01 },
 763                        { }
 764                },
 765        },
 766        [CXT_FIXUP_ASPIRE_DMIC] = {
 767                .type = HDA_FIXUP_FUNC,
 768                .v.func = cxt_fixup_stereo_dmic,
 769                .chained = true,
 770                .chain_id = CXT_FIXUP_GPIO1,
 771        },
 772        [CXT_FIXUP_THINKPAD_ACPI] = {
 773                .type = HDA_FIXUP_FUNC,
 774                .v.func = hda_fixup_thinkpad_acpi,
 775        },
 776        [CXT_FIXUP_OLPC_XO] = {
 777                .type = HDA_FIXUP_FUNC,
 778                .v.func = cxt_fixup_olpc_xo,
 779        },
 780        [CXT_FIXUP_CAP_MIX_AMP] = {
 781                .type = HDA_FIXUP_FUNC,
 782                .v.func = cxt_fixup_cap_mix_amp,
 783        },
 784        [CXT_FIXUP_TOSHIBA_P105] = {
 785                .type = HDA_FIXUP_PINS,
 786                .v.pins = (const struct hda_pintbl[]) {
 787                        { 0x10, 0x961701f0 }, /* speaker/hp */
 788                        { 0x12, 0x02a1901e }, /* ext mic */
 789                        { 0x14, 0x95a70110 }, /* int mic */
 790                        {}
 791                },
 792        },
 793        [CXT_FIXUP_HP_530] = {
 794                .type = HDA_FIXUP_PINS,
 795                .v.pins = (const struct hda_pintbl[]) {
 796                        { 0x12, 0x90a60160 }, /* int mic */
 797                        {}
 798                },
 799                .chained = true,
 800                .chain_id = CXT_FIXUP_CAP_MIX_AMP,
 801        },
 802        [CXT_FIXUP_CAP_MIX_AMP_5047] = {
 803                .type = HDA_FIXUP_FUNC,
 804                .v.func = cxt_fixup_cap_mix_amp_5047,
 805        },
 806        [CXT_FIXUP_MUTE_LED_EAPD] = {
 807                .type = HDA_FIXUP_FUNC,
 808                .v.func = cxt_fixup_mute_led_eapd,
 809        },
 810        [CXT_FIXUP_HP_DOCK] = {
 811                .type = HDA_FIXUP_PINS,
 812                .v.pins = (const struct hda_pintbl[]) {
 813                        { 0x16, 0x21011020 }, /* line-out */
 814                        { 0x18, 0x2181103f }, /* line-in */
 815                        { }
 816                },
 817                .chained = true,
 818                .chain_id = CXT_FIXUP_MUTE_LED_GPIO,
 819        },
 820        [CXT_FIXUP_HP_SPECTRE] = {
 821                .type = HDA_FIXUP_PINS,
 822                .v.pins = (const struct hda_pintbl[]) {
 823                        /* enable NID 0x1d for the speaker on top */
 824                        { 0x1d, 0x91170111 },
 825                        { }
 826                }
 827        },
 828        [CXT_FIXUP_HP_GATE_MIC] = {
 829                .type = HDA_FIXUP_FUNC,
 830                .v.func = cxt_fixup_hp_gate_mic_jack,
 831        },
 832        [CXT_FIXUP_MUTE_LED_GPIO] = {
 833                .type = HDA_FIXUP_FUNC,
 834                .v.func = cxt_fixup_mute_led_gpio,
 835        },
 836        [CXT_FIXUP_HEADSET_MIC] = {
 837                .type = HDA_FIXUP_FUNC,
 838                .v.func = cxt_fixup_headset_mic,
 839        },
 840        [CXT_FIXUP_HP_MIC_NO_PRESENCE] = {
 841                .type = HDA_FIXUP_PINS,
 842                .v.pins = (const struct hda_pintbl[]) {
 843                        { 0x1a, 0x02a1113c },
 844                        { }
 845                },
 846                .chained = true,
 847                .chain_id = CXT_FIXUP_HEADSET_MIC,
 848        },
 849};
 850
 851static const struct snd_pci_quirk cxt5045_fixups[] = {
 852        SND_PCI_QUIRK(0x103c, 0x30d5, "HP 530", CXT_FIXUP_HP_530),
 853        SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba P105", CXT_FIXUP_TOSHIBA_P105),
 854        /* HP, Packard Bell, Fujitsu-Siemens & Lenovo laptops have
 855         * really bad sound over 0dB on NID 0x17.
 856         */
 857        SND_PCI_QUIRK_VENDOR(0x103c, "HP", CXT_FIXUP_CAP_MIX_AMP),
 858        SND_PCI_QUIRK_VENDOR(0x1631, "Packard Bell", CXT_FIXUP_CAP_MIX_AMP),
 859        SND_PCI_QUIRK_VENDOR(0x1734, "Fujitsu", CXT_FIXUP_CAP_MIX_AMP),
 860        SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", CXT_FIXUP_CAP_MIX_AMP),
 861        {}
 862};
 863
 864static const struct hda_model_fixup cxt5045_fixup_models[] = {
 865        { .id = CXT_FIXUP_CAP_MIX_AMP, .name = "cap-mix-amp" },
 866        { .id = CXT_FIXUP_TOSHIBA_P105, .name = "toshiba-p105" },
 867        { .id = CXT_FIXUP_HP_530, .name = "hp-530" },
 868        {}
 869};
 870
 871static const struct snd_pci_quirk cxt5047_fixups[] = {
 872        /* HP laptops have really bad sound over 0 dB on NID 0x10.
 873         */
 874        SND_PCI_QUIRK_VENDOR(0x103c, "HP", CXT_FIXUP_CAP_MIX_AMP_5047),
 875        {}
 876};
 877
 878static const struct hda_model_fixup cxt5047_fixup_models[] = {
 879        { .id = CXT_FIXUP_CAP_MIX_AMP_5047, .name = "cap-mix-amp" },
 880        {}
 881};
 882
 883static const struct snd_pci_quirk cxt5051_fixups[] = {
 884        SND_PCI_QUIRK(0x103c, 0x360b, "Compaq CQ60", CXT_PINCFG_COMPAQ_CQ60),
 885        SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo X200", CXT_PINCFG_LENOVO_X200),
 886        {}
 887};
 888
 889static const struct hda_model_fixup cxt5051_fixup_models[] = {
 890        { .id = CXT_PINCFG_LENOVO_X200, .name = "lenovo-x200" },
 891        {}
 892};
 893
 894static const struct snd_pci_quirk cxt5066_fixups[] = {
 895        SND_PCI_QUIRK(0x1025, 0x0543, "Acer Aspire One 522", CXT_FIXUP_STEREO_DMIC),
 896        SND_PCI_QUIRK(0x1025, 0x054c, "Acer Aspire 3830TG", CXT_FIXUP_ASPIRE_DMIC),
 897        SND_PCI_QUIRK(0x1025, 0x054f, "Acer Aspire 4830T", CXT_FIXUP_ASPIRE_DMIC),
 898        SND_PCI_QUIRK(0x103c, 0x8079, "HP EliteBook 840 G3", CXT_FIXUP_HP_DOCK),
 899        SND_PCI_QUIRK(0x103c, 0x807C, "HP EliteBook 820 G3", CXT_FIXUP_HP_DOCK),
 900        SND_PCI_QUIRK(0x103c, 0x80FD, "HP ProBook 640 G2", CXT_FIXUP_HP_DOCK),
 901        SND_PCI_QUIRK(0x103c, 0x828c, "HP EliteBook 840 G4", CXT_FIXUP_HP_DOCK),
 902        SND_PCI_QUIRK(0x103c, 0x83b2, "HP EliteBook 840 G5", CXT_FIXUP_HP_DOCK),
 903        SND_PCI_QUIRK(0x103c, 0x83b3, "HP EliteBook 830 G5", CXT_FIXUP_HP_DOCK),
 904        SND_PCI_QUIRK(0x103c, 0x83d3, "HP ProBook 640 G4", CXT_FIXUP_HP_DOCK),
 905        SND_PCI_QUIRK(0x103c, 0x8174, "HP Spectre x360", CXT_FIXUP_HP_SPECTRE),
 906        SND_PCI_QUIRK(0x103c, 0x8115, "HP Z1 Gen3", CXT_FIXUP_HP_GATE_MIC),
 907        SND_PCI_QUIRK(0x103c, 0x814f, "HP ZBook 15u G3", CXT_FIXUP_MUTE_LED_GPIO),
 908        SND_PCI_QUIRK(0x103c, 0x822e, "HP ProBook 440 G4", CXT_FIXUP_MUTE_LED_GPIO),
 909        SND_PCI_QUIRK(0x103c, 0x836e, "HP ProBook 455 G5", CXT_FIXUP_MUTE_LED_GPIO),
 910        SND_PCI_QUIRK(0x103c, 0x837f, "HP ProBook 470 G5", CXT_FIXUP_MUTE_LED_GPIO),
 911        SND_PCI_QUIRK(0x103c, 0x8299, "HP 800 G3 SFF", CXT_FIXUP_HP_MIC_NO_PRESENCE),
 912        SND_PCI_QUIRK(0x103c, 0x829a, "HP 800 G3 DM", CXT_FIXUP_HP_MIC_NO_PRESENCE),
 913        SND_PCI_QUIRK(0x103c, 0x8402, "HP ProBook 645 G4", CXT_FIXUP_MUTE_LED_GPIO),
 914        SND_PCI_QUIRK(0x103c, 0x8455, "HP Z2 G4", CXT_FIXUP_HP_MIC_NO_PRESENCE),
 915        SND_PCI_QUIRK(0x103c, 0x8456, "HP Z2 G4 SFF", CXT_FIXUP_HP_MIC_NO_PRESENCE),
 916        SND_PCI_QUIRK(0x103c, 0x8457, "HP Z2 G4 mini", CXT_FIXUP_HP_MIC_NO_PRESENCE),
 917        SND_PCI_QUIRK(0x103c, 0x8458, "HP Z2 G4 mini premium", CXT_FIXUP_HP_MIC_NO_PRESENCE),
 918        SND_PCI_QUIRK(0x1043, 0x138d, "Asus", CXT_FIXUP_HEADPHONE_MIC_PIN),
 919        SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT_FIXUP_OLPC_XO),
 920        SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400", CXT_PINCFG_LENOVO_TP410),
 921        SND_PCI_QUIRK(0x17aa, 0x215e, "Lenovo T410", CXT_PINCFG_LENOVO_TP410),
 922        SND_PCI_QUIRK(0x17aa, 0x215f, "Lenovo T510", CXT_PINCFG_LENOVO_TP410),
 923        SND_PCI_QUIRK(0x17aa, 0x21ce, "Lenovo T420", CXT_PINCFG_LENOVO_TP410),
 924        SND_PCI_QUIRK(0x17aa, 0x21cf, "Lenovo T520", CXT_PINCFG_LENOVO_TP410),
 925        SND_PCI_QUIRK(0x17aa, 0x21d2, "Lenovo T420s", CXT_PINCFG_LENOVO_TP410),
 926        SND_PCI_QUIRK(0x17aa, 0x21da, "Lenovo X220", CXT_PINCFG_LENOVO_TP410),
 927        SND_PCI_QUIRK(0x17aa, 0x21db, "Lenovo X220-tablet", CXT_PINCFG_LENOVO_TP410),
 928        SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo IdeaPad Z560", CXT_FIXUP_MUTE_LED_EAPD),
 929        SND_PCI_QUIRK(0x17aa, 0x3905, "Lenovo G50-30", CXT_FIXUP_STEREO_DMIC),
 930        SND_PCI_QUIRK(0x17aa, 0x390b, "Lenovo G50-80", CXT_FIXUP_STEREO_DMIC),
 931        SND_PCI_QUIRK(0x17aa, 0x3975, "Lenovo U300s", CXT_FIXUP_STEREO_DMIC),
 932        SND_PCI_QUIRK(0x17aa, 0x3977, "Lenovo IdeaPad U310", CXT_FIXUP_STEREO_DMIC),
 933        SND_PCI_QUIRK(0x17aa, 0x3978, "Lenovo G50-70", CXT_FIXUP_STEREO_DMIC),
 934        SND_PCI_QUIRK(0x17aa, 0x397b, "Lenovo S205", CXT_FIXUP_STEREO_DMIC),
 935        SND_PCI_QUIRK_VENDOR(0x17aa, "Thinkpad", CXT_FIXUP_THINKPAD_ACPI),
 936        SND_PCI_QUIRK(0x1c06, 0x2011, "Lemote A1004", CXT_PINCFG_LEMOTE_A1004),
 937        SND_PCI_QUIRK(0x1c06, 0x2012, "Lemote A1205", CXT_PINCFG_LEMOTE_A1205),
 938        {}
 939};
 940
 941static const struct hda_model_fixup cxt5066_fixup_models[] = {
 942        { .id = CXT_FIXUP_STEREO_DMIC, .name = "stereo-dmic" },
 943        { .id = CXT_FIXUP_GPIO1, .name = "gpio1" },
 944        { .id = CXT_FIXUP_HEADPHONE_MIC_PIN, .name = "headphone-mic-pin" },
 945        { .id = CXT_PINCFG_LENOVO_TP410, .name = "tp410" },
 946        { .id = CXT_FIXUP_THINKPAD_ACPI, .name = "thinkpad" },
 947        { .id = CXT_PINCFG_LEMOTE_A1004, .name = "lemote-a1004" },
 948        { .id = CXT_PINCFG_LEMOTE_A1205, .name = "lemote-a1205" },
 949        { .id = CXT_FIXUP_OLPC_XO, .name = "olpc-xo" },
 950        { .id = CXT_FIXUP_MUTE_LED_EAPD, .name = "mute-led-eapd" },
 951        { .id = CXT_FIXUP_HP_DOCK, .name = "hp-dock" },
 952        { .id = CXT_FIXUP_MUTE_LED_GPIO, .name = "mute-led-gpio" },
 953        { .id = CXT_FIXUP_HP_MIC_NO_PRESENCE, .name = "hp-mic-fix" },
 954        {}
 955};
 956
 957/* add "fake" mute amp-caps to DACs on cx5051 so that mixer mute switches
 958 * can be created (bko#42825)
 959 */
 960static void add_cx5051_fake_mutes(struct hda_codec *codec)
 961{
 962        struct conexant_spec *spec = codec->spec;
 963        static const hda_nid_t out_nids[] = {
 964                0x10, 0x11, 0
 965        };
 966        const hda_nid_t *p;
 967
 968        for (p = out_nids; *p; p++)
 969                snd_hda_override_amp_caps(codec, *p, HDA_OUTPUT,
 970                                          AC_AMPCAP_MIN_MUTE |
 971                                          query_amp_caps(codec, *p, HDA_OUTPUT));
 972        spec->gen.dac_min_mute = true;
 973}
 974
 975static int patch_conexant_auto(struct hda_codec *codec)
 976{
 977        struct conexant_spec *spec;
 978        int err;
 979
 980        codec_info(codec, "%s: BIOS auto-probing.\n", codec->core.chip_name);
 981
 982        spec = kzalloc(sizeof(*spec), GFP_KERNEL);
 983        if (!spec)
 984                return -ENOMEM;
 985        snd_hda_gen_spec_init(&spec->gen);
 986        codec->spec = spec;
 987        codec->patch_ops = cx_auto_patch_ops;
 988
 989        cx_auto_parse_eapd(codec);
 990        spec->gen.own_eapd_ctl = 1;
 991        if (spec->dynamic_eapd)
 992                spec->gen.vmaster_mute.hook = cx_auto_vmaster_hook;
 993
 994        switch (codec->core.vendor_id) {
 995        case 0x14f15045:
 996                codec->single_adc_amp = 1;
 997                spec->gen.mixer_nid = 0x17;
 998                spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO;
 999                snd_hda_pick_fixup(codec, cxt5045_fixup_models,
1000                                   cxt5045_fixups, cxt_fixups);
1001                break;
1002        case 0x14f15047:
1003                codec->pin_amp_workaround = 1;
1004                spec->gen.mixer_nid = 0x19;
1005                spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO;
1006                snd_hda_pick_fixup(codec, cxt5047_fixup_models,
1007                                   cxt5047_fixups, cxt_fixups);
1008                break;
1009        case 0x14f15051:
1010                add_cx5051_fake_mutes(codec);
1011                codec->pin_amp_workaround = 1;
1012                snd_hda_pick_fixup(codec, cxt5051_fixup_models,
1013                                   cxt5051_fixups, cxt_fixups);
1014                break;
1015        case 0x14f150f2:
1016                codec->power_save_node = 1;
1017                /* Fall through */
1018        default:
1019                codec->pin_amp_workaround = 1;
1020                snd_hda_pick_fixup(codec, cxt5066_fixup_models,
1021                                   cxt5066_fixups, cxt_fixups);
1022                break;
1023        }
1024
1025        /* Show mute-led control only on HP laptops
1026         * This is a sort of white-list: on HP laptops, EAPD corresponds
1027         * only to the mute-LED without actualy amp function.  Meanwhile,
1028         * others may use EAPD really as an amp switch, so it might be
1029         * not good to expose it blindly.
1030         */
1031        switch (codec->core.subsystem_id >> 16) {
1032        case 0x103c:
1033                spec->gen.vmaster_mute_enum = 1;
1034                break;
1035        }
1036
1037        snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1038
1039        err = snd_hda_parse_pin_defcfg(codec, &spec->gen.autocfg, NULL,
1040                                       spec->parse_flags);
1041        if (err < 0)
1042                goto error;
1043
1044        err = snd_hda_gen_parse_auto_config(codec, &spec->gen.autocfg);
1045        if (err < 0)
1046                goto error;
1047
1048        err = cx_auto_parse_beep(codec);
1049        if (err < 0)
1050                goto error;
1051
1052        /* Some laptops with Conexant chips show stalls in S3 resume,
1053         * which falls into the single-cmd mode.
1054         * Better to make reset, then.
1055         */
1056        if (!codec->bus->core.sync_write) {
1057                codec_info(codec,
1058                           "Enable sync_write for stable communication\n");
1059                codec->bus->core.sync_write = 1;
1060                codec->bus->allow_bus_reset = 1;
1061        }
1062
1063        snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1064
1065        return 0;
1066
1067 error:
1068        cx_auto_free(codec);
1069        return err;
1070}
1071
1072/*
1073 */
1074
1075static const struct hda_device_id snd_hda_id_conexant[] = {
1076        HDA_CODEC_ENTRY(0x14f11f86, "CX8070", patch_conexant_auto),
1077        HDA_CODEC_ENTRY(0x14f12008, "CX8200", patch_conexant_auto),
1078        HDA_CODEC_ENTRY(0x14f15045, "CX20549 (Venice)", patch_conexant_auto),
1079        HDA_CODEC_ENTRY(0x14f15047, "CX20551 (Waikiki)", patch_conexant_auto),
1080        HDA_CODEC_ENTRY(0x14f15051, "CX20561 (Hermosa)", patch_conexant_auto),
1081        HDA_CODEC_ENTRY(0x14f15066, "CX20582 (Pebble)", patch_conexant_auto),
1082        HDA_CODEC_ENTRY(0x14f15067, "CX20583 (Pebble HSF)", patch_conexant_auto),
1083        HDA_CODEC_ENTRY(0x14f15068, "CX20584", patch_conexant_auto),
1084        HDA_CODEC_ENTRY(0x14f15069, "CX20585", patch_conexant_auto),
1085        HDA_CODEC_ENTRY(0x14f1506c, "CX20588", patch_conexant_auto),
1086        HDA_CODEC_ENTRY(0x14f1506e, "CX20590", patch_conexant_auto),
1087        HDA_CODEC_ENTRY(0x14f15097, "CX20631", patch_conexant_auto),
1088        HDA_CODEC_ENTRY(0x14f15098, "CX20632", patch_conexant_auto),
1089        HDA_CODEC_ENTRY(0x14f150a1, "CX20641", patch_conexant_auto),
1090        HDA_CODEC_ENTRY(0x14f150a2, "CX20642", patch_conexant_auto),
1091        HDA_CODEC_ENTRY(0x14f150ab, "CX20651", patch_conexant_auto),
1092        HDA_CODEC_ENTRY(0x14f150ac, "CX20652", patch_conexant_auto),
1093        HDA_CODEC_ENTRY(0x14f150b8, "CX20664", patch_conexant_auto),
1094        HDA_CODEC_ENTRY(0x14f150b9, "CX20665", patch_conexant_auto),
1095        HDA_CODEC_ENTRY(0x14f150f1, "CX21722", patch_conexant_auto),
1096        HDA_CODEC_ENTRY(0x14f150f2, "CX20722", patch_conexant_auto),
1097        HDA_CODEC_ENTRY(0x14f150f3, "CX21724", patch_conexant_auto),
1098        HDA_CODEC_ENTRY(0x14f150f4, "CX20724", patch_conexant_auto),
1099        HDA_CODEC_ENTRY(0x14f1510f, "CX20751/2", patch_conexant_auto),
1100        HDA_CODEC_ENTRY(0x14f15110, "CX20751/2", patch_conexant_auto),
1101        HDA_CODEC_ENTRY(0x14f15111, "CX20753/4", patch_conexant_auto),
1102        HDA_CODEC_ENTRY(0x14f15113, "CX20755", patch_conexant_auto),
1103        HDA_CODEC_ENTRY(0x14f15114, "CX20756", patch_conexant_auto),
1104        HDA_CODEC_ENTRY(0x14f15115, "CX20757", patch_conexant_auto),
1105        HDA_CODEC_ENTRY(0x14f151d7, "CX20952", patch_conexant_auto),
1106        {} /* terminator */
1107};
1108MODULE_DEVICE_TABLE(hdaudio, snd_hda_id_conexant);
1109
1110MODULE_LICENSE("GPL");
1111MODULE_DESCRIPTION("Conexant HD-audio codec");
1112
1113static struct hda_codec_driver conexant_driver = {
1114        .id = snd_hda_id_conexant,
1115};
1116
1117module_hda_codec_driver(conexant_driver);
1118