projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - Add missing num_adc_nids definition for IDT92HD8xxx
[deliverable/linux.git] / sound / pci / hda / patch_sigmatel.c
CommitLineData
2f2f4251
M		 1/*
2 * Universal Interface for Intel High Definition Audio Codec
3 *
4 * HD audio interface patch for SigmaTel STAC92xx
5 *
6 * Copyright (c) 2005 Embedded Alley Solutions, Inc.
403d1944 7 * Matt Porter <mporter@embeddedalley.com>
2f2f4251
M		 8 *
9 * Based on patch_cmedia.c and patch_realtek.c
10 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
11 *
12 * This driver is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This driver is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 */
26
2f2f4251
M		 27#include <linux/init.h>
28#include <linux/delay.h>
29#include <linux/slab.h>
30#include <linux/pci.h>
31#include <sound/core.h>
c7d4b2fa 32#include <sound/asoundef.h>
45a6ac16 33#include <sound/jack.h>
2f2f4251
M		 34#include "hda_codec.h"
35#include "hda_local.h"
1cd2224c 36#include "hda_beep.h"
2f2f4251 37
c6e4c666
TI		 38enum {
39 STAC_VREF_EVENT = 1,
40 STAC_INSERT_EVENT,
41 STAC_PWR_EVENT,
42 STAC_HP_EVENT,
fefd67f3 43 STAC_LO_EVENT,
3d21d3f7 44 STAC_MIC_EVENT,
c6e4c666 45};
4e55096e 46
f5fcc13c 47enum {
1607b8ea 48 STAC_AUTO,
f5fcc13c 49 STAC_REF,
bf277785 50 STAC_9200_OQO,
dfe495d0
TI		 51 STAC_9200_DELL_D21,
52 STAC_9200_DELL_D22,
53 STAC_9200_DELL_D23,
54 STAC_9200_DELL_M21,
55 STAC_9200_DELL_M22,
56 STAC_9200_DELL_M23,
57 STAC_9200_DELL_M24,
58 STAC_9200_DELL_M25,
59 STAC_9200_DELL_M26,
60 STAC_9200_DELL_M27,
58eec423
MCC		 61 STAC_9200_M4,
62 STAC_9200_M4_2,
117f257d 63 STAC_9200_PANASONIC,
f5fcc13c
TI		 64 STAC_9200_MODELS
65};
66
67enum {
1607b8ea 68 STAC_9205_AUTO,
f5fcc13c 69 STAC_9205_REF,
dfe495d0 70 STAC_9205_DELL_M42,
ae0a8ed8
TD		 71 STAC_9205_DELL_M43,
72 STAC_9205_DELL_M44,
d9a4268e 73 STAC_9205_EAPD,
f5fcc13c
TI		 74 STAC_9205_MODELS
75};
76
e1f0d669 77enum {
1607b8ea 78 STAC_92HD73XX_AUTO,
9e43f0de 79 STAC_92HD73XX_NO_JD, /* no jack-detection */
e1f0d669 80 STAC_92HD73XX_REF,
661cd8fb
TI		 81 STAC_DELL_M6_AMIC,
82 STAC_DELL_M6_DMIC,
83 STAC_DELL_M6_BOTH,
6b3ab21e 84 STAC_DELL_EQ,
e1f0d669
MR		 85 STAC_92HD73XX_MODELS
86};
87
d0513fc6 88enum {
1607b8ea 89 STAC_92HD83XXX_AUTO,
d0513fc6 90 STAC_92HD83XXX_REF,
32ed3f46 91 STAC_92HD83XXX_PWR_REF,
8bb0ac55 92 STAC_DELL_S14,
d0513fc6
MR		 93 STAC_92HD83XXX_MODELS
94};
95
e035b841 96enum {
1607b8ea 97 STAC_92HD71BXX_AUTO,
e035b841 98 STAC_92HD71BXX_REF,
a7662640
MR		 99 STAC_DELL_M4_1,
100 STAC_DELL_M4_2,
3a7abfd2 101 STAC_DELL_M4_3,
6a14f585 102 STAC_HP_M4,
1b0652eb 103 STAC_HP_DV5,
ae6241fb 104 STAC_HP_HDX,
514bf54c 105 STAC_HP_DV4_1222NR,
e035b841
MR		 106 STAC_92HD71BXX_MODELS
107};
108
8e21c34c 109enum {
1607b8ea 110 STAC_925x_AUTO,
8e21c34c 111 STAC_925x_REF,
9cb36c2a
MCC		 112 STAC_M1,
113 STAC_M1_2,
114 STAC_M2,
8e21c34c 115 STAC_M2_2,
9cb36c2a
MCC		 116 STAC_M3,
117 STAC_M5,
118 STAC_M6,
8e21c34c
TD		 119 STAC_925x_MODELS
120};
121
f5fcc13c 122enum {
1607b8ea 123 STAC_922X_AUTO,
f5fcc13c
TI		 124 STAC_D945_REF,
125 STAC_D945GTP3,
126 STAC_D945GTP5,
5d5d3bc3
IZ		 127 STAC_INTEL_MAC_V1,
128 STAC_INTEL_MAC_V2,
129 STAC_INTEL_MAC_V3,
130 STAC_INTEL_MAC_V4,
131 STAC_INTEL_MAC_V5,
536319af
NB		 132 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
133 * is given, one of the above models will be
134 * chosen according to the subsystem id. */
dfe495d0 135 /* for backward compatibility */
f5fcc13c 136 STAC_MACMINI,
3fc24d85 137 STAC_MACBOOK,
6f0778d8
NB		 138 STAC_MACBOOK_PRO_V1,
139 STAC_MACBOOK_PRO_V2,
f16928fb 140 STAC_IMAC_INTEL,
0dae0f83 141 STAC_IMAC_INTEL_20,
8c650087 142 STAC_ECS_202,
dfe495d0
TI		 143 STAC_922X_DELL_D81,
144 STAC_922X_DELL_D82,
145 STAC_922X_DELL_M81,
146 STAC_922X_DELL_M82,
f5fcc13c
TI		 147 STAC_922X_MODELS
148};
149
150enum {
1607b8ea 151 STAC_927X_AUTO,
e28d8322 152 STAC_D965_REF_NO_JD, /* no jack-detection */
f5fcc13c
TI		 153 STAC_D965_REF,
154 STAC_D965_3ST,
155 STAC_D965_5ST,
679d92ed 156 STAC_D965_5ST_NO_FP,
4ff076e5 157 STAC_DELL_3ST,
8e9068b1 158 STAC_DELL_BIOS,
f5fcc13c
TI		 159 STAC_927X_MODELS
160};
403d1944 161
307282c8
TI		 162enum {
163 STAC_9872_AUTO,
164 STAC_9872_VAIO,
165 STAC_9872_MODELS
166};
167
74aeaabc
MR		 168struct sigmatel_event {
169 hda_nid_t nid;
c6e4c666
TI		 170 unsigned char type;
171 unsigned char tag;
74aeaabc
MR		 172 int data;
173};
174
175struct sigmatel_jack {
176 hda_nid_t nid;
177 int type;
178 struct snd_jack *jack;
179};
180
3d21d3f7
TI		 181struct sigmatel_mic_route {
182 hda_nid_t pin;
183 unsigned char mux_idx;
184 unsigned char dmux_idx;
185};
186
2f2f4251 187struct sigmatel_spec {
c8b6bf9b 188 struct snd_kcontrol_new *mixers[4];
c7d4b2fa
M		 189 unsigned int num_mixers;
190
403d1944 191 int board_config;
c0cea0d0 192 unsigned int eapd_switch: 1;
c7d4b2fa 193 unsigned int surr_switch: 1;
3cc08dc6 194 unsigned int alt_switch: 1;
82bc955f 195 unsigned int hp_detect: 1;
00ef50c2 196 unsigned int spdif_mute: 1;
7c7767eb 197 unsigned int check_volume_offset:1;
3d21d3f7 198 unsigned int auto_mic:1;
c7d4b2fa 199
4fe5195c 200 /* gpio lines */
0fc9dec4 201 unsigned int eapd_mask;
4fe5195c
MR		 202 unsigned int gpio_mask;
203 unsigned int gpio_dir;
204 unsigned int gpio_data;
205 unsigned int gpio_mute;
86d190e7 206 unsigned int gpio_led;
4fe5195c 207
8daaaa97
MR		 208 /* stream */
209 unsigned int stream_delay;
210
4fe5195c 211 /* analog loopback */
d78d7a90 212 struct snd_kcontrol_new *aloopback_ctl;
e1f0d669
MR		 213 unsigned char aloopback_mask;
214 unsigned char aloopback_shift;
8259980e 215
a64135a2
MR		 216 /* power management */
217 unsigned int num_pwrs;
d0513fc6 218 unsigned int *pwr_mapping;
a64135a2 219 hda_nid_t *pwr_nids;
b76c850f 220 hda_nid_t *dac_list;
a64135a2 221
74aeaabc
MR		 222 /* jack detection */
223 struct snd_array jacks;
224
225 /* events */
226 struct snd_array events;
227
2f2f4251 228 /* playback */
b22b4821 229 struct hda_input_mux *mono_mux;
89385035 230 struct hda_input_mux *amp_mux;
b22b4821 231 unsigned int cur_mmux;
2f2f4251 232 struct hda_multi_out multiout;
3cc08dc6 233 hda_nid_t dac_nids[5];
c21ca4a8
TI		 234 hda_nid_t hp_dacs[5];
235 hda_nid_t speaker_dacs[5];
2f2f4251 236
7c7767eb
TI		 237 int volume_offset;
238
2f2f4251
M		 239 /* capture */
240 hda_nid_t *adc_nids;
2f2f4251 241 unsigned int num_adcs;
dabbed6f
M		 242 hda_nid_t *mux_nids;
243 unsigned int num_muxes;
8b65727b
MP		 244 hda_nid_t *dmic_nids;
245 unsigned int num_dmics;
e1f0d669 246 hda_nid_t *dmux_nids;
1697055e 247 unsigned int num_dmuxes;
d9737751
MR		 248 hda_nid_t *smux_nids;
249 unsigned int num_smuxes;
5207e10e 250 unsigned int num_analog_muxes;
6479c631
TI		 251
252 unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
253 unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */
254 unsigned int num_caps; /* number of capture volume/switch elements */
255
3d21d3f7
TI		 256 struct sigmatel_mic_route ext_mic;
257 struct sigmatel_mic_route int_mic;
258
65973632 259 const char **spdif_labels;
d9737751 260
dabbed6f 261 hda_nid_t dig_in_nid;
b22b4821 262 hda_nid_t mono_nid;
1cd2224c
MR		 263 hda_nid_t anabeep_nid;
264 hda_nid_t digbeep_nid;
2f2f4251 265
2f2f4251
M		 266 /* pin widgets */
267 hda_nid_t *pin_nids;
268 unsigned int num_pins;
2f2f4251
M		 269
270 /* codec specific stuff */
271 struct hda_verb *init;
c8b6bf9b 272 struct snd_kcontrol_new *mixer;
2f2f4251
M		 273
274 /* capture source */
8b65727b 275 struct hda_input_mux *dinput_mux;
e1f0d669 276 unsigned int cur_dmux[2];
c7d4b2fa 277 struct hda_input_mux *input_mux;
3cc08dc6 278 unsigned int cur_mux[3];
d9737751
MR		 279 struct hda_input_mux *sinput_mux;
280 unsigned int cur_smux[2];
2a9c7816
MR		 281 unsigned int cur_amux;
282 hda_nid_t *amp_nids;
283 unsigned int num_amps;
8daaaa97 284 unsigned int powerdown_adcs;
2f2f4251 285
403d1944
MP		 286 /* i/o switches */
287 unsigned int io_switch[2];
0fb87bb4 288 unsigned int clfe_swap;
c21ca4a8
TI		 289 hda_nid_t line_switch; /* shared line-in for input and output */
290 hda_nid_t mic_switch; /* shared mic-in for input and output */
291 hda_nid_t hp_switch; /* NID of HP as line-out */
5f10c4a9 292 unsigned int aloopback;
2f2f4251 293
c7d4b2fa
M		 294 struct hda_pcm pcm_rec[2]; /* PCM information */
295
296 /* dynamic controls and input_mux */
297 struct auto_pin_cfg autocfg;
603c4019 298 struct snd_array kctls;
8b65727b 299 struct hda_input_mux private_dimux;
c7d4b2fa 300 struct hda_input_mux private_imux;
d9737751 301 struct hda_input_mux private_smux;
89385035 302 struct hda_input_mux private_amp_mux;
b22b4821 303 struct hda_input_mux private_mono_mux;
2f2f4251
M		 304};
305
306static hda_nid_t stac9200_adc_nids[1] = {
307 0x03,
308};
309
310static hda_nid_t stac9200_mux_nids[1] = {
311 0x0c,
312};
313
314static hda_nid_t stac9200_dac_nids[1] = {
315 0x02,
316};
317
a64135a2
MR		 318static hda_nid_t stac92hd73xx_pwr_nids[8] = {
319 0x0a, 0x0b, 0x0c, 0xd, 0x0e,
320 0x0f, 0x10, 0x11
321};
322
0ffa9807
MR		 323static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
324 0x26, 0,
325};
326
e1f0d669
MR		 327static hda_nid_t stac92hd73xx_adc_nids[2] = {
328 0x1a, 0x1b
329};
330
2a9c7816
MR		 331#define DELL_M6_AMP 2
332static hda_nid_t stac92hd73xx_amp_nids[3] = {
333 0x0b, 0x0c, 0x0e
89385035
MR		 334};
335
e1f0d669
MR		 336#define STAC92HD73XX_NUM_DMICS 2
337static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
338 0x13, 0x14, 0
339};
340
341#define STAC92HD73_DAC_COUNT 5
e1f0d669
MR		 342
343static hda_nid_t stac92hd73xx_mux_nids[4] = {
344 0x28, 0x29, 0x2a, 0x2b,
345};
346
347static hda_nid_t stac92hd73xx_dmux_nids[2] = {
348 0x20, 0x21,
349};
350
d9737751
MR		 351static hda_nid_t stac92hd73xx_smux_nids[2] = {
352 0x22, 0x23,
353};
354
6479c631
TI		 355#define STAC92HD73XX_NUM_CAPS 2
356static unsigned long stac92hd73xx_capvols[] = {
357 HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
358 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
359};
360#define stac92hd73xx_capsws stac92hd73xx_capvols
361
d0513fc6 362#define STAC92HD83_DAC_COUNT 3
d0513fc6 363
667067d8 364static hda_nid_t stac92hd83xxx_mux_nids[2] = {
d0513fc6
MR		 365 0x17, 0x18,
366};
367
368static hda_nid_t stac92hd83xxx_adc_nids[2] = {
369 0x15, 0x16,
370};
371
372static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
373 0xa, 0xb, 0xd, 0xe,
374};
375
0ffa9807
MR		 376static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
377 0x1e, 0,
378};
379
d0513fc6 380static unsigned int stac92hd83xxx_pwr_mapping[4] = {
87e88a74 381 0x03, 0x0c, 0x20, 0x40,
d0513fc6
MR		 382};
383
6479c631
TI		 384#define STAC92HD83XXX_NUM_CAPS 2
385static unsigned long stac92hd83xxx_capvols[] = {
386 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
387 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_OUTPUT),
388};
389#define stac92hd83xxx_capsws stac92hd83xxx_capvols
390
a64135a2
MR		 391static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
392 0x0a, 0x0d, 0x0f
393};
394
e035b841
MR		 395static hda_nid_t stac92hd71bxx_adc_nids[2] = {
396 0x12, 0x13,
397};
398
399static hda_nid_t stac92hd71bxx_mux_nids[2] = {
400 0x1a, 0x1b
401};
402
4b33c767
MR		 403static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
404 0x1c, 0x1d,
e1f0d669
MR		 405};
406
d9737751
MR		 407static hda_nid_t stac92hd71bxx_smux_nids[2] = {
408 0x24, 0x25,
409};
410
e035b841
MR		 411#define STAC92HD71BXX_NUM_DMICS 2
412static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
413 0x18, 0x19, 0
414};
415
0ffa9807
MR		 416static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
417 0x22, 0
418};
419
6479c631
TI		 420#define STAC92HD71BXX_NUM_CAPS 2
421static unsigned long stac92hd71bxx_capvols[] = {
422 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
423 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
424};
425#define stac92hd71bxx_capsws stac92hd71bxx_capvols
426
8e21c34c
TD		 427static hda_nid_t stac925x_adc_nids[1] = {
428 0x03,
429};
430
431static hda_nid_t stac925x_mux_nids[1] = {
432 0x0f,
433};
434
435static hda_nid_t stac925x_dac_nids[1] = {
436 0x02,
437};
438
f6e9852a
TI		 439#define STAC925X_NUM_DMICS 1
440static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
441 0x15, 0
2c11f955
TD		 442};
443
1697055e
TI		 444static hda_nid_t stac925x_dmux_nids[1] = {
445 0x14,
446};
447
6479c631
TI		 448static unsigned long stac925x_capvols[] = {
449 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
450};
451static unsigned long stac925x_capsws[] = {
452 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
453};
454
2f2f4251
M		 455static hda_nid_t stac922x_adc_nids[2] = {
456 0x06, 0x07,
457};
458
459static hda_nid_t stac922x_mux_nids[2] = {
460 0x12, 0x13,
461};
462
6479c631
TI		 463#define STAC922X_NUM_CAPS 2
464static unsigned long stac922x_capvols[] = {
465 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
466 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
467};
468#define stac922x_capsws stac922x_capvols
469
45c1d85b
MR		 470static hda_nid_t stac927x_slave_dig_outs[2] = {
471 0x1f, 0,
472};
473
3cc08dc6
MP		 474static hda_nid_t stac927x_adc_nids[3] = {
475 0x07, 0x08, 0x09
476};
477
478static hda_nid_t stac927x_mux_nids[3] = {
479 0x15, 0x16, 0x17
480};
481
d9737751
MR		 482static hda_nid_t stac927x_smux_nids[1] = {
483 0x21,
484};
485
b76c850f
MR		 486static hda_nid_t stac927x_dac_nids[6] = {
487 0x02, 0x03, 0x04, 0x05, 0x06, 0
488};
489
e1f0d669
MR		 490static hda_nid_t stac927x_dmux_nids[1] = {
491 0x1b,
492};
493
7f16859a
MR		 494#define STAC927X_NUM_DMICS 2
495static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
496 0x13, 0x14, 0
497};
498
6479c631
TI		 499#define STAC927X_NUM_CAPS 3
500static unsigned long stac927x_capvols[] = {
501 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
502 HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
503 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
504};
505static unsigned long stac927x_capsws[] = {
506 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
507 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
508 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
509};
510
65973632
MR		 511static const char *stac927x_spdif_labels[5] = {
512 "Digital Playback", "ADAT", "Analog Mux 1",
513 "Analog Mux 2", "Analog Mux 3"
514};
515
f3302a59
MP		 516static hda_nid_t stac9205_adc_nids[2] = {
517 0x12, 0x13
518};
519
520static hda_nid_t stac9205_mux_nids[2] = {
521 0x19, 0x1a
522};
523
e1f0d669 524static hda_nid_t stac9205_dmux_nids[1] = {
1697055e 525 0x1d,
e1f0d669
MR		 526};
527
d9737751
MR		 528static hda_nid_t stac9205_smux_nids[1] = {
529 0x21,
530};
531
f6e9852a
TI		 532#define STAC9205_NUM_DMICS 2
533static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
534 0x17, 0x18, 0
8b65727b
MP		 535};
536
6479c631
TI		 537#define STAC9205_NUM_CAPS 2
538static unsigned long stac9205_capvols[] = {
539 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
540 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
541};
542static unsigned long stac9205_capsws[] = {
543 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
544 HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
545};
546
c7d4b2fa 547static hda_nid_t stac9200_pin_nids[8] = {
93ed1503
TD		 548 0x08, 0x09, 0x0d, 0x0e,
549 0x0f, 0x10, 0x11, 0x12,
2f2f4251
M		 550};
551
8e21c34c
TD		 552static hda_nid_t stac925x_pin_nids[8] = {
553 0x07, 0x08, 0x0a, 0x0b,
554 0x0c, 0x0d, 0x10, 0x11,
555};
556
2f2f4251
M		 557static hda_nid_t stac922x_pin_nids[10] = {
558 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
559 0x0f, 0x10, 0x11, 0x15, 0x1b,
560};
561
a7662640 562static hda_nid_t stac92hd73xx_pin_nids[13] = {
e1f0d669
MR		 563 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
564 0x0f, 0x10, 0x11, 0x12, 0x13,
d9737751 565 0x14, 0x22, 0x23
e1f0d669
MR		 566};
567
8bb0ac55 568static hda_nid_t stac92hd83xxx_pin_nids[10] = {
d0513fc6 569 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
8bb0ac55 570 0x0f, 0x10, 0x11, 0x1f, 0x20,
d0513fc6 571};
616f89e7
HRK		 572
573#define STAC92HD71BXX_NUM_PINS 13
574static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
575 0x0a, 0x0b, 0x0c, 0x0d, 0x00,
576 0x00, 0x14, 0x18, 0x19, 0x1e,
577 0x1f, 0x20, 0x27
578};
579static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
e035b841
MR		 580 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
581 0x0f, 0x14, 0x18, 0x19, 0x1e,
616f89e7 582 0x1f, 0x20, 0x27
e035b841
MR		 583};
584
3cc08dc6
MP		 585static hda_nid_t stac927x_pin_nids[14] = {
586 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
587 0x0f, 0x10, 0x11, 0x12, 0x13,
588 0x14, 0x21, 0x22, 0x23,
589};
590
f3302a59
MP		 591static hda_nid_t stac9205_pin_nids[12] = {
592 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
593 0x0f, 0x14, 0x16, 0x17, 0x18,
594 0x21, 0x22,
f3302a59
MP		 595};
596
89385035
MR		 597#define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info
598
599static int stac92xx_amp_volume_get(struct snd_kcontrol *kcontrol,
600 struct snd_ctl_elem_value *ucontrol)
601{
602 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
603 struct sigmatel_spec *spec = codec->spec;
604 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
605
606 kcontrol->private_value ^= get_amp_nid(kcontrol);
607 kcontrol->private_value |= nid;
608
609 return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
610}
611
612static int stac92xx_amp_volume_put(struct snd_kcontrol *kcontrol,
613 struct snd_ctl_elem_value *ucontrol)
614{
615 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
616 struct sigmatel_spec *spec = codec->spec;
617 hda_nid_t nid = spec->amp_nids[spec->cur_amux];
618
619 kcontrol->private_value ^= get_amp_nid(kcontrol);
620 kcontrol->private_value |= nid;
621
622 return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
623}
624
8b65727b
MP		 625static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
626 struct snd_ctl_elem_info *uinfo)
627{
628 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
629 struct sigmatel_spec *spec = codec->spec;
630 return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
631}
632
633static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
634 struct snd_ctl_elem_value *ucontrol)
635{
636 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
637 struct sigmatel_spec *spec = codec->spec;
e1f0d669 638 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
8b65727b 639
e1f0d669 640 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
8b65727b
MP		 641 return 0;
642}
643
644static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
645 struct snd_ctl_elem_value *ucontrol)
646{
647 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
648 struct sigmatel_spec *spec = codec->spec;
e1f0d669 649 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
8b65727b
MP		 650
651 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
e1f0d669 652 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
8b65727b
MP		 653}
654
d9737751
MR		 655static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
656 struct snd_ctl_elem_info *uinfo)
657{
658 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
659 struct sigmatel_spec *spec = codec->spec;
660 return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
661}
662
663static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
664 struct snd_ctl_elem_value *ucontrol)
665{
666 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
667 struct sigmatel_spec *spec = codec->spec;
668 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
669
670 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
671 return 0;
672}
673
674static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
675 struct snd_ctl_elem_value *ucontrol)
676{
677 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
678 struct sigmatel_spec *spec = codec->spec;
00ef50c2 679 struct hda_input_mux *smux = &spec->private_smux;
d9737751 680 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
00ef50c2
MR		 681 int err, val;
682 hda_nid_t nid;
d9737751 683
00ef50c2 684 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
d9737751 685 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
00ef50c2
MR		 686 if (err < 0)
687 return err;
688
689 if (spec->spdif_mute) {
690 if (smux_idx == 0)
691 nid = spec->multiout.dig_out_nid;
692 else
693 nid = codec->slave_dig_outs[smux_idx - 1];
694 if (spec->cur_smux[smux_idx] == smux->num_items - 1)
c9b46f91 695 val = HDA_AMP_MUTE;
00ef50c2 696 else
c9b46f91 697 val = 0;
00ef50c2 698 /* un/mute SPDIF out */
c9b46f91
TI		 699 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
700 HDA_AMP_MUTE, val);
00ef50c2
MR		 701 }
702 return 0;
d9737751
MR		 703}
704
2fc99890
NL		 705static unsigned int stac92xx_vref_set(struct hda_codec *codec,
706 hda_nid_t nid, unsigned int new_vref)
707{
b8621516 708 int error;
2fc99890
NL		 709 unsigned int pincfg;
710 pincfg = snd_hda_codec_read(codec, nid, 0,
711 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
712
713 pincfg &= 0xff;
714 pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
715 pincfg |= new_vref;
716
717 if (new_vref == AC_PINCTL_VREF_HIZ)
718 pincfg |= AC_PINCTL_OUT_EN;
719 else
720 pincfg |= AC_PINCTL_IN_EN;
721
722 error = snd_hda_codec_write_cache(codec, nid, 0,
723 AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
724 if (error < 0)
725 return error;
726 else
727 return 1;
728}
729
730static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
731{
732 unsigned int vref;
733 vref = snd_hda_codec_read(codec, nid, 0,
734 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
735 vref &= AC_PINCTL_VREFEN;
736 return vref;
737}
738
c8b6bf9b 739static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
2f2f4251
M		 740{
741 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
742 struct sigmatel_spec *spec = codec->spec;
c7d4b2fa 743 return snd_hda_input_mux_info(spec->input_mux, uinfo);
2f2f4251
M		 744}
745
c8b6bf9b 746static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2f2f4251
M		 747{
748 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
749 struct sigmatel_spec *spec = codec->spec;
750 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
751
752 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
753 return 0;
754}
755
c8b6bf9b 756static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2f2f4251
M		 757{
758 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
759 struct sigmatel_spec *spec = codec->spec;
760 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5207e10e
TI		 761 const struct hda_input_mux *imux = spec->input_mux;
762 unsigned int idx, prev_idx;
763
764 idx = ucontrol->value.enumerated.item[0];
765 if (idx >= imux->num_items)
766 idx = imux->num_items - 1;
767 prev_idx = spec->cur_mux[adc_idx];
768 if (prev_idx == idx)
769 return 0;
770 if (idx < spec->num_analog_muxes) {
771 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
772 AC_VERB_SET_CONNECT_SEL,
773 imux->items[idx].index);
774 if (prev_idx >= spec->num_analog_muxes) {
775 imux = spec->dinput_mux;
776 /* 0 = analog */
777 snd_hda_codec_write_cache(codec,
778 spec->dmux_nids[adc_idx], 0,
779 AC_VERB_SET_CONNECT_SEL,
780 imux->items[0].index);
781 }
782 } else {
783 imux = spec->dinput_mux;
784 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
785 AC_VERB_SET_CONNECT_SEL,
786 imux->items[idx - 1].index);
787 }
788 spec->cur_mux[adc_idx] = idx;
789 return 1;
2f2f4251
M		 790}
791
b22b4821
MR		 792static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
793 struct snd_ctl_elem_info *uinfo)
794{
795 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
796 struct sigmatel_spec *spec = codec->spec;
797 return snd_hda_input_mux_info(spec->mono_mux, uinfo);
798}
799
800static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
801 struct snd_ctl_elem_value *ucontrol)
802{
803 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
804 struct sigmatel_spec *spec = codec->spec;
805
806 ucontrol->value.enumerated.item[0] = spec->cur_mmux;
807 return 0;
808}
809
810static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
811 struct snd_ctl_elem_value *ucontrol)
812{
813 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
814 struct sigmatel_spec *spec = codec->spec;
815
816 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
817 spec->mono_nid, &spec->cur_mmux);
818}
819
89385035
MR		 820static int stac92xx_amp_mux_enum_info(struct snd_kcontrol *kcontrol,
821 struct snd_ctl_elem_info *uinfo)
822{
823 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
824 struct sigmatel_spec *spec = codec->spec;
825 return snd_hda_input_mux_info(spec->amp_mux, uinfo);
826}
827
828static int stac92xx_amp_mux_enum_get(struct snd_kcontrol *kcontrol,
829 struct snd_ctl_elem_value *ucontrol)
830{
831 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
832 struct sigmatel_spec *spec = codec->spec;
833
834 ucontrol->value.enumerated.item[0] = spec->cur_amux;
835 return 0;
836}
837
838static int stac92xx_amp_mux_enum_put(struct snd_kcontrol *kcontrol,
839 struct snd_ctl_elem_value *ucontrol)
840{
841 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
842 struct sigmatel_spec *spec = codec->spec;
843 struct snd_kcontrol *ctl =
844 snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
845 if (!ctl)
846 return -EINVAL;
847
848 snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
849 SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);
850
851 return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
852 0, &spec->cur_amux);
853}
854
5f10c4a9
ML		 855#define stac92xx_aloopback_info snd_ctl_boolean_mono_info
856
857static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
858 struct snd_ctl_elem_value *ucontrol)
859{
860 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
e1f0d669 861 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5f10c4a9
ML		 862 struct sigmatel_spec *spec = codec->spec;
863
e1f0d669
MR		 864 ucontrol->value.integer.value[0] = !!(spec->aloopback &
865 (spec->aloopback_mask << idx));
5f10c4a9
ML		 866 return 0;
867}
868
869static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
870 struct snd_ctl_elem_value *ucontrol)
871{
872 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
873 struct sigmatel_spec *spec = codec->spec;
e1f0d669 874 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
5f10c4a9 875 unsigned int dac_mode;
e1f0d669 876 unsigned int val, idx_val;
5f10c4a9 877
e1f0d669
MR		 878 idx_val = spec->aloopback_mask << idx;
879 if (ucontrol->value.integer.value[0])
880 val = spec->aloopback | idx_val;
881 else
882 val = spec->aloopback & ~idx_val;
68ea7b2f 883 if (spec->aloopback == val)
5f10c4a9
ML		 884 return 0;
885
68ea7b2f 886 spec->aloopback = val;
5f10c4a9 887
e1f0d669
MR		 888 /* Only return the bits defined by the shift value of the
889 * first two bytes of the mask
890 */
5f10c4a9 891 dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
e1f0d669
MR		 892 kcontrol->private_value & 0xFFFF, 0x0);
893 dac_mode >>= spec->aloopback_shift;
5f10c4a9 894
e1f0d669 895 if (spec->aloopback & idx_val) {
5f10c4a9 896 snd_hda_power_up(codec);
e1f0d669 897 dac_mode |= idx_val;
5f10c4a9
ML		 898 } else {
899 snd_hda_power_down(codec);
e1f0d669 900 dac_mode &= ~idx_val;
5f10c4a9
ML		 901 }
902
903 snd_hda_codec_write_cache(codec, codec->afg, 0,
904 kcontrol->private_value >> 16, dac_mode);
905
906 return 1;
907}
908
c7d4b2fa 909static struct hda_verb stac9200_core_init[] = {
2f2f4251 910 /* set dac0mux for dac converter */
c7d4b2fa 911 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2f2f4251
M		 912 {}
913};
914
1194b5b7
TI		 915static struct hda_verb stac9200_eapd_init[] = {
916 /* set dac0mux for dac converter */
917 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
918 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
919 {}
920};
921
e1f0d669
MR		 922static struct hda_verb stac92hd73xx_6ch_core_init[] = {
923 /* set master volume and direct control */
924 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
e1f0d669
MR		 925 /* setup adcs to point to mixer */
926 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
927 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
e1f0d669
MR		 928 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
929 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
930 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
931 /* setup import muxs */
932 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
933 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
934 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
935 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
936 {}
937};
938
d654a660
MR		 939static struct hda_verb dell_eq_core_init[] = {
940 /* set master volume to max value without distortion
941 * and direct control */
942 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
d654a660
MR		 943 /* setup adcs to point to mixer */
944 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
945 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
946 /* setup import muxs */
947 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
948 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
949 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
950 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
951 {}
952};
953
52fe0f9d 954static struct hda_verb dell_m6_core_init[] = {
6b3ab21e 955 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
52fe0f9d
MR		 956 /* setup adcs to point to mixer */
957 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
958 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
959 /* setup import muxs */
960 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
961 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
962 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
963 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
964 {}
965};
966
e1f0d669
MR		 967static struct hda_verb stac92hd73xx_8ch_core_init[] = {
968 /* set master volume and direct control */
969 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
e1f0d669
MR		 970 /* setup adcs to point to mixer */
971 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
972 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
e1f0d669
MR		 973 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
974 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
975 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
976 /* setup import muxs */
977 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
978 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
979 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
980 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
981 {}
982};
983
984static struct hda_verb stac92hd73xx_10ch_core_init[] = {
985 /* set master volume and direct control */
986 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
e1f0d669
MR		 987 /* dac3 is connected to import3 mux */
988 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
e1f0d669
MR		 989 /* setup adcs to point to mixer */
990 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
991 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
e1f0d669
MR		 992 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
993 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
994 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
995 /* setup import muxs */
996 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
997 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
998 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
999 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
1000 {}
1001};
1002
d0513fc6 1003static struct hda_verb stac92hd83xxx_core_init[] = {
8bb0ac55
MR		 1004 { 0xa, AC_VERB_SET_CONNECT_SEL, 0x1},
1005 { 0xb, AC_VERB_SET_CONNECT_SEL, 0x1},
1006 { 0xd, AC_VERB_SET_CONNECT_SEL, 0x0},
d0513fc6
MR		 1007
1008 /* power state controls amps */
1009 { 0x01, AC_VERB_SET_EAPD, 1 << 2},
574f3c4f 1010 {}
d0513fc6
MR		 1011};
1012
e035b841 1013static struct hda_verb stac92hd71bxx_core_init[] = {
541eee87
MR		 1014 /* set master volume and direct control */
1015 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
574f3c4f 1016 {}
541eee87
MR		 1017};
1018
ca8d33fc
MR		 1019static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
1020 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
1021 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
e035b841
MR		 1022 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1023 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
e035b841
MR		 1024 {}
1025};
1026
8e21c34c
TD		 1027static struct hda_verb stac925x_core_init[] = {
1028 /* set dac0mux for dac converter */
1029 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
c9280d68
TI		 1030 /* mute the master volume */
1031 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8e21c34c
TD		 1032 {}
1033};
1034
c7d4b2fa 1035static struct hda_verb stac922x_core_init[] = {
2f2f4251 1036 /* set master volume and direct control */
c7d4b2fa 1037 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
2f2f4251
M		 1038 {}
1039};
1040
93ed1503 1041static struct hda_verb d965_core_init[] = {
19039bd0 1042 /* set master volume and direct control */
93ed1503 1043 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
19039bd0
TI		 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
3cc08dc6
MP		 1051static struct hda_verb stac927x_core_init[] = {
1052 /* set master volume and direct control */
1053 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
1cd2224c
MR		 1054 /* enable analog pc beep path */
1055 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
3cc08dc6
MP		 1056 {}
1057};
1058
f3302a59
MP		 1059static struct hda_verb stac9205_core_init[] = {
1060 /* set master volume and direct control */
1061 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
d0513fc6
MR		 1062 /* enable analog pc beep path */
1063 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
f3302a59
MP		 1064 {}
1065};
1066
b22b4821
MR		 1067#define STAC_MONO_MUX \
1068 { \
1069 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1070 .name = "Mono Mux", \
1071 .count = 1, \
1072 .info = stac92xx_mono_mux_enum_info, \
1073 .get = stac92xx_mono_mux_enum_get, \
1074 .put = stac92xx_mono_mux_enum_put, \
1075 }
1076
89385035
MR		 1077#define STAC_AMP_MUX \
1078 { \
1079 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1080 .name = "Amp Selector Capture Switch", \
1081 .count = 1, \
1082 .info = stac92xx_amp_mux_enum_info, \
1083 .get = stac92xx_amp_mux_enum_get, \
1084 .put = stac92xx_amp_mux_enum_put, \
1085 }
1086
1087#define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
1088 { \
1089 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1090 .name = xname, \
1091 .index = 0, \
1092 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1093 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1094 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
1095 .info = stac92xx_amp_volume_info, \
1096 .get = stac92xx_amp_volume_get, \
1097 .put = stac92xx_amp_volume_put, \
1098 .tlv = { .c = snd_hda_mixer_amp_tlv }, \
1099 .private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
1100 }
1101
e1f0d669 1102#define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
5f10c4a9
ML		 1103 { \
1104 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1105 .name = "Analog Loopback", \
e1f0d669 1106 .count = cnt, \
5f10c4a9
ML		 1107 .info = stac92xx_aloopback_info, \
1108 .get = stac92xx_aloopback_get, \
1109 .put = stac92xx_aloopback_put, \
1110 .private_value = verb_read | (verb_write << 16), \
1111 }
1112
2fc99890
NL		 1113#define DC_BIAS(xname, idx, nid) \
1114 { \
1115 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1116 .name = xname, \
1117 .index = idx, \
1118 .info = stac92xx_dc_bias_info, \
1119 .get = stac92xx_dc_bias_get, \
1120 .put = stac92xx_dc_bias_put, \
1121 .private_value = nid, \
1122 }
1123
c8b6bf9b 1124static struct snd_kcontrol_new stac9200_mixer[] = {
2f2f4251
M		 1125 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
1126 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
2f2f4251
M		 1127 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
1128 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
2f2f4251
M		 1129 { } /* end */
1130};
1131
2a9c7816 1132#define DELL_M6_MIXER 6
e1f0d669 1133static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
2a9c7816 1134 /* start of config #1 */
e1f0d669
MR		 1135 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1136 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1137
e1f0d669
MR		 1138 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1139 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1140
2a9c7816
MR		 1141 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1142 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1143
1144 /* start of config #2 */
1145 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1146 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1147
e1f0d669
MR		 1148 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1149 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1150
e1f0d669
MR		 1151 { } /* end */
1152};
1153
d78d7a90
TI		 1154static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
1155 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
1156 {}
1157};
1158
1159static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
e1f0d669 1160 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
d78d7a90
TI		 1161 {}
1162};
e1f0d669 1163
d78d7a90
TI		 1164static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1165 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1166 {}
1167};
1168
1169static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
e1f0d669
MR		 1170 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1171 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1172
1173 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1174 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1175
1176 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1177 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1178
1179 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1180 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1181
1182 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1183 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1184 { } /* end */
1185};
1186
1187static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
e1f0d669
MR		 1188 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
1189 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),
1190
1191 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
1192 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),
1193
1194 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
1195 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),
1196
1197 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
1198 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),
1199
1200 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
1201 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
1202 { } /* end */
1203};
1204
d0513fc6 1205
d78d7a90
TI		 1206static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1207 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1208};
541eee87 1209
8e21c34c 1210static struct snd_kcontrol_new stac925x_mixer[] = {
c9280d68
TI		 1211 HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
1212 HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
2f2f4251
M		 1213 { } /* end */
1214};
1215
d78d7a90
TI		 1216static struct snd_kcontrol_new stac9205_loopback[] = {
1217 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1218 {}
1219};
1220
d78d7a90
TI		 1221static struct snd_kcontrol_new stac927x_loopback[] = {
1222 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1223 {}
1224};
1225
1697055e
TI		 1226static struct snd_kcontrol_new stac_dmux_mixer = {
1227 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1228 .name = "Digital Input Source",
1229 /* count set later */
1230 .info = stac92xx_dmux_enum_info,
1231 .get = stac92xx_dmux_enum_get,
1232 .put = stac92xx_dmux_enum_put,
1233};
1234
d9737751
MR		 1235static struct snd_kcontrol_new stac_smux_mixer = {
1236 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
e3487970 1237 .name = "IEC958 Playback Source",
d9737751
MR		 1238 /* count set later */
1239 .info = stac92xx_smux_enum_info,
1240 .get = stac92xx_smux_enum_get,
1241 .put = stac92xx_smux_enum_put,
1242};
1243
2134ea4f
TI		 1244static const char *slave_vols[] = {
1245 "Front Playback Volume",
1246 "Surround Playback Volume",
1247 "Center Playback Volume",
1248 "LFE Playback Volume",
1249 "Side Playback Volume",
1250 "Headphone Playback Volume",
2134ea4f 1251 "Speaker Playback Volume",
2134ea4f
TI		 1252 NULL
1253};
1254
1255static const char *slave_sws[] = {
1256 "Front Playback Switch",
1257 "Surround Playback Switch",
1258 "Center Playback Switch",
1259 "LFE Playback Switch",
1260 "Side Playback Switch",
1261 "Headphone Playback Switch",
2134ea4f 1262 "Speaker Playback Switch",
edb54a55 1263 "IEC958 Playback Switch",
2134ea4f
TI		 1264 NULL
1265};
1266
603c4019 1267static void stac92xx_free_kctls(struct hda_codec *codec);
e4973e1e 1268static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
603c4019 1269
2f2f4251
M		 1270static int stac92xx_build_controls(struct hda_codec *codec)
1271{
1272 struct sigmatel_spec *spec = codec->spec;
e4973e1e
TI		 1273 struct auto_pin_cfg *cfg = &spec->autocfg;
1274 hda_nid_t nid;
2f2f4251 1275 int err;
c7d4b2fa 1276 int i;
2f2f4251 1277
6479c631
TI		 1278 if (spec->mixer) {
1279 err = snd_hda_add_new_ctls(codec, spec->mixer);
1280 if (err < 0)
1281 return err;
1282 }
c7d4b2fa
M		 1283
1284 for (i = 0; i < spec->num_mixers; i++) {
1285 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1286 if (err < 0)
1287 return err;
1288 }
5207e10e
TI		 1289 if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1290 snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1697055e 1291 stac_dmux_mixer.count = spec->num_dmuxes;
d13bd412 1292 err = snd_hda_ctl_add(codec,
1697055e
TI		 1293 snd_ctl_new1(&stac_dmux_mixer, codec));
1294 if (err < 0)
1295 return err;
1296 }
d9737751 1297 if (spec->num_smuxes > 0) {
00ef50c2
MR		 1298 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1299 struct hda_input_mux *smux = &spec->private_smux;
1300 /* check for mute support on SPDIF out */
1301 if (wcaps & AC_WCAP_OUT_AMP) {
1302 smux->items[smux->num_items].label = "Off";
1303 smux->items[smux->num_items].index = 0;
1304 smux->num_items++;
1305 spec->spdif_mute = 1;
1306 }
d9737751 1307 stac_smux_mixer.count = spec->num_smuxes;
4f2d23e1 1308 err = snd_hda_ctl_add(codec,
d9737751
MR		 1309 snd_ctl_new1(&stac_smux_mixer, codec));
1310 if (err < 0)
1311 return err;
1312 }
c7d4b2fa 1313
dabbed6f
M		 1314 if (spec->multiout.dig_out_nid) {
1315 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1316 if (err < 0)
1317 return err;
9a08160b
TI		 1318 err = snd_hda_create_spdif_share_sw(codec,
1319 &spec->multiout);
1320 if (err < 0)
1321 return err;
1322 spec->multiout.share_spdif = 1;
dabbed6f 1323 }
da74ae3e 1324 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
dabbed6f
M		 1325 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1326 if (err < 0)
1327 return err;
1328 }
2134ea4f
TI		 1329
1330 /* if we have no master control, let's create it */
1331 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1c82ed1b 1332 unsigned int vmaster_tlv[4];
2134ea4f 1333 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1c82ed1b 1334 HDA_OUTPUT, vmaster_tlv);
7c7767eb
TI		 1335 /* correct volume offset */
1336 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
2134ea4f 1337 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1c82ed1b 1338 vmaster_tlv, slave_vols);
2134ea4f
TI		 1339 if (err < 0)
1340 return err;
1341 }
1342 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1343 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1344 NULL, slave_sws);
1345 if (err < 0)
1346 return err;
1347 }
1348
d78d7a90
TI		 1349 if (spec->aloopback_ctl &&
1350 snd_hda_get_bool_hint(codec, "loopback") == 1) {
1351 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1352 if (err < 0)
1353 return err;
1354 }
1355
603c4019 1356 stac92xx_free_kctls(codec); /* no longer needed */
e4973e1e
TI		 1357
1358 /* create jack input elements */
1359 if (spec->hp_detect) {
1360 for (i = 0; i < cfg->hp_outs; i++) {
1361 int type = SND_JACK_HEADPHONE;
1362 nid = cfg->hp_pins[i];
1363 /* jack detection */
1364 if (cfg->hp_outs == i)
1365 type |= SND_JACK_LINEOUT;
1366 err = stac92xx_add_jack(codec, nid, type);
1367 if (err < 0)
1368 return err;
1369 }
1370 }
1371 for (i = 0; i < cfg->line_outs; i++) {
1372 err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1373 SND_JACK_LINEOUT);
1374 if (err < 0)
1375 return err;
1376 }
1377 for (i = 0; i < AUTO_PIN_LAST; i++) {
1378 nid = cfg->input_pins[i];
1379 if (nid) {
1380 err = stac92xx_add_jack(codec, nid,
1381 SND_JACK_MICROPHONE);
1382 if (err < 0)
1383 return err;
1384 }
1385 }
1386
dabbed6f 1387 return 0;
2f2f4251
M		 1388}
1389
403d1944 1390static unsigned int ref9200_pin_configs[8] = {
dabbed6f 1391 0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
2f2f4251
M		 1392 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1393};
1394
58eec423
MCC		 1395static unsigned int gateway9200_m4_pin_configs[8] = {
1396 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1397 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1398};
1399static unsigned int gateway9200_m4_2_pin_configs[8] = {
1400 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1401 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1402};
1403
1404/*
dfe495d0
TI		 1405 STAC 9200 pin configs for
1406 102801A8
1407 102801DE
1408 102801E8
1409*/
1410static unsigned int dell9200_d21_pin_configs[8] = {
af6c016e
TI		 1411 0x400001f0, 0x400001f1, 0x02214030, 0x01014010,
1412 0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
dfe495d0
TI		 1413};
1414
1415/*
1416 STAC 9200 pin configs for
1417 102801C0
1418 102801C1
1419*/
1420static unsigned int dell9200_d22_pin_configs[8] = {
af6c016e
TI		 1421 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1422 0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
dfe495d0
TI		 1423};
1424
1425/*
1426 STAC 9200 pin configs for
1427 102801C4 (Dell Dimension E310)
1428 102801C5
1429 102801C7
1430 102801D9
1431 102801DA
1432 102801E3
1433*/
1434static unsigned int dell9200_d23_pin_configs[8] = {
af6c016e
TI		 1435 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010,
1436 0x01813020, 0x01a19021, 0x90100140, 0x400001f2,
dfe495d0
TI		 1437};
1438
1439
1440/*
1441 STAC 9200-32 pin configs for
1442 102801B5 (Dell Inspiron 630m)
1443 102801D8 (Dell Inspiron 640m)
1444*/
1445static unsigned int dell9200_m21_pin_configs[8] = {
af6c016e
TI		 1446 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1447 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
dfe495d0
TI		 1448};
1449
1450/*
1451 STAC 9200-32 pin configs for
1452 102801C2 (Dell Latitude D620)
1453 102801C8
1454 102801CC (Dell Latitude D820)
1455 102801D4
1456 102801D6
1457*/
1458static unsigned int dell9200_m22_pin_configs[8] = {
af6c016e
TI		 1459 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310,
1460 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
dfe495d0
TI		 1461};
1462
1463/*
1464 STAC 9200-32 pin configs for
1465 102801CE (Dell XPS M1710)
1466 102801CF (Dell Precision M90)
1467*/
1468static unsigned int dell9200_m23_pin_configs[8] = {
1469 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1470 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1471};
1472
1473/*
1474 STAC 9200-32 pin configs for
1475 102801C9
1476 102801CA
1477 102801CB (Dell Latitude 120L)
1478 102801D3
1479*/
1480static unsigned int dell9200_m24_pin_configs[8] = {
af6c016e
TI		 1481 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310,
1482 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe,
dfe495d0
TI		 1483};
1484
1485/*
1486 STAC 9200-32 pin configs for
1487 102801BD (Dell Inspiron E1505n)
1488 102801EE
1489 102801EF
1490*/
1491static unsigned int dell9200_m25_pin_configs[8] = {
af6c016e
TI		 1492 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1493 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
dfe495d0
TI		 1494};
1495
1496/*
1497 STAC 9200-32 pin configs for
1498 102801F5 (Dell Inspiron 1501)
1499 102801F6
1500*/
1501static unsigned int dell9200_m26_pin_configs[8] = {
af6c016e
TI		 1502 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310,
1503 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
dfe495d0
TI		 1504};
1505
1506/*
1507 STAC 9200-32
1508 102801CD (Dell Inspiron E1705/9400)
1509*/
1510static unsigned int dell9200_m27_pin_configs[8] = {
af6c016e
TI		 1511 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1512 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
dfe495d0
TI		 1513};
1514
bf277785
TD		 1515static unsigned int oqo9200_pin_configs[8] = {
1516 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1517 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1518};
1519
dfe495d0 1520
f5fcc13c
TI		 1521static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1522 [STAC_REF] = ref9200_pin_configs,
bf277785 1523 [STAC_9200_OQO] = oqo9200_pin_configs,
dfe495d0
TI		 1524 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1525 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1526 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1527 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1528 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1529 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1530 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1531 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1532 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1533 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
58eec423
MCC		 1534 [STAC_9200_M4] = gateway9200_m4_pin_configs,
1535 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
117f257d 1536 [STAC_9200_PANASONIC] = ref9200_pin_configs,
403d1944
MP		 1537};
1538
f5fcc13c 1539static const char *stac9200_models[STAC_9200_MODELS] = {
1607b8ea 1540 [STAC_AUTO] = "auto",
f5fcc13c 1541 [STAC_REF] = "ref",
bf277785 1542 [STAC_9200_OQO] = "oqo",
dfe495d0
TI		 1543 [STAC_9200_DELL_D21] = "dell-d21",
1544 [STAC_9200_DELL_D22] = "dell-d22",
1545 [STAC_9200_DELL_D23] = "dell-d23",
1546 [STAC_9200_DELL_M21] = "dell-m21",
1547 [STAC_9200_DELL_M22] = "dell-m22",
1548 [STAC_9200_DELL_M23] = "dell-m23",
1549 [STAC_9200_DELL_M24] = "dell-m24",
1550 [STAC_9200_DELL_M25] = "dell-m25",
1551 [STAC_9200_DELL_M26] = "dell-m26",
1552 [STAC_9200_DELL_M27] = "dell-m27",
58eec423
MCC		 1553 [STAC_9200_M4] = "gateway-m4",
1554 [STAC_9200_M4_2] = "gateway-m4-2",
117f257d 1555 [STAC_9200_PANASONIC] = "panasonic",
f5fcc13c
TI		 1556};
1557
1558static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1559 /* SigmaTel reference board */
1560 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1561 "DFI LanParty", STAC_REF),
577aa2c1
MR		 1562 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1563 "DFI LanParty", STAC_REF),
e7377071 1564 /* Dell laptops have BIOS problem */
dfe495d0
TI		 1565 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1566 "unknown Dell", STAC_9200_DELL_D21),
f5fcc13c 1567 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
dfe495d0
TI		 1568 "Dell Inspiron 630m", STAC_9200_DELL_M21),
1569 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1570 "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1571 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1572 "unknown Dell", STAC_9200_DELL_D22),
1573 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1574 "unknown Dell", STAC_9200_DELL_D22),
f5fcc13c 1575 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
dfe495d0
TI		 1576 "Dell Latitude D620", STAC_9200_DELL_M22),
1577 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1578 "unknown Dell", STAC_9200_DELL_D23),
1579 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1580 "unknown Dell", STAC_9200_DELL_D23),
1581 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1582 "unknown Dell", STAC_9200_DELL_M22),
1583 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1584 "unknown Dell", STAC_9200_DELL_M24),
1585 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1586 "unknown Dell", STAC_9200_DELL_M24),
f5fcc13c 1587 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
dfe495d0 1588 "Dell Latitude 120L", STAC_9200_DELL_M24),
877b866d 1589 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
dfe495d0 1590 "Dell Latitude D820", STAC_9200_DELL_M22),
46f02ca3 1591 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
dfe495d0 1592 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
46f02ca3 1593 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
dfe495d0 1594 "Dell XPS M1710", STAC_9200_DELL_M23),
f0f96745 1595 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
dfe495d0
TI		 1596 "Dell Precision M90", STAC_9200_DELL_M23),
1597 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1598 "unknown Dell", STAC_9200_DELL_M22),
1599 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1600 "unknown Dell", STAC_9200_DELL_M22),
8286c53e 1601 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
dfe495d0 1602 "unknown Dell", STAC_9200_DELL_M22),
49c605db 1603 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
dfe495d0
TI		 1604 "Dell Inspiron 640m", STAC_9200_DELL_M21),
1605 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1606 "unknown Dell", STAC_9200_DELL_D23),
1607 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1608 "unknown Dell", STAC_9200_DELL_D23),
1609 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1610 "unknown Dell", STAC_9200_DELL_D21),
1611 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1612 "unknown Dell", STAC_9200_DELL_D23),
1613 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1614 "unknown Dell", STAC_9200_DELL_D21),
1615 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1616 "unknown Dell", STAC_9200_DELL_M25),
1617 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1618 "unknown Dell", STAC_9200_DELL_M25),
49c605db 1619 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
dfe495d0
TI		 1620 "Dell Inspiron 1501", STAC_9200_DELL_M26),
1621 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1622 "unknown Dell", STAC_9200_DELL_M26),
49c605db 1623 /* Panasonic */
117f257d 1624 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1194b5b7 1625 /* Gateway machines needs EAPD to be set on resume */
58eec423
MCC		 1626 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1627 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1628 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
bf277785
TD		 1629 /* OQO Mobile */
1630 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
403d1944
MP		 1631 {} /* terminator */
1632};
1633
8e21c34c
TD		 1634static unsigned int ref925x_pin_configs[8] = {
1635 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
09a99959 1636 0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
8e21c34c
TD		 1637};
1638
9cb36c2a
MCC		 1639static unsigned int stac925xM1_pin_configs[8] = {
1640 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1641 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
8e21c34c
TD		 1642};
1643
9cb36c2a
MCC		 1644static unsigned int stac925xM1_2_pin_configs[8] = {
1645 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1646 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1647};
58eec423 1648
9cb36c2a
MCC		 1649static unsigned int stac925xM2_pin_configs[8] = {
1650 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1651 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
2c11f955
TD		 1652};
1653
8e21c34c 1654static unsigned int stac925xM2_2_pin_configs[8] = {
58eec423
MCC		 1655 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1656 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1657};
1658
9cb36c2a
MCC		 1659static unsigned int stac925xM3_pin_configs[8] = {
1660 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1661 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1662};
58eec423 1663
9cb36c2a
MCC		 1664static unsigned int stac925xM5_pin_configs[8] = {
1665 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1666 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1667};
1668
9cb36c2a
MCC		 1669static unsigned int stac925xM6_pin_configs[8] = {
1670 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1671 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
8e21c34c
TD		 1672};
1673
1674static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1675 [STAC_REF] = ref925x_pin_configs,
9cb36c2a
MCC		 1676 [STAC_M1] = stac925xM1_pin_configs,
1677 [STAC_M1_2] = stac925xM1_2_pin_configs,
1678 [STAC_M2] = stac925xM2_pin_configs,
8e21c34c 1679 [STAC_M2_2] = stac925xM2_2_pin_configs,
9cb36c2a
MCC		 1680 [STAC_M3] = stac925xM3_pin_configs,
1681 [STAC_M5] = stac925xM5_pin_configs,
1682 [STAC_M6] = stac925xM6_pin_configs,
8e21c34c
TD		 1683};
1684
1685static const char *stac925x_models[STAC_925x_MODELS] = {
1607b8ea 1686 [STAC_925x_AUTO] = "auto",
8e21c34c 1687 [STAC_REF] = "ref",
9cb36c2a
MCC		 1688 [STAC_M1] = "m1",
1689 [STAC_M1_2] = "m1-2",
1690 [STAC_M2] = "m2",
8e21c34c 1691 [STAC_M2_2] = "m2-2",
9cb36c2a
MCC		 1692 [STAC_M3] = "m3",
1693 [STAC_M5] = "m5",
1694 [STAC_M6] = "m6",
8e21c34c
TD		 1695};
1696
9cb36c2a 1697static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
58eec423
MCC		 1698 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1699 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1700 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1701 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
9cb36c2a 1702 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
9cb36c2a
MCC		 1703 /* Not sure about the brand name for those */
1704 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1705 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1706 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1707 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
9cb36c2a 1708 {} /* terminator */
8e21c34c
TD		 1709};
1710
1711static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1712 /* SigmaTel reference board */
1713 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
577aa2c1 1714 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
2c11f955 1715 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
9cb36c2a
MCC		 1716
1717 /* Default table for unknown ID */
1718 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1719
8e21c34c
TD		 1720 {} /* terminator */
1721};
1722
a7662640 1723static unsigned int ref92hd73xx_pin_configs[13] = {
e1f0d669
MR		 1724 0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1725 0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1726 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
a7662640
MR		 1727 0x01452050,
1728};
1729
1730static unsigned int dell_m6_pin_configs[13] = {
1731 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
7c2ba97b 1732 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
a7662640
MR		 1733 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1734 0x4f0000f0,
e1f0d669
MR		 1735};
1736
1737static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
a7662640 1738 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs,
661cd8fb
TI		 1739 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs,
1740 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs,
1741 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs,
6b3ab21e 1742 [STAC_DELL_EQ] = dell_m6_pin_configs,
e1f0d669
MR		 1743};
1744
1745static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1607b8ea 1746 [STAC_92HD73XX_AUTO] = "auto",
9e43f0de 1747 [STAC_92HD73XX_NO_JD] = "no-jd",
e1f0d669 1748 [STAC_92HD73XX_REF] = "ref",
661cd8fb
TI		 1749 [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1750 [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1751 [STAC_DELL_M6_BOTH] = "dell-m6",
6b3ab21e 1752 [STAC_DELL_EQ] = "dell-eq",
e1f0d669
MR		 1753};
1754
1755static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1756 /* SigmaTel reference board */
1757 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
a7662640 1758 "DFI LanParty", STAC_92HD73XX_REF),
577aa2c1
MR		 1759 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1760 "DFI LanParty", STAC_92HD73XX_REF),
a7662640 1761 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
661cd8fb 1762 "Dell Studio 1535", STAC_DELL_M6_DMIC),
a7662640 1763 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
661cd8fb 1764 "unknown Dell", STAC_DELL_M6_DMIC),
a7662640 1765 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
661cd8fb 1766 "unknown Dell", STAC_DELL_M6_BOTH),
a7662640 1767 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
661cd8fb 1768 "unknown Dell", STAC_DELL_M6_BOTH),
a7662640 1769 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
661cd8fb 1770 "unknown Dell", STAC_DELL_M6_AMIC),
a7662640 1771 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
661cd8fb 1772 "unknown Dell", STAC_DELL_M6_AMIC),
a7662640 1773 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
661cd8fb
TI		 1774 "unknown Dell", STAC_DELL_M6_DMIC),
1775 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1776 "unknown Dell", STAC_DELL_M6_DMIC),
b0fc5e04 1777 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
661cd8fb 1778 "Dell Studio 1537", STAC_DELL_M6_DMIC),
fa620e97
JS		 1779 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1780 "Dell Studio 17", STAC_DELL_M6_DMIC),
626f5cef
TI		 1781 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1782 "Dell Studio 1555", STAC_DELL_M6_DMIC),
e1f0d669
MR		 1783 {} /* terminator */
1784};
1785
8bb0ac55 1786static unsigned int ref92hd83xxx_pin_configs[10] = {
d0513fc6
MR		 1787 0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1788 0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
d0513fc6
MR		 1789 0x01451160, 0x98560170,
1790};
1791
8bb0ac55
MR		 1792static unsigned int dell_s14_pin_configs[10] = {
1793 0x02214030, 0x02211010, 0x02a19020, 0x01014050,
1794 0x40f000f0, 0x01819040, 0x40f000f0, 0x90a60160,
1795 0x40f000f0, 0x40f000f0,
1796};
1797
d0513fc6
MR		 1798static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1799 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
32ed3f46 1800 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
8bb0ac55 1801 [STAC_DELL_S14] = dell_s14_pin_configs,
d0513fc6
MR		 1802};
1803
1804static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1607b8ea 1805 [STAC_92HD83XXX_AUTO] = "auto",
d0513fc6 1806 [STAC_92HD83XXX_REF] = "ref",
32ed3f46 1807 [STAC_92HD83XXX_PWR_REF] = "mic-ref",
8bb0ac55 1808 [STAC_DELL_S14] = "dell-s14",
d0513fc6
MR		 1809};
1810
1811static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1812 /* SigmaTel reference board */
1813 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
f9d088b2 1814 "DFI LanParty", STAC_92HD83XXX_REF),
577aa2c1
MR		 1815 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1816 "DFI LanParty", STAC_92HD83XXX_REF),
8bb0ac55
MR		 1817 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1818 "unknown Dell", STAC_DELL_S14),
574f3c4f 1819 {} /* terminator */
d0513fc6
MR		 1820};
1821
616f89e7 1822static unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
e035b841 1823 0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
4b33c767 1824 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
616f89e7
HRK		 1825 0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1826 0x00000000
e035b841
MR		 1827};
1828
616f89e7 1829static unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
a7662640 1830 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
07bcb316 1831 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
616f89e7
HRK		 1832 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1833 0x00000000
a7662640
MR		 1834};
1835
616f89e7 1836static unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
a7662640
MR		 1837 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1838 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
616f89e7
HRK		 1839 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1840 0x00000000
a7662640
MR		 1841};
1842
616f89e7 1843static unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
3a7abfd2
MR		 1844 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1845 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
616f89e7
HRK		 1846 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1847 0x00000000
3a7abfd2
MR		 1848};
1849
e035b841
MR		 1850static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1851 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
a7662640
MR		 1852 [STAC_DELL_M4_1] = dell_m4_1_pin_configs,
1853 [STAC_DELL_M4_2] = dell_m4_2_pin_configs,
3a7abfd2 1854 [STAC_DELL_M4_3] = dell_m4_3_pin_configs,
6a14f585 1855 [STAC_HP_M4] = NULL,
1b0652eb 1856 [STAC_HP_DV5] = NULL,
ae6241fb 1857 [STAC_HP_HDX] = NULL,
514bf54c 1858 [STAC_HP_DV4_1222NR] = NULL,
e035b841
MR		 1859};
1860
1861static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1607b8ea 1862 [STAC_92HD71BXX_AUTO] = "auto",
e035b841 1863 [STAC_92HD71BXX_REF] = "ref",
a7662640
MR		 1864 [STAC_DELL_M4_1] = "dell-m4-1",
1865 [STAC_DELL_M4_2] = "dell-m4-2",
3a7abfd2 1866 [STAC_DELL_M4_3] = "dell-m4-3",
6a14f585 1867 [STAC_HP_M4] = "hp-m4",
1b0652eb 1868 [STAC_HP_DV5] = "hp-dv5",
ae6241fb 1869 [STAC_HP_HDX] = "hp-hdx",
514bf54c 1870 [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
e035b841
MR		 1871};
1872
1873static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1874 /* SigmaTel reference board */
1875 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1876 "DFI LanParty", STAC_92HD71BXX_REF),
577aa2c1
MR		 1877 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1878 "DFI LanParty", STAC_92HD71BXX_REF),
514bf54c
JG		 1879 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1880 "HP dv4-1222nr", STAC_HP_DV4_1222NR),
58d8395b
TI		 1881 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1882 "HP", STAC_HP_DV5),
2ae466f8
TI		 1883 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1884 "HP dv4-7", STAC_HP_DV5),
1885 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1886 "HP dv4-7", STAC_HP_DV5),
6fce61ae
TI		 1887 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1888 "HP HDX", STAC_HP_HDX), /* HDX18 */
9a9e2359 1889 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
2ae466f8 1890 "HP mini 1000", STAC_HP_M4),
ae6241fb 1891 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
6fce61ae 1892 "HP HDX", STAC_HP_HDX), /* HDX16 */
1972d025
TI		 1893 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1894 "HP", STAC_HP_DV5),
a7662640
MR		 1895 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1896 "unknown Dell", STAC_DELL_M4_1),
1897 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1898 "unknown Dell", STAC_DELL_M4_1),
1899 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1900 "unknown Dell", STAC_DELL_M4_1),
1901 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1902 "unknown Dell", STAC_DELL_M4_1),
1903 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1904 "unknown Dell", STAC_DELL_M4_1),
1905 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1906 "unknown Dell", STAC_DELL_M4_1),
1907 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1908 "unknown Dell", STAC_DELL_M4_1),
1909 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1910 "unknown Dell", STAC_DELL_M4_2),
1911 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1912 "unknown Dell", STAC_DELL_M4_2),
1913 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1914 "unknown Dell", STAC_DELL_M4_2),
1915 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1916 "unknown Dell", STAC_DELL_M4_2),
3a7abfd2
MR		 1917 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1918 "unknown Dell", STAC_DELL_M4_3),
e035b841
MR		 1919 {} /* terminator */
1920};
1921
403d1944
MP		 1922static unsigned int ref922x_pin_configs[10] = {
1923 0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1924 0x01813122, 0x01011014, 0x01441030, 0x01c41030,
2f2f4251
M		 1925 0x40000100, 0x40000100,
1926};
1927
dfe495d0
TI		 1928/*
1929 STAC 922X pin configs for
1930 102801A7
1931 102801AB
1932 102801A9
1933 102801D1
1934 102801D2
1935*/
1936static unsigned int dell_922x_d81_pin_configs[10] = {
1937 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1938 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1939 0x01813122, 0x400001f2,
1940};
1941
1942/*
1943 STAC 922X pin configs for
1944 102801AC
1945 102801D0
1946*/
1947static unsigned int dell_922x_d82_pin_configs[10] = {
1948 0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1949 0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1950 0x01813122, 0x400001f1,
1951};
1952
1953/*
1954 STAC 922X pin configs for
1955 102801BF
1956*/
1957static unsigned int dell_922x_m81_pin_configs[10] = {
1958 0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1959 0x03a11050, 0x01116221, 0x90a70330, 0x01452340,
1960 0x40C003f1, 0x405003f0,
1961};
1962
1963/*
1964 STAC 9221 A1 pin configs for
1965 102801D7 (Dell XPS M1210)
1966*/
1967static unsigned int dell_922x_m82_pin_configs[10] = {
7f9310c1
JZ		 1968 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310,
1969 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2,
dfe495d0
TI		 1970 0x508003f3, 0x405003f4,
1971};
1972
403d1944 1973static unsigned int d945gtp3_pin_configs[10] = {
869264c4 1974 0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
403d1944
MP		 1975 0x40000100, 0x40000100, 0x40000100, 0x40000100,
1976 0x02a19120, 0x40000100,
1977};
1978
1979static unsigned int d945gtp5_pin_configs[10] = {
869264c4
MP		 1980 0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1981 0x01a19021, 0x01016011, 0x01452130, 0x40000100,
403d1944
MP		 1982 0x02a19320, 0x40000100,
1983};
1984
5d5d3bc3
IZ		 1985static unsigned int intel_mac_v1_pin_configs[10] = {
1986 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1987 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1988 0x400000fc, 0x400000fb,
1989};
1990
1991static unsigned int intel_mac_v2_pin_configs[10] = {
1992 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1993 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1994 0x400000fc, 0x400000fb,
6f0778d8
NB		 1995};
1996
5d5d3bc3
IZ		 1997static unsigned int intel_mac_v3_pin_configs[10] = {
1998 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1999 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
3fc24d85
TI		 2000 0x400000fc, 0x400000fb,
2001};
2002
5d5d3bc3
IZ		 2003static unsigned int intel_mac_v4_pin_configs[10] = {
2004 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
2005 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
f16928fb
SF		 2006 0x400000fc, 0x400000fb,
2007};
2008
5d5d3bc3
IZ		 2009static unsigned int intel_mac_v5_pin_configs[10] = {
2010 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
2011 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
2012 0x400000fc, 0x400000fb,
0dae0f83
TI		 2013};
2014
8c650087
MCC		 2015static unsigned int ecs202_pin_configs[10] = {
2016 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
2017 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
2018 0x9037012e, 0x40e000f2,
2019};
76c08828 2020
19039bd0 2021static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
f5fcc13c 2022 [STAC_D945_REF] = ref922x_pin_configs,
19039bd0
TI		 2023 [STAC_D945GTP3] = d945gtp3_pin_configs,
2024 [STAC_D945GTP5] = d945gtp5_pin_configs,
5d5d3bc3
IZ		 2025 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
2026 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
2027 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
2028 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
2029 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
536319af 2030 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
dfe495d0 2031 /* for backward compatibility */
5d5d3bc3
IZ		 2032 [STAC_MACMINI] = intel_mac_v3_pin_configs,
2033 [STAC_MACBOOK] = intel_mac_v5_pin_configs,
2034 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
2035 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
2036 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
2037 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
8c650087 2038 [STAC_ECS_202] = ecs202_pin_configs,
dfe495d0
TI		 2039 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
2040 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,
2041 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
2042 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,
403d1944
MP		 2043};
2044
f5fcc13c 2045static const char *stac922x_models[STAC_922X_MODELS] = {
1607b8ea 2046 [STAC_922X_AUTO] = "auto",
f5fcc13c
TI		 2047 [STAC_D945_REF] = "ref",
2048 [STAC_D945GTP5] = "5stack",
2049 [STAC_D945GTP3] = "3stack",
5d5d3bc3
IZ		 2050 [STAC_INTEL_MAC_V1] = "intel-mac-v1",
2051 [STAC_INTEL_MAC_V2] = "intel-mac-v2",
2052 [STAC_INTEL_MAC_V3] = "intel-mac-v3",
2053 [STAC_INTEL_MAC_V4] = "intel-mac-v4",
2054 [STAC_INTEL_MAC_V5] = "intel-mac-v5",
536319af 2055 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
dfe495d0 2056 /* for backward compatibility */
f5fcc13c 2057 [STAC_MACMINI] = "macmini",
3fc24d85 2058 [STAC_MACBOOK] = "macbook",
6f0778d8
NB		 2059 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1",
2060 [STAC_MACBOOK_PRO_V2] = "macbook-pro",
f16928fb 2061 [STAC_IMAC_INTEL] = "imac-intel",
0dae0f83 2062 [STAC_IMAC_INTEL_20] = "imac-intel-20",
8c650087 2063 [STAC_ECS_202] = "ecs202",
dfe495d0
TI		 2064 [STAC_922X_DELL_D81] = "dell-d81",
2065 [STAC_922X_DELL_D82] = "dell-d82",
2066 [STAC_922X_DELL_M81] = "dell-m81",
2067 [STAC_922X_DELL_M82] = "dell-m82",
f5fcc13c
TI		 2068};
2069
2070static struct snd_pci_quirk stac922x_cfg_tbl[] = {
2071 /* SigmaTel reference board */
2072 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2073 "DFI LanParty", STAC_D945_REF),
577aa2c1
MR		 2074 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2075 "DFI LanParty", STAC_D945_REF),
f5fcc13c
TI		 2076 /* Intel 945G based systems */
2077 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
2078 "Intel D945G", STAC_D945GTP3),
2079 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
2080 "Intel D945G", STAC_D945GTP3),
2081 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
2082 "Intel D945G", STAC_D945GTP3),
2083 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
2084 "Intel D945G", STAC_D945GTP3),
2085 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
2086 "Intel D945G", STAC_D945GTP3),
2087 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
2088 "Intel D945G", STAC_D945GTP3),
2089 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
2090 "Intel D945G", STAC_D945GTP3),
2091 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
2092 "Intel D945G", STAC_D945GTP3),
2093 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
2094 "Intel D945G", STAC_D945GTP3),
2095 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
2096 "Intel D945G", STAC_D945GTP3),
2097 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
2098 "Intel D945G", STAC_D945GTP3),
2099 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
2100 "Intel D945G", STAC_D945GTP3),
2101 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
2102 "Intel D945G", STAC_D945GTP3),
2103 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
2104 "Intel D945G", STAC_D945GTP3),
2105 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
2106 "Intel D945G", STAC_D945GTP3),
2107 /* Intel D945G 5-stack systems */
2108 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
2109 "Intel D945G", STAC_D945GTP5),
2110 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
2111 "Intel D945G", STAC_D945GTP5),
2112 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
2113 "Intel D945G", STAC_D945GTP5),
2114 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
2115 "Intel D945G", STAC_D945GTP5),
2116 /* Intel 945P based systems */
2117 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
2118 "Intel D945P", STAC_D945GTP3),
2119 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
2120 "Intel D945P", STAC_D945GTP3),
2121 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
2122 "Intel D945P", STAC_D945GTP3),
2123 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
2124 "Intel D945P", STAC_D945GTP3),
2125 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
2126 "Intel D945P", STAC_D945GTP3),
2127 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
2128 "Intel D945P", STAC_D945GTP5),
8056d47e
TI		 2129 /* other intel */
2130 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
2131 "Intel D945", STAC_D945_REF),
f5fcc13c 2132 /* other systems */
536319af 2133 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
f5fcc13c 2134 SND_PCI_QUIRK(0x8384, 0x7680,
536319af 2135 "Mac", STAC_INTEL_MAC_AUTO),
dfe495d0
TI		 2136 /* Dell systems */
2137 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
2138 "unknown Dell", STAC_922X_DELL_D81),
2139 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
2140 "unknown Dell", STAC_922X_DELL_D81),
2141 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
2142 "unknown Dell", STAC_922X_DELL_D81),
2143 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
2144 "unknown Dell", STAC_922X_DELL_D82),
2145 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2146 "unknown Dell", STAC_922X_DELL_M81),
2147 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2148 "unknown Dell", STAC_922X_DELL_D82),
2149 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2150 "unknown Dell", STAC_922X_DELL_D81),
2151 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2152 "unknown Dell", STAC_922X_DELL_D81),
2153 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2154 "Dell XPS M1210", STAC_922X_DELL_M82),
8c650087 2155 /* ECS/PC Chips boards */
dea0a509 2156 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
8663ae55 2157 "ECS/PC chips", STAC_ECS_202),
403d1944
MP		 2158 {} /* terminator */
2159};
2160
3cc08dc6 2161static unsigned int ref927x_pin_configs[14] = {
93ed1503
TD		 2162 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2163 0x01a19040, 0x01011012, 0x01016011, 0x0101201f,
2164 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2165 0x01c42190, 0x40000100,
3cc08dc6
MP		 2166};
2167
93ed1503 2168static unsigned int d965_3st_pin_configs[14] = {
81d3dbde
TD		 2169 0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2170 0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2171 0x40000100, 0x40000100, 0x40000100, 0x40000100,
2172 0x40000100, 0x40000100
2173};
2174
93ed1503
TD		 2175static unsigned int d965_5st_pin_configs[14] = {
2176 0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2177 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2178 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2179 0x40000100, 0x40000100
2180};
2181
679d92ed
TI		 2182static unsigned int d965_5st_no_fp_pin_configs[14] = {
2183 0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2184 0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2185 0x40000100, 0x40000100, 0x40000100, 0x01442070,
2186 0x40000100, 0x40000100
2187};
2188
4ff076e5
TD		 2189static unsigned int dell_3st_pin_configs[14] = {
2190 0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2191 0x01111212, 0x01116211, 0x01813050, 0x01112214,
8e9068b1 2192 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
4ff076e5
TD		 2193 0x40c003fc, 0x40000100
2194};
2195
93ed1503 2196static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
e28d8322 2197 [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
8e9068b1
MR		 2198 [STAC_D965_REF] = ref927x_pin_configs,
2199 [STAC_D965_3ST] = d965_3st_pin_configs,
2200 [STAC_D965_5ST] = d965_5st_pin_configs,
679d92ed 2201 [STAC_D965_5ST_NO_FP] = d965_5st_no_fp_pin_configs,
8e9068b1
MR		 2202 [STAC_DELL_3ST] = dell_3st_pin_configs,
2203 [STAC_DELL_BIOS] = NULL,
3cc08dc6
MP		 2204};
2205
f5fcc13c 2206static const char *stac927x_models[STAC_927X_MODELS] = {
1607b8ea 2207 [STAC_927X_AUTO] = "auto",
e28d8322 2208 [STAC_D965_REF_NO_JD] = "ref-no-jd",
8e9068b1
MR		 2209 [STAC_D965_REF] = "ref",
2210 [STAC_D965_3ST] = "3stack",
2211 [STAC_D965_5ST] = "5stack",
679d92ed 2212 [STAC_D965_5ST_NO_FP] = "5stack-no-fp",
8e9068b1
MR		 2213 [STAC_DELL_3ST] = "dell-3stack",
2214 [STAC_DELL_BIOS] = "dell-bios",
f5fcc13c
TI		 2215};
2216
2217static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2218 /* SigmaTel reference board */
2219 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2220 "DFI LanParty", STAC_D965_REF),
577aa2c1
MR		 2221 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2222 "DFI LanParty", STAC_D965_REF),
81d3dbde 2223 /* Intel 946 based systems */
f5fcc13c
TI		 2224 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2225 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
93ed1503 2226 /* 965 based 3 stack systems */
dea0a509
TI		 2227 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2228 "Intel D965", STAC_D965_3ST),
2229 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2230 "Intel D965", STAC_D965_3ST),
4ff076e5 2231 /* Dell 3 stack systems */
8e9068b1 2232 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
dfe495d0 2233 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
4ff076e5
TD		 2234 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST),
2235 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST),
8e9068b1 2236 /* Dell 3 stack systems with verb table in BIOS */
2f32d909
MR		 2237 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2238 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS),
8e9068b1 2239 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS),
84d3dc20 2240 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
8e9068b1
MR		 2241 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS),
2242 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS),
2243 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS),
2244 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
93ed1503 2245 /* 965 based 5 stack systems */
dea0a509
TI		 2246 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2247 "Intel D965", STAC_D965_5ST),
2248 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2249 "Intel D965", STAC_D965_5ST),
3cc08dc6
MP		 2250 {} /* terminator */
2251};
2252
f3302a59
MP		 2253static unsigned int ref9205_pin_configs[12] = {
2254 0x40000100, 0x40000100, 0x01016011, 0x01014010,
09a99959 2255 0x01813122, 0x01a19021, 0x01019020, 0x40000100,
8b65727b 2256 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
f3302a59
MP		 2257};
2258
dfe495d0
TI		 2259/*
2260 STAC 9205 pin configs for
2261 102801F1
2262 102801F2
2263 102801FC
2264 102801FD
2265 10280204
2266 1028021F
3fa2ef74 2267 10280228 (Dell Vostro 1500)
dfe495d0
TI		 2268*/
2269static unsigned int dell_9205_m42_pin_configs[12] = {
2270 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2271 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2272 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2273};
2274
2275/*
2276 STAC 9205 pin configs for
2277 102801F9
2278 102801FA
2279 102801FE
2280 102801FF (Dell Precision M4300)
2281 10280206
2282 10280200
2283 10280201
2284*/
2285static unsigned int dell_9205_m43_pin_configs[12] = {
ae0a8ed8
TD		 2286 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2287 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2288 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2289};
2290
dfe495d0 2291static unsigned int dell_9205_m44_pin_configs[12] = {
ae0a8ed8
TD		 2292 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2293 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2294 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2295};
2296
f5fcc13c 2297static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
ae0a8ed8 2298 [STAC_9205_REF] = ref9205_pin_configs,
dfe495d0
TI		 2299 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2300 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2301 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
d9a4268e 2302 [STAC_9205_EAPD] = NULL,
f3302a59
MP		 2303};
2304
f5fcc13c 2305static const char *stac9205_models[STAC_9205_MODELS] = {
1607b8ea 2306 [STAC_9205_AUTO] = "auto",
f5fcc13c 2307 [STAC_9205_REF] = "ref",
dfe495d0 2308 [STAC_9205_DELL_M42] = "dell-m42",
ae0a8ed8
TD		 2309 [STAC_9205_DELL_M43] = "dell-m43",
2310 [STAC_9205_DELL_M44] = "dell-m44",
d9a4268e 2311 [STAC_9205_EAPD] = "eapd",
f5fcc13c
TI		 2312};
2313
2314static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2315 /* SigmaTel reference board */
2316 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2317 "DFI LanParty", STAC_9205_REF),
02358fcf
HRK		 2318 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2319 "SigmaTel", STAC_9205_REF),
577aa2c1
MR		 2320 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2321 "DFI LanParty", STAC_9205_REF),
d9a4268e 2322 /* Dell */
dfe495d0
TI		 2323 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2324 "unknown Dell", STAC_9205_DELL_M42),
2325 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2326 "unknown Dell", STAC_9205_DELL_M42),
ae0a8ed8 2327 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
b44ef2f1 2328 "Dell Precision", STAC_9205_DELL_M43),
ae0a8ed8
TD		 2329 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2330 "Dell Precision", STAC_9205_DELL_M43),
2331 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2332 "Dell Precision", STAC_9205_DELL_M43),
dfe495d0
TI		 2333 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2334 "unknown Dell", STAC_9205_DELL_M42),
2335 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2336 "unknown Dell", STAC_9205_DELL_M42),
ae0a8ed8
TD		 2337 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2338 "Dell Precision", STAC_9205_DELL_M43),
2339 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
dfe495d0 2340 "Dell Precision M4300", STAC_9205_DELL_M43),
dfe495d0
TI		 2341 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2342 "unknown Dell", STAC_9205_DELL_M42),
4549915c
TI		 2343 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2344 "Dell Precision", STAC_9205_DELL_M43),
2345 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2346 "Dell Precision", STAC_9205_DELL_M43),
2347 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2348 "Dell Precision", STAC_9205_DELL_M43),
ae0a8ed8
TD		 2349 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2350 "Dell Inspiron", STAC_9205_DELL_M44),
3fa2ef74
MR		 2351 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2352 "Dell Vostro 1500", STAC_9205_DELL_M42),
d9a4268e 2353 /* Gateway */
42b95f0c 2354 SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
d9a4268e 2355 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
f3302a59
MP		 2356 {} /* terminator */
2357};
2358
330ee995
TI		 2359static void stac92xx_set_config_regs(struct hda_codec *codec,
2360 unsigned int *pincfgs)
11b44bbd
RF		 2361{
2362 int i;
2363 struct sigmatel_spec *spec = codec->spec;
11b44bbd 2364
330ee995
TI		 2365 if (!pincfgs)
2366 return;
11b44bbd 2367
87d48363 2368 for (i = 0; i < spec->num_pins; i++)
330ee995
TI		 2369 if (spec->pin_nids[i] && pincfgs[i])
2370 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2371 pincfgs[i]);
af9f341a
TI		 2372}
2373
dabbed6f 2374/*
c7d4b2fa 2375 * Analog playback callbacks
dabbed6f 2376 */
c7d4b2fa
M		 2377static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2378 struct hda_codec *codec,
c8b6bf9b 2379 struct snd_pcm_substream *substream)
2f2f4251 2380{
dabbed6f 2381 struct sigmatel_spec *spec = codec->spec;
8daaaa97
MR		 2382 if (spec->stream_delay)
2383 msleep(spec->stream_delay);
9a08160b
TI		 2384 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2385 hinfo);
2f2f4251
M		 2386}
2387
2f2f4251
M		 2388static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2389 struct hda_codec *codec,
2390 unsigned int stream_tag,
2391 unsigned int format,
c8b6bf9b 2392 struct snd_pcm_substream *substream)
2f2f4251
M		 2393{
2394 struct sigmatel_spec *spec = codec->spec;
403d1944 2395 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2f2f4251
M		 2396}
2397
2398static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2399 struct hda_codec *codec,
c8b6bf9b 2400 struct snd_pcm_substream *substream)
2f2f4251
M		 2401{
2402 struct sigmatel_spec *spec = codec->spec;
2403 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2404}
2405
dabbed6f
M		 2406/*
2407 * Digital playback callbacks
2408 */
2409static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2410 struct hda_codec *codec,
c8b6bf9b 2411 struct snd_pcm_substream *substream)
dabbed6f
M		 2412{
2413 struct sigmatel_spec *spec = codec->spec;
2414 return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2415}
2416
2417static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2418 struct hda_codec *codec,
c8b6bf9b 2419 struct snd_pcm_substream *substream)
dabbed6f
M		 2420{
2421 struct sigmatel_spec *spec = codec->spec;
2422 return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2423}
2424
6b97eb45
TI		 2425static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2426 struct hda_codec *codec,
2427 unsigned int stream_tag,
2428 unsigned int format,
2429 struct snd_pcm_substream *substream)
2430{
2431 struct sigmatel_spec *spec = codec->spec;
2432 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2433 stream_tag, format, substream);
2434}
2435
9411e21c
TI		 2436static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2437 struct hda_codec *codec,
2438 struct snd_pcm_substream *substream)
2439{
2440 struct sigmatel_spec *spec = codec->spec;
2441 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2442}
2443
dabbed6f 2444
2f2f4251
M		 2445/*
2446 * Analog capture callbacks
2447 */
2448static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2449 struct hda_codec *codec,
2450 unsigned int stream_tag,
2451 unsigned int format,
c8b6bf9b 2452 struct snd_pcm_substream *substream)
2f2f4251
M		 2453{
2454 struct sigmatel_spec *spec = codec->spec;
8daaaa97 2455 hda_nid_t nid = spec->adc_nids[substream->number];
2f2f4251 2456
8daaaa97
MR		 2457 if (spec->powerdown_adcs) {
2458 msleep(40);
8c2f767b 2459 snd_hda_codec_write(codec, nid, 0,
8daaaa97
MR		 2460 AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2461 }
2462 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2f2f4251
M		 2463 return 0;
2464}
2465
2466static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2467 struct hda_codec *codec,
c8b6bf9b 2468 struct snd_pcm_substream *substream)
2f2f4251
M		 2469{
2470 struct sigmatel_spec *spec = codec->spec;
8daaaa97 2471 hda_nid_t nid = spec->adc_nids[substream->number];
2f2f4251 2472
8daaaa97
MR		 2473 snd_hda_codec_cleanup_stream(codec, nid);
2474 if (spec->powerdown_adcs)
8c2f767b 2475 snd_hda_codec_write(codec, nid, 0,
8daaaa97 2476 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2f2f4251
M		 2477 return 0;
2478}
2479
dabbed6f
M		 2480static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2481 .substreams = 1,
2482 .channels_min = 2,
2483 .channels_max = 2,
2484 /* NID is set in stac92xx_build_pcms */
2485 .ops = {
2486 .open = stac92xx_dig_playback_pcm_open,
6b97eb45 2487 .close = stac92xx_dig_playback_pcm_close,
9411e21c
TI		 2488 .prepare = stac92xx_dig_playback_pcm_prepare,
2489 .cleanup = stac92xx_dig_playback_pcm_cleanup
dabbed6f
M		 2490 },
2491};
2492
2493static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2494 .substreams = 1,
2495 .channels_min = 2,
2496 .channels_max = 2,
2497 /* NID is set in stac92xx_build_pcms */
2498};
2499
2f2f4251
M		 2500static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2501 .substreams = 1,
2502 .channels_min = 2,
c7d4b2fa 2503 .channels_max = 8,
2f2f4251
M		 2504 .nid = 0x02, /* NID to query formats and rates */
2505 .ops = {
2506 .open = stac92xx_playback_pcm_open,
2507 .prepare = stac92xx_playback_pcm_prepare,
2508 .cleanup = stac92xx_playback_pcm_cleanup
2509 },
2510};
2511
3cc08dc6
MP		 2512static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2513 .substreams = 1,
2514 .channels_min = 2,
2515 .channels_max = 2,
2516 .nid = 0x06, /* NID to query formats and rates */
2517 .ops = {
2518 .open = stac92xx_playback_pcm_open,
2519 .prepare = stac92xx_playback_pcm_prepare,
2520 .cleanup = stac92xx_playback_pcm_cleanup
2521 },
2522};
2523
2f2f4251 2524static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2f2f4251
M		 2525 .channels_min = 2,
2526 .channels_max = 2,
9e05b7a3 2527 /* NID + .substreams is set in stac92xx_build_pcms */
2f2f4251
M		 2528 .ops = {
2529 .prepare = stac92xx_capture_pcm_prepare,
2530 .cleanup = stac92xx_capture_pcm_cleanup
2531 },
2532};
2533
2534static int stac92xx_build_pcms(struct hda_codec *codec)
2535{
2536 struct sigmatel_spec *spec = codec->spec;
2537 struct hda_pcm *info = spec->pcm_rec;
2538
2539 codec->num_pcms = 1;
2540 codec->pcm_info = info;
2541
c7d4b2fa 2542 info->name = "STAC92xx Analog";
2f2f4251 2543 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
00a602db
TI		 2544 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2545 spec->multiout.dac_nids[0];
2f2f4251 2546 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
3cc08dc6 2547 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
9e05b7a3 2548 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
3cc08dc6
MP		 2549
2550 if (spec->alt_switch) {
2551 codec->num_pcms++;
2552 info++;
2553 info->name = "STAC92xx Analog Alt";
2554 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2555 }
2f2f4251 2556
dabbed6f
M		 2557 if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2558 codec->num_pcms++;
2559 info++;
2560 info->name = "STAC92xx Digital";
0852d7a6 2561 info->pcm_type = spec->autocfg.dig_out_type[0];
dabbed6f
M		 2562 if (spec->multiout.dig_out_nid) {
2563 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2564 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2565 }
2566 if (spec->dig_in_nid) {
2567 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2568 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2569 }
2570 }
2571
2f2f4251
M		 2572 return 0;
2573}
2574
7c922de7
NL		 2575static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
2576 hda_nid_t nid)
c960a03b 2577{
1327a32b 2578 unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
c960a03b
TI		 2579 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2580 if (pincap & AC_PINCAP_VREF_100)
2581 return AC_PINCTL_VREF_100;
2582 if (pincap & AC_PINCAP_VREF_80)
2583 return AC_PINCTL_VREF_80;
2584 if (pincap & AC_PINCAP_VREF_50)
2585 return AC_PINCTL_VREF_50;
2586 if (pincap & AC_PINCAP_VREF_GRD)
2587 return AC_PINCTL_VREF_GRD;
2588 return 0;
2589}
2590
403d1944
MP		 2591static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2592
2593{
82beb8fd
TI		 2594 snd_hda_codec_write_cache(codec, nid, 0,
2595 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
403d1944
MP		 2596}
2597
7c2ba97b
MR		 2598#define stac92xx_hp_switch_info snd_ctl_boolean_mono_info
2599
2600static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2601 struct snd_ctl_elem_value *ucontrol)
2602{
2603 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2604 struct sigmatel_spec *spec = codec->spec;
2605
d7a89436 2606 ucontrol->value.integer.value[0] = !!spec->hp_switch;
7c2ba97b
MR		 2607 return 0;
2608}
2609
62558ce1 2610static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
c6e4c666 2611
7c2ba97b
MR		 2612static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2613 struct snd_ctl_elem_value *ucontrol)
2614{
2615 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2616 struct sigmatel_spec *spec = codec->spec;
d7a89436
TI		 2617 int nid = kcontrol->private_value;
2618
2619 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
7c2ba97b
MR		 2620
2621 /* check to be sure that the ports are upto date with
2622 * switch changes
2623 */
62558ce1 2624 stac_issue_unsol_event(codec, nid);
7c2ba97b
MR		 2625
2626 return 1;
2627}
2628
7c922de7
NL		 2629static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2630 struct snd_ctl_elem_info *uinfo)
2631{
2632 int i;
2633 static char *texts[] = {
2634 "Mic In", "Line In", "Line Out"
2635 };
2636
2637 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2638 struct sigmatel_spec *spec = codec->spec;
2639 hda_nid_t nid = kcontrol->private_value;
2640
2641 if (nid == spec->mic_switch || nid == spec->line_switch)
2642 i = 3;
2643 else
2644 i = 2;
2645
2646 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2647 uinfo->value.enumerated.items = i;
2648 uinfo->count = 1;
2649 if (uinfo->value.enumerated.item >= i)
2650 uinfo->value.enumerated.item = i-1;
2651 strcpy(uinfo->value.enumerated.name,
2652 texts[uinfo->value.enumerated.item]);
2653
2654 return 0;
2655}
2656
2657static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2658 struct snd_ctl_elem_value *ucontrol)
2659{
2660 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2661 hda_nid_t nid = kcontrol->private_value;
2662 unsigned int vref = stac92xx_vref_get(codec, nid);
2663
2664 if (vref == stac92xx_get_default_vref(codec, nid))
2665 ucontrol->value.enumerated.item[0] = 0;
2666 else if (vref == AC_PINCTL_VREF_GRD)
2667 ucontrol->value.enumerated.item[0] = 1;
2668 else if (vref == AC_PINCTL_VREF_HIZ)
2669 ucontrol->value.enumerated.item[0] = 2;
2670
2671 return 0;
2672}
2673
2674static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2675 struct snd_ctl_elem_value *ucontrol)
2676{
2677 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2678 unsigned int new_vref = 0;
b8621516 2679 int error;
7c922de7
NL		 2680 hda_nid_t nid = kcontrol->private_value;
2681
2682 if (ucontrol->value.enumerated.item[0] == 0)
2683 new_vref = stac92xx_get_default_vref(codec, nid);
2684 else if (ucontrol->value.enumerated.item[0] == 1)
2685 new_vref = AC_PINCTL_VREF_GRD;
2686 else if (ucontrol->value.enumerated.item[0] == 2)
2687 new_vref = AC_PINCTL_VREF_HIZ;
2688 else
2689 return 0;
2690
2691 if (new_vref != stac92xx_vref_get(codec, nid)) {
2692 error = stac92xx_vref_set(codec, nid, new_vref);
2693 return error;
2694 }
2695
2696 return 0;
2697}
2698
2699static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2700 struct snd_ctl_elem_info *uinfo)
2701{
2702 static char *texts[2];
2703 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2704 struct sigmatel_spec *spec = codec->spec;
2705
2706 if (kcontrol->private_value == spec->line_switch)
2707 texts[0] = "Line In";
2708 else
2709 texts[0] = "Mic In";
2710 texts[1] = "Line Out";
2711 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2712 uinfo->value.enumerated.items = 2;
2713 uinfo->count = 1;
2714
2715 if (uinfo->value.enumerated.item >= 2)
2716 uinfo->value.enumerated.item = 1;
2717 strcpy(uinfo->value.enumerated.name,
2718 texts[uinfo->value.enumerated.item]);
2719
2720 return 0;
2721}
403d1944
MP		 2722
2723static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2724{
2725 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2726 struct sigmatel_spec *spec = codec->spec;
7c922de7
NL		 2727 hda_nid_t nid = kcontrol->private_value;
2728 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
403d1944 2729
7c922de7 2730 ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
403d1944
MP		 2731 return 0;
2732}
2733
2734static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2735{
2736 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2737 struct sigmatel_spec *spec = codec->spec;
7c922de7
NL		 2738 hda_nid_t nid = kcontrol->private_value;
2739 int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2740 unsigned short val = !!ucontrol->value.enumerated.item[0];
403d1944
MP		 2741
2742 spec->io_switch[io_idx] = val;
2743
2744 if (val)
2745 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
c960a03b
TI		 2746 else {
2747 unsigned int pinctl = AC_PINCTL_IN_EN;
2748 if (io_idx) /* set VREF for mic */
7c922de7 2749 pinctl |= stac92xx_get_default_vref(codec, nid);
c960a03b
TI		 2750 stac92xx_auto_set_pinctl(codec, nid, pinctl);
2751 }
40c1d308
JZ		 2752
2753 /* check the auto-mute again: we need to mute/unmute the speaker
2754 * appropriately according to the pin direction
2755 */
2756 if (spec->hp_detect)
62558ce1 2757 stac_issue_unsol_event(codec, nid);
40c1d308 2758
403d1944
MP		 2759 return 1;
2760}
2761
0fb87bb4
ML		 2762#define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2763
2764static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2765 struct snd_ctl_elem_value *ucontrol)
2766{
2767 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2768 struct sigmatel_spec *spec = codec->spec;
2769
2770 ucontrol->value.integer.value[0] = spec->clfe_swap;
2771 return 0;
2772}
2773
2774static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2775 struct snd_ctl_elem_value *ucontrol)
2776{
2777 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2778 struct sigmatel_spec *spec = codec->spec;
2779 hda_nid_t nid = kcontrol->private_value & 0xff;
68ea7b2f 2780 unsigned int val = !!ucontrol->value.integer.value[0];
0fb87bb4 2781
68ea7b2f 2782 if (spec->clfe_swap == val)
0fb87bb4
ML		 2783 return 0;
2784
68ea7b2f 2785 spec->clfe_swap = val;
0fb87bb4
ML		 2786
2787 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2788 spec->clfe_swap ? 0x4 : 0x0);
2789
2790 return 1;
2791}
2792
7c2ba97b
MR		 2793#define STAC_CODEC_HP_SWITCH(xname) \
2794 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2795 .name = xname, \
2796 .index = 0, \
2797 .info = stac92xx_hp_switch_info, \
2798 .get = stac92xx_hp_switch_get, \
2799 .put = stac92xx_hp_switch_put, \
2800 }
2801
403d1944
MP		 2802#define STAC_CODEC_IO_SWITCH(xname, xpval) \
2803 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2804 .name = xname, \
2805 .index = 0, \
2806 .info = stac92xx_io_switch_info, \
2807 .get = stac92xx_io_switch_get, \
2808 .put = stac92xx_io_switch_put, \
2809 .private_value = xpval, \
2810 }
2811
0fb87bb4
ML		 2812#define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2813 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2814 .name = xname, \
2815 .index = 0, \
2816 .info = stac92xx_clfe_switch_info, \
2817 .get = stac92xx_clfe_switch_get, \
2818 .put = stac92xx_clfe_switch_put, \
2819 .private_value = xpval, \
2820 }
403d1944 2821
c7d4b2fa
M		 2822enum {
2823 STAC_CTL_WIDGET_VOL,
2824 STAC_CTL_WIDGET_MUTE,
09a99959 2825 STAC_CTL_WIDGET_MONO_MUX,
89385035
MR		 2826 STAC_CTL_WIDGET_AMP_MUX,
2827 STAC_CTL_WIDGET_AMP_VOL,
7c2ba97b 2828 STAC_CTL_WIDGET_HP_SWITCH,
403d1944 2829 STAC_CTL_WIDGET_IO_SWITCH,
2fc99890
NL		 2830 STAC_CTL_WIDGET_CLFE_SWITCH,
2831 STAC_CTL_WIDGET_DC_BIAS
c7d4b2fa
M		 2832};
2833
c8b6bf9b 2834static struct snd_kcontrol_new stac92xx_control_templates[] = {
c7d4b2fa
M		 2835 HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2836 HDA_CODEC_MUTE(NULL, 0, 0, 0),
09a99959 2837 STAC_MONO_MUX,
89385035
MR		 2838 STAC_AMP_MUX,
2839 STAC_AMP_VOL(NULL, 0, 0, 0, 0),
7c2ba97b 2840 STAC_CODEC_HP_SWITCH(NULL),
403d1944 2841 STAC_CODEC_IO_SWITCH(NULL, 0),
0fb87bb4 2842 STAC_CODEC_CLFE_SWITCH(NULL, 0),
2fc99890 2843 DC_BIAS(NULL, 0, 0),
c7d4b2fa
M		 2844};
2845
2846/* add dynamic controls */
e3c75964
TI		 2847static struct snd_kcontrol_new *
2848stac_control_new(struct sigmatel_spec *spec,
2849 struct snd_kcontrol_new *ktemp,
2850 const char *name)
c7d4b2fa 2851{
c8b6bf9b 2852 struct snd_kcontrol_new *knew;
c7d4b2fa 2853
603c4019
TI		 2854 snd_array_init(&spec->kctls, sizeof(*knew), 32);
2855 knew = snd_array_new(&spec->kctls);
2856 if (!knew)
e3c75964 2857 return NULL;
4d4e9bb3 2858 *knew = *ktemp;
82fe0c58 2859 knew->name = kstrdup(name, GFP_KERNEL);
e3c75964
TI		 2860 if (!knew->name) {
2861 /* roolback */
2862 memset(knew, 0, sizeof(*knew));
2863 spec->kctls.alloced--;
2864 return NULL;
2865 }
2866 return knew;
2867}
2868
2869static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2870 struct snd_kcontrol_new *ktemp,
2871 int idx, const char *name,
2872 unsigned long val)
2873{
2874 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name);
2875 if (!knew)
c7d4b2fa 2876 return -ENOMEM;
e3c75964 2877 knew->index = idx;
c7d4b2fa 2878 knew->private_value = val;
c7d4b2fa
M		 2879 return 0;
2880}
2881
4d4e9bb3
TI		 2882static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2883 int type, int idx, const char *name,
2884 unsigned long val)
2885{
2886 return stac92xx_add_control_temp(spec,
2887 &stac92xx_control_templates[type],
2888 idx, name, val);
2889}
2890
4682eee0
MR		 2891
2892/* add dynamic controls */
4d4e9bb3
TI		 2893static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2894 const char *name, unsigned long val)
4682eee0
MR		 2895{
2896 return stac92xx_add_control_idx(spec, type, 0, name, val);
2897}
2898
e3c75964
TI		 2899static struct snd_kcontrol_new stac_input_src_temp = {
2900 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2901 .name = "Input Source",
2902 .info = stac92xx_mux_enum_info,
2903 .get = stac92xx_mux_enum_get,
2904 .put = stac92xx_mux_enum_put,
2905};
2906
7c922de7
NL		 2907static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2908 hda_nid_t nid, int idx)
2909{
2910 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2911 int control = 0;
2912 struct sigmatel_spec *spec = codec->spec;
2913 char name[22];
2914
2915 if (!((get_defcfg_connect(def_conf)) & AC_JACK_PORT_FIXED)) {
2916 if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2917 && nid == spec->line_switch)
2918 control = STAC_CTL_WIDGET_IO_SWITCH;
2919 else if (snd_hda_query_pin_caps(codec, nid)
2920 & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2921 control = STAC_CTL_WIDGET_DC_BIAS;
2922 else if (nid == spec->mic_switch)
2923 control = STAC_CTL_WIDGET_IO_SWITCH;
2924 }
2925
2926 if (control) {
2927 strcpy(name, auto_pin_cfg_labels[idx]);
2928 return stac92xx_add_control(codec->spec, control,
2929 strcat(name, " Jack Mode"), nid);
2930 }
2931
2932 return 0;
2933}
2934
e3c75964
TI		 2935static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2936{
2937 struct snd_kcontrol_new *knew;
2938 struct hda_input_mux *imux = &spec->private_imux;
2939
3d21d3f7
TI		 2940 if (spec->auto_mic)
2941 return 0; /* no need for input source */
e3c75964
TI		 2942 if (!spec->num_adcs || imux->num_items <= 1)
2943 return 0; /* no need for input source control */
2944 knew = stac_control_new(spec, &stac_input_src_temp,
2945 stac_input_src_temp.name);
2946 if (!knew)
2947 return -ENOMEM;
2948 knew->count = spec->num_adcs;
2949 return 0;
2950}
2951
c21ca4a8
TI		 2952/* check whether the line-input can be used as line-out */
2953static hda_nid_t check_line_out_switch(struct hda_codec *codec)
403d1944
MP		 2954{
2955 struct sigmatel_spec *spec = codec->spec;
c21ca4a8
TI		 2956 struct auto_pin_cfg *cfg = &spec->autocfg;
2957 hda_nid_t nid;
2958 unsigned int pincap;
8e9068b1 2959
c21ca4a8
TI		 2960 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2961 return 0;
2962 nid = cfg->input_pins[AUTO_PIN_LINE];
1327a32b 2963 pincap = snd_hda_query_pin_caps(codec, nid);
c21ca4a8
TI		 2964 if (pincap & AC_PINCAP_OUT)
2965 return nid;
2966 return 0;
2967}
403d1944 2968
c21ca4a8
TI		 2969/* check whether the mic-input can be used as line-out */
2970static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
2971{
2972 struct sigmatel_spec *spec = codec->spec;
2973 struct auto_pin_cfg *cfg = &spec->autocfg;
2974 unsigned int def_conf, pincap;
2975 unsigned int mic_pin;
2976
2977 if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2978 return 0;
2979 mic_pin = AUTO_PIN_MIC;
2980 for (;;) {
2981 hda_nid_t nid = cfg->input_pins[mic_pin];
330ee995 2982 def_conf = snd_hda_codec_get_pincfg(codec, nid);
c21ca4a8
TI		 2983 /* some laptops have an internal analog microphone
2984 * which can't be used as a output */
2985 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
1327a32b 2986 pincap = snd_hda_query_pin_caps(codec, nid);
c21ca4a8
TI		 2987 if (pincap & AC_PINCAP_OUT)
2988 return nid;
403d1944 2989 }
c21ca4a8
TI		 2990 if (mic_pin == AUTO_PIN_MIC)
2991 mic_pin = AUTO_PIN_FRONT_MIC;
2992 else
2993 break;
403d1944 2994 }
403d1944
MP		 2995 return 0;
2996}
2997
7b043899
SL		 2998static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2999{
3000 int i;
3001
3002 for (i = 0; i < spec->multiout.num_dacs; i++) {
3003 if (spec->multiout.dac_nids[i] == nid)
3004 return 1;
3005 }
3006
3007 return 0;
3008}
3009
c21ca4a8
TI		 3010static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
3011{
3012 int i;
3013 if (is_in_dac_nids(spec, nid))
3014 return 1;
3015 for (i = 0; i < spec->autocfg.hp_outs; i++)
3016 if (spec->hp_dacs[i] == nid)
3017 return 1;
3018 for (i = 0; i < spec->autocfg.speaker_outs; i++)
3019 if (spec->speaker_dacs[i] == nid)
3020 return 1;
3021 return 0;
3022}
3023
3024static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
3025{
3026 struct sigmatel_spec *spec = codec->spec;
3027 int j, conn_len;
3028 hda_nid_t conn[HDA_MAX_CONNECTIONS];
3029 unsigned int wcaps, wtype;
3030
3031 conn_len = snd_hda_get_connections(codec, nid, conn,
3032 HDA_MAX_CONNECTIONS);
3033 for (j = 0; j < conn_len; j++) {
14bafe32 3034 wcaps = get_wcaps(codec, conn[j]);
a22d543a 3035 wtype = get_wcaps_type(wcaps);
c21ca4a8
TI		 3036 /* we check only analog outputs */
3037 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
3038 continue;
3039 /* if this route has a free DAC, assign it */
3040 if (!check_all_dac_nids(spec, conn[j])) {
3041 if (conn_len > 1) {
3042 /* select this DAC in the pin's input mux */
3043 snd_hda_codec_write_cache(codec, nid, 0,
3044 AC_VERB_SET_CONNECT_SEL, j);
3045 }
3046 return conn[j];
3047 }
3048 }
ee58a7ca
TI		 3049 /* if all DACs are already assigned, connect to the primary DAC */
3050 if (conn_len > 1) {
3051 for (j = 0; j < conn_len; j++) {
3052 if (conn[j] == spec->multiout.dac_nids[0]) {
3053 snd_hda_codec_write_cache(codec, nid, 0,
3054 AC_VERB_SET_CONNECT_SEL, j);
3055 break;
3056 }
3057 }
3058 }
c21ca4a8
TI		 3059 return 0;
3060}
3061
3062static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
3063static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
3064
3cc08dc6 3065/*
7b043899
SL		 3066 * Fill in the dac_nids table from the parsed pin configuration
3067 * This function only works when every pin in line_out_pins[]
3068 * contains atleast one DAC in its connection list. Some 92xx
3069 * codecs are not connected directly to a DAC, such as the 9200
3070 * and 9202/925x. For those, dac_nids[] must be hard-coded.
3cc08dc6 3071 */
c21ca4a8 3072static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
c7d4b2fa
M		 3073{
3074 struct sigmatel_spec *spec = codec->spec;
c21ca4a8
TI		 3075 struct auto_pin_cfg *cfg = &spec->autocfg;
3076 int i;
3077 hda_nid_t nid, dac;
7b043899 3078
c7d4b2fa
M		 3079 for (i = 0; i < cfg->line_outs; i++) {
3080 nid = cfg->line_out_pins[i];
c21ca4a8
TI		 3081 dac = get_unassigned_dac(codec, nid);
3082 if (!dac) {
df802952
TI		 3083 if (spec->multiout.num_dacs > 0) {
3084 /* we have already working output pins,
3085 * so let's drop the broken ones again
3086 */
3087 cfg->line_outs = spec->multiout.num_dacs;
3088 break;
3089 }
7b043899
SL		 3090 /* error out, no available DAC found */
3091 snd_printk(KERN_ERR
3092 "%s: No available DAC for pin 0x%x\n",
3093 __func__, nid);
3094 return -ENODEV;
3095 }
c21ca4a8
TI		 3096 add_spec_dacs(spec, dac);
3097 }
7b043899 3098
139e071b
TI		 3099 for (i = 0; i < cfg->hp_outs; i++) {
3100 nid = cfg->hp_pins[i];
3101 dac = get_unassigned_dac(codec, nid);
3102 if (dac) {
3103 if (!spec->multiout.hp_nid)
3104 spec->multiout.hp_nid = dac;
3105 else
3106 add_spec_extra_dacs(spec, dac);
3107 }
3108 spec->hp_dacs[i] = dac;
3109 }
3110
3111 for (i = 0; i < cfg->speaker_outs; i++) {
3112 nid = cfg->speaker_pins[i];
3113 dac = get_unassigned_dac(codec, nid);
3114 if (dac)
3115 add_spec_extra_dacs(spec, dac);
3116 spec->speaker_dacs[i] = dac;
3117 }
3118
c21ca4a8
TI		 3119 /* add line-in as output */
3120 nid = check_line_out_switch(codec);
3121 if (nid) {
3122 dac = get_unassigned_dac(codec, nid);
3123 if (dac) {
3124 snd_printdd("STAC: Add line-in 0x%x as output %d\n",
3125 nid, cfg->line_outs);
3126 cfg->line_out_pins[cfg->line_outs] = nid;
3127 cfg->line_outs++;
3128 spec->line_switch = nid;
3129 add_spec_dacs(spec, dac);
3130 }
3131 }
3132 /* add mic as output */
3133 nid = check_mic_out_switch(codec);
3134 if (nid) {
3135 dac = get_unassigned_dac(codec, nid);
3136 if (dac) {
3137 snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3138 nid, cfg->line_outs);
3139 cfg->line_out_pins[cfg->line_outs] = nid;
3140 cfg->line_outs++;
3141 spec->mic_switch = nid;
3142 add_spec_dacs(spec, dac);
3143 }
3144 }
c7d4b2fa 3145
c21ca4a8 3146 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
7b043899
SL		 3147 spec->multiout.num_dacs,
3148 spec->multiout.dac_nids[0],
3149 spec->multiout.dac_nids[1],
3150 spec->multiout.dac_nids[2],
3151 spec->multiout.dac_nids[3],
3152 spec->multiout.dac_nids[4]);
c21ca4a8 3153
c7d4b2fa
M		 3154 return 0;
3155}
3156
eb06ed8f 3157/* create volume control/switch for the given prefx type */
668b9652
TI		 3158static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3159 int idx, hda_nid_t nid, int chs)
eb06ed8f 3160{
7c7767eb 3161 struct sigmatel_spec *spec = codec->spec;
eb06ed8f
TI		 3162 char name[32];
3163 int err;
3164
7c7767eb
TI		 3165 if (!spec->check_volume_offset) {
3166 unsigned int caps, step, nums, db_scale;
3167 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3168 step = (caps & AC_AMPCAP_STEP_SIZE) >>
3169 AC_AMPCAP_STEP_SIZE_SHIFT;
3170 step = (step + 1) * 25; /* in .01dB unit */
3171 nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3172 AC_AMPCAP_NUM_STEPS_SHIFT;
3173 db_scale = nums * step;
3174 /* if dB scale is over -64dB, and finer enough,
3175 * let's reduce it to half
3176 */
3177 if (db_scale > 6400 && nums >= 0x1f)
3178 spec->volume_offset = nums / 2;
3179 spec->check_volume_offset = 1;
3180 }
3181
eb06ed8f 3182 sprintf(name, "%s Playback Volume", pfx);
668b9652 3183 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
7c7767eb
TI		 3184 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3185 spec->volume_offset));
eb06ed8f
TI		 3186 if (err < 0)
3187 return err;
3188 sprintf(name, "%s Playback Switch", pfx);
668b9652 3189 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
eb06ed8f
TI		 3190 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3191 if (err < 0)
3192 return err;
3193 return 0;
3194}
3195
668b9652
TI		 3196#define create_controls(codec, pfx, nid, chs) \
3197 create_controls_idx(codec, pfx, 0, nid, chs)
3198
ae0afd81
MR		 3199static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3200{
c21ca4a8 3201 if (spec->multiout.num_dacs > 4) {
ae0afd81
MR		 3202 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3203 return 1;
3204 } else {
3205 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3206 spec->multiout.num_dacs++;
3207 }
3208 return 0;
3209}
3210
c21ca4a8 3211static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
ae0afd81 3212{
c21ca4a8
TI		 3213 int i;
3214 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3215 if (!spec->multiout.extra_out_nid[i]) {
3216 spec->multiout.extra_out_nid[i] = nid;
3217 return 0;
3218 }
3219 }
3220 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3221 return 1;
ae0afd81
MR		 3222}
3223
dc04d1b4
TI		 3224/* Create output controls
3225 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3226 */
3227static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3228 const hda_nid_t *pins,
3229 const hda_nid_t *dac_nids,
3230 int type)
c7d4b2fa 3231{
76624534 3232 struct sigmatel_spec *spec = codec->spec;
19039bd0
TI		 3233 static const char *chname[4] = {
3234 "Front", "Surround", NULL /*CLFE*/, "Side"
3235 };
dc04d1b4 3236 hda_nid_t nid;
91589232
TI		 3237 int i, err;
3238 unsigned int wid_caps;
0fb87bb4 3239
dc04d1b4 3240 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
ffd0e56c
TI		 3241 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3242 wid_caps = get_wcaps(codec, pins[i]);
3243 if (wid_caps & AC_WCAP_UNSOL_CAP)
3244 spec->hp_detect = 1;
3245 }
dc04d1b4
TI		 3246 nid = dac_nids[i];
3247 if (!nid)
3248 continue;
3249 if (type != AUTO_PIN_HP_OUT && i == 2) {
c7d4b2fa 3250 /* Center/LFE */
7c7767eb 3251 err = create_controls(codec, "Center", nid, 1);
eb06ed8f 3252 if (err < 0)
c7d4b2fa 3253 return err;
7c7767eb 3254 err = create_controls(codec, "LFE", nid, 2);
eb06ed8f 3255 if (err < 0)
c7d4b2fa 3256 return err;
0fb87bb4
ML		 3257
3258 wid_caps = get_wcaps(codec, nid);
3259
3260 if (wid_caps & AC_WCAP_LR_SWAP) {
3261 err = stac92xx_add_control(spec,
3262 STAC_CTL_WIDGET_CLFE_SWITCH,
3263 "Swap Center/LFE Playback Switch", nid);
3264
3265 if (err < 0)
3266 return err;
3267 }
3268
c7d4b2fa 3269 } else {
dc04d1b4 3270 const char *name;
668b9652 3271 int idx;
dc04d1b4
TI		 3272 switch (type) {
3273 case AUTO_PIN_HP_OUT:
668b9652
TI		 3274 name = "Headphone";
3275 idx = i;
dc04d1b4
TI		 3276 break;
3277 case AUTO_PIN_SPEAKER_OUT:
668b9652
TI		 3278 name = "Speaker";
3279 idx = i;
dc04d1b4
TI		 3280 break;
3281 default:
3282 name = chname[i];
668b9652 3283 idx = 0;
dc04d1b4 3284 break;
76624534 3285 }
668b9652 3286 err = create_controls_idx(codec, name, idx, nid, 3);
eb06ed8f 3287 if (err < 0)
c7d4b2fa
M		 3288 return err;
3289 }
3290 }
dc04d1b4
TI		 3291 return 0;
3292}
3293
6479c631
TI		 3294static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3295 unsigned long sw, int idx)
3296{
3297 int err;
3298 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
bf677bd8 3299 "Capture Volume", vol);
6479c631
TI		 3300 if (err < 0)
3301 return err;
3302 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
bf677bd8 3303 "Capture Switch", sw);
6479c631
TI		 3304 if (err < 0)
3305 return err;
3306 return 0;
3307}
3308
dc04d1b4
TI		 3309/* add playback controls from the parsed DAC table */
3310static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3311 const struct auto_pin_cfg *cfg)
3312{
3313 struct sigmatel_spec *spec = codec->spec;
7c922de7 3314 hda_nid_t nid;
dc04d1b4 3315 int err;
7c922de7 3316 int idx;
dc04d1b4
TI		 3317
3318 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3319 spec->multiout.dac_nids,
3320 cfg->line_out_type);
3321 if (err < 0)
3322 return err;
c7d4b2fa 3323
a9cb5c90 3324 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
7c2ba97b
MR		 3325 err = stac92xx_add_control(spec,
3326 STAC_CTL_WIDGET_HP_SWITCH,
d7a89436
TI		 3327 "Headphone as Line Out Switch",
3328 cfg->hp_pins[cfg->hp_outs - 1]);
7c2ba97b
MR		 3329 if (err < 0)
3330 return err;
3331 }
3332
7c922de7
NL		 3333 for (idx = AUTO_PIN_MIC; idx <= AUTO_PIN_FRONT_LINE; idx++) {
3334 nid = cfg->input_pins[idx];
3335 if (nid) {
3336 err = stac92xx_add_jack_mode_control(codec, nid, idx);
3337 if (err < 0)
3338 return err;
3339 }
b5895dc8 3340 }
403d1944 3341
c7d4b2fa
M		 3342 return 0;
3343}
3344
eb06ed8f
TI		 3345/* add playback controls for Speaker and HP outputs */
3346static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3347 struct auto_pin_cfg *cfg)
3348{
3349 struct sigmatel_spec *spec = codec->spec;
dc04d1b4
TI		 3350 int err;
3351
3352 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3353 spec->hp_dacs, AUTO_PIN_HP_OUT);
3354 if (err < 0)
3355 return err;
3356
3357 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3358 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3359 if (err < 0)
3360 return err;
eb06ed8f 3361
c7d4b2fa
M		 3362 return 0;
3363}
3364
b22b4821 3365/* labels for mono mux outputs */
d0513fc6
MR		 3366static const char *stac92xx_mono_labels[4] = {
3367 "DAC0", "DAC1", "Mixer", "DAC2"
b22b4821
MR		 3368};
3369
3370/* create mono mux for mono out on capable codecs */
3371static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3372{
3373 struct sigmatel_spec *spec = codec->spec;
3374 struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3375 int i, num_cons;
3376 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3377
3378 num_cons = snd_hda_get_connections(codec,
3379 spec->mono_nid,
3380 con_lst,
3381 HDA_MAX_NUM_INPUTS);
16a433d8 3382 if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
b22b4821
MR		 3383 return -EINVAL;
3384
3385 for (i = 0; i < num_cons; i++) {
3386 mono_mux->items[mono_mux->num_items].label =
3387 stac92xx_mono_labels[i];
3388 mono_mux->items[mono_mux->num_items].index = i;
3389 mono_mux->num_items++;
3390 }
09a99959
MR		 3391
3392 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3393 "Mono Mux", spec->mono_nid);
b22b4821
MR		 3394}
3395
89385035
MR		 3396/* labels for amp mux outputs */
3397static const char *stac92xx_amp_labels[3] = {
4b33c767 3398 "Front Microphone", "Microphone", "Line In",
89385035
MR		 3399};
3400
3401/* create amp out controls mux on capable codecs */
3402static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
3403{
3404 struct sigmatel_spec *spec = codec->spec;
3405 struct hda_input_mux *amp_mux = &spec->private_amp_mux;
3406 int i, err;
3407
2a9c7816 3408 for (i = 0; i < spec->num_amps; i++) {
89385035
MR		 3409 amp_mux->items[amp_mux->num_items].label =
3410 stac92xx_amp_labels[i];
3411 amp_mux->items[amp_mux->num_items].index = i;
3412 amp_mux->num_items++;
3413 }
3414
2a9c7816
MR		 3415 if (spec->num_amps > 1) {
3416 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
3417 "Amp Selector Capture Switch", 0);
3418 if (err < 0)
3419 return err;
3420 }
89385035
MR		 3421 return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
3422 "Amp Capture Volume",
3423 HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
3424}
3425
3426
1cd2224c
MR		 3427/* create PC beep volume controls */
3428static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3429 hda_nid_t nid)
3430{
3431 struct sigmatel_spec *spec = codec->spec;
3432 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3433 int err;
3434
3435 /* check for mute support for the the amp */
3436 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3437 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3438 "PC Beep Playback Switch",
3439 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3440 if (err < 0)
3441 return err;
3442 }
3443
3444 /* check to see if there is volume support for the amp */
3445 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3446 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3447 "PC Beep Playback Volume",
3448 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3449 if (err < 0)
3450 return err;
3451 }
3452 return 0;
3453}
3454
4d4e9bb3
TI		 3455#ifdef CONFIG_SND_HDA_INPUT_BEEP
3456#define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3457
3458static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3459 struct snd_ctl_elem_value *ucontrol)
3460{
3461 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3462 ucontrol->value.integer.value[0] = codec->beep->enabled;
3463 return 0;
3464}
3465
3466static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3467 struct snd_ctl_elem_value *ucontrol)
3468{
3469 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3470 int enabled = !!ucontrol->value.integer.value[0];
3471 if (codec->beep->enabled != enabled) {
3472 codec->beep->enabled = enabled;
3473 return 1;
3474 }
3475 return 0;
3476}
3477
3478static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3479 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3480 .info = stac92xx_dig_beep_switch_info,
3481 .get = stac92xx_dig_beep_switch_get,
3482 .put = stac92xx_dig_beep_switch_put,
3483};
3484
3485static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3486{
3487 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3488 0, "PC Beep Playback Switch", 0);
3489}
3490#endif
3491
4682eee0
MR		 3492static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3493{
3494 struct sigmatel_spec *spec = codec->spec;
667067d8 3495 int i, j, err = 0;
4682eee0
MR		 3496
3497 for (i = 0; i < spec->num_muxes; i++) {
667067d8
TI		 3498 hda_nid_t nid;
3499 unsigned int wcaps;
3500 unsigned long val;
3501
4682eee0
MR		 3502 nid = spec->mux_nids[i];
3503 wcaps = get_wcaps(codec, nid);
667067d8
TI		 3504 if (!(wcaps & AC_WCAP_OUT_AMP))
3505 continue;
4682eee0 3506
667067d8
TI		 3507 /* check whether already the same control was created as
3508 * normal Capture Volume.
3509 */
3510 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3511 for (j = 0; j < spec->num_caps; j++) {
3512 if (spec->capvols[j] == val)
3513 break;
4682eee0 3514 }
667067d8
TI		 3515 if (j < spec->num_caps)
3516 continue;
3517
3518 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3519 "Mux Capture Volume", val);
3520 if (err < 0)
3521 return err;
4682eee0
MR		 3522 }
3523 return 0;
3524};
3525
d9737751 3526static const char *stac92xx_spdif_labels[3] = {
65973632 3527 "Digital Playback", "Analog Mux 1", "Analog Mux 2",
d9737751
MR		 3528};
3529
3530static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3531{
3532 struct sigmatel_spec *spec = codec->spec;
3533 struct hda_input_mux *spdif_mux = &spec->private_smux;
65973632 3534 const char **labels = spec->spdif_labels;
d9737751 3535 int i, num_cons;
65973632 3536 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
d9737751
MR		 3537
3538 num_cons = snd_hda_get_connections(codec,
3539 spec->smux_nids[0],
3540 con_lst,
3541 HDA_MAX_NUM_INPUTS);
16a433d8 3542 if (num_cons <= 0)
d9737751
MR		 3543 return -EINVAL;
3544
65973632
MR		 3545 if (!labels)
3546 labels = stac92xx_spdif_labels;
3547
d9737751 3548 for (i = 0; i < num_cons; i++) {
65973632 3549 spdif_mux->items[spdif_mux->num_items].label = labels[i];
d9737751
MR		 3550 spdif_mux->items[spdif_mux->num_items].index = i;
3551 spdif_mux->num_items++;
3552 }
3553
3554 return 0;
3555}
3556
8b65727b 3557/* labels for dmic mux inputs */
ddc2cec4 3558static const char *stac92xx_dmic_labels[5] = {
8b65727b
MP		 3559 "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3560 "Digital Mic 3", "Digital Mic 4"
3561};
3562
3d21d3f7
TI		 3563static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
3564 hda_nid_t nid)
3565{
3566 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3567 int i, nums;
3568
3569 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3570 for (i = 0; i < nums; i++)
3571 if (conn[i] == nid)
3572 return i;
3573 return -1;
3574}
3575
667067d8
TI		 3576/* create a volume assigned to the given pin (only if supported) */
3577static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3578 const char *label)
3579{
3580 unsigned int caps, nums;
3581 char name[32];
3582
3583 if (!(get_wcaps(codec, nid) & AC_WCAP_IN_AMP))
3584 return 0;
3585 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3586 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3587 if (!nums)
3588 return 0;
3589 snprintf(name, sizeof(name), "%s Capture Volume", label);
3590 return stac92xx_add_control(codec->spec, STAC_CTL_WIDGET_VOL, name,
3591 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
3592}
3593
8b65727b
MP		 3594/* create playback/capture controls for input pins on dmic capable codecs */
3595static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3596 const struct auto_pin_cfg *cfg)
3597{
3598 struct sigmatel_spec *spec = codec->spec;
5207e10e 3599 struct hda_input_mux *imux = &spec->private_imux;
8b65727b 3600 struct hda_input_mux *dimux = &spec->private_dimux;
5207e10e
TI		 3601 int err, i, active_mics;
3602 unsigned int def_conf;
8b65727b
MP		 3603
3604 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
3605 dimux->items[dimux->num_items].index = 0;
3606 dimux->num_items++;
3607
5207e10e
TI		 3608 active_mics = 0;
3609 for (i = 0; i < spec->num_dmics; i++) {
667067d8
TI		 3610 /* check the validity: sometimes it's a dead vendor-spec node */
3611 if (get_wcaps_type(get_wcaps(codec, spec->dmic_nids[i]))
3612 != AC_WID_PIN)
3613 continue;
5207e10e
TI		 3614 def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]);
3615 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)
3616 active_mics++;
3617 }
3618
8b65727b 3619 for (i = 0; i < spec->num_dmics; i++) {
0678accd 3620 hda_nid_t nid;
8b65727b 3621 int index;
5207e10e 3622 const char *label;
8b65727b 3623
667067d8
TI		 3624 nid = spec->dmic_nids[i];
3625 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3626 continue;
3627 def_conf = snd_hda_codec_get_pincfg(codec, nid);
8b65727b
MP		 3628 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3629 continue;
3630
3d21d3f7
TI		 3631 index = get_connection_index(codec, spec->dmux_nids[0], nid);
3632 if (index < 0)
3633 continue;
3634
5207e10e
TI		 3635 if (active_mics == 1)
3636 label = "Digital Mic";
3637 else
3638 label = stac92xx_dmic_labels[dimux->num_items];
3639
667067d8
TI		 3640 err = create_elem_capture_vol(codec, nid, label);
3641 if (err < 0)
3642 return err;
0678accd 3643
5207e10e 3644 dimux->items[dimux->num_items].label = label;
8b65727b
MP		 3645 dimux->items[dimux->num_items].index = index;
3646 dimux->num_items++;
5207e10e
TI		 3647 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) {
3648 imux->items[imux->num_items].label = label;
3649 imux->items[imux->num_items].index = index;
3650 imux->num_items++;
3651 }
8b65727b
MP		 3652 }
3653
3654 return 0;
3655}
3656
3d21d3f7
TI		 3657static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3658 hda_nid_t *fixed, hda_nid_t *ext)
3659{
3660 unsigned int cfg;
3661
3662 if (!nid)
3663 return 0;
3664 cfg = snd_hda_codec_get_pincfg(codec, nid);
3665 switch (get_defcfg_connect(cfg)) {
3666 case AC_JACK_PORT_FIXED:
3667 if (*fixed)
3668 return 1; /* already occupied */
3669 *fixed = nid;
3670 break;
3671 case AC_JACK_PORT_COMPLEX:
3672 if (*ext)
3673 return 1; /* already occupied */
3674 *ext = nid;
3675 break;
3676 }
3677 return 0;
3678}
3679
3680static int set_mic_route(struct hda_codec *codec,
3681 struct sigmatel_mic_route *mic,
3682 hda_nid_t pin)
3683{
3684 struct sigmatel_spec *spec = codec->spec;
3685 struct auto_pin_cfg *cfg = &spec->autocfg;
3686 int i;
3687
3688 mic->pin = pin;
3689 for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++)
3690 if (pin == cfg->input_pins[i])
3691 break;
3692 if (i <= AUTO_PIN_FRONT_MIC) {
3693 /* analog pin */
3694 mic->dmux_idx = 0;
3695 i = get_connection_index(codec, spec->mux_nids[0], pin);
3696 if (i < 0)
3697 return -1;
3698 mic->mux_idx = i;
da2a2aaa 3699 } else if (spec->dmux_nids) {
3d21d3f7
TI		 3700 /* digital pin */
3701 mic->mux_idx = 0;
3702 i = get_connection_index(codec, spec->dmux_nids[0], pin);
3703 if (i < 0)
3704 return -1;
3705 mic->dmux_idx = i;
3706 }
3707 return 0;
3708}
3709
3710/* return non-zero if the device is for automatic mic switch */
3711static int stac_check_auto_mic(struct hda_codec *codec)
3712{
3713 struct sigmatel_spec *spec = codec->spec;
3714 struct auto_pin_cfg *cfg = &spec->autocfg;
3715 hda_nid_t fixed, ext;
3716 int i;
3717
3718 for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++) {
3719 if (cfg->input_pins[i])
3720 return 0; /* must be exclusively mics */
3721 }
3722 fixed = ext = 0;
3723 for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++)
3724 if (check_mic_pin(codec, cfg->input_pins[i], &fixed, &ext))
3725 return 0;
3726 for (i = 0; i < spec->num_dmics; i++)
3727 if (check_mic_pin(codec, spec->dmic_nids[i], &fixed, &ext))
3728 return 0;
3729 if (!fixed || !ext)
3730 return 0;
3731 if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
3732 return 0; /* no unsol support */
3733 if (set_mic_route(codec, &spec->ext_mic, ext) ||
3734 set_mic_route(codec, &spec->int_mic, fixed))
3735 return 0; /* something is wrong */
3736 return 1;
3737}
3738
c7d4b2fa
M		 3739/* create playback/capture controls for input pins */
3740static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3741{
3742 struct sigmatel_spec *spec = codec->spec;
c7d4b2fa 3743 struct hda_input_mux *imux = &spec->private_imux;
667067d8 3744 int i, j;
c7d4b2fa
M		 3745
3746 for (i = 0; i < AUTO_PIN_LAST; i++) {
667067d8
TI		 3747 hda_nid_t nid = cfg->input_pins[i];
3748 int index, err;
314634bc 3749
667067d8 3750 if (!nid)
314634bc
TI		 3751 continue;
3752 index = -1;
3753 for (j = 0; j < spec->num_muxes; j++) {
667067d8
TI		 3754 index = get_connection_index(codec, spec->mux_nids[j],
3755 nid);
3756 if (index >= 0)
3757 break;
c7d4b2fa 3758 }
667067d8
TI		 3759 if (index < 0)
3760 continue;
3761
3762 err = create_elem_capture_vol(codec, nid,
3763 auto_pin_cfg_labels[i]);
3764 if (err < 0)
3765 return err;
3766
314634bc
TI		 3767 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
3768 imux->items[imux->num_items].index = index;
3769 imux->num_items++;
c7d4b2fa 3770 }
5207e10e 3771 spec->num_analog_muxes = imux->num_items;
c7d4b2fa 3772
7b043899 3773 if (imux->num_items) {
62fe78e9
SR		 3774 /*
3775 * Set the current input for the muxes.
3776 * The STAC9221 has two input muxes with identical source
3777 * NID lists. Hopefully this won't get confused.
3778 */
3779 for (i = 0; i < spec->num_muxes; i++) {
82beb8fd
TI		 3780 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3781 AC_VERB_SET_CONNECT_SEL,
3782 imux->items[0].index);
62fe78e9
SR		 3783 }
3784 }
3785
c7d4b2fa
M		 3786 return 0;
3787}
3788
c7d4b2fa
M		 3789static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3790{
3791 struct sigmatel_spec *spec = codec->spec;
3792 int i;
3793
3794 for (i = 0; i < spec->autocfg.line_outs; i++) {
3795 hda_nid_t nid = spec->autocfg.line_out_pins[i];
3796 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3797 }
3798}
3799
3800static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3801{
3802 struct sigmatel_spec *spec = codec->spec;
eb06ed8f 3803 int i;
c7d4b2fa 3804
eb06ed8f
TI		 3805 for (i = 0; i < spec->autocfg.hp_outs; i++) {
3806 hda_nid_t pin;
3807 pin = spec->autocfg.hp_pins[i];
3808 if (pin) /* connect to front */
3809 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3810 }
3811 for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3812 hda_nid_t pin;
3813 pin = spec->autocfg.speaker_pins[i];
3814 if (pin) /* connect to front */
3815 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3816 }
c7d4b2fa
M		 3817}
3818
3cc08dc6 3819static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
c7d4b2fa
M		 3820{
3821 struct sigmatel_spec *spec = codec->spec;
dc04d1b4 3822 int hp_swap = 0;
6479c631 3823 int i, err;
c7d4b2fa 3824
8b65727b
MP		 3825 if ((err = snd_hda_parse_pin_def_config(codec,
3826 &spec->autocfg,
3827 spec->dmic_nids)) < 0)
c7d4b2fa 3828 return err;
82bc955f 3829 if (! spec->autocfg.line_outs)
869264c4 3830 return 0; /* can't find valid pin config */
19039bd0 3831
bcecd9bd
JZ		 3832 /* If we have no real line-out pin and multiple hp-outs, HPs should
3833 * be set up as multi-channel outputs.
3834 */
3835 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
3836 spec->autocfg.hp_outs > 1) {
3837 /* Copy hp_outs to line_outs, backup line_outs in
3838 * speaker_outs so that the following routines can handle
3839 * HP pins as primary outputs.
3840 */
c21ca4a8 3841 snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
bcecd9bd
JZ		 3842 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3843 sizeof(spec->autocfg.line_out_pins));
3844 spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3845 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3846 sizeof(spec->autocfg.hp_pins));
3847 spec->autocfg.line_outs = spec->autocfg.hp_outs;
c21ca4a8
TI		 3848 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3849 spec->autocfg.hp_outs = 0;
dc04d1b4 3850 hp_swap = 1;
bcecd9bd 3851 }
09a99959 3852 if (spec->autocfg.mono_out_pin) {
d0513fc6
MR		 3853 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3854 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
09a99959
MR		 3855 u32 caps = query_amp_caps(codec,
3856 spec->autocfg.mono_out_pin, dir);
3857 hda_nid_t conn_list[1];
3858
3859 /* get the mixer node and then the mono mux if it exists */
3860 if (snd_hda_get_connections(codec,
3861 spec->autocfg.mono_out_pin, conn_list, 1) &&
3862 snd_hda_get_connections(codec, conn_list[0],
16a433d8 3863 conn_list, 1) > 0) {
09a99959
MR		 3864
3865 int wcaps = get_wcaps(codec, conn_list[0]);
a22d543a 3866 int wid_type = get_wcaps_type(wcaps);
09a99959
MR		 3867 /* LR swap check, some stac925x have a mux that
3868 * changes the DACs output path instead of the
3869 * mono-mux path.
3870 */
3871 if (wid_type == AC_WID_AUD_SEL &&
3872 !(wcaps & AC_WCAP_LR_SWAP))
3873 spec->mono_nid = conn_list[0];
3874 }
d0513fc6
MR		 3875 if (dir) {
3876 hda_nid_t nid = spec->autocfg.mono_out_pin;
3877
3878 /* most mono outs have a least a mute/unmute switch */
3879 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3880 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3881 "Mono Playback Switch",
3882 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
09a99959
MR		 3883 if (err < 0)
3884 return err;
d0513fc6
MR		 3885 /* check for volume support for the amp */
3886 if ((caps & AC_AMPCAP_NUM_STEPS)
3887 >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3888 err = stac92xx_add_control(spec,
3889 STAC_CTL_WIDGET_VOL,
3890 "Mono Playback Volume",
3891 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3892 if (err < 0)
3893 return err;
3894 }
09a99959
MR		 3895 }
3896
3897 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3898 AC_PINCTL_OUT_EN);
3899 }
bcecd9bd 3900
c21ca4a8
TI		 3901 if (!spec->multiout.num_dacs) {
3902 err = stac92xx_auto_fill_dac_nids(codec);
3903 if (err < 0)
19039bd0 3904 return err;
c9280d68
TI		 3905 err = stac92xx_auto_create_multi_out_ctls(codec,
3906 &spec->autocfg);
3907 if (err < 0)
3908 return err;
c21ca4a8 3909 }
c7d4b2fa 3910
1cd2224c
MR		 3911 /* setup analog beep controls */
3912 if (spec->anabeep_nid > 0) {
3913 err = stac92xx_auto_create_beep_ctls(codec,
3914 spec->anabeep_nid);
3915 if (err < 0)
3916 return err;
3917 }
3918
3919 /* setup digital beep controls and input device */
3920#ifdef CONFIG_SND_HDA_INPUT_BEEP
3921 if (spec->digbeep_nid > 0) {
3922 hda_nid_t nid = spec->digbeep_nid;
4d4e9bb3 3923 unsigned int caps;
1cd2224c
MR		 3924
3925 err = stac92xx_auto_create_beep_ctls(codec, nid);
3926 if (err < 0)
3927 return err;
3928 err = snd_hda_attach_beep_device(codec, nid);
3929 if (err < 0)
3930 return err;
fa797966
TI		 3931 /* IDT/STAC codecs have linear beep tone parameter */
3932 codec->beep->linear_tone = 1;
4d4e9bb3
TI		 3933 /* if no beep switch is available, make its own one */
3934 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3935 if (codec->beep &&
3936 !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
3937 err = stac92xx_beep_switch_ctl(codec);
3938 if (err < 0)
3939 return err;
3940 }
1cd2224c
MR		 3941 }
3942#endif
3943
0fb87bb4 3944 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
0fb87bb4
ML		 3945 if (err < 0)
3946 return err;
3947
dc04d1b4
TI		 3948 /* All output parsing done, now restore the swapped hp pins */
3949 if (hp_swap) {
3950 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3951 sizeof(spec->autocfg.hp_pins));
3952 spec->autocfg.hp_outs = spec->autocfg.line_outs;
3953 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3954 spec->autocfg.line_outs = 0;
3955 }
0fb87bb4 3956
3d21d3f7
TI		 3957 if (stac_check_auto_mic(codec)) {
3958 spec->auto_mic = 1;
3959 /* only one capture for auto-mic */
3960 spec->num_adcs = 1;
3961 spec->num_caps = 1;
3962 spec->num_muxes = 1;
3963 }
3964
6479c631
TI		 3965 for (i = 0; i < spec->num_caps; i++) {
3966 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
3967 spec->capsws[i], i);
3968 if (err < 0)
3969 return err;
3970 }
3971
dc04d1b4 3972 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
0fb87bb4 3973 if (err < 0)
c7d4b2fa
M		 3974 return err;
3975
b22b4821
MR		 3976 if (spec->mono_nid > 0) {
3977 err = stac92xx_auto_create_mono_output_ctls(codec);
3978 if (err < 0)
3979 return err;
3980 }
2a9c7816 3981 if (spec->num_amps > 0) {
89385035
MR		 3982 err = stac92xx_auto_create_amp_output_ctls(codec);
3983 if (err < 0)
3984 return err;
3985 }
2a9c7816 3986 if (spec->num_dmics > 0 && !spec->dinput_mux)
8b65727b
MP		 3987 if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3988 &spec->autocfg)) < 0)
3989 return err;
4682eee0
MR		 3990 if (spec->num_muxes > 0) {
3991 err = stac92xx_auto_create_mux_input_ctls(codec);
3992 if (err < 0)
3993 return err;
3994 }
d9737751
MR		 3995 if (spec->num_smuxes > 0) {
3996 err = stac92xx_auto_create_spdif_mux_ctls(codec);
3997 if (err < 0)
3998 return err;
3999 }
8b65727b 4000
e3c75964
TI		 4001 err = stac92xx_add_input_source(spec);
4002 if (err < 0)
4003 return err;
4004
c7d4b2fa 4005 spec->multiout.max_channels = spec->multiout.num_dacs * 2;
403d1944 4006 if (spec->multiout.max_channels > 2)
c7d4b2fa 4007 spec->surr_switch = 1;
c7d4b2fa 4008
0852d7a6 4009 if (spec->autocfg.dig_outs)
3cc08dc6 4010 spec->multiout.dig_out_nid = dig_out;
d0513fc6 4011 if (dig_in && spec->autocfg.dig_in_pin)
3cc08dc6 4012 spec->dig_in_nid = dig_in;
c7d4b2fa 4013
603c4019
TI		 4014 if (spec->kctls.list)
4015 spec->mixers[spec->num_mixers++] = spec->kctls.list;
c7d4b2fa
M		 4016
4017 spec->input_mux = &spec->private_imux;
f8ccbf65
MR		 4018 if (!spec->dinput_mux)
4019 spec->dinput_mux = &spec->private_dimux;
d9737751 4020 spec->sinput_mux = &spec->private_smux;
b22b4821 4021 spec->mono_mux = &spec->private_mono_mux;
89385035 4022 spec->amp_mux = &spec->private_amp_mux;
c7d4b2fa
M		 4023 return 1;
4024}
4025
82bc955f
TI		 4026/* add playback controls for HP output */
4027static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
4028 struct auto_pin_cfg *cfg)
4029{
4030 struct sigmatel_spec *spec = codec->spec;
eb06ed8f 4031 hda_nid_t pin = cfg->hp_pins[0];
82bc955f
TI		 4032 unsigned int wid_caps;
4033
4034 if (! pin)
4035 return 0;
4036
4037 wid_caps = get_wcaps(codec, pin);
505cb341 4038 if (wid_caps & AC_WCAP_UNSOL_CAP)
82bc955f 4039 spec->hp_detect = 1;
82bc955f
TI		 4040
4041 return 0;
4042}
4043
160ea0dc
RF		 4044/* add playback controls for LFE output */
4045static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
4046 struct auto_pin_cfg *cfg)
4047{
4048 struct sigmatel_spec *spec = codec->spec;
4049 int err;
4050 hda_nid_t lfe_pin = 0x0;
4051 int i;
4052
4053 /*
4054 * search speaker outs and line outs for a mono speaker pin
4055 * with an amp. If one is found, add LFE controls
4056 * for it.
4057 */
4058 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
4059 hda_nid_t pin = spec->autocfg.speaker_pins[i];
64ed0dfd 4060 unsigned int wcaps = get_wcaps(codec, pin);
160ea0dc
RF		 4061 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
4062 if (wcaps == AC_WCAP_OUT_AMP)
4063 /* found a mono speaker with an amp, must be lfe */
4064 lfe_pin = pin;
4065 }
4066
4067 /* if speaker_outs is 0, then speakers may be in line_outs */
4068 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
4069 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
4070 hda_nid_t pin = spec->autocfg.line_out_pins[i];
64ed0dfd 4071 unsigned int defcfg;
330ee995 4072 defcfg = snd_hda_codec_get_pincfg(codec, pin);
8b551785 4073 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
64ed0dfd 4074 unsigned int wcaps = get_wcaps(codec, pin);
160ea0dc
RF		 4075 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
4076 if (wcaps == AC_WCAP_OUT_AMP)
4077 /* found a mono speaker with an amp,
4078 must be lfe */
4079 lfe_pin = pin;
4080 }
4081 }
4082 }
4083
4084 if (lfe_pin) {
7c7767eb 4085 err = create_controls(codec, "LFE", lfe_pin, 1);
160ea0dc
RF		 4086 if (err < 0)
4087 return err;
4088 }
4089
4090 return 0;
4091}
4092
c7d4b2fa
M		 4093static int stac9200_parse_auto_config(struct hda_codec *codec)
4094{
4095 struct sigmatel_spec *spec = codec->spec;
4096 int err;
4097
df694daa 4098 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
c7d4b2fa
M		 4099 return err;
4100
4101 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
4102 return err;
4103
82bc955f
TI		 4104 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
4105 return err;
4106
160ea0dc
RF		 4107 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
4108 return err;
4109
355a0ec4
TI		 4110 if (spec->num_muxes > 0) {
4111 err = stac92xx_auto_create_mux_input_ctls(codec);
4112 if (err < 0)
4113 return err;
4114 }
4115
e3c75964
TI		 4116 err = stac92xx_add_input_source(spec);
4117 if (err < 0)
4118 return err;
4119
0852d7a6 4120 if (spec->autocfg.dig_outs)
c7d4b2fa 4121 spec->multiout.dig_out_nid = 0x05;
82bc955f 4122 if (spec->autocfg.dig_in_pin)
c7d4b2fa 4123 spec->dig_in_nid = 0x04;
c7d4b2fa 4124
603c4019
TI		 4125 if (spec->kctls.list)
4126 spec->mixers[spec->num_mixers++] = spec->kctls.list;
c7d4b2fa
M		 4127
4128 spec->input_mux = &spec->private_imux;
8b65727b 4129 spec->dinput_mux = &spec->private_dimux;
c7d4b2fa
M		 4130
4131 return 1;
4132}
4133
62fe78e9
SR		 4134/*
4135 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
4136 * funky external mute control using GPIO pins.
4137 */
4138
76e1ddfb 4139static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4fe5195c 4140 unsigned int dir_mask, unsigned int data)
62fe78e9
SR		 4141{
4142 unsigned int gpiostate, gpiomask, gpiodir;
4143
4144 gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4145 AC_VERB_GET_GPIO_DATA, 0);
4fe5195c 4146 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
62fe78e9
SR		 4147
4148 gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4149 AC_VERB_GET_GPIO_MASK, 0);
76e1ddfb 4150 gpiomask |= mask;
62fe78e9
SR		 4151
4152 gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4153 AC_VERB_GET_GPIO_DIRECTION, 0);
4fe5195c 4154 gpiodir |= dir_mask;
62fe78e9 4155
76e1ddfb 4156 /* Configure GPIOx as CMOS */
62fe78e9
SR		 4157 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4158
4159 snd_hda_codec_write(codec, codec->afg, 0,
4160 AC_VERB_SET_GPIO_MASK, gpiomask);
76e1ddfb
TI		 4161 snd_hda_codec_read(codec, codec->afg, 0,
4162 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
62fe78e9
SR		 4163
4164 msleep(1);
4165
76e1ddfb
TI		 4166 snd_hda_codec_read(codec, codec->afg, 0,
4167 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
62fe78e9
SR		 4168}
4169
8c8145b8 4170#ifdef CONFIG_SND_HDA_INPUT_JACK
95c09099
TI		 4171static void stac92xx_free_jack_priv(struct snd_jack *jack)
4172{
4173 struct sigmatel_jack *jacks = jack->private_data;
4174 jacks->nid = 0;
4175 jacks->jack = NULL;
4176}
4177#endif
4178
74aeaabc
MR		 4179static int stac92xx_add_jack(struct hda_codec *codec,
4180 hda_nid_t nid, int type)
4181{
8c8145b8 4182#ifdef CONFIG_SND_HDA_INPUT_JACK
74aeaabc
MR		 4183 struct sigmatel_spec *spec = codec->spec;
4184 struct sigmatel_jack *jack;
330ee995 4185 int def_conf = snd_hda_codec_get_pincfg(codec, nid);
74aeaabc
MR		 4186 int connectivity = get_defcfg_connect(def_conf);
4187 char name[32];
95c09099 4188 int err;
74aeaabc
MR		 4189
4190 if (connectivity && connectivity != AC_JACK_PORT_FIXED)
4191 return 0;
4192
4193 snd_array_init(&spec->jacks, sizeof(*jack), 32);
4194 jack = snd_array_new(&spec->jacks);
4195 if (!jack)
4196 return -ENOMEM;
4197 jack->nid = nid;
4198 jack->type = type;
4199
86de7416 4200 snprintf(name, sizeof(name), "%s at %s %s Jack",
74aeaabc
MR		 4201 snd_hda_get_jack_type(def_conf),
4202 snd_hda_get_jack_connectivity(def_conf),
4203 snd_hda_get_jack_location(def_conf));
4204
95c09099
TI		 4205 err = snd_jack_new(codec->bus->card, name, type, &jack->jack);
4206 if (err < 0) {
4207 jack->nid = 0;
4208 return err;
4209 }
4210 jack->jack->private_data = jack;
4211 jack->jack->private_free = stac92xx_free_jack_priv;
e4973e1e 4212#endif
95c09099 4213 return 0;
74aeaabc
MR		 4214}
4215
c6e4c666
TI		 4216static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
4217 unsigned char type, int data)
74aeaabc
MR		 4218{
4219 struct sigmatel_event *event;
4220
4221 snd_array_init(&spec->events, sizeof(*event), 32);
4222 event = snd_array_new(&spec->events);
4223 if (!event)
4224 return -ENOMEM;
4225 event->nid = nid;
c6e4c666
TI		 4226 event->type = type;
4227 event->tag = spec->events.used;
74aeaabc
MR		 4228 event->data = data;
4229
c6e4c666 4230 return event->tag;
74aeaabc
MR		 4231}
4232
c6e4c666 4233static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
62558ce1 4234 hda_nid_t nid)
74aeaabc
MR		 4235{
4236 struct sigmatel_spec *spec = codec->spec;
c6e4c666
TI		 4237 struct sigmatel_event *event = spec->events.list;
4238 int i;
4239
4240 for (i = 0; i < spec->events.used; i++, event++) {
62558ce1 4241 if (event->nid == nid)
c6e4c666 4242 return event;
74aeaabc 4243 }
c6e4c666 4244 return NULL;
74aeaabc
MR		 4245}
4246
c6e4c666
TI		 4247static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
4248 unsigned char tag)
314634bc 4249{
c6e4c666
TI		 4250 struct sigmatel_spec *spec = codec->spec;
4251 struct sigmatel_event *event = spec->events.list;
4252 int i;
4253
4254 for (i = 0; i < spec->events.used; i++, event++) {
4255 if (event->tag == tag)
4256 return event;
74aeaabc 4257 }
c6e4c666
TI		 4258 return NULL;
4259}
4260
62558ce1
TI		 4261/* check if given nid is a valid pin and no other events are assigned
4262 * to it. If OK, assign the event, set the unsol flag, and returns 1.
4263 * Otherwise, returns zero.
4264 */
4265static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4266 unsigned int type)
c6e4c666
TI		 4267{
4268 struct sigmatel_event *event;
4269 int tag;
4270
4271 if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
62558ce1
TI		 4272 return 0;
4273 event = stac_get_event(codec, nid);
4274 if (event) {
4275 if (event->type != type)
4276 return 0;
c6e4c666 4277 tag = event->tag;
62558ce1 4278 } else {
c6e4c666 4279 tag = stac_add_event(codec->spec, nid, type, 0);
62558ce1
TI		 4280 if (tag < 0)
4281 return 0;
4282 }
c6e4c666
TI		 4283 snd_hda_codec_write_cache(codec, nid, 0,
4284 AC_VERB_SET_UNSOLICITED_ENABLE,
4285 AC_USRSP_EN | tag);
62558ce1 4286 return 1;
314634bc
TI		 4287}
4288
a64135a2
MR		 4289static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4290{
4291 int i;
4292 for (i = 0; i < cfg->hp_outs; i++)
4293 if (cfg->hp_pins[i] == nid)
4294 return 1; /* nid is a HP-Out */
4295
4296 return 0; /* nid is not a HP-Out */
4297};
4298
b76c850f
MR		 4299static void stac92xx_power_down(struct hda_codec *codec)
4300{
4301 struct sigmatel_spec *spec = codec->spec;
4302
4303 /* power down inactive DACs */
4304 hda_nid_t *dac;
4305 for (dac = spec->dac_list; *dac; dac++)
c21ca4a8 4306 if (!check_all_dac_nids(spec, *dac))
8c2f767b 4307 snd_hda_codec_write(codec, *dac, 0,
b76c850f
MR		 4308 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4309}
4310
f73d3585
TI		 4311static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4312 int enable);
4313
6565e4fa
TI		 4314/* override some hints from the hwdep entry */
4315static void stac_store_hints(struct hda_codec *codec)
4316{
4317 struct sigmatel_spec *spec = codec->spec;
4318 const char *p;
4319 int val;
4320
4321 val = snd_hda_get_bool_hint(codec, "hp_detect");
4322 if (val >= 0)
4323 spec->hp_detect = val;
4324 p = snd_hda_get_hint(codec, "gpio_mask");
4325 if (p) {
4326 spec->gpio_mask = simple_strtoul(p, NULL, 0);
4327 spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4328 spec->gpio_mask;
4329 }
4330 p = snd_hda_get_hint(codec, "gpio_dir");
4331 if (p)
4332 spec->gpio_dir = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
4333 p = snd_hda_get_hint(codec, "gpio_data");
4334 if (p)
4335 spec->gpio_data = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
4336 p = snd_hda_get_hint(codec, "eapd_mask");
4337 if (p)
4338 spec->eapd_mask = simple_strtoul(p, NULL, 0) & spec->gpio_mask;
4339 val = snd_hda_get_bool_hint(codec, "eapd_switch");
4340 if (val >= 0)
4341 spec->eapd_switch = val;
4342}
4343
c7d4b2fa
M		 4344static int stac92xx_init(struct hda_codec *codec)
4345{
4346 struct sigmatel_spec *spec = codec->spec;
82bc955f 4347 struct auto_pin_cfg *cfg = &spec->autocfg;
f73d3585 4348 unsigned int gpio;
e4973e1e 4349 int i;
c7d4b2fa 4350
c7d4b2fa
M		 4351 snd_hda_sequence_write(codec, spec->init);
4352
8daaaa97
MR		 4353 /* power down adcs initially */
4354 if (spec->powerdown_adcs)
4355 for (i = 0; i < spec->num_adcs; i++)
8c2f767b 4356 snd_hda_codec_write(codec,
8daaaa97
MR		 4357 spec->adc_nids[i], 0,
4358 AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
f73d3585 4359
6565e4fa
TI		 4360 /* override some hints */
4361 stac_store_hints(codec);
4362
f73d3585
TI		 4363 /* set up GPIO */
4364 gpio = spec->gpio_data;
4365 /* turn on EAPD statically when spec->eapd_switch isn't set.
4366 * otherwise, unsol event will turn it on/off dynamically
4367 */
4368 if (!spec->eapd_switch)
4369 gpio |= spec->eapd_mask;
4370 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4371
82bc955f
TI		 4372 /* set up pins */
4373 if (spec->hp_detect) {
505cb341 4374 /* Enable unsolicited responses on the HP widget */
74aeaabc 4375 for (i = 0; i < cfg->hp_outs; i++) {
74aeaabc 4376 hda_nid_t nid = cfg->hp_pins[i];
c6e4c666 4377 enable_pin_detect(codec, nid, STAC_HP_EVENT);
74aeaabc 4378 }
1c4bdf9b
TI		 4379 if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4380 cfg->speaker_outs > 0) {
fefd67f3 4381 /* enable pin-detect for line-outs as well */
15cfa2b3
TI		 4382 for (i = 0; i < cfg->line_outs; i++) {
4383 hda_nid_t nid = cfg->line_out_pins[i];
fefd67f3
TI		 4384 enable_pin_detect(codec, nid, STAC_LO_EVENT);
4385 }
4386 }
4387
0a07acaf
TI		 4388 /* force to enable the first line-out; the others are set up
4389 * in unsol_event
4390 */
4391 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
74aeaabc 4392 AC_PINCTL_OUT_EN);
82bc955f 4393 /* fake event to set up pins */
62558ce1 4394 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
82bc955f
TI		 4395 } else {
4396 stac92xx_auto_init_multi_out(codec);
4397 stac92xx_auto_init_hp_out(codec);
12dde4c6
TI		 4398 for (i = 0; i < cfg->hp_outs; i++)
4399 stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
82bc955f 4400 }
3d21d3f7 4401 if (spec->auto_mic) {
15b4f296 4402 /* initialize connection to analog input */
da2a2aaa
TI		 4403 if (spec->dmux_nids)
4404 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
15b4f296 4405 AC_VERB_SET_CONNECT_SEL, 0);
3d21d3f7
TI		 4406 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4407 stac_issue_unsol_event(codec, spec->ext_mic.pin);
4408 }
82bc955f 4409 for (i = 0; i < AUTO_PIN_LAST; i++) {
c960a03b
TI		 4410 hda_nid_t nid = cfg->input_pins[i];
4411 if (nid) {
12dde4c6 4412 unsigned int pinctl, conf;
4f1e6bc3
TI		 4413 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
4414 /* for mic pins, force to initialize */
7c922de7 4415 pinctl = stac92xx_get_default_vref(codec, nid);
12dde4c6
TI		 4416 pinctl |= AC_PINCTL_IN_EN;
4417 stac92xx_auto_set_pinctl(codec, nid, pinctl);
4f1e6bc3
TI		 4418 } else {
4419 pinctl = snd_hda_codec_read(codec, nid, 0,
4420 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4421 /* if PINCTL already set then skip */
5dd17cb9
TI		 4422 /* Also, if both INPUT and OUTPUT are set,
4423 * it must be a BIOS bug; need to override, too
4424 */
4425 if (!(pinctl & AC_PINCTL_IN_EN) ||
4426 (pinctl & AC_PINCTL_OUT_EN)) {
4427 pinctl &= ~AC_PINCTL_OUT_EN;
12dde4c6
TI		 4428 pinctl |= AC_PINCTL_IN_EN;
4429 stac92xx_auto_set_pinctl(codec, nid,
4430 pinctl);
4431 }
4432 }
330ee995 4433 conf = snd_hda_codec_get_pincfg(codec, nid);
12dde4c6 4434 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
62558ce1
TI		 4435 if (enable_pin_detect(codec, nid,
4436 STAC_INSERT_EVENT))
4437 stac_issue_unsol_event(codec, nid);
4f1e6bc3 4438 }
c960a03b 4439 }
82bc955f 4440 }
a64135a2
MR		 4441 for (i = 0; i < spec->num_dmics; i++)
4442 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4443 AC_PINCTL_IN_EN);
0852d7a6
TI		 4444 if (cfg->dig_out_pins[0])
4445 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
f73d3585
TI		 4446 AC_PINCTL_OUT_EN);
4447 if (cfg->dig_in_pin)
4448 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4449 AC_PINCTL_IN_EN);
a64135a2 4450 for (i = 0; i < spec->num_pwrs; i++) {
f73d3585
TI		 4451 hda_nid_t nid = spec->pwr_nids[i];
4452 int pinctl, def_conf;
f73d3585 4453
eb632128
TI		 4454 /* power on when no jack detection is available */
4455 if (!spec->hp_detect) {
4456 stac_toggle_power_map(codec, nid, 1);
4457 continue;
4458 }
4459
4460 if (is_nid_hp_pin(cfg, nid))
f73d3585
TI		 4461 continue; /* already has an unsol event */
4462
4463 pinctl = snd_hda_codec_read(codec, nid, 0,
4464 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
a64135a2
MR		 4465 /* outputs are only ports capable of power management
4466 * any attempts on powering down a input port cause the
4467 * referenced VREF to act quirky.
4468 */
eb632128
TI		 4469 if (pinctl & AC_PINCTL_IN_EN) {
4470 stac_toggle_power_map(codec, nid, 1);
a64135a2 4471 continue;
eb632128 4472 }
330ee995 4473 def_conf = snd_hda_codec_get_pincfg(codec, nid);
f73d3585 4474 def_conf = get_defcfg_connect(def_conf);
aafc4412
MR		 4475 /* skip any ports that don't have jacks since presence
4476 * detection is useless */
f73d3585
TI		 4477 if (def_conf != AC_JACK_PORT_COMPLEX) {
4478 if (def_conf != AC_JACK_PORT_NONE)
4479 stac_toggle_power_map(codec, nid, 1);
bce6c2b5 4480 continue;
f73d3585 4481 }
62558ce1
TI		 4482 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT))
4483 stac_issue_unsol_event(codec, nid);
a64135a2 4484 }
b76c850f
MR		 4485 if (spec->dac_list)
4486 stac92xx_power_down(codec);
c7d4b2fa
M		 4487 return 0;
4488}
4489
74aeaabc
MR		 4490static void stac92xx_free_jacks(struct hda_codec *codec)
4491{
8c8145b8 4492#ifdef CONFIG_SND_HDA_INPUT_JACK
b94d3539 4493 /* free jack instances manually when clearing/reconfiguring */
74aeaabc 4494 struct sigmatel_spec *spec = codec->spec;
b94d3539 4495 if (!codec->bus->shutdown && spec->jacks.list) {
74aeaabc
MR		 4496 struct sigmatel_jack *jacks = spec->jacks.list;
4497 int i;
95c09099
TI		 4498 for (i = 0; i < spec->jacks.used; i++, jacks++) {
4499 if (jacks->jack)
4500 snd_device_free(codec->bus->card, jacks->jack);
4501 }
74aeaabc
MR		 4502 }
4503 snd_array_free(&spec->jacks);
e4973e1e 4504#endif
74aeaabc
MR		 4505}
4506
603c4019
TI		 4507static void stac92xx_free_kctls(struct hda_codec *codec)
4508{
4509 struct sigmatel_spec *spec = codec->spec;
4510
4511 if (spec->kctls.list) {
4512 struct snd_kcontrol_new *kctl = spec->kctls.list;
4513 int i;
4514 for (i = 0; i < spec->kctls.used; i++)
4515 kfree(kctl[i].name);
4516 }
4517 snd_array_free(&spec->kctls);
4518}
4519
2f2f4251
M		 4520static void stac92xx_free(struct hda_codec *codec)
4521{
c7d4b2fa 4522 struct sigmatel_spec *spec = codec->spec;
c7d4b2fa
M		 4523
4524 if (! spec)
4525 return;
4526
74aeaabc
MR		 4527 stac92xx_free_jacks(codec);
4528 snd_array_free(&spec->events);
11b44bbd 4529
c7d4b2fa 4530 kfree(spec);
1cd2224c 4531 snd_hda_detach_beep_device(codec);
2f2f4251
M		 4532}
4533
4e55096e
M		 4534static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4535 unsigned int flag)
4536{
8ce84198
TI		 4537 unsigned int old_ctl, pin_ctl;
4538
4539 pin_ctl = snd_hda_codec_read(codec, nid,
4e55096e 4540 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
7b043899 4541
f9acba43
TI		 4542 if (pin_ctl & AC_PINCTL_IN_EN) {
4543 /*
4544 * we need to check the current set-up direction of
4545 * shared input pins since they can be switched via
4546 * "xxx as Output" mixer switch
4547 */
4548 struct sigmatel_spec *spec = codec->spec;
c21ca4a8 4549 if (nid == spec->line_switch || nid == spec->mic_switch)
f9acba43
TI		 4550 return;
4551 }
4552
8ce84198 4553 old_ctl = pin_ctl;
7b043899
SL		 4554 /* if setting pin direction bits, clear the current
4555 direction bits first */
4556 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4557 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4558
8ce84198
TI		 4559 pin_ctl |= flag;
4560 if (old_ctl != pin_ctl)
4561 snd_hda_codec_write_cache(codec, nid, 0,
4562 AC_VERB_SET_PIN_WIDGET_CONTROL,
4563 pin_ctl);
4e55096e
M		 4564}
4565
4566static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4567 unsigned int flag)
4568{
4569 unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4570 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
8ce84198
TI		 4571 if (pin_ctl & flag)
4572 snd_hda_codec_write_cache(codec, nid, 0,
4573 AC_VERB_SET_PIN_WIDGET_CONTROL,
4574 pin_ctl & ~flag);
4e55096e
M		 4575}
4576
e6e3ea25 4577static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
314634bc
TI		 4578{
4579 if (!nid)
4580 return 0;
4581 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
e6e3ea25
TI		 4582 & (1 << 31))
4583 return 1;
314634bc
TI		 4584 return 0;
4585}
4586
fefd67f3
TI		 4587static void stac92xx_line_out_detect(struct hda_codec *codec,
4588 int presence)
4589{
4590 struct sigmatel_spec *spec = codec->spec;
4591 struct auto_pin_cfg *cfg = &spec->autocfg;
4592 int i;
4593
4594 for (i = 0; i < cfg->line_outs; i++) {
4595 if (presence)
4596 break;
4597 presence = get_pin_presence(codec, cfg->line_out_pins[i]);
4598 if (presence) {
4599 unsigned int pinctl;
4600 pinctl = snd_hda_codec_read(codec,
4601 cfg->line_out_pins[i], 0,
4602 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4603 if (pinctl & AC_PINCTL_IN_EN)
4604 presence = 0; /* mic- or line-input */
4605 }
4606 }
4607
4608 if (presence) {
4609 /* disable speakers */
4610 for (i = 0; i < cfg->speaker_outs; i++)
4611 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4612 AC_PINCTL_OUT_EN);
4613 if (spec->eapd_mask && spec->eapd_switch)
4614 stac_gpio_set(codec, spec->gpio_mask,
4615 spec->gpio_dir, spec->gpio_data &
4616 ~spec->eapd_mask);
4617 } else {
4618 /* enable speakers */
4619 for (i = 0; i < cfg->speaker_outs; i++)
4620 stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4621 AC_PINCTL_OUT_EN);
4622 if (spec->eapd_mask && spec->eapd_switch)
4623 stac_gpio_set(codec, spec->gpio_mask,
4624 spec->gpio_dir, spec->gpio_data |
4625 spec->eapd_mask);
4626 }
4627}
4628
d7a89436
TI		 4629/* return non-zero if the hp-pin of the given array index isn't
4630 * a jack-detection target
4631 */
4632static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4633{
4634 struct auto_pin_cfg *cfg = &spec->autocfg;
4635
4636 /* ignore sensing of shared line and mic jacks */
c21ca4a8 4637 if (cfg->hp_pins[i] == spec->line_switch)
d7a89436 4638 return 1;
c21ca4a8 4639 if (cfg->hp_pins[i] == spec->mic_switch)
d7a89436
TI		 4640 return 1;
4641 /* ignore if the pin is set as line-out */
4642 if (cfg->hp_pins[i] == spec->hp_switch)
4643 return 1;
4644 return 0;
4645}
4646
c6e4c666 4647static void stac92xx_hp_detect(struct hda_codec *codec)
4e55096e
M		 4648{
4649 struct sigmatel_spec *spec = codec->spec;
4650 struct auto_pin_cfg *cfg = &spec->autocfg;
4651 int i, presence;
4652
eb06ed8f 4653 presence = 0;
4fe5195c
MR		 4654 if (spec->gpio_mute)
4655 presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4656 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4657
eb06ed8f 4658 for (i = 0; i < cfg->hp_outs; i++) {
314634bc
TI		 4659 if (presence)
4660 break;
d7a89436
TI		 4661 if (no_hp_sensing(spec, i))
4662 continue;
e6e3ea25
TI		 4663 presence = get_pin_presence(codec, cfg->hp_pins[i]);
4664 if (presence) {
4665 unsigned int pinctl;
4666 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4667 AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4668 if (pinctl & AC_PINCTL_IN_EN)
4669 presence = 0; /* mic- or line-input */
4670 }
eb06ed8f 4671 }
4e55096e
M		 4672
4673 if (presence) {
d7a89436 4674 /* disable lineouts */
7c2ba97b 4675 if (spec->hp_switch)
d7a89436
TI		 4676 stac92xx_reset_pinctl(codec, spec->hp_switch,
4677 AC_PINCTL_OUT_EN);
4e55096e
M		 4678 for (i = 0; i < cfg->line_outs; i++)
4679 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4680 AC_PINCTL_OUT_EN);
4e55096e 4681 } else {
d7a89436 4682 /* enable lineouts */
7c2ba97b 4683 if (spec->hp_switch)
d7a89436
TI		 4684 stac92xx_set_pinctl(codec, spec->hp_switch,
4685 AC_PINCTL_OUT_EN);
4e55096e
M		 4686 for (i = 0; i < cfg->line_outs; i++)
4687 stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4688 AC_PINCTL_OUT_EN);
4e55096e 4689 }
fefd67f3 4690 stac92xx_line_out_detect(codec, presence);
d7a89436
TI		 4691 /* toggle hp outs */
4692 for (i = 0; i < cfg->hp_outs; i++) {
4693 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4694 if (no_hp_sensing(spec, i))
4695 continue;
4696 if (presence)
4697 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
8317e0b0
TI		 4698#if 0 /* FIXME */
4699/* Resetting the pinctl like below may lead to (a sort of) regressions
4700 * on some devices since they use the HP pin actually for line/speaker
4701 * outs although the default pin config shows a different pin (that is
4702 * wrong and useless).
4703 *
4704 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4705 * But, disabling the code below just works around it, and I'm too tired of
4706 * bug reports with such devices...
4707 */
d7a89436
TI		 4708 else
4709 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
8317e0b0 4710#endif /* FIXME */
d7a89436 4711 }
4e55096e
M		 4712}
4713
f73d3585
TI		 4714static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4715 int enable)
a64135a2
MR		 4716{
4717 struct sigmatel_spec *spec = codec->spec;
f73d3585
TI		 4718 unsigned int idx, val;
4719
4720 for (idx = 0; idx < spec->num_pwrs; idx++) {
4721 if (spec->pwr_nids[idx] == nid)
4722 break;
4723 }
4724 if (idx >= spec->num_pwrs)
4725 return;
d0513fc6
MR		 4726
4727 /* several codecs have two power down bits */
4728 if (spec->pwr_mapping)
4729 idx = spec->pwr_mapping[idx];
4730 else
4731 idx = 1 << idx;
a64135a2 4732
f73d3585
TI		 4733 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4734 if (enable)
a64135a2
MR		 4735 val &= ~idx;
4736 else
4737 val |= idx;
4738
4739 /* power down unused output ports */
4740 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
74aeaabc
MR		 4741}
4742
f73d3585
TI		 4743static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4744{
e6e3ea25 4745 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
f73d3585 4746}
a64135a2 4747
74aeaabc
MR		 4748static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
4749{
4750 struct sigmatel_spec *spec = codec->spec;
4751 struct sigmatel_jack *jacks = spec->jacks.list;
4752
4753 if (jacks) {
4754 int i;
4755 for (i = 0; i < spec->jacks.used; i++) {
4756 if (jacks->nid == nid) {
4757 unsigned int pin_ctl =
4758 snd_hda_codec_read(codec, nid,
4759 0, AC_VERB_GET_PIN_WIDGET_CONTROL,
4760 0x00);
4761 int type = jacks->type;
4762 if (type == (SND_JACK_LINEOUT
4763 | SND_JACK_HEADPHONE))
4764 type = (pin_ctl & AC_PINCTL_HP_EN)
4765 ? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
4766 snd_jack_report(jacks->jack,
e6e3ea25 4767 get_pin_presence(codec, nid)
74aeaabc
MR		 4768 ? type : 0);
4769 }
4770 jacks++;
4771 }
4772 }
4773}
a64135a2 4774
3d21d3f7
TI		 4775static void stac92xx_mic_detect(struct hda_codec *codec)
4776{
4777 struct sigmatel_spec *spec = codec->spec;
4778 struct sigmatel_mic_route *mic;
4779
4780 if (get_pin_presence(codec, spec->ext_mic.pin))
4781 mic = &spec->ext_mic;
4782 else
4783 mic = &spec->int_mic;
4784 if (mic->dmux_idx)
4785 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4786 AC_VERB_SET_CONNECT_SEL,
4787 mic->dmux_idx);
4788 else
4789 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
4790 AC_VERB_SET_CONNECT_SEL,
4791 mic->mux_idx);
4792}
4793
62558ce1 4794static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
c6e4c666 4795{
62558ce1 4796 struct sigmatel_event *event = stac_get_event(codec, nid);
c6e4c666
TI		 4797 if (!event)
4798 return;
4799 codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4800}
4801
314634bc
TI		 4802static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4803{
a64135a2 4804 struct sigmatel_spec *spec = codec->spec;
c6e4c666
TI		 4805 struct sigmatel_event *event;
4806 int tag, data;
a64135a2 4807
c6e4c666
TI		 4808 tag = (res >> 26) & 0x7f;
4809 event = stac_get_event_from_tag(codec, tag);
4810 if (!event)
4811 return;
4812
4813 switch (event->type) {
314634bc 4814 case STAC_HP_EVENT:
fefd67f3 4815 case STAC_LO_EVENT:
16ffe32c 4816 stac92xx_hp_detect(codec);
fefd67f3 4817 break;
3d21d3f7
TI		 4818 case STAC_MIC_EVENT:
4819 stac92xx_mic_detect(codec);
4820 break;
4821 }
4822
4823 switch (event->type) {
4824 case STAC_HP_EVENT:
fefd67f3 4825 case STAC_LO_EVENT:
3d21d3f7 4826 case STAC_MIC_EVENT:
74aeaabc 4827 case STAC_INSERT_EVENT:
a64135a2 4828 case STAC_PWR_EVENT:
c6e4c666
TI		 4829 if (spec->num_pwrs > 0)
4830 stac92xx_pin_sense(codec, event->nid);
4831 stac92xx_report_jack(codec, event->nid);
fd60cc89
MR		 4832
4833 switch (codec->subsystem_id) {
4834 case 0x103c308f:
4835 if (event->nid == 0xb) {
4836 int pin = AC_PINCTL_IN_EN;
4837
4838 if (get_pin_presence(codec, 0xa)
4839 && get_pin_presence(codec, 0xb))
4840 pin |= AC_PINCTL_VREF_80;
4841 if (!get_pin_presence(codec, 0xb))
4842 pin |= AC_PINCTL_VREF_80;
4843
4844 /* toggle VREF state based on mic + hp pin
4845 * status
4846 */
4847 stac92xx_auto_set_pinctl(codec, 0x0a, pin);
4848 }
4849 }
72474be6 4850 break;
c6e4c666
TI		 4851 case STAC_VREF_EVENT:
4852 data = snd_hda_codec_read(codec, codec->afg, 0,
4853 AC_VERB_GET_GPIO_DATA, 0);
72474be6
MR		 4854 /* toggle VREF state based on GPIOx status */
4855 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
c6e4c666 4856 !!(data & (1 << event->data)));
72474be6 4857 break;
314634bc
TI		 4858 }
4859}
4860
2d34e1b3
TI		 4861#ifdef CONFIG_PROC_FS
4862static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4863 struct hda_codec *codec, hda_nid_t nid)
4864{
4865 if (nid == codec->afg)
4866 snd_iprintf(buffer, "Power-Map: 0x%02x\n",
4867 snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4868}
4869
4870static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
4871 struct hda_codec *codec,
4872 unsigned int verb)
4873{
4874 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
4875 snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
4876}
4877
4878/* stac92hd71bxx, stac92hd73xx */
4879static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4880 struct hda_codec *codec, hda_nid_t nid)
4881{
4882 stac92hd_proc_hook(buffer, codec, nid);
4883 if (nid == codec->afg)
4884 analog_loop_proc_hook(buffer, codec, 0xfa0);
4885}
4886
4887static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4888 struct hda_codec *codec, hda_nid_t nid)
4889{
4890 if (nid == codec->afg)
4891 analog_loop_proc_hook(buffer, codec, 0xfe0);
4892}
4893
4894static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4895 struct hda_codec *codec, hda_nid_t nid)
4896{
4897 if (nid == codec->afg)
4898 analog_loop_proc_hook(buffer, codec, 0xfeb);
4899}
4900#else
4901#define stac92hd_proc_hook NULL
4902#define stac92hd7x_proc_hook NULL
4903#define stac9205_proc_hook NULL
4904#define stac927x_proc_hook NULL
4905#endif
4906
cb53c626 4907#ifdef SND_HDA_NEEDS_RESUME
ff6fdc37
M		 4908static int stac92xx_resume(struct hda_codec *codec)
4909{
dc81bed1
TI		 4910 struct sigmatel_spec *spec = codec->spec;
4911
2c885878 4912 stac92xx_init(codec);
82beb8fd
TI		 4913 snd_hda_codec_resume_amp(codec);
4914 snd_hda_codec_resume_cache(codec);
2c885878 4915 /* fake event to set up pins again to override cached values */
dc81bed1 4916 if (spec->hp_detect)
62558ce1 4917 stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
ff6fdc37
M		 4918 return 0;
4919}
c6798d2b 4920
ae6241fb 4921/*
514bf54c 4922 * using power check for controlling mute led of HP notebooks
ae6241fb
CP		 4923 * check for mute state only on Speakers (nid = 0x10)
4924 *
4925 * For this feature CONFIG_SND_HDA_POWER_SAVE is needed, otherwise
4926 * the LED is NOT working properly !
514bf54c
JG		 4927 *
4928 * Changed name to reflect that it now works for any designated
4929 * model, not just HP HDX.
ae6241fb
CP		 4930 */
4931
4932#ifdef CONFIG_SND_HDA_POWER_SAVE
514bf54c 4933static int stac92xx_hp_check_power_status(struct hda_codec *codec,
6fce61ae 4934 hda_nid_t nid)
ae6241fb
CP		 4935{
4936 struct sigmatel_spec *spec = codec->spec;
6fce61ae
TI		 4937
4938 if (nid == 0x10) {
4939 if (snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
ae6241fb 4940 HDA_AMP_MUTE)
86d190e7 4941 spec->gpio_data &= ~spec->gpio_led; /* orange */
ba84bfcd
TI		 4942 else
4943 spec->gpio_data |= spec->gpio_led; /* white */
6fce61ae
TI		 4944
4945 stac_gpio_set(codec, spec->gpio_mask,
4946 spec->gpio_dir,
ae6241fb
CP		 4947 spec->gpio_data);
4948 }
4949
4950 return 0;
4951}
4952#endif
4953
c6798d2b
MR		 4954static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4955{
4956 struct sigmatel_spec *spec = codec->spec;
05ff7e11
TI		 4957 int i;
4958 hda_nid_t nid;
4959
4960 /* reset each pin before powering down DAC/ADC to avoid click noise */
4961 nid = codec->start_nid;
4962 for (i = 0; i < codec->num_nodes; i++, nid++) {
4963 unsigned int wcaps = get_wcaps(codec, nid);
a22d543a 4964 unsigned int wid_type = get_wcaps_type(wcaps);
05ff7e11
TI		 4965 if (wid_type == AC_WID_PIN)
4966 snd_hda_codec_read(codec, nid, 0,
4967 AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
4968 }
4969
c6798d2b
MR		 4970 if (spec->eapd_mask)
4971 stac_gpio_set(codec, spec->gpio_mask,
4972 spec->gpio_dir, spec->gpio_data &
4973 ~spec->eapd_mask);
4974 return 0;
4975}
ff6fdc37
M		 4976#endif
4977
2f2f4251
M		 4978static struct hda_codec_ops stac92xx_patch_ops = {
4979 .build_controls = stac92xx_build_controls,
4980 .build_pcms = stac92xx_build_pcms,
4981 .init = stac92xx_init,
4982 .free = stac92xx_free,
4e55096e 4983 .unsol_event = stac92xx_unsol_event,
cb53c626 4984#ifdef SND_HDA_NEEDS_RESUME
c6798d2b 4985 .suspend = stac92xx_suspend,
ff6fdc37
M		 4986 .resume = stac92xx_resume,
4987#endif
2f2f4251
M		 4988};
4989
4990static int patch_stac9200(struct hda_codec *codec)
4991{
4992 struct sigmatel_spec *spec;
c7d4b2fa 4993 int err;
2f2f4251 4994
e560d8d8 4995 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2f2f4251
M		 4996 if (spec == NULL)
4997 return -ENOMEM;
4998
4999 codec->spec = spec;
a4eed138 5000 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
11b44bbd 5001 spec->pin_nids = stac9200_pin_nids;
f5fcc13c
TI		 5002 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
5003 stac9200_models,
5004 stac9200_cfg_tbl);
330ee995 5005 if (spec->board_config < 0)
9a11f1aa
TI		 5006 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5007 codec->chip_name);
330ee995
TI		 5008 else
5009 stac92xx_set_config_regs(codec,
af9f341a 5010 stac9200_brd_tbl[spec->board_config]);
2f2f4251
M		 5011
5012 spec->multiout.max_channels = 2;
5013 spec->multiout.num_dacs = 1;
5014 spec->multiout.dac_nids = stac9200_dac_nids;
5015 spec->adc_nids = stac9200_adc_nids;
5016 spec->mux_nids = stac9200_mux_nids;
dabbed6f 5017 spec->num_muxes = 1;
8b65727b 5018 spec->num_dmics = 0;
9e05b7a3 5019 spec->num_adcs = 1;
a64135a2 5020 spec->num_pwrs = 0;
c7d4b2fa 5021
58eec423
MCC		 5022 if (spec->board_config == STAC_9200_M4 ||
5023 spec->board_config == STAC_9200_M4_2 ||
bf277785 5024 spec->board_config == STAC_9200_OQO)
1194b5b7
TI		 5025 spec->init = stac9200_eapd_init;
5026 else
5027 spec->init = stac9200_core_init;
2f2f4251 5028 spec->mixer = stac9200_mixer;
c7d4b2fa 5029
117f257d
TI		 5030 if (spec->board_config == STAC_9200_PANASONIC) {
5031 spec->gpio_mask = spec->gpio_dir = 0x09;
5032 spec->gpio_data = 0x00;
5033 }
5034
c7d4b2fa
M		 5035 err = stac9200_parse_auto_config(codec);
5036 if (err < 0) {
5037 stac92xx_free(codec);
5038 return err;
5039 }
2f2f4251 5040
2acc9dcb
TI		 5041 /* CF-74 has no headphone detection, and the driver should *NOT*
5042 * do detection and HP/speaker toggle because the hardware does it.
5043 */
5044 if (spec->board_config == STAC_9200_PANASONIC)
5045 spec->hp_detect = 0;
5046
2f2f4251
M		 5047 codec->patch_ops = stac92xx_patch_ops;
5048
5049 return 0;
5050}
5051
8e21c34c
TD		 5052static int patch_stac925x(struct hda_codec *codec)
5053{
5054 struct sigmatel_spec *spec;
5055 int err;
5056
5057 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5058 if (spec == NULL)
5059 return -ENOMEM;
5060
5061 codec->spec = spec;
a4eed138 5062 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
8e21c34c 5063 spec->pin_nids = stac925x_pin_nids;
9cb36c2a
MCC		 5064
5065 /* Check first for codec ID */
5066 spec->board_config = snd_hda_check_board_codec_sid_config(codec,
5067 STAC_925x_MODELS,
5068 stac925x_models,
5069 stac925x_codec_id_cfg_tbl);
5070
5071 /* Now checks for PCI ID, if codec ID is not found */
5072 if (spec->board_config < 0)
5073 spec->board_config = snd_hda_check_board_config(codec,
5074 STAC_925x_MODELS,
8e21c34c
TD		 5075 stac925x_models,
5076 stac925x_cfg_tbl);
9e507abd 5077 again:
330ee995 5078 if (spec->board_config < 0)
9a11f1aa
TI		 5079 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5080 codec->chip_name);
330ee995
TI		 5081 else
5082 stac92xx_set_config_regs(codec,
af9f341a 5083 stac925x_brd_tbl[spec->board_config]);
8e21c34c
TD		 5084
5085 spec->multiout.max_channels = 2;
5086 spec->multiout.num_dacs = 1;
5087 spec->multiout.dac_nids = stac925x_dac_nids;
5088 spec->adc_nids = stac925x_adc_nids;
5089 spec->mux_nids = stac925x_mux_nids;
5090 spec->num_muxes = 1;
9e05b7a3 5091 spec->num_adcs = 1;
a64135a2 5092 spec->num_pwrs = 0;
2c11f955
TD		 5093 switch (codec->vendor_id) {
5094 case 0x83847632: /* STAC9202 */
5095 case 0x83847633: /* STAC9202D */
5096 case 0x83847636: /* STAC9251 */
5097 case 0x83847637: /* STAC9251D */
f6e9852a 5098 spec->num_dmics = STAC925X_NUM_DMICS;
2c11f955 5099 spec->dmic_nids = stac925x_dmic_nids;
1697055e
TI		 5100 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
5101 spec->dmux_nids = stac925x_dmux_nids;
2c11f955
TD		 5102 break;
5103 default:
5104 spec->num_dmics = 0;
5105 break;
5106 }
8e21c34c
TD		 5107
5108 spec->init = stac925x_core_init;
5109 spec->mixer = stac925x_mixer;
6479c631
TI		 5110 spec->num_caps = 1;
5111 spec->capvols = stac925x_capvols;
5112 spec->capsws = stac925x_capsws;
8e21c34c
TD		 5113
5114 err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
9e507abd
TI		 5115 if (!err) {
5116 if (spec->board_config < 0) {
5117 printk(KERN_WARNING "hda_codec: No auto-config is "
5118 "available, default to model=ref\n");
5119 spec->board_config = STAC_925x_REF;
5120 goto again;
5121 }
5122 err = -EINVAL;
5123 }
8e21c34c
TD		 5124 if (err < 0) {
5125 stac92xx_free(codec);
5126 return err;
5127 }
5128
5129 codec->patch_ops = stac92xx_patch_ops;
5130
5131 return 0;
5132}
5133
e1f0d669
MR		 5134static int patch_stac92hd73xx(struct hda_codec *codec)
5135{
5136 struct sigmatel_spec *spec;
5137 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
5138 int err = 0;
c21ca4a8 5139 int num_dacs;
e1f0d669
MR		 5140
5141 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5142 if (spec == NULL)
5143 return -ENOMEM;
5144
5145 codec->spec = spec;
e99d32b3 5146 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
e1f0d669
MR		 5147 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
5148 spec->pin_nids = stac92hd73xx_pin_nids;
5149 spec->board_config = snd_hda_check_board_config(codec,
5150 STAC_92HD73XX_MODELS,
5151 stac92hd73xx_models,
5152 stac92hd73xx_cfg_tbl);
5153again:
330ee995 5154 if (spec->board_config < 0)
9a11f1aa
TI		 5155 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5156 codec->chip_name);
330ee995
TI		 5157 else
5158 stac92xx_set_config_regs(codec,
af9f341a 5159 stac92hd73xx_brd_tbl[spec->board_config]);
e1f0d669 5160
c21ca4a8 5161 num_dacs = snd_hda_get_connections(codec, 0x0a,
e1f0d669
MR		 5162 conn, STAC92HD73_DAC_COUNT + 2) - 1;
5163
c21ca4a8 5164 if (num_dacs < 3 || num_dacs > 5) {
e1f0d669
MR		 5165 printk(KERN_WARNING "hda_codec: Could not determine "
5166 "number of channels defaulting to DAC count\n");
c21ca4a8 5167 num_dacs = STAC92HD73_DAC_COUNT;
e1f0d669 5168 }
c21ca4a8 5169 switch (num_dacs) {
e1f0d669
MR		 5170 case 0x3: /* 6 Channel */
5171 spec->mixer = stac92hd73xx_6ch_mixer;
5172 spec->init = stac92hd73xx_6ch_core_init;
d78d7a90 5173 spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
e1f0d669
MR		 5174 break;
5175 case 0x4: /* 8 Channel */
e1f0d669
MR		 5176 spec->mixer = stac92hd73xx_8ch_mixer;
5177 spec->init = stac92hd73xx_8ch_core_init;
d78d7a90 5178 spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
e1f0d669
MR		 5179 break;
5180 case 0x5: /* 10 Channel */
e1f0d669
MR		 5181 spec->mixer = stac92hd73xx_10ch_mixer;
5182 spec->init = stac92hd73xx_10ch_core_init;
d78d7a90
TI		 5183 spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
5184 break;
c21ca4a8
TI		 5185 }
5186 spec->multiout.dac_nids = spec->dac_nids;
e1f0d669 5187
e1f0d669
MR		 5188 spec->aloopback_mask = 0x01;
5189 spec->aloopback_shift = 8;
5190
1cd2224c 5191 spec->digbeep_nid = 0x1c;
e1f0d669
MR		 5192 spec->mux_nids = stac92hd73xx_mux_nids;
5193 spec->adc_nids = stac92hd73xx_adc_nids;
5194 spec->dmic_nids = stac92hd73xx_dmic_nids;
5195 spec->dmux_nids = stac92hd73xx_dmux_nids;
d9737751 5196 spec->smux_nids = stac92hd73xx_smux_nids;
89385035 5197 spec->amp_nids = stac92hd73xx_amp_nids;
2a9c7816 5198 spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
e1f0d669
MR		 5199
5200 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
5201 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
1697055e 5202 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
2a9c7816 5203
6479c631
TI		 5204 spec->num_caps = STAC92HD73XX_NUM_CAPS;
5205 spec->capvols = stac92hd73xx_capvols;
5206 spec->capsws = stac92hd73xx_capsws;
5207
a7662640 5208 switch (spec->board_config) {
6b3ab21e 5209 case STAC_DELL_EQ:
d654a660 5210 spec->init = dell_eq_core_init;
6b3ab21e 5211 /* fallthru */
661cd8fb
TI		 5212 case STAC_DELL_M6_AMIC:
5213 case STAC_DELL_M6_DMIC:
5214 case STAC_DELL_M6_BOTH:
2a9c7816 5215 spec->num_smuxes = 0;
2a9c7816
MR		 5216 spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
5217 spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
c0cea0d0 5218 spec->eapd_switch = 0;
2a9c7816 5219 spec->num_amps = 1;
6b3ab21e 5220
c21ca4a8 5221 if (spec->board_config != STAC_DELL_EQ)
6b3ab21e 5222 spec->init = dell_m6_core_init;
661cd8fb
TI		 5223 switch (spec->board_config) {
5224 case STAC_DELL_M6_AMIC: /* Analog Mics */
330ee995 5225 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
a7662640
MR		 5226 spec->num_dmics = 0;
5227 break;
661cd8fb 5228 case STAC_DELL_M6_DMIC: /* Digital Mics */
330ee995 5229 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
a7662640
MR		 5230 spec->num_dmics = 1;
5231 break;
661cd8fb 5232 case STAC_DELL_M6_BOTH: /* Both */
330ee995
TI		 5233 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5234 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
a7662640
MR		 5235 spec->num_dmics = 1;
5236 break;
5237 }
5238 break;
5239 default:
5240 spec->num_dmics = STAC92HD73XX_NUM_DMICS;
2a9c7816 5241 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
c0cea0d0 5242 spec->eapd_switch = 1;
5207e10e 5243 break;
a7662640 5244 }
b2c4f4d7
MR		 5245 if (spec->board_config > STAC_92HD73XX_REF) {
5246 /* GPIO0 High = Enable EAPD */
5247 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5248 spec->gpio_data = 0x01;
5249 }
a7662640 5250
a64135a2
MR		 5251 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
5252 spec->pwr_nids = stac92hd73xx_pwr_nids;
5253
d9737751 5254 err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
e1f0d669
MR		 5255
5256 if (!err) {
5257 if (spec->board_config < 0) {
5258 printk(KERN_WARNING "hda_codec: No auto-config is "
5259 "available, default to model=ref\n");
5260 spec->board_config = STAC_92HD73XX_REF;
5261 goto again;
5262 }
5263 err = -EINVAL;
5264 }
5265
5266 if (err < 0) {
5267 stac92xx_free(codec);
5268 return err;
5269 }
5270
9e43f0de
TI		 5271 if (spec->board_config == STAC_92HD73XX_NO_JD)
5272 spec->hp_detect = 0;
5273
e1f0d669
MR		 5274 codec->patch_ops = stac92xx_patch_ops;
5275
2d34e1b3
TI		 5276 codec->proc_widget_hook = stac92hd7x_proc_hook;
5277
e1f0d669
MR		 5278 return 0;
5279}
5280
d0513fc6
MR		 5281static int patch_stac92hd83xxx(struct hda_codec *codec)
5282{
5283 struct sigmatel_spec *spec;
65557f35 5284 hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
d0513fc6 5285 int err;
65557f35 5286 int num_dacs;
8bb0ac55 5287 hda_nid_t nid;
d0513fc6
MR		 5288
5289 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5290 if (spec == NULL)
5291 return -ENOMEM;
5292
5293 codec->spec = spec;
0ffa9807 5294 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
d0513fc6
MR		 5295 spec->mono_nid = 0x19;
5296 spec->digbeep_nid = 0x21;
667067d8
TI		 5297 spec->mux_nids = stac92hd83xxx_mux_nids;
5298 spec->num_muxes = ARRAY_SIZE(stac92hd83xxx_mux_nids);
d0513fc6 5299 spec->adc_nids = stac92hd83xxx_adc_nids;
7570ef18 5300 spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
d0513fc6
MR		 5301 spec->pwr_nids = stac92hd83xxx_pwr_nids;
5302 spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
5303 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
c21ca4a8 5304 spec->multiout.dac_nids = spec->dac_nids;
d0513fc6
MR		 5305
5306 spec->init = stac92hd83xxx_core_init;
d0513fc6 5307 spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
d0513fc6 5308 spec->pin_nids = stac92hd83xxx_pin_nids;
6479c631
TI		 5309 spec->num_caps = STAC92HD83XXX_NUM_CAPS;
5310 spec->capvols = stac92hd83xxx_capvols;
5311 spec->capsws = stac92hd83xxx_capsws;
5312
d0513fc6
MR		 5313 spec->board_config = snd_hda_check_board_config(codec,
5314 STAC_92HD83XXX_MODELS,
5315 stac92hd83xxx_models,
5316 stac92hd83xxx_cfg_tbl);
5317again:
330ee995 5318 if (spec->board_config < 0)
9a11f1aa
TI		 5319 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5320 codec->chip_name);
330ee995
TI		 5321 else
5322 stac92xx_set_config_regs(codec,
af9f341a 5323 stac92hd83xxx_brd_tbl[spec->board_config]);
d0513fc6 5324
32ed3f46
MR		 5325 switch (codec->vendor_id) {
5326 case 0x111d7604:
5327 case 0x111d7605:
ff2e7337 5328 case 0x111d76d5:
32ed3f46
MR		 5329 if (spec->board_config == STAC_92HD83XXX_PWR_REF)
5330 break;
5331 spec->num_pwrs = 0;
5332 break;
5333 }
5334
d0513fc6
MR		 5335 err = stac92xx_parse_auto_config(codec, 0x1d, 0);
5336 if (!err) {
5337 if (spec->board_config < 0) {
5338 printk(KERN_WARNING "hda_codec: No auto-config is "
5339 "available, default to model=ref\n");
5340 spec->board_config = STAC_92HD83XXX_REF;
5341 goto again;
5342 }
5343 err = -EINVAL;
5344 }
5345
5346 if (err < 0) {
5347 stac92xx_free(codec);
5348 return err;
5349 }
5350
8bb0ac55
MR		 5351 switch (spec->board_config) {
5352 case STAC_DELL_S14:
5353 nid = 0xf;
5354 break;
5355 default:
5356 nid = 0xe;
5357 break;
5358 }
5359
5360 num_dacs = snd_hda_get_connections(codec, nid,
5361 conn, STAC92HD83_DAC_COUNT + 1) - 1;
16a433d8
JK		 5362 if (num_dacs < 0)
5363 num_dacs = STAC92HD83_DAC_COUNT;
8bb0ac55
MR		 5364
5365 /* set port X to select the last DAC
5366 */
5367 snd_hda_codec_write_cache(codec, nid, 0,
5368 AC_VERB_SET_CONNECT_SEL, num_dacs);
5369
d0513fc6
MR		 5370 codec->patch_ops = stac92xx_patch_ops;
5371
2d34e1b3
TI		 5372 codec->proc_widget_hook = stac92hd_proc_hook;
5373
d0513fc6
MR		 5374 return 0;
5375}
5376
330ee995
TI		 5377/* get the pin connection (fixed, none, etc) */
5378static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
5379{
5380 struct sigmatel_spec *spec = codec->spec;
5381 unsigned int cfg;
5382
5383 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
5384 return get_defcfg_connect(cfg);
5385}
5386
6df703ae
HRK		 5387static int stac92hd71bxx_connected_ports(struct hda_codec *codec,
5388 hda_nid_t *nids, int num_nids)
5389{
5390 struct sigmatel_spec *spec = codec->spec;
5391 int idx, num;
5392 unsigned int def_conf;
5393
5394 for (num = 0; num < num_nids; num++) {
5395 for (idx = 0; idx < spec->num_pins; idx++)
5396 if (spec->pin_nids[idx] == nids[num])
5397 break;
5398 if (idx >= spec->num_pins)
5399 break;
330ee995 5400 def_conf = stac_get_defcfg_connect(codec, idx);
6df703ae
HRK		 5401 if (def_conf == AC_JACK_PORT_NONE)
5402 break;
5403 }
5404 return num;
5405}
5406
5407static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
5408 hda_nid_t dig0pin)
5409{
5410 struct sigmatel_spec *spec = codec->spec;
5411 int idx;
5412
5413 for (idx = 0; idx < spec->num_pins; idx++)
5414 if (spec->pin_nids[idx] == dig0pin)
5415 break;
5416 if ((idx + 2) >= spec->num_pins)
5417 return 0;
5418
5419 /* dig1pin case */
330ee995 5420 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
6df703ae
HRK		 5421 return 2;
5422
5423 /* dig0pin + dig2pin case */
330ee995 5424 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
6df703ae 5425 return 2;
330ee995 5426 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
6df703ae
HRK		 5427 return 1;
5428 else
5429 return 0;
5430}
5431
e035b841
MR		 5432static int patch_stac92hd71bxx(struct hda_codec *codec)
5433{
5434 struct sigmatel_spec *spec;
ca8d33fc 5435 struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
e035b841
MR		 5436 int err = 0;
5437
5438 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5439 if (spec == NULL)
5440 return -ENOMEM;
5441
5442 codec->spec = spec;
8daaaa97 5443 codec->patch_ops = stac92xx_patch_ops;
616f89e7
HRK		 5444 spec->num_pins = STAC92HD71BXX_NUM_PINS;
5445 switch (codec->vendor_id) {
5446 case 0x111d76b6:
5447 case 0x111d76b7:
5448 spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5449 break;
5450 case 0x111d7603:
5451 case 0x111d7608:
5452 /* On 92HD75Bx 0x27 isn't a pin nid */
5453 spec->num_pins--;
5454 /* fallthrough */
5455 default:
5456 spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5457 }
aafc4412 5458 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
e035b841
MR		 5459 spec->board_config = snd_hda_check_board_config(codec,
5460 STAC_92HD71BXX_MODELS,
5461 stac92hd71bxx_models,
5462 stac92hd71bxx_cfg_tbl);
5463again:
330ee995 5464 if (spec->board_config < 0)
9a11f1aa
TI		 5465 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5466 codec->chip_name);
330ee995
TI		 5467 else
5468 stac92xx_set_config_regs(codec,
af9f341a 5469 stac92hd71bxx_brd_tbl[spec->board_config]);
e035b841 5470
41c3b648
TI		 5471 if (spec->board_config > STAC_92HD71BXX_REF) {
5472 /* GPIO0 = EAPD */
5473 spec->gpio_mask = 0x01;
5474 spec->gpio_dir = 0x01;
5475 spec->gpio_data = 0x01;
5476 }
5477
6df703ae
HRK		 5478 spec->dmic_nids = stac92hd71bxx_dmic_nids;
5479 spec->dmux_nids = stac92hd71bxx_dmux_nids;
5480
6479c631
TI		 5481 spec->num_caps = STAC92HD71BXX_NUM_CAPS;
5482 spec->capvols = stac92hd71bxx_capvols;
5483 spec->capsws = stac92hd71bxx_capsws;
5484
541eee87
MR		 5485 switch (codec->vendor_id) {
5486 case 0x111d76b6: /* 4 Port without Analog Mixer */
5487 case 0x111d76b7:
23c7b521
HRK		 5488 unmute_init++;
5489 /* fallthru */
541eee87
MR		 5490 case 0x111d76b4: /* 6 Port without Analog Mixer */
5491 case 0x111d76b5:
541eee87 5492 spec->init = stac92hd71bxx_core_init;
0ffa9807 5493 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
6df703ae
HRK		 5494 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5495 stac92hd71bxx_dmic_nids,
5496 STAC92HD71BXX_NUM_DMICS);
541eee87 5497 break;
aafc4412 5498 case 0x111d7608: /* 5 Port with Analog Mixer */
8e5f262b
TI		 5499 switch (spec->board_config) {
5500 case STAC_HP_M4:
72474be6 5501 /* Enable VREF power saving on GPIO1 detect */
c6e4c666
TI		 5502 err = stac_add_event(spec, codec->afg,
5503 STAC_VREF_EVENT, 0x02);
5504 if (err < 0)
5505 return err;
c5d08bb5 5506 snd_hda_codec_write_cache(codec, codec->afg, 0,
72474be6
MR		 5507 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5508 snd_hda_codec_write_cache(codec, codec->afg, 0,
74aeaabc 5509 AC_VERB_SET_UNSOLICITED_ENABLE,
c6e4c666 5510 AC_USRSP_EN | err);
72474be6
MR		 5511 spec->gpio_mask |= 0x02;
5512 break;
5513 }
8daaaa97 5514 if ((codec->revision_id & 0xf) == 0 ||
8c2f767b 5515 (codec->revision_id & 0xf) == 1)
8daaaa97 5516 spec->stream_delay = 40; /* 40 milliseconds */
8daaaa97 5517
aafc4412
MR		 5518 /* no output amps */
5519 spec->num_pwrs = 0;
aafc4412 5520 /* disable VSW */
26a27980 5521 spec->init = stac92hd71bxx_core_init;
ca8d33fc 5522 unmute_init++;
330ee995
TI		 5523 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5524 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
6df703ae
HRK		 5525 stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0;
5526 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5527 stac92hd71bxx_dmic_nids,
5528 STAC92HD71BXX_NUM_DMICS - 1);
aafc4412
MR		 5529 break;
5530 case 0x111d7603: /* 6 Port with Analog Mixer */
8c2f767b 5531 if ((codec->revision_id & 0xf) == 1)
8daaaa97 5532 spec->stream_delay = 40; /* 40 milliseconds */
8daaaa97 5533
aafc4412
MR		 5534 /* no output amps */
5535 spec->num_pwrs = 0;
5536 /* fallthru */
541eee87 5537 default:
26a27980 5538 spec->init = stac92hd71bxx_core_init;
0ffa9807 5539 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
6df703ae
HRK		 5540 spec->num_dmics = stac92hd71bxx_connected_ports(codec,
5541 stac92hd71bxx_dmic_nids,
5542 STAC92HD71BXX_NUM_DMICS);
5207e10e 5543 break;
541eee87
MR		 5544 }
5545
ca8d33fc
MR		 5546 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5547 snd_hda_sequence_write_cache(codec, unmute_init);
5548
b20f3b83
TI		 5549 /* Some HP machines seem to have unstable codec communications
5550 * especially with ATI fglrx driver. For recovering from the
5551 * CORB/RIRB stall, allow the BUS reset and keep always sync
5552 */
5553 if (spec->board_config == STAC_HP_DV5) {
5554 codec->bus->sync_write = 1;
5555 codec->bus->allow_bus_reset = 1;
5556 }
5557
d78d7a90 5558 spec->aloopback_ctl = stac92hd71bxx_loopback;
4b33c767 5559 spec->aloopback_mask = 0x50;
541eee87
MR		 5560 spec->aloopback_shift = 0;
5561
8daaaa97 5562 spec->powerdown_adcs = 1;
1cd2224c 5563 spec->digbeep_nid = 0x26;
e035b841
MR		 5564 spec->mux_nids = stac92hd71bxx_mux_nids;
5565 spec->adc_nids = stac92hd71bxx_adc_nids;
d9737751 5566 spec->smux_nids = stac92hd71bxx_smux_nids;
aafc4412 5567 spec->pwr_nids = stac92hd71bxx_pwr_nids;
e035b841
MR		 5568
5569 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5570 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5207e10e 5571 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
6df703ae 5572 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
e035b841 5573
6a14f585
MR		 5574 switch (spec->board_config) {
5575 case STAC_HP_M4:
6a14f585 5576 /* enable internal microphone */
330ee995 5577 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
b9aea715
MR		 5578 stac92xx_auto_set_pinctl(codec, 0x0e,
5579 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
3a7abfd2
MR		 5580 /* fallthru */
5581 case STAC_DELL_M4_2:
5582 spec->num_dmics = 0;
5583 spec->num_smuxes = 0;
5584 spec->num_dmuxes = 0;
5585 break;
5586 case STAC_DELL_M4_1:
5587 case STAC_DELL_M4_3:
5588 spec->num_dmics = 1;
5589 spec->num_smuxes = 0;
ea18aa46 5590 spec->num_dmuxes = 1;
6a14f585 5591 break;
514bf54c
JG		 5592 case STAC_HP_DV4_1222NR:
5593 spec->num_dmics = 1;
5594 /* I don't know if it needs 1 or 2 smuxes - will wait for
5595 * bug reports to fix if needed
5596 */
5597 spec->num_smuxes = 1;
5598 spec->num_dmuxes = 1;
86d190e7 5599 spec->gpio_led = 0x01;
514bf54c 5600 /* fallthrough */
e2ea57a8 5601 case STAC_HP_DV5:
330ee995 5602 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
e2ea57a8
HRK		 5603 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5604 break;
ae6241fb
CP		 5605 case STAC_HP_HDX:
5606 spec->num_dmics = 1;
5607 spec->num_dmuxes = 1;
5608 spec->num_smuxes = 1;
443e26d0 5609 /* orange/white mute led on GPIO3, orange=0, white=1 */
86d190e7
TI		 5610 spec->gpio_led = 0x08;
5611 break;
5612 }
443e26d0 5613
86d190e7
TI		 5614#ifdef CONFIG_SND_HDA_POWER_SAVE
5615 if (spec->gpio_led) {
5616 spec->gpio_mask |= spec->gpio_led;
5617 spec->gpio_dir |= spec->gpio_led;
5618 spec->gpio_data |= spec->gpio_led;
443e26d0 5619 /* register check_power_status callback. */
6fce61ae 5620 codec->patch_ops.check_power_status =
86d190e7
TI		 5621 stac92xx_hp_check_power_status;
5622 }
443e26d0 5623#endif
6a14f585 5624
c21ca4a8 5625 spec->multiout.dac_nids = spec->dac_nids;
e035b841 5626
29d4ab4d 5627 err = stac92xx_parse_auto_config(codec, 0x21, 0);
e035b841
MR		 5628 if (!err) {
5629 if (spec->board_config < 0) {
5630 printk(KERN_WARNING "hda_codec: No auto-config is "
5631 "available, default to model=ref\n");
5632 spec->board_config = STAC_92HD71BXX_REF;
5633 goto again;
5634 }
5635 err = -EINVAL;
5636 }
5637
5638 if (err < 0) {
5639 stac92xx_free(codec);
5640 return err;
5641 }
5642
2d34e1b3
TI		 5643 codec->proc_widget_hook = stac92hd7x_proc_hook;
5644
e035b841 5645 return 0;
86d190e7 5646}
e035b841 5647
2f2f4251
M		 5648static int patch_stac922x(struct hda_codec *codec)
5649{
5650 struct sigmatel_spec *spec;
c7d4b2fa 5651 int err;
2f2f4251 5652
e560d8d8 5653 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2f2f4251
M		 5654 if (spec == NULL)
5655 return -ENOMEM;
5656
5657 codec->spec = spec;
a4eed138 5658 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
11b44bbd 5659 spec->pin_nids = stac922x_pin_nids;
f5fcc13c
TI		 5660 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5661 stac922x_models,
5662 stac922x_cfg_tbl);
536319af 5663 if (spec->board_config == STAC_INTEL_MAC_AUTO) {
4fe5195c
MR		 5664 spec->gpio_mask = spec->gpio_dir = 0x03;
5665 spec->gpio_data = 0x03;
3fc24d85
TI		 5666 /* Intel Macs have all same PCI SSID, so we need to check
5667 * codec SSID to distinguish the exact models
5668 */
6f0778d8 5669 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
3fc24d85 5670 switch (codec->subsystem_id) {
5d5d3bc3
IZ		 5671
5672 case 0x106b0800:
5673 spec->board_config = STAC_INTEL_MAC_V1;
c45e20eb 5674 break;
5d5d3bc3
IZ		 5675 case 0x106b0600:
5676 case 0x106b0700:
5677 spec->board_config = STAC_INTEL_MAC_V2;
6f0778d8 5678 break;
5d5d3bc3
IZ		 5679 case 0x106b0e00:
5680 case 0x106b0f00:
5681 case 0x106b1600:
5682 case 0x106b1700:
5683 case 0x106b0200:
5684 case 0x106b1e00:
5685 spec->board_config = STAC_INTEL_MAC_V3;
3fc24d85 5686 break;
5d5d3bc3
IZ		 5687 case 0x106b1a00:
5688 case 0x00000100:
5689 spec->board_config = STAC_INTEL_MAC_V4;
f16928fb 5690 break;
5d5d3bc3
IZ		 5691 case 0x106b0a00:
5692 case 0x106b2200:
5693 spec->board_config = STAC_INTEL_MAC_V5;
0dae0f83 5694 break;
536319af
NB		 5695 default:
5696 spec->board_config = STAC_INTEL_MAC_V3;
5697 break;
3fc24d85
TI		 5698 }
5699 }
5700
9e507abd 5701 again:
330ee995 5702 if (spec->board_config < 0)
9a11f1aa
TI		 5703 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5704 codec->chip_name);
330ee995
TI		 5705 else
5706 stac92xx_set_config_regs(codec,
af9f341a 5707 stac922x_brd_tbl[spec->board_config]);
2f2f4251 5708
c7d4b2fa
M		 5709 spec->adc_nids = stac922x_adc_nids;
5710 spec->mux_nids = stac922x_mux_nids;
2549413e 5711 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
9e05b7a3 5712 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
8b65727b 5713 spec->num_dmics = 0;
a64135a2 5714 spec->num_pwrs = 0;
c7d4b2fa
M		 5715
5716 spec->init = stac922x_core_init;
6479c631
TI		 5717
5718 spec->num_caps = STAC922X_NUM_CAPS;
5719 spec->capvols = stac922x_capvols;
5720 spec->capsws = stac922x_capsws;
c7d4b2fa
M		 5721
5722 spec->multiout.dac_nids = spec->dac_nids;
19039bd0 5723
3cc08dc6 5724 err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
9e507abd
TI		 5725 if (!err) {
5726 if (spec->board_config < 0) {
5727 printk(KERN_WARNING "hda_codec: No auto-config is "
5728 "available, default to model=ref\n");
5729 spec->board_config = STAC_D945_REF;
5730 goto again;
5731 }
5732 err = -EINVAL;
5733 }
3cc08dc6
MP		 5734 if (err < 0) {
5735 stac92xx_free(codec);
5736 return err;
5737 }
5738
5739 codec->patch_ops = stac92xx_patch_ops;
5740
807a4636
TI		 5741 /* Fix Mux capture level; max to 2 */
5742 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5743 (0 << AC_AMPCAP_OFFSET_SHIFT) |
5744 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5745 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5746 (0 << AC_AMPCAP_MUTE_SHIFT));
5747
3cc08dc6
MP		 5748 return 0;
5749}
5750
5751static int patch_stac927x(struct hda_codec *codec)
5752{
5753 struct sigmatel_spec *spec;
5754 int err;
5755
5756 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5757 if (spec == NULL)
5758 return -ENOMEM;
5759
5760 codec->spec = spec;
45c1d85b 5761 codec->slave_dig_outs = stac927x_slave_dig_outs;
a4eed138 5762 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
11b44bbd 5763 spec->pin_nids = stac927x_pin_nids;
f5fcc13c
TI		 5764 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5765 stac927x_models,
5766 stac927x_cfg_tbl);
9e507abd 5767 again:
330ee995 5768 if (spec->board_config < 0)
9a11f1aa
TI		 5769 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5770 codec->chip_name);
330ee995
TI		 5771 else
5772 stac92xx_set_config_regs(codec,
af9f341a 5773 stac927x_brd_tbl[spec->board_config]);
3cc08dc6 5774
1cd2224c 5775 spec->digbeep_nid = 0x23;
8e9068b1
MR		 5776 spec->adc_nids = stac927x_adc_nids;
5777 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
5778 spec->mux_nids = stac927x_mux_nids;
5779 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
d9737751
MR		 5780 spec->smux_nids = stac927x_smux_nids;
5781 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
65973632 5782 spec->spdif_labels = stac927x_spdif_labels;
b76c850f 5783 spec->dac_list = stac927x_dac_nids;
8e9068b1
MR		 5784 spec->multiout.dac_nids = spec->dac_nids;
5785
81d3dbde 5786 switch (spec->board_config) {
93ed1503 5787 case STAC_D965_3ST:
93ed1503 5788 case STAC_D965_5ST:
8e9068b1 5789 /* GPIO0 High = Enable EAPD */
0fc9dec4 5790 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
4fe5195c 5791 spec->gpio_data = 0x01;
8e9068b1
MR		 5792 spec->num_dmics = 0;
5793
93ed1503 5794 spec->init = d965_core_init;
81d3dbde 5795 break;
8e9068b1 5796 case STAC_DELL_BIOS:
780c8be4
MR		 5797 switch (codec->subsystem_id) {
5798 case 0x10280209:
5799 case 0x1028022e:
5800 /* correct the device field to SPDIF out */
330ee995 5801 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
780c8be4 5802 break;
86d190e7 5803 }
03d7ca17 5804 /* configure the analog microphone on some laptops */
330ee995 5805 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
2f32d909 5806 /* correct the front output jack as a hp out */
330ee995 5807 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
c481fca3 5808 /* correct the front input jack as a mic */
330ee995 5809 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
c481fca3 5810 /* fallthru */
8e9068b1
MR		 5811 case STAC_DELL_3ST:
5812 /* GPIO2 High = Enable EAPD */
0fc9dec4 5813 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
4fe5195c 5814 spec->gpio_data = 0x04;
84d3dc20
CW		 5815 switch (codec->subsystem_id) {
5816 case 0x1028022f:
5817 /* correct EAPD to be GPIO0 */
5818 spec->eapd_mask = spec->gpio_mask = 0x01;
5819 spec->gpio_dir = spec->gpio_data = 0x01;
5820 break;
5821 };
7f16859a
MR		 5822 spec->dmic_nids = stac927x_dmic_nids;
5823 spec->num_dmics = STAC927X_NUM_DMICS;
f1f208d0 5824
8e9068b1 5825 spec->init = d965_core_init;
8e9068b1 5826 spec->dmux_nids = stac927x_dmux_nids;
1697055e 5827 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
7f16859a
MR		 5828 break;
5829 default:
b2c4f4d7
MR		 5830 if (spec->board_config > STAC_D965_REF) {
5831 /* GPIO0 High = Enable EAPD */
5832 spec->eapd_mask = spec->gpio_mask = 0x01;
5833 spec->gpio_dir = spec->gpio_data = 0x01;
5834 }
8e9068b1
MR		 5835 spec->num_dmics = 0;
5836
5837 spec->init = stac927x_core_init;
7f16859a
MR		 5838 }
5839
6479c631
TI		 5840 spec->num_caps = STAC927X_NUM_CAPS;
5841 spec->capvols = stac927x_capvols;
5842 spec->capsws = stac927x_capsws;
5843
a64135a2 5844 spec->num_pwrs = 0;
d78d7a90 5845 spec->aloopback_ctl = stac927x_loopback;
e1f0d669
MR		 5846 spec->aloopback_mask = 0x40;
5847 spec->aloopback_shift = 0;
c0cea0d0 5848 spec->eapd_switch = 1;
8e9068b1 5849
3cc08dc6 5850 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
9e507abd
TI		 5851 if (!err) {
5852 if (spec->board_config < 0) {
5853 printk(KERN_WARNING "hda_codec: No auto-config is "
5854 "available, default to model=ref\n");
5855 spec->board_config = STAC_D965_REF;
5856 goto again;
5857 }
5858 err = -EINVAL;
5859 }
c7d4b2fa
M		 5860 if (err < 0) {
5861 stac92xx_free(codec);
5862 return err;
5863 }
2f2f4251
M		 5864
5865 codec->patch_ops = stac92xx_patch_ops;
5866
2d34e1b3
TI		 5867 codec->proc_widget_hook = stac927x_proc_hook;
5868
52987656
TI		 5869 /*
5870 * !!FIXME!!
5871 * The STAC927x seem to require fairly long delays for certain
5872 * command sequences. With too short delays (even if the answer
5873 * is set to RIRB properly), it results in the silence output
5874 * on some hardwares like Dell.
5875 *
5876 * The below flag enables the longer delay (see get_response
5877 * in hda_intel.c).
5878 */
5879 codec->bus->needs_damn_long_delay = 1;
5880
e28d8322
TI		 5881 /* no jack detecion for ref-no-jd model */
5882 if (spec->board_config == STAC_D965_REF_NO_JD)
5883 spec->hp_detect = 0;
5884
2f2f4251
M		 5885 return 0;
5886}
5887
f3302a59
MP		 5888static int patch_stac9205(struct hda_codec *codec)
5889{
5890 struct sigmatel_spec *spec;
8259980e 5891 int err;
f3302a59
MP		 5892
5893 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5894 if (spec == NULL)
5895 return -ENOMEM;
5896
5897 codec->spec = spec;
a4eed138 5898 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
11b44bbd 5899 spec->pin_nids = stac9205_pin_nids;
f5fcc13c
TI		 5900 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
5901 stac9205_models,
5902 stac9205_cfg_tbl);
9e507abd 5903 again:
330ee995 5904 if (spec->board_config < 0)
9a11f1aa
TI		 5905 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5906 codec->chip_name);
330ee995
TI		 5907 else
5908 stac92xx_set_config_regs(codec,
af9f341a 5909 stac9205_brd_tbl[spec->board_config]);
f3302a59 5910
1cd2224c 5911 spec->digbeep_nid = 0x23;
f3302a59 5912 spec->adc_nids = stac9205_adc_nids;
9e05b7a3 5913 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
f3302a59 5914 spec->mux_nids = stac9205_mux_nids;
2549413e 5915 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
d9737751
MR		 5916 spec->smux_nids = stac9205_smux_nids;
5917 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
8b65727b 5918 spec->dmic_nids = stac9205_dmic_nids;
f6e9852a 5919 spec->num_dmics = STAC9205_NUM_DMICS;
e1f0d669 5920 spec->dmux_nids = stac9205_dmux_nids;
1697055e 5921 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
a64135a2 5922 spec->num_pwrs = 0;
f3302a59
MP		 5923
5924 spec->init = stac9205_core_init;
d78d7a90 5925 spec->aloopback_ctl = stac9205_loopback;
f3302a59 5926
6479c631
TI		 5927 spec->num_caps = STAC9205_NUM_CAPS;
5928 spec->capvols = stac9205_capvols;
5929 spec->capsws = stac9205_capsws;
5930
e1f0d669
MR		 5931 spec->aloopback_mask = 0x40;
5932 spec->aloopback_shift = 0;
d9a4268e
TI		 5933 /* Turn on/off EAPD per HP plugging */
5934 if (spec->board_config != STAC_9205_EAPD)
5935 spec->eapd_switch = 1;
f3302a59 5936 spec->multiout.dac_nids = spec->dac_nids;
87d48363 5937
ae0a8ed8 5938 switch (spec->board_config){
ae0a8ed8 5939 case STAC_9205_DELL_M43:
87d48363 5940 /* Enable SPDIF in/out */
330ee995
TI		 5941 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
5942 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
87d48363 5943
4fe5195c 5944 /* Enable unsol response for GPIO4/Dock HP connection */
c6e4c666
TI		 5945 err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
5946 if (err < 0)
5947 return err;
c5d08bb5 5948 snd_hda_codec_write_cache(codec, codec->afg, 0,
4fe5195c
MR		 5949 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
5950 snd_hda_codec_write_cache(codec, codec->afg, 0,
c6e4c666
TI		 5951 AC_VERB_SET_UNSOLICITED_ENABLE,
5952 AC_USRSP_EN | err);
4fe5195c
MR		 5953
5954 spec->gpio_dir = 0x0b;
0fc9dec4 5955 spec->eapd_mask = 0x01;
4fe5195c
MR		 5956 spec->gpio_mask = 0x1b;
5957 spec->gpio_mute = 0x10;
e2e7d624 5958 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
4fe5195c 5959 * GPIO3 Low = DRM
87d48363 5960 */
4fe5195c 5961 spec->gpio_data = 0x01;
ae0a8ed8 5962 break;
b2c4f4d7
MR		 5963 case STAC_9205_REF:
5964 /* SPDIF-In enabled */
5965 break;
ae0a8ed8
TD		 5966 default:
5967 /* GPIO0 High = EAPD */
0fc9dec4 5968 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
4fe5195c 5969 spec->gpio_data = 0x01;
ae0a8ed8
TD		 5970 break;
5971 }
33382403 5972
f3302a59 5973 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
9e507abd
TI		 5974 if (!err) {
5975 if (spec->board_config < 0) {
5976 printk(KERN_WARNING "hda_codec: No auto-config is "
5977 "available, default to model=ref\n");
5978 spec->board_config = STAC_9205_REF;
5979 goto again;
5980 }
5981 err = -EINVAL;
5982 }
f3302a59
MP		 5983 if (err < 0) {
5984 stac92xx_free(codec);
5985 return err;
5986 }
5987
5988 codec->patch_ops = stac92xx_patch_ops;
5989
2d34e1b3
TI		 5990 codec->proc_widget_hook = stac9205_proc_hook;
5991
f3302a59
MP		 5992 return 0;
5993}
5994
db064e50 5995/*
6d859065 5996 * STAC9872 hack
db064e50
TI		 5997 */
5998
1e137f92 5999static struct hda_verb stac9872_core_init[] = {
1624cb9a 6000 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
6d859065
GM		 6001 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
6002 {}
6003};
6004
caa10b6e
TI		 6005static hda_nid_t stac9872_pin_nids[] = {
6006 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
6007 0x11, 0x13, 0x14,
6008};
6009
6010static hda_nid_t stac9872_adc_nids[] = {
6011 0x8 /*,0x6*/
6012};
6013
6014static hda_nid_t stac9872_mux_nids[] = {
6015 0x15
6016};
6017
6479c631
TI		 6018static unsigned long stac9872_capvols[] = {
6019 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
6020};
6021#define stac9872_capsws stac9872_capvols
6022
307282c8
TI		 6023static unsigned int stac9872_vaio_pin_configs[9] = {
6024 0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
6025 0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
6026 0x90a7013e
6027};
6028
6029static const char *stac9872_models[STAC_9872_MODELS] = {
6030 [STAC_9872_AUTO] = "auto",
6031 [STAC_9872_VAIO] = "vaio",
6032};
6033
6034static unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
6035 [STAC_9872_VAIO] = stac9872_vaio_pin_configs,
6036};
6037
6038static struct snd_pci_quirk stac9872_cfg_tbl[] = {
b04add95
TI		 6039 SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
6040 "Sony VAIO F/S", STAC_9872_VAIO),
307282c8
TI		 6041 {} /* terminator */
6042};
6043
6d859065 6044static int patch_stac9872(struct hda_codec *codec)
db064e50
TI		 6045{
6046 struct sigmatel_spec *spec;
1e137f92 6047 int err;
db064e50 6048
db064e50
TI		 6049 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6050 if (spec == NULL)
6051 return -ENOMEM;
db064e50 6052 codec->spec = spec;
b04add95
TI		 6053 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
6054 spec->pin_nids = stac9872_pin_nids;
caa10b6e
TI		 6055
6056 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
6057 stac9872_models,
6058 stac9872_cfg_tbl);
307282c8 6059 if (spec->board_config < 0)
9a11f1aa
TI		 6060 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6061 codec->chip_name);
307282c8
TI		 6062 else
6063 stac92xx_set_config_regs(codec,
6064 stac9872_brd_tbl[spec->board_config]);
db064e50 6065
1e137f92
TI		 6066 spec->multiout.dac_nids = spec->dac_nids;
6067 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
6068 spec->adc_nids = stac9872_adc_nids;
6069 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
6070 spec->mux_nids = stac9872_mux_nids;
1e137f92 6071 spec->init = stac9872_core_init;
6479c631
TI		 6072 spec->num_caps = 1;
6073 spec->capvols = stac9872_capvols;
6074 spec->capsws = stac9872_capsws;
1e137f92
TI		 6075
6076 err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
6077 if (err < 0) {
6078 stac92xx_free(codec);
6079 return -EINVAL;
6080 }
6081 spec->input_mux = &spec->private_imux;
6082 codec->patch_ops = stac92xx_patch_ops;
db064e50
TI		 6083 return 0;
6084}
6085
6086
2f2f4251
M		 6087/*
6088 * patch entries
6089 */
1289e9e8 6090static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
2f2f4251
M		 6091 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
6092 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
6093 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
6094 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
6095 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
6096 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
6097 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
22a27c7f
MP		 6098 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
6099 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
6100 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
6101 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
6102 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
6103 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
3cc08dc6
MP		 6104 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
6105 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
6106 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
6107 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
6108 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
6109 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
6110 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
6111 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
6112 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
6113 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
8e21c34c
TD		 6114 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x },
6115 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
6116 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
6117 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
6118 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
6119 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
7bd3c0f7
TI		 6120 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
6121 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
6d859065
GM		 6122 /* The following does not take into account .id=0x83847661 when subsys =
6123 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
6124 * currently not fully supported.
6125 */
6126 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
6127 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
6128 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
a5c0f886 6129 { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
f3302a59
MP		 6130 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
6131 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
6132 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
6133 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
6134 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
6135 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
6136 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
6137 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
aafc4412 6138 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
d0513fc6
MR		 6139 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
6140 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
ff2e7337 6141 { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
aafc4412 6142 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
541eee87
MR		 6143 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
6144 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
e1f0d669 6145 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
541eee87
MR		 6146 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6147 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6148 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6149 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6150 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6151 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6152 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6153 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
2f2f4251
M		 6154 {} /* terminator */
6155};
1289e9e8
TI		 6156
6157MODULE_ALIAS("snd-hda-codec-id:8384*");
6158MODULE_ALIAS("snd-hda-codec-id:111d*");
6159
6160MODULE_LICENSE("GPL");
6161MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");
6162
6163static struct hda_codec_preset_list sigmatel_list = {
6164 .preset = snd_hda_preset_sigmatel,
6165 .owner = THIS_MODULE,
6166};
6167
6168static int __init patch_sigmatel_init(void)
6169{
6170 return snd_hda_add_codec_preset(&sigmatel_list);
6171}
6172
6173static void __exit patch_sigmatel_exit(void)
6174{
6175 snd_hda_delete_codec_preset(&sigmatel_list);
6176}
6177
6178module_init(patch_sigmatel_init)
6179module_exit(patch_sigmatel_exit)
Linux kernel - Deliverables
This page took 1.810115 seconds and 5 git commands to generate.