patch_sigmatel.c 160.6 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 31
 *
 * 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>
#include <sound/core.h>
32
#include <sound/asoundef.h>
33
#include <sound/jack.h>
M
Matt 已提交
34 35
#include "hda_codec.h"
#include "hda_local.h"
36
#include "hda_beep.h"
M
Matt 已提交
37

38 39 40 41 42 43
enum {
	STAC_VREF_EVENT	= 1,
	STAC_INSERT_EVENT,
	STAC_PWR_EVENT,
	STAC_HP_EVENT,
};
44

45 46
enum {
	STAC_REF,
47
	STAC_9200_OQO,
48 49 50 51 52 53 54 55 56 57
	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,
58 59
	STAC_9200_M4,
	STAC_9200_M4_2,
60
	STAC_9200_PANASONIC,
61 62 63 64 65
	STAC_9200_MODELS
};

enum {
	STAC_9205_REF,
66
	STAC_9205_DELL_M42,
67 68
	STAC_9205_DELL_M43,
	STAC_9205_DELL_M44,
69 70 71
	STAC_9205_MODELS
};

72
enum {
73
	STAC_92HD73XX_NO_JD, /* no jack-detection */
74
	STAC_92HD73XX_REF,
75 76 77
	STAC_DELL_M6_AMIC,
	STAC_DELL_M6_DMIC,
	STAC_DELL_M6_BOTH,
78
	STAC_DELL_EQ,
79 80 81
	STAC_92HD73XX_MODELS
};

82 83 84 85 86
enum {
	STAC_92HD83XXX_REF,
	STAC_92HD83XXX_MODELS
};

87 88
enum {
	STAC_92HD71BXX_REF,
89 90
	STAC_DELL_M4_1,
	STAC_DELL_M4_2,
91
	STAC_DELL_M4_3,
92
	STAC_HP_M4,
T
Takashi Iwai 已提交
93
	STAC_HP_DV5,
94 95 96
	STAC_92HD71BXX_MODELS
};

97 98
enum {
	STAC_925x_REF,
99 100 101
	STAC_M1,
	STAC_M1_2,
	STAC_M2,
102
	STAC_M2_2,
103 104 105
	STAC_M3,
	STAC_M5,
	STAC_M6,
106 107 108
	STAC_925x_MODELS
};

109 110 111 112
enum {
	STAC_D945_REF,
	STAC_D945GTP3,
	STAC_D945GTP5,
113 114 115 116 117
	STAC_INTEL_MAC_V1,
	STAC_INTEL_MAC_V2,
	STAC_INTEL_MAC_V3,
	STAC_INTEL_MAC_V4,
	STAC_INTEL_MAC_V5,
118 119 120
	STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
			      * is given, one of the above models will be
			      * chosen according to the subsystem id. */
121
	/* for backward compatibility */
122
	STAC_MACMINI,
123
	STAC_MACBOOK,
124 125
	STAC_MACBOOK_PRO_V1,
	STAC_MACBOOK_PRO_V2,
126
	STAC_IMAC_INTEL,
127
	STAC_IMAC_INTEL_20,
128
	STAC_ECS_202,
129 130 131 132
	STAC_922X_DELL_D81,
	STAC_922X_DELL_D82,
	STAC_922X_DELL_M81,
	STAC_922X_DELL_M82,
133 134 135 136
	STAC_922X_MODELS
};

enum {
137
	STAC_D965_REF_NO_JD, /* no jack-detection */
138 139 140
	STAC_D965_REF,
	STAC_D965_3ST,
	STAC_D965_5ST,
141
	STAC_DELL_3ST,
142
	STAC_DELL_BIOS,
143 144
	STAC_927X_MODELS
};
145

146 147
struct sigmatel_event {
	hda_nid_t nid;
148 149
	unsigned char type;
	unsigned char tag;
150 151 152 153 154 155 156 157 158
	int data;
};

struct sigmatel_jack {
	hda_nid_t nid;
	int type;
	struct snd_jack *jack;
};

M
Matt 已提交
159
struct sigmatel_spec {
160
	struct snd_kcontrol_new *mixers[4];
161 162
	unsigned int num_mixers;

163
	int board_config;
M
Matthew Ranostay 已提交
164
	unsigned int eapd_switch: 1;
165
	unsigned int surr_switch: 1;
166
	unsigned int alt_switch: 1;
167
	unsigned int hp_detect: 1;
168
	unsigned int spdif_mute: 1;
169

170
	/* gpio lines */
171
	unsigned int eapd_mask;
172 173 174 175 176
	unsigned int gpio_mask;
	unsigned int gpio_dir;
	unsigned int gpio_data;
	unsigned int gpio_mute;

M
Matthew Ranostay 已提交
177 178 179
	/* stream */
	unsigned int stream_delay;

180
	/* analog loopback */
181 182
	unsigned char aloopback_mask;
	unsigned char aloopback_shift;
183

184 185
	/* power management */
	unsigned int num_pwrs;
186
	unsigned int *pwr_mapping;
187
	hda_nid_t *pwr_nids;
188
	hda_nid_t *dac_list;
189

190 191 192 193 194 195
	/* jack detection */
	struct snd_array jacks;

	/* events */
	struct snd_array events;

M
Matt 已提交
196
	/* playback */
197
	struct hda_input_mux *mono_mux;
198
	struct hda_input_mux *amp_mux;
199
	unsigned int cur_mmux;
M
Matt 已提交
200
	struct hda_multi_out multiout;
201
	hda_nid_t dac_nids[5];
202 203
	hda_nid_t hp_dacs[5];
	hda_nid_t speaker_dacs[5];
M
Matt 已提交
204 205 206 207

	/* capture */
	hda_nid_t *adc_nids;
	unsigned int num_adcs;
208 209
	hda_nid_t *mux_nids;
	unsigned int num_muxes;
210 211
	hda_nid_t *dmic_nids;
	unsigned int num_dmics;
212
	hda_nid_t *dmux_nids;
213
	unsigned int num_dmuxes;
M
Matthew Ranostay 已提交
214 215
	hda_nid_t *smux_nids;
	unsigned int num_smuxes;
216
	const char **spdif_labels;
M
Matthew Ranostay 已提交
217

218
	hda_nid_t dig_in_nid;
219
	hda_nid_t mono_nid;
220 221
	hda_nid_t anabeep_nid;
	hda_nid_t digbeep_nid;
M
Matt 已提交
222 223 224 225 226 227 228 229

	/* pin widgets */
	hda_nid_t *pin_nids;
	unsigned int num_pins;
	unsigned int *pin_configs;

	/* codec specific stuff */
	struct hda_verb *init;
230
	struct snd_kcontrol_new *mixer;
M
Matt 已提交
231 232

	/* capture source */
233
	struct hda_input_mux *dinput_mux;
234
	unsigned int cur_dmux[2];
235
	struct hda_input_mux *input_mux;
236
	unsigned int cur_mux[3];
M
Matthew Ranostay 已提交
237 238
	struct hda_input_mux *sinput_mux;
	unsigned int cur_smux[2];
M
Matthew Ranostay 已提交
239 240 241
	unsigned int cur_amux;
	hda_nid_t *amp_nids;
	unsigned int num_amps;
M
Matthew Ranostay 已提交
242
	unsigned int powerdown_adcs;
M
Matt 已提交
243

244 245
	/* i/o switches */
	unsigned int io_switch[2];
246
	unsigned int clfe_swap;
247 248 249
	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 */
250
	unsigned int aloopback;
M
Matt 已提交
251

252 253 254 255
	struct hda_pcm pcm_rec[2];	/* PCM information */

	/* dynamic controls and input_mux */
	struct auto_pin_cfg autocfg;
256
	struct snd_array kctls;
257
	struct hda_input_mux private_dimux;
258
	struct hda_input_mux private_imux;
M
Matthew Ranostay 已提交
259
	struct hda_input_mux private_smux;
260
	struct hda_input_mux private_amp_mux;
261
	struct hda_input_mux private_mono_mux;
M
Matt 已提交
262 263 264 265 266 267 268 269 270 271 272 273 274 275
};

static hda_nid_t stac9200_adc_nids[1] = {
        0x03,
};

static hda_nid_t stac9200_mux_nids[1] = {
        0x0c,
};

static hda_nid_t stac9200_dac_nids[1] = {
        0x02,
};

276 277 278 279 280
static hda_nid_t stac92hd73xx_pwr_nids[8] = {
	0x0a, 0x0b, 0x0c, 0xd, 0x0e,
	0x0f, 0x10, 0x11
};

281 282 283 284
static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
	0x26, 0,
};

285 286 287 288
static hda_nid_t stac92hd73xx_adc_nids[2] = {
	0x1a, 0x1b
};

M
Matthew Ranostay 已提交
289 290 291
#define DELL_M6_AMP 2
static hda_nid_t stac92hd73xx_amp_nids[3] = {
	0x0b, 0x0c, 0x0e
292 293
};

294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
#define STAC92HD73XX_NUM_DMICS	2
static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
	0x13, 0x14, 0
};

#define STAC92HD73_DAC_COUNT 5

static hda_nid_t stac92hd73xx_mux_nids[4] = {
	0x28, 0x29, 0x2a, 0x2b,
};

static hda_nid_t stac92hd73xx_dmux_nids[2] = {
	0x20, 0x21,
};

M
Matthew Ranostay 已提交
309 310 311 312
static hda_nid_t stac92hd73xx_smux_nids[2] = {
	0x22, 0x23,
};

313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
#define STAC92HD83XXX_NUM_DMICS	2
static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = {
	0x11, 0x12, 0
};

#define STAC92HD83_DAC_COUNT 3

static hda_nid_t stac92hd83xxx_dmux_nids[2] = {
	0x17, 0x18,
};

static hda_nid_t stac92hd83xxx_adc_nids[2] = {
	0x15, 0x16,
};

static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
	0xa, 0xb, 0xd, 0xe,
};

332 333 334 335
static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
	0x1e, 0,
};

336
static unsigned int stac92hd83xxx_pwr_mapping[4] = {
337
	0x03, 0x0c, 0x20, 0x40,
338 339
};

340
static hda_nid_t stac92hd83xxx_amp_nids[1] = {
341 342 343
	0xc,
};

344 345 346 347
static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
	0x0a, 0x0d, 0x0f
};

348 349 350 351 352 353 354 355
static hda_nid_t stac92hd71bxx_adc_nids[2] = {
	0x12, 0x13,
};

static hda_nid_t stac92hd71bxx_mux_nids[2] = {
	0x1a, 0x1b
};

356 357
static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
	0x1c, 0x1d,
358 359
};

M
Matthew Ranostay 已提交
360 361 362 363
static hda_nid_t stac92hd71bxx_smux_nids[2] = {
	0x24, 0x25,
};

364 365 366 367 368
#define STAC92HD71BXX_NUM_DMICS	2
static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
	0x18, 0x19, 0
};

369 370 371 372
static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
	0x22, 0
};

373 374 375 376 377 378 379 380 381 382 383 384
static hda_nid_t stac925x_adc_nids[1] = {
        0x03,
};

static hda_nid_t stac925x_mux_nids[1] = {
        0x0f,
};

static hda_nid_t stac925x_dac_nids[1] = {
        0x02,
};

385 386 387
#define STAC925X_NUM_DMICS	1
static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
	0x15, 0
388 389
};

390 391 392 393
static hda_nid_t stac925x_dmux_nids[1] = {
	0x14,
};

M
Matt 已提交
394 395 396 397 398 399 400 401
static hda_nid_t stac922x_adc_nids[2] = {
        0x06, 0x07,
};

static hda_nid_t stac922x_mux_nids[2] = {
        0x12, 0x13,
};

402 403 404 405 406 407 408 409
static hda_nid_t stac927x_adc_nids[3] = {
        0x07, 0x08, 0x09
};

static hda_nid_t stac927x_mux_nids[3] = {
        0x15, 0x16, 0x17
};

M
Matthew Ranostay 已提交
410 411 412 413
static hda_nid_t stac927x_smux_nids[1] = {
	0x21,
};

414 415 416 417
static hda_nid_t stac927x_dac_nids[6] = {
	0x02, 0x03, 0x04, 0x05, 0x06, 0
};

418 419 420 421
static hda_nid_t stac927x_dmux_nids[1] = {
	0x1b,
};

422 423 424 425 426
#define STAC927X_NUM_DMICS 2
static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
	0x13, 0x14, 0
};

427 428 429 430 431
static const char *stac927x_spdif_labels[5] = {
	"Digital Playback", "ADAT", "Analog Mux 1",
	"Analog Mux 2", "Analog Mux 3"
};

432 433 434 435 436 437 438 439
static hda_nid_t stac9205_adc_nids[2] = {
        0x12, 0x13
};

static hda_nid_t stac9205_mux_nids[2] = {
        0x19, 0x1a
};

440
static hda_nid_t stac9205_dmux_nids[1] = {
441
	0x1d,
442 443
};

M
Matthew Ranostay 已提交
444 445 446 447
static hda_nid_t stac9205_smux_nids[1] = {
	0x21,
};

448 449 450
#define STAC9205_NUM_DMICS	2
static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
        0x17, 0x18, 0
451 452
};

453
static hda_nid_t stac9200_pin_nids[8] = {
454 455
	0x08, 0x09, 0x0d, 0x0e, 
	0x0f, 0x10, 0x11, 0x12,
M
Matt 已提交
456 457
};

458 459 460 461 462
static hda_nid_t stac925x_pin_nids[8] = {
	0x07, 0x08, 0x0a, 0x0b, 
	0x0c, 0x0d, 0x10, 0x11,
};

M
Matt 已提交
463 464 465 466 467
static hda_nid_t stac922x_pin_nids[10] = {
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x15, 0x1b,
};

468
static hda_nid_t stac92hd73xx_pin_nids[13] = {
469 470
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x12, 0x13,
M
Matthew Ranostay 已提交
471
	0x14, 0x22, 0x23
472 473
};

474 475 476 477 478
static hda_nid_t stac92hd83xxx_pin_nids[14] = {
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x12, 0x13,
	0x1d, 0x1e, 0x1f, 0x20
};
479
static hda_nid_t stac92hd71bxx_pin_nids[11] = {
480 481
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x14, 0x18, 0x19, 0x1e,
482
	0x1f,
483 484
};

485 486 487 488 489 490
static hda_nid_t stac927x_pin_nids[14] = {
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x12, 0x13,
	0x14, 0x21, 0x22, 0x23,
};

491 492 493 494 495 496
static hda_nid_t stac9205_pin_nids[12] = {
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x14, 0x16, 0x17, 0x18,
	0x21, 0x22,
};

497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
#define stac92xx_amp_volume_info snd_hda_mixer_amp_volume_info

static int stac92xx_amp_volume_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;
	hda_nid_t nid = spec->amp_nids[spec->cur_amux];

	kcontrol->private_value ^= get_amp_nid(kcontrol);
	kcontrol->private_value |= nid;

	return snd_hda_mixer_amp_volume_get(kcontrol, ucontrol);
}

static int stac92xx_amp_volume_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 = spec->amp_nids[spec->cur_amux];

	kcontrol->private_value ^= get_amp_nid(kcontrol);
	kcontrol->private_value |= nid;

	return snd_hda_mixer_amp_volume_put(kcontrol, ucontrol);
}

525 526 527 528 529 530 531 532 533 534 535 536 537
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;
538
	unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
539

540
	ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
541 542 543 544 545 546 547 548
	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;
549
	unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
550 551

	return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
552
			spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
553 554
}

M
Matthew Ranostay 已提交
555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
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;
579
	struct hda_input_mux *smux = &spec->private_smux;
M
Matthew Ranostay 已提交
580
	unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
581 582
	int err, val;
	hda_nid_t nid;
M
Matthew Ranostay 已提交
583

584
	err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
M
Matthew Ranostay 已提交
585
			spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
586 587 588 589 590 591 592 593 594
	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)
595
			val = HDA_AMP_MUTE;
596
		else
597
			val = 0;
598
		/* un/mute SPDIF out */
599 600
		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
					 HDA_AMP_MUTE, val);
601 602
	}
	return 0;
M
Matthew Ranostay 已提交
603 604
}

605
static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
M
Matt 已提交
606 607 608
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
609
	return snd_hda_input_mux_info(spec->input_mux, uinfo);
M
Matt 已提交
610 611
}

612
static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
M
Matt 已提交
613 614 615 616 617 618 619 620 621
{
	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;
}

622
static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
M
Matt 已提交
623 624 625 626 627
{
	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);

628
	return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol,
M
Matt 已提交
629 630 631
				     spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]);
}

632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
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);
}

660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
static int stac92xx_amp_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->amp_mux, uinfo);
}

static int stac92xx_amp_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_amux;
	return 0;
}

static int stac92xx_amp_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;
	struct snd_kcontrol *ctl =
		snd_hda_find_mixer_ctl(codec, "Amp Capture Volume");
	if (!ctl)
		return -EINVAL;

	snd_ctl_notify(codec->bus->card, SNDRV_CTL_EVENT_MASK_VALUE |
		SNDRV_CTL_EVENT_MASK_INFO, &ctl->id);

	return snd_hda_input_mux_put(codec, spec->amp_mux, ucontrol,
				     0, &spec->cur_amux);
}

695 696 697 698 699 700
#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);
701
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
702 703
	struct sigmatel_spec *spec = codec->spec;

704 705
	ucontrol->value.integer.value[0] = !!(spec->aloopback &
					      (spec->aloopback_mask << idx));
706 707 708 709 710 711 712 713
	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;
714
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
715
	unsigned int dac_mode;
716
	unsigned int val, idx_val;
717

718 719 720 721 722
	idx_val = spec->aloopback_mask << idx;
	if (ucontrol->value.integer.value[0])
		val = spec->aloopback | idx_val;
	else
		val = spec->aloopback & ~idx_val;
723
	if (spec->aloopback == val)
724 725
		return 0;

726
	spec->aloopback = val;
727

728 729 730
	/* Only return the bits defined by the shift value of the
	 * first two bytes of the mask
	 */
731
	dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
732 733
				      kcontrol->private_value & 0xFFFF, 0x0);
	dac_mode >>= spec->aloopback_shift;
734

735
	if (spec->aloopback & idx_val) {
736
		snd_hda_power_up(codec);
737
		dac_mode |= idx_val;
738 739
	} else {
		snd_hda_power_down(codec);
740
		dac_mode &= ~idx_val;
741 742 743 744 745 746 747 748
	}

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

	return 1;
}

