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