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