patch_sigmatel.c 191.4 KB
Newer Older
M
Matt 已提交
1 2 3 4 5 6
/*
 * Universal Interface for Intel High Definition Audio Codec
 *
 * HD audio interface patch for SigmaTel STAC92xx
 *
 * Copyright (c) 2005 Embedded Alley Solutions, Inc.
7
 * Matt Porter <mporter@embeddedalley.com>
M
Matt 已提交
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 * Based on patch_cmedia.c and patch_realtek.c
 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
 *
 *  This driver is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This driver is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/pci.h>
31
#include <linux/dmi.h>
32
#include <linux/module.h>
M
Matt 已提交
33
#include <sound/core.h>
34
#include <sound/asoundef.h>
35
#include <sound/jack.h>
36
#include <sound/tlv.h>
M
Matt 已提交
37 38
#include "hda_codec.h"
#include "hda_local.h"
39
#include "hda_auto_parser.h"
40
#include "hda_beep.h"
41
#include "hda_jack.h"
M
Matt 已提交
42

43 44 45 46 47
enum {
	STAC_VREF_EVENT	= 1,
	STAC_INSERT_EVENT,
	STAC_PWR_EVENT,
	STAC_HP_EVENT,
48
	STAC_LO_EVENT,
49
	STAC_MIC_EVENT,
50
};
51

52 53
enum {
	STAC_REF,
54
	STAC_9200_OQO,
55 56 57 58 59 60 61 62 63 64
	STAC_9200_DELL_D21,
	STAC_9200_DELL_D22,
	STAC_9200_DELL_D23,
	STAC_9200_DELL_M21,
	STAC_9200_DELL_M22,
	STAC_9200_DELL_M23,
	STAC_9200_DELL_M24,
	STAC_9200_DELL_M25,
	STAC_9200_DELL_M26,
	STAC_9200_DELL_M27,
65 66
	STAC_9200_M4,
	STAC_9200_M4_2,
67
	STAC_9200_PANASONIC,
68
	STAC_9200_EAPD_INIT,
69 70 71 72 73
	STAC_9200_MODELS
};

enum {
	STAC_9205_REF,
74
	STAC_9205_DELL_M42,
75 76
	STAC_9205_DELL_M43,
	STAC_9205_DELL_M44,
77
	STAC_9205_EAPD,
78 79 80
	STAC_9205_MODELS
};

81
enum {
82
	STAC_92HD73XX_AUTO,
83
	STAC_92HD73XX_NO_JD, /* no jack-detection */
84
	STAC_92HD73XX_REF,
85
	STAC_92HD73XX_INTEL,
86 87 88
	STAC_DELL_M6_AMIC,
	STAC_DELL_M6_DMIC,
	STAC_DELL_M6_BOTH,
89
	STAC_DELL_EQ,
90
	STAC_ALIENWARE_M17X,
91 92 93
	STAC_92HD73XX_MODELS
};

94
enum {
95
	STAC_92HD83XXX_AUTO,
96
	STAC_92HD83XXX_REF,
97
	STAC_92HD83XXX_PWR_REF,
98
	STAC_DELL_S14,
99
	STAC_DELL_VOSTRO_3500,
100
	STAC_92HD83XXX_HP_cNB11_INTQUAD,
101
	STAC_HP_DV7_4000,
102
	STAC_HP_ZEPHYR,
103
	STAC_92HD83XXX_HP_LED,
104
	STAC_92HD83XXX_HP_INV_LED,
105
	STAC_92HD83XXX_HP_MIC_LED,
106
	STAC_92HD83XXX_HEADSET_JACK,
107 108 109
	STAC_92HD83XXX_MODELS
};

110
enum {
111
	STAC_92HD71BXX_AUTO,
112
	STAC_92HD71BXX_REF,
113 114
	STAC_DELL_M4_1,
	STAC_DELL_M4_2,
115
	STAC_DELL_M4_3,
116
	STAC_HP_M4,
117
	STAC_HP_DV4,
T
Takashi Iwai 已提交
118
	STAC_HP_DV5,
119
	STAC_HP_HDX,
120
	STAC_HP_DV4_1222NR,
121 122 123
	STAC_92HD71BXX_MODELS
};

124 125
enum {
	STAC_925x_REF,
126 127 128
	STAC_M1,
	STAC_M1_2,
	STAC_M2,
129
	STAC_M2_2,
130 131 132
	STAC_M3,
	STAC_M5,
	STAC_M6,
133 134 135
	STAC_925x_MODELS
};

136 137 138 139
enum {
	STAC_D945_REF,
	STAC_D945GTP3,
	STAC_D945GTP5,
140 141 142 143 144
	STAC_INTEL_MAC_V1,
	STAC_INTEL_MAC_V2,
	STAC_INTEL_MAC_V3,
	STAC_INTEL_MAC_V4,
	STAC_INTEL_MAC_V5,
145
	STAC_INTEL_MAC_AUTO,
146
	STAC_ECS_202,
147 148 149 150
	STAC_922X_DELL_D81,
	STAC_922X_DELL_D82,
	STAC_922X_DELL_M81,
	STAC_922X_DELL_M82,
151
	STAC_922X_INTEL_MAC_GPIO,
152 153 154 155
	STAC_922X_MODELS
};

enum {
156
	STAC_927X_AUTO,
157
	STAC_D965_REF_NO_JD, /* no jack-detection */
158 159 160
	STAC_D965_REF,
	STAC_D965_3ST,
	STAC_D965_5ST,
161
	STAC_D965_5ST_NO_FP,
162
	STAC_DELL_3ST,
163
	STAC_DELL_BIOS,
164
	STAC_927X_VOLKNOB,
165 166
	STAC_927X_MODELS
};
167

168 169 170 171 172
enum {
	STAC_9872_VAIO,
	STAC_9872_MODELS
};

173 174
struct sigmatel_mic_route {
	hda_nid_t pin;
175 176
	signed char mux_idx;
	signed char dmux_idx;
177 178
};

179 180 181 182
#define MAX_PINS_NUM 16
#define MAX_ADCS_NUM 4
#define MAX_DMICS_NUM 4

M
Matt 已提交
183
struct sigmatel_spec {
184
	struct snd_kcontrol_new *mixers[4];
185 186
	unsigned int num_mixers;

187
	int board_config;
M
Matthew Ranostay 已提交
188
	unsigned int eapd_switch: 1;
189
	unsigned int surr_switch: 1;
190
	unsigned int alt_switch: 1;
191
	unsigned int hp_detect: 1;
192
	unsigned int spdif_mute: 1;
193
	unsigned int check_volume_offset:1;
194
	unsigned int auto_mic:1;
195
	unsigned int linear_tone_beep:1;
196
	unsigned int headset_jack:1; /* 4-pin headset jack (hp + mono mic) */
197

198
	/* gpio lines */
199
	unsigned int eapd_mask;
200 201 202 203
	unsigned int gpio_mask;
	unsigned int gpio_dir;
	unsigned int gpio_data;
	unsigned int gpio_mute;
204
	unsigned int gpio_led;
205
	unsigned int gpio_led_polarity;
206
	unsigned int vref_mute_led_nid; /* pin NID for mute-LED vref control */
207
	unsigned int vref_led;
208

209 210 211
	unsigned int mic_mute_led_gpio; /* capture mute LED GPIO */
	bool mic_mute_led_on; /* current mic mute state */

M
Matthew Ranostay 已提交
212 213 214
	/* stream */
	unsigned int stream_delay;

215
	/* analog loopback */
216
	const struct snd_kcontrol_new *aloopback_ctl;
217 218
	unsigned char aloopback_mask;
	unsigned char aloopback_shift;
219

220
	/* power management */
221
	unsigned int power_map_bits;
222
	unsigned int num_pwrs;
223 224
	const hda_nid_t *pwr_nids;
	const hda_nid_t *dac_list;
225

M
Matt 已提交
226
	/* playback */
227 228
	struct hda_input_mux *mono_mux;
	unsigned int cur_mmux;
M
Matt 已提交
229
	struct hda_multi_out multiout;
230
	hda_nid_t dac_nids[5];
231 232
	hda_nid_t hp_dacs[5];
	hda_nid_t speaker_dacs[5];
M
Matt 已提交
233

234 235
	int volume_offset;

M
Matt 已提交
236
	/* capture */
237
	const hda_nid_t *adc_nids;
M
Matt 已提交
238
	unsigned int num_adcs;
239
	const hda_nid_t *mux_nids;
240
	unsigned int num_muxes;
241
	const hda_nid_t *dmic_nids;
242
	unsigned int num_dmics;
243
	const hda_nid_t *dmux_nids;
244
	unsigned int num_dmuxes;
245
	const hda_nid_t *smux_nids;
M
Matthew Ranostay 已提交
246
	unsigned int num_smuxes;
247
	unsigned int num_analog_muxes;
248

249 250
	const unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
	const unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */
251 252
	unsigned int num_caps; /* number of capture volume/switch elements */

253 254
	struct sigmatel_mic_route ext_mic;
	struct sigmatel_mic_route int_mic;
255
	struct sigmatel_mic_route dock_mic;
256

257
	const char * const *spdif_labels;
M
Matthew Ranostay 已提交
258

259
	hda_nid_t dig_in_nid;
260
	hda_nid_t mono_nid;
261 262
	hda_nid_t anabeep_nid;
	hda_nid_t digbeep_nid;
M
Matt 已提交
263 264

	/* pin widgets */
265
	const hda_nid_t *pin_nids;
M
Matt 已提交
266 267 268
	unsigned int num_pins;

	/* codec specific stuff */
269 270
	const struct hda_verb *init;
	const struct snd_kcontrol_new *mixer;
M
Matt 已提交
271 272

	/* capture source */
273
	struct hda_input_mux *dinput_mux;
274
	unsigned int cur_dmux[2];
275
	struct hda_input_mux *input_mux;
276
	unsigned int cur_mux[3];
M
Matthew Ranostay 已提交
277 278
	struct hda_input_mux *sinput_mux;
	unsigned int cur_smux[2];
M
Matthew Ranostay 已提交
279 280
	unsigned int cur_amux;
	hda_nid_t *amp_nids;
M
Matthew Ranostay 已提交
281
	unsigned int powerdown_adcs;
M
Matt 已提交
282

283 284
	/* i/o switches */
	unsigned int io_switch[2];
285
	unsigned int clfe_swap;
286 287 288
	hda_nid_t line_switch;	/* shared line-in for input and output */
	hda_nid_t mic_switch;	/* shared mic-in for input and output */
	hda_nid_t hp_switch; /* NID of HP as line-out */
289
	unsigned int aloopback;
M
Matt 已提交
290

291 292 293 294
	struct hda_pcm pcm_rec[2];	/* PCM information */

	/* dynamic controls and input_mux */
	struct auto_pin_cfg autocfg;
295
	struct snd_array kctls;
296
	struct hda_input_mux private_dimux;
297
	struct hda_input_mux private_imux;
M
Matthew Ranostay 已提交
298
	struct hda_input_mux private_smux;
299
	struct hda_input_mux private_mono_mux;
300 301 302 303 304 305 306 307 308 309 310

	/* auto spec */
	unsigned auto_pin_cnt;
	hda_nid_t auto_pin_nids[MAX_PINS_NUM];
	unsigned auto_adc_cnt;
	hda_nid_t auto_adc_nids[MAX_ADCS_NUM];
	hda_nid_t auto_mux_nids[MAX_ADCS_NUM];
	hda_nid_t auto_dmux_nids[MAX_ADCS_NUM];
	unsigned long auto_capvols[MAX_ADCS_NUM];
	unsigned auto_dmic_cnt;
	hda_nid_t auto_dmic_nids[MAX_DMICS_NUM];
311

312
	struct hda_vmaster_mute_hook vmaster_mute;
M
Matt 已提交
313 314
};

315 316 317
#define AC_VERB_IDT_SET_POWER_MAP	0x7ec
#define AC_VERB_IDT_GET_POWER_MAP	0xfec

318
static const hda_nid_t stac9200_adc_nids[1] = {
M
Matt 已提交
319 320 321
        0x03,
};

322
static const hda_nid_t stac9200_mux_nids[1] = {
M
Matt 已提交
323 324 325
        0x0c,
};

326
static const hda_nid_t stac9200_dac_nids[1] = {
M
Matt 已提交
327 328 329
        0x02,
};

330
static const hda_nid_t stac92hd73xx_pwr_nids[8] = {
331 332 333 334
	0x0a, 0x0b, 0x0c, 0xd, 0x0e,
	0x0f, 0x10, 0x11
};

335
static const hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
336 337 338
	0x26, 0,
};

339
static const hda_nid_t stac92hd73xx_adc_nids[2] = {
340 341 342 343
	0x1a, 0x1b
};

#define STAC92HD73XX_NUM_DMICS	2
344
static const hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
345 346 347 348 349
	0x13, 0x14, 0
};

#define STAC92HD73_DAC_COUNT 5

350
static const hda_nid_t stac92hd73xx_mux_nids[2] = {
351
	0x20, 0x21,
352 353
};

354
static const hda_nid_t stac92hd73xx_dmux_nids[2] = {
355 356 357
	0x20, 0x21,
};

358
static const hda_nid_t stac92hd73xx_smux_nids[2] = {
M
Matthew Ranostay 已提交
359 360 361
	0x22, 0x23,
};

362
#define STAC92HD73XX_NUM_CAPS	2
363
static const unsigned long stac92hd73xx_capvols[] = {
364 365 366 367 368
	HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
	HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
};
#define stac92hd73xx_capsws	stac92hd73xx_capvols

369 370
#define STAC92HD83_DAC_COUNT 3

371 372 373
static const hda_nid_t stac92hd83xxx_pwr_nids[7] = {
	0x0a, 0x0b, 0x0c, 0xd, 0x0e,
	0x0f, 0x10
374 375
};

376
static const hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
377 378 379
	0x1e, 0,
};

380
static const hda_nid_t stac92hd83xxx_dmic_nids[] = {
381
		0x11, 0x20,
382 383
};

384
static const hda_nid_t stac92hd71bxx_pwr_nids[3] = {
385 386 387
	0x0a, 0x0d, 0x0f
};

388
static const hda_nid_t stac92hd71bxx_adc_nids[2] = {
389 390 391
	0x12, 0x13,
};

392
static const hda_nid_t stac92hd71bxx_mux_nids[2] = {
393 394 395
	0x1a, 0x1b
};

396
static const hda_nid_t stac92hd71bxx_dmux_nids[2] = {
397
	0x1c, 0x1d,
398 399
};

400
static const hda_nid_t stac92hd71bxx_smux_nids[2] = {
M
Matthew Ranostay 已提交
401 402 403
	0x24, 0x25,
};

404
#define STAC92HD71BXX_NUM_DMICS	2
405
static const hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
406 407 408
	0x18, 0x19, 0
};

409 410 411 412 413
static const hda_nid_t stac92hd71bxx_dmic_5port_nids[STAC92HD71BXX_NUM_DMICS] = {
	0x18, 0
};

static const hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
414 415 416
	0x22, 0
};

417
#define STAC92HD71BXX_NUM_CAPS		2
418
static const unsigned long stac92hd71bxx_capvols[] = {
419 420 421 422 423
	HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
	HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
};
#define stac92hd71bxx_capsws	stac92hd71bxx_capvols

424
static const hda_nid_t stac925x_adc_nids[1] = {
425 426 427
        0x03,
};

428
static const hda_nid_t stac925x_mux_nids[1] = {
429 430 431
        0x0f,
};

432
static const hda_nid_t stac925x_dac_nids[1] = {
433 434 435
        0x02,
};

436
#define STAC925X_NUM_DMICS	1
437
static const hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
438
	0x15, 0
439 440
};

441
static const hda_nid_t stac925x_dmux_nids[1] = {
442 443 444
	0x14,
};

445
static const unsigned long stac925x_capvols[] = {
446 447
	HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
};
448
static const unsigned long stac925x_capsws[] = {
449 450 451
	HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
};

452
static const hda_nid_t stac922x_adc_nids[2] = {
M
Matt 已提交
453 454 455
        0x06, 0x07,
};

456
static const hda_nid_t stac922x_mux_nids[2] = {
M
Matt 已提交
457 458 459
        0x12, 0x13,
};

460
#define STAC922X_NUM_CAPS	2
461
static const unsigned long stac922x_capvols[] = {
462 463 464 465 466
	HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
	HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
};
#define stac922x_capsws		stac922x_capvols

467
static const hda_nid_t stac927x_slave_dig_outs[2] = {
468 469 470
	0x1f, 0,
};

471
static const hda_nid_t stac927x_adc_nids[3] = {
472 473 474
        0x07, 0x08, 0x09
};

475
static const hda_nid_t stac927x_mux_nids[3] = {
476 477 478
        0x15, 0x16, 0x17
};

479
static const hda_nid_t stac927x_smux_nids[1] = {
M
Matthew Ranostay 已提交
480 481 482
	0x21,
};

483
static const hda_nid_t stac927x_dac_nids[6] = {
484 485 486
	0x02, 0x03, 0x04, 0x05, 0x06, 0
};

487
static const hda_nid_t stac927x_dmux_nids[1] = {
488 489 490
	0x1b,
};

491
#define STAC927X_NUM_DMICS 2
492
static const hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
493 494 495
	0x13, 0x14, 0
};

496
#define STAC927X_NUM_CAPS	3
497
static const unsigned long stac927x_capvols[] = {
498 499 500 501
	HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
	HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
	HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
};
502
static const unsigned long stac927x_capsws[] = {
503 504 505 506 507
	HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
	HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
	HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
};

508
static const char * const stac927x_spdif_labels[5] = {
509 510 511 512
	"Digital Playback", "ADAT", "Analog Mux 1",
	"Analog Mux 2", "Analog Mux 3"
};

513
static const hda_nid_t stac9205_adc_nids[2] = {
514 515 516
        0x12, 0x13
};

517
static const hda_nid_t stac9205_mux_nids[2] = {
518 519 520
        0x19, 0x1a
};

521
static const hda_nid_t stac9205_dmux_nids[1] = {
522
	0x1d,
523 524
};

525
static const hda_nid_t stac9205_smux_nids[1] = {
M
Matthew Ranostay 已提交
526 527 528
	0x21,
};

529
#define STAC9205_NUM_DMICS	2
530
static const hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
531
        0x17, 0x18, 0
532 533
};

534
#define STAC9205_NUM_CAPS	2
535
static const unsigned long stac9205_capvols[] = {
536 537 538
	HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
	HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
};
539
static const unsigned long stac9205_capsws[] = {
540 541 542 543
	HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
	HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
};

544
static const hda_nid_t stac9200_pin_nids[8] = {
545 546
	0x08, 0x09, 0x0d, 0x0e, 
	0x0f, 0x10, 0x11, 0x12,
M
Matt 已提交
547 548
};

549
static const hda_nid_t stac925x_pin_nids[8] = {
550 551 552 553
	0x07, 0x08, 0x0a, 0x0b, 
	0x0c, 0x0d, 0x10, 0x11,
};

554
static const hda_nid_t stac922x_pin_nids[10] = {
M
Matt 已提交
555 556 557 558
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x15, 0x1b,
};

559
static const hda_nid_t stac92hd73xx_pin_nids[13] = {
560 561
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x12, 0x13,
M
Matthew Ranostay 已提交
562
	0x14, 0x22, 0x23
563 564
};

565
#define STAC92HD71BXX_NUM_PINS 13
566
static const hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
567 568 569 570
	0x0a, 0x0b, 0x0c, 0x0d, 0x00,
	0x00, 0x14, 0x18, 0x19, 0x1e,
	0x1f, 0x20, 0x27
};
571
static const hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
572 573
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x14, 0x18, 0x19, 0x1e,
574
	0x1f, 0x20, 0x27
575 576
};

577
static const hda_nid_t stac927x_pin_nids[14] = {
578 579 580 581 582
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x12, 0x13,
	0x14, 0x21, 0x22, 0x23,
};

583
static const hda_nid_t stac9205_pin_nids[12] = {
584 585 586 587 588
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x14, 0x16, 0x17, 0x18,
	0x21, 0x22,
};

589 590 591 592 593 594 595 596 597 598 599 600 601
static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_info *uinfo)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
}

static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
602
	unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
603

604
	ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
605 606 607 608 609 610 611 612
	return 0;
}

static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
613
	unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
614 615

	return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
616
			spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
617 618
}

M
Matthew Ranostay 已提交
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_info *uinfo)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
}

static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

	ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
	return 0;
}

static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
				  struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
643
	struct hda_input_mux *smux = &spec->private_smux;
M
Matthew Ranostay 已提交
644
	unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
645 646
	int err, val;
	hda_nid_t nid;
M
Matthew Ranostay 已提交
647

648
	err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
M
Matthew Ranostay 已提交
649
			spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
650 651 652 653 654 655 656 657 658
	if (err < 0)
		return err;

	if (spec->spdif_mute) {
		if (smux_idx == 0)
			nid = spec->multiout.dig_out_nid;
		else
			nid = codec->slave_dig_outs[smux_idx - 1];
		if (spec->cur_smux[smux_idx] == smux->num_items - 1)
659
			val = HDA_AMP_MUTE;
660
		else
661
			val = 0;
662
		/* un/mute SPDIF out */
663 664
		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
					 HDA_AMP_MUTE, val);
665 666
	}
	return 0;
M
Matthew Ranostay 已提交
667 668
}

669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
static int stac_vrefout_set(struct hda_codec *codec,
					hda_nid_t nid, unsigned int new_vref)
{
	int error, pinctl;

	snd_printdd("%s, nid %x ctl %x\n", __func__, nid, new_vref);
	pinctl = snd_hda_codec_read(codec, nid, 0,
				AC_VERB_GET_PIN_WIDGET_CONTROL, 0);

	if (pinctl < 0)
		return pinctl;

	pinctl &= 0xff;
	pinctl &= ~AC_PINCTL_VREFEN;
	pinctl |= (new_vref & AC_PINCTL_VREFEN);

685
	error = snd_hda_set_pin_ctl_cache(codec, nid, pinctl);
686 687 688 689 690 691
	if (error < 0)
		return error;

	return 1;
}

692 693 694
static unsigned int stac92xx_vref_set(struct hda_codec *codec,
					hda_nid_t nid, unsigned int new_vref)
{
695
	int error;
696 697 698 699 700 701 702 703 704 705 706 707 708
	unsigned int pincfg;
	pincfg = snd_hda_codec_read(codec, nid, 0,
				AC_VERB_GET_PIN_WIDGET_CONTROL, 0);

	pincfg &= 0xff;
	pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
	pincfg |= new_vref;

	if (new_vref == AC_PINCTL_VREF_HIZ)
		pincfg |= AC_PINCTL_OUT_EN;
	else
		pincfg |= AC_PINCTL_IN_EN;

709
	error = snd_hda_set_pin_ctl_cache(codec, nid, pincfg);
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
	if (error < 0)
		return error;
	else
		return 1;
}

static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
{
	unsigned int vref;
	vref = snd_hda_codec_read(codec, nid, 0,
				AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
	vref &= AC_PINCTL_VREFEN;
	return vref;
}

725
static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
M
Matt 已提交
726 727 728
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
729
	return snd_hda_input_mux_info(spec->input_mux, uinfo);
M
Matt 已提交
730 731
}

732
static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
M
Matt 已提交
733 734 735 736 737 738 739 740 741
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

	ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
	return 0;
}

742
static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
M
Matt 已提交
743 744 745 746
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
747
	const struct hda_input_mux *imux = spec->input_mux;
748
	unsigned int idx, prev_idx, didx;
749 750 751 752 753 754 755 756 757 758 759

	idx = ucontrol->value.enumerated.item[0];
	if (idx >= imux->num_items)
		idx = imux->num_items - 1;
	prev_idx = spec->cur_mux[adc_idx];
	if (prev_idx == idx)
		return 0;
	if (idx < spec->num_analog_muxes) {
		snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
					  AC_VERB_SET_CONNECT_SEL,
					  imux->items[idx].index);
760 761
		if (prev_idx >= spec->num_analog_muxes &&
		    spec->mux_nids[adc_idx] != spec->dmux_nids[adc_idx]) {
762 763 764 765 766 767 768 769 770
			imux = spec->dinput_mux;
			/* 0 = analog */
			snd_hda_codec_write_cache(codec,
						  spec->dmux_nids[adc_idx], 0,
						  AC_VERB_SET_CONNECT_SEL,
						  imux->items[0].index);
		}
	} else {
		imux = spec->dinput_mux;
771 772 773 774
		/* first dimux item is hardcoded to select analog imux,
		 * so lets skip it
		 */
		didx = idx - spec->num_analog_muxes + 1;
775 776
		snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
					  AC_VERB_SET_CONNECT_SEL,
777
					  imux->items[didx].index);
778 779 780
	}
	spec->cur_mux[adc_idx] = idx;
	return 1;
M
Matt 已提交
781 782
}

783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_info *uinfo)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_input_mux_info(spec->mono_mux, uinfo);
}

static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;

	ucontrol->value.enumerated.item[0] = spec->cur_mmux;
	return 0;
}

static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;

	return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
				     spec->mono_nid, &spec->cur_mmux);
}

811 812 813 814 815 816
#define stac92xx_aloopback_info snd_ctl_boolean_mono_info

static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
817
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
818 819
	struct sigmatel_spec *spec = codec->spec;

820 821
	ucontrol->value.integer.value[0] = !!(spec->aloopback &
					      (spec->aloopback_mask << idx));
822 823 824 825 826 827 828 829
	return 0;
}

static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
830
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
831
	unsigned int dac_mode;
832
	unsigned int val, idx_val;
833

834 835 836 837 838
	idx_val = spec->aloopback_mask << idx;
	if (ucontrol->value.integer.value[0])
		val = spec->aloopback | idx_val;
	else
		val = spec->aloopback & ~idx_val;
839
	if (spec->aloopback == val)
840 841
		return 0;

842
	spec->aloopback = val;
843

844 845 846
	/* Only return the bits defined by the shift value of the
	 * first two bytes of the mask
	 */
847
	dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
848 849
				      kcontrol->private_value & 0xFFFF, 0x0);
	dac_mode >>= spec->aloopback_shift;
850

851
	if (spec->aloopback & idx_val) {
852
		snd_hda_power_up(codec);
853
		dac_mode |= idx_val;
854 855
	} else {
		snd_hda_power_down(codec);
856
		dac_mode &= ~idx_val;
857 858 859 860 861 862 863 864
	}

	snd_hda_codec_write_cache(codec, codec->afg, 0,
		kcontrol->private_value >> 16, dac_mode);

	return 1;
}