749
static struct hda_verb stac9200_core_init[] = {
M
Matt 已提交
750
	/* set dac0mux for dac converter */
751
	{ 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
M
Matt 已提交
752 753 754
	{}
};

755 756 757 758 759 760 761
static struct hda_verb stac9200_eapd_init[] = {
	/* set dac0mux for dac converter */
	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
	{0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
	{}
};

762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
static struct hda_verb stac92hd73xx_6ch_core_init[] = {
	/* set master volume and direct control */
	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
	/* setup adcs to point to mixer */
	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
	{ 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	/* setup import muxs */
	{ 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
	{}
};

779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
static struct hda_verb dell_eq_core_init[] = {
	/* set master volume to max value without distortion
	 * and direct control */
	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
	/* setup adcs to point to mixer */
	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
	{ 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
	/* setup import muxs */
	{ 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
	{}
};

794
static struct hda_verb dell_m6_core_init[] = {
795
	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
796 797 798 799 800 801 802 803 804 805 806
	/* setup adcs to point to mixer */
	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
	{ 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
	/* setup import muxs */
	{ 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00},
	{}
};

807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
static struct hda_verb stac92hd73xx_8ch_core_init[] = {
	/* set master volume and direct control */
	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
	/* setup adcs to point to mixer */
	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
	{ 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	/* setup import muxs */
	{ 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
	{}
};

static struct hda_verb stac92hd73xx_10ch_core_init[] = {
	/* set master volume and direct control */
	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
	/* dac3 is connected to import3 mux */
	{ 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f},
	/* setup adcs to point to mixer */
	{ 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b},
	{ 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b},
	{ 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	{ 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	{ 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
	/* setup import muxs */
	{ 0x28, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x29, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01},
	{ 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03},
	{}
};

843 844 845 846 847 848 849
static struct hda_verb stac92hd83xxx_core_init[] = {
	{ 0xa, AC_VERB_SET_CONNECT_SEL, 0x0},
	{ 0xb, AC_VERB_SET_CONNECT_SEL, 0x0},
	{ 0xd, AC_VERB_SET_CONNECT_SEL, 0x1},

	/* power state controls amps */
	{ 0x01, AC_VERB_SET_EAPD, 1 << 2},
850
	{}
851 852
};

853
static struct hda_verb stac92hd71bxx_core_init[] = {
854 855 856 857 858 859
	/* set master volume and direct control */
	{ 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
	/* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */
	{ 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	{ 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
860
	{}
861 862
};

863
#define HD_DISABLE_PORTF 2
864
static struct hda_verb stac92hd71bxx_analog_core_init[] = {
865 866 867 868 869 870 871 872
	/* start of config #1 */

	/* connect port 0f to audio mixer */
	{ 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2},
	/* unmute right and left channels for node 0x0f */
	{ 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	/* start of config #2 */

873 874
	/* set master volume and direct control */
	{ 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
875
	/* unmute right and left channels for nodes 0x0a, 0xd */
876 877 878 879 880
	{ 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	{}
};

881 882 883
static struct hda_verb stac925x_core_init[] = {
	/* set dac0mux for dac converter */
	{ 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
884 885
	/* mute the master volume */
	{ 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
886 887 888
	{}
};

889
static struct hda_verb stac922x_core_init[] = {
M
Matt 已提交
890
	/* set master volume and direct control */	
891
	{ 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
M
Matt 已提交
892 893 894
	{}
};

895
static struct hda_verb d965_core_init[] = {
896
	/* set master volume and direct control */	
897
	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
898 899 900 901 902 903 904
	/* unmute node 0x1b */
	{ 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
	/* select node 0x03 as DAC */	
	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
	{}
};

905 906 907
static struct hda_verb stac927x_core_init[] = {
	/* set master volume and direct control */	
	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
908 909
	/* enable analog pc beep path */
	{ 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
910 911 912
	{}
};

913 914 915
static struct hda_verb stac9205_core_init[] = {
	/* set master volume and direct control */	
	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
916 917
	/* enable analog pc beep path */
	{ 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
918 919 920
	{}
};

921 922 923 924 925 926 927 928 929 930
#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, \
	}

931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
#define STAC_AMP_MUX \
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = "Amp Selector Capture Switch", \
		.count = 1, \
		.info = stac92xx_amp_mux_enum_info, \
		.get = stac92xx_amp_mux_enum_get, \
		.put = stac92xx_amp_mux_enum_put, \
	}

#define STAC_AMP_VOL(xname, nid, chs, idx, dir) \
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = xname, \
		.index = 0, \
		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
			SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
			SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \
		.info = stac92xx_amp_volume_info, \
		.get = stac92xx_amp_volume_get, \
		.put = stac92xx_amp_volume_put, \
		.tlv = { .c = snd_hda_mixer_amp_tlv }, \
		.private_value = HDA_COMPOSE_AMP_VAL(nid, chs, idx, dir) \
	}

956
#define STAC_INPUT_SOURCE(cnt) \
957 958 959
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = "Input Source", \
960
		.count = cnt, \
961 962 963 964 965
		.info = stac92xx_mux_enum_info, \
		.get = stac92xx_mux_enum_get, \
		.put = stac92xx_mux_enum_put, \
	}

966
#define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
967 968 969
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name  = "Analog Loopback", \
970
		.count = cnt, \
971 972 973 974 975 976
		.info  = stac92xx_aloopback_info, \
		.get   = stac92xx_aloopback_get, \
		.put   = stac92xx_aloopback_put, \
		.private_value = verb_read | (verb_write << 16), \
	}

977
static struct snd_kcontrol_new stac9200_mixer[] = {
M
Matt 已提交
978 979
	HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
980
	STAC_INPUT_SOURCE(1),
M
Matt 已提交
981 982 983 984 985
	HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
	{ } /* end */
};

M
Matthew Ranostay 已提交
986
#define DELL_M6_MIXER 6
987
static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = {
M
Matthew Ranostay 已提交
988
	/* start of config #1 */
989 990 991 992 993 994
	HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
	HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),

	HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
	HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),

M
Matthew Ranostay 已提交
995 996 997 998 999 1000 1001
	HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
	HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),

	/* start of config #2 */
	HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
	HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),

1002 1003 1004
	HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
	HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),

M
Matthew Ranostay 已提交
1005 1006 1007 1008 1009 1010 1011 1012
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),

1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
	{ } /* end */
};

static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = {
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
	HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),

	HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
	HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),

	HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
	HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),

	HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
	HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),

	HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
	HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
	{ } /* end */
};

static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = {
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT),
	HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT),

	HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT),
	HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT),

	HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT),
	HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT),

	HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT),
	HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT),

	HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT),
	HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT),
	{ } /* end */
};

1068 1069 1070 1071 1072 1073 1074 1075

static struct snd_kcontrol_new stac92hd83xxx_mixer[] = {
	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_OUTPUT),

1076 1077
	HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x1b, 0x3, HDA_INPUT),
	HDA_CODEC_MUTE("DAC0 Capture Switch", 0x1b, 0x3, HDA_INPUT),
1078

1079 1080
	HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x1b, 0x4, HDA_INPUT),
	HDA_CODEC_MUTE("DAC1 Capture Switch", 0x1b, 0x4, HDA_INPUT),
1081

1082 1083
	HDA_CODEC_VOLUME("Front Mic Capture Volume", 0x1b, 0x0, HDA_INPUT),
	HDA_CODEC_MUTE("Front Mic Capture Switch", 0x1b, 0x0, HDA_INPUT),
1084

1085 1086
	HDA_CODEC_VOLUME("Line In Capture Volume", 0x1b, 0x2, HDA_INPUT),
	HDA_CODEC_MUTE("Line In Capture Switch", 0x1b, 0x2, HDA_INPUT),
1087 1088

	/*
1089 1090
	HDA_CODEC_VOLUME("Mic Capture Volume", 0x1b, 0x1, HDA_INPUT),
	HDA_CODEC_MUTE("Mic Capture Switch", 0x1b 0x1, HDA_INPUT),
1091 1092 1093 1094
	*/
	{ } /* end */
};

1095
static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = {
1096
	STAC_INPUT_SOURCE(2),
1097
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),
1098

1099 1100 1101 1102 1103
	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
1104 1105
	/* analog pc-beep replaced with digital beep support */
	/*
M
Matthew Ranostay 已提交
1106 1107
	HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT),
	HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT),
1108
	*/
M
Matthew Ranostay 已提交
1109

1110 1111
	HDA_CODEC_MUTE("Import0 Mux Capture Switch", 0x17, 0x0, HDA_INPUT),
	HDA_CODEC_VOLUME("Import0 Mux Capture Volume", 0x17, 0x0, HDA_INPUT),
1112

1113 1114
	HDA_CODEC_MUTE("Import1 Mux Capture Switch", 0x17, 0x1, HDA_INPUT),
	HDA_CODEC_VOLUME("Import1 Mux Capture Volume", 0x17, 0x1, HDA_INPUT),
1115 1116 1117 1118 1119 1120

	HDA_CODEC_MUTE("DAC0 Capture Switch", 0x17, 0x3, HDA_INPUT),
	HDA_CODEC_VOLUME("DAC0 Capture Volume", 0x17, 0x3, HDA_INPUT),

	HDA_CODEC_MUTE("DAC1 Capture Switch", 0x17, 0x4, HDA_INPUT),
	HDA_CODEC_VOLUME("DAC1 Capture Volume", 0x17, 0x4, HDA_INPUT),
1121 1122 1123
	{ } /* end */
};

1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
static struct snd_kcontrol_new stac92hd71bxx_mixer[] = {
	STAC_INPUT_SOURCE(2),
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT),
	{ } /* end */
};

1136
static struct snd_kcontrol_new stac925x_mixer[] = {
1137 1138
	HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1139
	STAC_INPUT_SOURCE(1),
1140
	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT),
1141
	HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT),
1142 1143 1144
	{ } /* end */
};

1145 1146
static struct snd_kcontrol_new stac9205_mixer[] = {
	STAC_INPUT_SOURCE(2),
1147
	STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1148 1149 1150 1151 1152 1153

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT),
M
Matt 已提交
1154 1155 1156
	{ } /* end */
};

1157
/* This needs to be generated dynamically based on sequence */
1158 1159 1160 1161 1162 1163 1164
static struct snd_kcontrol_new stac922x_mixer[] = {
	STAC_INPUT_SOURCE(2),
	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT),
1165 1166 1167
	{ } /* end */
};

1168

T
Takashi Iwai 已提交
1169
static struct snd_kcontrol_new stac927x_mixer[] = {
1170
	STAC_INPUT_SOURCE(3),
1171
	STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1172

1173 1174 1175 1176 1177 1178 1179 1180
	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT),

	HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT),
	HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT),
1181 1182 1183
	{ } /* end */
};

1184 1185 1186 1187 1188 1189 1190 1191 1192
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 已提交
1193 1194
static struct snd_kcontrol_new stac_smux_mixer = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1195
	.name = "IEC958 Playback Source",
M
Matthew Ranostay 已提交
1196 1197 1198 1199 1200 1201
	/* count set later */
	.info = stac92xx_smux_enum_info,
	.get = stac92xx_smux_enum_get,
	.put = stac92xx_smux_enum_put,
};

1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
static const char *slave_vols[] = {
	"Front Playback Volume",
	"Surround Playback Volume",
	"Center Playback Volume",
	"LFE Playback Volume",
	"Side Playback Volume",
	"Headphone Playback Volume",
	"Headphone Playback Volume",
	"Speaker Playback Volume",
	"External Speaker Playback Volume",
	"Speaker2 Playback Volume",
	NULL
};

static const char *slave_sws[] = {
	"Front Playback Switch",
	"Surround Playback Switch",
	"Center Playback Switch",
	"LFE Playback Switch",
	"Side Playback Switch",
	"Headphone Playback Switch",
	"Headphone Playback Switch",
	"Speaker Playback Switch",
	"External Speaker Playback Switch",
	"Speaker2 Playback Switch",
1227
	"IEC958 Playback Switch",
1228 1229 1230
	NULL
};

1231
static void stac92xx_free_kctls(struct hda_codec *codec);
1232
static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1233

M
Matt 已提交
1234 1235 1236
static int stac92xx_build_controls(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
1237 1238
	struct auto_pin_cfg *cfg = &spec->autocfg;
	hda_nid_t nid;
M
Matt 已提交
1239
	int err;
1240
	int i;
M
Matt 已提交
1241 1242 1243 1244

	err = snd_hda_add_new_ctls(codec, spec->mixer);
	if (err < 0)
		return err;
1245 1246 1247 1248 1249 1250

	for (i = 0; i < spec->num_mixers; i++) {
		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
		if (err < 0)
			return err;
	}
1251 1252
	if (spec->num_dmuxes > 0) {
		stac_dmux_mixer.count = spec->num_dmuxes;
T
Takashi Iwai 已提交
1253
		err = snd_hda_ctl_add(codec,
1254 1255 1256 1257
				  snd_ctl_new1(&stac_dmux_mixer, codec));
		if (err < 0)
			return err;
	}
M
Matthew Ranostay 已提交
1258
	if (spec->num_smuxes > 0) {
1259 1260 1261 1262 1263 1264 1265 1266 1267
		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) {
			smux->items[smux->num_items].label = "Off";
			smux->items[smux->num_items].index = 0;
			smux->num_items++;
			spec->spdif_mute = 1;
		}
M
Matthew Ranostay 已提交
1268
		stac_smux_mixer.count = spec->num_smuxes;
1269
		err = snd_hda_ctl_add(codec,
M
Matthew Ranostay 已提交
1270 1271 1272 1273
				  snd_ctl_new1(&stac_smux_mixer, codec));
		if (err < 0)
			return err;
	}
1274

1275 1276 1277 1278
	if (spec->multiout.dig_out_nid) {
		err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
		if (err < 0)
			return err;
1279 1280 1281 1282 1283
		err = snd_hda_create_spdif_share_sw(codec,
						    &spec->multiout);
		if (err < 0)
			return err;
		spec->multiout.share_spdif = 1;
1284
	}
1285
	if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1286 1287 1288 1289
		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
		if (err < 0)
			return err;
	}
1290 1291 1292

	/* if we have no master control, let's create it */
	if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1293
		unsigned int vmaster_tlv[4];
1294
		snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1295
					HDA_OUTPUT, vmaster_tlv);
1296
		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1297
					  vmaster_tlv, slave_vols);
1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
		if (err < 0)
			return err;
	}
	if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
					  NULL, slave_sws);
		if (err < 0)
			return err;
	}

1308
	stac92xx_free_kctls(codec); /* no longer needed */
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338

	/* create jack input elements */
	if (spec->hp_detect) {
		for (i = 0; i < cfg->hp_outs; i++) {
			int type = SND_JACK_HEADPHONE;
			nid = cfg->hp_pins[i];
			/* jack detection */
			if (cfg->hp_outs == i)
				type |= SND_JACK_LINEOUT;
			err = stac92xx_add_jack(codec, nid, type);
			if (err < 0)
				return err;
		}
	}
	for (i = 0; i < cfg->line_outs; i++) {
		err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
					SND_JACK_LINEOUT);
		if (err < 0)
			return err;
	}
	for (i = 0; i < AUTO_PIN_LAST; i++) {
		nid = cfg->input_pins[i];
		if (nid) {
			err = stac92xx_add_jack(codec, nid,
						SND_JACK_MICROPHONE);
			if (err < 0)
				return err;
		}
	}

1339
	return 0;	
M
Matt 已提交
1340 1341
}

1342
static unsigned int ref9200_pin_configs[8] = {
1343
	0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
M
Matt 已提交
1344 1345 1346
	0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
};

1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
static unsigned int gateway9200_m4_pin_configs[8] = {
	0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
	0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
};
static unsigned int gateway9200_m4_2_pin_configs[8] = {
	0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
	0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
};

/*
1357 1358 1359 1360 1361 1362
    STAC 9200 pin configs for
    102801A8
    102801DE
    102801E8
*/
static unsigned int dell9200_d21_pin_configs[8] = {
1363 1364
	0x400001f0, 0x400001f1, 0x02214030, 0x01014010, 
	0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1365 1366 1367 1368 1369 1370 1371 1372
};

/* 
    STAC 9200 pin configs for
    102801C0
    102801C1
*/
static unsigned int dell9200_d22_pin_configs[8] = {
1373 1374
	0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
	0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386
};

/* 
    STAC 9200 pin configs for
    102801C4 (Dell Dimension E310)
    102801C5
    102801C7
    102801D9
    102801DA
    102801E3
*/
static unsigned int dell9200_d23_pin_configs[8] = {
1387 1388
	0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
	0x01813020, 0x01a19021, 0x90100140, 0x400001f2, 
1389 1390 1391 1392 1393 1394 1395 1396 1397
};


/* 
    STAC 9200-32 pin configs for
    102801B5 (Dell Inspiron 630m)
    102801D8 (Dell Inspiron 640m)
*/
static unsigned int dell9200_m21_pin_configs[8] = {
1398 1399
	0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
	0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
};

/* 
    STAC 9200-32 pin configs for
    102801C2 (Dell Latitude D620)
    102801C8 
    102801CC (Dell Latitude D820)
    102801D4 
    102801D6 
*/
static unsigned int dell9200_m22_pin_configs[8] = {
1411 1412
	0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310, 
	0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
};

/* 
    STAC 9200-32 pin configs for
    102801CE (Dell XPS M1710)
    102801CF (Dell Precision M90)
*/
static unsigned int dell9200_m23_pin_configs[8] = {
	0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
	0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
};

/*
    STAC 9200-32 pin configs for 
    102801C9
    102801CA
    102801CB (Dell Latitude 120L)
    102801D3
*/
static unsigned int dell9200_m24_pin_configs[8] = {
1433 1434
	0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310, 
	0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe, 
1435 1436 1437 1438 1439 1440 1441 1442 1443
};

/*
    STAC 9200-32 pin configs for
    102801BD (Dell Inspiron E1505n)
    102801EE
    102801EF
*/
static unsigned int dell9200_m25_pin_configs[8] = {
1444 1445
	0x40c003fa, 0x01441340, 0x0421121f, 0x90170310, 
	0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1446 1447 1448 1449 1450 1451 1452 1453
};

/*
    STAC 9200-32 pin configs for
    102801F5 (Dell Inspiron 1501)
    102801F6
*/
static unsigned int dell9200_m26_pin_configs[8] = {
1454 1455
	0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310, 
	0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1456 1457 1458 1459 1460 1461 1462
};

/*
    STAC 9200-32
    102801CD (Dell Inspiron E1705/9400)
*/
static unsigned int dell9200_m27_pin_configs[8] = {
1463 1464
	0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
	0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1465 1466
};

1467 1468 1469 1470 1471
static unsigned int oqo9200_pin_configs[8] = {
	0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
	0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
};

1472

1473 1474
static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
	[STAC_REF] = ref9200_pin_configs,
