← Back to branch summary

~ubuntu-branches/ubuntu/precise/alsa-driver/precise

« back to all changes in this revision

Viewing changes to alsa-kernel/pci/hda/patch_analog.c

  • Committer: Bazaar Package Importer
  • Author(s): Luke Yelavich
  • Date: 2011-02-21 18:06:40 UTC
  • mfrom: (1.1.15 upstream)
  • Revision ID: james.westby@ubuntu.com-20110221180640-a8p2yxtvgf7xbxub
Tags: 1.0.24+dfsg-0ubuntu1
* New upstream release
* Refreshed patches:
  - distinguish_kernel_makefile_and_source_dirs.patch
  - debian_dfsg_configure.patch
* debian/control: Update Vcs-bzr field to point to new branch location

Show diffs side-by-side

added added

removed removed

Lines of Context:
alsa-kernel/pci/hda/patch_analog.c
46
46
        unsigned int cur_eapd;
47
47
        unsigned int need_dac_fix;
48
48
 
 
49
        hda_nid_t *alt_dac_nid;
 
50
        struct hda_pcm_stream *stream_analog_alt_playback;
 
51
 
49
52
        /* capture */
50
53
        unsigned int num_adc_nids;
51
54
        hda_nid_t *adc_nids;
81
84
#endif
82
85
        /* for virtual master */
83
86
        hda_nid_t vmaster_nid;
84
 
        const char **slave_vols;
85
 
        const char **slave_sws;
 
87
        const char * const *slave_vols;
 
88
        const char * const *slave_sws;
86
89
};
87
90
 
88
91
/*
130
133
        return 0;
131
134
}
132
135
 
133
 
static const char *ad_slave_vols[] = {
 
136
static const char * const ad_slave_vols[] = {
134
137
        "Front Playback Volume",
135
138
        "Surround Playback Volume",
136
139
        "Center Playback Volume",
143
146
        NULL
144
147
};
145
148
 
146
 
static const char *ad_slave_sws[] = {
 
149
static const char * const ad_slave_sws[] = {
147
150
        "Front Playback Switch",
148
151
        "Surround Playback Switch",
149
152
        "Center Playback Switch",
156
159
        NULL
157
160
};
158
161
 
 
162
static const char * const ad1988_6stack_fp_slave_vols[] = {
 
163
        "Front Playback Volume",
 
164
        "Surround Playback Volume",
 
165
        "Center Playback Volume",
 
166
        "LFE Playback Volume",
 
167
        "Side Playback Volume",
 
168
        "IEC958 Playback Volume",
 
169
        NULL
 
170
};
 
171
 
 
172
static const char * const ad1988_6stack_fp_slave_sws[] = {
 
173
        "Front Playback Switch",
 
174
        "Surround Playback Switch",
 
175
        "Center Playback Switch",
 
176
        "LFE Playback Switch",
 
177
        "Side Playback Switch",
 
178
        "IEC958 Playback Switch",
 
179
        NULL
 
180
};
159
181
static void ad198x_free_kctls(struct hda_codec *codec);
160
182
 
161
183
#ifdef CONFIG_SND_HDA_INPUT_BEEP
309
331
        return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
310
332
}
311
333
 
 
334
static int ad198x_alt_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 
335
                                struct hda_codec *codec,
 
336
                                unsigned int stream_tag,
 
337
                                unsigned int format,
 
338
                                struct snd_pcm_substream *substream)
 
339
{
 
340
        struct ad198x_spec *spec = codec->spec;
 
341
        snd_hda_codec_setup_stream(codec, spec->alt_dac_nid[0], stream_tag,
 
342
                                        0, format);
 
343
        return 0;
 
344
}
 
345
 
 
346
static int ad198x_alt_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 
347
                                struct hda_codec *codec,
 
348
                                struct snd_pcm_substream *substream)
 
349
{
 
350
        struct ad198x_spec *spec = codec->spec;
 
351
        snd_hda_codec_cleanup_stream(codec, spec->alt_dac_nid[0]);
 
352
        return 0;
 
353
}
 
354
 
 
355
static struct hda_pcm_stream ad198x_pcm_analog_alt_playback = {
 
356
        .substreams = 1,
 
357
        .channels_min = 2,
 
358
        .channels_max = 2,
 
359
        /* NID is set in ad198x_build_pcms */
 