865
static const struct hda_verb stac9200_core_init[] = {
M
Matt 已提交
866
	/* set dac0mux for dac converter */
867
	{ 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
M
Matt 已提交
868 869 870
	{}
};

871
static const struct hda_verb stac9200_eapd_init[] = {
872 873 874 875 876 877
	/* set dac0mux for dac converter */
	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
	{0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
	{}
};

878
static const struct hda_verb dell_eq_core_init[] = {
879 880 881
	/* set master volume to max value without distortion
	 * and direct control */
	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
882 883 884
	{}
};

885
static const struct hda_verb stac92hd73xx_core_init[] = {
886 887 888 889 890
	/* set master volume and direct control */
	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
	{}
};

891
static const struct hda_verb stac92hd83xxx_core_init[] = {
892 893
	/* power state controls amps */
	{ 0x01, AC_VERB_SET_EAPD, 1 << 2},
894
	{}
895 896
};

897 898 899 900 901 902 903
static const struct hda_verb stac92hd83xxx_hp_zephyr_init[] = {
	{ 0x22, 0x785, 0x43 },
	{ 0x22, 0x782, 0xe0 },
	{ 0x22, 0x795, 0x00 },
	{}
};

904
static const struct hda_verb stac92hd71bxx_core_init[] = {
905 906
	/* set master volume and direct control */
	{ 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
907
	{}
908 909
};

910
static const struct hda_verb stac92hd71bxx_unmute_core_init[] = {
911 912
	/* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
	{ 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
913 914 915 916 917
	{ 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	{}
};

918
static const struct hda_verb stac925x_core_init[] = {
919 920
	/* set dac0mux for dac converter */
	{ 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
921 922
	/* mute the master volume */
	{ 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
923 924 925
	{}
};

926
static const struct hda_verb stac922x_core_init[] = {
M
Matt 已提交
927
	/* set master volume and direct control */	
928
	{ 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
M
Matt 已提交
929 930 931
	{}
};

932
static const struct hda_verb d965_core_init[] = {
933
	/* set master volume and direct control */	
934
	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
935 936 937 938 939 940 941
	/* unmute node 0x1b */
	{ 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
	/* select node 0x03 as DAC */	
	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
	{}
};

942
static const struct hda_verb dell_3st_core_init[] = {
943 944 945 946 947 948 949 950 951
	/* don't set delta bit */
	{0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
	/* unmute node 0x1b */
	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
	/* select node 0x03 as DAC */
	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
	{}
};

952
static const struct hda_verb stac927x_core_init[] = {
953 954
	/* set master volume and direct control */	
	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
955 956
	/* enable analog pc beep path */
	{ 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
957 958 959
	{}
};

960
static const struct hda_verb stac927x_volknob_core_init[] = {
961 962 963 964 965 966 967
	/* don't set delta bit */
	{0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
	/* enable analog pc beep path */
	{0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
	{}
};

968
static const struct hda_verb stac9205_core_init[] = {
969 970
	/* set master volume and direct control */	
	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
971 972
	/* enable analog pc beep path */
	{ 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
973 974 975
	{}
};

976 977 978 979 980 981 982 983 984 985
#define STAC_MONO_MUX \
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = "Mono Mux", \
		.count = 1, \
		.info = stac92xx_mono_mux_enum_info, \
		.get = stac92xx_mono_mux_enum_get, \
		.put = stac92xx_mono_mux_enum_put, \
	}

986
#define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
987 988 989
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name  = "Analog Loopback", \
990
		.count = cnt, \
991 992 993 994 995 996
		.info  = stac92xx_aloopback_info, \
		.get   = stac92xx_aloopback_get, \
		.put   = stac92xx_aloopback_put, \
		.private_value = verb_read | (verb_write << 16), \
	}

997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
#define DC_BIAS(xname, idx, nid) \
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = xname, \
		.index = idx, \
		.info = stac92xx_dc_bias_info, \
		.get = stac92xx_dc_bias_get, \
		.put = stac92xx_dc_bias_put, \
		.private_value = nid, \
	}

1008
static const struct snd_kcontrol_new stac9200_mixer[] = {
1009 1010
	HDA_CODEC_VOLUME_MIN_MUTE("PCM Playback Volume", 0xb, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("PCM Playback Switch", 0xb, 0, HDA_OUTPUT),
M
Matt 已提交
1011 1012 1013 1014 1015
	HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
	{ } /* end */
};

1016
static const struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
1017 1018 1019 1020
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
	{}
};

1021
static const struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
1022
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1023 1024
	{}
};
1025

1026
static const struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
1027 1028 1029 1030
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
	{}
};

1031

1032
static const struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1033 1034
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
};
1035

1036
static const struct snd_kcontrol_new stac925x_mixer[] = {
1037 1038
	HDA_CODEC_VOLUME_MIN_MUTE("PCM Playback Volume", 0xe, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("PCM Playback Switch", 0x0e, 0, HDA_OUTPUT),
M
Matt 已提交
1039 1040 1041
	{ } /* end */
};

1042
static const struct snd_kcontrol_new stac9205_loopback[] = {
1043 1044 1045 1046
	STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
	{}
};

1047
static const struct snd_kcontrol_new stac927x_loopback[] = {
1048 1049 1050 1051
	STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
	{}
};

1052 1053 1054 1055 1056 1057 1058 1059 1060
static struct snd_kcontrol_new stac_dmux_mixer = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Digital Input Source",
	/* count set later */
	.info = stac92xx_dmux_enum_info,
	.get = stac92xx_dmux_enum_get,
	.put = stac92xx_dmux_enum_put,
};

M
Matthew Ranostay 已提交
1061 1062
static struct snd_kcontrol_new stac_smux_mixer = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1063
	.name = "IEC958 Playback Source",
M
Matthew Ranostay 已提交
1064 1065 1066 1067 1068 1069
	/* count set later */
	.info = stac92xx_smux_enum_info,
	.get = stac92xx_smux_enum_get,
	.put = stac92xx_smux_enum_put,
};

1070 1071
static const char * const slave_pfxs[] = {
	"Front", "Surround", "Center", "LFE", "Side",
1072
	"Headphone", "Speaker", "Bass Speaker", "IEC958", "PCM",
1073 1074 1075
	NULL
};

1076 1077 1078 1079 1080 1081 1082
static void stac92xx_update_led_status(struct hda_codec *codec, int enabled);

static void stac92xx_vmaster_hook(void *private_data, int val)
{
	stac92xx_update_led_status(private_data, val);
}

1083 1084
static void stac92xx_free_kctls(struct hda_codec *codec);

M
Matt 已提交
1085 1086 1087
static int stac92xx_build_controls(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
1088
	unsigned int vmaster_tlv[4];
M
Matt 已提交
1089
	int err;
1090
	int i;
M
Matt 已提交
1091

1092 1093 1094 1095 1096
	if (spec->mixer) {
		err = snd_hda_add_new_ctls(codec, spec->mixer);
		if (err < 0)
			return err;
	}
1097 1098 1099 1100 1101 1102

	for (i = 0; i < spec->num_mixers; i++) {
		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
		if (err < 0)
			return err;
	}
1103 1104
	if (!spec->auto_mic && spec->num_dmuxes > 0 &&
	    snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1105
		stac_dmux_mixer.count = spec->num_dmuxes;
1106
		err = snd_hda_ctl_add(codec, 0,
1107 1108 1109 1110
				  snd_ctl_new1(&stac_dmux_mixer, codec));
		if (err < 0)
			return err;
	}
M
Matthew Ranostay 已提交
1111
	if (spec->num_smuxes > 0) {
1112 1113 1114 1115
		int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
		struct hda_input_mux *smux = &spec->private_smux;
		/* check for mute support on SPDIF out */
		if (wcaps & AC_WCAP_OUT_AMP) {
1116
			snd_hda_add_imux_item(smux, "Off", 0, NULL);
1117 1118
			spec->spdif_mute = 1;
		}
M
Matthew Ranostay 已提交
1119
		stac_smux_mixer.count = spec->num_smuxes;
1120
		err = snd_hda_ctl_add(codec, 0,
M
Matthew Ranostay 已提交
1121 1122 1123 1124
				  snd_ctl_new1(&stac_smux_mixer, codec));
		if (err < 0)
			return err;
	}
1125

1126
	if (spec->multiout.dig_out_nid) {
1127 1128 1129 1130
		err = snd_hda_create_dig_out_ctls(codec,
						  spec->multiout.dig_out_nid,
						  spec->multiout.dig_out_nid,
						  spec->autocfg.dig_out_type[0]);
1131 1132
		if (err < 0)
			return err;
1133 1134 1135 1136 1137
		err = snd_hda_create_spdif_share_sw(codec,
						    &spec->multiout);
		if (err < 0)
			return err;
		spec->multiout.share_spdif = 1;
1138
	}
1139
	if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1140 1141 1142 1143
		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
		if (err < 0)
			return err;
	}
1144 1145

	/* if we have no master control, let's create it */
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
	snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
				HDA_OUTPUT, vmaster_tlv);
	/* correct volume offset */
	vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
	/* minimum value is actually mute */
	vmaster_tlv[3] |= TLV_DB_SCALE_MUTE;
	err = snd_hda_add_vmaster(codec, "Master Playback Volume",
				  vmaster_tlv, slave_pfxs,
				  "Playback Volume");
	if (err < 0)
		return err;

	err = __snd_hda_add_vmaster(codec, "Master Playback Switch",
				    NULL, slave_pfxs,
				    "Playback Switch", true,
1161
				    &spec->vmaster_mute.sw_kctl);
1162 1163 1164 1165
	if (err < 0)
		return err;

	if (spec->gpio_led) {
1166
		spec->vmaster_mute.hook = stac92xx_vmaster_hook;
1167
		err = snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute, true);
1168 1169
		if (err < 0)
			return err;
1170 1171
	}

1172 1173 1174 1175 1176 1177 1178
	if (spec->aloopback_ctl &&
	    snd_hda_get_bool_hint(codec, "loopback") == 1) {
		err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
		if (err < 0)
			return err;
	}

1179
	stac92xx_free_kctls(codec); /* no longer needed */
1180

1181 1182 1183
	err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
	if (err < 0)
		return err;
1184

1185
	return 0;	
M
Matt 已提交
1186 1187
}

1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
static const struct hda_pintbl ref9200_pin_configs[] = {
	{ 0x08, 0x01c47010 },
	{ 0x09, 0x01447010 },
	{ 0x0d, 0x0221401f },
	{ 0x0e, 0x01114010 },
	{ 0x0f, 0x02a19020 },
	{ 0x10, 0x01a19021 },
	{ 0x11, 0x90100140 },
	{ 0x12, 0x01813122 },
	{}
M
Matt 已提交
1198 1199
};

1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
static const struct hda_pintbl gateway9200_m4_pin_configs[] = {
	{ 0x08, 0x400000fe },
	{ 0x09, 0x404500f4 },
	{ 0x0d, 0x400100f0 },
	{ 0x0e, 0x90110010 },
	{ 0x0f, 0x400100f1 },
	{ 0x10, 0x02a1902e },
	{ 0x11, 0x500000f2 },
	{ 0x12, 0x500000f3 },
	{}
1210
};
1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221

static const struct hda_pintbl gateway9200_m4_2_pin_configs[] = {
	{ 0x08, 0x400000fe },
	{ 0x09, 0x404500f4 },
	{ 0x0d, 0x400100f0 },
	{ 0x0e, 0x90110010 },
	{ 0x0f, 0x400100f1 },
	{ 0x10, 0x02a1902e },
	{ 0x11, 0x500000f2 },
	{ 0x12, 0x500000f3 },
	{}
1222 1223 1224
};

/*
1225 1226 1227 1228 1229
    STAC 9200 pin configs for
    102801A8
    102801DE
    102801E8
*/
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
static const struct hda_pintbl dell9200_d21_pin_configs[] = {
	{ 0x08, 0x400001f0 },
	{ 0x09, 0x400001f1 },
	{ 0x0d, 0x02214030 },
	{ 0x0e, 0x01014010 },
	{ 0x0f, 0x02a19020 },
	{ 0x10, 0x01a19021 },
	{ 0x11, 0x90100140 },
	{ 0x12, 0x01813122 },
	{}
1240 1241 1242 1243 1244 1245 1246
};

/* 
    STAC 9200 pin configs for
    102801C0
    102801C1
*/
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
static const struct hda_pintbl dell9200_d22_pin_configs[] = {
	{ 0x08, 0x400001f0 },
	{ 0x09, 0x400001f1 },
	{ 0x0d, 0x0221401f },
	{ 0x0e, 0x01014010 },
	{ 0x0f, 0x01813020 },
	{ 0x10, 0x02a19021 },
	{ 0x11, 0x90100140 },
	{ 0x12, 0x400001f2 },
	{}
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
};

/* 
    STAC 9200 pin configs for
    102801C4 (Dell Dimension E310)
    102801C5
    102801C7
    102801D9
    102801DA
    102801E3
*/
1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
static const struct hda_pintbl dell9200_d23_pin_configs[] = {
	{ 0x08, 0x400001f0 },
	{ 0x09, 0x400001f1 },
	{ 0x0d, 0x0221401f },
	{ 0x0e, 0x01014010 },
	{ 0x0f, 0x01813020 },
	{ 0x10, 0x01a19021 },
	{ 0x11, 0x90100140 },
	{ 0x12, 0x400001f2 },
	{}
1278 1279 1280 1281 1282 1283 1284 1285
};


/* 
    STAC 9200-32 pin configs for
    102801B5 (Dell Inspiron 630m)
    102801D8 (Dell Inspiron 640m)
*/
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
static const struct hda_pintbl dell9200_m21_pin_configs[] = {
	{ 0x08, 0x40c003fa },
	{ 0x09, 0x03441340 },
	{ 0x0d, 0x0321121f },
	{ 0x0e, 0x90170310 },
	{ 0x0f, 0x408003fb },
	{ 0x10, 0x03a11020 },
	{ 0x11, 0x401003fc },
	{ 0x12, 0x403003fd },
	{}
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305
};

/* 
    STAC 9200-32 pin configs for
    102801C2 (Dell Latitude D620)
    102801C8 
    102801CC (Dell Latitude D820)
    102801D4 
    102801D6 
*/
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
static const struct hda_pintbl dell9200_m22_pin_configs[] = {
	{ 0x08, 0x40c003fa },
	{ 0x09, 0x0144131f },
	{ 0x0d, 0x0321121f },
	{ 0x0e, 0x90170310 },
	{ 0x0f, 0x90a70321 },
	{ 0x10, 0x03a11020 },
	{ 0x11, 0x401003fb },
	{ 0x12, 0x40f000fc },
	{}
1316 1317 1318 1319 1320 1321 1322
};

/* 
    STAC 9200-32 pin configs for
    102801CE (Dell XPS M1710)
    102801CF (Dell Precision M90)
*/
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332
static const struct hda_pintbl dell9200_m23_pin_configs[] = {
	{ 0x08, 0x40c003fa },
	{ 0x09, 0x01441340 },
	{ 0x0d, 0x0421421f },
	{ 0x0e, 0x90170310 },
	{ 0x0f, 0x408003fb },
	{ 0x10, 0x04a1102e },
	{ 0x11, 0x90170311 },
	{ 0x12, 0x403003fc },
	{}
1333 1334 1335 1336 1337 1338 1339 1340 1341
};

/*
    STAC 9200-32 pin configs for 
    102801C9
    102801CA
    102801CB (Dell Latitude 120L)
    102801D3
*/
1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
static const struct hda_pintbl dell9200_m24_pin_configs[] = {
	{ 0x08, 0x40c003fa },
	{ 0x09, 0x404003fb },
	{ 0x0d, 0x0321121f },
	{ 0x0e, 0x90170310 },
	{ 0x0f, 0x408003fc },
	{ 0x10, 0x03a11020 },
	{ 0x11, 0x401003fd },
	{ 0x12, 0x403003fe },
	{}
1352 1353 1354 1355 1356 1357 1358 1359
};

/*
    STAC 9200-32 pin configs for
    102801BD (Dell Inspiron E1505n)
    102801EE
    102801EF
*/
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
static const struct hda_pintbl dell9200_m25_pin_configs[] = {
	{ 0x08, 0x40c003fa },
	{ 0x09, 0x01441340 },
	{ 0x0d, 0x0421121f },
	{ 0x0e, 0x90170310 },
	{ 0x0f, 0x408003fb },
	{ 0x10, 0x04a11020 },
	{ 0x11, 0x401003fc },
	{ 0x12, 0x403003fd },
	{}
1370 1371 1372 1373 1374 1375 1376
};

/*
    STAC 9200-32 pin configs for
    102801F5 (Dell Inspiron 1501)
    102801F6
*/
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
static const struct hda_pintbl dell9200_m26_pin_configs[] = {
	{ 0x08, 0x40c003fa },
	{ 0x09, 0x404003fb },
	{ 0x0d, 0x0421121f },
	{ 0x0e, 0x90170310 },
	{ 0x0f, 0x408003fc },
	{ 0x10, 0x04a11020 },
	{ 0x11, 0x401003fd },
	{ 0x12, 0x403003fe },
	{}
1387 1388 1389 1390 1391 1392
};

/*
    STAC 9200-32
    102801CD (Dell Inspiron E1705/9400)
*/
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402
static const struct hda_pintbl dell9200_m27_pin_configs[] = {
	{ 0x08, 0x40c003fa },
	{ 0x09, 0x01441340 },
	{ 0x0d, 0x0421121f },
	{ 0x0e, 0x90170310 },
	{ 0x0f, 0x90170310 },
	{ 0x10, 0x04a11020 },
	{ 0x11, 0x90170310 },
	{ 0x12, 0x40f003fc },
	{}
1403 1404
};

1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
static const struct hda_pintbl oqo9200_pin_configs[] = {
	{ 0x08, 0x40c000f0 },
	{ 0x09, 0x404000f1 },
	{ 0x0d, 0x0221121f },
	{ 0x0e, 0x02211210 },
	{ 0x0f, 0x90170111 },
	{ 0x10, 0x90a70120 },
	{ 0x11, 0x400000f2 },
	{ 0x12, 0x400000f3 },
	{}
1415 1416
};

1417

1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
static void stac9200_fixup_panasonic(struct hda_codec *codec,
				     const struct hda_fixup *fix, int action)
{
	struct sigmatel_spec *spec = codec->spec;

	switch (action) {
	case HDA_FIXUP_ACT_PRE_PROBE:
		spec->gpio_mask = spec->gpio_dir = 0x09;
		spec->gpio_data = 0x00;
		break;
	case HDA_FIXUP_ACT_PROBE:
		/* CF-74 has no headphone detection, and the driver should *NOT*
		 * do detection and HP/speaker toggle because the hardware does it.
		 */
		spec->hp_detect = 0;
		break;
	}
}


static const struct hda_fixup stac9200_fixups[] = {
	[STAC_REF] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = ref9200_pin_configs,
	},
	[STAC_9200_OQO] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = oqo9200_pin_configs,
		.chained = true,
		.chain_id = STAC_9200_EAPD_INIT,
	},
	[STAC_9200_DELL_D21] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_d21_pin_configs,
	},
	[STAC_9200_DELL_D22] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_d22_pin_configs,
	},
	[STAC_9200_DELL_D23] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_d23_pin_configs,
	},
	[STAC_9200_DELL_M21] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_m21_pin_configs,
	},
	[STAC_9200_DELL_M22] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_m22_pin_configs,
	},
	[STAC_9200_DELL_M23] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_m23_pin_configs,
	},
	[STAC_9200_DELL_M24] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_m24_pin_configs,
	},
	[STAC_9200_DELL_M25] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_m25_pin_configs,
	},
	[STAC_9200_DELL_M26] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_m26_pin_configs,
	},
	[STAC_9200_DELL_M27] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell9200_m27_pin_configs,
	},
	[STAC_9200_M4] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = gateway9200_m4_pin_configs,
		.chained = true,
		.chain_id = STAC_9200_EAPD_INIT,
	},
	[STAC_9200_M4_2] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = gateway9200_m4_2_pin_configs,
		.chained = true,
		.chain_id = STAC_9200_EAPD_INIT,
	},
	[STAC_9200_PANASONIC] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = stac9200_fixup_panasonic,
	},
	[STAC_9200_EAPD_INIT] = {
		.type = HDA_FIXUP_VERBS,
		.v.verbs = (const struct hda_verb[]) {
			{0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
			{}
		},
	},
1512 1513
};

1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
static const struct hda_model_fixup stac9200_models[] = {
	{ .id = STAC_REF, .name = "ref" },
	{ .id = STAC_9200_OQO, .name = "oqo" },
	{ .id = STAC_9200_DELL_D21, .name = "dell-d21" },
	{ .id = STAC_9200_DELL_D22, .name = "dell-d22" },
	{ .id = STAC_9200_DELL_D23, .name = "dell-d23" },
	{ .id = STAC_9200_DELL_M21, .name = "dell-m21" },
	{ .id = STAC_9200_DELL_M22, .name = "dell-m22" },
	{ .id = STAC_9200_DELL_M23, .name = "dell-m23" },
	{ .id = STAC_9200_DELL_M24, .name = "dell-m24" },
	{ .id = STAC_9200_DELL_M25, .name = "dell-m25" },
	{ .id = STAC_9200_DELL_M26, .name = "dell-m26" },
	{ .id = STAC_9200_DELL_M27, .name = "dell-m27" },
	{ .id = STAC_9200_M4, .name = "gateway-m4" },
	{ .id = STAC_9200_M4_2, .name = "gateway-m4-2" },
	{ .id = STAC_9200_PANASONIC, .name = "panasonic" },
	{}
};

static const struct snd_pci_quirk stac9200_fixup_tbl[] = {
1534 1535 1536
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_REF),
1537 1538
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
		      "DFI LanParty", STAC_REF),
1539
	/* Dell laptops have BIOS problem */
1540 1541
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
		      "unknown Dell", STAC_9200_DELL_D21),
1542
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1543 1544 1545 1546 1547 1548 1549
		      "Dell Inspiron 630m", STAC_9200_DELL_M21),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
		      "Dell Inspiron E1505n", STAC_9200_DELL_M25),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
		      "unknown Dell", STAC_9200_DELL_D22),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
		      "unknown Dell", STAC_9200_DELL_D22),
1550
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
		      "Dell Latitude D620", STAC_9200_DELL_M22),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
		      "unknown Dell", STAC_9200_DELL_D23),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
		      "unknown Dell", STAC_9200_DELL_D23),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
		      "unknown Dell", STAC_9200_DELL_M22),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
		      "unknown Dell", STAC_9200_DELL_M24),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
		      "unknown Dell", STAC_9200_DELL_M24),
1562
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1563
		      "Dell Latitude 120L", STAC_9200_DELL_M24),
1564
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1565
		      "Dell Latitude D820", STAC_9200_DELL_M22),
1566
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1567
		      "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1568
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1569
		      "Dell XPS M1710", STAC_9200_DELL_M23),
1570
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1571 1572 1573 1574 1575
		      "Dell Precision M90", STAC_9200_DELL_M23),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
		      "unknown Dell", STAC_9200_DELL_M22),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
		      "unknown Dell", STAC_9200_DELL_M22),
1576
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1577
		      "unknown Dell", STAC_9200_DELL_M22),
1578
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
		      "Dell Inspiron 640m", STAC_9200_DELL_M21),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
		      "unknown Dell", STAC_9200_DELL_D23),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
		      "unknown Dell", STAC_9200_DELL_D23),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
		      "unknown Dell", STAC_9200_DELL_D21),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
		      "unknown Dell", STAC_9200_DELL_D23),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
		      "unknown Dell", STAC_9200_DELL_D21),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
		      "unknown Dell", STAC_9200_DELL_M25),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
		      "unknown Dell", STAC_9200_DELL_M25),
1594
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1595 1596 1597
		      "Dell Inspiron 1501", STAC_9200_DELL_M26),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
		      "unknown Dell", STAC_9200_DELL_M26),
1598
	/* Panasonic */
1599
	SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1600
	/* Gateway machines needs EAPD to be set on resume */
1601 1602 1603
	SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
	SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
	SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1604 1605
	/* OQO Mobile */
	SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1606 1607 1608
	{} /* terminator */
};

1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
static const struct hda_pintbl ref925x_pin_configs[] = {
	{ 0x07, 0x40c003f0 },
	{ 0x08, 0x424503f2 },
	{ 0x0a, 0x01813022 },
	{ 0x0b, 0x02a19021 },
	{ 0x0c, 0x90a70320 },
	{ 0x0d, 0x02214210 },
	{ 0x10, 0x01019020 },
	{ 0x11, 0x9033032e },
	{}
1619 1620
};

1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
static const struct hda_pintbl stac925xM1_pin_configs[] = {
	{ 0x07, 0x40c003f4 },
	{ 0x08, 0x424503f2 },
	{ 0x0a, 0x400000f3 },
	{ 0x0b, 0x02a19020 },
	{ 0x0c, 0x40a000f0 },
	{ 0x0d, 0x90100210 },
	{ 0x10, 0x400003f1 },
	{ 0x11, 0x9033032e },
	{}
1631 1632
};

1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
static const struct hda_pintbl stac925xM1_2_pin_configs[] = {
	{ 0x07, 0x40c003f4 },
	{ 0x08, 0x424503f2 },
	{ 0x0a, 0x400000f3 },
	{ 0x0b, 0x02a19020 },
	{ 0x0c, 0x40a000f0 },
	{ 0x0d, 0x90100210 },
	{ 0x10, 0x400003f1 },
	{ 0x11, 0x9033032e },
	{}
1643
};
1644

1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
static const struct hda_pintbl stac925xM2_pin_configs[] = {
	{ 0x07, 0x40c003f4 },
	{ 0x08, 0x424503f2 },
	{ 0x0a, 0x400000f3 },
	{ 0x0b, 0x02a19020 },
	{ 0x0c, 0x40a000f0 },
	{ 0x0d, 0x90100210 },
	{ 0x10, 0x400003f1 },
	{ 0x11, 0x9033032e },
	{}
1655 1656
};

1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
static const struct hda_pintbl stac925xM2_2_pin_configs[] = {
	{ 0x07, 0x40c003f4 },
	{ 0x08, 0x424503f2 },
	{ 0x0a, 0x400000f3 },
	{ 0x0b, 0x02a19020 },
	{ 0x0c, 0x40a000f0 },
	{ 0x0d, 0x90100210 },
	{ 0x10, 0x400003f1 },
	{ 0x11, 0x9033032e },
	{}
1667 1668
};

1669 1670 1671 1672 1673 1674 1675 1676 1677 1678
static const struct hda_pintbl stac925xM3_pin_configs[] = {
	{ 0x07, 0x40c003f4 },
	{ 0x08, 0x424503f2 },
	{ 0x0a, 0x400000f3 },
	{ 0x0b, 0x02a19020 },
	{ 0x0c, 0x40a000f0 },
	{ 0x0d, 0x90100210 },
	{ 0x10, 0x400003f1 },
	{ 0x11, 0x503303f3 },
	{}
1679
};
1680

1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
static const struct hda_pintbl stac925xM5_pin_configs[] = {
	{ 0x07, 0x40c003f4 },
	{ 0x08, 0x424503f2 },
	{ 0x0a, 0x400000f3 },
	{ 0x0b, 0x02a19020 },
	{ 0x0c, 0x40a000f0 },
	{ 0x0d, 0x90100210 },
	{ 0x10, 0x400003f1 },
	{ 0x11, 0x9033032e },
	{}
1691 1692
};

1693 1694 1695 1696 1697 1698 1699 1700 1701 1702
static const struct hda_pintbl stac925xM6_pin_configs[] = {
	{ 0x07, 0x40c003f4 },
	{ 0x08, 0x424503f2 },
	{ 0x0a, 0x400000f3 },
	{ 0x0b, 0x02a19020 },
	{ 0x0c, 0x40a000f0 },
	{ 0x0d, 0x90100210 },
	{ 0x10, 0x400003f1 },
	{ 0x11, 0x90330320 },
	{}
1703 1704
};

1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737
static const struct hda_fixup stac925x_fixups[] = {
	[STAC_REF] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = ref925x_pin_configs,
	},
	[STAC_M1] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = stac925xM1_pin_configs,
	},
	[STAC_M1_2] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = stac925xM1_2_pin_configs,
	},
	[STAC_M2] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = stac925xM2_pin_configs,
	},
	[STAC_M2_2] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = stac925xM2_2_pin_configs,
	},
	[STAC_M3] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = stac925xM3_pin_configs,
	},
	[STAC_M5] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = stac925xM5_pin_configs,
	},
	[STAC_M6] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = stac925xM6_pin_configs,
	},
1738 1739
};

1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
static const struct hda_model_fixup stac925x_models[] = {
	{ .id = STAC_REF, .name = "ref" },
	{ .id = STAC_M1, .name = "m1" },
	{ .id = STAC_M1_2, .name = "m1-2" },
	{ .id = STAC_M2, .name = "m2" },
	{ .id = STAC_M2_2, .name = "m2-2" },
	{ .id = STAC_M3, .name = "m3" },
	{ .id = STAC_M5, .name = "m5" },
	{ .id = STAC_M6, .name = "m6" },
	{}
1750 1751
};

1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
static const struct snd_pci_quirk stac925x_fixup_tbl[] = {
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
	SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),

	/* Default table for unknown ID */
	SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),

	/* gateway machines are checked via codec ssid */
1762 1763 1764 1765
	SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
	SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
	SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
	SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1766 1767 1768 1769 1770 1771 1772
	SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
	/* Not sure about the brand name for those */
	SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
	SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
	SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
	SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
	{} /* terminator */
1773 1774
};

1775
static const unsigned int ref92hd73xx_pin_configs[13] = {
1776 1777 1778
	0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
	0x0181302e, 0x01014010, 0x01014020, 0x01014030,
	0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1779 1780 1781
	0x01452050,
};

1782
static const unsigned int dell_m6_pin_configs[13] = {
1783
	0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1784
	0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1785 1786
	0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
	0x4f0000f0,
1787 1788
};

1789
static const unsigned int alienware_m17x_pin_configs[13] = {
1790 1791 1792 1793 1794 1795
	0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
	0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
	0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
	0x904601b0,
};

1796
static const unsigned int intel_dg45id_pin_configs[13] = {
1797
	0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1798
	0x01A19250, 0x01011212, 0x01016211
1799 1800
};

1801
static const unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1802
	[STAC_92HD73XX_REF]	= ref92hd73xx_pin_configs,
1803 1804 1805
	[STAC_DELL_M6_AMIC]	= dell_m6_pin_configs,
	[STAC_DELL_M6_DMIC]	= dell_m6_pin_configs,
	[STAC_DELL_M6_BOTH]	= dell_m6_pin_configs,
1806
	[STAC_DELL_EQ]	= dell_m6_pin_configs,
1807
	[STAC_ALIENWARE_M17X]	= alienware_m17x_pin_configs,
1808
	[STAC_92HD73XX_INTEL]	= intel_dg45id_pin_configs,
1809 1810
};

1811
static const char * const stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1812
	[STAC_92HD73XX_AUTO] = "auto",
1813
	[STAC_92HD73XX_NO_JD] = "no-jd",
1814
	[STAC_92HD73XX_REF] = "ref",
1815
	[STAC_92HD73XX_INTEL] = "intel",
1816 1817 1818
	[STAC_DELL_M6_AMIC] = "dell-m6-amic",
	[STAC_DELL_M6_DMIC] = "dell-m6-dmic",
	[STAC_DELL_M6_BOTH] = "dell-m6",
1819
	[STAC_DELL_EQ] = "dell-eq",
1820
	[STAC_ALIENWARE_M17X] = "alienware",
1821 1822
};

1823
static const struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1824 1825
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1826
				"DFI LanParty", STAC_92HD73XX_REF),
1827 1828
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
				"DFI LanParty", STAC_92HD73XX_REF),
1829 1830 1831 1832
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
				"Intel DG45ID", STAC_92HD73XX_INTEL),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
				"Intel DG45FC", STAC_92HD73XX_INTEL),
1833
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1834
				"Dell Studio 1535", STAC_DELL_M6_DMIC),