1475
	[STAC_9200_OQO] = oqo9200_pin_configs,
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
	[STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
	[STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
	[STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
	[STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
	[STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
	[STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
	[STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
	[STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
	[STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
	[STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1486 1487
	[STAC_9200_M4] = gateway9200_m4_pin_configs,
	[STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1488
	[STAC_9200_PANASONIC] = ref9200_pin_configs,
1489 1490
};

1491 1492
static const char *stac9200_models[STAC_9200_MODELS] = {
	[STAC_REF] = "ref",
1493
	[STAC_9200_OQO] = "oqo",
1494 1495 1496 1497 1498 1499 1500 1501 1502 1503
	[STAC_9200_DELL_D21] = "dell-d21",
	[STAC_9200_DELL_D22] = "dell-d22",
	[STAC_9200_DELL_D23] = "dell-d23",
	[STAC_9200_DELL_M21] = "dell-m21",
	[STAC_9200_DELL_M22] = "dell-m22",
	[STAC_9200_DELL_M23] = "dell-m23",
	[STAC_9200_DELL_M24] = "dell-m24",
	[STAC_9200_DELL_M25] = "dell-m25",
	[STAC_9200_DELL_M26] = "dell-m26",
	[STAC_9200_DELL_M27] = "dell-m27",
1504 1505
	[STAC_9200_M4] = "gateway-m4",
	[STAC_9200_M4_2] = "gateway-m4-2",
1506
	[STAC_9200_PANASONIC] = "panasonic",
1507 1508 1509 1510 1511 1512
};

static struct snd_pci_quirk stac9200_cfg_tbl[] = {
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_REF),
1513
	/* Dell laptops have BIOS problem */
1514 1515
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
		      "unknown Dell", STAC_9200_DELL_D21),
1516
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1517 1518 1519 1520 1521 1522 1523
		      "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),
1524
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
		      "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),
1536
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1537
		      "Dell Latitude 120L", STAC_9200_DELL_M24),
1538
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1539
		      "Dell Latitude D820", STAC_9200_DELL_M22),
1540
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1541
		      "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1542
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1543
		      "Dell XPS M1710", STAC_9200_DELL_M23),
1544
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1545 1546 1547 1548 1549
		      "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),
1550
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1551
		      "unknown Dell", STAC_9200_DELL_M22),
1552
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
		      "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),
1568
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1569 1570 1571
		      "Dell Inspiron 1501", STAC_9200_DELL_M26),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
		      "unknown Dell", STAC_9200_DELL_M26),
1572
	/* Panasonic */
1573
	SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1574
	/* Gateway machines needs EAPD to be set on resume */
1575 1576 1577
	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),
1578 1579
	/* OQO Mobile */
	SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1580 1581 1582
	{} /* terminator */
};

1583 1584
static unsigned int ref925x_pin_configs[8] = {
	0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1585
	0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1586 1587
};

1588 1589 1590
static unsigned int stac925xM1_pin_configs[8] = {
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1591 1592
};

1593 1594 1595 1596
static unsigned int stac925xM1_2_pin_configs[8] = {
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
};
1597

1598 1599 1600
static unsigned int stac925xM2_pin_configs[8] = {
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1601 1602
};

1603
static unsigned int stac925xM2_2_pin_configs[8] = {
1604 1605 1606 1607
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
};

1608 1609 1610 1611
static unsigned int stac925xM3_pin_configs[8] = {
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
	0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
};
1612

1613 1614 1615 1616 1617 1618 1619 1620
static unsigned int stac925xM5_pin_configs[8] = {
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
};

static unsigned int stac925xM6_pin_configs[8] = {
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
	0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1621 1622 1623 1624
};

static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
	[STAC_REF] = ref925x_pin_configs,
1625 1626 1627
	[STAC_M1] = stac925xM1_pin_configs,
	[STAC_M1_2] = stac925xM1_2_pin_configs,
	[STAC_M2] = stac925xM2_pin_configs,
1628
	[STAC_M2_2] = stac925xM2_2_pin_configs,
1629 1630 1631
	[STAC_M3] = stac925xM3_pin_configs,
	[STAC_M5] = stac925xM5_pin_configs,
	[STAC_M6] = stac925xM6_pin_configs,
1632 1633 1634 1635
};

static const char *stac925x_models[STAC_925x_MODELS] = {
	[STAC_REF] = "ref",
1636 1637 1638
	[STAC_M1] = "m1",
	[STAC_M1_2] = "m1-2",
	[STAC_M2] = "m2",
1639
	[STAC_M2_2] = "m2-2",
1640 1641 1642
	[STAC_M3] = "m3",
	[STAC_M5] = "m5",
	[STAC_M6] = "m6",
1643 1644
};

1645
static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1646 1647 1648 1649
	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),
1650 1651 1652 1653 1654 1655 1656
	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 */
1657 1658 1659 1660 1661
};

static struct snd_pci_quirk stac925x_cfg_tbl[] = {
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1662
	SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1663 1664 1665 1666

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

1667 1668 1669
	{} /* terminator */
};

1670
static unsigned int ref92hd73xx_pin_configs[13] = {
1671 1672 1673
	0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
	0x0181302e, 0x01014010, 0x01014020, 0x01014030,
	0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1674 1675 1676 1677 1678
	0x01452050,
};

static unsigned int dell_m6_pin_configs[13] = {
	0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1679
	0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1680 1681
	0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
	0x4f0000f0,
1682 1683 1684
};

static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1685
	[STAC_92HD73XX_REF]	= ref92hd73xx_pin_configs,
1686 1687 1688
	[STAC_DELL_M6_AMIC]	= dell_m6_pin_configs,
	[STAC_DELL_M6_DMIC]	= dell_m6_pin_configs,
	[STAC_DELL_M6_BOTH]	= dell_m6_pin_configs,
1689
	[STAC_DELL_EQ]	= dell_m6_pin_configs,
1690 1691 1692
};

static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1693
	[STAC_92HD73XX_NO_JD] = "no-jd",
1694
	[STAC_92HD73XX_REF] = "ref",
1695 1696 1697
	[STAC_DELL_M6_AMIC] = "dell-m6-amic",
	[STAC_DELL_M6_DMIC] = "dell-m6-dmic",
	[STAC_DELL_M6_BOTH] = "dell-m6",
1698
	[STAC_DELL_EQ] = "dell-eq",
1699 1700 1701 1702 1703
};

static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1704 1705
				"DFI LanParty", STAC_92HD73XX_REF),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1706
				"Dell Studio 1535", STAC_DELL_M6_DMIC),
1707
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1708
				"unknown Dell", STAC_DELL_M6_DMIC),
1709
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1710
				"unknown Dell", STAC_DELL_M6_BOTH),
1711
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1712
				"unknown Dell", STAC_DELL_M6_BOTH),
1713
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1714
				"unknown Dell", STAC_DELL_M6_AMIC),
1715
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1716
				"unknown Dell", STAC_DELL_M6_AMIC),
1717
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1718 1719 1720
				"unknown Dell", STAC_DELL_M6_DMIC),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
				"unknown Dell", STAC_DELL_M6_DMIC),
1721
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1722
				"Dell Studio 1537", STAC_DELL_M6_DMIC),
1723 1724
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
				"Dell Studio 17", STAC_DELL_M6_DMIC),
1725 1726 1727
	{} /* terminator */
};

1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
static unsigned int ref92hd83xxx_pin_configs[14] = {
	0x02214030, 0x02211010, 0x02a19020, 0x02170130,
	0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
	0x40f000f0, 0x40f000f0, 0x40f000f0, 0x40f000f0,
	0x01451160, 0x98560170,
};

static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
	[STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
};

static const char *stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
	[STAC_92HD83XXX_REF] = "ref",
};

static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
T
Takashi Iwai 已提交
1746
		      "DFI LanParty", STAC_92HD83XXX_REF),
1747
	{} /* terminator */
1748 1749
};

1750
static unsigned int ref92hd71bxx_pin_configs[11] = {
1751
	0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1752
	0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1753
	0x90a000f0, 0x01452050, 0x01452050,
1754 1755
};

1756
static unsigned int dell_m4_1_pin_configs[11] = {
1757
	0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1758
	0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1759
	0x40f000f0, 0x4f0000f0, 0x4f0000f0,
1760 1761
};

1762
static unsigned int dell_m4_2_pin_configs[11] = {
1763 1764
	0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
	0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1765
	0x40f000f0, 0x044413b0, 0x044413b0,
1766 1767
};

1768 1769 1770 1771 1772 1773
static unsigned int dell_m4_3_pin_configs[11] = {
	0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
	0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
	0x40f000f0, 0x044413b0, 0x044413b0,
};

1774 1775
static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
	[STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1776 1777
	[STAC_DELL_M4_1]	= dell_m4_1_pin_configs,
	[STAC_DELL_M4_2]	= dell_m4_2_pin_configs,
1778
	[STAC_DELL_M4_3]	= dell_m4_3_pin_configs,
1779
	[STAC_HP_M4]		= NULL,
T
Takashi Iwai 已提交
1780
	[STAC_HP_DV5]		= NULL,
1781 1782 1783 1784
};

static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
	[STAC_92HD71BXX_REF] = "ref",
1785 1786
	[STAC_DELL_M4_1] = "dell-m4-1",
	[STAC_DELL_M4_2] = "dell-m4-2",
1787
	[STAC_DELL_M4_3] = "dell-m4-3",
1788
	[STAC_HP_M4] = "hp-m4",
T
Takashi Iwai 已提交
1789
	[STAC_HP_DV5] = "hp-dv5",
1790 1791 1792 1793 1794 1795
};

static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_92HD71BXX_REF),
1796 1797 1798 1799
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f2,
		      "HP dv5", STAC_HP_M4),
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f4,
		      "HP dv7", STAC_HP_M4),
1800 1801
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30f7,
		      "HP dv4", STAC_HP_DV5),
1802 1803
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fc,
		      "HP dv7", STAC_HP_M4),
1804
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3603,
T
Takashi Iwai 已提交
1805
		      "HP dv5", STAC_HP_DV5),
M
Matthew Ranostay 已提交
1806 1807
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
				"unknown HP", STAC_HP_M4),
1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
	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),
1830 1831
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
				"unknown Dell", STAC_DELL_M4_3),
1832 1833 1834
	{} /* terminator */
};

1835 1836 1837
static unsigned int ref922x_pin_configs[10] = {
	0x01014010, 0x01016011, 0x01012012, 0x0221401f,
	0x01813122, 0x01011014, 0x01441030, 0x01c41030,
M
Matt 已提交
1838 1839 1840
	0x40000100, 0x40000100,
};

1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
/*
    STAC 922X pin configs for
    102801A7
    102801AB
    102801A9
    102801D1
    102801D2
*/
static unsigned int dell_922x_d81_pin_configs[10] = {
	0x02214030, 0x01a19021, 0x01111012, 0x01114010,
	0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
	0x01813122, 0x400001f2,
};

/*
    STAC 922X pin configs for
    102801AC
    102801D0
*/
static unsigned int dell_922x_d82_pin_configs[10] = {
	0x02214030, 0x01a19021, 0x01111012, 0x01114010,
	0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
	0x01813122, 0x400001f1,
};

/*
    STAC 922X pin configs for
    102801BF
*/
static unsigned int dell_922x_m81_pin_configs[10] = {
	0x0321101f, 0x01112024, 0x01111222, 0x91174220,
	0x03a11050, 0x01116221, 0x90a70330, 0x01452340, 
	0x40C003f1, 0x405003f0,
};

/*
    STAC 9221 A1 pin configs for
    102801D7 (Dell XPS M1210)
*/
static unsigned int dell_922x_m82_pin_configs[10] = {
1881 1882
	0x02211211, 0x408103ff, 0x02a1123e, 0x90100310, 
	0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2, 
1883 1884 1885
	0x508003f3, 0x405003f4, 
};

1886
static unsigned int d945gtp3_pin_configs[10] = {
M
Matt Porter 已提交
1887
	0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1888 1889 1890 1891 1892
	0x40000100, 0x40000100, 0x40000100, 0x40000100,
	0x02a19120, 0x40000100,
};

static unsigned int d945gtp5_pin_configs[10] = {
M
Matt Porter 已提交
1893 1894
	0x0221401f, 0x01011012, 0x01813024, 0x01014010,
	0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1895 1896 1897
	0x02a19320, 0x40000100,
};

1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
static unsigned int intel_mac_v1_pin_configs[10] = {
	0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
	0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
	0x400000fc, 0x400000fb,
};

static unsigned int intel_mac_v2_pin_configs[10] = {
	0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
	0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
	0x400000fc, 0x400000fb,
1908 1909
};

1910 1911 1912
static unsigned int intel_mac_v3_pin_configs[10] = {
	0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
	0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1913 1914 1915
	0x400000fc, 0x400000fb,
};

1916 1917 1918
static unsigned int intel_mac_v4_pin_configs[10] = {
	0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
	0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1919 1920 1921
	0x400000fc, 0x400000fb,
};

1922 1923 1924 1925
static unsigned int intel_mac_v5_pin_configs[10] = {
	0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
	0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
	0x400000fc, 0x400000fb,
1926 1927
};

1928 1929 1930 1931 1932
static unsigned int ecs202_pin_configs[10] = {
	0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
	0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
	0x9037012e, 0x40e000f2,
};
1933

1934
static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1935
	[STAC_D945_REF] = ref922x_pin_configs,
1936 1937
	[STAC_D945GTP3] = d945gtp3_pin_configs,
	[STAC_D945GTP5] = d945gtp5_pin_configs,
1938 1939 1940 1941 1942
	[STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
	[STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
	[STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
	[STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
	[STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1943
	[STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1944
	/* for backward compatibility */
1945 1946 1947 1948 1949 1950
	[STAC_MACMINI] = intel_mac_v3_pin_configs,
	[STAC_MACBOOK] = intel_mac_v5_pin_configs,
	[STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
	[STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
	[STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
	[STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1951
	[STAC_ECS_202] = ecs202_pin_configs,
1952 1953 1954 1955
	[STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
	[STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,	
	[STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
	[STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,	
1956 1957
};

1958 1959 1960 1961
static const char *stac922x_models[STAC_922X_MODELS] = {
	[STAC_D945_REF]	= "ref",
	[STAC_D945GTP5]	= "5stack",
	[STAC_D945GTP3]	= "3stack",
1962 1963 1964 1965 1966
	[STAC_INTEL_MAC_V1] = "intel-mac-v1",
	[STAC_INTEL_MAC_V2] = "intel-mac-v2",
	[STAC_INTEL_MAC_V3] = "intel-mac-v3",
	[STAC_INTEL_MAC_V4] = "intel-mac-v4",
	[STAC_INTEL_MAC_V5] = "intel-mac-v5",
1967
	[STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1968
	/* for backward compatibility */
1969
	[STAC_MACMINI]	= "macmini",
1970
	[STAC_MACBOOK]	= "macbook",
1971 1972
	[STAC_MACBOOK_PRO_V1]	= "macbook-pro-v1",
	[STAC_MACBOOK_PRO_V2]	= "macbook-pro",
1973
	[STAC_IMAC_INTEL] = "imac-intel",
1974
	[STAC_IMAC_INTEL_20] = "imac-intel-20",
1975
	[STAC_ECS_202] = "ecs202",
1976 1977 1978 1979
	[STAC_922X_DELL_D81] = "dell-d81",
	[STAC_922X_DELL_D82] = "dell-d82",
	[STAC_922X_DELL_M81] = "dell-m81",
	[STAC_922X_DELL_M82] = "dell-m82",
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 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
};

static struct snd_pci_quirk stac922x_cfg_tbl[] = {
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_D945_REF),
	/* 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),
	/* other systems  */
2040
	/* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
2041
	SND_PCI_QUIRK(0x8384, 0x7680,
2042
		      "Mac", STAC_INTEL_MAC_AUTO),
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061
	/* 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),
2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088
	/* ECS/PC Chips boards */
	SND_PCI_QUIRK(0x1019, 0x2144,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2608,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2633,
		      "ECS/PC chips P17G/1333", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2811,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2812,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2813,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2814,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2815,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2816,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2817,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2818,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2819,
		      "ECS/PC chips", STAC_ECS_202),
	SND_PCI_QUIRK(0x1019, 0x2820,
		      "ECS/PC chips", STAC_ECS_202),
2089 2090 2091
	{} /* terminator */
};

2092
static unsigned int ref927x_pin_configs[14] = {
2093 2094 2095 2096
	0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
	0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 
	0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
	0x01c42190, 0x40000100,
2097 2098
};

2099
static unsigned int d965_3st_pin_configs[14] = {
2100 2101 2102 2103 2104 2105
	0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
	0x01a19021, 0x01813024, 0x40000100, 0x40000100,
	0x40000100, 0x40000100, 0x40000100, 0x40000100,
	0x40000100, 0x40000100
};

2106 2107 2108 2109 2110 2111 2112
static unsigned int d965_5st_pin_configs[14] = {
	0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
	0x01a19040, 0x01011012, 0x01016011, 0x40000100,
	0x40000100, 0x40000100, 0x40000100, 0x01442070,
	0x40000100, 0x40000100
};

2113 2114 2115
static unsigned int dell_3st_pin_configs[14] = {
	0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
	0x01111212, 0x01116211, 0x01813050, 0x01112214,
2116
	0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2117 2118 2119
	0x40c003fc, 0x40000100
};

2120
static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2121
	[STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2122 2123 2124 2125 2126
	[STAC_D965_REF]  = ref927x_pin_configs,
	[STAC_D965_3ST]  = d965_3st_pin_configs,
	[STAC_D965_5ST]  = d965_5st_pin_configs,
	[STAC_DELL_3ST]  = dell_3st_pin_configs,
	[STAC_DELL_BIOS] = NULL,
2127 2128
};

2129
static const char *stac927x_models[STAC_927X_MODELS] = {
2130
	[STAC_D965_REF_NO_JD]	= "ref-no-jd",
2131 2132 2133 2134 2135
	[STAC_D965_REF]		= "ref",
	[STAC_D965_3ST]		= "3stack",
	[STAC_D965_5ST]		= "5stack",
	[STAC_DELL_3ST]		= "dell-3stack",
	[STAC_DELL_BIOS]	= "dell-bios",
2136 2137 2138 2139 2140 2141
};

static struct snd_pci_quirk stac927x_cfg_tbl[] = {
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_D965_REF),
2142
	 /* Intel 946 based systems */
2143 2144
	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),
2145
	/* 965 based 3 stack systems */
2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST),
2162
	/* Dell 3 stack systems */
2163
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_3ST),
2164
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2165 2166
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
2167
	/* Dell 3 stack systems with verb table in BIOS */
M
Matthew Ranostay 已提交
2168 2169
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
2170
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
2171
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_3ST),
2172 2173 2174 2175
	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),
2176
	/* 965 based 5 stack systems */
2177 2178 2179 2180 2181 2182 2183 2184 2185
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST),
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST),
2186 2187 2188
	{} /* terminator */
};

2189 2190
static unsigned int ref9205_pin_configs[12] = {
	0x40000100, 0x40000100, 0x01016011, 0x01014010,
2191
	0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2192
	0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2193 2194
};

2195 2196 2197 2198 2199 2200 2201 2202
/*
    STAC 9205 pin configs for
    102801F1
    102801F2
    102801FC
    102801FD
    10280204
    1028021F
2203
    10280228 (Dell Vostro 1500)
2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
*/
static unsigned int dell_9205_m42_pin_configs[12] = {
	0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
	0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
	0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
};

/*
    STAC 9205 pin configs for
    102801F9
    102801FA
    102801FE
    102801FF (Dell Precision M4300)
    10280206
    10280200
    10280201
*/
static unsigned int dell_9205_m43_pin_configs[12] = {
2222 2223 2224 2225 2226
	0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
	0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
	0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
};

2227
static unsigned int dell_9205_m44_pin_configs[12] = {
2228 2229 2230 2231 2232
	0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
	0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
	0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
};

2233
static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2234
	[STAC_9205_REF] = ref9205_pin_configs,
2235 2236 2237
	[STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
	[STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
	[STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2238 2239
};

2240 2241
static const char *stac9205_models[STAC_9205_MODELS] = {
	[STAC_9205_REF] = "ref",
2242
	[STAC_9205_DELL_M42] = "dell-m42",
2243 2244
	[STAC_9205_DELL_M43] = "dell-m43",
	[STAC_9205_DELL_M44] = "dell-m44",
2245 2246 2247 2248 2249 2250
};

static struct snd_pci_quirk stac9205_cfg_tbl[] = {
	/* SigmaTel reference board */
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
		      "DFI LanParty", STAC_9205_REF),
2251 2252 2253 2254
	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),
2255
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2256
		      "Dell Precision", STAC_9205_DELL_M43),
2257 2258 2259 2260
	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),
2261 2262 2263 2264
	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),
2265 2266 2267
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
		      "Dell Precision", STAC_9205_DELL_M43),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2268 2269 2270
		      "Dell Precision M4300", STAC_9205_DELL_M43),
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
		      "unknown Dell", STAC_9205_DELL_M42),