360
        .ops = {
 
361
                .prepare = ad198x_alt_playback_pcm_prepare,
 
362
                .cleanup = ad198x_alt_playback_pcm_cleanup
 
363
        },
 
364
};
 
365
 
312
366
/*
313
367
 * Digital out
314
368
 */
446
500
                }
447
501
        }
448
502
 
 
503
        if (spec->alt_dac_nid && spec->stream_analog_alt_playback) {
 
504
                codec->num_pcms++;
 
505
                info = spec->pcm_rec + 2;
 
506
                info->name = "AD198x Headphone";
 
507
                info->pcm_type = HDA_PCM_TYPE_AUDIO;
 
508
                info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
 
509
                        *spec->stream_analog_alt_playback;
 
510
                info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
 
511
                        spec->alt_dac_nid[0];
 
512
        }
 
513
 
449
514
        return 0;
450
515
}
451
516
 
527
592
        ad198x_power_eapd(codec);
528
593
        return 0;
529
594
}
530
 
 
531
 
static int ad198x_resume(struct hda_codec *codec)
532
 
{
533
 
        ad198x_init(codec);
534
 
        snd_hda_codec_resume_amp(codec);
535
 
        snd_hda_codec_resume_cache(codec);
536
 
        return 0;
537
 
}
538
595
#endif
539
596
 
540
597
static struct hda_codec_ops ad198x_patch_ops = {
547
604
#endif
548
605
#ifdef SND_HDA_NEEDS_RESUME
549
606
        .suspend = ad198x_suspend,
550
 
        .resume = ad198x_resume,
551
607
#endif
552
608
        .reboot_notify = ad198x_shutup,
553
609
};
675
731
        HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
676
732
        HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
677
733
        HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
678
 
        HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 
734
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),
679
735
        HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
680
736
        HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT),
681
737
        HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
738
794
        HDA_CODEC_MUTE("Aux Playback Switch", 0x16, 0x0, HDA_OUTPUT),
739
795
        HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
740
796
        HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
741
 
        HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 
797
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),
742
798
        /* 
743
799
           HDA_CODEC_VOLUME("Mono Playback Volume", 0x1e, 0x0, HDA_OUTPUT),
744
800
           HDA_CODEC_MUTE("Mono Playback Switch", 0x1e, 0x0, HDA_OUTPUT), */
784
840
        HDA_CODEC_MUTE("PCM Playback Switch", 0x03, 0x0, HDA_OUTPUT),
785
841
        HDA_CODEC_VOLUME("Mic Playback Volume", 0x13, 0x0, HDA_OUTPUT),
786
842
        HDA_CODEC_MUTE("Mic Playback Switch", 0x13, 0x0, HDA_OUTPUT),
787
 
        HDA_CODEC_VOLUME("Mic Boost", 0x0f, 0x0, HDA_OUTPUT),
 
843
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x0f, 0x0, HDA_OUTPUT),
788
844
        HDA_CODEC_VOLUME("Capture Volume", 0x12, 0x0, HDA_OUTPUT),
789
845
        HDA_CODEC_MUTE("Capture Switch", 0x12, 0x0, HDA_OUTPUT),
790
846
        {
1078
1134
        AD1986A_MODELS
1079
1135
};
1080
1136
 
1081
 
static const char *ad1986a_models[AD1986A_MODELS] = {
 
1137
static const char * const ad1986a_models[AD1986A_MODELS] = {
1082
1138
        [AD1986A_6STACK]        = "6stack",
1083
1139
        [AD1986A_3STACK]        = "3stack",
1084
1140
        [AD1986A_LAPTOP]        = "laptop",
1285
1341
        spec->multiout.no_share_stream = 1;
1286
1342
 
1287
1343
        codec->no_trigger_sense = 1;
 
1344
        codec->no_sticky_stream = 1;
1288
1345
 
1289
1346
        return 0;
1290
1347
}
1366
1423
        HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1367
1424
        HDA_CODEC_VOLUME("Line Playback Volume", 0x13, 0x0, HDA_OUTPUT),
1368
1425
        HDA_CODEC_MUTE("Line Playback Switch", 0x13, 0x0, HDA_OUTPUT),
1369
 
        HDA_CODEC_VOLUME("Mic Boost", 0x0c, 0x0, HDA_OUTPUT),
 
1426
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x0c, 0x0, HDA_OUTPUT),
1370
1427
        HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1371
1428
        HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1372