1835
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1836
				"unknown Dell", STAC_DELL_M6_DMIC),
1837
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1838
				"unknown Dell", STAC_DELL_M6_BOTH),
1839
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1840
				"unknown Dell", STAC_DELL_M6_BOTH),
1841
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1842
				"unknown Dell", STAC_DELL_M6_AMIC),
1843
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1844
				"unknown Dell", STAC_DELL_M6_AMIC),
1845
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1846 1847 1848
				"unknown Dell", STAC_DELL_M6_DMIC),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
				"unknown Dell", STAC_DELL_M6_DMIC),
1849
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1850
				"Dell Studio 1537", STAC_DELL_M6_DMIC),
1851 1852
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
				"Dell Studio 17", STAC_DELL_M6_DMIC),
1853 1854
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
				"Dell Studio 1555", STAC_DELL_M6_DMIC),
1855 1856
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
				"Dell Studio 1557", STAC_DELL_M6_DMIC),
1857
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1858
				"Dell Studio XPS 1645", STAC_DELL_M6_DMIC),
1859
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1860
				"Dell Studio 1558", STAC_DELL_M6_DMIC),
1861 1862 1863
	{} /* terminator */
};

1864
static const struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1865 1866
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
		      "Alienware M17x", STAC_ALIENWARE_M17X),
1867 1868
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
		      "Alienware M17x", STAC_ALIENWARE_M17X),
1869
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0490,
1870
		      "Alienware M17x R3", STAC_DELL_EQ),
1871 1872 1873
	{} /* terminator */
};

1874
static const unsigned int ref92hd83xxx_pin_configs[10] = {
1875 1876 1877 1878 1879
	0x02214030, 0x02211010, 0x02a19020, 0x02170130,
	0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
	0x01451160, 0x98560170,
};

1880
static const unsigned int dell_s14_pin_configs[10] = {
1881 1882
	0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
	0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1883 1884 1885
	0x40f000f0, 0x40f000f0,
};

1886 1887 1888 1889 1890 1891
static const unsigned int dell_vostro_3500_pin_configs[10] = {
	0x02a11020, 0x0221101f, 0x400000f0, 0x90170110,
	0x400000f1, 0x400000f2, 0x400000f3, 0x90a60160,
	0x400000f4, 0x400000f5,
};

1892
static const unsigned int hp_dv7_4000_pin_configs[10] = {
1893 1894 1895 1896 1897
	0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
	0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
	0x40f000f0, 0x40f000f0,
};

1898 1899 1900 1901 1902 1903
static const unsigned int hp_zephyr_pin_configs[10] = {
	0x01813050, 0x0421201f, 0x04a1205e, 0x96130310,
	0x96130310, 0x0101401f, 0x1111611f, 0xd5a30130,
	0, 0,
};

1904 1905 1906 1907 1908 1909
static const unsigned int hp_cNB11_intquad_pin_configs[10] = {
	0x40f000f0, 0x0221101f, 0x02a11020, 0x92170110,
	0x40f000f0, 0x92170110, 0x40f000f0, 0xd5a30130,
	0x40f000f0, 0x40f000f0,
};

1910
static const unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1911
	[STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1912
	[STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1913
	[STAC_DELL_S14] = dell_s14_pin_configs,
1914
	[STAC_DELL_VOSTRO_3500] = dell_vostro_3500_pin_configs,
1915
	[STAC_92HD83XXX_HP_cNB11_INTQUAD] = hp_cNB11_intquad_pin_configs,
1916
	[STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
1917
	[STAC_HP_ZEPHYR] = hp_zephyr_pin_configs,
1918 1919
};

1920
static const char * const stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1921
	[STAC_92HD83XXX_AUTO] = "auto",
1922
	[STAC_92HD83XXX_REF] = "ref",
1923
	[STAC_92HD83XXX_PWR_REF] = "mic-ref",
1924
	[STAC_DELL_S14] = "dell-s14",
1925
	[STAC_DELL_VOSTRO_3500] = "dell-vostro-3500",
1926
	[STAC_92HD83XXX_HP_cNB11_INTQUAD] = "hp_cNB11_intquad",
1927
	[STAC_HP_DV7_4000] = "hp-dv7-4000",
1928
	[STAC_HP_ZEPHYR] = "hp-zephyr",
1929
	[STAC_92HD83XXX_HP_LED] = "hp-led",
1930
	[STAC_92HD83XXX_HP_INV_LED] = "hp-inv-led",
1931
	[STAC_92HD83XXX_HP_MIC_LED] = "hp-mic-led",
1932
	[STAC_92HD83XXX_HEADSET_JACK] = "headset-jack",
1933 1934
};

1935
static const struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1936 1937
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
T
Takashi Iwai 已提交
1938
		      "DFI LanParty", STAC_92HD83XXX_REF),
1939 1940
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
		      "DFI LanParty", STAC_92HD83XXX_REF),
1941 1942
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
		      "unknown Dell", STAC_DELL_S14),
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0532,
		      "Dell Latitude E6230", STAC_92HD83XXX_HEADSET_JACK),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0533,
		      "Dell Latitude E6330", STAC_92HD83XXX_HEADSET_JACK),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0534,
		      "Dell Latitude E6430", STAC_92HD83XXX_HEADSET_JACK),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0535,
		      "Dell Latitude E6530", STAC_92HD83XXX_HEADSET_JACK),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x053c,
		      "Dell Latitude E5430", STAC_92HD83XXX_HEADSET_JACK),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x053d,
		      "Dell Latitude E5530", STAC_92HD83XXX_HEADSET_JACK),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0549,
		      "Dell Latitude E5430", STAC_92HD83XXX_HEADSET_JACK),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x057d,
		      "Dell Latitude E6430s", STAC_92HD83XXX_HEADSET_JACK),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0584,
		      "Dell Latitude E6430U", STAC_92HD83XXX_HEADSET_JACK),
1961 1962
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x1028,
		      "Dell Vostro 3500", STAC_DELL_VOSTRO_3500),
1963 1964 1965 1966 1967 1968 1969
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1656,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1657,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1658,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1659,
1970
			  "HP Pavilion dv7", STAC_HP_DV7_4000),
1971 1972 1973 1974
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165A,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165B,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
1975 1976
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x18df,
			  "HP Folio", STAC_92HD83XXX_HP_MIC_LED),
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3388,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3389,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355B,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355C,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355D,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355E,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355F,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3560,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358B,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358C,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358D,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3591,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3592,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3593,
			  "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD),
2005 2006
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561,
			  "HP", STAC_HP_ZEPHYR),
2007 2008
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3660,
			  "HP Mini", STAC_92HD83XXX_HP_LED),
2009 2010
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x144E,
			  "HP Pavilion dv5", STAC_92HD83XXX_HP_INV_LED),
2011 2012 2013 2014 2015 2016
	{} /* terminator */
};

static const struct snd_pci_quirk stac92hd83xxx_codec_id_cfg_tbl[] = {
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561,
			  "HP", STAC_HP_ZEPHYR),
2017
	{} /* terminator */
2018 2019
};

2020
static const unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
2021
	0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
2022
	0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
2023 2024
	0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
	0x00000000
2025 2026
};

2027
static const unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
2028
	0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
2029
	0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
2030 2031
	0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
	0x00000000
2032 2033
};

2034
static const unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
2035 2036
	0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
	0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
2037 2038
	0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
	0x00000000
2039 2040
};

2041
static const unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
2042 2043
	0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
	0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
2044 2045
	0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
	0x00000000
2046 2047
};

2048
static const unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
2049
	[STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
2050 2051
	[STAC_DELL_M4_1]	= dell_m4_1_pin_configs,
	[STAC_DELL_M4_2]	= dell_m4_2_pin_configs,
2052
	[STAC_DELL_M4_3]	= dell_m4_3_pin_configs,
2053
	[STAC_HP_M4]		= NULL,
2054
	[STAC_HP_DV4]		= NULL,
T
Takashi Iwai 已提交
2055
	[STAC_HP_DV5]		= NULL,
2056
	[STAC_HP_HDX]           = NULL,
2057
	[STAC_HP_DV4_1222NR]	= NULL,
2058 2059
};

2060
static const char * const stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
2061
	[STAC_92HD71BXX_AUTO] = "auto",
2062
	[STAC_92HD71BXX_REF] = "ref",
2063 2064
	[STAC_DELL_M4_1] = "dell-m4-1",
	[STAC_DELL_M4_2] = "dell-m4-2",
2065
	[STAC_DELL_M4_3] = "dell-m4-3",
2066
	[STAC_HP_M4] = "hp-m4",
2067
	[STAC_HP_DV4] = "hp-dv4",
T
Takashi Iwai 已提交
2068
	[STAC_HP_DV5] = "hp-dv5",
2069
	[STAC_HP_HDX] = "hp-hdx",
2070
	[STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
2071 2072
};

2073
static const struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
2074 2075 2076
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_92HD71BXX_REF),
2077 2078
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
		      "DFI LanParty", STAC_92HD71BXX_REF),
2079 2080
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
		      "HP dv4-1222nr", STAC_HP_DV4_1222NR),
2081 2082
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
			  "HP", STAC_HP_DV5),
2083 2084
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
		      "HP", STAC_HP_DV5),
2085
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
2086
		      "HP dv4-7", STAC_HP_DV4),
2087 2088
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
		      "HP dv4-7", STAC_HP_DV5),
2089 2090
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
		      "HP HDX", STAC_HP_HDX),  /* HDX18 */
M
Matthew Ranostay 已提交
2091
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
2092
		      "HP mini 1000", STAC_HP_M4),
2093
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
2094
		      "HP HDX", STAC_HP_HDX),  /* HDX16 */
2095 2096
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
		      "HP dv6", STAC_HP_DV5),
2097 2098
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
		      "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
2099 2100
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e,
		      "HP DV6", STAC_HP_DV5),
2101 2102
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
		      "HP", STAC_HP_DV5),
2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
				"unknown Dell", STAC_DELL_M4_1),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
				"unknown Dell", STAC_DELL_M4_1),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
				"unknown Dell", STAC_DELL_M4_1),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
				"unknown Dell", STAC_DELL_M4_1),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
				"unknown Dell", STAC_DELL_M4_1),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
				"unknown Dell", STAC_DELL_M4_1),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
				"unknown Dell", STAC_DELL_M4_1),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
				"unknown Dell", STAC_DELL_M4_2),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
				"unknown Dell", STAC_DELL_M4_2),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
				"unknown Dell", STAC_DELL_M4_2),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
				"unknown Dell", STAC_DELL_M4_2),
2125 2126
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
				"unknown Dell", STAC_DELL_M4_3),
2127 2128 2129
	{} /* terminator */
};

2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141
static const struct hda_pintbl ref922x_pin_configs[] = {
	{ 0x0a, 0x01014010 },
	{ 0x0b, 0x01016011 },
	{ 0x0c, 0x01012012 },
	{ 0x0d, 0x0221401f },
	{ 0x0e, 0x01813122 },
	{ 0x0f, 0x01011014 },
	{ 0x10, 0x01441030 },
	{ 0x11, 0x01c41030 },
	{ 0x15, 0x40000100 },
	{ 0x1b, 0x40000100 },
	{}
M
Matt 已提交
2142 2143
};

2144 2145 2146 2147 2148 2149 2150 2151
/*
    STAC 922X pin configs for
    102801A7
    102801AB
    102801A9
    102801D1
    102801D2
*/
2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163
static const struct hda_pintbl dell_922x_d81_pin_configs[] = {
	{ 0x0a, 0x02214030 },
	{ 0x0b, 0x01a19021 },
	{ 0x0c, 0x01111012 },
	{ 0x0d, 0x01114010 },
	{ 0x0e, 0x02a19020 },
	{ 0x0f, 0x01117011 },
	{ 0x10, 0x400001f0 },
	{ 0x11, 0x400001f1 },
	{ 0x15, 0x01813122 },
	{ 0x1b, 0x400001f2 },
	{}
2164 2165 2166 2167 2168 2169 2170
};

/*
    STAC 922X pin configs for
    102801AC
    102801D0
*/
2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182
static const struct hda_pintbl dell_922x_d82_pin_configs[] = {
	{ 0x0a, 0x02214030 },
	{ 0x0b, 0x01a19021 },
	{ 0x0c, 0x01111012 },
	{ 0x0d, 0x01114010 },
	{ 0x0e, 0x02a19020 },
	{ 0x0f, 0x01117011 },
	{ 0x10, 0x01451140 },
	{ 0x11, 0x400001f0 },
	{ 0x15, 0x01813122 },
	{ 0x1b, 0x400001f1 },
	{}
2183 2184 2185 2186 2187 2188
};

/*
    STAC 922X pin configs for
    102801BF
*/
2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200
static const struct hda_pintbl dell_922x_m81_pin_configs[] = {
	{ 0x0a, 0x0321101f },
	{ 0x0b, 0x01112024 },
	{ 0x0c, 0x01111222 },
	{ 0x0d, 0x91174220 },
	{ 0x0e, 0x03a11050 },
	{ 0x0f, 0x01116221 },
	{ 0x10, 0x90a70330 },
	{ 0x11, 0x01452340 },
	{ 0x15, 0x40C003f1 },
	{ 0x1b, 0x405003f0 },
	{}
2201 2202 2203 2204 2205 2206
};

/*
    STAC 9221 A1 pin configs for
    102801D7 (Dell XPS M1210)
*/
2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218
static const struct hda_pintbl dell_922x_m82_pin_configs[] = {
	{ 0x0a, 0x02211211 },
	{ 0x0b, 0x408103ff },
	{ 0x0c, 0x02a1123e },
	{ 0x0d, 0x90100310 },
	{ 0x0e, 0x408003f1 },
	{ 0x0f, 0x0221121f },
	{ 0x10, 0x03451340 },
	{ 0x11, 0x40c003f2 },
	{ 0x15, 0x508003f3 },
	{ 0x1b, 0x405003f4 },
	{}
2219 2220
};

2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246
static const struct hda_pintbl d945gtp3_pin_configs[] = {
	{ 0x0a, 0x0221401f },
	{ 0x0b, 0x01a19022 },
	{ 0x0c, 0x01813021 },
	{ 0x0d, 0x01014010 },
	{ 0x0e, 0x40000100 },
	{ 0x0f, 0x40000100 },
	{ 0x10, 0x40000100 },
	{ 0x11, 0x40000100 },
	{ 0x15, 0x02a19120 },
	{ 0x1b, 0x40000100 },
	{}
};

static const struct hda_pintbl d945gtp5_pin_configs[] = {
	{ 0x0a, 0x0221401f },
	{ 0x0b, 0x01011012 },
	{ 0x0c, 0x01813024 },
	{ 0x0d, 0x01014010 },
	{ 0x0e, 0x01a19021 },
	{ 0x0f, 0x01016011 },
	{ 0x10, 0x01452130 },
	{ 0x11, 0x40000100 },
	{ 0x15, 0x02a19320 },
	{ 0x1b, 0x40000100 },
	{}
2247 2248
};

2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
static const struct hda_pintbl intel_mac_v1_pin_configs[] = {
	{ 0x0a, 0x0121e21f },
	{ 0x0b, 0x400000ff },
	{ 0x0c, 0x9017e110 },
	{ 0x0d, 0x400000fd },
	{ 0x0e, 0x400000fe },
	{ 0x0f, 0x0181e020 },
	{ 0x10, 0x1145e030 },
	{ 0x11, 0x11c5e240 },
	{ 0x15, 0x400000fc },
	{ 0x1b, 0x400000fb },
	{}
2261 2262
};

2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274
static const struct hda_pintbl intel_mac_v2_pin_configs[] = {
	{ 0x0a, 0x0121e21f },
	{ 0x0b, 0x90a7012e },
	{ 0x0c, 0x9017e110 },
	{ 0x0d, 0x400000fd },
	{ 0x0e, 0x400000fe },
	{ 0x0f, 0x0181e020 },
	{ 0x10, 0x1145e230 },
	{ 0x11, 0x500000fa },
	{ 0x15, 0x400000fc },
	{ 0x1b, 0x400000fb },
	{}
2275 2276
};

2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288
static const struct hda_pintbl intel_mac_v3_pin_configs[] = {
	{ 0x0a, 0x0121e21f },
	{ 0x0b, 0x90a7012e },
	{ 0x0c, 0x9017e110 },
	{ 0x0d, 0x400000fd },
	{ 0x0e, 0x400000fe },
	{ 0x0f, 0x0181e020 },
	{ 0x10, 0x1145e230 },
	{ 0x11, 0x11c5e240 },
	{ 0x15, 0x400000fc },
	{ 0x1b, 0x400000fb },
	{}
2289 2290
};

2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302
static const struct hda_pintbl intel_mac_v4_pin_configs[] = {
	{ 0x0a, 0x0321e21f },
	{ 0x0b, 0x03a1e02e },
	{ 0x0c, 0x9017e110 },
	{ 0x0d, 0x9017e11f },
	{ 0x0e, 0x400000fe },
	{ 0x0f, 0x0381e020 },
	{ 0x10, 0x1345e230 },
	{ 0x11, 0x13c5e240 },
	{ 0x15, 0x400000fc },
	{ 0x1b, 0x400000fb },
	{}
2303 2304
};

2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
static const struct hda_pintbl intel_mac_v5_pin_configs[] = {
	{ 0x0a, 0x0321e21f },
	{ 0x0b, 0x03a1e02e },
	{ 0x0c, 0x9017e110 },
	{ 0x0d, 0x9017e11f },
	{ 0x0e, 0x400000fe },
	{ 0x0f, 0x0381e020 },
	{ 0x10, 0x1345e230 },
	{ 0x11, 0x13c5e240 },
	{ 0x15, 0x400000fc },
	{ 0x1b, 0x400000fb },
	{}
2317 2318
};

2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330
static const struct hda_pintbl ecs202_pin_configs[] = {
	{ 0x0a, 0x0221401f },
	{ 0x0b, 0x02a19020 },
	{ 0x0c, 0x01a19020 },
	{ 0x0d, 0x01114010 },
	{ 0x0e, 0x408000f0 },
	{ 0x0f, 0x01813022 },
	{ 0x10, 0x074510a0 },
	{ 0x11, 0x40c400f1 },
	{ 0x15, 0x9037012e },
	{ 0x1b, 0x40e000f2 },
	{}
2331 2332
};

2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347
/* codec SSIDs for Intel Mac sharing the same PCI SSID 8384:7680 */
static const struct snd_pci_quirk stac922x_intel_mac_fixup_tbl[] = {
	SND_PCI_QUIRK(0x106b, 0x0800, "Mac", STAC_INTEL_MAC_V1),
	SND_PCI_QUIRK(0x106b, 0x0600, "Mac", STAC_INTEL_MAC_V2),
	SND_PCI_QUIRK(0x106b, 0x0700, "Mac", STAC_INTEL_MAC_V2),
	SND_PCI_QUIRK(0x106b, 0x0e00, "Mac", STAC_INTEL_MAC_V3),
	SND_PCI_QUIRK(0x106b, 0x0f00, "Mac", STAC_INTEL_MAC_V3),
	SND_PCI_QUIRK(0x106b, 0x1600, "Mac", STAC_INTEL_MAC_V3),
	SND_PCI_QUIRK(0x106b, 0x1700, "Mac", STAC_INTEL_MAC_V3),
	SND_PCI_QUIRK(0x106b, 0x0200, "Mac", STAC_INTEL_MAC_V3),
	SND_PCI_QUIRK(0x106b, 0x1e00, "Mac", STAC_INTEL_MAC_V3),
	SND_PCI_QUIRK(0x106b, 0x1a00, "Mac", STAC_INTEL_MAC_V4),
	SND_PCI_QUIRK(0x106b, 0x0a00, "Mac", STAC_INTEL_MAC_V5),
	SND_PCI_QUIRK(0x106b, 0x2200, "Mac", STAC_INTEL_MAC_V5),
	{}
2348
};
2349

2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464
static const struct hda_fixup stac922x_fixups[];

/* remap the fixup from codec SSID and apply it */
static void stac922x_fixup_intel_mac_auto(struct hda_codec *codec,
					  const struct hda_fixup *fix,
					  int action)
{
	if (action != HDA_FIXUP_ACT_PRE_PROBE)
		return;
	snd_hda_pick_fixup(codec, NULL, stac922x_intel_mac_fixup_tbl,
			   stac922x_fixups);
	if (codec->fixup_id != STAC_INTEL_MAC_AUTO)
		snd_hda_apply_fixup(codec, action);
}

static void stac922x_fixup_intel_mac_gpio(struct hda_codec *codec,
					  const struct hda_fixup *fix,
					  int action)
{
	struct sigmatel_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		spec->gpio_mask = spec->gpio_dir = 0x03;
		spec->gpio_data = 0x03;
	}
}

static const struct hda_fixup stac922x_fixups[] = {
	[STAC_D945_REF] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = ref922x_pin_configs,
	},
	[STAC_D945GTP3] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = d945gtp3_pin_configs,
	},
	[STAC_D945GTP5] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = d945gtp5_pin_configs,
	},
	[STAC_INTEL_MAC_AUTO] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = stac922x_fixup_intel_mac_auto,
	},
	[STAC_INTEL_MAC_V1] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = intel_mac_v1_pin_configs,
		.chained = true,
		.chain_id = STAC_922X_INTEL_MAC_GPIO,
	},
	[STAC_INTEL_MAC_V2] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = intel_mac_v2_pin_configs,
		.chained = true,
		.chain_id = STAC_922X_INTEL_MAC_GPIO,
	},
	[STAC_INTEL_MAC_V3] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = intel_mac_v3_pin_configs,
		.chained = true,
		.chain_id = STAC_922X_INTEL_MAC_GPIO,
	},
	[STAC_INTEL_MAC_V4] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = intel_mac_v4_pin_configs,
		.chained = true,
		.chain_id = STAC_922X_INTEL_MAC_GPIO,
	},
	[STAC_INTEL_MAC_V5] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = intel_mac_v5_pin_configs,
		.chained = true,
		.chain_id = STAC_922X_INTEL_MAC_GPIO,
	},
	[STAC_922X_INTEL_MAC_GPIO] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = stac922x_fixup_intel_mac_gpio,
	},
	[STAC_ECS_202] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = ecs202_pin_configs,
	},
	[STAC_922X_DELL_D81] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell_922x_d81_pin_configs,
	},
	[STAC_922X_DELL_D82] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell_922x_d82_pin_configs,
	},
	[STAC_922X_DELL_M81] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell_922x_m81_pin_configs,
	},
	[STAC_922X_DELL_M82] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell_922x_m82_pin_configs,
	},
};

static const struct hda_model_fixup stac922x_models[] = {
	{ .id = STAC_D945_REF, .name = "ref" },
	{ .id = STAC_D945GTP5, .name = "5stack" },
	{ .id = STAC_D945GTP3, .name = "3stack" },
	{ .id = STAC_INTEL_MAC_V1, .name = "intel-mac-v1" },
	{ .id = STAC_INTEL_MAC_V2, .name = "intel-mac-v2" },
	{ .id = STAC_INTEL_MAC_V3, .name = "intel-mac-v3" },
	{ .id = STAC_INTEL_MAC_V4, .name = "intel-mac-v4" },
	{ .id = STAC_INTEL_MAC_V5, .name = "intel-mac-v5" },
	{ .id = STAC_INTEL_MAC_AUTO, .name = "intel-mac-auto" },
	{ .id = STAC_ECS_202, .name = "ecs202" },
	{ .id = STAC_922X_DELL_D81, .name = "dell-d81" },
	{ .id = STAC_922X_DELL_D82, .name = "dell-d82" },
	{ .id = STAC_922X_DELL_M81, .name = "dell-m81" },
	{ .id = STAC_922X_DELL_M82, .name = "dell-m82" },
2465
	/* for backward compatibility */
2466 2467 2468 2469 2470 2471 2472 2473 2474 2475
	{ .id = STAC_INTEL_MAC_V3, .name = "macmini" },
	{ .id = STAC_INTEL_MAC_V5, .name = "macbook" },
	{ .id = STAC_INTEL_MAC_V3, .name = "macbook-pro-v1" },
	{ .id = STAC_INTEL_MAC_V3, .name = "macbook-pro" },
	{ .id = STAC_INTEL_MAC_V2, .name = "imac-intel" },
	{ .id = STAC_INTEL_MAC_V3, .name = "imac-intel-20" },
	{}
};

static const struct snd_pci_quirk stac922x_fixup_tbl[] = {
2476 2477 2478
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_D945_REF),
2479 2480
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
		      "DFI LanParty", STAC_D945_REF),
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533
	/* Intel 945G based systems */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
		      "Intel D945G", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
		      "Intel D945G", STAC_D945GTP3),
	/* Intel D945G 5-stack systems */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
		      "Intel D945G", STAC_D945GTP5),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
		      "Intel D945G", STAC_D945GTP5),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
		      "Intel D945G", STAC_D945GTP5),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
		      "Intel D945G", STAC_D945GTP5),
	/* Intel 945P based systems */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
		      "Intel D945P", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
		      "Intel D945P", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
		      "Intel D945P", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
		      "Intel D945P", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
		      "Intel D945P", STAC_D945GTP3),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
		      "Intel D945P", STAC_D945GTP5),
2534 2535 2536
	/* other intel */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
		      "Intel D945", STAC_D945_REF),
2537
	/* other systems  */
2538

2539
	/* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
2540 2541
	SND_PCI_QUIRK(0x8384, 0x7680, "Mac", STAC_INTEL_MAC_AUTO),

2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
	/* Dell systems  */
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
		      "unknown Dell", STAC_922X_DELL_D81),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
		      "unknown Dell", STAC_922X_DELL_D81),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
		      "unknown Dell", STAC_922X_DELL_D81),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
		      "unknown Dell", STAC_922X_DELL_D82),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
		      "unknown Dell", STAC_922X_DELL_M81),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
		      "unknown Dell", STAC_922X_DELL_D82),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
		      "unknown Dell", STAC_922X_DELL_D81),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
		      "unknown Dell", STAC_922X_DELL_D81),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
		      "Dell XPS M1210", STAC_922X_DELL_M82),
2561
	/* ECS/PC Chips boards */
T
Takashi Iwai 已提交
2562
	SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2563
		      "ECS/PC chips", STAC_ECS_202),
2564 2565 2566
	{} /* terminator */
};

2567
static const unsigned int ref927x_pin_configs[14] = {
2568 2569 2570 2571
	0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
	0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 
	0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
	0x01c42190, 0x40000100,
2572 2573
};

2574
static const unsigned int d965_3st_pin_configs[14] = {
2575 2576 2577 2578 2579 2580
	0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
	0x01a19021, 0x01813024, 0x40000100, 0x40000100,
	0x40000100, 0x40000100, 0x40000100, 0x40000100,
	0x40000100, 0x40000100
};

2581
static const unsigned int d965_5st_pin_configs[14] = {
2582 2583 2584 2585 2586 2587
	0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
	0x01a19040, 0x01011012, 0x01016011, 0x40000100,
	0x40000100, 0x40000100, 0x40000100, 0x01442070,
	0x40000100, 0x40000100
};

2588
static const unsigned int d965_5st_no_fp_pin_configs[14] = {
2589 2590 2591 2592 2593 2594
	0x40000100, 0x40000100, 0x0181304e, 0x01014010,
	0x01a19040, 0x01011012, 0x01016011, 0x40000100,
	0x40000100, 0x40000100, 0x40000100, 0x01442070,
	0x40000100, 0x40000100
};

2595
static const unsigned int dell_3st_pin_configs[14] = {
2596 2597
	0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
	0x01111212, 0x01116211, 0x01813050, 0x01112214,
2598
	0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2599 2600 2601
	0x40c003fc, 0x40000100
};

2602
static const unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2603
	[STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2604 2605 2606
	[STAC_D965_REF]  = ref927x_pin_configs,
	[STAC_D965_3ST]  = d965_3st_pin_configs,
	[STAC_D965_5ST]  = d965_5st_pin_configs,
2607
	[STAC_D965_5ST_NO_FP]  = d965_5st_no_fp_pin_configs,
2608 2609
	[STAC_DELL_3ST]  = dell_3st_pin_configs,
	[STAC_DELL_BIOS] = NULL,
2610
	[STAC_927X_VOLKNOB] = NULL,
2611 2612
};

2613
static const char * const stac927x_models[STAC_927X_MODELS] = {
2614
	[STAC_927X_AUTO]	= "auto",
2615
	[STAC_D965_REF_NO_JD]	= "ref-no-jd",
2616 2617 2618
	[STAC_D965_REF]		= "ref",
	[STAC_D965_3ST]		= "3stack",
	[STAC_D965_5ST]		= "5stack",
2619
	[STAC_D965_5ST_NO_FP]	= "5stack-no-fp",
2620 2621
	[STAC_DELL_3ST]		= "dell-3stack",
	[STAC_DELL_BIOS]	= "dell-bios",
2622
	[STAC_927X_VOLKNOB]	= "volknob",
2623 2624
};

2625
static const struct snd_pci_quirk stac927x_cfg_tbl[] = {
2626 2627 2628
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_D965_REF),
2629 2630
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
		      "DFI LanParty", STAC_D965_REF),
2631
	 /* Intel 946 based systems */
2632 2633
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2634
	/* 965 based 3 stack systems */
T
Takashi Iwai 已提交
2635 2636 2637 2638
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
			   "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
			   "Intel D965", STAC_D965_3ST),