T
Takashi Iwai 已提交
2271 2272 2273 2274 2275 2276
	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),
2277 2278
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
		      "Dell Inspiron", STAC_9205_DELL_M44),
2279 2280
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
		      "Dell Vostro 1500", STAC_9205_DELL_M42),
2281 2282 2283
	{} /* terminator */
};

2284 2285 2286 2287 2288
static int stac92xx_save_bios_config_regs(struct hda_codec *codec)
{
	int i;
	struct sigmatel_spec *spec = codec->spec;
	
2289 2290 2291 2292 2293
	kfree(spec->pin_configs);
	spec->pin_configs = kcalloc(spec->num_pins, sizeof(*spec->pin_configs),
				    GFP_KERNEL);
	if (!spec->pin_configs)
		return -ENOMEM;
2294 2295 2296 2297 2298 2299 2300 2301 2302
	
	for (i = 0; i < spec->num_pins; i++) {
		hda_nid_t nid = spec->pin_nids[i];
		unsigned int pin_cfg;
		
		pin_cfg = snd_hda_codec_read(codec, nid, 0, 
			AC_VERB_GET_CONFIG_DEFAULT, 0x00);	
		snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n",
					nid, pin_cfg);
2303
		spec->pin_configs[i] = pin_cfg;
2304 2305 2306 2307 2308
	}
	
	return 0;
}

2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331
static void stac92xx_set_config_reg(struct hda_codec *codec,
				    hda_nid_t pin_nid, unsigned int pin_config)
{
	int i;
	snd_hda_codec_write(codec, pin_nid, 0,
			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_0,
			    pin_config & 0x000000ff);
	snd_hda_codec_write(codec, pin_nid, 0,
			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_1,
			    (pin_config & 0x0000ff00) >> 8);
	snd_hda_codec_write(codec, pin_nid, 0,
			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_2,
			    (pin_config & 0x00ff0000) >> 16);
	snd_hda_codec_write(codec, pin_nid, 0,
			    AC_VERB_SET_CONFIG_DEFAULT_BYTES_3,
			    pin_config >> 24);
	i = snd_hda_codec_read(codec, pin_nid, 0,
			       AC_VERB_GET_CONFIG_DEFAULT,
			       0x00);	
	snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n",
		    pin_nid, i);
}

M
Matt 已提交
2332 2333 2334 2335 2336
static void stac92xx_set_config_regs(struct hda_codec *codec)
{
	int i;
	struct sigmatel_spec *spec = codec->spec;

2337 2338
 	if (!spec->pin_configs)
 		return;
2339

2340 2341 2342
	for (i = 0; i < spec->num_pins; i++)
		stac92xx_set_config_reg(codec, spec->pin_nids[i],
					spec->pin_configs[i]);
M
Matt 已提交
2343 2344
}

2345 2346 2347 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
static int stac_save_pin_cfgs(struct hda_codec *codec, unsigned int *pins)
{
	struct sigmatel_spec *spec = codec->spec;

	if (!pins)
		return stac92xx_save_bios_config_regs(codec);

	kfree(spec->pin_configs);
	spec->pin_configs = kmemdup(pins,
				    spec->num_pins * sizeof(*pins),
				    GFP_KERNEL);
	if (!spec->pin_configs)
		return -ENOMEM;

	stac92xx_set_config_regs(codec);
	return 0;
}

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

	for (i = 0; i < spec->num_pins; i++) {
		if (spec->pin_nids[i] == nid) {
			spec->pin_configs[i] = cfg;
			stac92xx_set_config_reg(codec, nid, cfg);
			break;
		}
	}
}

2378
/*
2379
 * Analog playback callbacks
2380
 */
2381 2382
static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
				      struct hda_codec *codec,
2383
				      struct snd_pcm_substream *substream)
M
Matt 已提交
2384
{
2385
	struct sigmatel_spec *spec = codec->spec;
M
Matthew Ranostay 已提交
2386 2387
	if (spec->stream_delay)
		msleep(spec->stream_delay);
2388 2389
	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
					     hinfo);
M
Matt 已提交
2390 2391 2392 2393 2394 2395
}

static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
					 struct hda_codec *codec,
					 unsigned int stream_tag,
					 unsigned int format,
2396
					 struct snd_pcm_substream *substream)
M
Matt 已提交
2397 2398
{
	struct sigmatel_spec *spec = codec->spec;
2399
	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
M
Matt 已提交
2400 2401 2402 2403
}

static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
					struct hda_codec *codec,
2404
					struct snd_pcm_substream *substream)
M
Matt 已提交
2405 2406 2407 2408 2409
{
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
}

2410 2411 2412 2413 2414
/*
 * Digital playback callbacks
 */
static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
					  struct hda_codec *codec,
2415
					  struct snd_pcm_substream *substream)
2416 2417 2418 2419 2420 2421 2422
{
	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,
2423
					   struct snd_pcm_substream *substream)
2424 2425 2426 2427 2428
{
	struct sigmatel_spec *spec = codec->spec;
	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
}

2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439
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);
}

2440

M
Matt 已提交
2441 2442 2443 2444 2445 2446 2447
/*
 * 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,
2448
					struct snd_pcm_substream *substream)
M
Matt 已提交
2449 2450
{
	struct sigmatel_spec *spec = codec->spec;
M
Matthew Ranostay 已提交
2451
	hda_nid_t nid = spec->adc_nids[substream->number];
M
Matt 已提交
2452

M
Matthew Ranostay 已提交
2453 2454
	if (spec->powerdown_adcs) {
		msleep(40);
2455
		snd_hda_codec_write(codec, nid, 0,
M
Matthew Ranostay 已提交
2456 2457 2458
			AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
	}
	snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
M
Matt 已提交
2459 2460 2461 2462 2463
	return 0;
}

static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
					struct hda_codec *codec,
2464
					struct snd_pcm_substream *substream)
M
Matt 已提交
2465 2466
{
	struct sigmatel_spec *spec = codec->spec;
M
Matthew Ranostay 已提交
2467
	hda_nid_t nid = spec->adc_nids[substream->number];
M
Matt 已提交
2468

M
Matthew Ranostay 已提交
2469 2470
	snd_hda_codec_cleanup_stream(codec, nid);
	if (spec->powerdown_adcs)
2471
		snd_hda_codec_write(codec, nid, 0,
M
Matthew Ranostay 已提交
2472
			AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
M
Matt 已提交
2473 2474 2475
	return 0;
}

2476 2477 2478 2479 2480 2481 2482
static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in stac92xx_build_pcms */
	.ops = {
		.open = stac92xx_dig_playback_pcm_open,
2483 2484
		.close = stac92xx_dig_playback_pcm_close,
		.prepare = stac92xx_dig_playback_pcm_prepare
2485 2486 2487 2488 2489 2490 2491 2492 2493 2494
	},
};

static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
	.substreams = 1,
	.channels_min = 2,
	.channels_max = 2,
	/* NID is set in stac92xx_build_pcms */
};

M
Matt 已提交
2495 2496 2497
static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
	.substreams = 1,
	.channels_min = 2,
2498
	.channels_max = 8,
M
Matt 已提交
2499 2500 2501 2502 2503 2504 2505 2506
	.nid = 0x02, /* NID to query formats and rates */
	.ops = {
		.open = stac92xx_playback_pcm_open,
		.prepare = stac92xx_playback_pcm_prepare,
		.cleanup = stac92xx_playback_pcm_cleanup
	},
};

2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
	.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
	},
};

M
Matt 已提交
2519 2520 2521
static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
	.channels_min = 2,
	.channels_max = 2,
2522
	/* NID + .substreams is set in stac92xx_build_pcms */
M
Matt 已提交
2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536
	.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;

2537
	info->name = "STAC92xx Analog";
M
Matt 已提交
2538 2539
	info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
	info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2540
	info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2541
	info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2542 2543 2544 2545 2546 2547 2548

	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 已提交
2549

2550 2551 2552 2553
	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
		codec->num_pcms++;
		info++;
		info->name = "STAC92xx Digital";
2554
		info->pcm_type = HDA_PCM_TYPE_SPDIF;
2555 2556 2557 2558 2559 2560 2561 2562 2563 2564
		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 已提交
2565 2566 2567
	return 0;
}

2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583
static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid)
{
	unsigned int pincap = snd_hda_param_read(codec, nid,
						 AC_PAR_PIN_CAP);
	pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
	if (pincap & AC_PINCAP_VREF_100)
		return AC_PINCTL_VREF_100;
	if (pincap & AC_PINCAP_VREF_80)
		return AC_PINCTL_VREF_80;
	if (pincap & AC_PINCAP_VREF_50)
		return AC_PINCTL_VREF_50;
	if (pincap & AC_PINCAP_VREF_GRD)
		return AC_PINCTL_VREF_GRD;
	return 0;
}

2584 2585 2586
static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)

{
2587 2588
	snd_hda_codec_write_cache(codec, nid, 0,
				  AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2589 2590
}

2591 2592 2593 2594 2595 2596 2597 2598
#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;

2599
	ucontrol->value.integer.value[0] = !!spec->hp_switch;
2600 2601 2602
	return 0;
}

2603 2604 2605
static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
				   unsigned char type);

2606 2607 2608 2609 2610
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;
2611 2612 2613
	int nid = kcontrol->private_value;
 
	spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2614 2615 2616 2617

	/* check to be sure that the ports are upto date with
	 * switch changes
	 */
2618
	stac_issue_unsol_event(codec, nid, STAC_HP_EVENT);
2619 2620 2621 2622

	return 1;
}

2623
#define stac92xx_io_switch_info		snd_ctl_boolean_mono_info
2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640

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;
	int io_idx = kcontrol-> private_value & 0xff;

	ucontrol->value.integer.value[0] = spec->io_switch[io_idx];
	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;
        hda_nid_t nid = kcontrol->private_value >> 8;
	int io_idx = kcontrol-> private_value & 0xff;
2641
	unsigned short val = !!ucontrol->value.integer.value[0];
2642 2643 2644 2645 2646

	spec->io_switch[io_idx] = val;

	if (val)
		stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2647 2648 2649 2650 2651 2652
	else {
		unsigned int pinctl = AC_PINCTL_IN_EN;
		if (io_idx) /* set VREF for mic */
			pinctl |= stac92xx_get_vref(codec, nid);
		stac92xx_auto_set_pinctl(codec, nid, pinctl);
	}
2653 2654 2655 2656 2657

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

2660 2661 2662
        return 1;
}

2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680
#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;
2681
	unsigned int val = !!ucontrol->value.integer.value[0];
2682

2683
	if (spec->clfe_swap == val)
2684 2685
		return 0;

2686
	spec->clfe_swap = val;
2687 2688 2689 2690 2691 2692 2693

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

	return 1;
}

2694 2695 2696 2697 2698 2699 2700 2701 2702
#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, \
	}

2703 2704 2705 2706 2707 2708 2709 2710 2711 2712
#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, \
	}

2713 2714 2715 2716 2717 2718 2719 2720 2721
#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, \
	}
2722

2723 2724 2725
enum {
	STAC_CTL_WIDGET_VOL,
	STAC_CTL_WIDGET_MUTE,
2726
	STAC_CTL_WIDGET_MONO_MUX,
2727 2728
	STAC_CTL_WIDGET_AMP_MUX,
	STAC_CTL_WIDGET_AMP_VOL,
2729
	STAC_CTL_WIDGET_HP_SWITCH,
2730
	STAC_CTL_WIDGET_IO_SWITCH,
2731
	STAC_CTL_WIDGET_CLFE_SWITCH
2732 2733
};

2734
static struct snd_kcontrol_new stac92xx_control_templates[] = {
2735 2736
	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
	HDA_CODEC_MUTE(NULL, 0, 0, 0),
2737
	STAC_MONO_MUX,
2738 2739
	STAC_AMP_MUX,
	STAC_AMP_VOL(NULL, 0, 0, 0, 0),
2740
	STAC_CODEC_HP_SWITCH(NULL),
2741
	STAC_CODEC_IO_SWITCH(NULL, 0),
2742
	STAC_CODEC_CLFE_SWITCH(NULL, 0),
2743 2744 2745
};

/* add dynamic controls */
2746 2747 2748 2749
static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
				     struct snd_kcontrol_new *ktemp,
				     int idx, const char *name,
				     unsigned long val)
2750
{
2751
	struct snd_kcontrol_new *knew;
2752

2753 2754 2755 2756
	snd_array_init(&spec->kctls, sizeof(*knew), 32);
	knew = snd_array_new(&spec->kctls);
	if (!knew)
		return -ENOMEM;
2757
	*knew = *ktemp;
2758
	knew->index = idx;
T
Takashi Iwai 已提交
2759
	knew->name = kstrdup(name, GFP_KERNEL);
2760
	if (!knew->name)
2761 2762 2763 2764 2765
		return -ENOMEM;
	knew->private_value = val;
	return 0;
}

2766 2767 2768 2769 2770 2771 2772 2773 2774
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);
}

2775 2776

/* add dynamic controls */
2777 2778
static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
				       const char *name, unsigned long val)
2779 2780 2781 2782
{
	return stac92xx_add_control_idx(spec, type, 0, name, val);
}

2783 2784
/* check whether the line-input can be used as line-out */
static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2785 2786
{
	struct sigmatel_spec *spec = codec->spec;
2787 2788 2789
	struct auto_pin_cfg *cfg = &spec->autocfg;
	hda_nid_t nid;
	unsigned int pincap;
2790

2791 2792 2793 2794 2795 2796 2797 2798
	if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
		return 0;
	nid = cfg->input_pins[AUTO_PIN_LINE];
	pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
	if (pincap & AC_PINCAP_OUT)
		return nid;
	return 0;
}
2799

2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820
/* check whether the mic-input can be used as line-out */
static hda_nid_t check_mic_out_switch(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	unsigned int def_conf, pincap;
	unsigned int mic_pin;

	if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
		return 0;
	mic_pin = AUTO_PIN_MIC;
	for (;;) {
		hda_nid_t nid = cfg->input_pins[mic_pin];
		def_conf = snd_hda_codec_read(codec, nid, 0,
					      AC_VERB_GET_CONFIG_DEFAULT, 0);
		/* some laptops have an internal analog microphone
		 * which can't be used as a output */
		if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) {
			pincap = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
			if (pincap & AC_PINCAP_OUT)
				return nid;
2821
		}
2822 2823 2824 2825
		if (mic_pin == AUTO_PIN_MIC)
			mic_pin = AUTO_PIN_FRONT_MIC;
		else
			break;
2826 2827 2828 2829
	}
	return 0;
}

2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841
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;
}

2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887
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;
	int j, conn_len;
	hda_nid_t conn[HDA_MAX_CONNECTIONS];
	unsigned int wcaps, wtype;

	conn_len = snd_hda_get_connections(codec, nid, conn,
					   HDA_MAX_CONNECTIONS);
	for (j = 0; j < conn_len; j++) {
		wcaps = snd_hda_param_read(codec, conn[j],
					   AC_PAR_AUDIO_WIDGET_CAP);
		wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
		/* 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];
		}
	}
	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);

2888
/*
2889 2890 2891 2892 2893
 * 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.
2894
 */
2895
static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2896 2897
{
	struct sigmatel_spec *spec = codec->spec;
2898 2899 2900
	struct auto_pin_cfg *cfg = &spec->autocfg;
	int i;
	hda_nid_t nid, dac;
2901
	
2902 2903
	for (i = 0; i < cfg->line_outs; i++) {
		nid = cfg->line_out_pins[i];
2904 2905
		dac = get_unassigned_dac(codec, nid);
		if (!dac) {
2906 2907 2908 2909 2910 2911 2912
			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;
			}
2913 2914 2915 2916 2917 2918
			/* error out, no available DAC found */
			snd_printk(KERN_ERR
				   "%s: No available DAC for pin 0x%x\n",
				   __func__, nid);
			return -ENODEV;
		}
2919 2920
		add_spec_dacs(spec, dac);
	}
2921

2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947
	/* 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 */
	nid = check_mic_out_switch(codec);
	if (nid) {
		dac = get_unassigned_dac(codec, nid);
		if (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);
		}
	}
2948

2949 2950 2951 2952 2953 2954 2955 2956
	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);
2957
		}
2958 2959 2960 2961 2962 2963 2964 2965 2966
		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;
2967
	}
2968

2969
	snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
2970 2971 2972 2973 2974 2975
		   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]);
2976

2977 2978 2979
	return 0;
}

2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998
/* create volume control/switch for the given prefx type */
static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs)
{
	char name[32];
	int err;

	sprintf(name, "%s Playback Volume", pfx);
	err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name,
				   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
	if (err < 0)
		return err;
	sprintf(name, "%s Playback Switch", pfx);
	err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name,
				   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
	if (err < 0)
		return err;
	return 0;
}

M
Matthew Ranostay 已提交
2999 3000
static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
{
3001
	if (spec->multiout.num_dacs > 4) {
M
Matthew Ranostay 已提交
3002 3003 3004 3005 3006 3007 3008 3009 3010
		printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
		return 1;
	} else {
		spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
		spec->multiout.num_dacs++;
	}
	return 0;
}