1429
        {
1472
1529
        codec->patch_ops = ad198x_patch_ops;
1473
1530
 
1474
1531
        codec->no_trigger_sense = 1;
 
1532
        codec->no_sticky_stream = 1;
1475
1533
 
1476
1534
        return 0;
1477
1535
}
1522
1580
        HDA_CODEC_MUTE("Mic Playback Switch", 0x1c, 0x0, HDA_OUTPUT),
1523
1581
        HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1524
1582
        HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1525
 
        HDA_CODEC_VOLUME("Front Mic Boost", 0x08, 0x0, HDA_INPUT),
1526
 
        HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x0, HDA_INPUT),
 
1583
        HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
 
1584
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x18, 0x0, HDA_INPUT),
1527
1585
        HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1528
1586
        HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1529
1587
        {
1733
1791
        HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1734
1792
        HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1735
1793
#endif
1736
 
        HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
1737
 
        HDA_CODEC_VOLUME("Internal Mic Boost", 0x18, 0x0, HDA_INPUT),
 
1794
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
 
1795
        HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x18, 0x0, HDA_INPUT),
1738
1796
        HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1739
1797
        HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1740
1798
        {
1781
1839
        HDA_CODEC_MUTE("Mic Playback Switch", 0x12, 0x0, HDA_OUTPUT),
1782
1840
        HDA_CODEC_VOLUME("CD Playback Volume", 0x1d, 0x0, HDA_OUTPUT),
1783
1841
        HDA_CODEC_MUTE("CD Playback Switch", 0x1d, 0x0, HDA_OUTPUT),
1784
 
        HDA_CODEC_VOLUME("Mic Boost", 0x08, 0x0, HDA_INPUT),
 
1842
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x08, 0x0, HDA_INPUT),
1785
1843
        HDA_CODEC_VOLUME("Capture Volume", 0x15, 0x0, HDA_OUTPUT),
1786
1844
        HDA_CODEC_MUTE("Capture Switch", 0x15, 0x0, HDA_OUTPUT),
1787
1845
        {
1820
1878
        AD1981_MODELS
1821
1879
};
1822
1880
 
1823
 
static const char *ad1981_models[AD1981_MODELS] = {
 
1881
static const char * const ad1981_models[AD1981_MODELS] = {
1824
1882
        [AD1981_HP]             = "hp",
1825
1883
        [AD1981_THINKPAD]       = "thinkpad",
1826
1884
        [AD1981_BASIC]          = "basic",
1926
1984
        }
1927
1985
 
1928
1986
        codec->no_trigger_sense = 1;
 
1987
        codec->no_sticky_stream = 1;
1929
1988
 
1930
1989
        return 0;
1931
1990
}
2021
2080
enum {
2022
2081
        AD1988_6STACK,
2023
2082
        AD1988_6STACK_DIG,
 
2083
        AD1988_6STACK_DIG_FP,
2024
2084
        AD1988_3STACK,
2025
2085
        AD1988_3STACK_DIG,
2026
2086
        AD1988_LAPTOP,
2053
2113
        0x04, 0x05, 0x0a, 0x06
2054
2114
};
2055
2115
 
 
2116
static hda_nid_t ad1988_alt_dac_nid[1] = {
 
2117
        0x03
 
2118
};
 
2119
 
2056
2120
static hda_nid_t ad1988_3stack_dac_nids_rev2[3] = {
2057
2121
        0x04, 0x0a, 0x06
2058
2122
};
2166
2230
        HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2167
2231
        HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2168
2232
 
2169
 
        HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2170
 
        HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
 
2233
        HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
 
2234
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
 
2235
 
 
2236
        { } /* end */
 
2237
};
 
2238
 
 
2239
static struct snd_kcontrol_new ad1988_6stack_fp_mixers[] = {
 
2240
        HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
 
2241
 
 
2242
        HDA_BIND_MUTE("Front Playback Switch", 0x29, 2, HDA_INPUT),
 
2243
        HDA_BIND_MUTE("Surround Playback Switch", 0x2a, 2, HDA_INPUT),
 
2244
        HDA_BIND_MUTE_MONO("Center Playback Switch", 0x27, 1, 2, HDA_INPUT),
 
2245
        HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x27, 2, 2, HDA_INPUT),
 
2246
        HDA_BIND_MUTE("Side Playback Switch", 0x28, 2, HDA_INPUT),
 
2247
        HDA_BIND_MUTE("Headphone Playback Switch", 0x22, 2, HDA_INPUT),
 
