patch_sigmatel.c 173 KB
Newer Older
Matt's avatar
Matt committed
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>
Matt's avatar
Matt committed
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 * Based on patch_cmedia.c and patch_realtek.c
 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
 *
 *  This driver is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This driver is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/pci.h>
31
#include <linux/dmi.h>
Matt's avatar
Matt committed
32
#include <sound/core.h>
33
#include <sound/asoundef.h>
34
#include <sound/jack.h>
Matt's avatar
Matt committed
35 36
#include "hda_codec.h"
#include "hda_local.h"
37
#include "hda_beep.h"
Matt's avatar
Matt committed
38

39 40 41 42 43
enum {
	STAC_VREF_EVENT	= 1,
	STAC_INSERT_EVENT,
	STAC_PWR_EVENT,
	STAC_HP_EVENT,
44
	STAC_LO_EVENT,
45
	STAC_MIC_EVENT,
46
};
47

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

enum {
69
	STAC_9205_AUTO,
70
	STAC_9205_REF,
71
	STAC_9205_DELL_M42,
72 73
	STAC_9205_DELL_M43,
	STAC_9205_DELL_M44,
74
	STAC_9205_EAPD,
75 76 77
	STAC_9205_MODELS
};

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

91
enum {
92
	STAC_92HD83XXX_AUTO,
93
	STAC_92HD83XXX_REF,
94
	STAC_92HD83XXX_PWR_REF,
95
	STAC_DELL_S14,
96
	STAC_92HD83XXX_HP,
97 98 99
	STAC_92HD83XXX_MODELS
};

100
enum {
101
	STAC_92HD71BXX_AUTO,
102
	STAC_92HD71BXX_REF,
103 104
	STAC_DELL_M4_1,
	STAC_DELL_M4_2,
105
	STAC_DELL_M4_3,
106
	STAC_HP_M4,
107
	STAC_HP_DV5,
108
	STAC_HP_HDX,
109
	STAC_HP_DV4_1222NR,
110 111 112
	STAC_92HD71BXX_MODELS
};

113
enum {
114
	STAC_925x_AUTO,
115
	STAC_925x_REF,
116 117 118
	STAC_M1,
	STAC_M1_2,
	STAC_M2,
119
	STAC_M2_2,
120 121 122
	STAC_M3,
	STAC_M5,
	STAC_M6,
123 124 125
	STAC_925x_MODELS
};

126
enum {
127
	STAC_922X_AUTO,
128 129 130
	STAC_D945_REF,
	STAC_D945GTP3,
	STAC_D945GTP5,
131 132 133 134 135
	STAC_INTEL_MAC_V1,
	STAC_INTEL_MAC_V2,
	STAC_INTEL_MAC_V3,
	STAC_INTEL_MAC_V4,
	STAC_INTEL_MAC_V5,
136 137 138
	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. */
139
	/* for backward compatibility */
140
	STAC_MACMINI,
141
	STAC_MACBOOK,
142 143
	STAC_MACBOOK_PRO_V1,
	STAC_MACBOOK_PRO_V2,
144
	STAC_IMAC_INTEL,
145
	STAC_IMAC_INTEL_20,
146
	STAC_ECS_202,
147 148 149 150
	STAC_922X_DELL_D81,
	STAC_922X_DELL_D82,
	STAC_922X_DELL_M81,
	STAC_922X_DELL_M82,
151 152 153 154
	STAC_922X_MODELS
};

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

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

173 174
struct sigmatel_event {
	hda_nid_t nid;
175 176
	unsigned char type;
	unsigned char tag;
177 178 179 180 181 182 183 184 185
	int data;
};

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

186 187
struct sigmatel_mic_route {
	hda_nid_t pin;
188 189
	signed char mux_idx;
	signed char dmux_idx;
190 191
};