3011
static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
M
Matthew Ranostay 已提交
3012
{
3013 3014 3015 3016 3017 3018 3019 3020 3021
	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 已提交
3022 3023
}

3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037
static int is_unique_dac(struct sigmatel_spec *spec, hda_nid_t nid)
{
	int i;

	if (spec->autocfg.line_outs != 1)
		return 0;
	if (spec->multiout.hp_nid == nid)
		return 0;
	for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++)
		if (spec->multiout.extra_out_nid[i] == nid)
			return 0;
	return 1;
}

3038
/* add playback controls from the parsed DAC table */
3039
static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3040
					       const struct auto_pin_cfg *cfg)
3041
{
3042
	struct sigmatel_spec *spec = codec->spec;
3043 3044 3045
	static const char *chname[4] = {
		"Front", "Surround", NULL /*CLFE*/, "Side"
	};
3046
	hda_nid_t nid = 0;
3047 3048
	int i, err;
	unsigned int wid_caps;
3049

3050
	for (i = 0; i < cfg->line_outs && spec->multiout.dac_nids[i]; i++) {
3051 3052 3053
		nid = spec->multiout.dac_nids[i];
		if (i == 2) {
			/* Center/LFE */
3054 3055
			err = create_controls(spec, "Center", nid, 1);
			if (err < 0)
3056
				return err;
3057 3058
			err = create_controls(spec, "LFE", nid, 2);
			if (err < 0)
3059
				return err;
3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071

			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;
			}

3072
		} else {
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085
			const char *name = chname[i];
			/* if it's a single DAC, assign a better name */
			if (!i && is_unique_dac(spec, nid)) {
				switch (cfg->line_out_type) {
				case AUTO_PIN_HP_OUT:
					name = "Headphone";
					break;
				case AUTO_PIN_SPEAKER_OUT:
					name = "Speaker";
					break;
				}
			}
			err = create_controls(spec, name, nid, 3);
3086
			if (err < 0)
3087 3088 3089 3090
				return err;
		}
	}

3091
	if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3092 3093
		err = stac92xx_add_control(spec,
			STAC_CTL_WIDGET_HP_SWITCH,
3094 3095
			"Headphone as Line Out Switch",
			cfg->hp_pins[cfg->hp_outs - 1]);
3096 3097 3098 3099
		if (err < 0)
			return err;
	}

3100
	if (spec->line_switch) {
3101 3102 3103 3104 3105
		err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
					   "Line In as Output Switch",
					   spec->line_switch << 8);
		if (err < 0)
			return err;
3106
	}
3107

3108
	if (spec->mic_switch) {
3109 3110 3111 3112 3113
		err = stac92xx_add_control(spec, STAC_CTL_WIDGET_IO_SWITCH,
					   "Mic as Output Switch",
					   (spec->mic_switch << 8) | 1);
		if (err < 0)
			return err;
3114
	}
3115

3116 3117 3118
	return 0;
}

3119 3120 3121 3122 3123 3124
/* 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;
	hda_nid_t nid;
3125
	int i, err, nums;
3126

3127
	nums = 0;
3128
	for (i = 0; i < cfg->hp_outs; i++) {
3129 3130 3131
		static const char *pfxs[] = {
			"Headphone", "Headphone2", "Headphone3",
		};
3132 3133 3134
		unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]);
		if (wid_caps & AC_WCAP_UNSOL_CAP)
			spec->hp_detect = 1;
3135
		if (nums >= ARRAY_SIZE(pfxs))
3136
			continue;
3137 3138
		nid = spec->hp_dacs[i];
		if (!nid)
3139
			continue;
3140 3141 3142
		err = create_controls(spec, pfxs[nums++], nid, 3);
		if (err < 0)
			return err;
3143
	}
3144 3145
	nums = 0;
	for (i = 0; i < cfg->speaker_outs; i++) {
3146 3147 3148
		static const char *pfxs[] = {
			"Speaker", "External Speaker", "Speaker2",
		};
3149 3150 3151 3152 3153 3154
		if (nums >= ARRAY_SIZE(pfxs))
			continue;
		nid = spec->speaker_dacs[i];
		if (!nid)
			continue;
		err = create_controls(spec, pfxs[nums++], nid, 3);
3155 3156 3157
		if (err < 0)
			return err;
	}
3158 3159 3160
	return 0;
}

3161
/* labels for mono mux outputs */
3162 3163
static const char *stac92xx_mono_labels[4] = {
	"DAC0", "DAC1", "Mixer", "DAC2"
3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186
};

/* 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);
	if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
		return -EINVAL;

	for (i = 0; i < num_cons; i++) {
		mono_mux->items[mono_mux->num_items].label =
					stac92xx_mono_labels[i];
		mono_mux->items[mono_mux->num_items].index = i;
		mono_mux->num_items++;
	}
3187 3188 3189

	return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
				"Mono Mux", spec->mono_nid);
3190 3191
}

3192 3193
/* labels for amp mux outputs */
static const char *stac92xx_amp_labels[3] = {
3194
	"Front Microphone", "Microphone", "Line In",
3195 3196 3197 3198 3199 3200 3201 3202 3203
};

/* create amp out controls mux on capable codecs */
static int stac92xx_auto_create_amp_output_ctls(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	struct hda_input_mux *amp_mux = &spec->private_amp_mux;
	int i, err;

M
Matthew Ranostay 已提交
3204
	for (i = 0; i < spec->num_amps; i++) {
3205 3206 3207 3208 3209 3210
		amp_mux->items[amp_mux->num_items].label =
					stac92xx_amp_labels[i];
		amp_mux->items[amp_mux->num_items].index = i;
		amp_mux->num_items++;
	}

M
Matthew Ranostay 已提交
3211 3212 3213 3214 3215 3216
	if (spec->num_amps > 1) {
		err = stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_MUX,
			"Amp Selector Capture Switch", 0);
		if (err < 0)
			return err;
	}
3217 3218 3219 3220 3221 3222
	return stac92xx_add_control(spec, STAC_CTL_WIDGET_AMP_VOL,
		"Amp Capture Volume",
		HDA_COMPOSE_AMP_VAL(spec->amp_nids[0], 3, 0, HDA_INPUT));
}


3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250
/* 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);
	int err;

	/* check for mute support for the the amp */
	if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
		err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
			"PC Beep Playback Switch",
			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,
			"PC Beep Playback Volume",
			HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
			if (err < 0)
				return err;
	}
	return 0;
}

3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287
#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);
	int enabled = !!ucontrol->value.integer.value[0];
	if (codec->beep->enabled != enabled) {
		codec->beep->enabled = enabled;
		return 1;
	}
	return 0;
}

static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
	.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,
					 0, "PC Beep Playback Switch", 0);
}
#endif

3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307
static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	int wcaps, nid, i, err = 0;

	for (i = 0; i < spec->num_muxes; i++) {
		nid = spec->mux_nids[i];
		wcaps = get_wcaps(codec, nid);

		if (wcaps & AC_WCAP_OUT_AMP) {
			err = stac92xx_add_control_idx(spec,
				STAC_CTL_WIDGET_VOL, i, "Mux Capture Volume",
				HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
			if (err < 0)
				return err;
		}
	}
	return 0;
};

M
Matthew Ranostay 已提交
3308
static const char *stac92xx_spdif_labels[3] = {
3309
	"Digital Playback", "Analog Mux 1", "Analog Mux 2",
M
Matthew Ranostay 已提交
3310 3311 3312 3313 3314 3315
};

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;
3316
	const char **labels = spec->spdif_labels;
M
Matthew Ranostay 已提交
3317
	int i, num_cons;
3318
	hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
M
Matthew Ranostay 已提交
3319 3320 3321 3322 3323

	num_cons = snd_hda_get_connections(codec,
				spec->smux_nids[0],
				con_lst,
				HDA_MAX_NUM_INPUTS);
3324
	if (!num_cons)
M
Matthew Ranostay 已提交
3325 3326
		return -EINVAL;

3327 3328 3329
	if (!labels)
		labels = stac92xx_spdif_labels;

M
Matthew Ranostay 已提交
3330
	for (i = 0; i < num_cons; i++) {
3331
		spdif_mux->items[spdif_mux->num_items].label = labels[i];
M
Matthew Ranostay 已提交
3332 3333 3334 3335 3336 3337 3338
		spdif_mux->items[spdif_mux->num_items].index = i;
		spdif_mux->num_items++;
	}

	return 0;
}

3339
/* labels for dmic mux inputs */
3340
static const char *stac92xx_dmic_labels[5] = {
3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351
	"Analog Inputs", "Digital Mic 1", "Digital Mic 2",
	"Digital Mic 3", "Digital Mic 4"
};

/* 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;
	struct hda_input_mux *dimux = &spec->private_dimux;
	hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3352 3353
	int err, i, j;
	char name[32];
3354 3355 3356 3357 3358 3359

	dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0];
	dimux->items[dimux->num_items].index = 0;
	dimux->num_items++;

	for (i = 0; i < spec->num_dmics; i++) {
3360
		hda_nid_t nid;
3361 3362
		int index;
		int num_cons;
3363
		unsigned int wcaps;
3364 3365 3366 3367 3368 3369 3370 3371 3372 3373
		unsigned int def_conf;

		def_conf = snd_hda_codec_read(codec,
					      spec->dmic_nids[i],
					      0,
					      AC_VERB_GET_CONFIG_DEFAULT,
					      0);
		if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
			continue;

3374
		nid = spec->dmic_nids[i];
3375
		num_cons = snd_hda_get_connections(codec,
3376
				spec->dmux_nids[0],
3377 3378 3379
				con_lst,
				HDA_MAX_NUM_INPUTS);
		for (j = 0; j < num_cons; j++)
3380
			if (con_lst[j] == nid) {
3381 3382 3383 3384 3385
				index = j;
				goto found;
			}
		continue;
found:
3386 3387
		wcaps = get_wcaps(codec, nid) &
			(AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3388

3389
		if (wcaps) {
3390 3391 3392 3393 3394 3395
			sprintf(name, "%s Capture Volume",
				stac92xx_dmic_labels[dimux->num_items]);

			err = stac92xx_add_control(spec,
				STAC_CTL_WIDGET_VOL,
				name,
3396 3397 3398
				HDA_COMPOSE_AMP_VAL(nid, 3, 0,
				(wcaps & AC_WCAP_OUT_AMP) ?
				HDA_OUTPUT : HDA_INPUT));
3399 3400 3401 3402
			if (err < 0)
				return err;
		}

3403 3404 3405 3406 3407 3408 3409 3410 3411
		dimux->items[dimux->num_items].label =
			stac92xx_dmic_labels[dimux->num_items];
		dimux->items[dimux->num_items].index = index;
		dimux->num_items++;
	}

	return 0;
}

3412 3413 3414 3415 3416 3417 3418 3419 3420
/* 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;
	hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
	int i, j, k;

	for (i = 0; i < AUTO_PIN_LAST; i++) {
3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436
		int index;

		if (!cfg->input_pins[i])
			continue;
		index = -1;
		for (j = 0; j < spec->num_muxes; j++) {
			int num_cons;
			num_cons = snd_hda_get_connections(codec,
							   spec->mux_nids[j],
							   con_lst,
							   HDA_MAX_NUM_INPUTS);
			for (k = 0; k < num_cons; k++)
				if (con_lst[k] == cfg->input_pins[i]) {
					index = k;
					goto found;
				}
3437
		}
3438 3439 3440 3441 3442
		continue;
	found:
		imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
		imux->items[imux->num_items].index = index;
		imux->num_items++;
3443 3444
	}

3445
	if (imux->num_items) {
3446 3447 3448 3449 3450 3451
		/*
		 * 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++) {
3452 3453 3454
			snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
						  AC_VERB_SET_CONNECT_SEL,
						  imux->items[0].index);
3455 3456 3457
		}
	}

3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474
	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;
3475
	int i;
3476

3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488
	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);
	}
3489 3490
}

3491
static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3492 3493 3494 3495
{
	struct sigmatel_spec *spec = codec->spec;
	int err;

3496 3497 3498
	if ((err = snd_hda_parse_pin_def_config(codec,
						&spec->autocfg,
						spec->dmic_nids)) < 0)
3499
		return err;
3500
	if (! spec->autocfg.line_outs)
M
Matt Porter 已提交
3501
		return 0; /* can't find valid pin config */
3502

3503 3504 3505 3506 3507 3508 3509 3510 3511
	/* If we have no real line-out pin and multiple hp-outs, HPs should
	 * be set up as multi-channel outputs.
	 */
	if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT &&
	    spec->autocfg.hp_outs > 1) {
		/* Copy hp_outs to line_outs, backup line_outs in
		 * speaker_outs so that the following routines can handle
		 * HP pins as primary outputs.
		 */
3512
		snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3513 3514 3515 3516 3517 3518
		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;
3519 3520
		spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
		spec->autocfg.hp_outs = 0;
3521
	}
3522
	if (spec->autocfg.mono_out_pin) {
3523 3524
		int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
			(AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545
		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],
				conn_list, 1)) {

				int wcaps = get_wcaps(codec, conn_list[0]);
				int wid_type = (wcaps & AC_WCAP_TYPE)
					>> AC_WCAP_TYPE_SHIFT;
				/* 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];
		}
3546 3547 3548 3549 3550 3551 3552 3553
		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));
3554 3555
			if (err < 0)
				return err;
3556 3557 3558 3559 3560 3561 3562 3563 3564 3565
			/* 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;
			}
3566 3567 3568 3569 3570
		}

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

3572 3573 3574
	if (!spec->multiout.num_dacs) {
		err = stac92xx_auto_fill_dac_nids(codec);
		if (err < 0)
3575
			return err;
3576 3577 3578 3579
		err = stac92xx_auto_create_multi_out_ctls(codec,
							  &spec->autocfg);
		if (err < 0)
			return err;
3580
	}
3581

3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593
	/* 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;
3594
		unsigned int caps;
3595 3596 3597 3598 3599 3600 3601

		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;
3602 3603 3604 3605 3606 3607 3608 3609
		/* if no beep switch is available, make its own one */
		caps = query_amp_caps(codec, nid, HDA_OUTPUT);
		if (codec->beep &&
		    !((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT)) {
			err = stac92xx_beep_switch_ctl(codec);
			if (err < 0)
				return err;
		}
3610 3611 3612
	}
#endif

3613 3614 3615 3616 3617 3618 3619 3620
	err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);

	if (err < 0)
		return err;

	err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);

	if (err < 0)
3621 3622
		return err;

3623 3624 3625 3626 3627
	if (spec->mono_nid > 0) {
		err = stac92xx_auto_create_mono_output_ctls(codec);
		if (err < 0)
			return err;
	}
M
Matthew Ranostay 已提交
3628
	if (spec->num_amps > 0) {
3629 3630 3631 3632
		err = stac92xx_auto_create_amp_output_ctls(codec);
		if (err < 0)
			return err;
	}
M
Matthew Ranostay 已提交
3633
	if (spec->num_dmics > 0 && !spec->dinput_mux)
3634 3635 3636
		if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
						&spec->autocfg)) < 0)
			return err;
3637 3638 3639 3640 3641
	if (spec->num_muxes > 0) {
		err = stac92xx_auto_create_mux_input_ctls(codec);
		if (err < 0)
			return err;
	}
M
Matthew Ranostay 已提交
3642 3643 3644 3645 3646
	if (spec->num_smuxes > 0) {
		err = stac92xx_auto_create_spdif_mux_ctls(codec);
		if (err < 0)
			return err;
	}
3647

3648
	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3649
	if (spec->multiout.max_channels > 2)
3650 3651
		spec->surr_switch = 1;

3652
	if (spec->autocfg.dig_out_pin)
3653
		spec->multiout.dig_out_nid = dig_out;
3654
	if (dig_in && spec->autocfg.dig_in_pin)
3655
		spec->dig_in_nid = dig_in;
3656

3657 3658
	if (spec->kctls.list)
		spec->mixers[spec->num_mixers++] = spec->kctls.list;
3659 3660

	spec->input_mux = &spec->private_imux;
M
Matthew Ranostay 已提交
3661 3662
	if (!spec->dinput_mux)
		spec->dinput_mux = &spec->private_dimux;
M
Matthew Ranostay 已提交
3663
	spec->sinput_mux = &spec->private_smux;
3664
	spec->mono_mux = &spec->private_mono_mux;
3665
	spec->amp_mux = &spec->private_amp_mux;
3666 3667 3668
	return 1;
}

3669 3670 3671 3672 3673
/* 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;
3674
	hda_nid_t pin = cfg->hp_pins[0];
3675 3676 3677 3678 3679 3680
	unsigned int wid_caps;

	if (! pin)
		return 0;

	wid_caps = get_wcaps(codec, pin);
3681
	if (wid_caps & AC_WCAP_UNSOL_CAP)
3682 3683 3684 3685 3686
		spec->hp_detect = 1;

	return 0;
}

3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702
/* 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];
3703
		unsigned int wcaps = get_wcaps(codec, pin);
3704 3705 3706 3707 3708 3709 3710 3711 3712 3713
		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];
3714
			unsigned int defcfg;
3715
			defcfg = snd_hda_codec_read(codec, pin, 0,
3716 3717
						 AC_VERB_GET_CONFIG_DEFAULT,
						 0x00);
3718
			if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3719
				unsigned int wcaps = get_wcaps(codec, pin);
3720 3721 3722 3723 3724 3725 3726 3727 3728 3729
				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) {
3730
		err = create_controls(spec, "LFE", lfe_pin, 1);
3731 3732 3733 3734 3735 3736 3737
		if (err < 0)
			return err;
	}

	return 0;
}

3738 3739 3740 3741 3742
static int stac9200_parse_auto_config(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
	int err;

3743
	if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3744 3745 3746 3747 3748
		return err;

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

3749 3750 3751
	if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
		return err;

3752 3753 3754
	if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
		return err;

3755 3756 3757 3758 3759 3760
	if (spec->num_muxes > 0) {
		err = stac92xx_auto_create_mux_input_ctls(codec);
		if (err < 0)
			return err;
	}

3761
	if (spec->autocfg.dig_out_pin)
3762
		spec->multiout.dig_out_nid = 0x05;
3763
	if (spec->autocfg.dig_in_pin)
3764 3765
		spec->dig_in_nid = 0x04;

3766 3767
	if (spec->kctls.list)
		spec->mixers[spec->num_mixers++] = spec->kctls.list;
3768 3769

	spec->input_mux = &spec->private_imux;
3770
	spec->dinput_mux = &spec->private_dimux;
3771 3772 3773 3774

	return 1;
}

3775 3776 3777 3778 3779
/*
 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
 * funky external mute control using GPIO pins.
 */

3780
static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
3781
			  unsigned int dir_mask, unsigned int data)
3782 3783 3784 3785 3786
{
	unsigned int gpiostate, gpiomask, gpiodir;

	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
				       AC_VERB_GET_GPIO_DATA, 0);
