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