Matt's avatar
Matt committed
192
struct sigmatel_spec {
193
	struct snd_kcontrol_new *mixers[4];
194 195
	unsigned int num_mixers;

196
	int board_config;
197
	unsigned int eapd_switch: 1;
198
	unsigned int surr_switch: 1;
199
	unsigned int alt_switch: 1;
200
	unsigned int hp_detect: 1;
201
	unsigned int spdif_mute: 1;
202
	unsigned int check_volume_offset:1;
203
	unsigned int auto_mic:1;
204

205
	/* gpio lines */
206
	unsigned int eapd_mask;
207 208 209 210
	unsigned int gpio_mask;
	unsigned int gpio_dir;
	unsigned int gpio_data;
	unsigned int gpio_mute;
211
	unsigned int gpio_led;
212
	unsigned int gpio_led_polarity;
213

Matthew Ranostay's avatar
Matthew Ranostay committed
214 215 216
	/* stream */
	unsigned int stream_delay;

217
	/* analog loopback */
218
	struct snd_kcontrol_new *aloopback_ctl;
219 220
	unsigned char aloopback_mask;
	unsigned char aloopback_shift;
221

222 223
	/* power management */
	unsigned int num_pwrs;
224
	unsigned int *pwr_mapping;
225
	hda_nid_t *pwr_nids;
226
	hda_nid_t *dac_list;
227

228 229 230 231 232 233
	/* jack detection */
	struct snd_array jacks;

	/* events */
	struct snd_array events;

Matt's avatar
Matt committed
234
	/* playback */
235 236
	struct hda_input_mux *mono_mux;
	unsigned int cur_mmux;
Matt's avatar
Matt committed
237
	struct hda_multi_out multiout;
238
	hda_nid_t dac_nids[5];
239 240
	hda_nid_t hp_dacs[5];
	hda_nid_t speaker_dacs[5];
Matt's avatar
Matt committed
241

242 243
	int volume_offset;

Matt's avatar
Matt committed
244 245 246
	/* capture */
	hda_nid_t *adc_nids;
	unsigned int num_adcs;
247 248
	hda_nid_t *mux_nids;
	unsigned int num_muxes;
249 250
	hda_nid_t *dmic_nids;
	unsigned int num_dmics;
251
	hda_nid_t *dmux_nids;
252
	unsigned int num_dmuxes;
253 254
	hda_nid_t *smux_nids;
	unsigned int num_smuxes;
255
	unsigned int num_analog_muxes;
256 257 258 259 260

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

261 262 263
	struct sigmatel_mic_route ext_mic;
	struct sigmatel_mic_route int_mic;

264
	const char **spdif_labels;
265

266
	hda_nid_t dig_in_nid;
267
	hda_nid_t mono_nid;
268 269
	hda_nid_t anabeep_nid;
	hda_nid_t digbeep_nid;
Matt's avatar
Matt committed
270 271 272 273 274 275 276

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

	/* codec specific stuff */
	struct hda_verb *init;
277
	struct snd_kcontrol_new *mixer;
Matt's avatar
Matt committed
278 279

	/* capture source */
280
	struct hda_input_mux *dinput_mux;
281
	unsigned int cur_dmux[2];
282
	struct hda_input_mux *input_mux;
283
	unsigned int cur_mux[3];
284 285
	struct hda_input_mux *sinput_mux;
	unsigned int cur_smux[2];
Matthew Ranostay's avatar
Matthew Ranostay committed
286 287
	unsigned int cur_amux;
	hda_nid_t *amp_nids;
Matthew Ranostay's avatar
Matthew Ranostay committed
288
	unsigned int powerdown_adcs;
Matt's avatar
Matt committed
289

290 291
	/* i/o switches */
	unsigned int io_switch[2];
292
	unsigned int clfe_swap;
293 294 295
	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 */
296
	unsigned int aloopback;
Matt's avatar
Matt committed
297

298 299 300 301
	struct hda_pcm pcm_rec[2];	/* PCM information */

	/* dynamic controls and input_mux */
	struct auto_pin_cfg autocfg;
302
	struct snd_array kctls;
303
	struct hda_input_mux private_dimux;
304
	struct hda_input_mux private_imux;
305
	struct hda_input_mux private_smux;
306
	struct hda_input_mux private_mono_mux;
Matt's avatar
Matt committed
307 308 309 310 311 312 313 314 315 316 317 318 319 320
};

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

321 322 323 324 325
static hda_nid_t stac92hd73xx_pwr_nids[8] = {
	0x0a, 0x0b, 0x0c, 0xd, 0x0e,
	0x0f, 0x10, 0x11
};