3787
	gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
3788 3789 3790

	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
				      AC_VERB_GET_GPIO_MASK, 0);
3791
	gpiomask |= mask;
3792 3793 3794

	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
				     AC_VERB_GET_GPIO_DIRECTION, 0);
3795
	gpiodir |= dir_mask;
3796

3797
	/* Configure GPIOx as CMOS */
3798 3799 3800 3801
	snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);

	snd_hda_codec_write(codec, codec->afg, 0,
			    AC_VERB_SET_GPIO_MASK, gpiomask);
3802 3803
	snd_hda_codec_read(codec, codec->afg, 0,
			   AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
3804 3805 3806

	msleep(1);

3807 3808
	snd_hda_codec_read(codec, codec->afg, 0,
			   AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
3809 3810
}

3811 3812 3813
static int stac92xx_add_jack(struct hda_codec *codec,
		hda_nid_t nid, int type)
{
3814
#ifdef CONFIG_SND_JACK
3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837
	struct sigmatel_spec *spec = codec->spec;
	struct sigmatel_jack *jack;
	int def_conf = snd_hda_codec_read(codec, nid,
			0, AC_VERB_GET_CONFIG_DEFAULT, 0);
	int connectivity = get_defcfg_connect(def_conf);
	char name[32];

	if (connectivity && connectivity != AC_JACK_PORT_FIXED)
		return 0;

	snd_array_init(&spec->jacks, sizeof(*jack), 32);
	jack = snd_array_new(&spec->jacks);
	if (!jack)
		return -ENOMEM;
	jack->nid = nid;
	jack->type = type;

	sprintf(name, "%s at %s %s Jack",
		snd_hda_get_jack_type(def_conf),
		snd_hda_get_jack_connectivity(def_conf),
		snd_hda_get_jack_location(def_conf));

	return snd_jack_new(codec->bus->card, name, type, &jack->jack);
3838 3839 3840
#else
	return 0;
#endif
3841 3842
}

3843 3844
static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
			  unsigned char type, int data)
3845 3846 3847 3848 3849 3850 3851 3852
{
	struct sigmatel_event *event;

	snd_array_init(&spec->events, sizeof(*event), 32);
	event = snd_array_new(&spec->events);
	if (!event)
		return -ENOMEM;
	event->nid = nid;
3853 3854
	event->type = type;
	event->tag = spec->events.used;
3855 3856
	event->data = data;

3857
	return event->tag;
3858 3859
}

3860 3861
static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
					     hda_nid_t nid, unsigned char type)
3862 3863
{
	struct sigmatel_spec *spec = codec->spec;
3864 3865 3866 3867 3868 3869
	struct sigmatel_event *event = spec->events.list;
	int i;

	for (i = 0; i < spec->events.used; i++, event++) {
		if (event->nid == nid && event->type == type)
			return event;
3870
	}
3871
	return NULL;
3872 3873
}

3874 3875
static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
						      unsigned char tag)
3876
{
3877 3878 3879 3880 3881 3882 3883
	struct sigmatel_spec *spec = codec->spec;
	struct sigmatel_event *event = spec->events.list;
	int i;

	for (i = 0; i < spec->events.used; i++, event++) {
		if (event->tag == tag)
			return event;
3884
	}
3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905
	return NULL;
}

static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
			      unsigned int type)
{
	struct sigmatel_event *event;
	int tag;

	if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
		return;
	event = stac_get_event(codec, nid, type);
	if (event)
		tag = event->tag;
	else
		tag = stac_add_event(codec->spec, nid, type, 0);
	if (tag < 0)
		return;
	snd_hda_codec_write_cache(codec, nid, 0,
				  AC_VERB_SET_UNSOLICITED_ENABLE,
				  AC_USRSP_EN | tag);
3906 3907
}

3908 3909 3910 3911 3912 3913 3914 3915 3916 3917
static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
{
	int i;
	for (i = 0; i < cfg->hp_outs; i++)
		if (cfg->hp_pins[i] == nid)
			return 1; /* nid is a HP-Out */

	return 0; /* nid is not a HP-Out */
};

3918 3919 3920 3921 3922 3923 3924
static void stac92xx_power_down(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;

	/* power down inactive DACs */
	hda_nid_t *dac;
	for (dac = spec->dac_list; *dac; dac++)
3925
		if (!check_all_dac_nids(spec, *dac))
3926
			snd_hda_codec_write(codec, *dac, 0,
3927 3928 3929
					AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
}

3930 3931 3932
static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
				  int enable);

3933 3934 3935
static int stac92xx_init(struct hda_codec *codec)
{
	struct sigmatel_spec *spec = codec->spec;
3936
	struct auto_pin_cfg *cfg = &spec->autocfg;
3937
	unsigned int gpio;
3938
	int i;
3939 3940 3941

	snd_hda_sequence_write(codec, spec->init);

M
Matthew Ranostay 已提交
3942 3943 3944
	/* power down adcs initially */
	if (spec->powerdown_adcs)
		for (i = 0; i < spec->num_adcs; i++)
3945
			snd_hda_codec_write(codec,
M
Matthew Ranostay 已提交
3946 3947
				spec->adc_nids[i], 0,
				AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
3948 3949 3950 3951 3952 3953 3954 3955 3956 3957

	/* 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);

3958 3959
	/* set up pins */
	if (spec->hp_detect) {
3960
		/* Enable unsolicited responses on the HP widget */
3961 3962
		for (i = 0; i < cfg->hp_outs; i++) {
			hda_nid_t nid = cfg->hp_pins[i];
3963
			enable_pin_detect(codec, nid, STAC_HP_EVENT);
3964
		}
3965 3966 3967 3968
		/* 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],
3969
				AC_PINCTL_OUT_EN);
3970
		/* fake event to set up pins */
3971 3972
		stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
				       STAC_HP_EVENT);
3973 3974 3975
	} else {
		stac92xx_auto_init_multi_out(codec);
		stac92xx_auto_init_hp_out(codec);
3976 3977
		for (i = 0; i < cfg->hp_outs; i++)
			stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
3978 3979
	}
	for (i = 0; i < AUTO_PIN_LAST; i++) {
3980 3981
		hda_nid_t nid = cfg->input_pins[i];
		if (nid) {
3982
			unsigned int pinctl, conf;
3983 3984 3985
			if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) {
				/* for mic pins, force to initialize */
				pinctl = stac92xx_get_vref(codec, nid);
3986 3987
				pinctl |= AC_PINCTL_IN_EN;
				stac92xx_auto_set_pinctl(codec, nid, pinctl);
3988 3989 3990 3991
			} else {
				pinctl = snd_hda_codec_read(codec, nid, 0,
					AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
				/* if PINCTL already set then skip */
3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004
				if (!(pinctl & AC_PINCTL_IN_EN)) {
					pinctl |= AC_PINCTL_IN_EN;
					stac92xx_auto_set_pinctl(codec, nid,
								 pinctl);
				}
			}
			conf = snd_hda_codec_read(codec, nid, 0,
					      AC_VERB_GET_CONFIG_DEFAULT, 0);
			if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
				enable_pin_detect(codec, nid,
						  STAC_INSERT_EVENT);
				stac_issue_unsol_event(codec, nid,
						       STAC_INSERT_EVENT);
4005
			}
4006
		}
4007
	}
4008 4009 4010
	for (i = 0; i < spec->num_dmics; i++)
		stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
					AC_PINCTL_IN_EN);
4011 4012 4013 4014 4015 4016
	if (cfg->dig_out_pin)
		stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin,
					 AC_PINCTL_OUT_EN);
	if (cfg->dig_in_pin)
		stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
					 AC_PINCTL_IN_EN);
4017
	for (i = 0; i < spec->num_pwrs; i++)  {
4018 4019 4020
		hda_nid_t nid = spec->pwr_nids[i];
		int pinctl, def_conf;

4021 4022 4023 4024 4025 4026 4027
		/* power on when no jack detection is available */
		if (!spec->hp_detect) {
			stac_toggle_power_map(codec, nid, 1);
			continue;
		}

		if (is_nid_hp_pin(cfg, nid))
4028 4029 4030 4031
			continue; /* already has an unsol event */

		pinctl = snd_hda_codec_read(codec, nid, 0,
					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4032 4033 4034 4035
		/* outputs are only ports capable of power management
		 * any attempts on powering down a input port cause the
		 * referenced VREF to act quirky.
		 */
4036 4037
		if (pinctl & AC_PINCTL_IN_EN) {
			stac_toggle_power_map(codec, nid, 1);
4038
			continue;
4039
		}
4040 4041 4042
		def_conf = snd_hda_codec_read(codec, nid, 0,
					      AC_VERB_GET_CONFIG_DEFAULT, 0);
		def_conf = get_defcfg_connect(def_conf);
4043 4044
		/* skip any ports that don't have jacks since presence
 		 * detection is useless */
4045 4046 4047
		if (def_conf != AC_JACK_PORT_COMPLEX) {
			if (def_conf != AC_JACK_PORT_NONE)
				stac_toggle_power_map(codec, nid, 1);
4048
			continue;
4049
		}
4050 4051 4052 4053
		if (!stac_get_event(codec, nid, STAC_INSERT_EVENT)) {
			enable_pin_detect(codec, nid, STAC_PWR_EVENT);
			stac_issue_unsol_event(codec, nid, STAC_PWR_EVENT);
		}
4054
	}
4055 4056
	if (spec->dac_list)
		stac92xx_power_down(codec);
4057 4058 4059
	return 0;
}

4060 4061
static void stac92xx_free_jacks(struct hda_codec *codec)
{
4062
#ifdef CONFIG_SND_JACK
4063
	/* free jack instances manually when clearing/reconfiguring */
4064
	struct sigmatel_spec *spec = codec->spec;
4065
	if (!codec->bus->shutdown && spec->jacks.list) {
4066 4067 4068 4069 4070 4071
		struct sigmatel_jack *jacks = spec->jacks.list;
		int i;
		for (i = 0; i < spec->jacks.used; i++)
			snd_device_free(codec->bus->card, &jacks[i].jack);
	}
	snd_array_free(&spec->jacks);
4072
#endif
4073 4074
}

4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087
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);
}

M
Matt 已提交
4088 4089
static void stac92xx_free(struct hda_codec *codec)
{
4090 4091 4092 4093 4094
	struct sigmatel_spec *spec = codec->spec;

	if (! spec)
		return;

4095
	kfree(spec->pin_configs);
4096 4097
	stac92xx_free_jacks(codec);
	snd_array_free(&spec->events);
4098

4099
	kfree(spec);
4100
	snd_hda_detach_beep_device(codec);
M
Matt 已提交
4101 4102
}

4103 4104 4105 4106 4107
static void stac92xx_set_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);
4108

4109 4110 4111 4112 4113 4114 4115
	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;
4116
		if (nid == spec->line_switch || nid == spec->mic_switch)
4117 4118 4119
			return;
	}

4120 4121 4122 4123 4124
	/* 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);
	
4125
	snd_hda_codec_write_cache(codec, nid, 0,
4126 4127 4128 4129 4130 4131 4132 4133 4134
			AC_VERB_SET_PIN_WIDGET_CONTROL,
			pin_ctl | flag);
}

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);
4135
	snd_hda_codec_write_cache(codec, nid, 0,
4136 4137 4138 4139
			AC_VERB_SET_PIN_WIDGET_CONTROL,
			pin_ctl & ~flag);
}

4140
static int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4141 4142 4143 4144
{
	if (!nid)
		return 0;
	if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00)
4145 4146
	    & (1 << 31))
		return 1;
4147 4148 4149
	return 0;
}

4150 4151 4152 4153 4154 4155 4156 4157
/* 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 */
4158
	if (cfg->hp_pins[i] == spec->line_switch)
4159
		return 1;
4160
	if (cfg->hp_pins[i] == spec->mic_switch)
4161 4162 4163 4164 4165 4166 4167
		return 1;
	/* ignore if the pin is set as line-out */
	if (cfg->hp_pins[i] == spec->hp_switch)
		return 1;
	return 0;
}

4168
static void stac92xx_hp_detect(struct hda_codec *codec)
4169 4170 4171 4172 4173
{
	struct sigmatel_spec *spec = codec->spec;
	struct auto_pin_cfg *cfg = &spec->autocfg;
	int i, presence;

4174
	presence = 0;
4175 4176 4177 4178
	if (spec->gpio_mute)
		presence = !(snd_hda_codec_read(codec, codec->afg, 0,
			AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);

4179
	for (i = 0; i < cfg->hp_outs; i++) {
4180 4181
		if (presence)
			break;
4182 4183
		if (no_hp_sensing(spec, i))
			continue;
4184 4185 4186 4187 4188 4189 4190 4191
		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 */
		}
4192
	}
4193 4194

	if (presence) {
4195
		/* disable lineouts */
4196
		if (spec->hp_switch)
4197 4198
			stac92xx_reset_pinctl(codec, spec->hp_switch,
					      AC_PINCTL_OUT_EN);
4199 4200 4201
		for (i = 0; i < cfg->line_outs; i++)
			stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
						AC_PINCTL_OUT_EN);
4202 4203 4204
		for (i = 0; i < cfg->speaker_outs; i++)
			stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
						AC_PINCTL_OUT_EN);
M
Matthew Ranostay 已提交
4205
		if (spec->eapd_mask && spec->eapd_switch)
4206 4207 4208
			stac_gpio_set(codec, spec->gpio_mask,
				spec->gpio_dir, spec->gpio_data &
				~spec->eapd_mask);
4209
	} else {
4210
		/* enable lineouts */
4211
		if (spec->hp_switch)
4212 4213
			stac92xx_set_pinctl(codec, spec->hp_switch,
					    AC_PINCTL_OUT_EN);
4214 4215 4216
		for (i = 0; i < cfg->line_outs; i++)
			stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
						AC_PINCTL_OUT_EN);
4217 4218 4219
		for (i = 0; i < cfg->speaker_outs; i++)
			stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
						AC_PINCTL_OUT_EN);
M
Matthew Ranostay 已提交
4220
		if (spec->eapd_mask && spec->eapd_switch)
4221 4222 4223
			stac_gpio_set(codec, spec->gpio_mask,
				spec->gpio_dir, spec->gpio_data |
				spec->eapd_mask);
4224
	}
4225 4226 4227 4228 4229 4230 4231
	/* 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;
		if (presence)
			stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4232 4233 4234 4235 4236 4237 4238 4239 4240 4241
#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... 
 */
4242 4243
		else
			stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4244
#endif /* FIXME */
4245
	}
4246 4247
} 

4248 4249
static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
				  int enable)
4250 4251
{
	struct sigmatel_spec *spec = codec->spec;
4252 4253 4254 4255 4256 4257 4258 4259
	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;
4260 4261 4262 4263 4264 4265

	/* several codecs have two power down bits */
	if (spec->pwr_mapping)
		idx = spec->pwr_mapping[idx];
	else
		idx = 1 << idx;
4266

4267 4268
	val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
	if (enable)
4269 4270 4271 4272 4273 4274
		val &= ~idx;
	else
		val |= idx;

	/* power down unused output ports */
	snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4275 4276
}

4277 4278
static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
{
4279
	stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4280
}
4281

4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300
static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid)
{
	struct sigmatel_spec *spec = codec->spec;
	struct sigmatel_jack *jacks = spec->jacks.list;

	if (jacks) {
		int i;
		for (i = 0; i < spec->jacks.used; i++) {
			if (jacks->nid == nid) {
				unsigned int pin_ctl =
					snd_hda_codec_read(codec, nid,
					0, AC_VERB_GET_PIN_WIDGET_CONTROL,
					 0x00);
				int type = jacks->type;
				if (type == (SND_JACK_LINEOUT
						| SND_JACK_HEADPHONE))
					type = (pin_ctl & AC_PINCTL_HP_EN)
					? SND_JACK_HEADPHONE : SND_JACK_LINEOUT;
				snd_jack_report(jacks->jack,
4301
					get_pin_presence(codec, nid)
4302 4303 4304 4305 4306 4307
					? type : 0);
			}
			jacks++;
		}
	}
}
4308

4309 4310 4311 4312 4313 4314 4315 4316 4317
static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid,
				   unsigned char type)
{
	struct sigmatel_event *event = stac_get_event(codec, nid, type);
	if (!event)
		return;
	codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
}

4318 4319
static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
{
4320
	struct sigmatel_spec *spec = codec->spec;
4321 4322
	struct sigmatel_event *event;
	int tag, data;
4323

4324 4325 4326 4327 4328 4329
	tag = (res >> 26) & 0x7f;
	event = stac_get_event_from_tag(codec, tag);
	if (!event)
		return;

	switch (event->type) {
4330
	case STAC_HP_EVENT:
4331
		stac92xx_hp_detect(codec);
4332
		/* fallthru */
4333
	case STAC_INSERT_EVENT:
4334
	case STAC_PWR_EVENT:
4335 4336 4337
		if (spec->num_pwrs > 0)
			stac92xx_pin_sense(codec, event->nid);
		stac92xx_report_jack(codec, event->nid);
4338
		break;
4339 4340 4341
	case STAC_VREF_EVENT:
		data = snd_hda_codec_read(codec, codec->afg, 0,
					  AC_VERB_GET_GPIO_DATA, 0);
4342 4343
		/* toggle VREF state based on GPIOx status */
		snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4344
				    !!(data & (1 << event->data)));
4345
		break;
4346 4347 4348
	}
}

4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394
#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", 
			    snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
}

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

4395
#ifdef SND_HDA_NEEDS_RESUME
4396 4397
static int stac92xx_resume(struct hda_codec *codec)
{
4398 4399
	struct sigmatel_spec *spec = codec->spec;

4400
	stac92xx_set_config_regs(codec);
4401
	stac92xx_init(codec);
4402 4403
	snd_hda_codec_resume_amp(codec);
	snd_hda_codec_resume_cache(codec);
4404
	/* fake event to set up pins again to override cached values */
4405
	if (spec->hp_detect)
4406 4407
		stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0],
				       STAC_HP_EVENT);
4408 4409
	return 0;
}
M
Matthew Ranostay 已提交
4410 4411 4412 4413 4414 4415 4416 4417 4418 4419

static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
{
	struct sigmatel_spec *spec = codec->spec;
	if (spec->eapd_mask)
		stac_gpio_set(codec, spec->gpio_mask,
				spec->gpio_dir, spec->gpio_data &
				~spec->eapd_mask);
	return 0;
}
4420 4421
#endif

M
Matt 已提交
4422 4423 4424 4425 4426
static struct hda_codec_ops stac92xx_patch_ops = {
	.build_controls = stac92xx_build_controls,
	.build_pcms = stac92xx_build_pcms,
	.init = stac92xx_init,
	.free = stac92xx_free,
4427
	.unsol_event = stac92xx_unsol_event,
4428
#ifdef SND_HDA_NEEDS_RESUME
M
Matthew Ranostay 已提交
4429
	.suspend = stac92xx_suspend,
4430 4431
	.resume = stac92xx_resume,
#endif
M
Matt 已提交
4432 4433 4434 4435 4436
};