2639
	/* Dell 3 stack systems */
2640
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2641 2642
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
2643
	/* Dell 3 stack systems with verb table in BIOS */
M
Matthew Ranostay 已提交
2644
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2645
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
M
Matthew Ranostay 已提交
2646
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
2647
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
2648
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2649 2650 2651 2652
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2653
	/* 965 based 5 stack systems */
T
Takashi Iwai 已提交
2654 2655 2656 2657
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
			   "Intel D965", STAC_D965_5ST),
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
			   "Intel D965", STAC_D965_5ST),
2658 2659
	/* volume-knob fixes */
	SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2660 2661 2662
	{} /* terminator */
};

2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676
static const struct hda_pintbl ref9205_pin_configs[] = {
	{ 0x0a, 0x40000100 },
	{ 0x0b, 0x40000100 },
	{ 0x0c, 0x01016011 },
	{ 0x0d, 0x01014010 },
	{ 0x0e, 0x01813122 },
	{ 0x0f, 0x01a19021 },
	{ 0x14, 0x01019020 },
	{ 0x16, 0x40000100 },
	{ 0x17, 0x90a000f0 },
	{ 0x18, 0x90a000f0 },
	{ 0x21, 0x01441030 },
	{ 0x22, 0x01c41030 },
	{}
2677 2678
};

2679 2680 2681 2682 2683 2684 2685 2686
/*
    STAC 9205 pin configs for
    102801F1
    102801F2
    102801FC
    102801FD
    10280204
    1028021F
2687
    10280228 (Dell Vostro 1500)
2688
    10280229 (Dell Vostro 1700)
2689
*/
2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703
static const struct hda_pintbl dell_9205_m42_pin_configs[] = {
	{ 0x0a, 0x0321101F },
	{ 0x0b, 0x03A11020 },
	{ 0x0c, 0x400003FA },
	{ 0x0d, 0x90170310 },
	{ 0x0e, 0x400003FB },
	{ 0x0f, 0x400003FC },
	{ 0x14, 0x400003FD },
	{ 0x16, 0x40F000F9 },
	{ 0x17, 0x90A60330 },
	{ 0x18, 0x400003FF },
	{ 0x21, 0x0144131F },
	{ 0x22, 0x40C003FE },
	{}
2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
};

/*
    STAC 9205 pin configs for
    102801F9
    102801FA
    102801FE
    102801FF (Dell Precision M4300)
    10280206
    10280200
    10280201
*/
2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732
static const struct hda_pintbl dell_9205_m43_pin_configs[] = {
	{ 0x0a, 0x0321101f },
	{ 0x0b, 0x03a11020 },
	{ 0x0c, 0x90a70330 },
	{ 0x0d, 0x90170310 },
	{ 0x0e, 0x400000fe },
	{ 0x0f, 0x400000ff },
	{ 0x14, 0x400000fd },
	{ 0x16, 0x40f000f9 },
	{ 0x17, 0x400000fa },
	{ 0x18, 0x400000fc },
	{ 0x21, 0x0144131f },
	{ 0x22, 0x40c003f8 },
	/* Enable SPDIF in/out */
	{ 0x1f, 0x01441030 },
	{ 0x20, 0x1c410030 },
	{}
2733 2734
};

2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748
static const struct hda_pintbl dell_9205_m44_pin_configs[] = {
	{ 0x0a, 0x0421101f },
	{ 0x0b, 0x04a11020 },
	{ 0x0c, 0x400003fa },
	{ 0x0d, 0x90170310 },
	{ 0x0e, 0x400003fb },
	{ 0x0f, 0x400003fc },
	{ 0x14, 0x400003fd },
	{ 0x16, 0x400003f9 },
	{ 0x17, 0x90a60330 },
	{ 0x18, 0x400003ff },
	{ 0x21, 0x01441340 },
	{ 0x22, 0x40c003fe },
	{}
2749 2750
};

2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824
static void stac9205_fixup_ref(struct hda_codec *codec,
			       const struct hda_fixup *fix, int action)
{
	struct sigmatel_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		snd_hda_apply_pincfgs(codec, ref9205_pin_configs);
		/* SPDIF-In enabled */
		spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0;
	}
}

static int stac_add_event(struct hda_codec *codec, hda_nid_t nid,
			  unsigned char type, int data);

static void stac9205_fixup_dell_m43(struct hda_codec *codec,
				    const struct hda_fixup *fix, int action)
{
	struct sigmatel_spec *spec = codec->spec;
	int err;

	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
		snd_hda_apply_pincfgs(codec, dell_9205_m43_pin_configs);

		/* Enable unsol response for GPIO4/Dock HP connection */
		err = stac_add_event(codec, codec->afg, STAC_VREF_EVENT, 0x01);
		if (err < 0)
			return;
		snd_hda_codec_write_cache(codec, codec->afg, 0,
			AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
		snd_hda_jack_detect_enable(codec, codec->afg, 0);

		spec->gpio_dir = 0x0b;
		spec->eapd_mask = 0x01;
		spec->gpio_mask = 0x1b;
		spec->gpio_mute = 0x10;
		/* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
		 * GPIO3 Low = DRM
		 */
		spec->gpio_data = 0x01;
	}
}

static void stac9205_fixup_eapd(struct hda_codec *codec,
				const struct hda_fixup *fix, int action)
{
	struct sigmatel_spec *spec = codec->spec;

	if (action == HDA_FIXUP_ACT_PRE_PROBE)
		spec->eapd_switch = 0;
}

static const struct hda_fixup stac9205_fixups[] = {
	[STAC_9205_REF] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = stac9205_fixup_ref,
	},
	[STAC_9205_DELL_M42] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell_9205_m42_pin_configs,
	},
	[STAC_9205_DELL_M43] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = stac9205_fixup_dell_m43,
	},
	[STAC_9205_DELL_M44] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = dell_9205_m44_pin_configs,
	},
	[STAC_9205_EAPD] = {
		.type = HDA_FIXUP_FUNC,
		.v.func = stac9205_fixup_eapd,
	},
	{}
2825 2826
};

2827 2828 2829 2830 2831 2832 2833
static const struct hda_model_fixup stac9205_models[] = {
	{ .id = STAC_9205_REF, .name = "ref" },
	{ .id = STAC_9205_DELL_M42, .name = "dell-m42" },
	{ .id = STAC_9205_DELL_M43, .name = "dell-m43" },
	{ .id = STAC_9205_DELL_M44, .name = "dell-m44" },
	{ .id = STAC_9205_EAPD, .name = "eapd" },
	{}
2834 2835
};

2836
static const struct snd_pci_quirk stac9205_fixup_tbl[] = {
2837 2838 2839
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_9205_REF),
2840 2841
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
		      "SigmaTel", STAC_9205_REF),
2842 2843
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
		      "DFI LanParty", STAC_9205_REF),
2844
	/* Dell */
2845 2846 2847 2848
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
		      "unknown Dell", STAC_9205_DELL_M42),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
		      "unknown Dell", STAC_9205_DELL_M42),
2849
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2850
		      "Dell Precision", STAC_9205_DELL_M43),
2851 2852 2853 2854
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
		      "Dell Precision", STAC_9205_DELL_M43),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
		      "Dell Precision", STAC_9205_DELL_M43),
2855 2856 2857 2858
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
		      "unknown Dell", STAC_9205_DELL_M42),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
		      "unknown Dell", STAC_9205_DELL_M42),
2859 2860 2861
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
		      "Dell Precision", STAC_9205_DELL_M43),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2862 2863 2864
		      "Dell Precision M4300", STAC_9205_DELL_M43),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
		      "unknown Dell", STAC_9205_DELL_M42),
T
Takashi Iwai 已提交
2865 2866 2867 2868 2869 2870
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
		      "Dell Precision", STAC_9205_DELL_M43),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
		      "Dell Precision", STAC_9205_DELL_M43),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
		      "Dell Precision", STAC_9205_DELL_M43),
2871 2872
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
		      "Dell Inspiron", STAC_9205_DELL_M44),
2873 2874
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
		      "Dell Vostro 1500", STAC_9205_DELL_M42),
2875 2876
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
		      "Dell Vostro 1700", STAC_9205_DELL_M42),
2877
	/* Gateway */
2878
	SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2879
	SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2880 2881 2882
	{} /* terminator */
};

2883
static void stac92xx_set_config_regs(struct hda_codec *codec,
2884
				     const unsigned int *pincfgs)
2885 2886 2887 2888
{
	int i;
	struct sigmatel_spec *spec = codec->spec;

2889 2890
	if (!pincfgs)
		return;
2891

2892
	for (i = 0; i < spec->num_pins; i++)
2893 2894 2895
		if (spec->pin_nids[i] && pincfgs[i])
			snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
						 pincfgs[i]);
2896 2897
}

2898
/*
2899
 * Analog playback callbacks
2900
 */
2901 2902
static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
				      struct hda_codec *codec,
2903
				      struct snd_pcm_substream *substream)
M
Matt 已提交
2904
{
2905
	struct sigmatel_spec *spec = codec->spec;
M
Matthew Ranostay 已提交
2906 2907
	if (spec->stream_delay)
		msleep(spec->stream_delay);
2908 2909
	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
					     hinfo);
M
Matt 已提交
2910 2911 2912 2913 2914 2915
}

static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
					 struct hda_codec *codec,
					 unsigned int stream_tag,
					 unsigned int format,
2916
					 struct snd_pcm_substream *substream)
M
Matt 已提交
2917 2918
{
	struct sigmatel_spec *spec = codec->spec;
2919
	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
M
Matt 已提交
2920 2921 2922 2923
}

static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
					struct hda_codec *codec,
2924
					struct snd_pcm_substream *substream)
M
Matt 已提交
2925 2926 2927 2928 2929
{
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
}

2930 2931 2932 2933 2934
/*
 * Digital playback callbacks
 */
static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
					  struct hda_codec *codec,
2935
					  struct snd_pcm_substream *substream)
2936 2937 2938 2939 2940 2941 2942
{
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
}

static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
					   struct hda_codec *codec,
2943
					   struct snd_pcm_substream *substream)
2944 2945 2946 2947 2948
{
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
}

2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959
static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
					 struct hda_codec *codec,
					 unsigned int stream_tag,
					 unsigned int format,
					 struct snd_pcm_substream *substream)
{
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
					     stream_tag, format, substream);
}

2960 2961 2962 2963 2964 2965 2966 2967
static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
					struct hda_codec *codec,
					struct snd_pcm_substream *substream)
{
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
}

2968

M
Matt 已提交
2969 2970 2971 2972 2973 2974 2975
/*
 * Analog capture callbacks
 */
static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
					struct hda_codec *codec,
					unsigned int stream_tag,
					unsigned int format,
2976
					struct snd_pcm_substream *substream)
M
Matt 已提交
2977 2978
{
	struct sigmatel_spec *spec = codec->spec;
M
Matthew Ranostay 已提交
2979
	hda_nid_t nid = spec->adc_nids[substream->number];
M
Matt 已提交
2980

M
Matthew Ranostay 已提交
2981 2982
	if (spec->powerdown_adcs) {
		msleep(40);
2983
		snd_hda_codec_write(codec, nid, 0,
M
Matthew Ranostay 已提交
2984 2985 2986
			AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
	}
	snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
M
Matt 已提交
2987 2988 2989 2990 2991
	return 0;
}

static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
					struct hda_codec *codec,
2992
					struct snd_pcm_substream *substream)
M
Matt 已提交
2993 2994
{
	struct sigmatel_spec *spec = codec->spec;
M
Matthew Ranostay 已提交
2995
	hda_nid_t nid = spec->adc_nids[substream->number];
M
Matt 已提交
2996

M
Matthew Ranostay 已提交
2997 2998
	snd_hda_codec_cleanup_stream(codec, nid);
	if (spec->powerdown_adcs)
2999
		snd_hda_codec_write(codec, nid, 0,
M
Matthew Ranostay 已提交
3000
			AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
M
Matt 已提交
3001 3002 3003
	return 0;
}

3004
static const struct hda_pcm_stream stac92xx_pcm_digital_playback = {
3005 3006 3007 3008 3009 3010
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in stac92xx_build_pcms */
	.ops = {
		.open = stac92xx_dig_playback_pcm_open,
3011
		.close = stac92xx_dig_playback_pcm_close,
3012 3013
		.prepare = stac92xx_dig_playback_pcm_prepare,
		.cleanup = stac92xx_dig_playback_pcm_cleanup
3014 3015 3016
	},
};

3017
static const struct hda_pcm_stream stac92xx_pcm_digital_capture = {
3018 3019 3020 3021 3022 3023
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in stac92xx_build_pcms */
};

3024
static const struct hda_pcm_stream stac92xx_pcm_analog_playback = {
M
Matt 已提交
3025 3026
	.substreams = 1,
	.channels_min = 2,
3027
	.channels_max = 8,
M
Matt 已提交
3028 3029 3030 3031 3032 3033 3034 3035
	.nid = 0x02, /* NID to query formats and rates */
	.ops = {
		.open = stac92xx_playback_pcm_open,
		.prepare = stac92xx_playback_pcm_prepare,
		.cleanup = stac92xx_playback_pcm_cleanup
	},
};

3036
static const struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	.nid = 0x06, /* NID to query formats and rates */
	.ops = {
		.open = stac92xx_playback_pcm_open,
		.prepare = stac92xx_playback_pcm_prepare,
		.cleanup = stac92xx_playback_pcm_cleanup
	},
};

3048
static const struct hda_pcm_stream stac92xx_pcm_analog_capture = {
M
Matt 已提交
3049 3050
	.channels_min = 2,
	.channels_max = 2,
3051
	/* NID + .substreams is set in stac92xx_build_pcms */
M
Matt 已提交
3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065
	.ops = {
		.prepare = stac92xx_capture_pcm_prepare,
		.cleanup = stac92xx_capture_pcm_cleanup
	},
};

static int stac92xx_build_pcms(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	struct hda_pcm *info = spec->pcm_rec;

	codec->num_pcms = 1;
	codec->pcm_info = info;

3066
	info->name = "STAC92xx Analog";
M
Matt 已提交
3067
	info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
3068 3069
	info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
		spec->multiout.dac_nids[0];
3070 3071 3072 3073 3074
	if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
	    spec->autocfg.line_outs == 2)
		info->stream[SNDRV_PCM_STREAM_PLAYBACK].chmap =
			snd_pcm_2_1_chmaps;

M
Matt 已提交
3075
	info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
3076
	info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3077
	info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
3078 3079 3080 3081 3082 3083 3084

	if (spec->alt_switch) {
		codec->num_pcms++;
		info++;
		info->name = "STAC92xx Analog Alt";
		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
	}
M
Matt 已提交
3085

3086 3087 3088 3089
	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
		codec->num_pcms++;
		info++;
		info->name = "STAC92xx Digital";
3090
		info->pcm_type = spec->autocfg.dig_out_type[0];
3091 3092 3093 3094 3095 3096 3097 3098 3099 3100
		if (spec->multiout.dig_out_nid) {
			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
		}
		if (spec->dig_in_nid) {
			info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
		}
	}

M
Matt 已提交
3101 3102 3103
	return 0;
}

3104 3105 3106
static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)

{
3107
	snd_hda_set_pin_ctl_cache(codec, nid, pin_type);
3108 3109
}

3110 3111 3112 3113 3114 3115 3116 3117
#define stac92xx_hp_switch_info		snd_ctl_boolean_mono_info

static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
			struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;

3118
	ucontrol->value.integer.value[0] = !!spec->hp_switch;
3119 3120 3121
	return 0;
}

3122
static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
3123

3124 3125 3126 3127 3128
static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
			struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
3129 3130 3131
	int nid = kcontrol->private_value;
 
	spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
3132

L
Lucas De Marchi 已提交
3133
	/* check to be sure that the ports are up to date with
3134 3135
	 * switch changes
	 */
3136
	stac_issue_unsol_event(codec, nid);
3137 3138 3139 3140

	return 1;
}

3141 3142 3143 3144
static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_info *uinfo)
{
	int i;
3145
	static const char * const texts[] = {
3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175
		"Mic In", "Line In", "Line Out"
	};

	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	hda_nid_t nid = kcontrol->private_value;

	if (nid == spec->mic_switch || nid == spec->line_switch)
		i = 3;
	else
		i = 2;

	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->value.enumerated.items = i;
	uinfo->count = 1;
	if (uinfo->value.enumerated.item >= i)
		uinfo->value.enumerated.item = i-1;
	strcpy(uinfo->value.enumerated.name,
		texts[uinfo->value.enumerated.item]);

	return 0;
}

static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	hda_nid_t nid = kcontrol->private_value;
	unsigned int vref = stac92xx_vref_get(codec, nid);

3176
	if (vref == snd_hda_get_default_vref(codec, nid))
3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190
		ucontrol->value.enumerated.item[0] = 0;
	else if (vref == AC_PINCTL_VREF_GRD)
		ucontrol->value.enumerated.item[0] = 1;
	else if (vref == AC_PINCTL_VREF_HIZ)
		ucontrol->value.enumerated.item[0] = 2;

	return 0;
}

static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	unsigned int new_vref = 0;
3191
	int error;
3192 3193 3194
	hda_nid_t nid = kcontrol->private_value;

	if (ucontrol->value.enumerated.item[0] == 0)
3195
		new_vref = snd_hda_get_default_vref(codec, nid);
3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213
	else if (ucontrol->value.enumerated.item[0] == 1)
		new_vref = AC_PINCTL_VREF_GRD;
	else if (ucontrol->value.enumerated.item[0] == 2)
		new_vref = AC_PINCTL_VREF_HIZ;
	else
		return 0;

	if (new_vref != stac92xx_vref_get(codec, nid)) {
		error = stac92xx_vref_set(codec, nid, new_vref);
		return error;
	}

	return 0;
}

static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
				struct snd_ctl_elem_info *uinfo)
{
3214
	char *texts[2];
3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;

	if (kcontrol->private_value == spec->line_switch)
		texts[0] = "Line In";
	else
		texts[0] = "Mic In";
	texts[1] = "Line Out";
	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
	uinfo->value.enumerated.items = 2;
	uinfo->count = 1;

	if (uinfo->value.enumerated.item >= 2)
		uinfo->value.enumerated.item = 1;
	strcpy(uinfo->value.enumerated.name,
		texts[uinfo->value.enumerated.item]);

	return 0;
}
3234 3235 3236 3237 3238

static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
3239 3240
	hda_nid_t nid = kcontrol->private_value;
	int io_idx = (nid == spec->mic_switch) ? 1 : 0;
3241

3242
	ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
3243 3244 3245 3246 3247 3248 3249
	return 0;
}

static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
3250 3251 3252
	hda_nid_t nid = kcontrol->private_value;
	int io_idx = (nid == spec->mic_switch) ? 1 : 0;
	unsigned short val = !!ucontrol->value.enumerated.item[0];
3253 3254 3255 3256 3257

	spec->io_switch[io_idx] = val;

	if (val)
		stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3258 3259 3260
	else {
		unsigned int pinctl = AC_PINCTL_IN_EN;
		if (io_idx) /* set VREF for mic */
3261
			pinctl |= snd_hda_get_default_vref(codec, nid);
3262 3263
		stac92xx_auto_set_pinctl(codec, nid, pinctl);
	}
3264 3265 3266 3267 3268

	/* check the auto-mute again: we need to mute/unmute the speaker
	 * appropriately according to the pin direction
	 */
	if (spec->hp_detect)
3269
		stac_issue_unsol_event(codec, nid);
3270

3271 3272 3273
        return 1;
}

3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291
#define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info

static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;

	ucontrol->value.integer.value[0] = spec->clfe_swap;
	return 0;
}

static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
		struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	hda_nid_t nid = kcontrol->private_value & 0xff;
3292
	unsigned int val = !!ucontrol->value.integer.value[0];
3293

3294
	if (spec->clfe_swap == val)
3295 3296
		return 0;

3297
	spec->clfe_swap = val;
3298 3299 3300 3301 3302 3303 3304

	snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
		spec->clfe_swap ? 0x4 : 0x0);

	return 1;
}

3305 3306 3307 3308 3309 3310 3311 3312 3313
#define STAC_CODEC_HP_SWITCH(xname) \
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
	  .name = xname, \
	  .index = 0, \
	  .info = stac92xx_hp_switch_info, \
	  .get = stac92xx_hp_switch_get, \
	  .put = stac92xx_hp_switch_put, \
	}

3314 3315 3316 3317 3318 3319 3320 3321 3322 3323
#define STAC_CODEC_IO_SWITCH(xname, xpval) \
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
	  .name = xname, \
	  .index = 0, \
          .info = stac92xx_io_switch_info, \
          .get = stac92xx_io_switch_get, \
          .put = stac92xx_io_switch_put, \
          .private_value = xpval, \
	}

3324 3325 3326 3327 3328 3329 3330 3331 3332
#define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
	  .name = xname, \
	  .index = 0, \
	  .info = stac92xx_clfe_switch_info, \
	  .get = stac92xx_clfe_switch_get, \
	  .put = stac92xx_clfe_switch_put, \
	  .private_value = xpval, \
	}
3333

3334 3335 3336
enum {
	STAC_CTL_WIDGET_VOL,
	STAC_CTL_WIDGET_MUTE,
3337
	STAC_CTL_WIDGET_MUTE_BEEP,
3338
	STAC_CTL_WIDGET_MONO_MUX,
3339
	STAC_CTL_WIDGET_HP_SWITCH,
3340
	STAC_CTL_WIDGET_IO_SWITCH,
3341 3342
	STAC_CTL_WIDGET_CLFE_SWITCH,
	STAC_CTL_WIDGET_DC_BIAS
3343 3344
};

3345
static const struct snd_kcontrol_new stac92xx_control_templates[] = {
3346 3347
	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
	HDA_CODEC_MUTE(NULL, 0, 0, 0),
3348
	HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
3349
	STAC_MONO_MUX,
3350
	STAC_CODEC_HP_SWITCH(NULL),
3351
	STAC_CODEC_IO_SWITCH(NULL, 0),
3352
	STAC_CODEC_CLFE_SWITCH(NULL, 0),
3353
	DC_BIAS(NULL, 0, 0),
3354 3355 3356
};

/* add dynamic controls */
3357 3358
static struct snd_kcontrol_new *
stac_control_new(struct sigmatel_spec *spec,
3359
		 const struct snd_kcontrol_new *ktemp,
3360
		 const char *name,
3361
		 unsigned int subdev)
3362
{
3363
	struct snd_kcontrol_new *knew;
3364

3365 3366
	knew = snd_array_new(&spec->kctls);
	if (!knew)
3367
		return NULL;
3368
	*knew = *ktemp;
T
Takashi Iwai 已提交
3369
	knew->name = kstrdup(name, GFP_KERNEL);
3370 3371 3372 3373 3374 3375
	if (!knew->name) {
		/* roolback */
		memset(knew, 0, sizeof(*knew));
		spec->kctls.alloced--;
		return NULL;
	}
3376
	knew->subdevice = subdev;
3377 3378 3379
	return knew;
}

3380 3381 3382 3383 3384
static struct snd_kcontrol_new *
add_control_temp(struct sigmatel_spec *spec,
		 const struct snd_kcontrol_new *ktemp,
		 int idx, const char *name,
		 unsigned long val)
3385
{
3386
	struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
3387
							 HDA_SUBDEV_AMP_FLAG);
3388
	if (!knew)
3389
		return NULL;
3390
	knew->index = idx;
3391
	knew->private_value = val;
3392 3393 3394 3395 3396 3397 3398 3399 3400
	return knew;
}

static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
				     const struct snd_kcontrol_new *ktemp,
				     int idx, const char *name,
				     unsigned long val)
{
	return add_control_temp(spec, ktemp, idx, name, val) ? 0 : -ENOMEM;
3401 3402
}

3403 3404 3405 3406 3407 3408 3409 3410 3411
static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
					   int type, int idx, const char *name,
					   unsigned long val)
{
	return stac92xx_add_control_temp(spec,
					 &stac92xx_control_templates[type],
					 idx, name, val);
}

3412 3413

/* add dynamic controls */
3414 3415
static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
				       const char *name, unsigned long val)
3416 3417 3418 3419
{
	return stac92xx_add_control_idx(spec, type, 0, name, val);
}

3420
static const struct snd_kcontrol_new stac_input_src_temp = {
3421 3422 3423 3424 3425 3426 3427
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Input Source",
	.info = stac92xx_mux_enum_info,
	.get = stac92xx_mux_enum_get,
	.put = stac92xx_mux_enum_put,
};

3428 3429 3430 3431 3432 3433 3434 3435
static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
						hda_nid_t nid, int idx)
{
	int def_conf = snd_hda_codec_get_pincfg(codec, nid);
	int control = 0;
	struct sigmatel_spec *spec = codec->spec;
	char name[22];

3436
	if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
3437 3438 3439
		if (spec->headset_jack && snd_hda_get_input_pin_attr(def_conf)
			!= INPUT_PIN_ATTR_DOCK)
			return 0;
3440
		if (snd_hda_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
3441 3442 3443 3444 3445 3446 3447 3448 3449 3450
			&& nid == spec->line_switch)
			control = STAC_CTL_WIDGET_IO_SWITCH;
		else if (snd_hda_query_pin_caps(codec, nid)
			& (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
			control = STAC_CTL_WIDGET_DC_BIAS;
		else if (nid == spec->mic_switch)
			control = STAC_CTL_WIDGET_IO_SWITCH;
	}

	if (control) {
3451 3452
		snd_hda_get_pin_label(codec, nid, &spec->autocfg,
				      name, sizeof(name), NULL);
3453 3454 3455 3456 3457 3458 3459
		return stac92xx_add_control(codec->spec, control,
					strcat(name, " Jack Mode"), nid);
	}

	return 0;
}

3460 3461 3462 3463 3464
static int stac92xx_add_input_source(struct sigmatel_spec *spec)
{
	struct snd_kcontrol_new *knew;
	struct hda_input_mux *imux = &spec->private_imux;

3465 3466
	if (spec->auto_mic)
		return 0; /* no need for input source */
3467 3468 3469
	if (!spec->num_adcs || imux->num_items <= 1)
		return 0; /* no need for input source control */
	knew = stac_control_new(spec, &stac_input_src_temp,
3470
				stac_input_src_temp.name, 0);
3471 3472 3473 3474 3475 3476
	if (!knew)
		return -ENOMEM;
	knew->count = spec->num_adcs;
	return 0;
}

3477 3478
/* check whether the line-input can be used as line-out */
static hda_nid_t check_line_out_switch(struct hda_codec *codec)
3479 3480
{
	struct sigmatel_spec *spec = codec->spec;
3481 3482 3483
	struct auto_pin_cfg *cfg = &spec->autocfg;
	hda_nid_t nid;
	unsigned int pincap;
3484
	int i;
3485

3486 3487
	if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
		return 0;
3488
	for (i = 0; i < cfg->num_inputs; i++) {
3489
		if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) {
3490 3491 3492 3493 3494 3495
			nid = cfg->inputs[i].pin;
			pincap = snd_hda_query_pin_caps(codec, nid);
			if (pincap & AC_PINCAP_OUT)
				return nid;
		}
	}
3496 3497
	return 0;
}
3498

3499 3500
static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid);

3501
/* check whether the mic-input can be used as line-out */
3502
static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac)
3503 3504 3505 3506
{
	struct sigmatel_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	unsigned int def_conf, pincap;
3507
	int i;
3508

3509
	*dac = 0;
3510 3511
	if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
		return 0;
3512 3513
	for (i = 0; i < cfg->num_inputs; i++) {
		hda_nid_t nid = cfg->inputs[i].pin;
3514
		if (cfg->inputs[i].type != AUTO_PIN_MIC)
3515
			continue;
3516
		def_conf = snd_hda_codec_get_pincfg(codec, nid);
3517 3518
		/* some laptops have an internal analog microphone
		 * which can't be used as a output */
3519
		if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
T
Takashi Iwai 已提交
3520
			pincap = snd_hda_query_pin_caps(codec, nid);
3521 3522 3523 3524 3525
			if (pincap & AC_PINCAP_OUT) {
				*dac = get_unassigned_dac(codec, nid);
				if (*dac)
					return nid;
			}
3526 3527 3528 3529 3530
		}
	}
	return 0;
}

3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542
static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
{
	int i;
	
	for (i = 0; i < spec->multiout.num_dacs; i++) {
		if (spec->multiout.dac_nids[i] == nid)
			return 1;
	}

	return 0;
}

3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559
static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
{
	int i;
	if (is_in_dac_nids(spec, nid))
		return 1;
	for (i = 0; i < spec->autocfg.hp_outs; i++)
		if (spec->hp_dacs[i] == nid)
			return 1;
	for (i = 0; i < spec->autocfg.speaker_outs; i++)
		if (spec->speaker_dacs[i] == nid)
			return 1;
	return 0;
}

static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
{
	struct sigmatel_spec *spec = codec->spec;
3560
	struct auto_pin_cfg *cfg = &spec->autocfg;
3561
	int j, conn_len;
3562
	hda_nid_t conn[HDA_MAX_CONNECTIONS], fallback_dac;
3563 3564 3565 3566
	unsigned int wcaps, wtype;

	conn_len = snd_hda_get_connections(codec, nid, conn,
					   HDA_MAX_CONNECTIONS);
3567 3568 3569 3570 3571 3572 3573
	/* 92HD88: trace back up the link of nids to find the DAC */
	while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
					!= AC_WID_AUD_OUT)) {
		nid = conn[0];
		conn_len = snd_hda_get_connections(codec, nid, conn,
			HDA_MAX_CONNECTIONS);
	}