326 327 328 329
static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
	0x26, 0,
};

330 331 332 333 334 335 336 337 338 339 340
static hda_nid_t stac92hd73xx_adc_nids[2] = {
	0x1a, 0x1b
};

#define STAC92HD73XX_NUM_DMICS	2
static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
	0x13, 0x14, 0
};

#define STAC92HD73_DAC_COUNT 5

341 342
static hda_nid_t stac92hd73xx_mux_nids[2] = {
	0x20, 0x21,
343 344 345 346 347 348
};

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

349 350 351 352
static hda_nid_t stac92hd73xx_smux_nids[2] = {
	0x22, 0x23,
};

353 354 355 356 357 358 359
#define STAC92HD73XX_NUM_CAPS	2
static unsigned long stac92hd73xx_capvols[] = {
	HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
	HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
};
#define stac92hd73xx_capsws	stac92hd73xx_capvols

360 361
#define STAC92HD83_DAC_COUNT 3

362
static hda_nid_t stac92hd83xxx_mux_nids[2] = {
363 364 365 366 367 368 369 370 371 372 373
	0x17, 0x18,
};

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

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

374 375 376 377
static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
	0x1e, 0,
};

378
static unsigned int stac92hd83xxx_pwr_mapping[4] = {
379
	0x03, 0x0c, 0x20, 0x40,
380 381
};

382 383 384 385 386 387 388
#define STAC92HD83XXX_NUM_CAPS	2
static unsigned long stac92hd83xxx_capvols[] = {
	HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
	HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_OUTPUT),
};
#define stac92hd83xxx_capsws	stac92hd83xxx_capvols

389 390 391 392
static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
	0x0a, 0x0d, 0x0f
};

393 394 395 396 397 398 399 400
static hda_nid_t stac92hd71bxx_adc_nids[2] = {
	0x12, 0x13,
};

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

401 402
static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
	0x1c, 0x1d,
403 404
};

405 406 407 408
static hda_nid_t stac92hd71bxx_smux_nids[2] = {
	0x24, 0x25,
};

409 410 411 412 413
#define STAC92HD71BXX_NUM_DMICS	2
static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
	0x18, 0x19, 0
};

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

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

425 426 427 428 429 430 431 432 433 434 435 436
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,
};

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

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

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

Matt's avatar
Matt committed
453 454 455 456 457 458 459 460
static hda_nid_t stac922x_adc_nids[2] = {
        0x06, 0x07,
};

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

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

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

472 473 474 475 476 477 478 479
static hda_nid_t stac927x_adc_nids[3] = {
        0x07, 0x08, 0x09
};

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

480 481 482 483
static hda_nid_t stac927x_smux_nids[1] = {
	0x21,
};

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

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

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

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

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

514 515 516 517 518 519 520 521
static hda_nid_t stac9205_adc_nids[2] = {
        0x12, 0x13
};

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

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

526 527 528 529
static hda_nid_t stac9205_smux_nids[1] = {
	0x21,
};

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

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

545
static hda_nid_t stac9200_pin_nids[8] = {
546 547
	0x08, 0x09, 0x0d, 0x0e, 
	0x0f, 0x10, 0x11, 0x12,
Matt's avatar
Matt committed
548 549
};

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

Matt's avatar
Matt committed
555 556 557 558 559
static hda_nid_t stac922x_pin_nids[10] = {
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x15, 0x1b,
};

560
static hda_nid_t stac92hd73xx_pin_nids[13] = {
561 562
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x12, 0x13,
563
	0x14, 0x22, 0x23
564 565
};

566
static hda_nid_t stac92hd83xxx_pin_nids[10] = {
567
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
568
	0x0f, 0x10, 0x11, 0x1f, 0x20,
569
};
570

571 572 573 574 575
static hda_nid_t stac92hd88xxx_pin_nids[10] = {
	0x0a, 0x0b, 0x0c, 0x0d,
	0x0f, 0x11, 0x1f, 0x20,
};