static int patch_stac9200(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
4437
	int err;
M
Matt 已提交
4438

4439
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
M
Matt 已提交
4440 4441 4442 4443
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
4444
	spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
4445
	spec->pin_nids = stac9200_pin_nids;
4446 4447 4448
	spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
							stac9200_models,
							stac9200_cfg_tbl);
4449 4450 4451
	if (spec->board_config < 0) {
		snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n");
		err = stac92xx_save_bios_config_regs(codec);
4452 4453 4454 4455 4456 4457
	} else
		err = stac_save_pin_cfgs(codec,
					 stac9200_brd_tbl[spec->board_config]);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
4458
	}
M
Matt 已提交
4459 4460 4461 4462 4463 4464

	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;
4465
	spec->num_muxes = 1;
4466
	spec->num_dmics = 0;
4467
	spec->num_adcs = 1;
4468
	spec->num_pwrs = 0;
4469

4470 4471
	if (spec->board_config == STAC_9200_M4 ||
	    spec->board_config == STAC_9200_M4_2 ||
4472
	    spec->board_config == STAC_9200_OQO)
4473 4474 4475
		spec->init = stac9200_eapd_init;
	else
		spec->init = stac9200_core_init;
M
Matt 已提交
4476
	spec->mixer = stac9200_mixer;
4477

4478 4479 4480 4481 4482
	if (spec->board_config == STAC_9200_PANASONIC) {
		spec->gpio_mask = spec->gpio_dir = 0x09;
		spec->gpio_data = 0x00;
	}

4483 4484 4485 4486 4487
	err = stac9200_parse_auto_config(codec);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}
M
Matt 已提交
4488

4489 4490 4491 4492 4493 4494
	/* CF-74 has no headphone detection, and the driver should *NOT*
	 * do detection and HP/speaker toggle because the hardware does it.
	 */
	if (spec->board_config == STAC_9200_PANASONIC)
		spec->hp_detect = 0;

M
Matt 已提交
4495 4496 4497 4498 4499
	codec->patch_ops = stac92xx_patch_ops;

	return 0;
}

4500 4501 4502 4503 4504 4505 4506 4507 4508 4509
static int patch_stac925x(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
	int err;

	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
4510
	spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
4511
	spec->pin_nids = stac925x_pin_nids;
4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522

	/* Check first for codec ID */
	spec->board_config = snd_hda_check_board_codec_sid_config(codec,
							STAC_925x_MODELS,
							stac925x_models,
							stac925x_codec_id_cfg_tbl);

	/* Now checks for PCI ID, if codec ID is not found */
	if (spec->board_config < 0)
		spec->board_config = snd_hda_check_board_config(codec,
							STAC_925x_MODELS,
4523 4524
							stac925x_models,
							stac925x_cfg_tbl);
4525
 again:
4526
	if (spec->board_config < 0) {
4527
		snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x,"
4528
				      "using BIOS defaults\n");
4529
		err = stac92xx_save_bios_config_regs(codec);
4530 4531 4532 4533 4534 4535
	} else
		err = stac_save_pin_cfgs(codec,
					 stac925x_brd_tbl[spec->board_config]);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
4536 4537 4538 4539 4540 4541 4542 4543
	}

	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;
4544
	spec->num_adcs = 1;
4545
	spec->num_pwrs = 0;
4546 4547 4548 4549 4550
	switch (codec->vendor_id) {
	case 0x83847632: /* STAC9202  */
	case 0x83847633: /* STAC9202D */
	case 0x83847636: /* STAC9251  */
	case 0x83847637: /* STAC9251D */
4551
		spec->num_dmics = STAC925X_NUM_DMICS;
4552
		spec->dmic_nids = stac925x_dmic_nids;
4553 4554
		spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
		spec->dmux_nids = stac925x_dmux_nids;
4555 4556 4557 4558 4559
		break;
	default:
		spec->num_dmics = 0;
		break;
	}
4560 4561 4562 4563 4564

	spec->init = stac925x_core_init;
	spec->mixer = stac925x_mixer;

	err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
4565 4566 4567 4568 4569 4570 4571 4572 4573
	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_925x_REF;
			goto again;
		}
		err = -EINVAL;
	}
4574 4575 4576 4577 4578 4579 4580 4581 4582 4583
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}

	codec->patch_ops = stac92xx_patch_ops;

	return 0;
}

4584 4585 4586 4587 4588 4589
static struct hda_input_mux stac92hd73xx_dmux = {
	.num_items = 4,
	.items = {
		{ "Analog Inputs", 0x0b },
		{ "Digital Mic 1", 0x09 },
		{ "Digital Mic 2", 0x0a },
M
Matthew Ranostay 已提交
4590
		{ "CD", 0x08 },
4591 4592 4593 4594 4595 4596 4597 4598
	}
};

static int patch_stac92hd73xx(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
	hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
	int err = 0;
4599
	int num_dacs;
4600 4601 4602 4603 4604 4605

	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
4606
	codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617
	spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
	spec->pin_nids = stac92hd73xx_pin_nids;
	spec->board_config = snd_hda_check_board_config(codec,
							STAC_92HD73XX_MODELS,
							stac92hd73xx_models,
							stac92hd73xx_cfg_tbl);
again:
	if (spec->board_config < 0) {
		snd_printdd(KERN_INFO "hda_codec: Unknown model for"
			" STAC92HD73XX, using BIOS defaults\n");
		err = stac92xx_save_bios_config_regs(codec);
4618 4619 4620 4621 4622 4623
	} else
		err = stac_save_pin_cfgs(codec,
				stac92hd73xx_brd_tbl[spec->board_config]);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
4624 4625
	}

4626
	num_dacs = snd_hda_get_connections(codec, 0x0a,
4627 4628
			conn, STAC92HD73_DAC_COUNT + 2) - 1;

4629
	if (num_dacs < 3 || num_dacs > 5) {
4630 4631
		printk(KERN_WARNING "hda_codec: Could not determine "
		       "number of channels defaulting to DAC count\n");
4632
		num_dacs = STAC92HD73_DAC_COUNT;
4633
	}
4634
	switch (num_dacs) {
4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645
	case 0x3: /* 6 Channel */
		spec->mixer = stac92hd73xx_6ch_mixer;
		spec->init = stac92hd73xx_6ch_core_init;
		break;
	case 0x4: /* 8 Channel */
		spec->mixer = stac92hd73xx_8ch_mixer;
		spec->init = stac92hd73xx_8ch_core_init;
		break;
	case 0x5: /* 10 Channel */
		spec->mixer = stac92hd73xx_10ch_mixer;
		spec->init = stac92hd73xx_10ch_core_init;
4646 4647
	}
	spec->multiout.dac_nids = spec->dac_nids;
4648 4649 4650 4651

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

4652
	spec->digbeep_nid = 0x1c;
4653 4654 4655 4656
	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 已提交
4657
	spec->smux_nids = stac92hd73xx_smux_nids;
4658
	spec->amp_nids = stac92hd73xx_amp_nids;
M
Matthew Ranostay 已提交
4659
	spec->num_amps = ARRAY_SIZE(stac92hd73xx_amp_nids);
4660 4661 4662

	spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
	spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
4663
	spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
M
Matthew Ranostay 已提交
4664 4665 4666
	memcpy(&spec->private_dimux, &stac92hd73xx_dmux,
			sizeof(stac92hd73xx_dmux));

4667
	switch (spec->board_config) {
4668
	case STAC_DELL_EQ:
4669
		spec->init = dell_eq_core_init;
4670
		/* fallthru */
4671 4672 4673
	case STAC_DELL_M6_AMIC:
	case STAC_DELL_M6_DMIC:
	case STAC_DELL_M6_BOTH:
M
Matthew Ranostay 已提交
4674 4675 4676
		spec->num_smuxes = 0;
		spec->mixer = &stac92hd73xx_6ch_mixer[DELL_M6_MIXER];
		spec->amp_nids = &stac92hd73xx_amp_nids[DELL_M6_AMP];
M
Matthew Ranostay 已提交
4677
		spec->eapd_switch = 0;
M
Matthew Ranostay 已提交
4678
		spec->num_amps = 1;
4679

4680
		if (spec->board_config != STAC_DELL_EQ)
4681
			spec->init = dell_m6_core_init;
4682 4683
		switch (spec->board_config) {
		case STAC_DELL_M6_AMIC: /* Analog Mics */
4684 4685
			stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
			spec->num_dmics = 0;
M
Matthew Ranostay 已提交
4686
			spec->private_dimux.num_items = 1;
4687
			break;
4688
		case STAC_DELL_M6_DMIC: /* Digital Mics */
4689 4690
			stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
			spec->num_dmics = 1;
M
Matthew Ranostay 已提交
4691
			spec->private_dimux.num_items = 2;
4692
			break;
4693
		case STAC_DELL_M6_BOTH: /* Both */
4694 4695 4696
			stac92xx_set_config_reg(codec, 0x0b, 0x90A70170);
			stac92xx_set_config_reg(codec, 0x13, 0x90A60160);
			spec->num_dmics = 1;
M
Matthew Ranostay 已提交
4697
			spec->private_dimux.num_items = 2;
4698 4699 4700 4701 4702
			break;
		}
		break;
	default:
		spec->num_dmics = STAC92HD73XX_NUM_DMICS;
M
Matthew Ranostay 已提交
4703
		spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
M
Matthew Ranostay 已提交
4704
		spec->eapd_switch = 1;
4705
	}
4706 4707 4708 4709 4710
	if (spec->board_config > STAC_92HD73XX_REF) {
		/* GPIO0 High = Enable EAPD */
		spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
		spec->gpio_data = 0x01;
	}
M
Matthew Ranostay 已提交
4711
	spec->dinput_mux = &spec->private_dimux;
4712

4713 4714 4715
	spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
	spec->pwr_nids = stac92hd73xx_pwr_nids;

M
Matthew Ranostay 已提交
4716
	err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732

	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;
	}

4733 4734 4735
	if (spec->board_config == STAC_92HD73XX_NO_JD)
		spec->hp_detect = 0;

4736 4737
	codec->patch_ops = stac92xx_patch_ops;

4738 4739
	codec->proc_widget_hook = stac92hd7x_proc_hook;

4740 4741 4742
	return 0;
}

4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754
static struct hda_input_mux stac92hd83xxx_dmux = {
	.num_items = 3,
	.items = {
		{ "Analog Inputs", 0x03 },
		{ "Digital Mic 1", 0x04 },
		{ "Digital Mic 2", 0x05 },
	}
};

static int patch_stac92hd83xxx(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
4755
	hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
4756
	int err;
4757
	int num_dacs;
4758 4759 4760 4761 4762 4763

	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
4764
	codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
4765 4766 4767 4768 4769 4770
	spec->mono_nid = 0x19;
	spec->digbeep_nid = 0x21;
	spec->dmic_nids = stac92hd83xxx_dmic_nids;
	spec->dmux_nids = stac92hd83xxx_dmux_nids;
	spec->adc_nids = stac92hd83xxx_adc_nids;
	spec->pwr_nids = stac92hd83xxx_pwr_nids;
4771
	spec->amp_nids = stac92hd83xxx_amp_nids;
4772 4773
	spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
	spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
4774
	spec->multiout.dac_nids = spec->dac_nids;
4775

4776 4777 4778 4779 4780 4781 4782 4783 4784

	/* set port 0xe to select the last DAC
	 */
	num_dacs = snd_hda_get_connections(codec, 0x0e,
		conn, STAC92HD83_DAC_COUNT + 1) - 1;

	snd_hda_codec_write_cache(codec, 0xe, 0,
		AC_VERB_SET_CONNECT_SEL, num_dacs);

4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796
	spec->init = stac92hd83xxx_core_init;
	switch (codec->vendor_id) {
	case 0x111d7605:
		break;
	default:
		spec->num_pwrs--;
	}

	spec->mixer = stac92hd83xxx_mixer;
	spec->num_pins = ARRAY_SIZE(stac92hd83xxx_pin_nids);
	spec->num_dmuxes = ARRAY_SIZE(stac92hd83xxx_dmux_nids);
	spec->num_adcs = ARRAY_SIZE(stac92hd83xxx_adc_nids);
4797
	spec->num_amps = ARRAY_SIZE(stac92hd83xxx_amp_nids);
4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809
	spec->num_dmics = STAC92HD83XXX_NUM_DMICS;
	spec->dinput_mux = &stac92hd83xxx_dmux;
	spec->pin_nids = stac92hd83xxx_pin_nids;
	spec->board_config = snd_hda_check_board_config(codec,
							STAC_92HD83XXX_MODELS,
							stac92hd83xxx_models,
							stac92hd83xxx_cfg_tbl);
again:
	if (spec->board_config < 0) {
		snd_printdd(KERN_INFO "hda_codec: Unknown model for"
			" STAC92HD83XXX, using BIOS defaults\n");
		err = stac92xx_save_bios_config_regs(codec);
4810 4811 4812 4813 4814 4815
	} else
		err = stac_save_pin_cfgs(codec,
				stac92hd83xxx_brd_tbl[spec->board_config]);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835
	}

	err = stac92xx_parse_auto_config(codec, 0x1d, 0);
	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;
	}

	codec->patch_ops = stac92xx_patch_ops;

4836 4837
	codec->proc_widget_hook = stac92hd_proc_hook;

4838 4839 4840
	return 0;
}

4841 4842 4843 4844 4845 4846 4847 4848 4849 4850
static struct hda_input_mux stac92hd71bxx_dmux = {
	.num_items = 4,
	.items = {
		{ "Analog Inputs", 0x00 },
		{ "Mixer", 0x01 },
		{ "Digital Mic 1", 0x02 },
		{ "Digital Mic 2", 0x03 },
	}
};

4851 4852 4853 4854 4855 4856 4857 4858 4859 4860
static int patch_stac92hd71bxx(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
	int err = 0;

	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
M
Matthew Ranostay 已提交
4861
	codec->patch_ops = stac92xx_patch_ops;
4862
	spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids);
4863
	spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
4864
	spec->pin_nids = stac92hd71bxx_pin_nids;
4865 4866
	memcpy(&spec->private_dimux, &stac92hd71bxx_dmux,
			sizeof(stac92hd71bxx_dmux));
4867 4868 4869 4870 4871 4872 4873 4874 4875
	spec->board_config = snd_hda_check_board_config(codec,
							STAC_92HD71BXX_MODELS,
							stac92hd71bxx_models,
							stac92hd71bxx_cfg_tbl);
again:
	if (spec->board_config < 0) {
		snd_printdd(KERN_INFO "hda_codec: Unknown model for"
			" STAC92HD71BXX, using BIOS defaults\n");
		err = stac92xx_save_bios_config_regs(codec);
4876 4877 4878 4879 4880 4881
	} else
		err = stac_save_pin_cfgs(codec,
				stac92hd71bxx_brd_tbl[spec->board_config]);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
4882 4883
	}

4884 4885 4886 4887 4888 4889 4890
	if (spec->board_config > STAC_92HD71BXX_REF) {
		/* GPIO0 = EAPD */
		spec->gpio_mask = 0x01;
		spec->gpio_dir = 0x01;
		spec->gpio_data = 0x01;
	}

4891 4892 4893 4894 4895 4896 4897
	switch (codec->vendor_id) {
	case 0x111d76b6: /* 4 Port without Analog Mixer */
	case 0x111d76b7:
	case 0x111d76b4: /* 6 Port without Analog Mixer */
	case 0x111d76b5:
		spec->mixer = stac92hd71bxx_mixer;
		spec->init = stac92hd71bxx_core_init;
4898
		codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4899
		break;
4900
	case 0x111d7608: /* 5 Port with Analog Mixer */
4901 4902
		switch (spec->board_config) {
		case STAC_HP_M4:
4903
			/* Enable VREF power saving on GPIO1 detect */
4904 4905 4906 4907
			err = stac_add_event(spec, codec->afg,
					     STAC_VREF_EVENT, 0x02);
			if (err < 0)
				return err;
4908
			snd_hda_codec_write_cache(codec, codec->afg, 0,
4909 4910
				AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
			snd_hda_codec_write_cache(codec, codec->afg, 0,
4911
				AC_VERB_SET_UNSOLICITED_ENABLE,
4912
				AC_USRSP_EN | err);
4913 4914 4915
			spec->gpio_mask |= 0x02;
			break;
		}
M
Matthew Ranostay 已提交
4916
		if ((codec->revision_id & 0xf) == 0 ||
4917
		    (codec->revision_id & 0xf) == 1)
M
Matthew Ranostay 已提交
4918 4919
			spec->stream_delay = 40; /* 40 milliseconds */

4920 4921 4922
		/* no output amps */
		spec->num_pwrs = 0;
		spec->mixer = stac92hd71bxx_analog_mixer;
4923
		spec->dinput_mux = &spec->private_dimux;
4924 4925 4926

		/* disable VSW */
		spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF];
4927
		stac_change_pin_config(codec, 0xf, 0x40f000f0);
4928 4929
		break;
	case 0x111d7603: /* 6 Port with Analog Mixer */
4930
		if ((codec->revision_id & 0xf) == 1)
M
Matthew Ranostay 已提交
4931 4932
			spec->stream_delay = 40; /* 40 milliseconds */

4933 4934 4935
		/* no output amps */
		spec->num_pwrs = 0;
		/* fallthru */
4936
	default:
4937
		spec->dinput_mux = &spec->private_dimux;
4938 4939
		spec->mixer = stac92hd71bxx_analog_mixer;
		spec->init = stac92hd71bxx_analog_core_init;
4940
		codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
4941 4942
	}

4943
	spec->aloopback_mask = 0x50;
4944 4945
	spec->aloopback_shift = 0;

M
Matthew Ranostay 已提交
4946
	spec->powerdown_adcs = 1;
4947
	spec->digbeep_nid = 0x26;
4948 4949 4950
	spec->mux_nids = stac92hd71bxx_mux_nids;
	spec->adc_nids = stac92hd71bxx_adc_nids;
	spec->dmic_nids = stac92hd71bxx_dmic_nids;
4951
	spec->dmux_nids = stac92hd71bxx_dmux_nids;
M
Matthew Ranostay 已提交
4952
	spec->smux_nids = stac92hd71bxx_smux_nids;
4953
	spec->pwr_nids = stac92hd71bxx_pwr_nids;
4954 4955 4956 4957

	spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
	spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);