3574
	for (j = 0; j < conn_len; j++) {
3575
		wcaps = get_wcaps(codec, conn[j]);
3576
		wtype = get_wcaps_type(wcaps);
3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589
		/* we check only analog outputs */
		if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
			continue;
		/* if this route has a free DAC, assign it */
		if (!check_all_dac_nids(spec, conn[j])) {
			if (conn_len > 1) {
				/* select this DAC in the pin's input mux */
				snd_hda_codec_write_cache(codec, nid, 0,
						  AC_VERB_SET_CONNECT_SEL, j);
			}
			return conn[j];
		}
	}
3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601

	/* if all DACs are already assigned, connect to the primary DAC,
	   unless we're assigning a secondary headphone */
	fallback_dac = spec->multiout.dac_nids[0];
	if (spec->multiout.hp_nid) {
		for (j = 0; j < cfg->hp_outs; j++)
			if (cfg->hp_pins[j] == nid) {
				fallback_dac = spec->multiout.hp_nid;
				break;
			}
	}

3602 3603
	if (conn_len > 1) {
		for (j = 0; j < conn_len; j++) {
3604
			if (conn[j] == fallback_dac) {
3605 3606 3607 3608 3609 3610
				snd_hda_codec_write_cache(codec, nid, 0,
						  AC_VERB_SET_CONNECT_SEL, j);
				break;
			}
		}
	}
3611 3612 3613 3614 3615 3616
	return 0;
}

static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);

3617
/*
3618 3619 3620 3621 3622
 * Fill in the dac_nids table from the parsed pin configuration
 * This function only works when every pin in line_out_pins[]
 * contains atleast one DAC in its connection list. Some 92xx
 * codecs are not connected directly to a DAC, such as the 9200
 * and 9202/925x. For those, dac_nids[] must be hard-coded.
3623
 */
3624
static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
3625 3626
{
	struct sigmatel_spec *spec = codec->spec;
3627 3628 3629
	struct auto_pin_cfg *cfg = &spec->autocfg;
	int i;
	hda_nid_t nid, dac;
3630
	
3631 3632
	for (i = 0; i < cfg->line_outs; i++) {
		nid = cfg->line_out_pins[i];
3633 3634
		dac = get_unassigned_dac(codec, nid);
		if (!dac) {
3635 3636 3637 3638 3639 3640 3641
			if (spec->multiout.num_dacs > 0) {
				/* we have already working output pins,
				 * so let's drop the broken ones again
				 */
				cfg->line_outs = spec->multiout.num_dacs;
				break;
			}
3642 3643 3644 3645 3646 3647
			/* error out, no available DAC found */
			snd_printk(KERN_ERR
				   "%s: No available DAC for pin 0x%x\n",
				   __func__, nid);
			return -ENODEV;
		}
3648 3649
		add_spec_dacs(spec, dac);
	}
3650

3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670
	for (i = 0; i < cfg->hp_outs; i++) {
		nid = cfg->hp_pins[i];
		dac = get_unassigned_dac(codec, nid);
		if (dac) {
			if (!spec->multiout.hp_nid)
				spec->multiout.hp_nid = dac;
			else
				add_spec_extra_dacs(spec, dac);
		}
		spec->hp_dacs[i] = dac;
	}

	for (i = 0; i < cfg->speaker_outs; i++) {
		nid = cfg->speaker_pins[i];
		dac = get_unassigned_dac(codec, nid);
		if (dac)
			add_spec_extra_dacs(spec, dac);
		spec->speaker_dacs[i] = dac;
	}

3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684
	/* add line-in as output */
	nid = check_line_out_switch(codec);
	if (nid) {
		dac = get_unassigned_dac(codec, nid);
		if (dac) {
			snd_printdd("STAC: Add line-in 0x%x as output %d\n",
				    nid, cfg->line_outs);
			cfg->line_out_pins[cfg->line_outs] = nid;
			cfg->line_outs++;
			spec->line_switch = nid;
			add_spec_dacs(spec, dac);
		}
	}
	/* add mic as output */
3685 3686 3687 3688 3689 3690 3691 3692
	nid = check_mic_out_switch(codec, &dac);
	if (nid && dac) {
		snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
			    nid, cfg->line_outs);
		cfg->line_out_pins[cfg->line_outs] = nid;
		cfg->line_outs++;
		spec->mic_switch = nid;
		add_spec_dacs(spec, dac);
3693
	}
3694

3695
	snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3696 3697 3698 3699 3700 3701
		   spec->multiout.num_dacs,
		   spec->multiout.dac_nids[0],
		   spec->multiout.dac_nids[1],
		   spec->multiout.dac_nids[2],
		   spec->multiout.dac_nids[3],
		   spec->multiout.dac_nids[4]);
3702

3703 3704 3705
	return 0;
}

3706
/* create volume control/switch for the given prefx type */
3707 3708
static int create_controls_idx(struct hda_codec *codec, const char *pfx,
			       int idx, hda_nid_t nid, int chs)
3709
{
3710
	struct sigmatel_spec *spec = codec->spec;
3711 3712 3713
	char name[32];
	int err;

3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730
	if (!spec->check_volume_offset) {
		unsigned int caps, step, nums, db_scale;
		caps = query_amp_caps(codec, nid, HDA_OUTPUT);
		step = (caps & AC_AMPCAP_STEP_SIZE) >>
			AC_AMPCAP_STEP_SIZE_SHIFT;
		step = (step + 1) * 25; /* in .01dB unit */
		nums = (caps & AC_AMPCAP_NUM_STEPS) >>
			AC_AMPCAP_NUM_STEPS_SHIFT;
		db_scale = nums * step;
		/* if dB scale is over -64dB, and finer enough,
		 * let's reduce it to half
		 */
		if (db_scale > 6400 && nums >= 0x1f)
			spec->volume_offset = nums / 2;
		spec->check_volume_offset = 1;
	}

3731
	sprintf(name, "%s Playback Volume", pfx);
3732
	err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3733 3734
		HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
					spec->volume_offset));
3735 3736 3737
	if (err < 0)
		return err;
	sprintf(name, "%s Playback Switch", pfx);
3738
	err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3739 3740 3741 3742 3743 3744
				   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
	if (err < 0)
		return err;
	return 0;
}

3745 3746 3747
#define create_controls(codec, pfx, nid, chs) \
	create_controls_idx(codec, pfx, 0, nid, chs)

M
Matthew Ranostay 已提交
3748 3749
static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
{
3750
	if (spec->multiout.num_dacs > 4) {
M
Matthew Ranostay 已提交
3751 3752 3753
		printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
		return 1;
	} else {
3754 3755
		snd_BUG_ON(spec->multiout.dac_nids != spec->dac_nids);
		spec->dac_nids[spec->multiout.num_dacs] = nid;
M
Matthew Ranostay 已提交
3756 3757 3758 3759 3760
		spec->multiout.num_dacs++;
	}
	return 0;
}

3761
static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
M
Matthew Ranostay 已提交
3762
{
3763 3764 3765 3766 3767 3768 3769 3770 3771
	int i;
	for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
		if (!spec->multiout.extra_out_nid[i]) {
			spec->multiout.extra_out_nid[i] = nid;
			return 0;
		}
	}
	printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
	return 1;
M
Matthew Ranostay 已提交
3772 3773
}

3774 3775 3776 3777 3778 3779 3780
/* Create output controls
 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
 */
static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
				 const hda_nid_t *pins,
				 const hda_nid_t *dac_nids,
				 int type)
3781
{
3782
	struct sigmatel_spec *spec = codec->spec;
3783
	static const char * const chname[4] = {
3784 3785
		"Front", "Surround", NULL /*CLFE*/, "Side"
	};
3786
	hda_nid_t nid;
3787 3788
	int i, err;
	unsigned int wid_caps;
3789

3790
	for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3791
		if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3792
			if (is_jack_detectable(codec, pins[i]))
3793 3794
				spec->hp_detect = 1;
		}
3795 3796 3797 3798
		nid = dac_nids[i];
		if (!nid)
			continue;
		if (type != AUTO_PIN_HP_OUT && i == 2) {
3799
			/* Center/LFE */
3800
			err = create_controls(codec, "Center", nid, 1);
3801
			if (err < 0)
3802
				return err;
3803
			err = create_controls(codec, "LFE", nid, 2);
3804
			if (err < 0)
3805
				return err;
3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817

			wid_caps = get_wcaps(codec, nid);

			if (wid_caps & AC_WCAP_LR_SWAP) {
				err = stac92xx_add_control(spec,
					STAC_CTL_WIDGET_CLFE_SWITCH,
					"Swap Center/LFE Playback Switch", nid);

				if (err < 0)
					return err;
			}

3818
		} else {
3819
			const char *name;
3820
			int idx;
3821 3822
			switch (type) {
			case AUTO_PIN_HP_OUT:
3823 3824
				name = "Headphone";
				idx = i;
3825 3826
				break;
			case AUTO_PIN_SPEAKER_OUT:
3827 3828 3829
				if (num_outs <= 2) {
					name = i ? "Bass Speaker" : "Speaker";
					idx = 0;
3830 3831 3832
					break;
				}
				/* Fall through in case of multi speaker outs */
3833 3834
			default:
				name = chname[i];
3835
				idx = 0;
3836
				break;
3837
			}
3838
			err = create_controls_idx(codec, name, idx, nid, 3);
3839
			if (err < 0)
3840 3841 3842
				return err;
		}
	}
3843 3844 3845
	return 0;
}

3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874
static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
			  unsigned int dir_mask, unsigned int data);

/* hook for controlling mic-mute LED GPIO */
static int stac92xx_capture_sw_put_led(struct snd_kcontrol *kcontrol,
				       struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	int err;
	bool mute;

	err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol);
	if (err <= 0)
		return err;
	mute = !(ucontrol->value.integer.value[0] &&
		 ucontrol->value.integer.value[1]);
	if (spec->mic_mute_led_on != mute) {
		spec->mic_mute_led_on = mute;
		if (mute)
			spec->gpio_data |= spec->mic_mute_led_gpio;
		else
			spec->gpio_data &= ~spec->mic_mute_led_gpio;
		stac_gpio_set(codec, spec->gpio_mask,
			      spec->gpio_dir, spec->gpio_data);
	}
	return err;
}

3875 3876 3877
static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
				    unsigned long sw, int idx)
{
3878 3879
	struct sigmatel_spec *spec = codec->spec;
	struct snd_kcontrol_new *knew;
3880
	int err;
3881

3882
	err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3883
				       "Capture Volume", vol);
3884 3885
	if (err < 0)
		return err;
3886 3887 3888 3889 3890 3891 3892 3893 3894 3895

	knew = add_control_temp(spec,
				&stac92xx_control_templates[STAC_CTL_WIDGET_MUTE],
				idx, "Capture Switch", sw);
	if (!knew)
		return -ENOMEM;
	/* add a LED hook for some HP laptops */
	if (spec->mic_mute_led_gpio)
		knew->put = stac92xx_capture_sw_put_led;

3896 3897 3898
	return 0;
}

3899 3900 3901 3902 3903
/* add playback controls from the parsed DAC table */
static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
					       const struct auto_pin_cfg *cfg)
{
	struct sigmatel_spec *spec = codec->spec;
3904
	hda_nid_t nid;
3905
	int err;
3906
	int idx;
3907 3908 3909 3910 3911 3912

	err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
				    spec->multiout.dac_nids,
				    cfg->line_out_type);
	if (err < 0)
		return err;
3913

3914
	if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3915 3916
		err = stac92xx_add_control(spec,
			STAC_CTL_WIDGET_HP_SWITCH,
3917 3918
			"Headphone as Line Out Switch",
			cfg->hp_pins[cfg->hp_outs - 1]);
3919 3920 3921 3922
		if (err < 0)
			return err;
	}

3923
	for (idx = 0; idx < cfg->num_inputs; idx++) {
3924
		if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3925 3926 3927 3928 3929
			break;
		nid = cfg->inputs[idx].pin;
		err = stac92xx_add_jack_mode_control(codec, nid, idx);
		if (err < 0)
			return err;
3930
	}
3931

3932 3933 3934
	return 0;
}

3935 3936 3937 3938 3939
/* add playback controls for Speaker and HP outputs */
static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
					struct auto_pin_cfg *cfg)
{
	struct sigmatel_spec *spec = codec->spec;
3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950
	int err;

	err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
				    spec->hp_dacs, AUTO_PIN_HP_OUT);
	if (err < 0)
		return err;

	err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
				    spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
	if (err < 0)
		return err;
3951

3952 3953 3954
	return 0;
}

3955
/* labels for mono mux outputs */
3956
static const char * const stac92xx_mono_labels[4] = {
3957
	"DAC0", "DAC1", "Mixer", "DAC2"
3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971
};

/* create mono mux for mono out on capable codecs */
static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	struct hda_input_mux *mono_mux = &spec->private_mono_mux;
	int i, num_cons;
	hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];

	num_cons = snd_hda_get_connections(codec,
				spec->mono_nid,
				con_lst,
				HDA_MAX_NUM_INPUTS);
3972
	if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3973 3974
		return -EINVAL;

3975 3976 3977
	for (i = 0; i < num_cons; i++)
		snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i,
				      NULL);
3978 3979 3980

	return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
				"Mono Mux", spec->mono_nid);
3981 3982
}

3983 3984 3985 3986 3987 3988
/* create PC beep volume controls */
static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
						hda_nid_t nid)
{
	struct sigmatel_spec *spec = codec->spec;
	u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3989 3990 3991 3992
	int err, type = STAC_CTL_WIDGET_MUTE_BEEP;

	if (spec->anabeep_nid == nid)
		type = STAC_CTL_WIDGET_MUTE;
3993 3994 3995

	/* check for mute support for the the amp */
	if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3996
		err = stac92xx_add_control(spec, type,
3997
			"Beep Playback Switch",
3998 3999 4000 4001 4002 4003 4004 4005
			HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
			if (err < 0)
				return err;
	}

	/* check to see if there is volume support for the amp */
	if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
		err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
4006
			"Beep Playback Volume",
4007 4008 4009 4010 4011 4012 4013
			HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
			if (err < 0)
				return err;
	}
	return 0;
}

4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028
#ifdef CONFIG_SND_HDA_INPUT_BEEP
#define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info

static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
					struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	ucontrol->value.integer.value[0] = codec->beep->enabled;
	return 0;
}

static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
					struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4029
	return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
4030 4031
}

4032
static const struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
4033 4034 4035 4036 4037 4038 4039 4040 4041
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.info = stac92xx_dig_beep_switch_info,
	.get = stac92xx_dig_beep_switch_get,
	.put = stac92xx_dig_beep_switch_put,
};

static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
{
	return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
4042
					 0, "Beep Playback Switch", 0);
4043 4044 4045
}
#endif

4046 4047 4048
static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
4049
	int i, j, err = 0;
4050 4051

	for (i = 0; i < spec->num_muxes; i++) {
4052 4053 4054 4055
		hda_nid_t nid;
		unsigned int wcaps;
		unsigned long val;

4056 4057
		nid = spec->mux_nids[i];
		wcaps = get_wcaps(codec, nid);
4058 4059
		if (!(wcaps & AC_WCAP_OUT_AMP))
			continue;
4060

4061 4062 4063 4064 4065 4066 4067
		/* check whether already the same control was created as
		 * normal Capture Volume.
		 */
		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
		for (j = 0; j < spec->num_caps; j++) {
			if (spec->capvols[j] == val)
				break;
4068
		}
4069 4070 4071 4072 4073 4074 4075
		if (j < spec->num_caps)
			continue;

		err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
					       "Mux Capture Volume", val);
		if (err < 0)
			return err;
4076 4077 4078 4079
	}
	return 0;
};

4080
static const char * const stac92xx_spdif_labels[3] = {
4081
	"Digital Playback", "Analog Mux 1", "Analog Mux 2",
M
Matthew Ranostay 已提交
4082 4083 4084 4085 4086 4087
};

static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	struct hda_input_mux *spdif_mux = &spec->private_smux;
4088
	const char * const *labels = spec->spdif_labels;
M
Matthew Ranostay 已提交
4089
	int i, num_cons;
4090
	hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
M
Matthew Ranostay 已提交
4091 4092 4093 4094 4095

	num_cons = snd_hda_get_connections(codec,
				spec->smux_nids[0],
				con_lst,
				HDA_MAX_NUM_INPUTS);
4096
	if (num_cons <= 0)
M
Matthew Ranostay 已提交
4097 4098
		return -EINVAL;

4099 4100 4101
	if (!labels)
		labels = stac92xx_spdif_labels;

4102 4103
	for (i = 0; i < num_cons; i++)
		snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL);
M
Matthew Ranostay 已提交
4104 4105 4106 4107

	return 0;
}

4108
/* labels for dmic mux inputs */
4109
static const char * const stac92xx_dmic_labels[5] = {
4110 4111 4112 4113
	"Analog Inputs", "Digital Mic 1", "Digital Mic 2",
	"Digital Mic 3", "Digital Mic 4"
};

4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124
static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux,
				    int idx)
{
	hda_nid_t conn[HDA_MAX_NUM_INPUTS];
	int nums;
	nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
	if (idx >= 0 && idx < nums)
		return conn[idx];
	return 0;
}

4125 4126 4127
/* look for NID recursively */
#define get_connection_index(codec, mux, nid) \
	snd_hda_get_conn_index(codec, mux, nid, 1)
4128

4129
/* create a volume assigned to the given pin (only if supported) */
4130
/* return 1 if the volume control is created */
4131
static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
4132
				   const char *label, int idx, int direction)
4133 4134 4135
{
	unsigned int caps, nums;
	char name[32];
4136
	int err;
4137

4138 4139 4140 4141 4142
	if (direction == HDA_OUTPUT)
		caps = AC_WCAP_OUT_AMP;
	else
		caps = AC_WCAP_IN_AMP;
	if (!(get_wcaps(codec, nid) & caps))
4143
		return 0;
4144
	caps = query_amp_caps(codec, nid, direction);
4145 4146 4147 4148
	nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
	if (!nums)
		return 0;
	snprintf(name, sizeof(name), "%s Capture Volume", label);
4149 4150
	err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
				       HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
4151 4152 4153
	if (err < 0)
		return err;
	return 1;
4154 4155
}

4156 4157 4158 4159 4160
/* create playback/capture controls for input pins on dmic capable codecs */
static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
						const struct auto_pin_cfg *cfg)
{
	struct sigmatel_spec *spec = codec->spec;
4161
	struct hda_input_mux *imux = &spec->private_imux;
4162
	struct hda_input_mux *dimux = &spec->private_dimux;
4163
	int err, i;
4164
	unsigned int def_conf;
4165

4166
	snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL);
4167

4168
	for (i = 0; i < spec->num_dmics; i++) {
4169
		hda_nid_t nid;
4170
		int index, type_idx;
4171
		char label[32];
4172

4173 4174 4175 4176
		nid = spec->dmic_nids[i];
		if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
			continue;
		def_conf = snd_hda_codec_get_pincfg(codec, nid);
4177 4178 4179
		if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
			continue;

4180 4181 4182 4183
		index = get_connection_index(codec, spec->dmux_nids[0], nid);
		if (index < 0)
			continue;

4184 4185
		snd_hda_get_pin_label(codec, nid, &spec->autocfg,
				      label, sizeof(label), NULL);
4186
		snd_hda_add_imux_item(dimux, label, index, &type_idx);
4187 4188
		if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1)
			snd_hda_add_imux_item(imux, label, index, &type_idx);
4189

4190 4191
		err = create_elem_capture_vol(codec, nid, label, type_idx,
					      HDA_INPUT);
4192 4193
		if (err < 0)
			return err;
4194 4195
		if (!err) {
			err = create_elem_capture_vol(codec, nid, label,
4196
						      type_idx, HDA_OUTPUT);
4197 4198
			if (err < 0)
				return err;
4199 4200 4201 4202 4203 4204 4205 4206 4207 4208
			if (!err) {
				nid = get_connected_node(codec,
						spec->dmux_nids[0], index);
				if (nid)
					err = create_elem_capture_vol(codec,
							nid, label,
							type_idx, HDA_INPUT);
				if (err < 0)
					return err;
			}
4209
		}
4210 4211 4212 4213 4214
	}

	return 0;
}

4215
static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
4216
			 hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock)
4217 4218
{
	unsigned int cfg;
4219
	unsigned int type;
4220 4221 4222 4223

	if (!nid)
		return 0;
	cfg = snd_hda_codec_get_pincfg(codec, nid);
4224
	type = get_defcfg_device(cfg);
4225 4226
	switch (snd_hda_get_input_pin_attr(cfg)) {
	case INPUT_PIN_ATTR_INT:
4227 4228
		if (*fixed)
			return 1; /* already occupied */
4229 4230
		if (type != AC_JACK_MIC_IN)
			return 1; /* invalid type */
4231 4232
		*fixed = nid;
		break;
4233 4234 4235 4236 4237
	case INPUT_PIN_ATTR_UNUSED:
		break;
	case INPUT_PIN_ATTR_DOCK:
		if (*dock)
			return 1; /* already occupied */
4238 4239
		if (type != AC_JACK_MIC_IN && type != AC_JACK_LINE_IN)
			return 1; /* invalid type */
4240 4241 4242
		*dock = nid;
		break;
	default:
4243 4244
		if (*ext)
			return 1; /* already occupied */
4245 4246
		if (type != AC_JACK_MIC_IN)
			return 1; /* invalid type */
4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261
		*ext = nid;
		break;
	}
	return 0;
}

static int set_mic_route(struct hda_codec *codec,
			 struct sigmatel_mic_route *mic,
			 hda_nid_t pin)
{
	struct sigmatel_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	int i;

	mic->pin = pin;
4262 4263
	if (pin == 0)
		return 0;
4264 4265
	for (i = 0; i < cfg->num_inputs; i++) {
		if (pin == cfg->inputs[i].pin)
4266
			break;
4267
	}
4268
	if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) {
4269 4270 4271 4272 4273
		/* analog pin */
		i = get_connection_index(codec, spec->mux_nids[0], pin);
		if (i < 0)
			return -1;
		mic->mux_idx = i;
4274 4275 4276 4277 4278
		mic->dmux_idx = -1;
		if (spec->dmux_nids)
			mic->dmux_idx = get_connection_index(codec,
							     spec->dmux_nids[0],
							     spec->mux_nids[0]);
4279
	}  else if (spec->dmux_nids) {
4280 4281 4282 4283 4284
		/* digital pin */
		i = get_connection_index(codec, spec->dmux_nids[0], pin);
		if (i < 0)
			return -1;
		mic->dmux_idx = i;
4285 4286 4287 4288 4289
		mic->mux_idx = -1;
		if (spec->mux_nids)
			mic->mux_idx = get_connection_index(codec,
							    spec->mux_nids[0],
							    spec->dmux_nids[0]);
4290 4291 4292 4293 4294 4295 4296 4297 4298
	}
	return 0;
}

/* return non-zero if the device is for automatic mic switch */
static int stac_check_auto_mic(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
4299
	hda_nid_t fixed, ext, dock;
4300 4301
	int i;

4302
	fixed = ext = dock = 0;
4303
	for (i = 0; i < cfg->num_inputs; i++)
4304 4305
		if (check_mic_pin(codec, cfg->inputs[i].pin,
		    &fixed, &ext, &dock))
4306 4307
			return 0;
	for (i = 0; i < spec->num_dmics; i++)
4308 4309
		if (check_mic_pin(codec, spec->dmic_nids[i],
		    &fixed, &ext, &dock))
4310
			return 0;
4311
	if (!fixed || (!ext && !dock))
4312
		return 0; /* no input to switch */
4313
	if (!is_jack_detectable(codec, ext))
4314 4315
		return 0; /* no unsol support */
	if (set_mic_route(codec, &spec->ext_mic, ext) ||
4316 4317
	    set_mic_route(codec, &spec->int_mic, fixed) ||
	    set_mic_route(codec, &spec->dock_mic, dock))
4318 4319 4320 4321
		return 0; /* something is wrong */
	return 1;
}

4322 4323 4324 4325 4326
/* create playback/capture controls for input pins */
static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
{
	struct sigmatel_spec *spec = codec->spec;
	struct hda_input_mux *imux = &spec->private_imux;
4327
	int i, j;
4328
	const char *label;
4329

4330 4331
	for (i = 0; i < cfg->num_inputs; i++) {
		hda_nid_t nid = cfg->inputs[i].pin;
4332
		int index, err, type_idx;
4333 4334 4335

		index = -1;
		for (j = 0; j < spec->num_muxes; j++) {
4336 4337 4338 4339
			index = get_connection_index(codec, spec->mux_nids[j],
						     nid);
			if (index >= 0)
				break;
4340
		}
4341 4342 4343
		if (index < 0)
			continue;

4344 4345
		label = hda_get_autocfg_input_label(codec, cfg, i);
		snd_hda_add_imux_item(imux, label, index, &type_idx);
4346

4347
		err = create_elem_capture_vol(codec, nid,
4348
					      label, type_idx,
4349
					      HDA_INPUT);
4350 4351
		if (err < 0)
			return err;
4352
	}
4353
	spec->num_analog_muxes = imux->num_items;
4354

4355
	if (imux->num_items) {
4356 4357 4358 4359 4360 4361
		/*
		 * Set the current input for the muxes.
		 * The STAC9221 has two input muxes with identical source
		 * NID lists.  Hopefully this won't get confused.
		 */
		for (i = 0; i < spec->num_muxes; i++) {
4362 4363 4364
			snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
						  AC_VERB_SET_CONNECT_SEL,
						  imux->items[0].index);
4365 4366 4367
		}
	}

4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384
	return 0;
}

static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	int i;

	for (i = 0; i < spec->autocfg.line_outs; i++) {
		hda_nid_t nid = spec->autocfg.line_out_pins[i];
		stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
	}
}

static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
4385
	int i;
4386

4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398
	for (i = 0; i < spec->autocfg.hp_outs; i++) {
		hda_nid_t pin;
		pin = spec->autocfg.hp_pins[i];
		if (pin) /* connect to front */
			stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
	}
	for (i = 0; i < spec->autocfg.speaker_outs; i++) {
		hda_nid_t pin;
		pin = spec->autocfg.speaker_pins[i];
		if (pin) /* connect to front */
			stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
	}
4399 4400
}

4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420
static int is_dual_headphones(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	int i, valid_hps;

	if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
	    spec->autocfg.hp_outs <= 1)
		return 0;
	valid_hps = 0;
	for (i = 0; i < spec->autocfg.hp_outs; i++) {
		hda_nid_t nid = spec->autocfg.hp_pins[i];
		unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
		if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
			continue;
		valid_hps++;
	}
	return (valid_hps > 1);
}


4421
static int stac92xx_parse_auto_config(struct hda_codec *codec)
4422 4423
{
	struct sigmatel_spec *spec = codec->spec;
4424
	hda_nid_t dig_out = 0, dig_in = 0;
4425
	int hp_swap = 0;
4426
	int i, err;
4427

4428 4429 4430
	if ((err = snd_hda_parse_pin_def_config(codec,
						&spec->autocfg,
						spec->dmic_nids)) < 0)
4431
		return err;
4432
	if (! spec->autocfg.line_outs)
M
Matt Porter 已提交
4433
		return 0; /* can't find valid pin config */
4434

4435 4436 4437
	/* If we have no real line-out pin and multiple hp-outs, HPs should
	 * be set up as multi-channel outputs.
	 */
4438
	if (is_dual_headphones(codec)) {
4439 4440 4441 4442
		/* Copy hp_outs to line_outs, backup line_outs in
		 * speaker_outs so that the following routines can handle
		 * HP pins as primary outputs.
		 */
4443
		snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
4444 4445 4446 4447 4448 4449
		memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
		       sizeof(spec->autocfg.line_out_pins));
		spec->autocfg.speaker_outs = spec->autocfg.line_outs;
		memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
		       sizeof(spec->autocfg.hp_pins));
		spec->autocfg.line_outs = spec->autocfg.hp_outs;
4450 4451
		spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
		spec->autocfg.hp_outs = 0;
4452
		hp_swap = 1;
4453
	}