576 577 578 579 580 581 582
#define STAC92HD71BXX_NUM_PINS 13
static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
	0x0a, 0x0b, 0x0c, 0x0d, 0x00,
	0x00, 0x14, 0x18, 0x19, 0x1e,
	0x1f, 0x20, 0x27
};
static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
583 584
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x14, 0x18, 0x19, 0x1e,
585
	0x1f, 0x20, 0x27
586 587
};

588 589 590 591 592 593
static hda_nid_t stac927x_pin_nids[14] = {
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x10, 0x11, 0x12, 0x13,
	0x14, 0x21, 0x22, 0x23,
};

594 595 596 597 598 599
static hda_nid_t stac9205_pin_nids[12] = {
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
	0x0f, 0x14, 0x16, 0x17, 0x18,
	0x21, 0x22,
};

600 601 602 603 604 605 606 607 608 609 610 611 612
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;
613
	unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
614

615
	ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
616 617 618 619 620 621 622 623
	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;
624
	unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
625 626

	return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
627
			spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
628 629
}

630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
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;
654
	struct hda_input_mux *smux = &spec->private_smux;
655
	unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
656 657
	int err, val;
	hda_nid_t nid;
658

659
	err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
660
			spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
661 662 663 664 665 666 667 668 669
	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)
670
			val = HDA_AMP_MUTE;
671
		else
672
			val = 0;
673
		/* un/mute SPDIF out */
674 675
		snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
					 HDA_AMP_MUTE, val);
676 677
	}
	return 0;
678 679
}

680 681 682
static unsigned int stac92xx_vref_set(struct hda_codec *codec,
					hda_nid_t nid, unsigned int new_vref)
{
683
	int error;
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
	unsigned int pincfg;
	pincfg = snd_hda_codec_read(codec, nid, 0,
				AC_VERB_GET_PIN_WIDGET_CONTROL, 0);

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

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

	error = snd_hda_codec_write_cache(codec, nid, 0,
					AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
	if (error < 0)
		return error;
	else
		return 1;
}

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

714
static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
Matt's avatar
Matt committed
715 716 717
{
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
	struct sigmatel_spec *spec = codec->spec;
718
	return snd_hda_input_mux_info(spec->input_mux, uinfo);
Matt's avatar
Matt committed
719 720
}

721
static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
Matt's avatar
Matt committed
722 723 724 725 726 727 728 729 730
{
	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;
}

731
static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
Matt's avatar
Matt committed
732 733 734 735
{
	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);
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
	const struct hda_input_mux *imux = spec->input_mux;
	unsigned int idx, prev_idx;

	idx = ucontrol->value.enumerated.item[0];
	if (idx >= imux->num_items)
		idx = imux->num_items - 1;
	prev_idx = spec->cur_mux[adc_idx];
	if (prev_idx == idx)
		return 0;
	if (idx < spec->num_analog_muxes) {
		snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
					  AC_VERB_SET_CONNECT_SEL,
					  imux->items[idx].index);
		if (prev_idx >= spec->num_analog_muxes) {
			imux = spec->dinput_mux;
			/* 0 = analog */
			snd_hda_codec_write_cache(codec,
						  spec->dmux_nids[adc_idx], 0,
						  AC_VERB_SET_CONNECT_SEL,
						  imux->items[0].index);
		}
	} else {
		imux = spec->dinput_mux;
		snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
					  AC_VERB_SET_CONNECT_SEL,
					  imux->items[idx - 1].index);
	}
	spec->cur_mux[adc_idx] = idx;
	return 1;
Matt's avatar
Matt committed
765 766
}

767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
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);
}

795 796 797 798 799 800
#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);
801
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
802 803
	struct sigmatel_spec *spec = codec->spec;

804 805
	ucontrol->value.integer.value[0] = !!(spec->aloopback &
					      (spec->aloopback_mask << idx));
806 807 808 809 810 811 812 813
	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;
814
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
815
	unsigned int dac_mode;
816
	unsigned int val, idx_val;
817

818 819 820 821 822
	idx_val = spec->aloopback_mask << idx;
	if (ucontrol->value.integer.value[0])
		val = spec->aloopback | idx_val;
	else
		val = spec->aloopback & ~idx_val;