4958 4959 4960
	switch (spec->board_config) {
	case STAC_HP_M4:
		/* enable internal microphone */
4961
		stac_change_pin_config(codec, 0x0e, 0x01813040);
M
Matthew Ranostay 已提交
4962 4963
		stac92xx_auto_set_pinctl(codec, 0x0e,
			AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974
		/* 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;
		spec->num_dmuxes = 0;
4975 4976 4977 4978 4979 4980 4981
		break;
	default:
		spec->num_dmics = STAC92HD71BXX_NUM_DMICS;
		spec->num_smuxes = ARRAY_SIZE(stac92hd71bxx_smux_nids);
		spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
	};

4982
	spec->multiout.dac_nids = spec->dac_nids;
4983 4984 4985 4986
	if (spec->dinput_mux)
		spec->private_dimux.num_items +=
			spec->num_dmics -
				(ARRAY_SIZE(stac92hd71bxx_dmic_nids) - 1);
4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003

	err = stac92xx_parse_auto_config(codec, 0x21, 0x23);
	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;
	}

5004 5005
	codec->proc_widget_hook = stac92hd7x_proc_hook;

5006 5007 5008
	return 0;
};

M
Matt 已提交
5009 5010 5011
static int patch_stac922x(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
5012
	int err;
M
Matt 已提交
5013

5014
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
M
Matt 已提交
5015 5016 5017 5018
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
5019
	spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5020
	spec->pin_nids = stac922x_pin_nids;
5021 5022 5023
	spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
							stac922x_models,
							stac922x_cfg_tbl);
5024
	if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5025 5026
		spec->gpio_mask = spec->gpio_dir = 0x03;
		spec->gpio_data = 0x03;
5027 5028 5029
		/* Intel Macs have all same PCI SSID, so we need to check
		 * codec SSID to distinguish the exact models
		 */
5030
		printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5031
		switch (codec->subsystem_id) {
5032 5033 5034

		case 0x106b0800:
			spec->board_config = STAC_INTEL_MAC_V1;
5035
			break;
5036 5037 5038
		case 0x106b0600:
		case 0x106b0700:
			spec->board_config = STAC_INTEL_MAC_V2;
5039
			break;
5040 5041 5042 5043 5044 5045 5046
		case 0x106b0e00:
		case 0x106b0f00:
		case 0x106b1600:
		case 0x106b1700:
		case 0x106b0200:
		case 0x106b1e00:
			spec->board_config = STAC_INTEL_MAC_V3;
5047
			break;
5048 5049 5050
		case 0x106b1a00:
		case 0x00000100:
			spec->board_config = STAC_INTEL_MAC_V4;
5051
			break;
5052 5053 5054
		case 0x106b0a00:
		case 0x106b2200:
			spec->board_config = STAC_INTEL_MAC_V5;
5055
			break;
5056 5057 5058
		default:
			spec->board_config = STAC_INTEL_MAC_V3;
			break;
5059 5060 5061
		}
	}

5062
 again:
5063 5064 5065 5066
	if (spec->board_config < 0) {
		snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, "
			"using BIOS defaults\n");
		err = stac92xx_save_bios_config_regs(codec);
5067 5068 5069 5070 5071 5072
	} else
		err = stac_save_pin_cfgs(codec,
				stac922x_brd_tbl[spec->board_config]);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
5073
	}
M
Matt 已提交
5074

5075 5076
	spec->adc_nids = stac922x_adc_nids;
	spec->mux_nids = stac922x_mux_nids;
5077
	spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5078
	spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5079
	spec->num_dmics = 0;
5080
	spec->num_pwrs = 0;
5081 5082

	spec->init = stac922x_core_init;
M
Matt 已提交
5083
	spec->mixer = stac922x_mixer;
5084 5085

	spec->multiout.dac_nids = spec->dac_nids;
5086
	
5087
	err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5088 5089 5090 5091 5092 5093 5094 5095 5096
	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_D945_REF;
			goto again;
		}
		err = -EINVAL;
	}
5097 5098 5099 5100 5101 5102 5103
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}

	codec->patch_ops = stac92xx_patch_ops;

5104 5105 5106 5107 5108 5109 5110
	/* 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));

5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123
	return 0;
}

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

	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
5124
	spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5125
	spec->pin_nids = stac927x_pin_nids;
5126 5127 5128
	spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
							stac927x_models,
							stac927x_cfg_tbl);
5129
 again:
5130 5131 5132 5133
	if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) {
		if (spec->board_config < 0)
			snd_printdd(KERN_INFO "hda_codec: Unknown model for"
				    "STAC927x, using BIOS defaults\n");
5134
		err = stac92xx_save_bios_config_regs(codec);
5135 5136 5137 5138 5139 5140
	} else
		err = stac_save_pin_cfgs(codec,
				stac927x_brd_tbl[spec->board_config]);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
5141 5142
	}

5143
	spec->digbeep_nid = 0x23;
5144 5145 5146 5147
	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 已提交
5148 5149
	spec->smux_nids = stac927x_smux_nids;
	spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
5150
	spec->spdif_labels = stac927x_spdif_labels;
5151
	spec->dac_list = stac927x_dac_nids;
5152 5153
	spec->multiout.dac_nids = spec->dac_nids;

5154
	switch (spec->board_config) {
5155 5156
	case STAC_D965_3ST:
	case STAC_D965_5ST:
5157
		/* GPIO0 High = Enable EAPD */
5158
		spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01;
5159
		spec->gpio_data = 0x01;
5160 5161
		spec->num_dmics = 0;

5162
		spec->init = d965_core_init;
5163
		spec->mixer = stac927x_mixer;
5164
		break;
5165
	case STAC_DELL_BIOS:
5166 5167 5168 5169
		switch (codec->subsystem_id) {
		case 0x10280209:
		case 0x1028022e:
			/* correct the device field to SPDIF out */
5170
			stac_change_pin_config(codec, 0x21, 0x01442070);
5171 5172
			break;
		};
5173
		/* configure the analog microphone on some laptops */
5174
		stac_change_pin_config(codec, 0x0c, 0x90a79130);
M
Matthew Ranostay 已提交
5175
		/* correct the front output jack as a hp out */
5176
		stac_change_pin_config(codec, 0x0f, 0x0227011f);
M
Matthew Ranostay 已提交
5177
		/* correct the front input jack as a mic */
5178
		stac_change_pin_config(codec, 0x0e, 0x02a79130);
M
Matthew Ranostay 已提交
5179
		/* fallthru */
5180 5181
	case STAC_DELL_3ST:
		/* GPIO2 High = Enable EAPD */
5182
		spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04;
5183
		spec->gpio_data = 0x04;
5184 5185
		spec->dmic_nids = stac927x_dmic_nids;
		spec->num_dmics = STAC927X_NUM_DMICS;
M
Matthew Ranostay 已提交
5186

5187 5188 5189
		spec->init = d965_core_init;
		spec->mixer = stac927x_mixer;
		spec->dmux_nids = stac927x_dmux_nids;
5190
		spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
5191 5192
		break;
	default:
5193 5194 5195 5196 5197
		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;
		}
5198 5199 5200 5201
		spec->num_dmics = 0;

		spec->init = stac927x_core_init;
		spec->mixer = stac927x_mixer;
5202 5203
	}

5204
	spec->num_pwrs = 0;
5205 5206
	spec->aloopback_mask = 0x40;
	spec->aloopback_shift = 0;
M
Matthew Ranostay 已提交
5207
	spec->eapd_switch = 1;
5208

5209
	err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
5210 5211 5212 5213 5214 5215 5216 5217 5218
	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;
	}
5219 5220 5221 5222
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}
M
Matt 已提交
5223 5224 5225

	codec->patch_ops = stac92xx_patch_ops;

5226 5227
	codec->proc_widget_hook = stac927x_proc_hook;

5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239
	/*
	 * !!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;

5240 5241 5242 5243
	/* no jack detecion for ref-no-jd model */
	if (spec->board_config == STAC_D965_REF_NO_JD)
		spec->hp_detect = 0;

M
Matt 已提交
5244 5245 5246
	return 0;
}

5247 5248 5249
static int patch_stac9205(struct hda_codec *codec)
{
	struct sigmatel_spec *spec;
5250
	int err;
5251 5252 5253 5254 5255 5256

	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
5257
	spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
5258
	spec->pin_nids = stac9205_pin_nids;
5259 5260 5261
	spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
							stac9205_models,
							stac9205_cfg_tbl);
5262
 again:
5263 5264 5265
	if (spec->board_config < 0) {
		snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n");
		err = stac92xx_save_bios_config_regs(codec);
5266 5267 5268 5269 5270 5271
	} else
		err = stac_save_pin_cfgs(codec,
					 stac9205_brd_tbl[spec->board_config]);
	if (err < 0) {
		stac92xx_free(codec);
		return err;
5272 5273
	}

5274
	spec->digbeep_nid = 0x23;
5275
	spec->adc_nids = stac9205_adc_nids;
5276
	spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
5277
	spec->mux_nids = stac9205_mux_nids;
5278
	spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
M
Matthew Ranostay 已提交
5279 5280
	spec->smux_nids = stac9205_smux_nids;
	spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
5281
	spec->dmic_nids = stac9205_dmic_nids;
5282
	spec->num_dmics = STAC9205_NUM_DMICS;
5283
	spec->dmux_nids = stac9205_dmux_nids;
5284
	spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
5285
	spec->num_pwrs = 0;
5286 5287 5288 5289

	spec->init = stac9205_core_init;
	spec->mixer = stac9205_mixer;

5290 5291
	spec->aloopback_mask = 0x40;
	spec->aloopback_shift = 0;
M
Matthew Ranostay 已提交
5292
	spec->eapd_switch = 1;
5293
	spec->multiout.dac_nids = spec->dac_nids;
5294
	
5295 5296
	switch (spec->board_config){
	case STAC_9205_DELL_M43:
5297
		/* Enable SPDIF in/out */
5298 5299
		stac_change_pin_config(codec, 0x1f, 0x01441030);
		stac_change_pin_config(codec, 0x20, 0x1c410030);
5300

5301
		/* Enable unsol response for GPIO4/Dock HP connection */
5302 5303 5304
		err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
		if (err < 0)
			return err;
5305
		snd_hda_codec_write_cache(codec, codec->afg, 0,
5306 5307
			AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
		snd_hda_codec_write_cache(codec, codec->afg, 0,
5308 5309
					  AC_VERB_SET_UNSOLICITED_ENABLE,
					  AC_USRSP_EN | err);
5310 5311

		spec->gpio_dir = 0x0b;
5312
		spec->eapd_mask = 0x01;
5313 5314
		spec->gpio_mask = 0x1b;
		spec->gpio_mute = 0x10;
5315
		/* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
5316
		 * GPIO3 Low = DRM
5317
		 */
5318
		spec->gpio_data = 0x01;
5319
		break;
5320 5321 5322
	case STAC_9205_REF:
		/* SPDIF-In enabled */
		break;
5323 5324
	default:
		/* GPIO0 High = EAPD */
5325
		spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5326
		spec->gpio_data = 0x01;
5327 5328
		break;
	}
5329

5330
	err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
5331 5332 5333 5334 5335 5336 5337 5338 5339
	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_9205_REF;
			goto again;
		}
		err = -EINVAL;
	}
5340 5341 5342 5343 5344 5345 5346
	if (err < 0) {
		stac92xx_free(codec);
		return err;
	}

	codec->patch_ops = stac92xx_patch_ops;

5347 5348
	codec->proc_widget_hook = stac9205_proc_hook;

5349 5350 5351
	return 0;
}

5352
/*
5353
 * STAC9872 hack
5354 5355
 */

5356
/* static config for Sony VAIO FE550G and Sony VAIO AR */
5357 5358 5359 5360 5361 5362
static hda_nid_t vaio_dacs[] = { 0x2 };
#define VAIO_HP_DAC	0x5
static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ };
static hda_nid_t vaio_mux_nids[] = { 0x15 };

static struct hda_input_mux vaio_mux = {
5363
	.num_items = 3,
5364
	.items = {
5365
		/* { "HP", 0x0 }, */
5366 5367
		{ "Mic Jack", 0x1 },
		{ "Internal Mic", 0x2 },
5368 5369 5370 5371 5372 5373
		{ "PCM", 0x3 },
	}
};

static struct hda_verb vaio_init[] = {
	{0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
5374
	{0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT},
5375 5376 5377 5378
	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
	{0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
	{0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5379
	{0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5380 5381 5382 5383 5384 5385 5386 5387
	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
	{}
};

5388 5389 5390 5391 5392 5393 5394
static struct hda_verb vaio_ar_init[] = {
	{0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */
	{0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */
	{0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */
	{0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */
/*	{0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */
	{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */
5395
	{0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
5396 5397 5398 5399 5400 5401 5402 5403 5404
	{0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */
	{0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */
/*	{0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */
	{0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */
	{0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */
	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
	{}
};

5405
static struct snd_kcontrol_new vaio_mixer[] = {
5406 5407 5408 5409
	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423
	/* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
	HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Capture Source",
		.count = 1,
		.info = stac92xx_mux_enum_info,
		.get = stac92xx_mux_enum_get,
		.put = stac92xx_mux_enum_put,
	},
	{}
};

5424
static struct snd_kcontrol_new vaio_ar_mixer[] = {
5425 5426 5427 5428
	HDA_CODEC_VOLUME("Headphone Playback Volume", 0x02, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Headphone Playback Switch", 0x02, 0, HDA_OUTPUT),
	HDA_CODEC_VOLUME("Speaker Playback Volume", 0x05, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Speaker Playback Switch", 0x05, 0, HDA_OUTPUT),
5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445
	/* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */
	HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT),
	HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT),
	/*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT),
	HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Capture Source",
		.count = 1,
		.info = stac92xx_mux_enum_info,
		.get = stac92xx_mux_enum_get,
		.put = stac92xx_mux_enum_put,
	},
	{}
};

static struct hda_codec_ops stac9872_patch_ops = {
5446 5447 5448 5449
	.build_controls = stac92xx_build_controls,
	.build_pcms = stac92xx_build_pcms,
	.init = stac92xx_init,
	.free = stac92xx_free,
5450
#ifdef SND_HDA_NEEDS_RESUME
5451 5452 5453 5454
	.resume = stac92xx_resume,
#endif
};

5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468
static int stac9872_vaio_init(struct hda_codec *codec)
{
	int err;

	err = stac92xx_init(codec);
	if (err < 0)
		return err;
	if (codec->patch_ops.unsol_event)
		codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26);
	return 0;
}

static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res)
{
5469
	if (get_pin_presence(codec, 0x0a)) {
5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497
		stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
		stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
	} else {
		stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN);
		stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN);
	}
} 

static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res)
{
	switch (res >> 26) {
	case STAC_HP_EVENT:
		stac9872_vaio_hp_detect(codec, res);
		break;
	}
}

static struct hda_codec_ops stac9872_vaio_patch_ops = {
	.build_controls = stac92xx_build_controls,
	.build_pcms = stac92xx_build_pcms,
	.init = stac9872_vaio_init,
	.free = stac92xx_free,
	.unsol_event = stac9872_vaio_unsol_event,
#ifdef CONFIG_PM
	.resume = stac92xx_resume,
#endif
};

5498 5499 5500 5501 5502 5503 5504
enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */
       CXD9872RD_VAIO,
       /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */
       STAC9872AK_VAIO, 
       /* Unknown. id=0x83847661 and subsys=0x104D1200. */
       STAC9872K_VAIO,
       /* AR Series. id=0x83847664 and subsys=104D1300 */
5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517
       CXD9872AKD_VAIO,
       STAC_9872_MODELS,
};

static const char *stac9872_models[STAC_9872_MODELS] = {
	[CXD9872RD_VAIO]	= "vaio",
	[CXD9872AKD_VAIO]	= "vaio-ar",
};

static struct snd_pci_quirk stac9872_cfg_tbl[] = {
	SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO),
	SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO),
	SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO),
5518
	SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO),
5519 5520 5521
	{}
};

5522
static int patch_stac9872(struct hda_codec *codec)
5523 5524 5525 5526
{
	struct sigmatel_spec *spec;
	int board_config;

5527 5528 5529
	board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
						  stac9872_models,
						  stac9872_cfg_tbl);
5530 5531 5532 5533 5534 5535 5536 5537 5538 5539
	if (board_config < 0)
		/* unknown config, let generic-parser do its job... */
		return snd_hda_parse_generic_codec(codec);
	
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
	if (spec == NULL)
		return -ENOMEM;

	codec->spec = spec;
	switch (board_config) {
5540 5541 5542
	case CXD9872RD_VAIO:
	case STAC9872AK_VAIO:
	case STAC9872K_VAIO:
5543 5544 5545 5546 5547 5548 5549 5550
		spec->mixer = vaio_mixer;
		spec->init = vaio_init;
		spec->multiout.max_channels = 2;
		spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
		spec->multiout.dac_nids = vaio_dacs;
		spec->multiout.hp_nid = VAIO_HP_DAC;
		spec->num_adcs = ARRAY_SIZE(vaio_adcs);
		spec->adc_nids = vaio_adcs;
5551
		spec->num_pwrs = 0;
5552 5553
		spec->input_mux = &vaio_mux;
		spec->mux_nids = vaio_mux_nids;
5554
		codec->patch_ops = stac9872_vaio_patch_ops;
5555
		break;
5556 5557 5558 5559 5560 5561 5562 5563 5564
	
	case CXD9872AKD_VAIO:
		spec->mixer = vaio_ar_mixer;
		spec->init = vaio_ar_init;
		spec->multiout.max_channels = 2;
		spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs);
		spec->multiout.dac_nids = vaio_dacs;
		spec->multiout.hp_nid = VAIO_HP_DAC;
		spec->num_adcs = ARRAY_SIZE(vaio_adcs);
5565
		spec->num_pwrs = 0;
5566 5567 5568
		spec->adc_nids = vaio_adcs;
		spec->input_mux = &vaio_mux;
		spec->mux_nids = vaio_mux_nids;
5569
		codec->patch_ops = stac9872_patch_ops;
5570
		break;
5571 5572 5573 5574 5575 5576
	}

	return 0;
}


M
Matt 已提交
5577 5578 5579
/*
 * patch entries
 */
5580
static struct hda_codec_preset snd_hda_preset_sigmatel[] = {
M
Matt 已提交
5581 5582 5583 5584 5585 5586 5587
 	{ .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 },
5588 5589 5590 5591 5592 5593
 	{ .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 },
5594 5595 5596 5597 5598 5599 5600 5601 5602 5603
 	{ .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 },
5604 5605 5606 5607 5608 5609
	{ .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 },
5610 5611
	{ .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
	{ .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
5612 5613 5614 5615 5616 5617 5618
 	/* 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 },
5619 5620 5621 5622 5623 5624 5625 5626
 	{ .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 },
5627
	{ .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
5628 5629
	{ .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
	{ .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
5630
	{ .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
5631 5632
	{ .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
	{ .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
5633
	{ .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
5634 5635 5636 5637 5638 5639 5640 5641
	{ .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 },
M
Matt 已提交
5642 5643
	{} /* terminator */
};
5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667

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)