4454
	if (spec->autocfg.mono_out_pin) {
4455 4456
		int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
			(AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
4457 4458 4459 4460 4461 4462 4463 4464
		u32 caps = query_amp_caps(codec,
				spec->autocfg.mono_out_pin, dir);
		hda_nid_t conn_list[1];

		/* get the mixer node and then the mono mux if it exists */
		if (snd_hda_get_connections(codec,
				spec->autocfg.mono_out_pin, conn_list, 1) &&
				snd_hda_get_connections(codec, conn_list[0],
4465
				conn_list, 1) > 0) {
4466 4467

				int wcaps = get_wcaps(codec, conn_list[0]);
4468
				int wid_type = get_wcaps_type(wcaps);
4469 4470 4471 4472 4473 4474 4475 4476
				/* LR swap check, some stac925x have a mux that
 				 * changes the DACs output path instead of the
 				 * mono-mux path.
 				 */
				if (wid_type == AC_WID_AUD_SEL &&
						!(wcaps & AC_WCAP_LR_SWAP))
					spec->mono_nid = conn_list[0];
		}
4477 4478 4479 4480 4481 4482 4483 4484
		if (dir) {
			hda_nid_t nid = spec->autocfg.mono_out_pin;

			/* most mono outs have a least a mute/unmute switch */
			dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
			err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
				"Mono Playback Switch",
				HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
4485 4486
			if (err < 0)
				return err;
4487 4488 4489 4490 4491 4492 4493 4494 4495 4496
			/* check for volume support for the amp */
			if ((caps & AC_AMPCAP_NUM_STEPS)
					>> AC_AMPCAP_NUM_STEPS_SHIFT) {
				err = stac92xx_add_control(spec,
					STAC_CTL_WIDGET_VOL,
					"Mono Playback Volume",
				HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
				if (err < 0)
					return err;
			}
4497 4498 4499 4500 4501
		}

		stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
					 AC_PINCTL_OUT_EN);
	}
4502

4503 4504 4505
	if (!spec->multiout.num_dacs) {
		err = stac92xx_auto_fill_dac_nids(codec);
		if (err < 0)
4506
			return err;
4507 4508 4509 4510
		err = stac92xx_auto_create_multi_out_ctls(codec,
							  &spec->autocfg);
		if (err < 0)
			return err;
4511
	}
4512

4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524
	/* setup analog beep controls */
	if (spec->anabeep_nid > 0) {
		err = stac92xx_auto_create_beep_ctls(codec,
			spec->anabeep_nid);
		if (err < 0)
			return err;
	}

	/* setup digital beep controls and input device */
#ifdef CONFIG_SND_HDA_INPUT_BEEP
	if (spec->digbeep_nid > 0) {
		hda_nid_t nid = spec->digbeep_nid;
4525
		unsigned int caps;
4526 4527 4528 4529 4530 4531 4532

		err = stac92xx_auto_create_beep_ctls(codec, nid);
		if (err < 0)
			return err;
		err = snd_hda_attach_beep_device(codec, nid);
		if (err < 0)
			return err;
4533 4534
		if (codec->beep) {
			/* IDT/STAC codecs have linear beep tone parameter */
4535
			codec->beep->linear_tone = spec->linear_tone_beep;
4536 4537 4538 4539 4540 4541 4542
			/* if no beep switch is available, make its own one */
			caps = query_amp_caps(codec, nid, HDA_OUTPUT);
			if (!(caps & AC_AMPCAP_MUTE)) {
				err = stac92xx_beep_switch_ctl(codec);
				if (err < 0)
					return err;
			}
4543
		}
4544 4545 4546
	}
#endif

4547 4548 4549 4550
	err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
	if (err < 0)
		return err;

4551 4552 4553 4554 4555 4556 4557 4558
	/* All output parsing done, now restore the swapped hp pins */
	if (hp_swap) {
		memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
		       sizeof(spec->autocfg.hp_pins));
		spec->autocfg.hp_outs = spec->autocfg.line_outs;
		spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
		spec->autocfg.line_outs = 0;
	}
4559

4560 4561 4562 4563 4564 4565 4566 4567
	if (stac_check_auto_mic(codec)) {
		spec->auto_mic = 1;
		/* only one capture for auto-mic */
		spec->num_adcs = 1;
		spec->num_caps = 1;
		spec->num_muxes = 1;
	}

4568 4569 4570 4571 4572 4573 4574
	for (i = 0; i < spec->num_caps; i++) {
		err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
					       spec->capsws[i], i);
		if (err < 0)
			return err;
	}

4575
	err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
4576
	if (err < 0)
4577 4578
		return err;

4579 4580 4581 4582 4583
	if (spec->mono_nid > 0) {
		err = stac92xx_auto_create_mono_output_ctls(codec);
		if (err < 0)
			return err;
	}
M
Matthew Ranostay 已提交
4584
	if (spec->num_dmics > 0 && !spec->dinput_mux)
4585 4586 4587
		if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
						&spec->autocfg)) < 0)
			return err;
4588 4589 4590 4591 4592
	if (spec->num_muxes > 0) {
		err = stac92xx_auto_create_mux_input_ctls(codec);
		if (err < 0)
			return err;
	}
M
Matthew Ranostay 已提交
4593 4594 4595 4596 4597
	if (spec->num_smuxes > 0) {
		err = stac92xx_auto_create_spdif_mux_ctls(codec);
		if (err < 0)
			return err;
	}
4598

4599 4600 4601 4602
	err = stac92xx_add_input_source(spec);
	if (err < 0)
		return err;

4603
	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4604
	if (spec->multiout.max_channels > 2)
4605 4606
		spec->surr_switch = 1;

4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622
	/* find digital out and in converters */
	for (i = codec->start_nid; i < codec->start_nid + codec->num_nodes; i++) {
		unsigned int wid_caps = get_wcaps(codec, i);
		if (wid_caps & AC_WCAP_DIGITAL) {
			switch (get_wcaps_type(wid_caps)) {
			case AC_WID_AUD_OUT:
				if (!dig_out)
					dig_out = i;
				break;
			case AC_WID_AUD_IN:
				if (!dig_in)
					dig_in = i;
				break;
			}
		}
	}
4623
	if (spec->autocfg.dig_outs)
4624
		spec->multiout.dig_out_nid = dig_out;
4625
	if (dig_in && spec->autocfg.dig_in_pin)
4626
		spec->dig_in_nid = dig_in;
4627

4628 4629
	if (spec->kctls.list)
		spec->mixers[spec->num_mixers++] = spec->kctls.list;
4630 4631

	spec->input_mux = &spec->private_imux;
M
Matthew Ranostay 已提交
4632 4633
	if (!spec->dinput_mux)
		spec->dinput_mux = &spec->private_dimux;
M
Matthew Ranostay 已提交
4634
	spec->sinput_mux = &spec->private_smux;
4635
	spec->mono_mux = &spec->private_mono_mux;
4636 4637 4638
	return 1;
}

4639 4640 4641 4642 4643
/* add playback controls for HP output */
static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
					struct auto_pin_cfg *cfg)
{
	struct sigmatel_spec *spec = codec->spec;
4644
	hda_nid_t pin = cfg->hp_pins[0];
4645 4646 4647 4648

	if (! pin)
		return 0;

4649
	if (is_jack_detectable(codec, pin))
4650 4651 4652 4653 4654
		spec->hp_detect = 1;

	return 0;
}

4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670
/* add playback controls for LFE output */
static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
					struct auto_pin_cfg *cfg)
{
	struct sigmatel_spec *spec = codec->spec;
	int err;
	hda_nid_t lfe_pin = 0x0;
	int i;

	/*
	 * search speaker outs and line outs for a mono speaker pin
	 * with an amp.  If one is found, add LFE controls
	 * for it.
	 */
	for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
		hda_nid_t pin = spec->autocfg.speaker_pins[i];
4671
		unsigned int wcaps = get_wcaps(codec, pin);
4672 4673 4674 4675 4676 4677 4678 4679 4680 4681
		wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
		if (wcaps == AC_WCAP_OUT_AMP)
			/* found a mono speaker with an amp, must be lfe */
			lfe_pin = pin;
	}

	/* if speaker_outs is 0, then speakers may be in line_outs */
	if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
		for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
			hda_nid_t pin = spec->autocfg.line_out_pins[i];
4682
			unsigned int defcfg;
4683
			defcfg = snd_hda_codec_get_pincfg(codec, pin);
4684
			if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
4685
				unsigned int wcaps = get_wcaps(codec, pin);
4686 4687 4688 4689 4690 4691 4692 4693 4694 4695
				wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
				if (wcaps == AC_WCAP_OUT_AMP)
					/* found a mono speaker with an amp,
					   must be lfe */
					lfe_pin = pin;
			}
		}
	}

	if (lfe_pin) {
4696
		err = create_controls(codec, "LFE", lfe_pin, 1);
4697 4698 4699 4700 4701 4702 4703
		if (err < 0)
			return err;
	}

	return 0;
}

4704 4705 4706 4707 4708
static int stac9200_parse_auto_config(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	int err;

4709
	if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
4710 4711 4712 4713 4714
		return err;

	if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
		return err;

4715 4716 4717
	if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
		return err;

4718 4719 4720
	if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
		return err;

4721 4722 4723 4724 4725 4726
	if (spec->num_muxes > 0) {
		err = stac92xx_auto_create_mux_input_ctls(codec);
		if (err < 0)
			return err;
	}

4727 4728 4729 4730
	err = stac92xx_add_input_source(spec);
	if (err < 0)
		return err;

4731
	if (spec->autocfg.dig_outs)
4732
		spec->multiout.dig_out_nid = 0x05;
4733
	if (spec->autocfg.dig_in_pin)
4734 4735
		spec->dig_in_nid = 0x04;

4736 4737
	if (spec->kctls.list)
		spec->mixers[spec->num_mixers++] = spec->kctls.list;
4738 4739

	spec->input_mux = &spec->private_imux;
4740
	spec->dinput_mux = &spec->private_dimux;
4741 4742 4743 4744

	return 1;
}

4745 4746 4747 4748 4749
/*
 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
 * funky external mute control using GPIO pins.
 */

4750
static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4751
			  unsigned int dir_mask, unsigned int data)
4752 4753 4754
{
	unsigned int gpiostate, gpiomask, gpiodir;

4755 4756
	snd_printdd("%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data);

4757 4758
	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
				       AC_VERB_GET_GPIO_DATA, 0);
4759
	gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4760 4761 4762

	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
				      AC_VERB_GET_GPIO_MASK, 0);
4763
	gpiomask |= mask;
4764 4765 4766

	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
				     AC_VERB_GET_GPIO_DIRECTION, 0);
4767
	gpiodir |= dir_mask;
4768

4769
	/* Configure GPIOx as CMOS */
4770 4771 4772 4773
	snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);

	snd_hda_codec_write(codec, codec->afg, 0,
			    AC_VERB_SET_GPIO_MASK, gpiomask);
4774 4775
	snd_hda_codec_read(codec, codec->afg, 0,
			   AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
4776 4777 4778

	msleep(1);

4779 4780
	snd_hda_codec_read(codec, codec->afg, 0,
			   AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
4781 4782
}

4783
static int stac_add_event(struct hda_codec *codec, hda_nid_t nid,
4784
			  unsigned char type, int data)
4785
{
4786
	struct hda_jack_tbl *event;
4787

4788
	event = snd_hda_jack_tbl_new(codec, nid);
4789 4790
	if (!event)
		return -ENOMEM;
4791 4792
	event->action = type;
	event->private_data = data;
4793

4794
	return 0;
4795 4796
}

4797 4798 4799
static void handle_unsol_event(struct hda_codec *codec,
			       struct hda_jack_tbl *event);

4800 4801 4802 4803 4804 4805
/* check if given nid is a valid pin and no other events are assigned
 * to it.  If OK, assign the event, set the unsol flag, and returns 1.
 * Otherwise, returns zero.
 */
static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
			     unsigned int type)
4806
{
4807
	struct hda_jack_tbl *event;
4808

4809
	if (!is_jack_detectable(codec, nid))
4810
		return 0;
4811 4812 4813 4814 4815 4816
	event = snd_hda_jack_tbl_new(codec, nid);
	if (!event)
		return -ENOMEM;
	if (event->action && event->action != type)
		return 0;
	event->action = type;
4817
	event->callback = handle_unsol_event;
4818
	snd_hda_jack_detect_enable(codec, nid, 0);
4819
	return 1;
4820 4821
}

4822
static int is_nid_out_jack_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4823 4824 4825 4826 4827
{
	int i;
	for (i = 0; i < cfg->hp_outs; i++)
		if (cfg->hp_pins[i] == nid)
			return 1; /* nid is a HP-Out */
4828 4829 4830
	for (i = 0; i < cfg->line_outs; i++)
		if (cfg->line_out_pins[i] == nid)
			return 1; /* nid is a line-Out */
4831 4832 4833
	return 0; /* nid is not a HP-Out */
};

4834 4835 4836 4837 4838
static void stac92xx_power_down(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;

	/* power down inactive DACs */
4839
	const hda_nid_t *dac;
4840
	for (dac = spec->dac_list; *dac; dac++)
4841
		if (!check_all_dac_nids(spec, *dac))
4842
			snd_hda_codec_write(codec, *dac, 0,
4843 4844 4845
					AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
}

4846 4847 4848
static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
				  int enable);

4849 4850
static inline bool get_int_hint(struct hda_codec *codec, const char *key,
				int *valp)
T
Takashi Iwai 已提交
4851
{
4852
	return !snd_hda_get_int_hint(codec, key, valp);
T
Takashi Iwai 已提交
4853 4854
}

4855 4856 4857 4858 4859 4860 4861 4862 4863
/* override some hints from the hwdep entry */
static void stac_store_hints(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	int val;

	val = snd_hda_get_bool_hint(codec, "hp_detect");
	if (val >= 0)
		spec->hp_detect = val;
T
Takashi Iwai 已提交
4864
	if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4865 4866 4867
		spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
			spec->gpio_mask;
	}
T
Takashi Iwai 已提交
4868 4869 4870 4871 4872 4873 4874 4875
	if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
		spec->gpio_mask &= spec->gpio_mask;
	if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
		spec->gpio_dir &= spec->gpio_mask;
	if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
		spec->eapd_mask &= spec->gpio_mask;
	if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
		spec->gpio_mute &= spec->gpio_mask;
4876 4877 4878 4879 4880
	val = snd_hda_get_bool_hint(codec, "eapd_switch");
	if (val >= 0)
		spec->eapd_switch = val;
}

4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901
static void stac_issue_unsol_events(struct hda_codec *codec, int num_pins,
				    const hda_nid_t *pins)
{
	while (num_pins--)
		stac_issue_unsol_event(codec, *pins++);
}

/* fake event to set up pins */
static void stac_fake_hp_events(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;

	if (spec->autocfg.hp_outs)
		stac_issue_unsol_events(codec, spec->autocfg.hp_outs,
					spec->autocfg.hp_pins);
	if (spec->autocfg.line_outs &&
	    spec->autocfg.line_out_pins[0] != spec->autocfg.hp_pins[0])
		stac_issue_unsol_events(codec, spec->autocfg.line_outs,
					spec->autocfg.line_out_pins);
}

4902 4903 4904
static int stac92xx_init(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
4905
	struct auto_pin_cfg *cfg = &spec->autocfg;
4906
	unsigned int gpio;
4907
	int i;
4908

4909 4910
	if (spec->init)
		snd_hda_sequence_write(codec, spec->init);
4911

4912 4913
	snd_hda_apply_verbs(codec);

M
Matthew Ranostay 已提交
4914 4915 4916
	/* power down adcs initially */
	if (spec->powerdown_adcs)
		for (i = 0; i < spec->num_adcs; i++)
4917
			snd_hda_codec_write(codec,
M
Matthew Ranostay 已提交
4918 4919
				spec->adc_nids[i], 0,
				AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4920

4921 4922 4923
	/* override some hints */
	stac_store_hints(codec);

4924 4925 4926 4927 4928 4929 4930 4931 4932
	/* set up GPIO */
	gpio = spec->gpio_data;
	/* turn on EAPD statically when spec->eapd_switch isn't set.
	 * otherwise, unsol event will turn it on/off dynamically
	 */
	if (!spec->eapd_switch)
		gpio |= spec->eapd_mask;
	stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);

4933 4934
	/* set up pins */
	if (spec->hp_detect) {
4935
		/* Enable unsolicited responses on the HP widget */
4936 4937
		for (i = 0; i < cfg->hp_outs; i++) {
			hda_nid_t nid = cfg->hp_pins[i];
4938
			enable_pin_detect(codec, nid, STAC_HP_EVENT);
4939
		}
4940 4941
		if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
		    cfg->speaker_outs > 0) {
4942
			/* enable pin-detect for line-outs as well */
4943 4944
			for (i = 0; i < cfg->line_outs; i++) {
				hda_nid_t nid = cfg->line_out_pins[i];
4945 4946 4947 4948
				enable_pin_detect(codec, nid, STAC_LO_EVENT);
			}
		}

4949 4950 4951 4952
		/* force to enable the first line-out; the others are set up
		 * in unsol_event
		 */
		stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4953
				AC_PINCTL_OUT_EN);
4954
		/* fake event to set up pins */
4955
		stac_fake_hp_events(codec);
4956 4957 4958
	} else {
		stac92xx_auto_init_multi_out(codec);
		stac92xx_auto_init_hp_out(codec);
4959 4960
		for (i = 0; i < cfg->hp_outs; i++)
			stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4961
	}
4962
	if (spec->auto_mic) {
4963
		/* initialize connection to analog input */
4964 4965
		if (spec->dmux_nids)
			snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4966
					  AC_VERB_SET_CONNECT_SEL, 0);
4967 4968
		if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
			stac_issue_unsol_event(codec, spec->ext_mic.pin);
4969 4970 4971
		if (enable_pin_detect(codec, spec->dock_mic.pin,
		    STAC_MIC_EVENT))
			stac_issue_unsol_event(codec, spec->dock_mic.pin);
4972
	}
4973 4974 4975 4976
	for (i = 0; i < cfg->num_inputs; i++) {
		hda_nid_t nid = cfg->inputs[i].pin;
		int type = cfg->inputs[i].type;
		unsigned int pinctl, conf;
4977
		if (type == AUTO_PIN_MIC) {
4978
			/* for mic pins, force to initialize */
4979
			pinctl = snd_hda_get_default_vref(codec, nid);
4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991
			pinctl |= AC_PINCTL_IN_EN;
			stac92xx_auto_set_pinctl(codec, nid, pinctl);
		} else {
			pinctl = snd_hda_codec_read(codec, nid, 0,
					AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
			/* if PINCTL already set then skip */
			/* Also, if both INPUT and OUTPUT are set,
			 * it must be a BIOS bug; need to override, too
			 */
			if (!(pinctl & AC_PINCTL_IN_EN) ||
			    (pinctl & AC_PINCTL_OUT_EN)) {
				pinctl &= ~AC_PINCTL_OUT_EN;
4992 4993
				pinctl |= AC_PINCTL_IN_EN;
				stac92xx_auto_set_pinctl(codec, nid, pinctl);
4994
			}
4995
		}
4996 4997 4998 4999 5000
		conf = snd_hda_codec_get_pincfg(codec, nid);
		if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
			if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT))
				stac_issue_unsol_event(codec, nid);
		}
5001
	}
5002 5003 5004
	for (i = 0; i < spec->num_dmics; i++)
		stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
					AC_PINCTL_IN_EN);
5005 5006
	if (cfg->dig_out_pins[0])
		stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
5007 5008 5009 5010
					 AC_PINCTL_OUT_EN);
	if (cfg->dig_in_pin)
		stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
					 AC_PINCTL_IN_EN);
5011
	for (i = 0; i < spec->num_pwrs; i++)  {
5012
		hda_nid_t nid = spec->pwr_nids[i];
5013
		unsigned int pinctl, def_conf;
5014

5015 5016 5017 5018 5019 5020 5021
		def_conf = snd_hda_codec_get_pincfg(codec, nid);
		def_conf = get_defcfg_connect(def_conf);
		if (def_conf == AC_JACK_PORT_NONE) {
			/* power off unused ports */
			stac_toggle_power_map(codec, nid, 0);
			continue;
		}
5022 5023 5024 5025 5026
		if (def_conf == AC_JACK_PORT_FIXED) {
			/* no need for jack detection for fixed pins */
			stac_toggle_power_map(codec, nid, 1);
			continue;
		}
5027
		/* power on when no jack detection is available */
5028 5029
		/* or when the VREF is used for controlling LED */
		if (!spec->hp_detect ||
5030 5031
		    spec->vref_mute_led_nid == nid ||
		    !is_jack_detectable(codec, nid)) {
5032 5033 5034 5035
			stac_toggle_power_map(codec, nid, 1);
			continue;
		}

5036
		if (is_nid_out_jack_pin(cfg, nid))
5037 5038 5039 5040
			continue; /* already has an unsol event */

		pinctl = snd_hda_codec_read(codec, nid, 0,
					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
5041 5042 5043 5044
		/* outputs are only ports capable of power management
		 * any attempts on powering down a input port cause the
		 * referenced VREF to act quirky.
		 */
5045 5046
		if (pinctl & AC_PINCTL_IN_EN) {
			stac_toggle_power_map(codec, nid, 1);
5047
			continue;
5048
		}
5049
		if (enable_pin_detect(codec, nid, STAC_PWR_EVENT)) {
5050
			stac_issue_unsol_event(codec, nid);
5051 5052 5053 5054
			continue;
		}
		/* none of the above, turn the port OFF */
		stac_toggle_power_map(codec, nid, 0);
5055
	}
5056 5057

	/* sync mute LED */
5058 5059 5060 5061 5062 5063
	if (spec->gpio_led) {
		if (spec->vmaster_mute.hook)
			snd_hda_sync_vmaster_hook(&spec->vmaster_mute);
		else /* the very first init call doesn't have vmaster yet */
			stac92xx_update_led_status(codec, false);
	}
5064 5065 5066 5067 5068 5069

	/* sync the power-map */
	if (spec->num_pwrs)
		snd_hda_codec_write(codec, codec->afg, 0,
				    AC_VERB_IDT_SET_POWER_MAP,
				    spec->power_map_bits);
5070 5071
	if (spec->dac_list)
		stac92xx_power_down(codec);
5072 5073 5074
	return 0;
}

5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087
static void stac92xx_free_kctls(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;

	if (spec->kctls.list) {
		struct snd_kcontrol_new *kctl = spec->kctls.list;
		int i;
		for (i = 0; i < spec->kctls.used; i++)
			kfree(kctl[i].name);
	}
	snd_array_free(&spec->kctls);
}

5088 5089 5090 5091 5092 5093 5094 5095 5096 5097
static void stac92xx_shutup_pins(struct hda_codec *codec)
{
	unsigned int i, def_conf;

	if (codec->bus->shutdown)
		return;
	for (i = 0; i < codec->init_pins.used; i++) {
		struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i);
		def_conf = snd_hda_codec_get_pincfg(codec, pin->nid);
		if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE)
5098
			snd_hda_set_pin_ctl(codec, pin->nid, 0);
5099 5100 5101
	}
}

5102 5103 5104 5105
static void stac92xx_shutup(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;

5106
	stac92xx_shutup_pins(codec);
5107 5108 5109 5110 5111 5112 5113

	if (spec->eapd_mask)
		stac_gpio_set(codec, spec->gpio_mask,
				spec->gpio_dir, spec->gpio_data &
				~spec->eapd_mask);
}

M
Matt 已提交
5114 5115
static void stac92xx_free(struct hda_codec *codec)
{
5116 5117 5118 5119 5120 5121
	struct sigmatel_spec *spec = codec->spec;

	if (! spec)
		return;

	kfree(spec);
5122
	snd_hda_detach_beep_device(codec);
M
Matt 已提交
5123 5124
}

5125 5126 5127
static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
				unsigned int flag)
{
5128 5129 5130
	unsigned int old_ctl, pin_ctl;

	pin_ctl = snd_hda_codec_read(codec, nid,
5131
			0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
5132

5133 5134 5135 5136 5137 5138 5139
	if (pin_ctl & AC_PINCTL_IN_EN) {
		/*
		 * we need to check the current set-up direction of
		 * shared input pins since they can be switched via
		 * "xxx as Output" mixer switch
		 */
		struct sigmatel_spec *spec = codec->spec;
5140
		if (nid == spec->line_switch || nid == spec->mic_switch)
5141 5142 5143
			return;
	}

5144
	old_ctl = pin_ctl;
5145 5146 5147 5148 5149
	/* if setting pin direction bits, clear the current
	   direction bits first */
	if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
		pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
	
5150 5151
	pin_ctl |= flag;
	if (old_ctl != pin_ctl)
5152
		snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl);
5153 5154 5155 5156 5157 5158 5159
}

static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
				  unsigned int flag)
{
	unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
			0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
5160
	if (pin_ctl & flag)
5161
		snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl & ~flag);
5162 5163
}

5164
static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
5165 5166 5167
{
	if (!nid)
		return 0;
5168
	return snd_hda_jack_detect(codec, nid);
5169 5170
}

5171 5172 5173 5174 5175 5176 5177
static void stac92xx_line_out_detect(struct hda_codec *codec,
				     int presence)
{
	struct sigmatel_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	int i;

5178 5179 5180
	if (cfg->speaker_outs == 0)
		return;

5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215
	for (i = 0; i < cfg->line_outs; i++) {
		if (presence)
			break;
		presence = get_pin_presence(codec, cfg->line_out_pins[i]);
		if (presence) {
			unsigned int pinctl;
			pinctl = snd_hda_codec_read(codec,
						    cfg->line_out_pins[i], 0,
					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
			if (pinctl & AC_PINCTL_IN_EN)
				presence = 0; /* mic- or line-input */
		}
	}

	if (presence) {
		/* disable speakers */
		for (i = 0; i < cfg->speaker_outs; i++)
			stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
						AC_PINCTL_OUT_EN);
		if (spec->eapd_mask && spec->eapd_switch)
			stac_gpio_set(codec, spec->gpio_mask,
				spec->gpio_dir, spec->gpio_data &
				~spec->eapd_mask);
	} else {
		/* enable speakers */
		for (i = 0; i < cfg->speaker_outs; i++)
			stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
						AC_PINCTL_OUT_EN);
		if (spec->eapd_mask && spec->eapd_switch)
			stac_gpio_set(codec, spec->gpio_mask,
				spec->gpio_dir, spec->gpio_data |
				spec->eapd_mask);
	}
} 

5216 5217 5218 5219 5220 5221 5222 5223
/* return non-zero if the hp-pin of the given array index isn't
 * a jack-detection target
 */
static int no_hp_sensing(struct sigmatel_spec *spec, int i)
{
	struct auto_pin_cfg *cfg = &spec->autocfg;

	/* ignore sensing of shared line and mic jacks */
5224
	if (cfg->hp_pins[i] == spec->line_switch)
5225
		return 1;
5226
	if (cfg->hp_pins[i] == spec->mic_switch)
5227 5228 5229 5230 5231 5232 5233
		return 1;
	/* ignore if the pin is set as line-out */
	if (cfg->hp_pins[i] == spec->hp_switch)
		return 1;
	return 0;
}

5234
static void stac92xx_hp_detect(struct hda_codec *codec)
5235 5236 5237 5238 5239
{
	struct sigmatel_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	int i, presence;

5240
	presence = 0;
5241 5242 5243 5244
	if (spec->gpio_mute)
		presence = !(snd_hda_codec_read(codec, codec->afg, 0,
			AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);

5245
	for (i = 0; i < cfg->hp_outs; i++) {
5246 5247
		if (presence)
			break;
5248 5249
		if (no_hp_sensing(spec, i))
			continue;
5250 5251 5252 5253 5254 5255 5256 5257
		presence = get_pin_presence(codec, cfg->hp_pins[i]);
		if (presence) {
			unsigned int pinctl;
			pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
			if (pinctl & AC_PINCTL_IN_EN)
				presence = 0; /* mic- or line-input */
		}
5258
	}
5259 5260

	if (presence) {
5261
		/* disable lineouts */
5262
		if (spec->hp_switch)
5263 5264
			stac92xx_reset_pinctl(codec, spec->hp_switch,
					      AC_PINCTL_OUT_EN);
5265 5266 5267 5268
		for (i = 0; i < cfg->line_outs; i++)
			stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
						AC_PINCTL_OUT_EN);
	} else {
5269
		/* enable lineouts */
5270
		if (spec->hp_switch)
5271 5272
			stac92xx_set_pinctl(codec, spec->hp_switch,
					    AC_PINCTL_OUT_EN);
5273 5274 5275 5276
		for (i = 0; i < cfg->line_outs; i++)
			stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
						AC_PINCTL_OUT_EN);
	}
5277
	stac92xx_line_out_detect(codec, presence);
5278 5279 5280 5281 5282
	/* toggle hp outs */
	for (i = 0; i < cfg->hp_outs; i++) {
		unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
		if (no_hp_sensing(spec, i))
			continue;
5283
		if (1 /*presence*/)
5284
			stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
5285 5286 5287 5288 5289 5290 5291 5292 5293 5294
#if 0 /* FIXME */
/* Resetting the pinctl like below may lead to (a sort of) regressions
 * on some devices since they use the HP pin actually for line/speaker
 * outs although the default pin config shows a different pin (that is
 * wrong and useless).
 *
 * So, it's basically a problem of default pin configs, likely a BIOS issue.
 * But, disabling the code below just works around it, and I'm too tired of
 * bug reports with such devices... 
 */
5295 5296
		else
			stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
5297
#endif /* FIXME */
5298
	}
5299 5300
} 

5301 5302
static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
				  int enable)
5303 5304
{
	struct sigmatel_spec *spec = codec->spec;
5305 5306 5307 5308 5309 5310 5311 5312
	unsigned int idx, val;

	for (idx = 0; idx < spec->num_pwrs; idx++) {
		if (spec->pwr_nids[idx] == nid)
			break;
	}
	if (idx >= spec->num_pwrs)
		return;
5313

5314
	idx = 1 << idx;
5315

5316
	val = spec->power_map_bits;
5317
	if (enable)
5318 5319 5320 5321 5322
		val &= ~idx;
	else
		val |= idx;

	/* power down unused output ports */
5323 5324 5325 5326 5327
	if (val != spec->power_map_bits) {
		spec->power_map_bits = val;
		snd_hda_codec_write(codec, codec->afg, 0,
				    AC_VERB_IDT_SET_POWER_MAP, val);
	}
5328 5329
}