2248
        HDA_BIND_MUTE("Mono Playback Switch", 0x1e, 2, HDA_INPUT),
 
2249
 
 
2250
        HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x6, HDA_INPUT),
 
2251
        HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x6, HDA_INPUT),
 
2252
        HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x20, 0x0, HDA_INPUT),
 
2253
        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x0, HDA_INPUT),
 
2254
        HDA_CODEC_VOLUME("Line Playback Volume", 0x20, 0x1, HDA_INPUT),
 
2255
        HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x1, HDA_INPUT),
 
2256
        HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x4, HDA_INPUT),
 
2257
        HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x4, HDA_INPUT),
 
2258
 
 
2259
        HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
 
2260
        HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
 
2261
 
 
2262
        HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
 
2263
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
2171
2264
 
2172
2265
        { } /* end */
2173
2266
};
2209
2302
        HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2210
2303
        HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2211
2304
 
2212
 
        HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
2213
 
        HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
 
2305
        HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
 
2306
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
2214
2307
        {
2215
2308
                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2216
2309
                .name = "Channel Mode",
2238
2331
        HDA_CODEC_VOLUME("Analog Mix Playback Volume", 0x21, 0x0, HDA_OUTPUT),
2239
2332
        HDA_CODEC_MUTE("Analog Mix Playback Switch", 0x21, 0x0, HDA_OUTPUT),
2240
2333
 
2241
 
        HDA_CODEC_VOLUME("Mic Boost", 0x39, 0x0, HDA_OUTPUT),
 
2334
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
2242
2335
 
2243
2336
        {
2244
2337
                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2451
2544
        { }
2452
2545
};
2453
2546
 
 
2547
static struct hda_verb ad1988_6stack_fp_init_verbs[] = {
 
2548
        /* Front, Surround, CLFE, side DAC; unmute as default */
 
2549
        {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2550
        {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2551
        {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2552
        {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2553
        /* Headphone; unmute as default */
 
2554
        {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2555
        /* Port-A front headphon path */
 
2556
        {0x37, AC_VERB_SET_CONNECT_SEL, 0x00}, /* DAC0:03h */
 
2557
        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 
2558
        {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 
2559
        {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2560
        {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
 
2561
        /* Port-D line-out path */
 
2562
        {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 
2563
        {0x29, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 
2564
        {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2565
        {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 
2566
        /* Port-F surround path */
 
2567
        {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 
2568
        {0x2a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 
2569
        {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2570
        {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 
2571
        /* Port-G CLFE path */
 
2572
        {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 
2573
        {0x27, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 
2574
        {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2575
        {0x24, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 
2576
        /* Port-H side path */
 
2577
        {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 
2578
        {0x28, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 
2579
        {0x25, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
 
2580
        {0x25, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 
2581
        /* Mono out path */
 
2582
        {0x36, AC_VERB_SET_CONNECT_SEL, 0x1}, /* DAC1:04h */
 
2583
        {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
 
2584
        {0x1e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
 
2585
        {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
 
2586
        {0x13, AC_VERB_SET_AMP_GAIN_MUTE, 0xb01f}, /* unmute, 0dB */
 
2587
        /* Port-B front mic-in path */
 
2588
        {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 
2589
        {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 
2590
        {0x39, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 
2591
        /* Port-C line-in path */
 
2592
        {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 
2593
        {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 
2594
        {0x3a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 
2595
        {0x33, AC_VERB_SET_CONNECT_SEL, 0x0},
 
2596
        /* Port-E mic-in path */
 
2597
        {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
 
2598
        {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
 
2599
        {0x3c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
 
2600
        {0x34, AC_VERB_SET_CONNECT_SEL, 0x0},
 
2601
        /* Analog CD Input */
 
2602
        {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
 
2603
        /* Analog Mix output amp */
 
2604
        {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE | 0x1f}, /* 0dB */
 
2605
 
 
2606
        { }
 
2607
};
 
2608
 
2454
2609
static struct hda_verb ad1988_capture_init_verbs[] = {
2455
2610
        /* mute analog mix */
2456
2611
        {0x20, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2798
2953
                                             const struct auto_pin_cfg *cfg)
2799
2954
{
2800
2955
        char name[32];
2801
 
        static const char *chname[4] = { "Front", "Surround", NULL /*CLFE*/, "Side" };
 
2956
        static const char * const chname[4] = {
 
2957
                "Front", "Surround", NULL /*CLFE*/, "Side"
 
2958
        };
2802
2959
        hda_nid_t nid;
2803
2960
        int i, err;
2804
2961
 
2889
3046
 
2890
3047
/* create input playback/capture controls for the given pin */
2891
3048
static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin,
2892
 
                            const char *ctlname, int boost)
 
3049
                            const char *ctlname, int ctlidx, int boost)
2893
3050
{
2894
3051
        char name[32];
2895
3052
        int err, idx;
2908
3065
                idx = ad1988_pin_idx(pin);
2909
3066
                bnid = ad1988_boost_nids[idx];
2910
3067
                if (bnid) {
2911
 
                        sprintf(name, "%s Boost", ctlname);
 
3068
                        sprintf(name, "%s Boost Volume", ctlname);
2912
3069
                        return add_control(spec, AD_CTL_WIDGET_VOL, name,
2913
3070
                                           HDA_COMPOSE_AMP_VAL(bnid, 3, idx, HDA_OUTPUT));
2914
3071
 
2918
3075
}
2919
3076
 
2920
3077
/* create playback/capture controls for input pins */
2921
 
static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec,
 
3078
static int ad1988_auto_create_analog_input_ctls(struct hda_codec *codec,
2922
3079
                                                const struct auto_pin_cfg *cfg)
2923
3080
{
 
3081
        struct ad198x_spec *spec = codec->spec;
2924
3082
        struct hda_input_mux *imux = &spec->private_imux;
2925
 
        int i, err;
 
3083
        int i, err, type, type_idx;
2926
3084
 
2927
 
        for (i = 0; i < AUTO_PIN_LAST; i++) {
2928
 
                err = new_analog_input(spec, cfg->input_pins[i],
2929
 
                                       auto_pin_cfg_labels[i],
2930
 
                                       i <= AUTO_PIN_FRONT_MIC);
 
3085
        for (i = 0; i < cfg->num_inputs; i++) {
 
3086
                const char *label;
 
3087
                type = cfg->inputs[i].type;
 
3088
                label = hda_get_autocfg_input_label(codec, cfg, i);
 
3089
                snd_hda_add_imux_item(imux, label,
 
3090
                                      ad1988_pin_to_adc_idx(cfg->inputs[i].pin),
 
3091
                                      &type_idx);
 
3092
                err = new_analog_input(spec, cfg->inputs[i].pin,
 
3093
                                       label, type_idx,
 
3094
                                       type == AUTO_PIN_MIC);
2931
3095
                if (err < 0)
2932
3096
                        return err;
2933
 
                imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
2934
 
                imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]);
2935
 
                imux->num_items++;
2936
3097
        }
2937
 
        imux->items[imux->num_items].label = "Mix";
2938
 
        imux->items[imux->num_items].index = 9;
2939
 
        imux->num_items++;
 
3098
        snd_hda_add_imux_item(imux, "Mix", 9, NULL);
2940
3099
 
2941
3100
        if ((err = add_control(spec, AD_CTL_WIDGET_VOL,
2942
3101
                               "Analog Mix Playback Volume",
3003
3162
static void ad1988_auto_init_analog_input(struct hda_codec *codec)
3004
3163
{
3005
3164
        struct ad198x_spec *spec = codec->spec;
 
3165
        const struct auto_pin_cfg *cfg = &spec->autocfg;
3006
3166
        int i, idx;
3007
3167
 
3008
 
        for (i = 0; i < AUTO_PIN_LAST; i++) {
3009
 
                hda_nid_t nid = spec->autocfg.input_pins[i];
3010
 
                if (! nid)
3011
 
                        continue;
 
3168
        for (i = 0; i < cfg->num_inputs; i++) {
 
3169
                hda_nid_t nid = cfg->inputs[i].pin;
3012
3170
                switch (nid) {
3013
3171
                case 0x15: /* port-C */
3014
3172
                        snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0);
3018
3176
                        break;
3019
3177
                }
3020
3178
                snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
3021
 
                                    i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN);
 
3179
                                    i == AUTO_PIN_MIC ? PIN_VREF80 : PIN_IN);
3022
3180
                if (nid != AD1988_PIN_CD_NID)
3023
3181
                        snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
3024
3182
                                            AMP_OUT_MUTE);
3049
3207
                                                "Speaker")) < 0 ||
3050
3208
            (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
3051
3209
                                                "Headphone")) < 0 ||
3052
 
            (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0)
 
3210
            (err = ad1988_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3053
3211
                return err;
3054
3212
 
3055
3213
        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3079
3237
        return 0;
3080
3238
}
3081
3239
 
3082
 
 
3083
3240
/*
3084
3241
 */
3085
3242
 
3086
 
static const char *ad1988_models[AD1988_MODEL_LAST] = {
 
3243
static const char * const ad1988_models[AD1988_MODEL_LAST] = {
3087
3244
        [AD1988_6STACK]         = "6stack",
3088
3245
        [AD1988_6STACK_DIG]     = "6stack-dig",
 
3246
        [AD1988_6STACK_DIG_FP]  = "6stack-dig-fp",
3089
3247
        [AD1988_3STACK]         = "3stack",
3090
3248
        [AD1988_3STACK_DIG]     = "3stack-dig",
3091
3249
        [AD1988_LAPTOP]         = "laptop",
3145
3303
        switch (board_config) {
3146
3304
        case AD1988_6STACK:
3147
3305
        case AD1988_6STACK_DIG:
 
3306
        case AD1988_6STACK_DIG_FP:
3148
3307
                spec->multiout.max_channels = 8;
3149
3308
                spec->multiout.num_dacs = 4;
3150
3309
                if (is_rev2(codec))
3157
3316
                        spec->mixers[0] = ad1988_6stack_mixers1_rev2;
3158
3317
                else
3159
3318
                        spec->mixers[0] = ad1988_6stack_mixers1;
3160
 
                spec->mixers[1] = ad1988_6stack_mixers2;
 
3319
                if (board_config == AD1988_6STACK_DIG_FP) {
 
3320
                        spec->mixers[1] = ad1988_6stack_fp_mixers;
 
3321
                        spec->slave_vols = ad1988_6stack_fp_slave_vols;
 
3322
                        spec->slave_sws = ad1988_6stack_fp_slave_sws;
 
3323
                        spec->alt_dac_nid = ad1988_alt_dac_nid;
 
3324
                        spec->stream_analog_alt_playback =
 
3325
                                &ad198x_pcm_analog_alt_playback;
 
3326
                } else
 
3327
                        spec->mixers[1] = ad1988_6stack_mixers2;
3161
3328
                spec->num_init_verbs = 1;
3162
 
                spec->init_verbs[0] = ad1988_6stack_init_verbs;
3163
 
                if (board_config == AD1988_6STACK_DIG) {
 
3329
                if (board_config == AD1988_6STACK_DIG_FP)
 
3330
                        spec->init_verbs[0] = ad1988_6stack_fp_init_verbs;
 
3331
                else
 
3332
                        spec->init_verbs[0] = ad1988_6stack_init_verbs;
 
3333
                if ((board_config == AD1988_6STACK_DIG) ||
 
3334
                        (board_config == AD1988_6STACK_DIG_FP)) {
3164
3335
                        spec->multiout.dig_out_nid = AD1988_SPDIF_OUT;
3165
3336
                        spec->dig_in_nid = AD1988_SPDIF_IN;
3166
3337
                }
3244
3415
        spec->vmaster_nid = 0x04;
3245
3416
 
3246
3417
        codec->no_trigger_sense = 1;
 
3418
        codec->no_sticky_stream = 1;
3247
3419
 
3248
3420
        return 0;
3249
3421
}
3304
3476
        HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3305
3477
        HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3306
3478
        HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3307
 
        HDA_CODEC_VOLUME("Mic Boost", 0x15, 0x0, HDA_INPUT),
3308
 
        HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
 
3479
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
 
3480
        HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
3309
3481
        HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3310
3482
        HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3311
3483
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3403
3575
};
3404
3576
#endif
3405
3577
 
3406
 
static const char *ad1884_slave_vols[] = {
 
3578
static const char * const ad1884_slave_vols[] = {
3407
3579
        "PCM Playback Volume",
3408
3580
        "Mic Playback Volume",
3409
3581
        "Mono Playback Volume",
3458
3630
        codec->patch_ops = ad198x_patch_ops;
3459
3631
 
3460
3632
        codec->no_trigger_sense = 1;
 
3633
        codec->no_sticky_stream = 1;
3461
3634
 
3462
3635
        return 0;
3463
3636
}
3502
3675
        HDA_CODEC_MUTE("Beep Playback Switch", 0x20, 0x03, HDA_INPUT),
3503
3676
        HDA_CODEC_VOLUME("Docking Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3504
3677
        HDA_CODEC_MUTE("Docking Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3505
 
        HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3506
 
        HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3507
 
        HDA_CODEC_VOLUME("Docking Mic Boost", 0x25, 0x0, HDA_OUTPUT),
 
3678
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
 
3679
        HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
 
3680
        HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
3508
3681
        HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3509
3682
        HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3510
3683
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3563
3736
        HDA_CODEC_MUTE("Front Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
3564
3737
        HDA_CODEC_VOLUME("Line-In Playback Volume", 0x20, 0x01, HDA_INPUT),
3565
3738
        HDA_CODEC_MUTE("Line-In Playback Switch", 0x20, 0x01, HDA_INPUT),
3566
 
        HDA_CODEC_VOLUME("Line-In Boost", 0x15, 0x0, HDA_INPUT),
3567
 
        HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
 
3739
        HDA_CODEC_VOLUME("Line-In Boost Volume", 0x15, 0x0, HDA_INPUT),
 
3740
        HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
3568
3741
        HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3569
3742
        HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3570
3743
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3640
3813
        AD1984_MODELS
3641
3814
};
3642
3815
 
3643
 
static const char *ad1984_models[AD1984_MODELS] = {
 
3816
static const char * const ad1984_models[AD1984_MODELS] = {
3644
3817
        [AD1984_BASIC]          = "basic",
3645
3818
        [AD1984_THINKPAD]       = "thinkpad",
3646
3819
        [AD1984_DELL_DESKTOP]   = "dell_desktop",
3650
3823
        /* Lenovo Thinkpad T61/X61 */
3651
3824
        SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD),
3652
3825
        SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP),
 
3826
        SND_PCI_QUIRK(0x1028, 0x0233, "Dell Latitude E6400", AD1984_DELL_DESKTOP),
3653
3827
        {}
3654
3828
};
3655
3829
 
3671
3845
                codec->patch_ops.build_pcms = ad1984_build_pcms;
3672
3846
                break;
3673
3847
        case AD1984_THINKPAD:
3674
 
                spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
 
3848
                if (codec->subsystem_id == 0x17aa20fb) {
 
3849
                        /* Thinpad X300 does not have the ability to do SPDIF,
 
3850
                           or attach to docking station to use SPDIF */
 
3851
                        spec->multiout.dig_out_nid = 0;
 
3852
                } else
 
3853
                        spec->multiout.dig_out_nid = AD1884_SPDIF_OUT;
3675
3854
                spec->input_mux = &ad1984_thinkpad_capture_source;
3676
3855
                spec->mixers[0] = ad1984_thinkpad_mixers;
3677
3856
                spec->init_verbs[spec->num_init_verbs++] = ad1984_thinkpad_init_verbs;
3742
3921
        HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3743
3922
        HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x02, HDA_INPUT),
3744
3923
        HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x02, HDA_INPUT),
3745
 
        HDA_CODEC_VOLUME("Front Mic Boost", 0x14, 0x0, HDA_INPUT),
3746
 
        HDA_CODEC_VOLUME("Line Boost", 0x15, 0x0, HDA_INPUT),
3747
 
        HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
 
3924
        HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
 
3925
        HDA_CODEC_VOLUME("Line Boost Volume", 0x15, 0x0, HDA_INPUT),
 
3926
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
3748
3927
        HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3749
3928
        HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3750
3929
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
3885
4064
        HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x20, 0x01, HDA_INPUT),
3886
4065
        HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x20, 0x04, HDA_INPUT),
3887
4066
        HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x20, 0x04, HDA_INPUT),
3888
 
        HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
3889
 
        HDA_CODEC_VOLUME("Internal Mic Boost", 0x15, 0x0, HDA_INPUT),
3890
 
        HDA_CODEC_VOLUME("Dock Mic Boost", 0x25, 0x0, HDA_OUTPUT),
 
4067
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
 
4068
        HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x15, 0x0, HDA_INPUT),
 
4069
        HDA_CODEC_VOLUME("Dock Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
3891
4070
        HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
3892
4071
        HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
3893
4072
        { } /* end */
4123
4302
        HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4124
4303
        HDA_CODEC_VOLUME("Mic Playback Volume", 0x20, 0x00, HDA_INPUT),
4125
4304
        HDA_CODEC_MUTE("Mic Playback Switch", 0x20, 0x00, HDA_INPUT),
4126
 
        HDA_CODEC_VOLUME("Mic Boost", 0x14, 0x0, HDA_INPUT),
4127
 
        HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
 
4305
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x14, 0x0, HDA_INPUT),
 
4306
        HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x17, 0x0, HDA_INPUT),
4128
4307
        HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4129
4308
        HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4130
4309
        {
4252
4431
        HDA_CODEC_MUTE("PCM Playback Switch", 0x20, 0x5, HDA_INPUT),
4253
4432
        HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4254
4433
        HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4255
 
        HDA_CODEC_VOLUME("Mic Boost", 0x25, 0x0, HDA_OUTPUT),
4256
 
        HDA_CODEC_VOLUME("Internal Mic Boost", 0x17, 0x0, HDA_INPUT),
 
4434
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x25, 0x0, HDA_OUTPUT),
 
4435
        HDA_CODEC_VOLUME("Internal Mic Boost Volume", 0x17, 0x0, HDA_INPUT),
4257
4436
        { } /* end */
4258
4437
};
4259
4438
 
4305
4484
        AD1884A_MODELS
4306
4485
};
4307
4486
 
4308
 
static const char *ad1884a_models[AD1884A_MODELS] = {
 
4487
static const char * const ad1884a_models[AD1884A_MODELS] = {
4309
4488
        [AD1884A_DESKTOP]       = "desktop",
4310
4489
        [AD1884A_LAPTOP]        = "laptop",
4311
4490
        [AD1884A_MOBILE]        = "mobile",
4425
4604
        }
4426
4605
 
4427
4606
        codec->no_trigger_sense = 1;
 
4607
        codec->no_sticky_stream = 1;
4428
4608
 
4429
4609
        return 0;
4430
4610
}
4490
4670
        HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x13, 1, 0x0, HDA_OUTPUT),
4491
4671
        HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x13, 1, 0x0, HDA_OUTPUT),
4492
4672
 
4493
 
        HDA_CODEC_VOLUME("Mic Boost", 0x3c, 0x0, HDA_OUTPUT),
4494
 
        HDA_CODEC_VOLUME("Front Mic Boost", 0x39, 0x0, HDA_OUTPUT),
4495
 
        HDA_CODEC_VOLUME("Line-In Boost", 0x3a, 0x0, HDA_OUTPUT),
 
4673
        HDA_CODEC_VOLUME("Mic Boost Volume", 0x3c, 0x0, HDA_OUTPUT),
 
4674
        HDA_CODEC_VOLUME("Front Mic Boost Volume", 0x39, 0x0, HDA_OUTPUT),
 
4675
        HDA_CODEC_VOLUME("Line-In Boost Volume", 0x3a, 0x0, HDA_OUTPUT),
4496
4676
        HDA_CODEC_VOLUME("Capture Volume", 0x0c, 0x0, HDA_OUTPUT),
4497
4677
        HDA_CODEC_MUTE("Capture Switch", 0x0c, 0x0, HDA_OUTPUT),
4498
4678
        HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x0d, 0x0, HDA_OUTPUT),
4543
4723
        HDA_CODEC_MUTE("Line Playback Switch", 0x20, 0x01, HDA_INPUT),
4544
4724
        HDA_CODEC_VOLUME("CD Playback Volume", 0x20, 0x06, HDA_INPUT),
4545
4725
        HDA_CODEC_MUTE("CD Playback Switch", 0x20, 0x06, HDA_INPUT),
4546
 
        HDA_CODEC_VOLUME("Digital Mic Boost", 0x1f, 0x0, HDA_INPUT),
 
4726
        HDA_CODEC_VOLUME("Digital Mic Boost Volume", 0x1f, 0x0, HDA_INPUT),
4547
4727
        { } /* end */
4548
4728
};
4549
4729
 
4692
4872
        AD1882_MODELS
4693
4873
};
4694
4874
 
4695
 
static const char *ad1882_models[AD1986A_MODELS] = {
 
4875
static const char * const ad1882_models[AD1986A_MODELS] = {
4696
4876
        [AD1882_3STACK]         = "3stack",
4697
4877
        [AD1882_6STACK]         = "6stack",
4698
4878
};
4764
4944
        }
4765
4945
 
4766
4946
        codec->no_trigger_sense = 1;
 
4947
        codec->no_sticky_stream = 1;
4767
4948
 
4768
4949
        return 0;
4769
4950
}