823
	if (spec->aloopback == val)
824 825
		return 0;

826
	spec->aloopback = val;
827

828 829 830
	/* Only return the bits defined by the shift value of the
	 * first two bytes of the mask
	 */
831
	dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
832 833
				      kcontrol->private_value & 0xFFFF, 0x0);
	dac_mode >>= spec->aloopback_shift;
834

835
	if (spec->aloopback & idx_val) {
836
		snd_hda_power_up(codec);
837
		dac_mode |= idx_val;
838 839
	} else {
		snd_hda_power_down(codec);
840
		dac_mode &= ~idx_val;
841 842 843 844 845 846 847 848
	}

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

	return 1;
}

849
static struct hda_verb stac9200_core_init[] = {
Matt's avatar
Matt committed
850
	/* set dac0mux for dac converter */
851
	{ 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
Matt's avatar
Matt committed
852 853 854
	{}
};

855 856 857 858 859 860 861
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},
	{}
};

862 863 864 865
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},
866 867 868
	{}
};

869
static struct hda_verb stac92hd73xx_core_init[] = {
870 871 872 873 874
	/* set master volume and direct control */
	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
	{}
};

875 876 877
static struct hda_verb stac92hd83xxx_core_init[] = {
	/* power state controls amps */
	{ 0x01, AC_VERB_SET_EAPD, 1 << 2},
878
	{}
879 880
};

881
static struct hda_verb stac92hd71bxx_core_init[] = {
882 883
	/* set master volume and direct control */
	{ 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
884
	{}
885 886
};

887 888 889
static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
	/* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
	{ 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
890 891 892 893 894
	{ 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	{ 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
	{}
};

895 896 897
static struct hda_verb stac925x_core_init[] = {
	/* set dac0mux for dac converter */
	{ 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
898 899
	/* mute the master volume */
	{ 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
900 901 902
	{}
};

903
static struct hda_verb stac922x_core_init[] = {
Matt's avatar
Matt committed
904
	/* set master volume and direct control */	
905
	{ 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
Matt's avatar
Matt committed
906 907 908
	{}
};

909
static struct hda_verb d965_core_init[] = {
910
	/* set master volume and direct control */	
911
	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
912 913 914 915 916 917 918
	/* unmute node 0x1b */
	{ 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
	/* select node 0x03 as DAC */	
	{ 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
	{}
};

919 920 921 922 923 924 925 926 927 928
static struct hda_verb dell_3st_core_init[] = {
	/* don't set delta bit */
	{0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
	/* unmute node 0x1b */
	{0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
	/* select node 0x03 as DAC */
	{0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
	{}
};

929 930 931
static struct hda_verb stac927x_core_init[] = {
	/* set master volume and direct control */	
	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
932 933
	/* enable analog pc beep path */
	{ 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
934 935 936
	{}
};

937 938 939 940 941 942 943 944
static struct hda_verb stac927x_volknob_core_init[] = {
	/* don't set delta bit */
	{0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
	/* enable analog pc beep path */
	{0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
	{}
};

945 946 947
static struct hda_verb stac9205_core_init[] = {
	/* set master volume and direct control */	
	{ 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
948 949
	/* enable analog pc beep path */
	{ 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
950 951 952
	{}
};

953 954 955 956 957 958 959 960 961 962
#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, \
	}

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

974 975 976 977 978 979 980 981 982 983 984
#define DC_BIAS(xname, idx, nid) \
	{ \
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
		.name = xname, \
		.index = idx, \
		.info = stac92xx_dc_bias_info, \
		.get = stac92xx_dc_bias_get, \
		.put = stac92xx_dc_bias_put, \
		.private_value = nid, \
	}

985
static struct snd_kcontrol_new stac9200_mixer[] = {
Matt's avatar
Matt committed
986 987 988 989 990 991 992
	HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
	HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
	HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
	{ } /* end */
};

993 994 995 996 997 998
static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
	{}
};

static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
999
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
1000 1001
	{}
};
1002

1003 1004 1005 1006 1007
static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
	{}
};

1008

1009 1010 1011
static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
	STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
};
1012

1013
static struct snd_kcontrol_new stac925x_mixer[] = {