5330 5331
static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
{
5332
	stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
5333
}
5334

5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345
/* get the pin connection (fixed, none, etc) */
static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
{
	struct sigmatel_spec *spec = codec->spec;
	unsigned int cfg;

	cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]);
	return get_defcfg_connect(cfg);
}

static int stac92xx_connected_ports(struct hda_codec *codec,
5346
				    const hda_nid_t *nids, int num_nids)
5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364
{
	struct sigmatel_spec *spec = codec->spec;
	int idx, num;
	unsigned int def_conf;

	for (num = 0; num < num_nids; num++) {
		for (idx = 0; idx < spec->num_pins; idx++)
			if (spec->pin_nids[idx] == nids[num])
				break;
		if (idx >= spec->num_pins)
			break;
		def_conf = stac_get_defcfg_connect(codec, idx);
		if (def_conf == AC_JACK_PORT_NONE)
			break;
	}
	return num;
}

5365 5366 5367 5368 5369 5370 5371
static void stac92xx_mic_detect(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	struct sigmatel_mic_route *mic;

	if (get_pin_presence(codec, spec->ext_mic.pin))
		mic = &spec->ext_mic;
5372 5373
	else if (get_pin_presence(codec, spec->dock_mic.pin))
		mic = &spec->dock_mic;
5374 5375
	else
		mic = &spec->int_mic;
5376
	if (mic->dmux_idx >= 0)
5377 5378 5379
		snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
					  AC_VERB_SET_CONNECT_SEL,
					  mic->dmux_idx);
5380
	if (mic->mux_idx >= 0)
5381 5382 5383 5384 5385
		snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
					  AC_VERB_SET_CONNECT_SEL,
					  mic->mux_idx);
}

5386
static void handle_unsol_event(struct hda_codec *codec,
5387
			       struct hda_jack_tbl *event)
5388
{
5389
	struct sigmatel_spec *spec = codec->spec;
5390
	int data;
5391

5392
	switch (event->action) {
5393
	case STAC_HP_EVENT:
5394
	case STAC_LO_EVENT:
5395
		stac92xx_hp_detect(codec);
5396
		break;
5397 5398 5399 5400 5401
	case STAC_MIC_EVENT:
		stac92xx_mic_detect(codec);
		break;
	}

5402
	switch (event->action) {
5403
	case STAC_HP_EVENT:
5404
	case STAC_LO_EVENT:
5405
	case STAC_MIC_EVENT:
5406
	case STAC_INSERT_EVENT:
5407
	case STAC_PWR_EVENT:
5408 5409
		if (spec->num_pwrs > 0)
			stac92xx_pin_sense(codec, event->nid);
5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427

		switch (codec->subsystem_id) {
		case 0x103c308f:
			if (event->nid == 0xb) {
				int pin = AC_PINCTL_IN_EN;

				if (get_pin_presence(codec, 0xa)
						&& get_pin_presence(codec, 0xb))
					pin |= AC_PINCTL_VREF_80;
				if (!get_pin_presence(codec, 0xb))
					pin |= AC_PINCTL_VREF_80;

				/* toggle VREF state based on mic + hp pin
				 * status
				 */
				stac92xx_auto_set_pinctl(codec, 0x0a, pin);
			}
		}
5428
		break;
5429 5430 5431
	case STAC_VREF_EVENT:
		data = snd_hda_codec_read(codec, codec->afg, 0,
					  AC_VERB_GET_GPIO_DATA, 0);
5432 5433
		/* toggle VREF state based on GPIOx status */
		snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
5434
				    !!(data & (1 << event->private_data)));
5435
		break;
5436 5437 5438
	}
}

5439 5440
static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
{
5441
	struct hda_jack_tbl *event = snd_hda_jack_tbl_get(codec, nid);
5442 5443 5444 5445 5446
	if (!event)
		return;
	handle_unsol_event(codec, event);
}

5447 5448 5449 5450 5451
static int hp_blike_system(u32 subsystem_id);

static void set_hp_led_gpio(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
5452 5453
	unsigned int gpio;

5454 5455 5456
	if (spec->gpio_led)
		return;

5457 5458 5459 5460 5461 5462
	gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
	gpio &= AC_GPIO_IO_COUNT;
	if (gpio > 3)
		spec->gpio_led = 0x08; /* GPIO 3 */
	else
		spec->gpio_led = 0x01; /* GPIO 0 */
5463 5464
}

5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475
/*
 * This method searches for the mute LED GPIO configuration
 * provided as OEM string in SMBIOS. The format of that string
 * is HP_Mute_LED_P_G or HP_Mute_LED_P
 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
 * that corresponds to the NOT muted state of the master volume
 * and G is the index of the GPIO to use as the mute LED control (0..9)
 * If _G portion is missing it is assigned based on the codec ID
 *
 * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
 * or  HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
5476 5477 5478 5479 5480 5481 5482 5483
 *
 *
 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
 * SMBIOS - at least the ones I have seen do not have them - which include
 * my own system (HP Pavilion dv6-1110ax) and my cousin's
 * HP Pavilion dv9500t CTO.
 * Need more information on whether it is true across the entire series.
 * -- kunal
5484
 */
5485
static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity)
5486 5487 5488 5489
{
	struct sigmatel_spec *spec = codec->spec;
	const struct dmi_device *dev = NULL;

5490 5491 5492 5493 5494
	if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
		get_int_hint(codec, "gpio_led_polarity",
			     &spec->gpio_led_polarity);
		return 1;
	}
5495 5496 5497
	if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
		while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
								NULL, dev))) {
5498
			if (sscanf(dev->name, "HP_Mute_LED_%d_%x",
5499 5500
				  &spec->gpio_led_polarity,
				  &spec->gpio_led) == 2) {
5501 5502 5503 5504 5505
				unsigned int max_gpio;
				max_gpio = snd_hda_param_read(codec, codec->afg,
							      AC_PAR_GPIO_CAP);
				max_gpio &= AC_GPIO_IO_COUNT;
				if (spec->gpio_led < max_gpio)
5506
					spec->gpio_led = 1 << spec->gpio_led;
5507 5508
				else
					spec->vref_mute_led_nid = spec->gpio_led;
5509 5510 5511
				return 1;
			}
			if (sscanf(dev->name, "HP_Mute_LED_%d",
5512 5513 5514
				  &spec->gpio_led_polarity) == 1) {
				set_hp_led_gpio(codec);
				return 1;
5515
			}
5516 5517 5518
			/* BIOS bug: unfilled OEM string */
			if (strstr(dev->name, "HP_Mute_LED_P_G")) {
				set_hp_led_gpio(codec);
5519 5520 5521 5522 5523 5524 5525 5526
				switch (codec->subsystem_id) {
				case 0x103c148a:
					spec->gpio_led_polarity = 0;
					break;
				default:
					spec->gpio_led_polarity = 1;
					break;
				}
5527 5528
				return 1;
			}
5529
		}
5530 5531 5532

		/*
		 * Fallback case - if we don't find the DMI strings,
5533 5534
		 * we statically set the GPIO - if not a B-series system
		 * and default polarity is provided
5535
		 */
5536 5537
		if (!hp_blike_system(codec->subsystem_id) &&
			(default_polarity == 0 || default_polarity == 1)) {
5538
			set_hp_led_gpio(codec);
5539
			spec->gpio_led_polarity = default_polarity;
5540 5541
			return 1;
		}
5542 5543 5544 5545 5546
	}
	return 0;
}

static int hp_blike_system(u32 subsystem_id)
R
Randy Dunlap 已提交
5547 5548
{
	switch (subsystem_id) {
5549 5550 5551 5552 5553
	case 0x103c1520:
	case 0x103c1521:
	case 0x103c1523:
	case 0x103c1524:
	case 0x103c1525:
R
Randy Dunlap 已提交
5554 5555 5556 5557 5558 5559 5560 5561
	case 0x103c1722:
	case 0x103c1723:
	case 0x103c1724:
	case 0x103c1725:
	case 0x103c1726:
	case 0x103c1727:
	case 0x103c1728:
	case 0x103c1729:
5562 5563 5564 5565 5566 5567 5568 5569
	case 0x103c172a:
	case 0x103c172b:
	case 0x103c307e:
	case 0x103c307f:
	case 0x103c3080:
	case 0x103c3081:
	case 0x103c7007:
	case 0x103c7008:
R
Randy Dunlap 已提交
5570 5571 5572 5573 5574
		return 1;
	}
	return 0;
}

5575 5576 5577 5578 5579 5580
#ifdef CONFIG_PROC_FS
static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
			       struct hda_codec *codec, hda_nid_t nid)
{
	if (nid == codec->afg)
		snd_iprintf(buffer, "Power-Map: 0x%02x\n", 
5581 5582
			    snd_hda_codec_read(codec, nid, 0,
					       AC_VERB_IDT_GET_POWER_MAP, 0));
5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621
}

static void analog_loop_proc_hook(struct snd_info_buffer *buffer,
				  struct hda_codec *codec,
				  unsigned int verb)
{
	snd_iprintf(buffer, "Analog Loopback: 0x%02x\n",
		    snd_hda_codec_read(codec, codec->afg, 0, verb, 0));
}

/* stac92hd71bxx, stac92hd73xx */
static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
				 struct hda_codec *codec, hda_nid_t nid)
{
	stac92hd_proc_hook(buffer, codec, nid);
	if (nid == codec->afg)
		analog_loop_proc_hook(buffer, codec, 0xfa0);
}

static void stac9205_proc_hook(struct snd_info_buffer *buffer,
			       struct hda_codec *codec, hda_nid_t nid)
{
	if (nid == codec->afg)
		analog_loop_proc_hook(buffer, codec, 0xfe0);
}

static void stac927x_proc_hook(struct snd_info_buffer *buffer,
			       struct hda_codec *codec, hda_nid_t nid)
{
	if (nid == codec->afg)
		analog_loop_proc_hook(buffer, codec, 0xfeb);
}
#else
#define stac92hd_proc_hook	NULL
#define stac92hd7x_proc_hook	NULL
#define stac9205_proc_hook	NULL
#define stac927x_proc_hook	NULL
#endif

5622
#ifdef CONFIG_PM
5623 5624
static int stac92xx_resume(struct hda_codec *codec)
{
5625
	stac92xx_init(codec);
5626 5627
	snd_hda_codec_resume_amp(codec);
	snd_hda_codec_resume_cache(codec);
5628
	/* fake event to set up pins again to override cached values */
5629
	stac_fake_hp_events(codec);
5630 5631
	return 0;
}
M
Matthew Ranostay 已提交
5632

5633
static int stac92xx_suspend(struct hda_codec *codec)
5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645
{
	stac92xx_shutup(codec);
	return 0;
}

static void stac92xx_set_power_state(struct hda_codec *codec, hda_nid_t fg,
				unsigned int power_state)
{
	unsigned int afg_power_state = power_state;
	struct sigmatel_spec *spec = codec->spec;

	if (power_state == AC_PWRST_D3) {
5646
		if (spec->vref_mute_led_nid) {
5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658
			/* with vref-out pin used for mute led control
			 * codec AFG is prevented from D3 state
			 */
			afg_power_state = AC_PWRST_D1;
		}
		/* this delay seems necessary to avoid click noise at power-down */
		msleep(100);
	}
	snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE,
			afg_power_state);
	snd_hda_codec_set_power_to_all(codec, fg, power_state, true);
}
5659 5660 5661 5662
#else
#define stac92xx_suspend	NULL
#define stac92xx_resume		NULL
#define stac92xx_set_power_state NULL
5663
#endif /* CONFIG_PM */
5664

5665 5666
/* update mute-LED accoring to the master switch */
static void stac92xx_update_led_status(struct hda_codec *codec, int enabled)
5667 5668
{
	struct sigmatel_spec *spec = codec->spec;
5669
	int muted = !enabled;
5670

5671
	if (!spec->gpio_led)
5672 5673 5674 5675 5676
		return;

	/* LED state is inverted on these systems */
	if (spec->gpio_led_polarity)
		muted = !muted;
5677

5678
	if (!spec->vref_mute_led_nid) {
5679
		if (muted)
5680
			spec->gpio_data |= spec->gpio_led;
5681
		else
5682
			spec->gpio_data &= ~spec->gpio_led;
5683 5684 5685
		stac_gpio_set(codec, spec->gpio_mask,
				spec->gpio_dir, spec->gpio_data);
	} else {
5686
		spec->vref_led = muted ? AC_PINCTL_VREF_50 : AC_PINCTL_VREF_GRD;
5687 5688
		stac_vrefout_set(codec,	spec->vref_mute_led_nid,
				 spec->vref_led);
5689
	}
5690
}
5691

5692
static const struct hda_codec_ops stac92xx_patch_ops = {
M
Matt 已提交
5693 5694 5695 5696
	.build_controls = stac92xx_build_controls,
	.build_pcms = stac92xx_build_pcms,
	.init = stac92xx_init,
	.free = stac92xx_free,
5697
	.unsol_event = snd_hda_jack_unsol_event,
5698
#ifdef CONFIG_PM
M
Matthew Ranostay 已提交
5699
	.suspend = stac92xx_suspend,
5700 5701
	.resume = stac92xx_resume,
#endif
5702
	.reboot_notify = stac92xx_shutup,
M
Matt 已提交
5703 5704
};

5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720
static int alloc_stac_spec(struct hda_codec *codec, int num_pins,
			   const hda_nid_t *pin_nids)
{
	struct sigmatel_spec *spec;

	spec = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (!spec)
		return -ENOMEM;
	codec->spec = spec;
	codec->no_trigger_sense = 1; /* seems common with STAC/IDT codecs */
	spec->num_pins = num_pins;
	spec->pin_nids = pin_nids;
	snd_array_init(&spec->kctls, sizeof(struct snd_kcontrol_new), 32);
	return 0;
}

M
Matt 已提交
5721 5722 5723
static int patch_stac9200(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
5724
	int err;
M
Matt 已提交
5725

5726 5727 5728 5729
	err = alloc_stac_spec(codec, ARRAY_SIZE(stac9200_pin_nids),
			      stac9200_pin_nids);
	if (err < 0)
		return err;
M
Matt 已提交
5730

5731
	spec = codec->spec;
5732
	spec->linear_tone_beep = 1;
5733 5734 5735

	snd_hda_pick_fixup(codec, stac9200_models, stac9200_fixup_tbl,
			   stac9200_fixups);
M
Matt 已提交
5736 5737 5738 5739 5740 5741

	spec->multiout.max_channels = 2;
	spec->multiout.num_dacs = 1;
	spec->multiout.dac_nids = stac9200_dac_nids;
	spec->adc_nids = stac9200_adc_nids;
	spec->mux_nids = stac9200_mux_nids;
5742
	spec->num_muxes = 1;
5743
	spec->num_dmics = 0;
5744
	spec->num_adcs = 1;
5745
	spec->num_pwrs = 0;
5746
	snd_hda_add_verbs(codec, stac9200_eapd_init);
5747

M
Matt 已提交
5748
	spec->mixer = stac9200_mixer;
5749

5750
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
5751

5752 5753 5754 5755 5756
	err = stac9200_parse_auto_config(codec);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}
M
Matt 已提交
5757 5758 5759

	codec->patch_ops = stac92xx_patch_ops;

5760 5761
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

M
Matt 已提交
5762 5763 5764
	return 0;
}

5765 5766 5767 5768 5769
static int patch_stac925x(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
	int err;

5770 5771 5772 5773
	err = alloc_stac_spec(codec, ARRAY_SIZE(stac925x_pin_nids),
			      stac925x_pin_nids);
	if (err < 0)
		return err;
5774

5775
	spec = codec->spec;
5776
	spec->linear_tone_beep = 1;
5777

5778 5779
	snd_hda_pick_fixup(codec, stac925x_models, stac925x_fixup_tbl,
			   stac925x_fixups);
5780 5781 5782 5783 5784 5785 5786

	spec->multiout.max_channels = 2;
	spec->multiout.num_dacs = 1;
	spec->multiout.dac_nids = stac925x_dac_nids;
	spec->adc_nids = stac925x_adc_nids;
	spec->mux_nids = stac925x_mux_nids;
	spec->num_muxes = 1;
5787
	spec->num_adcs = 1;
5788
	spec->num_pwrs = 0;
5789 5790 5791 5792 5793
	switch (codec->vendor_id) {
	case 0x83847632: /* STAC9202  */
	case 0x83847633: /* STAC9202D */
	case 0x83847636: /* STAC9251  */
	case 0x83847637: /* STAC9251D */
5794
		spec->num_dmics = STAC925X_NUM_DMICS;
5795
		spec->dmic_nids = stac925x_dmic_nids;
5796 5797
		spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
		spec->dmux_nids = stac925x_dmux_nids;
5798 5799 5800 5801 5802
		break;
	default:
		spec->num_dmics = 0;
		break;
	}
5803

5804
	snd_hda_add_verbs(codec, stac925x_core_init);
5805
	spec->mixer = stac925x_mixer;
5806 5807 5808
	spec->num_caps = 1;
	spec->capvols = stac925x_capvols;
	spec->capsws = stac925x_capsws;
5809

5810 5811
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

5812
	err = stac92xx_parse_auto_config(codec);
5813
	if (!err)
5814
		err = -EINVAL;
5815 5816 5817 5818 5819 5820 5821
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}

	codec->patch_ops = stac92xx_patch_ops;

5822 5823
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

5824 5825 5826
	return 0;
}

5827 5828 5829 5830
static int patch_stac92hd73xx(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
	hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
5831
	int err;
5832
	int num_dacs;
5833

5834 5835 5836 5837
	err = alloc_stac_spec(codec, ARRAY_SIZE(stac92hd73xx_pin_nids),
			      stac92hd73xx_pin_nids);
	if (err < 0)
		return err;
5838

5839
	spec = codec->spec;
5840
	spec->linear_tone_beep = 0;
5841
	codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
5842 5843 5844 5845
	spec->board_config = snd_hda_check_board_config(codec,
							STAC_92HD73XX_MODELS,
							stac92hd73xx_models,
							stac92hd73xx_cfg_tbl);
5846 5847 5848 5849 5850 5851
	/* check codec subsystem id if not found */
	if (spec->board_config < 0)
		spec->board_config =
			snd_hda_check_board_codec_sid_config(codec,
				STAC_92HD73XX_MODELS, stac92hd73xx_models,
				stac92hd73xx_codec_id_cfg_tbl);
5852
again:
5853
	if (spec->board_config < 0)
5854 5855
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
			    codec->chip_name);
5856 5857
	else
		stac92xx_set_config_regs(codec,
5858
				stac92hd73xx_brd_tbl[spec->board_config]);
5859

5860
	num_dacs = snd_hda_get_connections(codec, 0x0a,
5861 5862
			conn, STAC92HD73_DAC_COUNT + 2) - 1;

5863
	if (num_dacs < 3 || num_dacs > 5) {
5864 5865
		printk(KERN_WARNING "hda_codec: Could not determine "
		       "number of channels defaulting to DAC count\n");
5866
		num_dacs = STAC92HD73_DAC_COUNT;
5867
	}
5868
	spec->init = stac92hd73xx_core_init;
5869
	switch (num_dacs) {
5870
	case 0x3: /* 6 Channel */
5871
		spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
5872 5873
		break;
	case 0x4: /* 8 Channel */
5874
		spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
5875 5876
		break;
	case 0x5: /* 10 Channel */
5877 5878
		spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
		break;
5879 5880
	}
	spec->multiout.dac_nids = spec->dac_nids;
5881 5882 5883 5884

	spec->aloopback_mask = 0x01;
	spec->aloopback_shift = 8;

5885
	spec->digbeep_nid = 0x1c;
5886 5887 5888 5889
	spec->mux_nids = stac92hd73xx_mux_nids;
	spec->adc_nids = stac92hd73xx_adc_nids;
	spec->dmic_nids = stac92hd73xx_dmic_nids;
	spec->dmux_nids = stac92hd73xx_dmux_nids;
M
Matthew Ranostay 已提交
5890
	spec->smux_nids = stac92hd73xx_smux_nids;
5891 5892 5893

	spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
	spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
5894
	spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
M
Matthew Ranostay 已提交
5895

5896 5897 5898 5899
	spec->num_caps = STAC92HD73XX_NUM_CAPS;
	spec->capvols = stac92hd73xx_capvols;
	spec->capsws = stac92hd73xx_capsws;

5900
	switch (spec->board_config) {
5901
	case STAC_DELL_EQ:
5902
		spec->init = dell_eq_core_init;
5903
		/* fallthru */
5904 5905 5906
	case STAC_DELL_M6_AMIC:
	case STAC_DELL_M6_DMIC:
	case STAC_DELL_M6_BOTH:
M
Matthew Ranostay 已提交
5907
		spec->num_smuxes = 0;
M
Matthew Ranostay 已提交
5908
		spec->eapd_switch = 0;
5909

5910 5911
		switch (spec->board_config) {
		case STAC_DELL_M6_AMIC: /* Analog Mics */
5912
			snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5913 5914
			spec->num_dmics = 0;
			break;
5915
		case STAC_DELL_M6_DMIC: /* Digital Mics */
5916
			snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5917 5918
			spec->num_dmics = 1;
			break;
5919
		case STAC_DELL_M6_BOTH: /* Both */
5920 5921
			snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
			snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5922 5923 5924 5925
			spec->num_dmics = 1;
			break;
		}
		break;
5926 5927 5928 5929 5930
	case STAC_ALIENWARE_M17X:
		spec->num_dmics = STAC92HD73XX_NUM_DMICS;
		spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
		spec->eapd_switch = 0;
		break;
5931 5932
	default:
		spec->num_dmics = STAC92HD73XX_NUM_DMICS;
M
Matthew Ranostay 已提交
5933
		spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
M
Matthew Ranostay 已提交
5934
		spec->eapd_switch = 1;
5935
		break;
5936
	}
5937
	if (spec->board_config != STAC_92HD73XX_REF) {
5938 5939 5940 5941
		/* GPIO0 High = Enable EAPD */
		spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
		spec->gpio_data = 0x01;
	}
5942

5943 5944 5945
	spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
	spec->pwr_nids = stac92hd73xx_pwr_nids;

5946
	err = stac92xx_parse_auto_config(codec);
5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962

	if (!err) {
		if (spec->board_config < 0) {
			printk(KERN_WARNING "hda_codec: No auto-config is "
			       "available, default to model=ref\n");
			spec->board_config = STAC_92HD73XX_REF;
			goto again;
		}
		err = -EINVAL;
	}

	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}

5963 5964 5965
	if (spec->board_config == STAC_92HD73XX_NO_JD)
		spec->hp_detect = 0;

5966 5967
	codec->patch_ops = stac92xx_patch_ops;

5968 5969
	codec->proc_widget_hook = stac92hd7x_proc_hook;

5970 5971 5972
	return 0;
}

5973
static int hp_bnb2011_with_dock(struct hda_codec *codec)
5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995
{
	if (codec->vendor_id != 0x111d7605 &&
	    codec->vendor_id != 0x111d76d1)
		return 0;

	switch (codec->subsystem_id) {
	case 0x103c1618:
	case 0x103c1619:
	case 0x103c161a:
	case 0x103c161b:
	case 0x103c161c:
	case 0x103c161d:
	case 0x103c161e:
	case 0x103c161f:

	case 0x103c162a:
	case 0x103c162b:

	case 0x103c1630:
	case 0x103c1631:

	case 0x103c1633:
5996
	case 0x103c1634:
5997 5998 5999 6000 6001 6002 6003 6004 6005
	case 0x103c1635:

	case 0x103c3587:
	case 0x103c3588:
	case 0x103c3589:
	case 0x103c358a:

	case 0x103c3667:
	case 0x103c3668:
6006 6007 6008
	case 0x103c3669:

		return 1;
6009 6010 6011 6012
	}
	return 0;
}

6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111
static void stac92hd8x_add_pin(struct hda_codec *codec, hda_nid_t nid)
{
	struct sigmatel_spec *spec = codec->spec;
	unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
	int i;

	spec->auto_pin_nids[spec->auto_pin_cnt] = nid;
	spec->auto_pin_cnt++;

	if (get_defcfg_device(def_conf) == AC_JACK_MIC_IN &&
	    get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) {
		for (i = 0; i < ARRAY_SIZE(stac92hd83xxx_dmic_nids); i++) {
			if (nid == stac92hd83xxx_dmic_nids[i]) {
				spec->auto_dmic_nids[spec->auto_dmic_cnt] = nid;
				spec->auto_dmic_cnt++;
			}
		}
	}
}

static void stac92hd8x_add_adc(struct hda_codec *codec, hda_nid_t nid)
{
	struct sigmatel_spec *spec = codec->spec;

	spec->auto_adc_nids[spec->auto_adc_cnt] = nid;
	spec->auto_adc_cnt++;
}

static void stac92hd8x_add_mux(struct hda_codec *codec, hda_nid_t nid)
{
	int i, j;
	struct sigmatel_spec *spec = codec->spec;

	for (i = 0; i < spec->auto_adc_cnt; i++) {
		if (get_connection_index(codec,
				spec->auto_adc_nids[i], nid) >= 0) {
			/* mux and volume for adc_nids[i] */
			if (!spec->auto_mux_nids[i]) {
				spec->auto_mux_nids[i] = nid;
				/* 92hd codecs capture volume is in mux */
				spec->auto_capvols[i] = HDA_COMPOSE_AMP_VAL(nid,
							3, 0, HDA_OUTPUT);
			}
			for (j = 0; j < spec->auto_dmic_cnt; j++) {
				if (get_connection_index(codec, nid,
						spec->auto_dmic_nids[j]) >= 0) {
					/* dmux for adc_nids[i] */
					if (!spec->auto_dmux_nids[i])
						spec->auto_dmux_nids[i] = nid;
					break;
				}
			}
			break;
		}
	}
}

static void stac92hd8x_fill_auto_spec(struct hda_codec *codec)
{
	hda_nid_t nid, end_nid;
	unsigned int wid_caps, wid_type;
	struct sigmatel_spec *spec = codec->spec;

	end_nid = codec->start_nid + codec->num_nodes;

	for (nid = codec->start_nid; nid < end_nid; nid++) {
		wid_caps = get_wcaps(codec, nid);
		wid_type = get_wcaps_type(wid_caps);

		if (wid_type == AC_WID_PIN)
			stac92hd8x_add_pin(codec, nid);

		if (wid_type == AC_WID_AUD_IN && !(wid_caps & AC_WCAP_DIGITAL))
			stac92hd8x_add_adc(codec, nid);
	}

	for (nid = codec->start_nid; nid < end_nid; nid++) {
		wid_caps = get_wcaps(codec, nid);
		wid_type = get_wcaps_type(wid_caps);

		if (wid_type == AC_WID_AUD_SEL)
			stac92hd8x_add_mux(codec, nid);
	}

	spec->pin_nids = spec->auto_pin_nids;
	spec->num_pins = spec->auto_pin_cnt;
	spec->adc_nids = spec->auto_adc_nids;
	spec->num_adcs = spec->auto_adc_cnt;
	spec->capvols = spec->auto_capvols;
	spec->capsws = spec->auto_capvols;
	spec->num_caps = spec->auto_adc_cnt;
	spec->mux_nids = spec->auto_mux_nids;
	spec->num_muxes = spec->auto_adc_cnt;
	spec->dmux_nids = spec->auto_dmux_nids;
	spec->num_dmuxes = spec->auto_adc_cnt;
	spec->dmic_nids = spec->auto_dmic_nids;
	spec->num_dmics = spec->auto_dmic_cnt;
}

6112 6113 6114
static int patch_stac92hd83xxx(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
6115
	int default_polarity = -1; /* no default cfg */
6116 6117
	int err;

6118 6119 6120
	err = alloc_stac_spec(codec, 0, NULL); /* pins filled later */
	if (err < 0)
		return err;
6121

6122 6123 6124 6125 6126
	if (hp_bnb2011_with_dock(codec)) {
		snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f);
		snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e);
	}

6127
	codec->epss = 0; /* longer delay needed for D3 */
6128 6129
	stac92hd8x_fill_auto_spec(codec);

6130
	spec = codec->spec;
6131
	spec->linear_tone_beep = 0;
6132
	codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
6133 6134 6135
	spec->digbeep_nid = 0x21;
	spec->pwr_nids = stac92hd83xxx_pwr_nids;
	spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
6136
	spec->multiout.dac_nids = spec->dac_nids;
6137
	spec->init = stac92hd83xxx_core_init;
6138

6139 6140 6141 6142
	spec->board_config = snd_hda_check_board_config(codec,
							STAC_92HD83XXX_MODELS,
							stac92hd83xxx_models,
							stac92hd83xxx_cfg_tbl);
6143 6144 6145 6146 6147 6148
	/* check codec subsystem id if not found */
	if (spec->board_config < 0)
		spec->board_config =
			snd_hda_check_board_codec_sid_config(codec,
				STAC_92HD83XXX_MODELS, stac92hd83xxx_models,
				stac92hd83xxx_codec_id_cfg_tbl);
6149
again:
6150
	if (spec->board_config < 0)
6151 6152
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
			    codec->chip_name);
6153 6154
	else
		stac92xx_set_config_regs(codec,
6155
				stac92hd83xxx_brd_tbl[spec->board_config]);
6156

6157 6158
	codec->patch_ops = stac92xx_patch_ops;

6159 6160 6161 6162
	switch (spec->board_config) {
	case STAC_HP_ZEPHYR:
		spec->init = stac92hd83xxx_hp_zephyr_init;
		break;
6163
	case STAC_92HD83XXX_HP_LED:
6164 6165 6166
		default_polarity = 0;
		break;
	case STAC_92HD83XXX_HP_INV_LED:
6167 6168
		default_polarity = 1;
		break;
6169 6170 6171
	case STAC_92HD83XXX_HP_MIC_LED:
		spec->mic_mute_led_gpio = 0x08; /* GPIO3 */
		break;
6172 6173 6174
	case STAC_92HD83XXX_HEADSET_JACK:
		spec->headset_jack = 1;
		break;
6175 6176
	}

6177
	if (find_mute_led_cfg(codec, default_polarity))
6178 6179 6180 6181
		snd_printd("mute LED gpio %d polarity %d\n",
				spec->gpio_led,
				spec->gpio_led_polarity);

6182
	if (spec->gpio_led) {
6183
		if (!spec->vref_mute_led_nid) {
6184 6185 6186 6187 6188 6189 6190
			spec->gpio_mask |= spec->gpio_led;
			spec->gpio_dir |= spec->gpio_led;
			spec->gpio_data |= spec->gpio_led;
		} else {
			codec->patch_ops.set_power_state =
					stac92xx_set_power_state;
		}
6191 6192
	}

6193 6194 6195 6196 6197 6198 6199
	if (spec->mic_mute_led_gpio) {
		spec->gpio_mask |= spec->mic_mute_led_gpio;
		spec->gpio_dir |= spec->mic_mute_led_gpio;
		spec->mic_mute_led_on = true;
		spec->gpio_data |= spec->mic_mute_led_gpio;
	}

6200
	err = stac92xx_parse_auto_config(codec);
6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215
	if (!err) {
		if (spec->board_config < 0) {
			printk(KERN_WARNING "hda_codec: No auto-config is "
			       "available, default to model=ref\n");
			spec->board_config = STAC_92HD83XXX_REF;
			goto again;
		}
		err = -EINVAL;
	}

	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}

6216 6217
	codec->proc_widget_hook = stac92hd_proc_hook;

6218 6219 6220
	return 0;
}

6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233
static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
					  hda_nid_t dig0pin)
{
	struct sigmatel_spec *spec = codec->spec;
	int idx;

	for (idx = 0; idx < spec->num_pins; idx++)
		if (spec->pin_nids[idx] == dig0pin)
			break;
	if ((idx + 2) >= spec->num_pins)
		return 0;

	/* dig1pin case */
6234
	if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
6235 6236 6237
		return 2;

	/* dig0pin + dig2pin case */
6238
	if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
6239
		return 2;
6240
	if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
6241 6242 6243 6244 6245
		return 1;
	else
		return 0;
}

6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272
/* HP dv7 bass switch - GPIO5 */
#define stac_hp_bass_gpio_info	snd_ctl_boolean_mono_info
static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
	return 0;
}

static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
				 struct snd_ctl_elem_value *ucontrol)
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
	unsigned int gpio_data;

	gpio_data = (spec->gpio_data & ~0x20) |
		(ucontrol->value.integer.value[0] ? 0x20 : 0);
	if (gpio_data == spec->gpio_data)
		return 0;
	spec->gpio_data = gpio_data;
	stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
	return 1;
}

6273
static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.info = stac_hp_bass_gpio_info,
	.get = stac_hp_bass_gpio_get,
	.put = stac_hp_bass_gpio_put,
};

static int stac_add_hp_bass_switch(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;

	if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl,
			      "Bass Speaker Playback Switch", 0))
		return -ENOMEM;

	spec->gpio_mask |= 0x20;
	spec->gpio_dir |= 0x20;
	spec->gpio_data |= 0x20;
	return 0;
}

6294 6295 6296
static int patch_stac92hd71bxx(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
6297
	const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
6298
	unsigned int pin_cfg;
6299
	int err;
6300

6301 6302 6303 6304
	err = alloc_stac_spec(codec, STAC92HD71BXX_NUM_PINS,
			      stac92hd71bxx_pin_nids_4port);
	if (err < 0)
		return err;
6305

6306
	spec = codec->spec;
6307
	spec->linear_tone_beep = 0;
M
Matthew Ranostay 已提交
6308
	codec->patch_ops = stac92xx_patch_ops;
6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320
	switch (codec->vendor_id) {
	case 0x111d76b6:
	case 0x111d76b7:
		break;
	case 0x111d7603:
	case 0x111d7608:
		/* On 92HD75Bx 0x27 isn't a pin nid */
		spec->num_pins--;
		/* fallthrough */
	default:
		spec->pin_nids = stac92hd71bxx_pin_nids_6port;
	}
6321
	spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
6322 6323 6324 6325 6326
	spec->board_config = snd_hda_check_board_config(codec,
							STAC_92HD71BXX_MODELS,
							stac92hd71bxx_models,
							stac92hd71bxx_cfg_tbl);
again:
6327
	if (spec->board_config < 0)
6328 6329
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
			    codec->chip_name);
6330 6331
	else
		stac92xx_set_config_regs(codec,
6332
				stac92hd71bxx_brd_tbl[spec->board_config]);
6333

6334
	if (spec->board_config != STAC_92HD71BXX_REF) {
6335 6336 6337 6338 6339 6340
		/* GPIO0 = EAPD */
		spec->gpio_mask = 0x01;
		spec->gpio_dir = 0x01;
		spec->gpio_data = 0x01;
	}

6341 6342 6343
	spec->dmic_nids = stac92hd71bxx_dmic_nids;
	spec->dmux_nids = stac92hd71bxx_dmux_nids;

6344 6345 6346 6347
	spec->num_caps = STAC92HD71BXX_NUM_CAPS;
	spec->capvols = stac92hd71bxx_capvols;
	spec->capsws = stac92hd71bxx_capsws;

6348 6349 6350
	switch (codec->vendor_id) {
	case 0x111d76b6: /* 4 Port without Analog Mixer */
	case 0x111d76b7:
6351 6352
		unmute_init++;
		/* fallthru */
6353 6354
	case 0x111d76b4: /* 6 Port without Analog Mixer */
	case 0x111d76b5:
6355
		codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
6356
		spec->num_dmics = stac92xx_connected_ports(codec,
6357 6358
					stac92hd71bxx_dmic_nids,
					STAC92HD71BXX_NUM_DMICS);
6359
		break;
6360
	case 0x111d7608: /* 5 Port with Analog Mixer */
6361 6362
		switch (spec->board_config) {
		case STAC_HP_M4:
6363
			/* Enable VREF power saving on GPIO1 detect */
6364
			err = stac_add_event(codec, codec->afg,
6365 6366 6367
					     STAC_VREF_EVENT, 0x02);
			if (err < 0)
				return err;
6368
			snd_hda_codec_write_cache(codec, codec->afg, 0,
6369
				AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
6370
			snd_hda_jack_detect_enable(codec, codec->afg, 0);
6371 6372 6373
			spec->gpio_mask |= 0x02;
			break;
		}
M
Matthew Ranostay 已提交
6374
		if ((codec->revision_id & 0xf) == 0 ||
6375
		    (codec->revision_id & 0xf) == 1)
M
Matthew Ranostay 已提交
6376 6377
			spec->stream_delay = 40; /* 40 milliseconds */

6378
		/* disable VSW */
6379
		unmute_init++;
6380 6381
		snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
		snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
6382
		spec->dmic_nids = stac92hd71bxx_dmic_5port_nids;
6383
		spec->num_dmics = stac92xx_connected_ports(codec,
6384
					stac92hd71bxx_dmic_5port_nids,
6385
					STAC92HD71BXX_NUM_DMICS - 1);
6386 6387
		break;
	case 0x111d7603: /* 6 Port with Analog Mixer */
6388
		if ((codec->revision_id & 0xf) == 1)
M
Matthew Ranostay 已提交
6389 6390
			spec->stream_delay = 40; /* 40 milliseconds */

6391
		/* fallthru */
6392
	default:
6393
		codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
6394
		spec->num_dmics = stac92xx_connected_ports(codec,
6395 6396
					stac92hd71bxx_dmic_nids,
					STAC92HD71BXX_NUM_DMICS);
6397
		break;
6398 6399
	}

6400 6401 6402
	if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB)
		spec->init = stac92hd71bxx_core_init;

6403 6404 6405
	if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
		snd_hda_sequence_write_cache(codec, unmute_init);

6406
	spec->aloopback_ctl = stac92hd71bxx_loopback;
6407
	spec->aloopback_mask = 0x50;
6408 6409
	spec->aloopback_shift = 0;

M
Matthew Ranostay 已提交
6410
	spec->powerdown_adcs = 1;
6411
	spec->digbeep_nid = 0x26;
6412 6413
	spec->mux_nids = stac92hd71bxx_mux_nids;
	spec->adc_nids = stac92hd71bxx_adc_nids;
M
Matthew Ranostay 已提交
6414
	spec->smux_nids = stac92hd71bxx_smux_nids;
6415
	spec->pwr_nids = stac92hd71bxx_pwr_nids;
6416 6417 6418

	spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
	spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
6419
	spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
6420
	spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
6421

6422 6423
	snd_printdd("Found board config: %d\n", spec->board_config);

6424 6425 6426
	switch (spec->board_config) {
	case STAC_HP_M4:
		/* enable internal microphone */
6427
		snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
M
Matthew Ranostay 已提交
6428 6429
		stac92xx_auto_set_pinctl(codec, 0x0e,
			AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
6430 6431 6432 6433 6434 6435 6436 6437 6438 6439
		/* fallthru */
	case STAC_DELL_M4_2:
		spec->num_dmics = 0;
		spec->num_smuxes = 0;
		spec->num_dmuxes = 0;
		break;
	case STAC_DELL_M4_1:
	case STAC_DELL_M4_3:
		spec->num_dmics = 1;
		spec->num_smuxes = 0;
6440
		spec->num_dmuxes = 1;
6441
		break;
6442 6443 6444 6445 6446 6447 6448 6449
	case STAC_HP_DV4_1222NR:
		spec->num_dmics = 1;
		/* I don't know if it needs 1 or 2 smuxes - will wait for
		 * bug reports to fix if needed
		 */
		spec->num_smuxes = 1;
		spec->num_dmuxes = 1;
		/* fallthrough */
6450 6451 6452
	case STAC_HP_DV4:
		spec->gpio_led = 0x01;
		/* fallthrough */
6453
	case STAC_HP_DV5:
6454
		snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
6455
		stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
6456 6457 6458 6459 6460
		/* HP dv6 gives the headphone pin as a line-out.  Thus we
		 * need to set hp_detect flag here to force to enable HP
		 * detection.
		 */
		spec->hp_detect = 1;
6461
		break;
6462 6463 6464 6465
	case STAC_HP_HDX:
		spec->num_dmics = 1;
		spec->num_dmuxes = 1;
		spec->num_smuxes = 1;
6466
		spec->gpio_led = 0x08;
6467 6468
		break;
	}
6469

6470
	if (hp_blike_system(codec->subsystem_id)) {
6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487
		pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
		if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
			get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER  ||
			get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) {
			/* It was changed in the BIOS to just satisfy MS DTM.
			 * Lets turn it back into slaved HP
			 */
			pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE))
					| (AC_JACK_HP_OUT <<
						AC_DEFCFG_DEVICE_SHIFT);
			pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC
							| AC_DEFCFG_SEQUENCE)))
								| 0x1f;
			snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg);
		}
	}

6488
	if (find_mute_led_cfg(codec, 1))
6489 6490 6491
		snd_printd("mute LED gpio %d polarity %d\n",
				spec->gpio_led,
				spec->gpio_led_polarity);
6492

6493
	if (spec->gpio_led) {
6494
		if (!spec->vref_mute_led_nid) {
6495 6496 6497 6498 6499 6500 6501
			spec->gpio_mask |= spec->gpio_led;
			spec->gpio_dir |= spec->gpio_led;
			spec->gpio_data |= spec->gpio_led;
		} else {
			codec->patch_ops.set_power_state =
					stac92xx_set_power_state;
		}
6502
	}
6503

6504
	spec->multiout.dac_nids = spec->dac_nids;
6505

6506
	err = stac92xx_parse_auto_config(codec);
6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520 6521
	if (!err) {
		if (spec->board_config < 0) {
			printk(KERN_WARNING "hda_codec: No auto-config is "
			       "available, default to model=ref\n");
			spec->board_config = STAC_92HD71BXX_REF;
			goto again;
		}
		err = -EINVAL;
	}

	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}

6522
	/* enable bass on HP dv7 */
6523 6524
	if (spec->board_config == STAC_HP_DV4 ||
	    spec->board_config == STAC_HP_DV5) {
6525 6526 6527 6528 6529 6530 6531
		unsigned int cap;
		cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
		cap &= AC_GPIO_IO_COUNT;
		if (cap >= 6)
			stac_add_hp_bass_switch(codec);
	}

6532 6533
	codec->proc_widget_hook = stac92hd7x_proc_hook;

6534
	return 0;
6535
}
6536

M
Matt 已提交
6537 6538 6539
static int patch_stac922x(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
6540
	int err;
M
Matt 已提交
6541

6542 6543 6544 6545
	err = alloc_stac_spec(codec, ARRAY_SIZE(stac922x_pin_nids),
			      stac922x_pin_nids);
	if (err < 0)
		return err;
M
Matt 已提交
6546

6547
	spec = codec->spec;
6548
	spec->linear_tone_beep = 1;
6549

6550 6551
	snd_hda_pick_fixup(codec, stac922x_models, stac922x_fixup_tbl,
			   stac922x_fixups);
M
Matt 已提交
6552

6553 6554
	spec->adc_nids = stac922x_adc_nids;
	spec->mux_nids = stac922x_mux_nids;
6555
	spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
6556
	spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
6557
	spec->num_dmics = 0;
6558
	spec->num_pwrs = 0;
6559

6560 6561 6562
	spec->num_caps = STAC922X_NUM_CAPS;
	spec->capvols = stac922x_capvols;
	spec->capsws = stac922x_capsws;
6563 6564

	spec->multiout.dac_nids = spec->dac_nids;
6565
	
6566 6567 6568 6569
	snd_hda_add_verbs(codec, stac922x_core_init);

	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);

6570
	err = stac92xx_parse_auto_config(codec);
6571
	if (!err)
6572
		err = -EINVAL;
6573 6574 6575 6576 6577 6578 6579
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}

	codec->patch_ops = stac92xx_patch_ops;

6580 6581 6582 6583 6584 6585 6586
	/* Fix Mux capture level; max to 2 */
	snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
				  (0 << AC_AMPCAP_OFFSET_SHIFT) |
				  (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
				  (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
				  (0 << AC_AMPCAP_MUTE_SHIFT));

6587 6588
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6589 6590 6591 6592 6593 6594 6595 6596
	return 0;
}

static int patch_stac927x(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
	int err;

6597 6598 6599 6600
	err = alloc_stac_spec(codec, ARRAY_SIZE(stac927x_pin_nids),
			      stac927x_pin_nids);
	if (err < 0)
		return err;
6601

6602
	spec = codec->spec;
6603
	spec->linear_tone_beep = 1;
6604
	codec->slave_dig_outs = stac927x_slave_dig_outs;
6605 6606 6607
	spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
							stac927x_models,
							stac927x_cfg_tbl);
6608
 again:
6609
	if (spec->board_config < 0)
6610 6611
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
			    codec->chip_name);
6612 6613
	else
		stac92xx_set_config_regs(codec,
6614
				stac927x_brd_tbl[spec->board_config]);
6615

6616
	spec->digbeep_nid = 0x23;
6617 6618 6619 6620
	spec->adc_nids = stac927x_adc_nids;
	spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
	spec->mux_nids = stac927x_mux_nids;
	spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
M
Matthew Ranostay 已提交
6621 6622
	spec->smux_nids = stac927x_smux_nids;
	spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
6623
	spec->spdif_labels = stac927x_spdif_labels;
6624
	spec->dac_list = stac927x_dac_nids;
6625 6626
	spec->multiout.dac_nids = spec->dac_nids;

6627 6628 6629 6630 6631 6632
	if (spec->board_config != STAC_D965_REF) {
		/* GPIO0 High = Enable EAPD */
		spec->eapd_mask = spec->gpio_mask = 0x01;
		spec->gpio_dir = spec->gpio_data = 0x01;
	}

6633
	switch (spec->board_config) {
6634 6635
	case STAC_D965_3ST:
	case STAC_D965_5ST:
6636 6637
		/* GPIO0 High = Enable EAPD */
		spec->num_dmics = 0;
6638
		spec->init = d965_core_init;
6639
		break;
6640
	case STAC_DELL_BIOS:
6641 6642 6643 6644
		switch (codec->subsystem_id) {
		case 0x10280209:
		case 0x1028022e:
			/* correct the device field to SPDIF out */
6645
			snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
6646
			break;
6647
		}
6648
		/* configure the analog microphone on some laptops */
6649
		snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
M
Matthew Ranostay 已提交
6650
		/* correct the front output jack as a hp out */
6651
		snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
M
Matthew Ranostay 已提交
6652
		/* correct the front input jack as a mic */
6653
		snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
M
Matthew Ranostay 已提交
6654
		/* fallthru */
6655
	case STAC_DELL_3ST:
6656 6657 6658 6659 6660
		if (codec->subsystem_id != 0x1028022f) {
			/* GPIO2 High = Enable EAPD */
			spec->eapd_mask = spec->gpio_mask = 0x04;
			spec->gpio_dir = spec->gpio_data = 0x04;
		}
6661 6662
		spec->dmic_nids = stac927x_dmic_nids;
		spec->num_dmics = STAC927X_NUM_DMICS;
M
Matthew Ranostay 已提交
6663

6664
		spec->init = dell_3st_core_init;
6665
		spec->dmux_nids = stac927x_dmux_nids;
6666
		spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
6667
		break;
6668 6669 6670 6671
	case STAC_927X_VOLKNOB:
		spec->num_dmics = 0;
		spec->init = stac927x_volknob_core_init;
		break;
6672
	default:
6673 6674
		spec->num_dmics = 0;
		spec->init = stac927x_core_init;
6675
		break;
6676 6677
	}

6678 6679 6680 6681
	spec->num_caps = STAC927X_NUM_CAPS;
	spec->capvols = stac927x_capvols;
	spec->capsws = stac927x_capsws;

6682
	spec->num_pwrs = 0;
6683
	spec->aloopback_ctl = stac927x_loopback;
6684 6685
	spec->aloopback_mask = 0x40;
	spec->aloopback_shift = 0;
M
Matthew Ranostay 已提交
6686
	spec->eapd_switch = 1;
6687

6688
	err = stac92xx_parse_auto_config(codec);
6689 6690 6691 6692 6693 6694 6695 6696 6697
	if (!err) {
		if (spec->board_config < 0) {
			printk(KERN_WARNING "hda_codec: No auto-config is "
			       "available, default to model=ref\n");
			spec->board_config = STAC_D965_REF;
			goto again;
		}
		err = -EINVAL;
	}
6698 6699 6700 6701
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}
M
Matt 已提交
6702 6703 6704

	codec->patch_ops = stac92xx_patch_ops;

6705 6706
	codec->proc_widget_hook = stac927x_proc_hook;

6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718
	/*
	 * !!FIXME!!
	 * The STAC927x seem to require fairly long delays for certain
	 * command sequences.  With too short delays (even if the answer
	 * is set to RIRB properly), it results in the silence output
	 * on some hardwares like Dell.
	 *
	 * The below flag enables the longer delay (see get_response
	 * in hda_intel.c).
	 */
	codec->bus->needs_damn_long_delay = 1;

6719 6720 6721 6722
	/* no jack detecion for ref-no-jd model */
	if (spec->board_config == STAC_D965_REF_NO_JD)
		spec->hp_detect = 0;

M
Matt 已提交
6723 6724 6725
	return 0;
}

6726 6727 6728
static int patch_stac9205(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
6729
	int err;
6730

6731 6732 6733 6734
	err = alloc_stac_spec(codec, ARRAY_SIZE(stac9205_pin_nids),
			      stac9205_pin_nids);
	if (err < 0)
		return err;
6735

6736
	spec = codec->spec;
6737
	spec->linear_tone_beep = 1;
6738 6739 6740

	snd_hda_pick_fixup(codec, stac9205_models, stac9205_fixup_tbl,
			   stac9205_fixups);
6741

6742
	spec->digbeep_nid = 0x23;
6743
	spec->adc_nids = stac9205_adc_nids;
6744
	spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
6745
	spec->mux_nids = stac9205_mux_nids;
6746
	spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
M
Matthew Ranostay 已提交
6747 6748
	spec->smux_nids = stac9205_smux_nids;
	spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
6749
	spec->dmic_nids = stac9205_dmic_nids;
6750
	spec->num_dmics = STAC9205_NUM_DMICS;
6751
	spec->dmux_nids = stac9205_dmux_nids;
6752
	spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
6753
	spec->num_pwrs = 0;
6754

6755
	snd_hda_add_verbs(codec, stac9205_core_init);
6756
	spec->aloopback_ctl = stac9205_loopback;
6757

6758 6759 6760 6761
	spec->num_caps = STAC9205_NUM_CAPS;
	spec->capvols = stac9205_capvols;
	spec->capsws = stac9205_capsws;

6762 6763
	spec->aloopback_mask = 0x40;
	spec->aloopback_shift = 0;
6764
	spec->multiout.dac_nids = spec->dac_nids;
6765
	
6766 6767 6768
	/* GPIO0 High = EAPD */
	spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
	spec->gpio_data = 0x01;
6769

6770 6771
	/* Turn on/off EAPD per HP plugging */
	spec->eapd_switch = 1;
6772

6773
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6774

6775
	err = stac92xx_parse_auto_config(codec);
6776
	if (!err)
6777
		err = -EINVAL;
6778 6779 6780 6781 6782 6783 6784
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}

	codec->patch_ops = stac92xx_patch_ops;

6785 6786
	codec->proc_widget_hook = stac9205_proc_hook;

6787 6788
	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6789 6790 6791
	return 0;
}

6792
/*
6793
 * STAC9872 hack
6794 6795
 */

6796
static const struct hda_verb stac9872_core_init[] = {
6797
	{0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
6798 6799 6800 6801
	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
	{}
};

6802
static const hda_nid_t stac9872_pin_nids[] = {
6803 6804 6805 6806
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
	0x11, 0x13, 0x14,
};

6807
static const hda_nid_t stac9872_adc_nids[] = {
6808 6809 6810
	0x8 /*,0x6*/
};

6811
static const hda_nid_t stac9872_mux_nids[] = {
6812 6813 6814
	0x15
};

6815
static const unsigned long stac9872_capvols[] = {
6816 6817 6818 6819
	HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
};
#define stac9872_capsws		stac9872_capvols

6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830
static const struct hda_pintbl stac9872_vaio_pin_configs[] = {
	{ 0x0a, 0x03211020 },
	{ 0x0b, 0x411111f0 },
	{ 0x0c, 0x411111f0 },
	{ 0x0d, 0x03a15030 },
	{ 0x0e, 0x411111f0 },
	{ 0x0f, 0x90170110 },
	{ 0x11, 0x411111f0 },
	{ 0x13, 0x411111f0 },
	{ 0x14, 0x90a7013e },
	{}
6831 6832
};

6833 6834 6835
static const struct hda_model_fixup stac9872_models[] = {
	{ .id = STAC_9872_VAIO, .name = "vaio" },
	{}
6836 6837
};

6838 6839 6840 6841 6842
static const struct hda_fixup stac9872_fixups[] = {
	[STAC_9872_VAIO] = {
		.type = HDA_FIXUP_PINS,
		.v.pins = stac9872_vaio_pin_configs,
	},
6843 6844
};

6845
static const struct snd_pci_quirk stac9872_fixup_tbl[] = {
6846 6847
	SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
			   "Sony VAIO F/S", STAC_9872_VAIO),
6848 6849 6850
	{} /* terminator */
};

6851
static int patch_stac9872(struct hda_codec *codec)
6852 6853
{
	struct sigmatel_spec *spec;
6854
	int err;
6855

6856 6857 6858 6859 6860 6861
	err = alloc_stac_spec(codec, ARRAY_SIZE(stac9872_pin_nids),
			      stac9872_pin_nids);
	if (err < 0)
		return err;

	spec = codec->spec;
6862
	spec->linear_tone_beep = 1;
6863

6864 6865
	snd_hda_pick_fixup(codec, stac9872_models, stac9872_fixup_tbl,
			   stac9872_fixups);
6866

6867 6868 6869 6870 6871
	spec->multiout.dac_nids = spec->dac_nids;
	spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
	spec->adc_nids = stac9872_adc_nids;
	spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
	spec->mux_nids = stac9872_mux_nids;
6872 6873 6874
	spec->num_caps = 1;
	spec->capvols = stac9872_capvols;
	spec->capsws = stac9872_capsws;
6875 6876 6877
	snd_hda_add_verbs(codec, stac9872_core_init);

	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
6878

6879
	err = stac92xx_parse_auto_config(codec);
6880 6881 6882 6883 6884 6885
	if (err < 0) {
		stac92xx_free(codec);
		return -EINVAL;
	}
	spec->input_mux = &spec->private_imux;
	codec->patch_ops = stac92xx_patch_ops;
6886 6887 6888

	snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);

6889 6890 6891 6892
	return 0;
}


M
Matt 已提交
6893 6894 6895
/*
 * patch entries
 */
6896
static const struct hda_codec_preset snd_hda_preset_sigmatel[] = {
M
Matt 已提交
6897 6898 6899 6900 6901 6902 6903
 	{ .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
 	{ .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
 	{ .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
 	{ .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
 	{ .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
 	{ .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
 	{ .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
6904 6905 6906 6907 6908 6909
 	{ .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
 	{ .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
 	{ .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
 	{ .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
 	{ .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
 	{ .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
6910 6911 6912 6913 6914 6915 6916 6917 6918 6919
 	{ .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
 	{ .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
 	{ .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
 	{ .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
 	{ .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
 	{ .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
 	{ .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
 	{ .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
 	{ .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
 	{ .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
6920 6921 6922 6923 6924 6925
	{ .id = 0x83847632, .name = "STAC9202",  .patch = patch_stac925x },
	{ .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
	{ .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
	{ .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
	{ .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
	{ .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
6926 6927
	{ .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
	{ .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
6928 6929 6930 6931 6932 6933 6934
 	/* The following does not take into account .id=0x83847661 when subsys =
 	 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
 	 * currently not fully supported.
 	 */
 	{ .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
 	{ .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
 	{ .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
6935
	{ .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
6936 6937 6938 6939 6940 6941 6942 6943
 	{ .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
 	{ .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
 	{ .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
 	{ .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
 	{ .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
 	{ .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
 	{ .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
 	{ .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
6944
	{ .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
6945
	{ .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
6946
	{ .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
6947
	{ .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
M
Matthew Ranostay 已提交
6948
	{ .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
6949 6950
	{ .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
6951 6952 6953 6954
	{ .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx},
6955
	{ .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
6956 6957
	{ .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
	{ .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
6958
	{ .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
6959 6960 6961 6962 6963 6964 6965 6966
	{ .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
	{ .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
	{ .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
	{ .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
	{ .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
	{ .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
	{ .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
	{ .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6967 6968 6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981
	{ .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx },
	{ .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx },
6982
	{ .id = 0x111d76df, .name = "92HD93BXX", .patch = patch_stac92hd83xxx},
6983
	{ .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx},
6984 6985
	{ .id = 0x111d76e3, .name = "92HD98BXX", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76e5, .name = "92HD99BXX", .patch = patch_stac92hd83xxx},
6986
	{ .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx},
6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998
	{ .id = 0x111d76e8, .name = "92HD66B1X5", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76e9, .name = "92HD66B2X5", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76ea, .name = "92HD66B3X5", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76eb, .name = "92HD66C1X5", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76ec, .name = "92HD66C2X5", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76ed, .name = "92HD66C3X5", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76ee, .name = "92HD66B1X3", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76ef, .name = "92HD66B2X3", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76f0, .name = "92HD66B3X3", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76f1, .name = "92HD66C1X3", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76f2, .name = "92HD66C2X3", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d76f3, .name = "92HD66C3/65", .patch = patch_stac92hd83xxx},
M
Matt 已提交
6999 7000
	{} /* terminator */
};
7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024

MODULE_ALIAS("snd-hda-codec-id:8384*");
MODULE_ALIAS("snd-hda-codec-id:111d*");

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec");

static struct hda_codec_preset_list sigmatel_list = {
	.preset = snd_hda_preset_sigmatel,
	.owner = THIS_MODULE,
};

static int __init patch_sigmatel_init(void)
{
	return snd_hda_add_codec_preset(&sigmatel_list);
}

static void __exit patch_sigmatel_exit(void)
{
	snd_hda_delete_codec_preset(&sigmatel_list);
}

module_init(patch_sigmatel_init)
module_exit(patch_sigmatel_exit)