CoCalc -- patch_sigmatel.c

GitHub Repository: awilliam/linux-vfio
Path: blob/master/sound/pci/hda/patch_sigmatel.c
¹⁰⁸¹⁷ views
1
/*
2
 * Universal Interface for Intel High Definition Audio Codec
3
 *
4
 * HD audio interface patch for SigmaTel STAC92xx
5
 *
6
 * Copyright (c) 2005 Embedded Alley Solutions, Inc.
7
 * Matt Porter <[email protected]>
8
 *
9
 * Based on patch_cmedia.c and patch_realtek.c
10
 * Copyright (c) 2004 Takashi Iwai <[email protected]>
11
 *
12
 *  This driver is free software; you can redistribute it and/or modify
13
 *  it under the terms of the GNU General Public License as published by
14
 *  the Free Software Foundation; either version 2 of the License, or
15
 *  (at your option) any later version.
16
 *
17
 *  This driver is distributed in the hope that it will be useful,
18
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
19
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
 *  GNU General Public License for more details.
21
 *
22
 *  You should have received a copy of the GNU General Public License
23
 *  along with this program; if not, write to the Free Software
24
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
25
 */
26

27
#include <linux/init.h>
28
#include <linux/delay.h>
29
#include <linux/slab.h>
30
#include <linux/pci.h>
31
#include <linux/dmi.h>
32
#include <sound/core.h>
33
#include <sound/asoundef.h>
34
#include <sound/jack.h>
35
#include <sound/tlv.h>
36
#include "hda_codec.h"
37
#include "hda_local.h"
38
#include "hda_beep.h"
39

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

49
enum {
50
	STAC_AUTO,
51
	STAC_REF,
52
	STAC_9200_OQO,
53
	STAC_9200_DELL_D21,
54
	STAC_9200_DELL_D22,
55
	STAC_9200_DELL_D23,
56
	STAC_9200_DELL_M21,
57
	STAC_9200_DELL_M22,
58
	STAC_9200_DELL_M23,
59
	STAC_9200_DELL_M24,
60
	STAC_9200_DELL_M25,
61
	STAC_9200_DELL_M26,
62
	STAC_9200_DELL_M27,
63
	STAC_9200_M4,
64
	STAC_9200_M4_2,
65
	STAC_9200_PANASONIC,
66
	STAC_9200_MODELS
67
};
68

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

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

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

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

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

129
enum {
130
	STAC_922X_AUTO,
131
	STAC_D945_REF,
132
	STAC_D945GTP3,
133
	STAC_D945GTP5,
134
	STAC_INTEL_MAC_V1,
135
	STAC_INTEL_MAC_V2,
136
	STAC_INTEL_MAC_V3,
137
	STAC_INTEL_MAC_V4,
138
	STAC_INTEL_MAC_V5,
139
	STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
140
			      * is given, one of the above models will be
141
			      * chosen according to the subsystem id. */
142
	/* for backward compatibility */
143
	STAC_MACMINI,
144
	STAC_MACBOOK,
145
	STAC_MACBOOK_PRO_V1,
146
	STAC_MACBOOK_PRO_V2,
147
	STAC_IMAC_INTEL,
148
	STAC_IMAC_INTEL_20,
149
	STAC_ECS_202,
150
	STAC_922X_DELL_D81,
151
	STAC_922X_DELL_D82,
152
	STAC_922X_DELL_M81,
153
	STAC_922X_DELL_M82,
154
	STAC_922X_MODELS
155
};
156

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

170
enum {
171
	STAC_9872_AUTO,
172
	STAC_9872_VAIO,
173
	STAC_9872_MODELS
174
};
175

176
struct sigmatel_event {
177
	hda_nid_t nid;
178
	unsigned char type;
179
	unsigned char tag;
180
	int data;
181
};
182

183
struct sigmatel_mic_route {
184
	hda_nid_t pin;
185
	signed char mux_idx;
186
	signed char dmux_idx;
187
};
188

189
#define MAX_PINS_NUM 16
190
#define MAX_ADCS_NUM 4
191
#define MAX_DMICS_NUM 4
192

193
struct sigmatel_spec {
194
	struct snd_kcontrol_new *mixers[4];
195
	unsigned int num_mixers;
196

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

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

216
	/* stream */
217
	unsigned int stream_delay;
218

219
	/* analog loopback */
220
	const struct snd_kcontrol_new *aloopback_ctl;
221
	unsigned char aloopback_mask;
222
	unsigned char aloopback_shift;
223

224
	/* power management */
225
	unsigned int num_pwrs;
226
	const unsigned int *pwr_mapping;
227
	const hda_nid_t *pwr_nids;
228
	const hda_nid_t *dac_list;
229

230
	/* events */
231
	struct snd_array events;
232

233
	/* playback */
234
	struct hda_input_mux *mono_mux;
235
	unsigned int cur_mmux;
236
	struct hda_multi_out multiout;
237
	hda_nid_t dac_nids[5];
238
	hda_nid_t hp_dacs[5];
239
	hda_nid_t speaker_dacs[5];
240

241
	int volume_offset;
242

243
	/* capture */
244
	const hda_nid_t *adc_nids;
245
	unsigned int num_adcs;
246
	const hda_nid_t *mux_nids;
247
	unsigned int num_muxes;
248
	const hda_nid_t *dmic_nids;
249
	unsigned int num_dmics;
250
	const hda_nid_t *dmux_nids;
251
	unsigned int num_dmuxes;
252
	const hda_nid_t *smux_nids;
253
	unsigned int num_smuxes;
254
	unsigned int num_analog_muxes;
255

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

260
	struct sigmatel_mic_route ext_mic;
261
	struct sigmatel_mic_route int_mic;
262
	struct sigmatel_mic_route dock_mic;
263

264
	const char * const *spdif_labels;
265

266
	hda_nid_t dig_in_nid;
267
	hda_nid_t mono_nid;
268
	hda_nid_t anabeep_nid;
269
	hda_nid_t digbeep_nid;
270

271
	/* pin widgets */
272
	const hda_nid_t *pin_nids;
273
	unsigned int num_pins;
274

275
	/* codec specific stuff */
276
	const struct hda_verb *init;
277
	const struct snd_kcontrol_new *mixer;
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
	struct hda_input_mux *sinput_mux;
285
	unsigned int cur_smux[2];
286
	unsigned int cur_amux;
287
	hda_nid_t *amp_nids;
288
	unsigned int powerdown_adcs;
289

290
	/* i/o switches */
291
	unsigned int io_switch[2];
292
	unsigned int clfe_swap;
293
	hda_nid_t line_switch;	/* shared line-in for input and output */
294
	hda_nid_t mic_switch;	/* shared mic-in for input and output */
295
	hda_nid_t hp_switch; /* NID of HP as line-out */
296
	unsigned int aloopback;
297

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

300
	/* dynamic controls and input_mux */
301
	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;
307

308
	/* auto spec */
309
	unsigned auto_pin_cnt;
310
	hda_nid_t auto_pin_nids[MAX_PINS_NUM];
311
	unsigned auto_adc_cnt;
312
	hda_nid_t auto_adc_nids[MAX_ADCS_NUM];
313
	hda_nid_t auto_mux_nids[MAX_ADCS_NUM];
314
	hda_nid_t auto_dmux_nids[MAX_ADCS_NUM];
315
	unsigned long auto_capvols[MAX_ADCS_NUM];
316
	unsigned auto_dmic_cnt;
317
	hda_nid_t auto_dmic_nids[MAX_DMICS_NUM];
318
};
319

320
static const hda_nid_t stac9200_adc_nids[1] = {
321
        0x03,
322
};
323

324
static const hda_nid_t stac9200_mux_nids[1] = {
325
        0x0c,
326
};
327

328
static const hda_nid_t stac9200_dac_nids[1] = {
329
        0x02,
330
};
331

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

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

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

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

350
#define STAC92HD73_DAC_COUNT 5
351

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

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

360
static const hda_nid_t stac92hd73xx_smux_nids[2] = {
361
	0x22, 0x23,
362
};
363

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

371
#define STAC92HD83_DAC_COUNT 3
372

373
static const hda_nid_t stac92hd83xxx_pwr_nids[4] = {
374
	0xa, 0xb, 0xd, 0xe,
375
};
376

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

381
static const unsigned int stac92hd83xxx_pwr_mapping[4] = {
382
	0x03, 0x0c, 0x20, 0x40,
383
};
384

385
static const hda_nid_t stac92hd83xxx_dmic_nids[] = {
386
		0x11, 0x20,
387
};
388

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

393
static const hda_nid_t stac92hd71bxx_adc_nids[2] = {
394
	0x12, 0x13,
395
};
396

397
static const hda_nid_t stac92hd71bxx_mux_nids[2] = {
398
	0x1a, 0x1b
399
};
400

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

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

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

414
static const hda_nid_t stac92hd71bxx_dmic_5port_nids[STAC92HD71BXX_NUM_DMICS] = {
415
	0x18, 0
416
};
417

418
static const hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
419
	0x22, 0
420
};
421

422
#define STAC92HD71BXX_NUM_CAPS		2
423
static const unsigned long stac92hd71bxx_capvols[] = {
424
	HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
425
	HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
426
};
427
#define stac92hd71bxx_capsws	stac92hd71bxx_capvols
428

429
static const hda_nid_t stac925x_adc_nids[1] = {
430
        0x03,
431
};
432

433
static const hda_nid_t stac925x_mux_nids[1] = {
434
        0x0f,
435
};
436

437
static const hda_nid_t stac925x_dac_nids[1] = {
438
        0x02,
439
};
440

441
#define STAC925X_NUM_DMICS	1
442
static const hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
443
	0x15, 0
444
};
445

446
static const hda_nid_t stac925x_dmux_nids[1] = {
447
	0x14,
448
};
449

450
static const unsigned long stac925x_capvols[] = {
451
	HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
452
};
453
static const unsigned long stac925x_capsws[] = {
454
	HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
455
};
456

457
static const hda_nid_t stac922x_adc_nids[2] = {
458
        0x06, 0x07,
459
};
460

461
static const hda_nid_t stac922x_mux_nids[2] = {
462
        0x12, 0x13,
463
};
464

465
#define STAC922X_NUM_CAPS	2
466
static const unsigned long stac922x_capvols[] = {
467
	HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
468
	HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
469
};
470
#define stac922x_capsws		stac922x_capvols
471

472
static const hda_nid_t stac927x_slave_dig_outs[2] = {
473
	0x1f, 0,
474
};
475

476
static const hda_nid_t stac927x_adc_nids[3] = {
477
        0x07, 0x08, 0x09
478
};
479

480
static const hda_nid_t stac927x_mux_nids[3] = {
481
        0x15, 0x16, 0x17
482
};
483

484
static const hda_nid_t stac927x_smux_nids[1] = {
485
	0x21,
486
};
487

488
static const hda_nid_t stac927x_dac_nids[6] = {
489
	0x02, 0x03, 0x04, 0x05, 0x06, 0
490
};
491

492
static const hda_nid_t stac927x_dmux_nids[1] = {
493
	0x1b,
494
};
495

496
#define STAC927X_NUM_DMICS 2
497
static const hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
498
	0x13, 0x14, 0
499
};
500

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

513
static const char * const stac927x_spdif_labels[5] = {
514
	"Digital Playback", "ADAT", "Analog Mux 1",
515
	"Analog Mux 2", "Analog Mux 3"
516
};
517

518
static const hda_nid_t stac9205_adc_nids[2] = {
519
        0x12, 0x13
520
};
521

522
static const hda_nid_t stac9205_mux_nids[2] = {
523
        0x19, 0x1a
524
};
525

526
static const hda_nid_t stac9205_dmux_nids[1] = {
527
	0x1d,
528
};
529

530
static const hda_nid_t stac9205_smux_nids[1] = {
531
	0x21,
532
};
533

534
#define STAC9205_NUM_DMICS	2
535
static const hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
536
        0x17, 0x18, 0
537
};
538

539
#define STAC9205_NUM_CAPS	2
540
static const unsigned long stac9205_capvols[] = {
541
	HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
542
	HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
543
};
544
static const unsigned long stac9205_capsws[] = {
545
	HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
546
	HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
547
};
548

549
static const hda_nid_t stac9200_pin_nids[8] = {
550
	0x08, 0x09, 0x0d, 0x0e, 
551
	0x0f, 0x10, 0x11, 0x12,
552
};
553

554
static const hda_nid_t stac925x_pin_nids[8] = {
555
	0x07, 0x08, 0x0a, 0x0b, 
556
	0x0c, 0x0d, 0x10, 0x11,
557
};
558

559
static const hda_nid_t stac922x_pin_nids[10] = {
560
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
561
	0x0f, 0x10, 0x11, 0x15, 0x1b,
562
};
563

564
static const hda_nid_t stac92hd73xx_pin_nids[13] = {
565
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
566
	0x0f, 0x10, 0x11, 0x12, 0x13,
567
	0x14, 0x22, 0x23
568
};
569

570
#define STAC92HD71BXX_NUM_PINS 13
571
static const hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
572
	0x0a, 0x0b, 0x0c, 0x0d, 0x00,
573
	0x00, 0x14, 0x18, 0x19, 0x1e,
574
	0x1f, 0x20, 0x27
575
};
576
static const hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
577
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
578
	0x0f, 0x14, 0x18, 0x19, 0x1e,
579
	0x1f, 0x20, 0x27
580
};
581

582
static const hda_nid_t stac927x_pin_nids[14] = {
583
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
584
	0x0f, 0x10, 0x11, 0x12, 0x13,
585
	0x14, 0x21, 0x22, 0x23,
586
};
587

588
static const hda_nid_t stac9205_pin_nids[12] = {
589
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
590
	0x0f, 0x14, 0x16, 0x17, 0x18,
591
	0x21, 0x22,
592
};
593

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

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

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

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

620
	return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
621
			spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
622
}
623

624
static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
625
				   struct snd_ctl_elem_info *uinfo)
626
{
627
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
628
	struct sigmatel_spec *spec = codec->spec;
629
	return snd_hda_input_mux_info(spec->sinput_mux, uinfo);
630
}
631

632
static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
633
				  struct snd_ctl_elem_value *ucontrol)
634
{
635
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
636
	struct sigmatel_spec *spec = codec->spec;
637
	unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
638

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

643
static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
644
				  struct snd_ctl_elem_value *ucontrol)
645
{
646
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
647
	struct sigmatel_spec *spec = codec->spec;
648
	struct hda_input_mux *smux = &spec->private_smux;
649
	unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
650
	int err, val;
651
	hda_nid_t nid;
652

653
	err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
654
			spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
655
	if (err < 0)
656
		return err;
657

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

674
static unsigned int stac92xx_vref_set(struct hda_codec *codec,
675
					hda_nid_t nid, unsigned int new_vref)
676
{
677
	int error;
678
	unsigned int pincfg;
679
	pincfg = snd_hda_codec_read(codec, nid, 0,
680
				AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
681

682
	pincfg &= 0xff;
683
	pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
684
	pincfg |= new_vref;
685

686
	if (new_vref == AC_PINCTL_VREF_HIZ)
687
		pincfg |= AC_PINCTL_OUT_EN;
688
	else
689
		pincfg |= AC_PINCTL_IN_EN;
690

691
	error = snd_hda_codec_write_cache(codec, nid, 0,
692
					AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
693
	if (error < 0)
694
		return error;
695
	else
696
		return 1;
697
}
698

699
static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
700
{
701
	unsigned int vref;
702
	vref = snd_hda_codec_read(codec, nid, 0,
703
				AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
704
	vref &= AC_PINCTL_VREFEN;
705
	return vref;
706
}
707

708
static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
709
{
710
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
711
	struct sigmatel_spec *spec = codec->spec;
712
	return snd_hda_input_mux_info(spec->input_mux, uinfo);
713
}
714

715
static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
716
{
717
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
718
	struct sigmatel_spec *spec = codec->spec;
719
	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
720

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

725
static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
726
{
727
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
728
	struct sigmatel_spec *spec = codec->spec;
729
	unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
730
	const struct hda_input_mux *imux = spec->input_mux;
731
	unsigned int idx, prev_idx, didx;
732

733
	idx = ucontrol->value.enumerated.item[0];
734
	if (idx >= imux->num_items)
735
		idx = imux->num_items - 1;
736
	prev_idx = spec->cur_mux[adc_idx];
737
	if (prev_idx == idx)
738
		return 0;
739
	if (idx < spec->num_analog_muxes) {
740
		snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
741
					  AC_VERB_SET_CONNECT_SEL,
742
					  imux->items[idx].index);
743
		if (prev_idx >= spec->num_analog_muxes &&
744
		    spec->mux_nids[adc_idx] != spec->dmux_nids[adc_idx]) {
745
			imux = spec->dinput_mux;
746
			/* 0 = analog */
747
			snd_hda_codec_write_cache(codec,
748
						  spec->dmux_nids[adc_idx], 0,
749
						  AC_VERB_SET_CONNECT_SEL,
750
						  imux->items[0].index);
751
		}
752
	} else {
753
		imux = spec->dinput_mux;
754
		/* first dimux item is hardcoded to select analog imux,
755
		 * so lets skip it
756
		 */
757
		didx = idx - spec->num_analog_muxes + 1;
758
		snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
759
					  AC_VERB_SET_CONNECT_SEL,
760
					  imux->items[didx].index);
761
	}
762
	spec->cur_mux[adc_idx] = idx;
763
	return 1;
764
}
765

766
static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
767
	struct snd_ctl_elem_info *uinfo)
768
{
769
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
770
	struct sigmatel_spec *spec = codec->spec;
771
	return snd_hda_input_mux_info(spec->mono_mux, uinfo);
772
}
773

774
static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
775
	struct snd_ctl_elem_value *ucontrol)
776
{
777
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
778
	struct sigmatel_spec *spec = codec->spec;
779

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

784
static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
785
	struct snd_ctl_elem_value *ucontrol)
786
{
787
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
788
	struct sigmatel_spec *spec = codec->spec;
789

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

794
#define stac92xx_aloopback_info snd_ctl_boolean_mono_info
795

796
static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
797
	struct snd_ctl_elem_value *ucontrol)
798
{
799
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
800
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
801
	struct sigmatel_spec *spec = codec->spec;
802

803
	ucontrol->value.integer.value[0] = !!(spec->aloopback &
804
					      (spec->aloopback_mask << idx));
805
	return 0;
806
}
807

808
static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
809
		struct snd_ctl_elem_value *ucontrol)
810
{
811
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
812
	struct sigmatel_spec *spec = codec->spec;
813
	unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
814
	unsigned int dac_mode;
815
	unsigned int val, idx_val;
816

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

825
	spec->aloopback = val;
826

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

834
	if (spec->aloopback & idx_val) {
835
		snd_hda_power_up(codec);
836
		dac_mode |= idx_val;
837
	} else {
838
		snd_hda_power_down(codec);
839
		dac_mode &= ~idx_val;
840
	}
841

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

845
	return 1;
846
}
847

848
static const struct hda_verb stac9200_core_init[] = {
849
	/* set dac0mux for dac converter */
850
	{ 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
851
	{}
852
};
853

854
static const struct hda_verb stac9200_eapd_init[] = {
855
	/* set dac0mux for dac converter */
856
	{0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
857
	{0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
858
	{}
859
};
860

861
static const struct hda_verb dell_eq_core_init[] = {
862
	/* set master volume to max value without distortion
863
	 * and direct control */
864
	{ 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
865
	{}
866
};
867

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

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

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

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

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

902
static const struct hda_verb stac922x_core_init[] = {
903
	/* set master volume and direct control */	
904
	{ 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
905
	{}
906
};
907

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

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

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

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

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

952
#define STAC_MONO_MUX \
953
	{ \
954
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
955
		.name = "Mono Mux", \
956
		.count = 1, \
957
		.info = stac92xx_mono_mux_enum_info, \
958
		.get = stac92xx_mono_mux_enum_get, \
959
		.put = stac92xx_mono_mux_enum_put, \
960
	}
961

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

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

984
static const struct snd_kcontrol_new stac9200_mixer[] = {
985
	HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
986
	HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
987
	HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
988
	HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
989
	{ } /* end */
990
};
991

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

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

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

1007

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

1012
static const struct snd_kcontrol_new stac925x_mixer[] = {
1013
	HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xe, 0, HDA_OUTPUT),
1014
	HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1015
	{ } /* end */
1016
};
1017

1018
static const struct snd_kcontrol_new stac9205_loopback[] = {
1019
	STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1020
	{}
1021
};
1022

1023
static const struct snd_kcontrol_new stac927x_loopback[] = {
1024
	STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1025
	{}
1026
};
1027

1028
static struct snd_kcontrol_new stac_dmux_mixer = {
1029
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1030
	.name = "Digital Input Source",
1031
	/* count set later */
1032
	.info = stac92xx_dmux_enum_info,
1033
	.get = stac92xx_dmux_enum_get,
1034
	.put = stac92xx_dmux_enum_put,
1035
};
1036

1037
static struct snd_kcontrol_new stac_smux_mixer = {
1038
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1039
	.name = "IEC958 Playback Source",
1040
	/* count set later */
1041
	.info = stac92xx_smux_enum_info,
1042
	.get = stac92xx_smux_enum_get,
1043
	.put = stac92xx_smux_enum_put,
1044
};
1045

1046
static const char * const slave_vols[] = {
1047
	"Front Playback Volume",
1048
	"Surround Playback Volume",
1049
	"Center Playback Volume",
1050
	"LFE Playback Volume",
1051
	"Side Playback Volume",
1052
	"Headphone Playback Volume",
1053
	"Speaker Playback Volume",
1054
	NULL
1055
};
1056

1057
static const char * const slave_sws[] = {
1058
	"Front Playback Switch",
1059
	"Surround Playback Switch",
1060
	"Center Playback Switch",
1061
	"LFE Playback Switch",
1062
	"Side Playback Switch",
1063
	"Headphone Playback Switch",
1064
	"Speaker Playback Switch",
1065
	"IEC958 Playback Switch",
1066
	NULL
1067
};
1068

1069
static void stac92xx_free_kctls(struct hda_codec *codec);
1070
static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1071

1072
static int stac92xx_build_controls(struct hda_codec *codec)
1073
{
1074
	struct sigmatel_spec *spec = codec->spec;
1075
	struct auto_pin_cfg *cfg = &spec->autocfg;
1076
	hda_nid_t nid;
1077
	int err;
1078
	int i;
1079

1080
	if (spec->mixer) {
1081
		err = snd_hda_add_new_ctls(codec, spec->mixer);
1082
		if (err < 0)
1083
			return err;
1084
	}
1085

1086
	for (i = 0; i < spec->num_mixers; i++) {
1087
		err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1088
		if (err < 0)
1089
			return err;
1090
	}
1091
	if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1092
	    snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1093
		stac_dmux_mixer.count = spec->num_dmuxes;
1094
		err = snd_hda_ctl_add(codec, 0,
1095
				  snd_ctl_new1(&stac_dmux_mixer, codec));
1096
		if (err < 0)
1097
			return err;
1098
	}
1099
	if (spec->num_smuxes > 0) {
1100
		int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1101
		struct hda_input_mux *smux = &spec->private_smux;
1102
		/* check for mute support on SPDIF out */
1103
		if (wcaps & AC_WCAP_OUT_AMP) {
1104
			snd_hda_add_imux_item(smux, "Off", 0, NULL);
1105
			spec->spdif_mute = 1;
1106
		}
1107
		stac_smux_mixer.count = spec->num_smuxes;
1108
		err = snd_hda_ctl_add(codec, 0,
1109
				  snd_ctl_new1(&stac_smux_mixer, codec));
1110
		if (err < 0)
1111
			return err;
1112
	}
1113

1114
	if (spec->multiout.dig_out_nid) {
1115
		err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1116
		if (err < 0)
1117
			return err;
1118
		err = snd_hda_create_spdif_share_sw(codec,
1119
						    &spec->multiout);
1120
		if (err < 0)
1121
			return err;
1122
		spec->multiout.share_spdif = 1;
1123
	}
1124
	if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1125
		err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1126
		if (err < 0)
1127
			return err;
1128
	}
1129

1130
	/* if we have no master control, let's create it */
1131
	if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1132
		unsigned int vmaster_tlv[4];
1133
		snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1134
					HDA_OUTPUT, vmaster_tlv);
1135
		/* correct volume offset */
1136
		vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1137
		/* minimum value is actually mute */
1138
		vmaster_tlv[3] |= TLV_DB_SCALE_MUTE;
1139
		err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1140
					  vmaster_tlv, slave_vols);
1141
		if (err < 0)
1142
			return err;
1143
	}
1144
	if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1145
		err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1146
					  NULL, slave_sws);
1147
		if (err < 0)
1148
			return err;
1149
	}
1150

1151
	if (spec->aloopback_ctl &&
1152
	    snd_hda_get_bool_hint(codec, "loopback") == 1) {
1153
		err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1154
		if (err < 0)
1155
			return err;
1156
	}
1157

1158
	stac92xx_free_kctls(codec); /* no longer needed */
1159

1160
	/* create jack input elements */
1161
	if (spec->hp_detect) {
1162
		for (i = 0; i < cfg->hp_outs; i++) {
1163
			int type = SND_JACK_HEADPHONE;
1164
			nid = cfg->hp_pins[i];
1165
			/* jack detection */
1166
			if (cfg->hp_outs == i)
1167
				type |= SND_JACK_LINEOUT;
1168
			err = stac92xx_add_jack(codec, nid, type);
1169
			if (err < 0)
1170
				return err;
1171
		}
1172
	}
1173
	for (i = 0; i < cfg->line_outs; i++) {
1174
		err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1175
					SND_JACK_LINEOUT);
1176
		if (err < 0)
1177
			return err;
1178
	}
1179
	for (i = 0; i < cfg->num_inputs; i++) {
1180
		nid = cfg->inputs[i].pin;
1181
		err = stac92xx_add_jack(codec, nid, SND_JACK_MICROPHONE);
1182
		if (err < 0)
1183
			return err;
1184
	}
1185

1186
	return 0;	
1187
}
1188

1189
static const unsigned int ref9200_pin_configs[8] = {
1190
	0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1191
	0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1192
};
1193

1194
static const unsigned int gateway9200_m4_pin_configs[8] = {
1195
	0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1196
	0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1197
};
1198
static const unsigned int gateway9200_m4_2_pin_configs[8] = {
1199
	0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1200
	0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1201
};
1202

1203
/*
1204
    STAC 9200 pin configs for
1205
    102801A8
1206
    102801DE
1207
    102801E8
1208
*/
1209
static const unsigned int dell9200_d21_pin_configs[8] = {
1210
	0x400001f0, 0x400001f1, 0x02214030, 0x01014010, 
1211
	0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1212
};
1213

1214
/* 
1215
    STAC 9200 pin configs for
1216
    102801C0
1217
    102801C1
1218
*/
1219
static const unsigned int dell9200_d22_pin_configs[8] = {
1220
	0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
1221
	0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1222
};
1223

1224
/* 
1225
    STAC 9200 pin configs for
1226
    102801C4 (Dell Dimension E310)
1227
    102801C5
1228
    102801C7
1229
    102801D9
1230
    102801DA
1231
    102801E3
1232
*/
1233
static const unsigned int dell9200_d23_pin_configs[8] = {
1234
	0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
1235
	0x01813020, 0x01a19021, 0x90100140, 0x400001f2, 
1236
};
1237

1238

1239
/* 
1240
    STAC 9200-32 pin configs for
1241
    102801B5 (Dell Inspiron 630m)
1242
    102801D8 (Dell Inspiron 640m)
1243
*/
1244
static const unsigned int dell9200_m21_pin_configs[8] = {
1245
	0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1246
	0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1247
};
1248

1249
/* 
1250
    STAC 9200-32 pin configs for
1251
    102801C2 (Dell Latitude D620)
1252
    102801C8 
1253
    102801CC (Dell Latitude D820)
1254
    102801D4 
1255
    102801D6 
1256
*/
1257
static const unsigned int dell9200_m22_pin_configs[8] = {
1258
	0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310, 
1259
	0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1260
};
1261

1262
/* 
1263
    STAC 9200-32 pin configs for
1264
    102801CE (Dell XPS M1710)
1265
    102801CF (Dell Precision M90)
1266
*/
1267
static const unsigned int dell9200_m23_pin_configs[8] = {
1268
	0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1269
	0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1270
};
1271

1272
/*
1273
    STAC 9200-32 pin configs for 
1274
    102801C9
1275
    102801CA
1276
    102801CB (Dell Latitude 120L)
1277
    102801D3
1278
*/
1279
static const unsigned int dell9200_m24_pin_configs[8] = {
1280
	0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310, 
1281
	0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe, 
1282
};
1283

1284
/*
1285
    STAC 9200-32 pin configs for
1286
    102801BD (Dell Inspiron E1505n)
1287
    102801EE
1288
    102801EF
1289
*/
1290
static const unsigned int dell9200_m25_pin_configs[8] = {
1291
	0x40c003fa, 0x01441340, 0x0421121f, 0x90170310, 
1292
	0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1293
};
1294

1295
/*
1296
    STAC 9200-32 pin configs for
1297
    102801F5 (Dell Inspiron 1501)
1298
    102801F6
1299
*/
1300
static const unsigned int dell9200_m26_pin_configs[8] = {
1301
	0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310, 
1302
	0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1303
};
1304

1305
/*
1306
    STAC 9200-32
1307
    102801CD (Dell Inspiron E1705/9400)
1308
*/
1309
static const unsigned int dell9200_m27_pin_configs[8] = {
1310
	0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1311
	0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1312
};
1313

1314
static const unsigned int oqo9200_pin_configs[8] = {
1315
	0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1316
	0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1317
};
1318

1319

1320
static const unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1321
	[STAC_REF] = ref9200_pin_configs,
1322
	[STAC_9200_OQO] = oqo9200_pin_configs,
1323
	[STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1324
	[STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1325
	[STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1326
	[STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1327
	[STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1328
	[STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1329
	[STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1330
	[STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1331
	[STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1332
	[STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1333
	[STAC_9200_M4] = gateway9200_m4_pin_configs,
1334
	[STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1335
	[STAC_9200_PANASONIC] = ref9200_pin_configs,
1336
};
1337

1338
static const char * const stac9200_models[STAC_9200_MODELS] = {
1339
	[STAC_AUTO] = "auto",
1340
	[STAC_REF] = "ref",
1341
	[STAC_9200_OQO] = "oqo",
1342
	[STAC_9200_DELL_D21] = "dell-d21",
1343
	[STAC_9200_DELL_D22] = "dell-d22",
1344
	[STAC_9200_DELL_D23] = "dell-d23",
1345
	[STAC_9200_DELL_M21] = "dell-m21",
1346
	[STAC_9200_DELL_M22] = "dell-m22",
1347
	[STAC_9200_DELL_M23] = "dell-m23",
1348
	[STAC_9200_DELL_M24] = "dell-m24",
1349
	[STAC_9200_DELL_M25] = "dell-m25",
1350
	[STAC_9200_DELL_M26] = "dell-m26",
1351
	[STAC_9200_DELL_M27] = "dell-m27",
1352
	[STAC_9200_M4] = "gateway-m4",
1353
	[STAC_9200_M4_2] = "gateway-m4-2",
1354
	[STAC_9200_PANASONIC] = "panasonic",
1355
};
1356

1357
static const struct snd_pci_quirk stac9200_cfg_tbl[] = {
1358
	/* SigmaTel reference board */
1359
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1360
		      "DFI LanParty", STAC_REF),
1361
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1362
		      "DFI LanParty", STAC_REF),
1363
	/* Dell laptops have BIOS problem */
1364
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1365
		      "unknown Dell", STAC_9200_DELL_D21),
1366
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1367
		      "Dell Inspiron 630m", STAC_9200_DELL_M21),
1368
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1369
		      "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1370
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1371
		      "unknown Dell", STAC_9200_DELL_D22),
1372
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1373
		      "unknown Dell", STAC_9200_DELL_D22),
1374
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1375
		      "Dell Latitude D620", STAC_9200_DELL_M22),
1376
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1377
		      "unknown Dell", STAC_9200_DELL_D23),
1378
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1379
		      "unknown Dell", STAC_9200_DELL_D23),
1380
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1381
		      "unknown Dell", STAC_9200_DELL_M22),
1382
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1383
		      "unknown Dell", STAC_9200_DELL_M24),
1384
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1385
		      "unknown Dell", STAC_9200_DELL_M24),
1386
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1387
		      "Dell Latitude 120L", STAC_9200_DELL_M24),
1388
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1389
		      "Dell Latitude D820", STAC_9200_DELL_M22),
1390
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1391
		      "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1392
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1393
		      "Dell XPS M1710", STAC_9200_DELL_M23),
1394
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1395
		      "Dell Precision M90", STAC_9200_DELL_M23),
1396
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1397
		      "unknown Dell", STAC_9200_DELL_M22),
1398
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1399
		      "unknown Dell", STAC_9200_DELL_M22),
1400
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1401
		      "unknown Dell", STAC_9200_DELL_M22),
1402
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1403
		      "Dell Inspiron 640m", STAC_9200_DELL_M21),
1404
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1405
		      "unknown Dell", STAC_9200_DELL_D23),
1406
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1407
		      "unknown Dell", STAC_9200_DELL_D23),
1408
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1409
		      "unknown Dell", STAC_9200_DELL_D21),
1410
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1411
		      "unknown Dell", STAC_9200_DELL_D23),
1412
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1413
		      "unknown Dell", STAC_9200_DELL_D21),
1414
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1415
		      "unknown Dell", STAC_9200_DELL_M25),
1416
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1417
		      "unknown Dell", STAC_9200_DELL_M25),
1418
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1419
		      "Dell Inspiron 1501", STAC_9200_DELL_M26),
1420
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1421
		      "unknown Dell", STAC_9200_DELL_M26),
1422
	/* Panasonic */
1423
	SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1424
	/* Gateway machines needs EAPD to be set on resume */
1425
	SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1426
	SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1427
	SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1428
	/* OQO Mobile */
1429
	SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1430
	{} /* terminator */
1431
};
1432

1433
static const unsigned int ref925x_pin_configs[8] = {
1434
	0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1435
	0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1436
};
1437

1438
static const unsigned int stac925xM1_pin_configs[8] = {
1439
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1440
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1441
};
1442

1443
static const unsigned int stac925xM1_2_pin_configs[8] = {
1444
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1445
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1446
};
1447

1448
static const unsigned int stac925xM2_pin_configs[8] = {
1449
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1450
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1451
};
1452

1453
static const unsigned int stac925xM2_2_pin_configs[8] = {
1454
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1455
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1456
};
1457

1458
static const unsigned int stac925xM3_pin_configs[8] = {
1459
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1460
	0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1461
};
1462

1463
static const unsigned int stac925xM5_pin_configs[8] = {
1464
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1465
	0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1466
};
1467

1468
static const unsigned int stac925xM6_pin_configs[8] = {
1469
	0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1470
	0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1471
};
1472

1473
static const unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1474
	[STAC_REF] = ref925x_pin_configs,
1475
	[STAC_M1] = stac925xM1_pin_configs,
1476
	[STAC_M1_2] = stac925xM1_2_pin_configs,
1477
	[STAC_M2] = stac925xM2_pin_configs,
1478
	[STAC_M2_2] = stac925xM2_2_pin_configs,
1479
	[STAC_M3] = stac925xM3_pin_configs,
1480
	[STAC_M5] = stac925xM5_pin_configs,
1481
	[STAC_M6] = stac925xM6_pin_configs,
1482
};
1483

1484
static const char * const stac925x_models[STAC_925x_MODELS] = {
1485
	[STAC_925x_AUTO] = "auto",
1486
	[STAC_REF] = "ref",
1487
	[STAC_M1] = "m1",
1488
	[STAC_M1_2] = "m1-2",
1489
	[STAC_M2] = "m2",
1490
	[STAC_M2_2] = "m2-2",
1491
	[STAC_M3] = "m3",
1492
	[STAC_M5] = "m5",
1493
	[STAC_M6] = "m6",
1494
};
1495

1496
static const struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1497
	SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1498
	SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1499
	SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1500
	SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1501
	SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1502
	/* Not sure about the brand name for those */
1503
	SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1504
	SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1505
	SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1506
	SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1507
	{} /* terminator */
1508
};
1509

1510
static const struct snd_pci_quirk stac925x_cfg_tbl[] = {
1511
	/* SigmaTel reference board */
1512
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1513
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1514
	SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1515

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

1519
	{} /* terminator */
1520
};
1521

1522
static const unsigned int ref92hd73xx_pin_configs[13] = {
1523
	0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1524
	0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1525
	0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1526
	0x01452050,
1527
};
1528

1529
static const unsigned int dell_m6_pin_configs[13] = {
1530
	0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1531
	0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1532
	0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1533
	0x4f0000f0,
1534
};
1535

1536
static const unsigned int alienware_m17x_pin_configs[13] = {
1537
	0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1538
	0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1539
	0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1540
	0x904601b0,
1541
};
1542

1543
static const unsigned int intel_dg45id_pin_configs[13] = {
1544
	0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1545
	0x01A19250, 0x01011212, 0x01016211
1546
};
1547

1548
static const unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1549
	[STAC_92HD73XX_REF]	= ref92hd73xx_pin_configs,
1550
	[STAC_DELL_M6_AMIC]	= dell_m6_pin_configs,
1551
	[STAC_DELL_M6_DMIC]	= dell_m6_pin_configs,
1552
	[STAC_DELL_M6_BOTH]	= dell_m6_pin_configs,
1553
	[STAC_DELL_EQ]	= dell_m6_pin_configs,
1554
	[STAC_ALIENWARE_M17X]	= alienware_m17x_pin_configs,
1555
	[STAC_92HD73XX_INTEL]	= intel_dg45id_pin_configs,
1556
};
1557

1558
static const char * const stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1559
	[STAC_92HD73XX_AUTO] = "auto",
1560
	[STAC_92HD73XX_NO_JD] = "no-jd",
1561
	[STAC_92HD73XX_REF] = "ref",
1562
	[STAC_92HD73XX_INTEL] = "intel",
1563
	[STAC_DELL_M6_AMIC] = "dell-m6-amic",
1564
	[STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1565
	[STAC_DELL_M6_BOTH] = "dell-m6",
1566
	[STAC_DELL_EQ] = "dell-eq",
1567
	[STAC_ALIENWARE_M17X] = "alienware",
1568
};
1569

1570
static const struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1571
	/* SigmaTel reference board */
1572
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1573
				"DFI LanParty", STAC_92HD73XX_REF),
1574
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1575
				"DFI LanParty", STAC_92HD73XX_REF),
1576
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1577
				"Intel DG45ID", STAC_92HD73XX_INTEL),
1578
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1579
				"Intel DG45FC", STAC_92HD73XX_INTEL),
1580
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1581
				"Dell Studio 1535", STAC_DELL_M6_DMIC),
1582
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1583
				"unknown Dell", STAC_DELL_M6_DMIC),
1584
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1585
				"unknown Dell", STAC_DELL_M6_BOTH),
1586
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1587
				"unknown Dell", STAC_DELL_M6_BOTH),
1588
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1589
				"unknown Dell", STAC_DELL_M6_AMIC),
1590
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1591
				"unknown Dell", STAC_DELL_M6_AMIC),
1592
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1593
				"unknown Dell", STAC_DELL_M6_DMIC),
1594
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1595
				"unknown Dell", STAC_DELL_M6_DMIC),
1596
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1597
				"Dell Studio 1537", STAC_DELL_M6_DMIC),
1598
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1599
				"Dell Studio 17", STAC_DELL_M6_DMIC),
1600
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1601
				"Dell Studio 1555", STAC_DELL_M6_DMIC),
1602
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1603
				"Dell Studio 1557", STAC_DELL_M6_DMIC),
1604
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1605
				"Dell Studio XPS 1645", STAC_DELL_M6_BOTH),
1606
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1607
				"Dell Studio 1558", STAC_DELL_M6_DMIC),
1608
	{} /* terminator */
1609
};
1610

1611
static const struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1612
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1613
		      "Alienware M17x", STAC_ALIENWARE_M17X),
1614
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
1615
		      "Alienware M17x", STAC_ALIENWARE_M17X),
1616
	{} /* terminator */
1617
};
1618

1619
static const unsigned int ref92hd83xxx_pin_configs[10] = {
1620
	0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1621
	0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1622
	0x01451160, 0x98560170,
1623
};
1624

1625
static const unsigned int dell_s14_pin_configs[10] = {
1626
	0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1627
	0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1628
	0x40f000f0, 0x40f000f0,
1629
};
1630

1631
static const unsigned int hp_dv7_4000_pin_configs[10] = {
1632
	0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
1633
	0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
1634
	0x40f000f0, 0x40f000f0,
1635
};
1636

1637
static const unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1638
	[STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1639
	[STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1640
	[STAC_DELL_S14] = dell_s14_pin_configs,
1641
	[STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
1642
};
1643

1644
static const char * const stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1645
	[STAC_92HD83XXX_AUTO] = "auto",
1646
	[STAC_92HD83XXX_REF] = "ref",
1647
	[STAC_92HD83XXX_PWR_REF] = "mic-ref",
1648
	[STAC_DELL_S14] = "dell-s14",
1649
	[STAC_92HD83XXX_HP] = "hp",
1650
	[STAC_HP_DV7_4000] = "hp-dv7-4000",
1651
};
1652

1653
static const struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1654
	/* SigmaTel reference board */
1655
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1656
		      "DFI LanParty", STAC_92HD83XXX_REF),
1657
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1658
		      "DFI LanParty", STAC_92HD83XXX_REF),
1659
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1660
		      "unknown Dell", STAC_DELL_S14),
1661
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600,
1662
		      "HP", STAC_92HD83XXX_HP),
1663
	{} /* terminator */
1664
};
1665

1666
static const unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1667
	0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1668
	0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1669
	0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1670
	0x00000000
1671
};
1672

1673
static const unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1674
	0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1675
	0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1676
	0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1677
	0x00000000
1678
};
1679

1680
static const unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1681
	0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1682
	0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1683
	0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1684
	0x00000000
1685
};
1686

1687
static const unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1688
	0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1689
	0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1690
	0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1691
	0x00000000
1692
};
1693

1694
static const unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1695
	[STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1696
	[STAC_DELL_M4_1]	= dell_m4_1_pin_configs,
1697
	[STAC_DELL_M4_2]	= dell_m4_2_pin_configs,
1698
	[STAC_DELL_M4_3]	= dell_m4_3_pin_configs,
1699
	[STAC_HP_M4]		= NULL,
1700
	[STAC_HP_DV4]		= NULL,
1701
	[STAC_HP_DV5]		= NULL,
1702
	[STAC_HP_HDX]           = NULL,
1703
	[STAC_HP_DV4_1222NR]	= NULL,
1704
};
1705

1706
static const char * const stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1707
	[STAC_92HD71BXX_AUTO] = "auto",
1708
	[STAC_92HD71BXX_REF] = "ref",
1709
	[STAC_DELL_M4_1] = "dell-m4-1",
1710
	[STAC_DELL_M4_2] = "dell-m4-2",
1711
	[STAC_DELL_M4_3] = "dell-m4-3",
1712
	[STAC_HP_M4] = "hp-m4",
1713
	[STAC_HP_DV4] = "hp-dv4",
1714
	[STAC_HP_DV5] = "hp-dv5",
1715
	[STAC_HP_HDX] = "hp-hdx",
1716
	[STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1717
};
1718

1719
static const struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1720
	/* SigmaTel reference board */
1721
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1722
		      "DFI LanParty", STAC_92HD71BXX_REF),
1723
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1724
		      "DFI LanParty", STAC_92HD71BXX_REF),
1725
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1726
		      "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1727
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1728
			  "HP", STAC_HP_DV5),
1729
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1730
		      "HP", STAC_HP_DV5),
1731
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1732
		      "HP dv4-7", STAC_HP_DV4),
1733
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1734
		      "HP dv4-7", STAC_HP_DV5),
1735
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1736
		      "HP HDX", STAC_HP_HDX),  /* HDX18 */
1737
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1738
		      "HP mini 1000", STAC_HP_M4),
1739
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1740
		      "HP HDX", STAC_HP_HDX),  /* HDX16 */
1741
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1742
		      "HP dv6", STAC_HP_DV5),
1743
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1744
		      "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
1745
	SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e,
1746
		      "HP DV6", STAC_HP_DV5),
1747
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1748
		      "HP", STAC_HP_DV5),
1749
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1750
				"unknown Dell", STAC_DELL_M4_1),
1751
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1752
				"unknown Dell", STAC_DELL_M4_1),
1753
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1754
				"unknown Dell", STAC_DELL_M4_1),
1755
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1756
				"unknown Dell", STAC_DELL_M4_1),
1757
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1758
				"unknown Dell", STAC_DELL_M4_1),
1759
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1760
				"unknown Dell", STAC_DELL_M4_1),
1761
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1762
				"unknown Dell", STAC_DELL_M4_1),
1763
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1764
				"unknown Dell", STAC_DELL_M4_2),
1765
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1766
				"unknown Dell", STAC_DELL_M4_2),
1767
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1768
				"unknown Dell", STAC_DELL_M4_2),
1769
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1770
				"unknown Dell", STAC_DELL_M4_2),
1771
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1772
				"unknown Dell", STAC_DELL_M4_3),
1773
	{} /* terminator */
1774
};
1775

1776
static const unsigned int ref922x_pin_configs[10] = {
1777
	0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1778
	0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1779
	0x40000100, 0x40000100,
1780
};
1781

1782
/*
1783
    STAC 922X pin configs for
1784
    102801A7
1785
    102801AB
1786
    102801A9
1787
    102801D1
1788
    102801D2
1789
*/
1790
static const unsigned int dell_922x_d81_pin_configs[10] = {
1791
	0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1792
	0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1793
	0x01813122, 0x400001f2,
1794
};
1795

1796
/*
1797
    STAC 922X pin configs for
1798
    102801AC
1799
    102801D0
1800
*/
1801
static const unsigned int dell_922x_d82_pin_configs[10] = {
1802
	0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1803
	0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1804
	0x01813122, 0x400001f1,
1805
};
1806

1807
/*
1808
    STAC 922X pin configs for
1809
    102801BF
1810
*/
1811
static const unsigned int dell_922x_m81_pin_configs[10] = {
1812
	0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1813
	0x03a11050, 0x01116221, 0x90a70330, 0x01452340, 
1814
	0x40C003f1, 0x405003f0,
1815
};
1816

1817
/*
1818
    STAC 9221 A1 pin configs for
1819
    102801D7 (Dell XPS M1210)
1820
*/
1821
static const unsigned int dell_922x_m82_pin_configs[10] = {
1822
	0x02211211, 0x408103ff, 0x02a1123e, 0x90100310, 
1823
	0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2, 
1824
	0x508003f3, 0x405003f4, 
1825
};
1826

1827
static const unsigned int d945gtp3_pin_configs[10] = {
1828
	0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1829
	0x40000100, 0x40000100, 0x40000100, 0x40000100,
1830
	0x02a19120, 0x40000100,
1831
};
1832

1833
static const unsigned int d945gtp5_pin_configs[10] = {
1834
	0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1835
	0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1836
	0x02a19320, 0x40000100,
1837
};
1838

1839
static const unsigned int intel_mac_v1_pin_configs[10] = {
1840
	0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1841
	0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1842
	0x400000fc, 0x400000fb,
1843
};
1844

1845
static const unsigned int intel_mac_v2_pin_configs[10] = {
1846
	0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1847
	0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1848
	0x400000fc, 0x400000fb,
1849
};
1850

1851
static const unsigned int intel_mac_v3_pin_configs[10] = {
1852
	0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1853
	0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1854
	0x400000fc, 0x400000fb,
1855
};
1856

1857
static const unsigned int intel_mac_v4_pin_configs[10] = {
1858
	0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1859
	0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1860
	0x400000fc, 0x400000fb,
1861
};
1862

1863
static const unsigned int intel_mac_v5_pin_configs[10] = {
1864
	0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1865
	0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1866
	0x400000fc, 0x400000fb,
1867
};
1868

1869
static const unsigned int ecs202_pin_configs[10] = {
1870
	0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1871
	0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1872
	0x9037012e, 0x40e000f2,
1873
};
1874

1875
static const unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1876
	[STAC_D945_REF] = ref922x_pin_configs,
1877
	[STAC_D945GTP3] = d945gtp3_pin_configs,
1878
	[STAC_D945GTP5] = d945gtp5_pin_configs,
1879
	[STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1880
	[STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1881
	[STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1882
	[STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1883
	[STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1884
	[STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1885
	/* for backward compatibility */
1886
	[STAC_MACMINI] = intel_mac_v3_pin_configs,
1887
	[STAC_MACBOOK] = intel_mac_v5_pin_configs,
1888
	[STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1889
	[STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1890
	[STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1891
	[STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1892
	[STAC_ECS_202] = ecs202_pin_configs,
1893
	[STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1894
	[STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,	
1895
	[STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1896
	[STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,	
1897
};
1898

1899
static const char * const stac922x_models[STAC_922X_MODELS] = {
1900
	[STAC_922X_AUTO] = "auto",
1901
	[STAC_D945_REF]	= "ref",
1902
	[STAC_D945GTP5]	= "5stack",
1903
	[STAC_D945GTP3]	= "3stack",
1904
	[STAC_INTEL_MAC_V1] = "intel-mac-v1",
1905
	[STAC_INTEL_MAC_V2] = "intel-mac-v2",
1906
	[STAC_INTEL_MAC_V3] = "intel-mac-v3",
1907
	[STAC_INTEL_MAC_V4] = "intel-mac-v4",
1908
	[STAC_INTEL_MAC_V5] = "intel-mac-v5",
1909
	[STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1910
	/* for backward compatibility */
1911
	[STAC_MACMINI]	= "macmini",
1912
	[STAC_MACBOOK]	= "macbook",
1913
	[STAC_MACBOOK_PRO_V1]	= "macbook-pro-v1",
1914
	[STAC_MACBOOK_PRO_V2]	= "macbook-pro",
1915
	[STAC_IMAC_INTEL] = "imac-intel",
1916
	[STAC_IMAC_INTEL_20] = "imac-intel-20",
1917
	[STAC_ECS_202] = "ecs202",
1918
	[STAC_922X_DELL_D81] = "dell-d81",
1919
	[STAC_922X_DELL_D82] = "dell-d82",
1920
	[STAC_922X_DELL_M81] = "dell-m81",
1921
	[STAC_922X_DELL_M82] = "dell-m82",
1922
};
1923

1924
static const struct snd_pci_quirk stac922x_cfg_tbl[] = {
1925
	/* SigmaTel reference board */
1926
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1927
		      "DFI LanParty", STAC_D945_REF),
1928
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1929
		      "DFI LanParty", STAC_D945_REF),
1930
	/* Intel 945G based systems */
1931
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1932
		      "Intel D945G", STAC_D945GTP3),
1933
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1934
		      "Intel D945G", STAC_D945GTP3),
1935
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1936
		      "Intel D945G", STAC_D945GTP3),
1937
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1938
		      "Intel D945G", STAC_D945GTP3),
1939
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1940
		      "Intel D945G", STAC_D945GTP3),
1941
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1942
		      "Intel D945G", STAC_D945GTP3),
1943
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1944
		      "Intel D945G", STAC_D945GTP3),
1945
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1946
		      "Intel D945G", STAC_D945GTP3),
1947
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1948
		      "Intel D945G", STAC_D945GTP3),
1949
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1950
		      "Intel D945G", STAC_D945GTP3),
1951
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1952
		      "Intel D945G", STAC_D945GTP3),
1953
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1954
		      "Intel D945G", STAC_D945GTP3),
1955
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1956
		      "Intel D945G", STAC_D945GTP3),
1957
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1958
		      "Intel D945G", STAC_D945GTP3),
1959
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1960
		      "Intel D945G", STAC_D945GTP3),
1961
	/* Intel D945G 5-stack systems */
1962
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1963
		      "Intel D945G", STAC_D945GTP5),
1964
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1965
		      "Intel D945G", STAC_D945GTP5),
1966
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1967
		      "Intel D945G", STAC_D945GTP5),
1968
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1969
		      "Intel D945G", STAC_D945GTP5),
1970
	/* Intel 945P based systems */
1971
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1972
		      "Intel D945P", STAC_D945GTP3),
1973
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1974
		      "Intel D945P", STAC_D945GTP3),
1975
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1976
		      "Intel D945P", STAC_D945GTP3),
1977
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1978
		      "Intel D945P", STAC_D945GTP3),
1979
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1980
		      "Intel D945P", STAC_D945GTP3),
1981
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1982
		      "Intel D945P", STAC_D945GTP5),
1983
	/* other intel */
1984
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
1985
		      "Intel D945", STAC_D945_REF),
1986
	/* other systems  */
1987
	/* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1988
	SND_PCI_QUIRK(0x8384, 0x7680,
1989
		      "Mac", STAC_INTEL_MAC_AUTO),
1990
	/* Dell systems  */
1991
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1992
		      "unknown Dell", STAC_922X_DELL_D81),
1993
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1994
		      "unknown Dell", STAC_922X_DELL_D81),
1995
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1996
		      "unknown Dell", STAC_922X_DELL_D81),
1997
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1998
		      "unknown Dell", STAC_922X_DELL_D82),
1999
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
2000
		      "unknown Dell", STAC_922X_DELL_M81),
2001
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
2002
		      "unknown Dell", STAC_922X_DELL_D82),
2003
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2004
		      "unknown Dell", STAC_922X_DELL_D81),
2005
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2006
		      "unknown Dell", STAC_922X_DELL_D81),
2007
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2008
		      "Dell XPS M1210", STAC_922X_DELL_M82),
2009
	/* ECS/PC Chips boards */
2010
	SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2011
		      "ECS/PC chips", STAC_ECS_202),
2012
	{} /* terminator */
2013
};
2014

2015
static const unsigned int ref927x_pin_configs[14] = {
2016
	0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2017
	0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 
2018
	0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2019
	0x01c42190, 0x40000100,
2020
};
2021

2022
static const unsigned int d965_3st_pin_configs[14] = {
2023
	0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2024
	0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2025
	0x40000100, 0x40000100, 0x40000100, 0x40000100,
2026
	0x40000100, 0x40000100
2027
};
2028

2029
static const unsigned int d965_5st_pin_configs[14] = {
2030
	0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2031
	0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2032
	0x40000100, 0x40000100, 0x40000100, 0x01442070,
2033
	0x40000100, 0x40000100
2034
};
2035

2036
static const unsigned int d965_5st_no_fp_pin_configs[14] = {
2037
	0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2038
	0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2039
	0x40000100, 0x40000100, 0x40000100, 0x01442070,
2040
	0x40000100, 0x40000100
2041
};
2042

2043
static const unsigned int dell_3st_pin_configs[14] = {
2044
	0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2045
	0x01111212, 0x01116211, 0x01813050, 0x01112214,
2046
	0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2047
	0x40c003fc, 0x40000100
2048
};
2049

2050
static const unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2051
	[STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2052
	[STAC_D965_REF]  = ref927x_pin_configs,
2053
	[STAC_D965_3ST]  = d965_3st_pin_configs,
2054
	[STAC_D965_5ST]  = d965_5st_pin_configs,
2055
	[STAC_D965_5ST_NO_FP]  = d965_5st_no_fp_pin_configs,
2056
	[STAC_DELL_3ST]  = dell_3st_pin_configs,
2057
	[STAC_DELL_BIOS] = NULL,
2058
	[STAC_927X_VOLKNOB] = NULL,
2059
};
2060

2061
static const char * const stac927x_models[STAC_927X_MODELS] = {
2062
	[STAC_927X_AUTO]	= "auto",
2063
	[STAC_D965_REF_NO_JD]	= "ref-no-jd",
2064
	[STAC_D965_REF]		= "ref",
2065
	[STAC_D965_3ST]		= "3stack",
2066
	[STAC_D965_5ST]		= "5stack",
2067
	[STAC_D965_5ST_NO_FP]	= "5stack-no-fp",
2068
	[STAC_DELL_3ST]		= "dell-3stack",
2069
	[STAC_DELL_BIOS]	= "dell-bios",
2070
	[STAC_927X_VOLKNOB]	= "volknob",
2071
};
2072

2073
static const struct snd_pci_quirk stac927x_cfg_tbl[] = {
2074
	/* SigmaTel reference board */
2075
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2076
		      "DFI LanParty", STAC_D965_REF),
2077
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2078
		      "DFI LanParty", STAC_D965_REF),
2079
	 /* Intel 946 based systems */
2080
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2081
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2082
	/* 965 based 3 stack systems */
2083
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2084
			   "Intel D965", STAC_D965_3ST),
2085
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2086
			   "Intel D965", STAC_D965_3ST),
2087
	/* Dell 3 stack systems */
2088
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2089
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
2090
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
2091
	/* Dell 3 stack systems with verb table in BIOS */
2092
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2093
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
2094
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
2095
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
2096
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2097
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
2098
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
2099
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
2100
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2101
	/* 965 based 5 stack systems */
2102
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2103
			   "Intel D965", STAC_D965_5ST),
2104
	SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2105
			   "Intel D965", STAC_D965_5ST),
2106
	/* volume-knob fixes */
2107
	SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2108
	{} /* terminator */
2109
};
2110

2111
static const unsigned int ref9205_pin_configs[12] = {
2112
	0x40000100, 0x40000100, 0x01016011, 0x01014010,
2113
	0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2114
	0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2115
};
2116

2117
/*
2118
    STAC 9205 pin configs for
2119
    102801F1
2120
    102801F2
2121
    102801FC
2122
    102801FD
2123
    10280204
2124
    1028021F
2125
    10280228 (Dell Vostro 1500)
2126
    10280229 (Dell Vostro 1700)
2127
*/
2128
static const unsigned int dell_9205_m42_pin_configs[12] = {
2129
	0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2130
	0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2131
	0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2132
};
2133

2134
/*
2135
    STAC 9205 pin configs for
2136
    102801F9
2137
    102801FA
2138
    102801FE
2139
    102801FF (Dell Precision M4300)
2140
    10280206
2141
    10280200
2142
    10280201
2143
*/
2144
static const unsigned int dell_9205_m43_pin_configs[12] = {
2145
	0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2146
	0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2147
	0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2148
};
2149

2150
static const unsigned int dell_9205_m44_pin_configs[12] = {
2151
	0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2152
	0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2153
	0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2154
};
2155

2156
static const unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2157
	[STAC_9205_REF] = ref9205_pin_configs,
2158
	[STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2159
	[STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2160
	[STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2161
	[STAC_9205_EAPD] = NULL,
2162
};
2163

2164
static const char * const stac9205_models[STAC_9205_MODELS] = {
2165
	[STAC_9205_AUTO] = "auto",
2166
	[STAC_9205_REF] = "ref",
2167
	[STAC_9205_DELL_M42] = "dell-m42",
2168
	[STAC_9205_DELL_M43] = "dell-m43",
2169
	[STAC_9205_DELL_M44] = "dell-m44",
2170
	[STAC_9205_EAPD] = "eapd",
2171
};
2172

2173
static const struct snd_pci_quirk stac9205_cfg_tbl[] = {
2174
	/* SigmaTel reference board */
2175
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2176
		      "DFI LanParty", STAC_9205_REF),
2177
	SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2178
		      "SigmaTel", STAC_9205_REF),
2179
	SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2180
		      "DFI LanParty", STAC_9205_REF),
2181
	/* Dell */
2182
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2183
		      "unknown Dell", STAC_9205_DELL_M42),
2184
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2185
		      "unknown Dell", STAC_9205_DELL_M42),
2186
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2187
		      "Dell Precision", STAC_9205_DELL_M43),
2188
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2189
		      "Dell Precision", STAC_9205_DELL_M43),
2190
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2191
		      "Dell Precision", STAC_9205_DELL_M43),
2192
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2193
		      "unknown Dell", STAC_9205_DELL_M42),
2194
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2195
		      "unknown Dell", STAC_9205_DELL_M42),
2196
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2197
		      "Dell Precision", STAC_9205_DELL_M43),
2198
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2199
		      "Dell Precision M4300", STAC_9205_DELL_M43),
2200
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2201
		      "unknown Dell", STAC_9205_DELL_M42),
2202
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2203
		      "Dell Precision", STAC_9205_DELL_M43),
2204
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2205
		      "Dell Precision", STAC_9205_DELL_M43),
2206
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2207
		      "Dell Precision", STAC_9205_DELL_M43),
2208
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2209
		      "Dell Inspiron", STAC_9205_DELL_M44),
2210
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2211
		      "Dell Vostro 1500", STAC_9205_DELL_M42),
2212
	SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2213
		      "Dell Vostro 1700", STAC_9205_DELL_M42),
2214
	/* Gateway */
2215
	SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2216
	SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2217
	{} /* terminator */
2218
};
2219

2220
static void stac92xx_set_config_regs(struct hda_codec *codec,
2221
				     const unsigned int *pincfgs)
2222
{
2223
	int i;
2224
	struct sigmatel_spec *spec = codec->spec;
2225

2226
	if (!pincfgs)
2227
		return;
2228

2229
	for (i = 0; i < spec->num_pins; i++)
2230
		if (spec->pin_nids[i] && pincfgs[i])
2231
			snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2232
						 pincfgs[i]);
2233
}
2234

2235
/*
2236
 * Analog playback callbacks
2237
 */
2238
static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2239
				      struct hda_codec *codec,
2240
				      struct snd_pcm_substream *substream)
2241
{
2242
	struct sigmatel_spec *spec = codec->spec;
2243
	if (spec->stream_delay)
2244
		msleep(spec->stream_delay);
2245
	return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2246
					     hinfo);
2247
}
2248

2249
static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2250
					 struct hda_codec *codec,
2251
					 unsigned int stream_tag,
2252
					 unsigned int format,
2253
					 struct snd_pcm_substream *substream)
2254
{
2255
	struct sigmatel_spec *spec = codec->spec;
2256
	return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2257
}
2258

2259
static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2260
					struct hda_codec *codec,
2261
					struct snd_pcm_substream *substream)
2262
{
2263
	struct sigmatel_spec *spec = codec->spec;
2264
	return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2265
}
2266

2267
/*
2268
 * Digital playback callbacks
2269
 */
2270
static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2271
					  struct hda_codec *codec,
2272
					  struct snd_pcm_substream *substream)
2273
{
2274
	struct sigmatel_spec *spec = codec->spec;
2275
	return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2276
}
2277

2278
static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2279
					   struct hda_codec *codec,
2280
					   struct snd_pcm_substream *substream)
2281
{
2282
	struct sigmatel_spec *spec = codec->spec;
2283
	return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2284
}
2285

2286
static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2287
					 struct hda_codec *codec,
2288
					 unsigned int stream_tag,
2289
					 unsigned int format,
2290
					 struct snd_pcm_substream *substream)
2291
{
2292
	struct sigmatel_spec *spec = codec->spec;
2293
	return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2294
					     stream_tag, format, substream);
2295
}
2296

2297
static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2298
					struct hda_codec *codec,
2299
					struct snd_pcm_substream *substream)
2300
{
2301
	struct sigmatel_spec *spec = codec->spec;
2302
	return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2303
}
2304

2305

2306
/*
2307
 * Analog capture callbacks
2308
 */
2309
static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2310
					struct hda_codec *codec,
2311
					unsigned int stream_tag,
2312
					unsigned int format,
2313
					struct snd_pcm_substream *substream)
2314
{
2315
	struct sigmatel_spec *spec = codec->spec;
2316
	hda_nid_t nid = spec->adc_nids[substream->number];
2317

2318
	if (spec->powerdown_adcs) {
2319
		msleep(40);
2320
		snd_hda_codec_write(codec, nid, 0,
2321
			AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2322
	}
2323
	snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2324
	return 0;
2325
}
2326

2327
static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2328
					struct hda_codec *codec,
2329
					struct snd_pcm_substream *substream)
2330
{
2331
	struct sigmatel_spec *spec = codec->spec;
2332
	hda_nid_t nid = spec->adc_nids[substream->number];
2333

2334
	snd_hda_codec_cleanup_stream(codec, nid);
2335
	if (spec->powerdown_adcs)
2336
		snd_hda_codec_write(codec, nid, 0,
2337
			AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2338
	return 0;
2339
}
2340

2341
static const struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2342
	.substreams = 1,
2343
	.channels_min = 2,
2344
	.channels_max = 2,
2345
	/* NID is set in stac92xx_build_pcms */
2346
	.ops = {
2347
		.open = stac92xx_dig_playback_pcm_open,
2348
		.close = stac92xx_dig_playback_pcm_close,
2349
		.prepare = stac92xx_dig_playback_pcm_prepare,
2350
		.cleanup = stac92xx_dig_playback_pcm_cleanup
2351
	},
2352
};
2353

2354
static const struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2355
	.substreams = 1,
2356
	.channels_min = 2,
2357
	.channels_max = 2,
2358
	/* NID is set in stac92xx_build_pcms */
2359
};
2360

2361
static const struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2362
	.substreams = 1,
2363
	.channels_min = 2,
2364
	.channels_max = 8,
2365
	.nid = 0x02, /* NID to query formats and rates */
2366
	.ops = {
2367
		.open = stac92xx_playback_pcm_open,
2368
		.prepare = stac92xx_playback_pcm_prepare,
2369
		.cleanup = stac92xx_playback_pcm_cleanup
2370
	},
2371
};
2372

2373
static const struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2374
	.substreams = 1,
2375
	.channels_min = 2,
2376
	.channels_max = 2,
2377
	.nid = 0x06, /* NID to query formats and rates */
2378
	.ops = {
2379
		.open = stac92xx_playback_pcm_open,
2380
		.prepare = stac92xx_playback_pcm_prepare,
2381
		.cleanup = stac92xx_playback_pcm_cleanup
2382
	},
2383
};
2384

2385
static const struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2386
	.channels_min = 2,
2387
	.channels_max = 2,
2388
	/* NID + .substreams is set in stac92xx_build_pcms */
2389
	.ops = {
2390
		.prepare = stac92xx_capture_pcm_prepare,
2391
		.cleanup = stac92xx_capture_pcm_cleanup
2392
	},
2393
};
2394

2395
static int stac92xx_build_pcms(struct hda_codec *codec)
2396
{
2397
	struct sigmatel_spec *spec = codec->spec;
2398
	struct hda_pcm *info = spec->pcm_rec;
2399

2400
	codec->num_pcms = 1;
2401
	codec->pcm_info = info;
2402

2403
	info->name = "STAC92xx Analog";
2404
	info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2405
	info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2406
		spec->multiout.dac_nids[0];
2407
	info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2408
	info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2409
	info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2410

2411
	if (spec->alt_switch) {
2412
		codec->num_pcms++;
2413
		info++;
2414
		info->name = "STAC92xx Analog Alt";
2415
		info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2416
	}
2417

2418
	if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2419
		codec->num_pcms++;
2420
		info++;
2421
		info->name = "STAC92xx Digital";
2422
		info->pcm_type = spec->autocfg.dig_out_type[0];
2423
		if (spec->multiout.dig_out_nid) {
2424
			info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2425
			info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2426
		}
2427
		if (spec->dig_in_nid) {
2428
			info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2429
			info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2430
		}
2431
	}
2432

2433
	return 0;
2434
}
2435

2436
static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
2437
					hda_nid_t nid)
2438
{
2439
	unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2440
	pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2441
	if (pincap & AC_PINCAP_VREF_100)
2442
		return AC_PINCTL_VREF_100;
2443
	if (pincap & AC_PINCAP_VREF_80)
2444
		return AC_PINCTL_VREF_80;
2445
	if (pincap & AC_PINCAP_VREF_50)
2446
		return AC_PINCTL_VREF_50;
2447
	if (pincap & AC_PINCAP_VREF_GRD)
2448
		return AC_PINCTL_VREF_GRD;
2449
	return 0;
2450
}
2451

2452
static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2453

2454
{
2455
	snd_hda_codec_write_cache(codec, nid, 0,
2456
				  AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2457
}
2458

2459
#define stac92xx_hp_switch_info		snd_ctl_boolean_mono_info
2460

2461
static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2462
			struct snd_ctl_elem_value *ucontrol)
2463
{
2464
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2465
	struct sigmatel_spec *spec = codec->spec;
2466

2467
	ucontrol->value.integer.value[0] = !!spec->hp_switch;
2468
	return 0;
2469
}
2470

2471
static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2472

2473
static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2474
			struct snd_ctl_elem_value *ucontrol)
2475
{
2476
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2477
	struct sigmatel_spec *spec = codec->spec;
2478
	int nid = kcontrol->private_value;
2479
 
2480
	spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2481

2482
	/* check to be sure that the ports are up to date with
2483
	 * switch changes
2484
	 */
2485
	stac_issue_unsol_event(codec, nid);
2486

2487
	return 1;
2488
}
2489

2490
static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2491
				struct snd_ctl_elem_info *uinfo)
2492
{
2493
	int i;
2494
	static const char * const texts[] = {
2495
		"Mic In", "Line In", "Line Out"
2496
	};
2497

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

2502
	if (nid == spec->mic_switch || nid == spec->line_switch)
2503
		i = 3;
2504
	else
2505
		i = 2;
2506

2507
	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2508
	uinfo->value.enumerated.items = i;
2509
	uinfo->count = 1;
2510
	if (uinfo->value.enumerated.item >= i)
2511
		uinfo->value.enumerated.item = i-1;
2512
	strcpy(uinfo->value.enumerated.name,
2513
		texts[uinfo->value.enumerated.item]);
2514

2515
	return 0;
2516
}
2517

2518
static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2519
				struct snd_ctl_elem_value *ucontrol)
2520
{
2521
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2522
	hda_nid_t nid = kcontrol->private_value;
2523
	unsigned int vref = stac92xx_vref_get(codec, nid);
2524

2525
	if (vref == stac92xx_get_default_vref(codec, nid))
2526
		ucontrol->value.enumerated.item[0] = 0;
2527
	else if (vref == AC_PINCTL_VREF_GRD)
2528
		ucontrol->value.enumerated.item[0] = 1;
2529
	else if (vref == AC_PINCTL_VREF_HIZ)
2530
		ucontrol->value.enumerated.item[0] = 2;
2531

2532
	return 0;
2533
}
2534

2535
static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2536
				struct snd_ctl_elem_value *ucontrol)
2537
{
2538
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2539
	unsigned int new_vref = 0;
2540
	int error;
2541
	hda_nid_t nid = kcontrol->private_value;
2542

2543
	if (ucontrol->value.enumerated.item[0] == 0)
2544
		new_vref = stac92xx_get_default_vref(codec, nid);
2545
	else if (ucontrol->value.enumerated.item[0] == 1)
2546
		new_vref = AC_PINCTL_VREF_GRD;
2547
	else if (ucontrol->value.enumerated.item[0] == 2)
2548
		new_vref = AC_PINCTL_VREF_HIZ;
2549
	else
2550
		return 0;
2551

2552
	if (new_vref != stac92xx_vref_get(codec, nid)) {
2553
		error = stac92xx_vref_set(codec, nid, new_vref);
2554
		return error;
2555
	}
2556

2557
	return 0;
2558
}
2559

2560
static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2561
				struct snd_ctl_elem_info *uinfo)
2562
{
2563
	char *texts[2];
2564
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2565
	struct sigmatel_spec *spec = codec->spec;
2566

2567
	if (kcontrol->private_value == spec->line_switch)
2568
		texts[0] = "Line In";
2569
	else
2570
		texts[0] = "Mic In";
2571
	texts[1] = "Line Out";
2572
	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2573
	uinfo->value.enumerated.items = 2;
2574
	uinfo->count = 1;
2575

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

2581
	return 0;
2582
}
2583

2584
static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2585
{
2586
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2587
	struct sigmatel_spec *spec = codec->spec;
2588
	hda_nid_t nid = kcontrol->private_value;
2589
	int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2590

2591
	ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2592
	return 0;
2593
}
2594

2595
static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2596
{
2597
        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2598
	struct sigmatel_spec *spec = codec->spec;
2599
	hda_nid_t nid = kcontrol->private_value;
2600
	int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2601
	unsigned short val = !!ucontrol->value.enumerated.item[0];
2602

2603
	spec->io_switch[io_idx] = val;
2604

2605
	if (val)
2606
		stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2607
	else {
2608
		unsigned int pinctl = AC_PINCTL_IN_EN;
2609
		if (io_idx) /* set VREF for mic */
2610
			pinctl |= stac92xx_get_default_vref(codec, nid);
2611
		stac92xx_auto_set_pinctl(codec, nid, pinctl);
2612
	}
2613

2614
	/* check the auto-mute again: we need to mute/unmute the speaker
2615
	 * appropriately according to the pin direction
2616
	 */
2617
	if (spec->hp_detect)
2618
		stac_issue_unsol_event(codec, nid);
2619

2620
        return 1;
2621
}
2622

2623
#define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2624

2625
static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2626
		struct snd_ctl_elem_value *ucontrol)
2627
{
2628
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2629
	struct sigmatel_spec *spec = codec->spec;
2630

2631
	ucontrol->value.integer.value[0] = spec->clfe_swap;
2632
	return 0;
2633
}
2634

2635
static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2636
		struct snd_ctl_elem_value *ucontrol)
2637
{
2638
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2639
	struct sigmatel_spec *spec = codec->spec;
2640
	hda_nid_t nid = kcontrol->private_value & 0xff;
2641
	unsigned int val = !!ucontrol->value.integer.value[0];
2642

2643
	if (spec->clfe_swap == val)
2644
		return 0;
2645

2646
	spec->clfe_swap = val;
2647

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

2651
	return 1;
2652
}
2653

2654
#define STAC_CODEC_HP_SWITCH(xname) \
2655
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2656
	  .name = xname, \
2657
	  .index = 0, \
2658
	  .info = stac92xx_hp_switch_info, \
2659
	  .get = stac92xx_hp_switch_get, \
2660
	  .put = stac92xx_hp_switch_put, \
2661
	}
2662

2663
#define STAC_CODEC_IO_SWITCH(xname, xpval) \
2664
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2665
	  .name = xname, \
2666
	  .index = 0, \
2667
          .info = stac92xx_io_switch_info, \
2668
          .get = stac92xx_io_switch_get, \
2669
          .put = stac92xx_io_switch_put, \
2670
          .private_value = xpval, \
2671
	}
2672

2673
#define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2674
	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2675
	  .name = xname, \
2676
	  .index = 0, \
2677
	  .info = stac92xx_clfe_switch_info, \
2678
	  .get = stac92xx_clfe_switch_get, \
2679
	  .put = stac92xx_clfe_switch_put, \
2680
	  .private_value = xpval, \
2681
	}
2682

2683
enum {
2684
	STAC_CTL_WIDGET_VOL,
2685
	STAC_CTL_WIDGET_MUTE,
2686
	STAC_CTL_WIDGET_MUTE_BEEP,
2687
	STAC_CTL_WIDGET_MONO_MUX,
2688
	STAC_CTL_WIDGET_HP_SWITCH,
2689
	STAC_CTL_WIDGET_IO_SWITCH,
2690
	STAC_CTL_WIDGET_CLFE_SWITCH,
2691
	STAC_CTL_WIDGET_DC_BIAS
2692
};
2693

2694
static const struct snd_kcontrol_new stac92xx_control_templates[] = {
2695
	HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2696
	HDA_CODEC_MUTE(NULL, 0, 0, 0),
2697
	HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2698
	STAC_MONO_MUX,
2699
	STAC_CODEC_HP_SWITCH(NULL),
2700
	STAC_CODEC_IO_SWITCH(NULL, 0),
2701
	STAC_CODEC_CLFE_SWITCH(NULL, 0),
2702
	DC_BIAS(NULL, 0, 0),
2703
};
2704

2705
/* add dynamic controls */
2706
static struct snd_kcontrol_new *
2707
stac_control_new(struct sigmatel_spec *spec,
2708
		 const struct snd_kcontrol_new *ktemp,
2709
		 const char *name,
2710
		 unsigned int subdev)
2711
{
2712
	struct snd_kcontrol_new *knew;
2713

2714
	snd_array_init(&spec->kctls, sizeof(*knew), 32);
2715
	knew = snd_array_new(&spec->kctls);
2716
	if (!knew)
2717
		return NULL;
2718
	*knew = *ktemp;
2719
	knew->name = kstrdup(name, GFP_KERNEL);
2720
	if (!knew->name) {
2721
		/* roolback */
2722
		memset(knew, 0, sizeof(*knew));
2723
		spec->kctls.alloced--;
2724
		return NULL;
2725
	}
2726
	knew->subdevice = subdev;
2727
	return knew;
2728
}
2729

2730
static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2731
				     const struct snd_kcontrol_new *ktemp,
2732
				     int idx, const char *name,
2733
				     unsigned long val)
2734
{
2735
	struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2736
							 HDA_SUBDEV_AMP_FLAG);
2737
	if (!knew)
2738
		return -ENOMEM;
2739
	knew->index = idx;
2740
	knew->private_value = val;
2741
	return 0;
2742
}
2743

2744
static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2745
					   int type, int idx, const char *name,
2746
					   unsigned long val)
2747
{
2748
	return stac92xx_add_control_temp(spec,
2749
					 &stac92xx_control_templates[type],
2750
					 idx, name, val);
2751
}
2752

2753

2754
/* add dynamic controls */
2755
static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2756
				       const char *name, unsigned long val)
2757
{
2758
	return stac92xx_add_control_idx(spec, type, 0, name, val);
2759
}
2760

2761
static const struct snd_kcontrol_new stac_input_src_temp = {
2762
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2763
	.name = "Input Source",
2764
	.info = stac92xx_mux_enum_info,
2765
	.get = stac92xx_mux_enum_get,
2766
	.put = stac92xx_mux_enum_put,
2767
};
2768

2769
static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2770
						hda_nid_t nid, int idx)
2771
{
2772
	int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2773
	int control = 0;
2774
	struct sigmatel_spec *spec = codec->spec;
2775
	char name[22];
2776

2777
	if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2778
		if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2779
			&& nid == spec->line_switch)
2780
			control = STAC_CTL_WIDGET_IO_SWITCH;
2781
		else if (snd_hda_query_pin_caps(codec, nid)
2782
			& (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2783
			control = STAC_CTL_WIDGET_DC_BIAS;
2784
		else if (nid == spec->mic_switch)
2785
			control = STAC_CTL_WIDGET_IO_SWITCH;
2786
	}
2787

2788
	if (control) {
2789
		strcpy(name, hda_get_input_pin_label(codec, nid, 1));
2790
		return stac92xx_add_control(codec->spec, control,
2791
					strcat(name, " Jack Mode"), nid);
2792
	}
2793

2794
	return 0;
2795
}
2796

2797
static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2798
{
2799
	struct snd_kcontrol_new *knew;
2800
	struct hda_input_mux *imux = &spec->private_imux;
2801

2802
	if (spec->auto_mic)
2803
		return 0; /* no need for input source */
2804
	if (!spec->num_adcs || imux->num_items <= 1)
2805
		return 0; /* no need for input source control */
2806
	knew = stac_control_new(spec, &stac_input_src_temp,
2807
				stac_input_src_temp.name, 0);
2808
	if (!knew)
2809
		return -ENOMEM;
2810
	knew->count = spec->num_adcs;
2811
	return 0;
2812
}
2813

2814
/* check whether the line-input can be used as line-out */
2815
static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2816
{
2817
	struct sigmatel_spec *spec = codec->spec;
2818
	struct auto_pin_cfg *cfg = &spec->autocfg;
2819
	hda_nid_t nid;
2820
	unsigned int pincap;
2821
	int i;
2822

2823
	if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2824
		return 0;
2825
	for (i = 0; i < cfg->num_inputs; i++) {
2826
		if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) {
2827
			nid = cfg->inputs[i].pin;
2828
			pincap = snd_hda_query_pin_caps(codec, nid);
2829
			if (pincap & AC_PINCAP_OUT)
2830
				return nid;
2831
		}
2832
	}
2833
	return 0;
2834
}
2835

2836
static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid);
2837

2838
/* check whether the mic-input can be used as line-out */
2839
static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac)
2840
{
2841
	struct sigmatel_spec *spec = codec->spec;
2842
	struct auto_pin_cfg *cfg = &spec->autocfg;
2843
	unsigned int def_conf, pincap;
2844
	int i;
2845

2846
	*dac = 0;
2847
	if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2848
		return 0;
2849
	for (i = 0; i < cfg->num_inputs; i++) {
2850
		hda_nid_t nid = cfg->inputs[i].pin;
2851
		if (cfg->inputs[i].type != AUTO_PIN_MIC)
2852
			continue;
2853
		def_conf = snd_hda_codec_get_pincfg(codec, nid);
2854
		/* some laptops have an internal analog microphone
2855
		 * which can't be used as a output */
2856
		if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2857
			pincap = snd_hda_query_pin_caps(codec, nid);
2858
			if (pincap & AC_PINCAP_OUT) {
2859
				*dac = get_unassigned_dac(codec, nid);
2860
				if (*dac)
2861
					return nid;
2862
			}
2863
		}
2864
	}
2865
	return 0;
2866
}
2867

2868
static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2869
{
2870
	int i;
2871
	
2872
	for (i = 0; i < spec->multiout.num_dacs; i++) {
2873
		if (spec->multiout.dac_nids[i] == nid)
2874
			return 1;
2875
	}
2876

2877
	return 0;
2878
}
2879

2880
static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2881
{
2882
	int i;
2883
	if (is_in_dac_nids(spec, nid))
2884
		return 1;
2885
	for (i = 0; i < spec->autocfg.hp_outs; i++)
2886
		if (spec->hp_dacs[i] == nid)
2887
			return 1;
2888
	for (i = 0; i < spec->autocfg.speaker_outs; i++)
2889
		if (spec->speaker_dacs[i] == nid)
2890
			return 1;
2891
	return 0;
2892
}
2893

2894
static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2895
{
2896
	struct sigmatel_spec *spec = codec->spec;
2897
	int j, conn_len;
2898
	hda_nid_t conn[HDA_MAX_CONNECTIONS];
2899
	unsigned int wcaps, wtype;
2900

2901
	conn_len = snd_hda_get_connections(codec, nid, conn,
2902
					   HDA_MAX_CONNECTIONS);
2903
	/* 92HD88: trace back up the link of nids to find the DAC */
2904
	while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2905
					!= AC_WID_AUD_OUT)) {
2906
		nid = conn[0];
2907
		conn_len = snd_hda_get_connections(codec, nid, conn,
2908
			HDA_MAX_CONNECTIONS);
2909
	}
2910
	for (j = 0; j < conn_len; j++) {
2911
		wcaps = get_wcaps(codec, conn[j]);
2912
		wtype = get_wcaps_type(wcaps);
2913
		/* we check only analog outputs */
2914
		if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2915
			continue;
2916
		/* if this route has a free DAC, assign it */
2917
		if (!check_all_dac_nids(spec, conn[j])) {
2918
			if (conn_len > 1) {
2919
				/* select this DAC in the pin's input mux */
2920
				snd_hda_codec_write_cache(codec, nid, 0,
2921
						  AC_VERB_SET_CONNECT_SEL, j);
2922
			}
2923
			return conn[j];
2924
		}
2925
	}
2926
	/* if all DACs are already assigned, connect to the primary DAC */
2927
	if (conn_len > 1) {
2928
		for (j = 0; j < conn_len; j++) {
2929
			if (conn[j] == spec->multiout.dac_nids[0]) {
2930
				snd_hda_codec_write_cache(codec, nid, 0,
2931
						  AC_VERB_SET_CONNECT_SEL, j);
2932
				break;
2933
			}
2934
		}
2935
	}
2936
	return 0;
2937
}
2938

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

2942
/*
2943
 * Fill in the dac_nids table from the parsed pin configuration
2944
 * This function only works when every pin in line_out_pins[]
2945
 * contains atleast one DAC in its connection list. Some 92xx
2946
 * codecs are not connected directly to a DAC, such as the 9200
2947
 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2948
 */
2949
static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2950
{
2951
	struct sigmatel_spec *spec = codec->spec;
2952
	struct auto_pin_cfg *cfg = &spec->autocfg;
2953
	int i;
2954
	hda_nid_t nid, dac;
2955
	
2956
	for (i = 0; i < cfg->line_outs; i++) {
2957
		nid = cfg->line_out_pins[i];
2958
		dac = get_unassigned_dac(codec, nid);
2959
		if (!dac) {
2960
			if (spec->multiout.num_dacs > 0) {
2961
				/* we have already working output pins,
2962
				 * so let's drop the broken ones again
2963
				 */
2964
				cfg->line_outs = spec->multiout.num_dacs;
2965
				break;
2966
			}
2967
			/* error out, no available DAC found */
2968
			snd_printk(KERN_ERR
2969
				   "%s: No available DAC for pin 0x%x\n",
2970
				   __func__, nid);
2971
			return -ENODEV;
2972
		}
2973
		add_spec_dacs(spec, dac);
2974
	}
2975

2976
	for (i = 0; i < cfg->hp_outs; i++) {
2977
		nid = cfg->hp_pins[i];
2978
		dac = get_unassigned_dac(codec, nid);
2979
		if (dac) {
2980
			if (!spec->multiout.hp_nid)
2981
				spec->multiout.hp_nid = dac;
2982
			else
2983
				add_spec_extra_dacs(spec, dac);
2984
		}
2985
		spec->hp_dacs[i] = dac;
2986
	}
2987

2988
	for (i = 0; i < cfg->speaker_outs; i++) {
2989
		nid = cfg->speaker_pins[i];
2990
		dac = get_unassigned_dac(codec, nid);
2991
		if (dac)
2992
			add_spec_extra_dacs(spec, dac);
2993
		spec->speaker_dacs[i] = dac;
2994
	}
2995

2996
	/* add line-in as output */
2997
	nid = check_line_out_switch(codec);
2998
	if (nid) {
2999
		dac = get_unassigned_dac(codec, nid);
3000
		if (dac) {
3001
			snd_printdd("STAC: Add line-in 0x%x as output %d\n",
3002
				    nid, cfg->line_outs);
3003
			cfg->line_out_pins[cfg->line_outs] = nid;
3004
			cfg->line_outs++;
3005
			spec->line_switch = nid;
3006
			add_spec_dacs(spec, dac);
3007
		}
3008
	}
3009
	/* add mic as output */
3010
	nid = check_mic_out_switch(codec, &dac);
3011
	if (nid && dac) {
3012
		snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3013
			    nid, cfg->line_outs);
3014
		cfg->line_out_pins[cfg->line_outs] = nid;
3015
		cfg->line_outs++;
3016
		spec->mic_switch = nid;
3017
		add_spec_dacs(spec, dac);
3018
	}
3019

3020
	snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3021
		   spec->multiout.num_dacs,
3022
		   spec->multiout.dac_nids[0],
3023
		   spec->multiout.dac_nids[1],
3024
		   spec->multiout.dac_nids[2],
3025
		   spec->multiout.dac_nids[3],
3026
		   spec->multiout.dac_nids[4]);
3027

3028
	return 0;
3029
}
3030

3031
/* create volume control/switch for the given prefx type */
3032
static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3033
			       int idx, hda_nid_t nid, int chs)
3034
{
3035
	struct sigmatel_spec *spec = codec->spec;
3036
	char name[32];
3037
	int err;
3038

3039
	if (!spec->check_volume_offset) {
3040
		unsigned int caps, step, nums, db_scale;
3041
		caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3042
		step = (caps & AC_AMPCAP_STEP_SIZE) >>
3043
			AC_AMPCAP_STEP_SIZE_SHIFT;
3044
		step = (step + 1) * 25; /* in .01dB unit */
3045
		nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3046
			AC_AMPCAP_NUM_STEPS_SHIFT;
3047
		db_scale = nums * step;
3048
		/* if dB scale is over -64dB, and finer enough,
3049
		 * let's reduce it to half
3050
		 */
3051
		if (db_scale > 6400 && nums >= 0x1f)
3052
			spec->volume_offset = nums / 2;
3053
		spec->check_volume_offset = 1;
3054
	}
3055

3056
	sprintf(name, "%s Playback Volume", pfx);
3057
	err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3058
		HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3059
					spec->volume_offset));
3060
	if (err < 0)
3061
		return err;
3062
	sprintf(name, "%s Playback Switch", pfx);
3063
	err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3064
				   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3065
	if (err < 0)
3066
		return err;
3067
	return 0;
3068
}
3069

3070
#define create_controls(codec, pfx, nid, chs) \
3071
	create_controls_idx(codec, pfx, 0, nid, chs)
3072

3073
static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3074
{
3075
	if (spec->multiout.num_dacs > 4) {
3076
		printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3077
		return 1;
3078
	} else {
3079
		snd_BUG_ON(spec->multiout.dac_nids != spec->dac_nids);
3080
		spec->dac_nids[spec->multiout.num_dacs] = nid;
3081
		spec->multiout.num_dacs++;
3082
	}
3083
	return 0;
3084
}
3085

3086
static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3087
{
3088
	int i;
3089
	for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3090
		if (!spec->multiout.extra_out_nid[i]) {
3091
			spec->multiout.extra_out_nid[i] = nid;
3092
			return 0;
3093
		}
3094
	}
3095
	printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3096
	return 1;
3097
}
3098

3099
/* Create output controls
3100
 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3101
 */
3102
static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3103
				 const hda_nid_t *pins,
3104
				 const hda_nid_t *dac_nids,
3105
				 int type)
3106
{
3107
	struct sigmatel_spec *spec = codec->spec;
3108
	static const char * const chname[4] = {
3109
		"Front", "Surround", NULL /*CLFE*/, "Side"
3110
	};
3111
	hda_nid_t nid;
3112
	int i, err;
3113
	unsigned int wid_caps;
3114

3115
	for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3116
		if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3117
			if (is_jack_detectable(codec, pins[i]))
3118
				spec->hp_detect = 1;
3119
		}
3120
		nid = dac_nids[i];
3121
		if (!nid)
3122
			continue;
3123
		if (type != AUTO_PIN_HP_OUT && i == 2) {
3124
			/* Center/LFE */
3125
			err = create_controls(codec, "Center", nid, 1);
3126
			if (err < 0)
3127
				return err;
3128
			err = create_controls(codec, "LFE", nid, 2);
3129
			if (err < 0)
3130
				return err;
3131

3132
			wid_caps = get_wcaps(codec, nid);
3133

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

3139
				if (err < 0)
3140
					return err;
3141
			}
3142

3143
		} else {
3144
			const char *name;
3145
			int idx;
3146
			switch (type) {
3147
			case AUTO_PIN_HP_OUT:
3148
				name = "Headphone";
3149
				idx = i;
3150
				break;
3151
			case AUTO_PIN_SPEAKER_OUT:
3152
				name = "Speaker";
3153
				idx = i;
3154
				break;
3155
			default:
3156
				name = chname[i];
3157
				idx = 0;
3158
				break;
3159
			}
3160
			err = create_controls_idx(codec, name, idx, nid, 3);
3161
			if (err < 0)
3162
				return err;
3163
		}
3164
	}
3165
	return 0;
3166
}
3167

3168
static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3169
				    unsigned long sw, int idx)
3170
{
3171
	int err;
3172
	err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3173
				       "Capture Volume", vol);
3174
	if (err < 0)
3175
		return err;
3176
	err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3177
				       "Capture Switch", sw);
3178
	if (err < 0)
3179
		return err;
3180
	return 0;
3181
}
3182

3183
/* add playback controls from the parsed DAC table */
3184
static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3185
					       const struct auto_pin_cfg *cfg)
3186
{
3187
	struct sigmatel_spec *spec = codec->spec;
3188
	hda_nid_t nid;
3189
	int err;
3190
	int idx;
3191

3192
	err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3193
				    spec->multiout.dac_nids,
3194
				    cfg->line_out_type);
3195
	if (err < 0)
3196
		return err;
3197

3198
	if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3199
		err = stac92xx_add_control(spec,
3200
			STAC_CTL_WIDGET_HP_SWITCH,
3201
			"Headphone as Line Out Switch",
3202
			cfg->hp_pins[cfg->hp_outs - 1]);
3203
		if (err < 0)
3204
			return err;
3205
	}
3206

3207
	for (idx = 0; idx < cfg->num_inputs; idx++) {
3208
		if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3209
			break;
3210
		nid = cfg->inputs[idx].pin;
3211
		err = stac92xx_add_jack_mode_control(codec, nid, idx);
3212
		if (err < 0)
3213
			return err;
3214
	}
3215

3216
	return 0;
3217
}
3218

3219
/* add playback controls for Speaker and HP outputs */
3220
static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3221
					struct auto_pin_cfg *cfg)
3222
{
3223
	struct sigmatel_spec *spec = codec->spec;
3224
	int err;
3225

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

3231
	err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3232
				    spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3233
	if (err < 0)
3234
		return err;
3235

3236
	return 0;
3237
}
3238

3239
/* labels for mono mux outputs */
3240
static const char * const stac92xx_mono_labels[4] = {
3241
	"DAC0", "DAC1", "Mixer", "DAC2"
3242
};
3243

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

3252
	num_cons = snd_hda_get_connections(codec,
3253
				spec->mono_nid,
3254
				con_lst,
3255
				HDA_MAX_NUM_INPUTS);
3256
	if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3257
		return -EINVAL;
3258

3259
	for (i = 0; i < num_cons; i++)
3260
		snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i,
3261
				      NULL);
3262

3263
	return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3264
				"Mono Mux", spec->mono_nid);
3265
}
3266

3267
/* create PC beep volume controls */
3268
static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3269
						hda_nid_t nid)
3270
{
3271
	struct sigmatel_spec *spec = codec->spec;
3272
	u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3273
	int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3274

3275
	if (spec->anabeep_nid == nid)
3276
		type = STAC_CTL_WIDGET_MUTE;
3277

3278
	/* check for mute support for the the amp */
3279
	if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3280
		err = stac92xx_add_control(spec, type,
3281
			"Beep Playback Switch",
3282
			HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3283
			if (err < 0)
3284
				return err;
3285
	}
3286

3287
	/* check to see if there is volume support for the amp */
3288
	if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3289
		err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3290
			"Beep Playback Volume",
3291
			HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3292
			if (err < 0)
3293
				return err;
3294
	}
3295
	return 0;
3296
}
3297

3298
#ifdef CONFIG_SND_HDA_INPUT_BEEP
3299
#define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3300

3301
static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3302
					struct snd_ctl_elem_value *ucontrol)
3303
{
3304
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3305
	ucontrol->value.integer.value[0] = codec->beep->enabled;
3306
	return 0;
3307
}
3308

3309
static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3310
					struct snd_ctl_elem_value *ucontrol)
3311
{
3312
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3313
	return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3314
}
3315

3316
static const struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3317
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3318
	.info = stac92xx_dig_beep_switch_info,
3319
	.get = stac92xx_dig_beep_switch_get,
3320
	.put = stac92xx_dig_beep_switch_put,
3321
};
3322

3323
static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3324
{
3325
	return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3326
					 0, "Beep Playback Switch", 0);
3327
}
3328
#endif
3329

3330
static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3331
{
3332
	struct sigmatel_spec *spec = codec->spec;
3333
	int i, j, err = 0;
3334

3335
	for (i = 0; i < spec->num_muxes; i++) {
3336
		hda_nid_t nid;
3337
		unsigned int wcaps;
3338
		unsigned long val;
3339

3340
		nid = spec->mux_nids[i];
3341
		wcaps = get_wcaps(codec, nid);
3342
		if (!(wcaps & AC_WCAP_OUT_AMP))
3343
			continue;
3344

3345
		/* check whether already the same control was created as
3346
		 * normal Capture Volume.
3347
		 */
3348
		val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3349
		for (j = 0; j < spec->num_caps; j++) {
3350
			if (spec->capvols[j] == val)
3351
				break;
3352
		}
3353
		if (j < spec->num_caps)
3354
			continue;
3355

3356
		err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3357
					       "Mux Capture Volume", val);
3358
		if (err < 0)
3359
			return err;
3360
	}
3361
	return 0;
3362
};
3363

3364
static const char * const stac92xx_spdif_labels[3] = {
3365
	"Digital Playback", "Analog Mux 1", "Analog Mux 2",
3366
};
3367

3368
static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3369
{
3370
	struct sigmatel_spec *spec = codec->spec;
3371
	struct hda_input_mux *spdif_mux = &spec->private_smux;
3372
	const char * const *labels = spec->spdif_labels;
3373
	int i, num_cons;
3374
	hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3375

3376
	num_cons = snd_hda_get_connections(codec,
3377
				spec->smux_nids[0],
3378
				con_lst,
3379
				HDA_MAX_NUM_INPUTS);
3380
	if (num_cons <= 0)
3381
		return -EINVAL;
3382

3383
	if (!labels)
3384
		labels = stac92xx_spdif_labels;
3385

3386
	for (i = 0; i < num_cons; i++)
3387
		snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL);
3388

3389
	return 0;
3390
}
3391

3392
/* labels for dmic mux inputs */
3393
static const char * const stac92xx_dmic_labels[5] = {
3394
	"Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3395
	"Digital Mic 3", "Digital Mic 4"
3396
};
3397

3398
static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux,
3399
				    int idx)
3400
{
3401
	hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3402
	int nums;
3403
	nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3404
	if (idx >= 0 && idx < nums)
3405
		return conn[idx];
3406
	return 0;
3407
}
3408

3409
static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
3410
				hda_nid_t nid)
3411
{
3412
	hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3413
	int i, nums;
3414

3415
	if (!(get_wcaps(codec, mux) & AC_WCAP_CONN_LIST))
3416
		return -1;
3417

3418
	nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3419
	for (i = 0; i < nums; i++)
3420
		if (conn[i] == nid)
3421
			return i;
3422

3423
	for (i = 0; i < nums; i++) {
3424
		unsigned int wid_caps = get_wcaps(codec, conn[i]);
3425
		unsigned int wid_type = get_wcaps_type(wid_caps);
3426

3427
		if (wid_type != AC_WID_PIN && wid_type != AC_WID_AUD_MIX)
3428
			if (get_connection_index(codec, conn[i], nid) >= 0)
3429
				return i;
3430
	}
3431
	return -1;
3432
}
3433

3434
/* create a volume assigned to the given pin (only if supported) */
3435
/* return 1 if the volume control is created */
3436
static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3437
				   const char *label, int idx, int direction)
3438
{
3439
	unsigned int caps, nums;
3440
	char name[32];
3441
	int err;
3442

3443
	if (direction == HDA_OUTPUT)
3444
		caps = AC_WCAP_OUT_AMP;
3445
	else
3446
		caps = AC_WCAP_IN_AMP;
3447
	if (!(get_wcaps(codec, nid) & caps))
3448
		return 0;
3449
	caps = query_amp_caps(codec, nid, direction);
3450
	nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3451
	if (!nums)
3452
		return 0;
3453
	snprintf(name, sizeof(name), "%s Capture Volume", label);
3454
	err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
3455
				       HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3456
	if (err < 0)
3457
		return err;
3458
	return 1;
3459
}
3460

3461
/* create playback/capture controls for input pins on dmic capable codecs */
3462
static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3463
						const struct auto_pin_cfg *cfg)
3464
{
3465
	struct sigmatel_spec *spec = codec->spec;
3466
	struct hda_input_mux *imux = &spec->private_imux;
3467
	struct hda_input_mux *dimux = &spec->private_dimux;
3468
	int err, i;
3469
	unsigned int def_conf;
3470

3471
	snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL);
3472

3473
	for (i = 0; i < spec->num_dmics; i++) {
3474
		hda_nid_t nid;
3475
		int index, type_idx;
3476
		const char *label;
3477

3478
		nid = spec->dmic_nids[i];
3479
		if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3480
			continue;
3481
		def_conf = snd_hda_codec_get_pincfg(codec, nid);
3482
		if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3483
			continue;
3484

3485
		index = get_connection_index(codec, spec->dmux_nids[0], nid);
3486
		if (index < 0)
3487
			continue;
3488

3489
		label = hda_get_input_pin_label(codec, nid, 1);
3490
		snd_hda_add_imux_item(dimux, label, index, &type_idx);
3491
		if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1)
3492
			snd_hda_add_imux_item(imux, label, index, &type_idx);
3493

3494
		err = create_elem_capture_vol(codec, nid, label, type_idx,
3495
					      HDA_INPUT);
3496
		if (err < 0)
3497
			return err;
3498
		if (!err) {
3499
			err = create_elem_capture_vol(codec, nid, label,
3500
						      type_idx, HDA_OUTPUT);
3501
			if (err < 0)
3502
				return err;
3503
			if (!err) {
3504
				nid = get_connected_node(codec,
3505
						spec->dmux_nids[0], index);
3506
				if (nid)
3507
					err = create_elem_capture_vol(codec,
3508
							nid, label,
3509
							type_idx, HDA_INPUT);
3510
				if (err < 0)
3511
					return err;
3512
			}
3513
		}
3514
	}
3515

3516
	return 0;
3517
}
3518

3519
static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3520
			 hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock)
3521
{
3522
	unsigned int cfg;
3523
	unsigned int type;
3524

3525
	if (!nid)
3526
		return 0;
3527
	cfg = snd_hda_codec_get_pincfg(codec, nid);
3528
	type = get_defcfg_device(cfg);
3529
	switch (snd_hda_get_input_pin_attr(cfg)) {
3530
	case INPUT_PIN_ATTR_INT:
3531
		if (*fixed)
3532
			return 1; /* already occupied */
3533
		if (type != AC_JACK_MIC_IN)
3534
			return 1; /* invalid type */
3535
		*fixed = nid;
3536
		break;
3537
	case INPUT_PIN_ATTR_UNUSED:
3538
		break;
3539
	case INPUT_PIN_ATTR_DOCK:
3540
		if (*dock)
3541
			return 1; /* already occupied */
3542
		if (type != AC_JACK_MIC_IN && type != AC_JACK_LINE_IN)
3543
			return 1; /* invalid type */
3544
		*dock = nid;
3545
		break;
3546
	default:
3547
		if (*ext)
3548
			return 1; /* already occupied */
3549
		if (type != AC_JACK_MIC_IN)
3550
			return 1; /* invalid type */
3551
		*ext = nid;
3552
		break;
3553
	}
3554
	return 0;
3555
}
3556

3557
static int set_mic_route(struct hda_codec *codec,
3558
			 struct sigmatel_mic_route *mic,
3559
			 hda_nid_t pin)
3560
{
3561
	struct sigmatel_spec *spec = codec->spec;
3562
	struct auto_pin_cfg *cfg = &spec->autocfg;
3563
	int i;
3564

3565
	mic->pin = pin;
3566
	if (pin == 0)
3567
		return 0;
3568
	for (i = 0; i < cfg->num_inputs; i++) {
3569
		if (pin == cfg->inputs[i].pin)
3570
			break;
3571
	}
3572
	if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) {
3573
		/* analog pin */
3574
		i = get_connection_index(codec, spec->mux_nids[0], pin);
3575
		if (i < 0)
3576
			return -1;
3577
		mic->mux_idx = i;
3578
		mic->dmux_idx = -1;
3579
		if (spec->dmux_nids)
3580
			mic->dmux_idx = get_connection_index(codec,
3581
							     spec->dmux_nids[0],
3582
							     spec->mux_nids[0]);
3583
	}  else if (spec->dmux_nids) {
3584
		/* digital pin */
3585
		i = get_connection_index(codec, spec->dmux_nids[0], pin);
3586
		if (i < 0)
3587
			return -1;
3588
		mic->dmux_idx = i;
3589
		mic->mux_idx = -1;
3590
		if (spec->mux_nids)
3591
			mic->mux_idx = get_connection_index(codec,
3592
							    spec->mux_nids[0],
3593
							    spec->dmux_nids[0]);
3594
	}
3595
	return 0;
3596
}
3597

3598
/* return non-zero if the device is for automatic mic switch */
3599
static int stac_check_auto_mic(struct hda_codec *codec)
3600
{
3601
	struct sigmatel_spec *spec = codec->spec;
3602
	struct auto_pin_cfg *cfg = &spec->autocfg;
3603
	hda_nid_t fixed, ext, dock;
3604
	int i;
3605

3606
	fixed = ext = dock = 0;
3607
	for (i = 0; i < cfg->num_inputs; i++)
3608
		if (check_mic_pin(codec, cfg->inputs[i].pin,
3609
		    &fixed, &ext, &dock))
3610
			return 0;
3611
	for (i = 0; i < spec->num_dmics; i++)
3612
		if (check_mic_pin(codec, spec->dmic_nids[i],
3613
		    &fixed, &ext, &dock))
3614
			return 0;
3615
	if (!fixed || (!ext && !dock))
3616
		return 0; /* no input to switch */
3617
	if (!is_jack_detectable(codec, ext))
3618
		return 0; /* no unsol support */
3619
	if (set_mic_route(codec, &spec->ext_mic, ext) ||
3620
	    set_mic_route(codec, &spec->int_mic, fixed) ||
3621
	    set_mic_route(codec, &spec->dock_mic, dock))
3622
		return 0; /* something is wrong */
3623
	return 1;
3624
}
3625

3626
/* create playback/capture controls for input pins */
3627
static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3628
{
3629
	struct sigmatel_spec *spec = codec->spec;
3630
	struct hda_input_mux *imux = &spec->private_imux;
3631
	int i, j;
3632
	const char *label;
3633

3634
	for (i = 0; i < cfg->num_inputs; i++) {
3635
		hda_nid_t nid = cfg->inputs[i].pin;
3636
		int index, err, type_idx;
3637

3638
		index = -1;
3639
		for (j = 0; j < spec->num_muxes; j++) {
3640
			index = get_connection_index(codec, spec->mux_nids[j],
3641
						     nid);
3642
			if (index >= 0)
3643
				break;
3644
		}
3645
		if (index < 0)
3646
			continue;
3647

3648
		label = hda_get_autocfg_input_label(codec, cfg, i);
3649
		snd_hda_add_imux_item(imux, label, index, &type_idx);
3650

3651
		err = create_elem_capture_vol(codec, nid,
3652
					      label, type_idx,
3653
					      HDA_INPUT);
3654
		if (err < 0)
3655
			return err;
3656
	}
3657
	spec->num_analog_muxes = imux->num_items;
3658

3659
	if (imux->num_items) {
3660
		/*
3661
		 * Set the current input for the muxes.
3662
		 * The STAC9221 has two input muxes with identical source
3663
		 * NID lists.  Hopefully this won't get confused.
3664
		 */
3665
		for (i = 0; i < spec->num_muxes; i++) {
3666
			snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3667
						  AC_VERB_SET_CONNECT_SEL,
3668
						  imux->items[0].index);
3669
		}
3670
	}
3671

3672
	return 0;
3673
}
3674

3675
static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3676
{
3677
	struct sigmatel_spec *spec = codec->spec;
3678
	int i;
3679

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

3686
static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3687
{
3688
	struct sigmatel_spec *spec = codec->spec;
3689
	int i;
3690

3691
	for (i = 0; i < spec->autocfg.hp_outs; i++) {
3692
		hda_nid_t pin;
3693
		pin = spec->autocfg.hp_pins[i];
3694
		if (pin) /* connect to front */
3695
			stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3696
	}
3697
	for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3698
		hda_nid_t pin;
3699
		pin = spec->autocfg.speaker_pins[i];
3700
		if (pin) /* connect to front */
3701
			stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3702
	}
3703
}
3704

3705
static int is_dual_headphones(struct hda_codec *codec)
3706
{
3707
	struct sigmatel_spec *spec = codec->spec;
3708
	int i, valid_hps;
3709

3710
	if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3711
	    spec->autocfg.hp_outs <= 1)
3712
		return 0;
3713
	valid_hps = 0;
3714
	for (i = 0; i < spec->autocfg.hp_outs; i++) {
3715
		hda_nid_t nid = spec->autocfg.hp_pins[i];
3716
		unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3717
		if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3718
			continue;
3719
		valid_hps++;
3720
	}
3721
	return (valid_hps > 1);
3722
}
3723

3724

3725
static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3726
{
3727
	struct sigmatel_spec *spec = codec->spec;
3728
	int hp_swap = 0;
3729
	int i, err;
3730

3731
	if ((err = snd_hda_parse_pin_def_config(codec,
3732
						&spec->autocfg,
3733
						spec->dmic_nids)) < 0)
3734
		return err;
3735
	if (! spec->autocfg.line_outs)
3736
		return 0; /* can't find valid pin config */
3737

3738
	/* If we have no real line-out pin and multiple hp-outs, HPs should
3739
	 * be set up as multi-channel outputs.
3740
	 */
3741
	if (is_dual_headphones(codec)) {
3742
		/* Copy hp_outs to line_outs, backup line_outs in
3743
		 * speaker_outs so that the following routines can handle
3744
		 * HP pins as primary outputs.
3745
		 */
3746
		snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3747
		memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3748
		       sizeof(spec->autocfg.line_out_pins));
3749
		spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3750
		memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3751
		       sizeof(spec->autocfg.hp_pins));
3752
		spec->autocfg.line_outs = spec->autocfg.hp_outs;
3753
		spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3754
		spec->autocfg.hp_outs = 0;
3755
		hp_swap = 1;
3756
	}
3757
	if (spec->autocfg.mono_out_pin) {
3758
		int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3759
			(AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3760
		u32 caps = query_amp_caps(codec,
3761
				spec->autocfg.mono_out_pin, dir);
3762
		hda_nid_t conn_list[1];
3763

3764
		/* get the mixer node and then the mono mux if it exists */
3765
		if (snd_hda_get_connections(codec,
3766
				spec->autocfg.mono_out_pin, conn_list, 1) &&
3767
				snd_hda_get_connections(codec, conn_list[0],
3768
				conn_list, 1) > 0) {
3769

3770
				int wcaps = get_wcaps(codec, conn_list[0]);
3771
				int wid_type = get_wcaps_type(wcaps);
3772
				/* LR swap check, some stac925x have a mux that
3773
 				 * changes the DACs output path instead of the
3774
 				 * mono-mux path.
3775
 				 */
3776
				if (wid_type == AC_WID_AUD_SEL &&
3777
						!(wcaps & AC_WCAP_LR_SWAP))
3778
					spec->mono_nid = conn_list[0];
3779
		}
3780
		if (dir) {
3781
			hda_nid_t nid = spec->autocfg.mono_out_pin;
3782

3783
			/* most mono outs have a least a mute/unmute switch */
3784
			dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3785
			err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3786
				"Mono Playback Switch",
3787
				HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3788
			if (err < 0)
3789
				return err;
3790
			/* check for volume support for the amp */
3791
			if ((caps & AC_AMPCAP_NUM_STEPS)
3792
					>> AC_AMPCAP_NUM_STEPS_SHIFT) {
3793
				err = stac92xx_add_control(spec,
3794
					STAC_CTL_WIDGET_VOL,
3795
					"Mono Playback Volume",
3796
				HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3797
				if (err < 0)
3798
					return err;
3799
			}
3800
		}
3801

3802
		stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3803
					 AC_PINCTL_OUT_EN);
3804
	}
3805

3806
	if (!spec->multiout.num_dacs) {
3807
		err = stac92xx_auto_fill_dac_nids(codec);
3808
		if (err < 0)
3809
			return err;
3810
		err = stac92xx_auto_create_multi_out_ctls(codec,
3811
							  &spec->autocfg);
3812
		if (err < 0)
3813
			return err;
3814
	}
3815

3816
	/* setup analog beep controls */
3817
	if (spec->anabeep_nid > 0) {
3818
		err = stac92xx_auto_create_beep_ctls(codec,
3819
			spec->anabeep_nid);
3820
		if (err < 0)
3821
			return err;
3822
	}
3823

3824
	/* setup digital beep controls and input device */
3825
#ifdef CONFIG_SND_HDA_INPUT_BEEP
3826
	if (spec->digbeep_nid > 0) {
3827
		hda_nid_t nid = spec->digbeep_nid;
3828
		unsigned int caps;
3829

3830
		err = stac92xx_auto_create_beep_ctls(codec, nid);
3831
		if (err < 0)
3832
			return err;
3833
		err = snd_hda_attach_beep_device(codec, nid);
3834
		if (err < 0)
3835
			return err;
3836
		if (codec->beep) {
3837
			/* IDT/STAC codecs have linear beep tone parameter */
3838
			codec->beep->linear_tone = spec->linear_tone_beep;
3839
			/* if no beep switch is available, make its own one */
3840
			caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3841
			if (!(caps & AC_AMPCAP_MUTE)) {
3842
				err = stac92xx_beep_switch_ctl(codec);
3843
				if (err < 0)
3844
					return err;
3845
			}
3846
		}
3847
	}
3848
#endif
3849

3850
	err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3851
	if (err < 0)
3852
		return err;
3853

3854
	/* All output parsing done, now restore the swapped hp pins */
3855
	if (hp_swap) {
3856
		memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3857
		       sizeof(spec->autocfg.hp_pins));
3858
		spec->autocfg.hp_outs = spec->autocfg.line_outs;
3859
		spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3860
		spec->autocfg.line_outs = 0;
3861
	}
3862

3863
	if (stac_check_auto_mic(codec)) {
3864
		spec->auto_mic = 1;
3865
		/* only one capture for auto-mic */
3866
		spec->num_adcs = 1;
3867
		spec->num_caps = 1;
3868
		spec->num_muxes = 1;
3869
	}
3870

3871
	for (i = 0; i < spec->num_caps; i++) {
3872
		err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
3873
					       spec->capsws[i], i);
3874
		if (err < 0)
3875
			return err;
3876
	}
3877

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

3882
	if (spec->mono_nid > 0) {
3883
		err = stac92xx_auto_create_mono_output_ctls(codec);
3884
		if (err < 0)
3885
			return err;
3886
	}
3887
	if (spec->num_dmics > 0 && !spec->dinput_mux)
3888
		if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3889
						&spec->autocfg)) < 0)
3890
			return err;
3891
	if (spec->num_muxes > 0) {
3892
		err = stac92xx_auto_create_mux_input_ctls(codec);
3893
		if (err < 0)
3894
			return err;
3895
	}
3896
	if (spec->num_smuxes > 0) {
3897
		err = stac92xx_auto_create_spdif_mux_ctls(codec);
3898
		if (err < 0)
3899
			return err;
3900
	}
3901

3902
	err = stac92xx_add_input_source(spec);
3903
	if (err < 0)
3904
		return err;
3905

3906
	spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3907
	if (spec->multiout.max_channels > 2)
3908
		spec->surr_switch = 1;
3909

3910
	if (spec->autocfg.dig_outs)
3911
		spec->multiout.dig_out_nid = dig_out;
3912
	if (dig_in && spec->autocfg.dig_in_pin)
3913
		spec->dig_in_nid = dig_in;
3914

3915
	if (spec->kctls.list)
3916
		spec->mixers[spec->num_mixers++] = spec->kctls.list;
3917

3918
	spec->input_mux = &spec->private_imux;
3919
	if (!spec->dinput_mux)
3920
		spec->dinput_mux = &spec->private_dimux;
3921
	spec->sinput_mux = &spec->private_smux;
3922
	spec->mono_mux = &spec->private_mono_mux;
3923
	return 1;
3924
}
3925

3926
/* add playback controls for HP output */
3927
static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3928
					struct auto_pin_cfg *cfg)
3929
{
3930
	struct sigmatel_spec *spec = codec->spec;
3931
	hda_nid_t pin = cfg->hp_pins[0];
3932

3933
	if (! pin)
3934
		return 0;
3935

3936
	if (is_jack_detectable(codec, pin))
3937
		spec->hp_detect = 1;
3938

3939
	return 0;
3940
}
3941

3942
/* add playback controls for LFE output */
3943
static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3944
					struct auto_pin_cfg *cfg)
3945
{
3946
	struct sigmatel_spec *spec = codec->spec;
3947
	int err;
3948
	hda_nid_t lfe_pin = 0x0;
3949
	int i;
3950

3951
	/*
3952
	 * search speaker outs and line outs for a mono speaker pin
3953
	 * with an amp.  If one is found, add LFE controls
3954
	 * for it.
3955
	 */
3956
	for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3957
		hda_nid_t pin = spec->autocfg.speaker_pins[i];
3958
		unsigned int wcaps = get_wcaps(codec, pin);
3959
		wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3960
		if (wcaps == AC_WCAP_OUT_AMP)
3961
			/* found a mono speaker with an amp, must be lfe */
3962
			lfe_pin = pin;
3963
	}
3964

3965
	/* if speaker_outs is 0, then speakers may be in line_outs */
3966
	if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3967
		for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3968
			hda_nid_t pin = spec->autocfg.line_out_pins[i];
3969
			unsigned int defcfg;
3970
			defcfg = snd_hda_codec_get_pincfg(codec, pin);
3971
			if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3972
				unsigned int wcaps = get_wcaps(codec, pin);
3973
				wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3974
				if (wcaps == AC_WCAP_OUT_AMP)
3975
					/* found a mono speaker with an amp,
3976
					   must be lfe */
3977
					lfe_pin = pin;
3978
			}
3979
		}
3980
	}
3981

3982
	if (lfe_pin) {
3983
		err = create_controls(codec, "LFE", lfe_pin, 1);
3984
		if (err < 0)
3985
			return err;
3986
	}
3987

3988
	return 0;
3989
}
3990

3991
static int stac9200_parse_auto_config(struct hda_codec *codec)
3992
{
3993
	struct sigmatel_spec *spec = codec->spec;
3994
	int err;
3995

3996
	if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3997
		return err;
3998

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

4002
	if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
4003
		return err;
4004

4005
	if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
4006
		return err;
4007

4008
	if (spec->num_muxes > 0) {
4009
		err = stac92xx_auto_create_mux_input_ctls(codec);
4010
		if (err < 0)
4011
			return err;
4012
	}
4013

4014
	err = stac92xx_add_input_source(spec);
4015
	if (err < 0)
4016
		return err;
4017

4018
	if (spec->autocfg.dig_outs)
4019
		spec->multiout.dig_out_nid = 0x05;
4020
	if (spec->autocfg.dig_in_pin)
4021
		spec->dig_in_nid = 0x04;
4022

4023
	if (spec->kctls.list)
4024
		spec->mixers[spec->num_mixers++] = spec->kctls.list;
4025

4026
	spec->input_mux = &spec->private_imux;
4027
	spec->dinput_mux = &spec->private_dimux;
4028

4029
	return 1;
4030
}
4031

4032
/*
4033
 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
4034
 * funky external mute control using GPIO pins.
4035
 */
4036

4037
static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4038
			  unsigned int dir_mask, unsigned int data)
4039
{
4040
	unsigned int gpiostate, gpiomask, gpiodir;
4041

4042
	gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4043
				       AC_VERB_GET_GPIO_DATA, 0);
4044
	gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4045

4046
	gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4047
				      AC_VERB_GET_GPIO_MASK, 0);
4048
	gpiomask |= mask;
4049

4050
	gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4051
				     AC_VERB_GET_GPIO_DIRECTION, 0);
4052
	gpiodir |= dir_mask;
4053

4054
	/* Configure GPIOx as CMOS */
4055
	snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4056

4057
	snd_hda_codec_write(codec, codec->afg, 0,
4058
			    AC_VERB_SET_GPIO_MASK, gpiomask);
4059
	snd_hda_codec_read(codec, codec->afg, 0,
4060
			   AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
4061

4062
	msleep(1);
4063

4064
	snd_hda_codec_read(codec, codec->afg, 0,
4065
			   AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
4066
}
4067

4068
static int stac92xx_add_jack(struct hda_codec *codec,
4069
		hda_nid_t nid, int type)
4070
{
4071
#ifdef CONFIG_SND_HDA_INPUT_JACK
4072
	int def_conf = snd_hda_codec_get_pincfg(codec, nid);
4073
	int connectivity = get_defcfg_connect(def_conf);
4074
	char name[32];
4075
	int err;
4076

4077
	if (connectivity && connectivity != AC_JACK_PORT_FIXED)
4078
		return 0;
4079

4080
	snprintf(name, sizeof(name), "%s at %s %s Jack",
4081
		snd_hda_get_jack_type(def_conf),
4082
		snd_hda_get_jack_connectivity(def_conf),
4083
		snd_hda_get_jack_location(def_conf));
4084

4085
	err = snd_hda_input_jack_add(codec, nid, type, name);
4086
	if (err < 0)
4087
		return err;
4088
#endif /* CONFIG_SND_HDA_INPUT_JACK */
4089
	return 0;
4090
}
4091

4092
static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
4093
			  unsigned char type, int data)
4094
{
4095
	struct sigmatel_event *event;
4096

4097
	snd_array_init(&spec->events, sizeof(*event), 32);
4098
	event = snd_array_new(&spec->events);
4099
	if (!event)
4100
		return -ENOMEM;
4101
	event->nid = nid;
4102
	event->type = type;
4103
	event->tag = spec->events.used;
4104
	event->data = data;
4105

4106
	return event->tag;
4107
}
4108

4109
static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
4110
					     hda_nid_t nid)
4111
{
4112
	struct sigmatel_spec *spec = codec->spec;
4113
	struct sigmatel_event *event = spec->events.list;
4114
	int i;
4115

4116
	for (i = 0; i < spec->events.used; i++, event++) {
4117
		if (event->nid == nid)
4118
			return event;
4119
	}
4120
	return NULL;
4121
}
4122

4123
static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
4124
						      unsigned char tag)
4125
{
4126
	struct sigmatel_spec *spec = codec->spec;
4127
	struct sigmatel_event *event = spec->events.list;
4128
	int i;
4129

4130
	for (i = 0; i < spec->events.used; i++, event++) {
4131
		if (event->tag == tag)
4132
			return event;
4133
	}
4134
	return NULL;
4135
}
4136

4137
/* check if given nid is a valid pin and no other events are assigned
4138
 * to it.  If OK, assign the event, set the unsol flag, and returns 1.
4139
 * Otherwise, returns zero.
4140
 */
4141
static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4142
			     unsigned int type)
4143
{
4144
	struct sigmatel_event *event;
4145
	int tag;
4146

4147
	if (!is_jack_detectable(codec, nid))
4148
		return 0;
4149
	event = stac_get_event(codec, nid);
4150
	if (event) {
4151
		if (event->type != type)
4152
			return 0;
4153
		tag = event->tag;
4154
	} else {
4155
		tag = stac_add_event(codec->spec, nid, type, 0);
4156
		if (tag < 0)
4157
			return 0;
4158
	}
4159
	snd_hda_codec_write_cache(codec, nid, 0,
4160
				  AC_VERB_SET_UNSOLICITED_ENABLE,
4161
				  AC_USRSP_EN | tag);
4162
	return 1;
4163
}
4164

4165
static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4166
{
4167
	int i;
4168
	for (i = 0; i < cfg->hp_outs; i++)
4169
		if (cfg->hp_pins[i] == nid)
4170
			return 1; /* nid is a HP-Out */
4171

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

4175
static void stac92xx_power_down(struct hda_codec *codec)
4176
{
4177
	struct sigmatel_spec *spec = codec->spec;
4178

4179
	/* power down inactive DACs */
4180
	const hda_nid_t *dac;
4181
	for (dac = spec->dac_list; *dac; dac++)
4182
		if (!check_all_dac_nids(spec, *dac))
4183
			snd_hda_codec_write(codec, *dac, 0,
4184
					AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4185
}
4186

4187
static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4188
				  int enable);
4189

4190
static inline int get_int_hint(struct hda_codec *codec, const char *key,
4191
			       int *valp)
4192
{
4193
	const char *p;
4194
	p = snd_hda_get_hint(codec, key);
4195
	if (p) {
4196
		unsigned long val;
4197
		if (!strict_strtoul(p, 0, &val)) {
4198
			*valp = val;
4199
			return 1;
4200
		}
4201
	}
4202
	return 0;
4203
}
4204

4205
/* override some hints from the hwdep entry */
4206
static void stac_store_hints(struct hda_codec *codec)
4207
{
4208
	struct sigmatel_spec *spec = codec->spec;
4209
	int val;
4210

4211
	val = snd_hda_get_bool_hint(codec, "hp_detect");
4212
	if (val >= 0)
4213
		spec->hp_detect = val;
4214
	if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4215
		spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4216
			spec->gpio_mask;
4217
	}
4218
	if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
4219
		spec->gpio_mask &= spec->gpio_mask;
4220
	if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
4221
		spec->gpio_dir &= spec->gpio_mask;
4222
	if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
4223
		spec->eapd_mask &= spec->gpio_mask;
4224
	if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
4225
		spec->gpio_mute &= spec->gpio_mask;
4226
	val = snd_hda_get_bool_hint(codec, "eapd_switch");
4227
	if (val >= 0)
4228
		spec->eapd_switch = val;
4229
	get_int_hint(codec, "gpio_led_polarity", &spec->gpio_led_polarity);
4230
	if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
4231
		spec->gpio_mask |= spec->gpio_led;
4232
		spec->gpio_dir |= spec->gpio_led;
4233
		if (spec->gpio_led_polarity)
4234
			spec->gpio_data |= spec->gpio_led;
4235
	}
4236
}
4237

4238
static int stac92xx_init(struct hda_codec *codec)
4239
{
4240
	struct sigmatel_spec *spec = codec->spec;
4241
	struct auto_pin_cfg *cfg = &spec->autocfg;
4242
	unsigned int gpio;
4243
	int i;
4244

4245
	snd_hda_sequence_write(codec, spec->init);
4246

4247
	/* power down adcs initially */
4248
	if (spec->powerdown_adcs)
4249
		for (i = 0; i < spec->num_adcs; i++)
4250
			snd_hda_codec_write(codec,
4251
				spec->adc_nids[i], 0,
4252
				AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4253

4254
	/* override some hints */
4255
	stac_store_hints(codec);
4256

4257
	/* set up GPIO */
4258
	gpio = spec->gpio_data;
4259
	/* turn on EAPD statically when spec->eapd_switch isn't set.
4260
	 * otherwise, unsol event will turn it on/off dynamically
4261
	 */
4262
	if (!spec->eapd_switch)
4263
		gpio |= spec->eapd_mask;
4264
	stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4265

4266
	/* set up pins */
4267
	if (spec->hp_detect) {
4268
		/* Enable unsolicited responses on the HP widget */
4269
		for (i = 0; i < cfg->hp_outs; i++) {
4270
			hda_nid_t nid = cfg->hp_pins[i];
4271
			enable_pin_detect(codec, nid, STAC_HP_EVENT);
4272
		}
4273
		if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4274
		    cfg->speaker_outs > 0) {
4275
			/* enable pin-detect for line-outs as well */
4276
			for (i = 0; i < cfg->line_outs; i++) {
4277
				hda_nid_t nid = cfg->line_out_pins[i];
4278
				enable_pin_detect(codec, nid, STAC_LO_EVENT);
4279
			}
4280
		}
4281

4282
		/* force to enable the first line-out; the others are set up
4283
		 * in unsol_event
4284
		 */
4285
		stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4286
				AC_PINCTL_OUT_EN);
4287
		/* fake event to set up pins */
4288
		if (cfg->hp_pins[0])
4289
			stac_issue_unsol_event(codec, cfg->hp_pins[0]);
4290
		else if (cfg->line_out_pins[0])
4291
			stac_issue_unsol_event(codec, cfg->line_out_pins[0]);
4292
	} else {
4293
		stac92xx_auto_init_multi_out(codec);
4294
		stac92xx_auto_init_hp_out(codec);
4295
		for (i = 0; i < cfg->hp_outs; i++)
4296
			stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4297
	}
4298
	if (spec->auto_mic) {
4299
		/* initialize connection to analog input */
4300
		if (spec->dmux_nids)
4301
			snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4302
					  AC_VERB_SET_CONNECT_SEL, 0);
4303
		if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4304
			stac_issue_unsol_event(codec, spec->ext_mic.pin);
4305
		if (enable_pin_detect(codec, spec->dock_mic.pin,
4306
		    STAC_MIC_EVENT))
4307
			stac_issue_unsol_event(codec, spec->dock_mic.pin);
4308
	}
4309
	for (i = 0; i < cfg->num_inputs; i++) {
4310
		hda_nid_t nid = cfg->inputs[i].pin;
4311
		int type = cfg->inputs[i].type;
4312
		unsigned int pinctl, conf;
4313
		if (type == AUTO_PIN_MIC) {
4314
			/* for mic pins, force to initialize */
4315
			pinctl = stac92xx_get_default_vref(codec, nid);
4316
			pinctl |= AC_PINCTL_IN_EN;
4317
			stac92xx_auto_set_pinctl(codec, nid, pinctl);
4318
		} else {
4319
			pinctl = snd_hda_codec_read(codec, nid, 0,
4320
					AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4321
			/* if PINCTL already set then skip */
4322
			/* Also, if both INPUT and OUTPUT are set,
4323
			 * it must be a BIOS bug; need to override, too
4324
			 */
4325
			if (!(pinctl & AC_PINCTL_IN_EN) ||
4326
			    (pinctl & AC_PINCTL_OUT_EN)) {
4327
				pinctl &= ~AC_PINCTL_OUT_EN;
4328
				pinctl |= AC_PINCTL_IN_EN;
4329
				stac92xx_auto_set_pinctl(codec, nid, pinctl);
4330
			}
4331
		}
4332
		conf = snd_hda_codec_get_pincfg(codec, nid);
4333
		if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) {
4334
			if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT))
4335
				stac_issue_unsol_event(codec, nid);
4336
		}
4337
	}
4338
	for (i = 0; i < spec->num_dmics; i++)
4339
		stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i],
4340
					AC_PINCTL_IN_EN);
4341
	if (cfg->dig_out_pins[0])
4342
		stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0],
4343
					 AC_PINCTL_OUT_EN);
4344
	if (cfg->dig_in_pin)
4345
		stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin,
4346
					 AC_PINCTL_IN_EN);
4347
	for (i = 0; i < spec->num_pwrs; i++)  {
4348
		hda_nid_t nid = spec->pwr_nids[i];
4349
		int pinctl, def_conf;
4350

4351
		/* power on when no jack detection is available */
4352
		if (!spec->hp_detect) {
4353
			stac_toggle_power_map(codec, nid, 1);
4354
			continue;
4355
		}
4356

4357
		if (is_nid_hp_pin(cfg, nid))
4358
			continue; /* already has an unsol event */
4359

4360
		pinctl = snd_hda_codec_read(codec, nid, 0,
4361
					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4362
		/* outputs are only ports capable of power management
4363
		 * any attempts on powering down a input port cause the
4364
		 * referenced VREF to act quirky.
4365
		 */
4366
		if (pinctl & AC_PINCTL_IN_EN) {
4367
			stac_toggle_power_map(codec, nid, 1);
4368
			continue;
4369
		}
4370
		def_conf = snd_hda_codec_get_pincfg(codec, nid);
4371
		def_conf = get_defcfg_connect(def_conf);
4372
		/* skip any ports that don't have jacks since presence
4373
 		 * detection is useless */
4374
		if (def_conf != AC_JACK_PORT_COMPLEX) {
4375
			if (def_conf != AC_JACK_PORT_NONE)
4376
				stac_toggle_power_map(codec, nid, 1);
4377
			continue;
4378
		}
4379
		if (enable_pin_detect(codec, nid, STAC_PWR_EVENT))
4380
			stac_issue_unsol_event(codec, nid);
4381
	}
4382

4383
	/* sync mute LED */
4384
	if (spec->gpio_led)
4385
		hda_call_check_power_status(codec, 0x01);
4386
	if (spec->dac_list)
4387
		stac92xx_power_down(codec);
4388
	return 0;
4389
}
4390

4391
static void stac92xx_free_kctls(struct hda_codec *codec)
4392
{
4393
	struct sigmatel_spec *spec = codec->spec;
4394

4395
	if (spec->kctls.list) {
4396
		struct snd_kcontrol_new *kctl = spec->kctls.list;
4397
		int i;
4398
		for (i = 0; i < spec->kctls.used; i++)
4399
			kfree(kctl[i].name);
4400
	}
4401
	snd_array_free(&spec->kctls);
4402
}
4403

4404
static void stac92xx_shutup(struct hda_codec *codec)
4405
{
4406
	struct sigmatel_spec *spec = codec->spec;
4407

4408
	snd_hda_shutup_pins(codec);
4409

4410
	if (spec->eapd_mask)
4411
		stac_gpio_set(codec, spec->gpio_mask,
4412
				spec->gpio_dir, spec->gpio_data &
4413
				~spec->eapd_mask);
4414
}
4415

4416
static void stac92xx_free(struct hda_codec *codec)
4417
{
4418
	struct sigmatel_spec *spec = codec->spec;
4419

4420
	if (! spec)
4421
		return;
4422

4423
	stac92xx_shutup(codec);
4424
	snd_hda_input_jack_free(codec);
4425
	snd_array_free(&spec->events);
4426

4427
	kfree(spec);
4428
	snd_hda_detach_beep_device(codec);
4429
}
4430

4431
static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid,
4432
				unsigned int flag)
4433
{
4434
	unsigned int old_ctl, pin_ctl;
4435

4436
	pin_ctl = snd_hda_codec_read(codec, nid,
4437
			0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4438

4439
	if (pin_ctl & AC_PINCTL_IN_EN) {
4440
		/*
4441
		 * we need to check the current set-up direction of
4442
		 * shared input pins since they can be switched via
4443
		 * "xxx as Output" mixer switch
4444
		 */
4445
		struct sigmatel_spec *spec = codec->spec;
4446
		if (nid == spec->line_switch || nid == spec->mic_switch)
4447
			return;
4448
	}
4449

4450
	old_ctl = pin_ctl;
4451
	/* if setting pin direction bits, clear the current
4452
	   direction bits first */
4453
	if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN))
4454
		pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
4455
	
4456
	pin_ctl |= flag;
4457
	if (old_ctl != pin_ctl)
4458
		snd_hda_codec_write_cache(codec, nid, 0,
4459
					  AC_VERB_SET_PIN_WIDGET_CONTROL,
4460
					  pin_ctl);
4461
}
4462

4463
static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid,
4464
				  unsigned int flag)
4465
{
4466
	unsigned int pin_ctl = snd_hda_codec_read(codec, nid,
4467
			0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00);
4468
	if (pin_ctl & flag)
4469
		snd_hda_codec_write_cache(codec, nid, 0,
4470
					  AC_VERB_SET_PIN_WIDGET_CONTROL,
4471
					  pin_ctl & ~flag);
4472
}
4473

4474
static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid)
4475
{
4476
	if (!nid)
4477
		return 0;
4478
	return snd_hda_jack_detect(codec, nid);
4479
}
4480

4481
static void stac92xx_line_out_detect(struct hda_codec *codec,
4482
				     int presence)
4483
{
4484
	struct sigmatel_spec *spec = codec->spec;
4485
	struct auto_pin_cfg *cfg = &spec->autocfg;
4486
	int i;
4487

4488
	for (i = 0; i < cfg->line_outs; i++) {
4489
		if (presence)
4490
			break;
4491
		presence = get_pin_presence(codec, cfg->line_out_pins[i]);
4492
		if (presence) {
4493
			unsigned int pinctl;
4494
			pinctl = snd_hda_codec_read(codec,
4495
						    cfg->line_out_pins[i], 0,
4496
					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4497
			if (pinctl & AC_PINCTL_IN_EN)
4498
				presence = 0; /* mic- or line-input */
4499
		}
4500
	}
4501

4502
	if (presence) {
4503
		/* disable speakers */
4504
		for (i = 0; i < cfg->speaker_outs; i++)
4505
			stac92xx_reset_pinctl(codec, cfg->speaker_pins[i],
4506
						AC_PINCTL_OUT_EN);
4507
		if (spec->eapd_mask && spec->eapd_switch)
4508
			stac_gpio_set(codec, spec->gpio_mask,
4509
				spec->gpio_dir, spec->gpio_data &
4510
				~spec->eapd_mask);
4511
	} else {
4512
		/* enable speakers */
4513
		for (i = 0; i < cfg->speaker_outs; i++)
4514
			stac92xx_set_pinctl(codec, cfg->speaker_pins[i],
4515
						AC_PINCTL_OUT_EN);
4516
		if (spec->eapd_mask && spec->eapd_switch)
4517
			stac_gpio_set(codec, spec->gpio_mask,
4518
				spec->gpio_dir, spec->gpio_data |
4519
				spec->eapd_mask);
4520
	}
4521
} 
4522

4523
/* return non-zero if the hp-pin of the given array index isn't
4524
 * a jack-detection target
4525
 */
4526
static int no_hp_sensing(struct sigmatel_spec *spec, int i)
4527
{
4528
	struct auto_pin_cfg *cfg = &spec->autocfg;
4529

4530
	/* ignore sensing of shared line and mic jacks */
4531
	if (cfg->hp_pins[i] == spec->line_switch)
4532
		return 1;
4533
	if (cfg->hp_pins[i] == spec->mic_switch)
4534
		return 1;
4535
	/* ignore if the pin is set as line-out */
4536
	if (cfg->hp_pins[i] == spec->hp_switch)
4537
		return 1;
4538
	return 0;
4539
}
4540

4541
static void stac92xx_hp_detect(struct hda_codec *codec)
4542
{
4543
	struct sigmatel_spec *spec = codec->spec;
4544
	struct auto_pin_cfg *cfg = &spec->autocfg;
4545
	int i, presence;
4546

4547
	presence = 0;
4548
	if (spec->gpio_mute)
4549
		presence = !(snd_hda_codec_read(codec, codec->afg, 0,
4550
			AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute);
4551

4552
	for (i = 0; i < cfg->hp_outs; i++) {
4553
		if (presence)
4554
			break;
4555
		if (no_hp_sensing(spec, i))
4556
			continue;
4557
		presence = get_pin_presence(codec, cfg->hp_pins[i]);
4558
		if (presence) {
4559
			unsigned int pinctl;
4560
			pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0,
4561
					    AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4562
			if (pinctl & AC_PINCTL_IN_EN)
4563
				presence = 0; /* mic- or line-input */
4564
		}
4565
	}
4566

4567
	if (presence) {
4568
		/* disable lineouts */
4569
		if (spec->hp_switch)
4570
			stac92xx_reset_pinctl(codec, spec->hp_switch,
4571
					      AC_PINCTL_OUT_EN);
4572
		for (i = 0; i < cfg->line_outs; i++)
4573
			stac92xx_reset_pinctl(codec, cfg->line_out_pins[i],
4574
						AC_PINCTL_OUT_EN);
4575
	} else {
4576
		/* enable lineouts */
4577
		if (spec->hp_switch)
4578
			stac92xx_set_pinctl(codec, spec->hp_switch,
4579
					    AC_PINCTL_OUT_EN);
4580
		for (i = 0; i < cfg->line_outs; i++)
4581
			stac92xx_set_pinctl(codec, cfg->line_out_pins[i],
4582
						AC_PINCTL_OUT_EN);
4583
	}
4584
	stac92xx_line_out_detect(codec, presence);
4585
	/* toggle hp outs */
4586
	for (i = 0; i < cfg->hp_outs; i++) {
4587
		unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN;
4588
		if (no_hp_sensing(spec, i))
4589
			continue;
4590
		if (presence)
4591
			stac92xx_set_pinctl(codec, cfg->hp_pins[i], val);
4592
#if 0 /* FIXME */
4593
/* Resetting the pinctl like below may lead to (a sort of) regressions
4594
 * on some devices since they use the HP pin actually for line/speaker
4595
 * outs although the default pin config shows a different pin (that is
4596
 * wrong and useless).
4597
 *
4598
 * So, it's basically a problem of default pin configs, likely a BIOS issue.
4599
 * But, disabling the code below just works around it, and I'm too tired of
4600
 * bug reports with such devices... 
4601
 */
4602
		else
4603
			stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val);
4604
#endif /* FIXME */
4605
	}
4606
} 
4607

4608
static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4609
				  int enable)
4610
{
4611
	struct sigmatel_spec *spec = codec->spec;
4612
	unsigned int idx, val;
4613

4614
	for (idx = 0; idx < spec->num_pwrs; idx++) {
4615
		if (spec->pwr_nids[idx] == nid)
4616
			break;
4617
	}
4618
	if (idx >= spec->num_pwrs)
4619
		return;
4620

4621
	/* several codecs have two power down bits */
4622
	if (spec->pwr_mapping)
4623
		idx = spec->pwr_mapping[idx];
4624
	else
4625
		idx = 1 << idx;
4626

4627
	val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) & 0xff;
4628
	if (enable)
4629
		val &= ~idx;
4630
	else
4631
		val |= idx;
4632

4633
	/* power down unused output ports */
4634
	snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val);
4635
}
4636

4637
static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid)
4638
{
4639
	stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid));
4640
}
4641

4642
/* get the pin connection (fixed, none, etc) */
4643
static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx)
4644
{
4645
	struct sigmatel_spec *spec = codec->spec;
4646
	unsigned int cfg;
4647

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

4652
static int stac92xx_connected_ports(struct hda_codec *codec,
4653
				    const hda_nid_t *nids, int num_nids)
4654
{
4655
	struct sigmatel_spec *spec = codec->spec;
4656
	int idx, num;
4657
	unsigned int def_conf;
4658

4659
	for (num = 0; num < num_nids; num++) {
4660
		for (idx = 0; idx < spec->num_pins; idx++)
4661
			if (spec->pin_nids[idx] == nids[num])
4662
				break;
4663
		if (idx >= spec->num_pins)
4664
			break;
4665
		def_conf = stac_get_defcfg_connect(codec, idx);
4666
		if (def_conf == AC_JACK_PORT_NONE)
4667
			break;
4668
	}
4669
	return num;
4670
}
4671

4672
static void stac92xx_mic_detect(struct hda_codec *codec)
4673
{
4674
	struct sigmatel_spec *spec = codec->spec;
4675
	struct sigmatel_mic_route *mic;
4676

4677
	if (get_pin_presence(codec, spec->ext_mic.pin))
4678
		mic = &spec->ext_mic;
4679
	else if (get_pin_presence(codec, spec->dock_mic.pin))
4680
		mic = &spec->dock_mic;
4681
	else
4682
		mic = &spec->int_mic;
4683
	if (mic->dmux_idx >= 0)
4684
		snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4685
					  AC_VERB_SET_CONNECT_SEL,
4686
					  mic->dmux_idx);
4687
	if (mic->mux_idx >= 0)
4688
		snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0,
4689
					  AC_VERB_SET_CONNECT_SEL,
4690
					  mic->mux_idx);
4691
}
4692

4693
static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid)
4694
{
4695
	struct sigmatel_event *event = stac_get_event(codec, nid);
4696
	if (!event)
4697
		return;
4698
	codec->patch_ops.unsol_event(codec, (unsigned)event->tag << 26);
4699
}
4700

4701
static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res)
4702
{
4703
	struct sigmatel_spec *spec = codec->spec;
4704
	struct sigmatel_event *event;
4705
	int tag, data;
4706

4707
	tag = (res >> 26) & 0x7f;
4708
	event = stac_get_event_from_tag(codec, tag);
4709
	if (!event)
4710
		return;
4711

4712
	switch (event->type) {
4713
	case STAC_HP_EVENT:
4714
	case STAC_LO_EVENT:
4715
		stac92xx_hp_detect(codec);
4716
		break;
4717
	case STAC_MIC_EVENT:
4718
		stac92xx_mic_detect(codec);
4719
		break;
4720
	}
4721

4722
	switch (event->type) {
4723
	case STAC_HP_EVENT:
4724
	case STAC_LO_EVENT:
4725
	case STAC_MIC_EVENT:
4726
	case STAC_INSERT_EVENT:
4727
	case STAC_PWR_EVENT:
4728
		if (spec->num_pwrs > 0)
4729
			stac92xx_pin_sense(codec, event->nid);
4730
		snd_hda_input_jack_report(codec, event->nid);
4731

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

4737
				if (get_pin_presence(codec, 0xa)
4738
						&& get_pin_presence(codec, 0xb))
4739
					pin |= AC_PINCTL_VREF_80;
4740
				if (!get_pin_presence(codec, 0xb))
4741
					pin |= AC_PINCTL_VREF_80;
4742

4743
				/* toggle VREF state based on mic + hp pin
4744
				 * status
4745
				 */
4746
				stac92xx_auto_set_pinctl(codec, 0x0a, pin);
4747
			}
4748
		}
4749
		break;
4750
	case STAC_VREF_EVENT:
4751
		data = snd_hda_codec_read(codec, codec->afg, 0,
4752
					  AC_VERB_GET_GPIO_DATA, 0);
4753
		/* toggle VREF state based on GPIOx status */
4754
		snd_hda_codec_write(codec, codec->afg, 0, 0x7e0,
4755
				    !!(data & (1 << event->data)));
4756
		break;
4757
	}
4758
}
4759

4760
static int hp_blike_system(u32 subsystem_id);
4761

4762
static void set_hp_led_gpio(struct hda_codec *codec)
4763
{
4764
	struct sigmatel_spec *spec = codec->spec;
4765
	unsigned int gpio;
4766

4767
	if (spec->gpio_led)
4768
		return;
4769

4770
	gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP);
4771
	gpio &= AC_GPIO_IO_COUNT;
4772
	if (gpio > 3)
4773
		spec->gpio_led = 0x08; /* GPIO 3 */
4774
	else
4775
		spec->gpio_led = 0x01; /* GPIO 0 */
4776
}
4777

4778
/*
4779
 * This method searches for the mute LED GPIO configuration
4780
 * provided as OEM string in SMBIOS. The format of that string
4781
 * is HP_Mute_LED_P_G or HP_Mute_LED_P
4782
 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high)
4783
 * that corresponds to the NOT muted state of the master volume
4784
 * and G is the index of the GPIO to use as the mute LED control (0..9)
4785
 * If _G portion is missing it is assigned based on the codec ID
4786
 *
4787
 * So, HP B-series like systems may have HP_Mute_LED_0 (current models)
4788
 * or  HP_Mute_LED_0_3 (future models) OEM SMBIOS strings
4789
 *
4790
 *
4791
 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in
4792
 * SMBIOS - at least the ones I have seen do not have them - which include
4793
 * my own system (HP Pavilion dv6-1110ax) and my cousin's
4794
 * HP Pavilion dv9500t CTO.
4795
 * Need more information on whether it is true across the entire series.
4796
 * -- kunal
4797
 */
4798
static int find_mute_led_gpio(struct hda_codec *codec, int default_polarity)
4799
{
4800
	struct sigmatel_spec *spec = codec->spec;
4801
	const struct dmi_device *dev = NULL;
4802

4803
	if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) {
4804
		while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING,
4805
								NULL, dev))) {
4806
			if (sscanf(dev->name, "HP_Mute_LED_%d_%d",
4807
				  &spec->gpio_led_polarity,
4808
				  &spec->gpio_led) == 2) {
4809
				spec->gpio_led = 1 << spec->gpio_led;
4810
				return 1;
4811
			}
4812
			if (sscanf(dev->name, "HP_Mute_LED_%d",
4813
				  &spec->gpio_led_polarity) == 1) {
4814
				set_hp_led_gpio(codec);
4815
				return 1;
4816
			}
4817
		}
4818

4819
		/*
4820
		 * Fallback case - if we don't find the DMI strings,
4821
		 * we statically set the GPIO - if not a B-series system.
4822
		 */
4823
		if (!hp_blike_system(codec->subsystem_id)) {
4824
			set_hp_led_gpio(codec);
4825
			spec->gpio_led_polarity = default_polarity;
4826
			return 1;
4827
		}
4828
	}
4829
	return 0;
4830
}
4831

4832
static int hp_blike_system(u32 subsystem_id)
4833
{
4834
	switch (subsystem_id) {
4835
	case 0x103c1520:
4836
	case 0x103c1521:
4837
	case 0x103c1523:
4838
	case 0x103c1524:
4839
	case 0x103c1525:
4840
	case 0x103c1722:
4841
	case 0x103c1723:
4842
	case 0x103c1724:
4843
	case 0x103c1725:
4844
	case 0x103c1726:
4845
	case 0x103c1727:
4846
	case 0x103c1728:
4847
	case 0x103c1729:
4848
	case 0x103c172a:
4849
	case 0x103c172b:
4850
	case 0x103c307e:
4851
	case 0x103c307f:
4852
	case 0x103c3080:
4853
	case 0x103c3081:
4854
	case 0x103c7007:
4855
	case 0x103c7008:
4856
		return 1;
4857
	}
4858
	return 0;
4859
}
4860

4861
#ifdef CONFIG_PROC_FS
4862
static void stac92hd_proc_hook(struct snd_info_buffer *buffer,
4863
			       struct hda_codec *codec, hda_nid_t nid)
4864
{
4865
	if (nid == codec->afg)
4866
		snd_iprintf(buffer, "Power-Map: 0x%02x\n", 
4867
			    snd_hda_codec_read(codec, nid, 0, 0x0fec, 0x0));
4868
}
4869

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

4878
/* stac92hd71bxx, stac92hd73xx */
4879
static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer,
4880
				 struct hda_codec *codec, hda_nid_t nid)
4881
{
4882
	stac92hd_proc_hook(buffer, codec, nid);
4883
	if (nid == codec->afg)
4884
		analog_loop_proc_hook(buffer, codec, 0xfa0);
4885
}
4886

4887
static void stac9205_proc_hook(struct snd_info_buffer *buffer,
4888
			       struct hda_codec *codec, hda_nid_t nid)
4889
{
4890
	if (nid == codec->afg)
4891
		analog_loop_proc_hook(buffer, codec, 0xfe0);
4892
}
4893

4894
static void stac927x_proc_hook(struct snd_info_buffer *buffer,
4895
			       struct hda_codec *codec, hda_nid_t nid)
4896
{
4897
	if (nid == codec->afg)
4898
		analog_loop_proc_hook(buffer, codec, 0xfeb);
4899
}
4900
#else
4901
#define stac92hd_proc_hook	NULL
4902
#define stac92hd7x_proc_hook	NULL
4903
#define stac9205_proc_hook	NULL
4904
#define stac927x_proc_hook	NULL
4905
#endif
4906

4907
#ifdef SND_HDA_NEEDS_RESUME
4908
static int stac92xx_resume(struct hda_codec *codec)
4909
{
4910
	struct sigmatel_spec *spec = codec->spec;
4911

4912
	stac92xx_init(codec);
4913
	snd_hda_codec_resume_amp(codec);
4914
	snd_hda_codec_resume_cache(codec);
4915
	/* fake event to set up pins again to override cached values */
4916
	if (spec->hp_detect) {
4917
		if (spec->autocfg.hp_pins[0])
4918
			stac_issue_unsol_event(codec, spec->autocfg.hp_pins[0]);
4919
		else if (spec->autocfg.line_out_pins[0])
4920
			stac_issue_unsol_event(codec,
4921
					       spec->autocfg.line_out_pins[0]);
4922
	}
4923
	/* sync mute LED */
4924
	if (spec->gpio_led)
4925
		hda_call_check_power_status(codec, 0x01);
4926
	return 0;
4927
}
4928

4929
/*
4930
 * using power check for controlling mute led of HP notebooks
4931
 * check for mute state only on Speakers (nid = 0x10)
4932
 *
4933
 * For this feature CONFIG_SND_HDA_POWER_SAVE is needed, otherwise
4934
 * the LED is NOT working properly !
4935
 *
4936
 * Changed name to reflect that it now works for any designated
4937
 * model, not just HP HDX.
4938
 */
4939

4940
#ifdef CONFIG_SND_HDA_POWER_SAVE
4941
static int stac92xx_hp_check_power_status(struct hda_codec *codec,
4942
					      hda_nid_t nid)
4943
{
4944
	struct sigmatel_spec *spec = codec->spec;
4945
	int i, muted = 1;
4946

4947
	for (i = 0; i < spec->multiout.num_dacs; i++) {
4948
		nid = spec->multiout.dac_nids[i];
4949
		if (!(snd_hda_codec_amp_read(codec, nid, 0, HDA_OUTPUT, 0) &
4950
		      HDA_AMP_MUTE)) {
4951
			muted = 0; /* something heard */
4952
			break;
4953
		}
4954
	}
4955
	if (muted)
4956
		spec->gpio_data &= ~spec->gpio_led; /* orange */
4957
	else
4958
		spec->gpio_data |= spec->gpio_led; /* white */
4959

4960
	if (!spec->gpio_led_polarity) {
4961
		/* LED state is inverted on these systems */
4962
		spec->gpio_data ^= spec->gpio_led;
4963
	}
4964

4965
	stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
4966
	return 0;
4967
}
4968
#endif
4969

4970
static int stac92xx_suspend(struct hda_codec *codec, pm_message_t state)
4971
{
4972
	stac92xx_shutup(codec);
4973
	return 0;
4974
}
4975
#endif
4976

4977
static const struct hda_codec_ops stac92xx_patch_ops = {
4978
	.build_controls = stac92xx_build_controls,
4979
	.build_pcms = stac92xx_build_pcms,
4980
	.init = stac92xx_init,
4981
	.free = stac92xx_free,
4982
	.unsol_event = stac92xx_unsol_event,
4983
#ifdef SND_HDA_NEEDS_RESUME
4984
	.suspend = stac92xx_suspend,
4985
	.resume = stac92xx_resume,
4986
#endif
4987
	.reboot_notify = stac92xx_shutup,
4988
};
4989

4990
static int patch_stac9200(struct hda_codec *codec)
4991
{
4992
	struct sigmatel_spec *spec;
4993
	int err;
4994

4995
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
4996
	if (spec == NULL)
4997
		return -ENOMEM;
4998

4999
	codec->no_trigger_sense = 1;
5000
	codec->spec = spec;
5001
	spec->linear_tone_beep = 1;
5002
	spec->num_pins = ARRAY_SIZE(stac9200_pin_nids);
5003
	spec->pin_nids = stac9200_pin_nids;
5004
	spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS,
5005
							stac9200_models,
5006
							stac9200_cfg_tbl);
5007
	if (spec->board_config < 0)
5008
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5009
			    codec->chip_name);
5010
	else
5011
		stac92xx_set_config_regs(codec,
5012
					 stac9200_brd_tbl[spec->board_config]);
5013

5014
	spec->multiout.max_channels = 2;
5015
	spec->multiout.num_dacs = 1;
5016
	spec->multiout.dac_nids = stac9200_dac_nids;
5017
	spec->adc_nids = stac9200_adc_nids;
5018
	spec->mux_nids = stac9200_mux_nids;
5019
	spec->num_muxes = 1;
5020
	spec->num_dmics = 0;
5021
	spec->num_adcs = 1;
5022
	spec->num_pwrs = 0;
5023

5024
	if (spec->board_config == STAC_9200_M4 ||
5025
	    spec->board_config == STAC_9200_M4_2 ||
5026
	    spec->board_config == STAC_9200_OQO)
5027
		spec->init = stac9200_eapd_init;
5028
	else
5029
		spec->init = stac9200_core_init;
5030
	spec->mixer = stac9200_mixer;
5031

5032
	if (spec->board_config == STAC_9200_PANASONIC) {
5033
		spec->gpio_mask = spec->gpio_dir = 0x09;
5034
		spec->gpio_data = 0x00;
5035
	}
5036

5037
	err = stac9200_parse_auto_config(codec);
5038
	if (err < 0) {
5039
		stac92xx_free(codec);
5040
		return err;
5041
	}
5042

5043
	/* CF-74 has no headphone detection, and the driver should *NOT*
5044
	 * do detection and HP/speaker toggle because the hardware does it.
5045
	 */
5046
	if (spec->board_config == STAC_9200_PANASONIC)
5047
		spec->hp_detect = 0;
5048

5049
	codec->patch_ops = stac92xx_patch_ops;
5050

5051
	return 0;
5052
}
5053

5054
static int patch_stac925x(struct hda_codec *codec)
5055
{
5056
	struct sigmatel_spec *spec;
5057
	int err;
5058

5059
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5060
	if (spec == NULL)
5061
		return -ENOMEM;
5062

5063
	codec->no_trigger_sense = 1;
5064
	codec->spec = spec;
5065
	spec->linear_tone_beep = 1;
5066
	spec->num_pins = ARRAY_SIZE(stac925x_pin_nids);
5067
	spec->pin_nids = stac925x_pin_nids;
5068

5069
	/* Check first for codec ID */
5070
	spec->board_config = snd_hda_check_board_codec_sid_config(codec,
5071
							STAC_925x_MODELS,
5072
							stac925x_models,
5073
							stac925x_codec_id_cfg_tbl);
5074

5075
	/* Now checks for PCI ID, if codec ID is not found */
5076
	if (spec->board_config < 0)
5077
		spec->board_config = snd_hda_check_board_config(codec,
5078
							STAC_925x_MODELS,
5079
							stac925x_models,
5080
							stac925x_cfg_tbl);
5081
 again:
5082
	if (spec->board_config < 0)
5083
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5084
			    codec->chip_name);
5085
	else
5086
		stac92xx_set_config_regs(codec,
5087
					 stac925x_brd_tbl[spec->board_config]);
5088

5089
	spec->multiout.max_channels = 2;
5090
	spec->multiout.num_dacs = 1;
5091
	spec->multiout.dac_nids = stac925x_dac_nids;
5092
	spec->adc_nids = stac925x_adc_nids;
5093
	spec->mux_nids = stac925x_mux_nids;
5094
	spec->num_muxes = 1;
5095
	spec->num_adcs = 1;
5096
	spec->num_pwrs = 0;
5097
	switch (codec->vendor_id) {
5098
	case 0x83847632: /* STAC9202  */
5099
	case 0x83847633: /* STAC9202D */
5100
	case 0x83847636: /* STAC9251  */
5101
	case 0x83847637: /* STAC9251D */
5102
		spec->num_dmics = STAC925X_NUM_DMICS;
5103
		spec->dmic_nids = stac925x_dmic_nids;
5104
		spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids);
5105
		spec->dmux_nids = stac925x_dmux_nids;
5106
		break;
5107
	default:
5108
		spec->num_dmics = 0;
5109
		break;
5110
	}
5111

5112
	spec->init = stac925x_core_init;
5113
	spec->mixer = stac925x_mixer;
5114
	spec->num_caps = 1;
5115
	spec->capvols = stac925x_capvols;
5116
	spec->capsws = stac925x_capsws;
5117

5118
	err = stac92xx_parse_auto_config(codec, 0x8, 0x7);
5119
	if (!err) {
5120
		if (spec->board_config < 0) {
5121
			printk(KERN_WARNING "hda_codec: No auto-config is "
5122
			       "available, default to model=ref\n");
5123
			spec->board_config = STAC_925x_REF;
5124
			goto again;
5125
		}
5126
		err = -EINVAL;
5127
	}
5128
	if (err < 0) {
5129
		stac92xx_free(codec);
5130
		return err;
5131
	}
5132

5133
	codec->patch_ops = stac92xx_patch_ops;
5134

5135
	return 0;
5136
}
5137

5138
static int patch_stac92hd73xx(struct hda_codec *codec)
5139
{
5140
	struct sigmatel_spec *spec;
5141
	hda_nid_t conn[STAC92HD73_DAC_COUNT + 2];
5142
	int err = 0;
5143
	int num_dacs;
5144

5145
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5146
	if (spec == NULL)
5147
		return -ENOMEM;
5148

5149
	codec->no_trigger_sense = 1;
5150
	codec->spec = spec;
5151
	spec->linear_tone_beep = 0;
5152
	codec->slave_dig_outs = stac92hd73xx_slave_dig_outs;
5153
	spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids);
5154
	spec->pin_nids = stac92hd73xx_pin_nids;
5155
	spec->board_config = snd_hda_check_board_config(codec,
5156
							STAC_92HD73XX_MODELS,
5157
							stac92hd73xx_models,
5158
							stac92hd73xx_cfg_tbl);
5159
	/* check codec subsystem id if not found */
5160
	if (spec->board_config < 0)
5161
		spec->board_config =
5162
			snd_hda_check_board_codec_sid_config(codec,
5163
				STAC_92HD73XX_MODELS, stac92hd73xx_models,
5164
				stac92hd73xx_codec_id_cfg_tbl);
5165
again:
5166
	if (spec->board_config < 0)
5167
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5168
			    codec->chip_name);
5169
	else
5170
		stac92xx_set_config_regs(codec,
5171
				stac92hd73xx_brd_tbl[spec->board_config]);
5172

5173
	num_dacs = snd_hda_get_connections(codec, 0x0a,
5174
			conn, STAC92HD73_DAC_COUNT + 2) - 1;
5175

5176
	if (num_dacs < 3 || num_dacs > 5) {
5177
		printk(KERN_WARNING "hda_codec: Could not determine "
5178
		       "number of channels defaulting to DAC count\n");
5179
		num_dacs = STAC92HD73_DAC_COUNT;
5180
	}
5181
	spec->init = stac92hd73xx_core_init;
5182
	switch (num_dacs) {
5183
	case 0x3: /* 6 Channel */
5184
		spec->aloopback_ctl = stac92hd73xx_6ch_loopback;
5185
		break;
5186
	case 0x4: /* 8 Channel */
5187
		spec->aloopback_ctl = stac92hd73xx_8ch_loopback;
5188
		break;
5189
	case 0x5: /* 10 Channel */
5190
		spec->aloopback_ctl = stac92hd73xx_10ch_loopback;
5191
		break;
5192
	}
5193
	spec->multiout.dac_nids = spec->dac_nids;
5194

5195
	spec->aloopback_mask = 0x01;
5196
	spec->aloopback_shift = 8;
5197

5198
	spec->digbeep_nid = 0x1c;
5199
	spec->mux_nids = stac92hd73xx_mux_nids;
5200
	spec->adc_nids = stac92hd73xx_adc_nids;
5201
	spec->dmic_nids = stac92hd73xx_dmic_nids;
5202
	spec->dmux_nids = stac92hd73xx_dmux_nids;
5203
	spec->smux_nids = stac92hd73xx_smux_nids;
5204

5205
	spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids);
5206
	spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids);
5207
	spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids);
5208

5209
	spec->num_caps = STAC92HD73XX_NUM_CAPS;
5210
	spec->capvols = stac92hd73xx_capvols;
5211
	spec->capsws = stac92hd73xx_capsws;
5212

5213
	switch (spec->board_config) {
5214
	case STAC_DELL_EQ:
5215
		spec->init = dell_eq_core_init;
5216
		/* fallthru */
5217
	case STAC_DELL_M6_AMIC:
5218
	case STAC_DELL_M6_DMIC:
5219
	case STAC_DELL_M6_BOTH:
5220
		spec->num_smuxes = 0;
5221
		spec->eapd_switch = 0;
5222

5223
		switch (spec->board_config) {
5224
		case STAC_DELL_M6_AMIC: /* Analog Mics */
5225
			snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5226
			spec->num_dmics = 0;
5227
			break;
5228
		case STAC_DELL_M6_DMIC: /* Digital Mics */
5229
			snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5230
			spec->num_dmics = 1;
5231
			break;
5232
		case STAC_DELL_M6_BOTH: /* Both */
5233
			snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170);
5234
			snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160);
5235
			spec->num_dmics = 1;
5236
			break;
5237
		}
5238
		break;
5239
	case STAC_ALIENWARE_M17X:
5240
		spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5241
		spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5242
		spec->eapd_switch = 0;
5243
		break;
5244
	default:
5245
		spec->num_dmics = STAC92HD73XX_NUM_DMICS;
5246
		spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids);
5247
		spec->eapd_switch = 1;
5248
		break;
5249
	}
5250
	if (spec->board_config != STAC_92HD73XX_REF) {
5251
		/* GPIO0 High = Enable EAPD */
5252
		spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
5253
		spec->gpio_data = 0x01;
5254
	}
5255

5256
	spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids);
5257
	spec->pwr_nids = stac92hd73xx_pwr_nids;
5258

5259
	err = stac92xx_parse_auto_config(codec, 0x25, 0x27);
5260

5261
	if (!err) {
5262
		if (spec->board_config < 0) {
5263
			printk(KERN_WARNING "hda_codec: No auto-config is "
5264
			       "available, default to model=ref\n");
5265
			spec->board_config = STAC_92HD73XX_REF;
5266
			goto again;
5267
		}
5268
		err = -EINVAL;
5269
	}
5270

5271
	if (err < 0) {
5272
		stac92xx_free(codec);
5273
		return err;
5274
	}
5275

5276
	if (spec->board_config == STAC_92HD73XX_NO_JD)
5277
		spec->hp_detect = 0;
5278

5279
	codec->patch_ops = stac92xx_patch_ops;
5280

5281
	codec->proc_widget_hook = stac92hd7x_proc_hook;
5282

5283
	return 0;
5284
}
5285

5286
static int hp_bnb2011_with_dock(struct hda_codec *codec)
5287
{
5288
	if (codec->vendor_id != 0x111d7605 &&
5289
	    codec->vendor_id != 0x111d76d1)
5290
		return 0;
5291

5292
	switch (codec->subsystem_id) {
5293
	case 0x103c1618:
5294
	case 0x103c1619:
5295
	case 0x103c161a:
5296
	case 0x103c161b:
5297
	case 0x103c161c:
5298
	case 0x103c161d:
5299
	case 0x103c161e:
5300
	case 0x103c161f:
5301

5302
	case 0x103c162a:
5303
	case 0x103c162b:
5304

5305
	case 0x103c1630:
5306
	case 0x103c1631:
5307

5308
	case 0x103c1633:
5309
	case 0x103c1634:
5310
	case 0x103c1635:
5311

5312
	case 0x103c3587:
5313
	case 0x103c3588:
5314
	case 0x103c3589:
5315
	case 0x103c358a:
5316

5317
	case 0x103c3667:
5318
	case 0x103c3668:
5319
	case 0x103c3669:
5320

5321
		return 1;
5322
	}
5323
	return 0;
5324
}
5325

5326
static void stac92hd8x_add_pin(struct hda_codec *codec, hda_nid_t nid)
5327
{
5328
	struct sigmatel_spec *spec = codec->spec;
5329
	unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid);
5330
	int i;
5331

5332
	spec->auto_pin_nids[spec->auto_pin_cnt] = nid;
5333
	spec->auto_pin_cnt++;
5334

5335
	if (get_defcfg_device(def_conf) == AC_JACK_MIC_IN &&
5336
	    get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) {
5337
		for (i = 0; i < ARRAY_SIZE(stac92hd83xxx_dmic_nids); i++) {
5338
			if (nid == stac92hd83xxx_dmic_nids[i]) {
5339
				spec->auto_dmic_nids[spec->auto_dmic_cnt] = nid;
5340
				spec->auto_dmic_cnt++;
5341
			}
5342
		}
5343
	}
5344
}
5345

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

5350
	spec->auto_adc_nids[spec->auto_adc_cnt] = nid;
5351
	spec->auto_adc_cnt++;
5352
}
5353

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

5359
	for (i = 0; i < spec->auto_adc_cnt; i++) {
5360
		if (get_connection_index(codec,
5361
				spec->auto_adc_nids[i], nid) >= 0) {
5362
			/* mux and volume for adc_nids[i] */
5363
			if (!spec->auto_mux_nids[i]) {
5364
				spec->auto_mux_nids[i] = nid;
5365
				/* 92hd codecs capture volume is in mux */
5366
				spec->auto_capvols[i] = HDA_COMPOSE_AMP_VAL(nid,
5367
							3, 0, HDA_OUTPUT);
5368
			}
5369
			for (j = 0; j < spec->auto_dmic_cnt; j++) {
5370
				if (get_connection_index(codec, nid,
5371
						spec->auto_dmic_nids[j]) >= 0) {
5372
					/* dmux for adc_nids[i] */
5373
					if (!spec->auto_dmux_nids[i])
5374
						spec->auto_dmux_nids[i] = nid;
5375
					break;
5376
				}
5377
			}
5378
			break;
5379
		}
5380
	}
5381
}
5382

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

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

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

5395
		if (wid_type == AC_WID_PIN)
5396
			stac92hd8x_add_pin(codec, nid);
5397

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

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

5406
		if (wid_type == AC_WID_AUD_SEL)
5407
			stac92hd8x_add_mux(codec, nid);
5408
	}
5409

5410
	spec->pin_nids = spec->auto_pin_nids;
5411
	spec->num_pins = spec->auto_pin_cnt;
5412
	spec->adc_nids = spec->auto_adc_nids;
5413
	spec->num_adcs = spec->auto_adc_cnt;
5414
	spec->capvols = spec->auto_capvols;
5415
	spec->capsws = spec->auto_capvols;
5416
	spec->num_caps = spec->auto_adc_cnt;
5417
	spec->mux_nids = spec->auto_mux_nids;
5418
	spec->num_muxes = spec->auto_adc_cnt;
5419
	spec->dmux_nids = spec->auto_dmux_nids;
5420
	spec->num_dmuxes = spec->auto_adc_cnt;
5421
	spec->dmic_nids = spec->auto_dmic_nids;
5422
	spec->num_dmics = spec->auto_dmic_cnt;
5423
}
5424

5425
static int patch_stac92hd83xxx(struct hda_codec *codec)
5426
{
5427
	struct sigmatel_spec *spec;
5428
	hda_nid_t conn[STAC92HD83_DAC_COUNT + 1];
5429
	int err;
5430
	int num_dacs;
5431

5432
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5433
	if (spec == NULL)
5434
		return -ENOMEM;
5435

5436
	if (hp_bnb2011_with_dock(codec)) {
5437
		snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f);
5438
		snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e);
5439
	}
5440

5441
	/* reset pin power-down; Windows may leave these bits after reboot */
5442
	snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7EC, 0);
5443
	snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7ED, 0);
5444
	codec->no_trigger_sense = 1;
5445
	codec->spec = spec;
5446

5447
	stac92hd8x_fill_auto_spec(codec);
5448

5449
	spec->linear_tone_beep = 0;
5450
	codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs;
5451
	spec->digbeep_nid = 0x21;
5452
	spec->pwr_nids = stac92hd83xxx_pwr_nids;
5453
	spec->pwr_mapping = stac92hd83xxx_pwr_mapping;
5454
	spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids);
5455
	spec->multiout.dac_nids = spec->dac_nids;
5456
	spec->init = stac92hd83xxx_core_init;
5457

5458
	spec->board_config = snd_hda_check_board_config(codec,
5459
							STAC_92HD83XXX_MODELS,
5460
							stac92hd83xxx_models,
5461
							stac92hd83xxx_cfg_tbl);
5462
again:
5463
	if (spec->board_config < 0)
5464
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5465
			    codec->chip_name);
5466
	else
5467
		stac92xx_set_config_regs(codec,
5468
				stac92hd83xxx_brd_tbl[spec->board_config]);
5469

5470
	switch (codec->vendor_id) {
5471
	case 0x111d76d1:
5472
	case 0x111d76d9:
5473
	case 0x111d76e5:
5474
	case 0x111d7666:
5475
	case 0x111d7667:
5476
	case 0x111d7668:
5477
	case 0x111d7669:
5478
	case 0x111d76e3:
5479
	case 0x111d7604:
5480
	case 0x111d76d4:
5481
	case 0x111d7605:
5482
	case 0x111d76d5:
5483
	case 0x111d76e7:
5484
		if (spec->board_config == STAC_92HD83XXX_PWR_REF)
5485
			break;
5486
		spec->num_pwrs = 0;
5487
		break;
5488
	}
5489

5490
	codec->patch_ops = stac92xx_patch_ops;
5491

5492
	if (find_mute_led_gpio(codec, 0))
5493
		snd_printd("mute LED gpio %d polarity %d\n",
5494
				spec->gpio_led,
5495
				spec->gpio_led_polarity);
5496

5497
#ifdef CONFIG_SND_HDA_POWER_SAVE
5498
	if (spec->gpio_led) {
5499
		spec->gpio_mask |= spec->gpio_led;
5500
		spec->gpio_dir |= spec->gpio_led;
5501
		spec->gpio_data |= spec->gpio_led;
5502
		/* register check_power_status callback. */
5503
		codec->patch_ops.check_power_status =
5504
			stac92xx_hp_check_power_status;
5505
	}
5506
#endif	
5507

5508
	err = stac92xx_parse_auto_config(codec, 0x1d, 0);
5509
	if (!err) {
5510
		if (spec->board_config < 0) {
5511
			printk(KERN_WARNING "hda_codec: No auto-config is "
5512
			       "available, default to model=ref\n");
5513
			spec->board_config = STAC_92HD83XXX_REF;
5514
			goto again;
5515
		}
5516
		err = -EINVAL;
5517
	}
5518

5519
	if (err < 0) {
5520
		stac92xx_free(codec);
5521
		return err;
5522
	}
5523

5524
	/* docking output support */
5525
	num_dacs = snd_hda_get_connections(codec, 0xF,
5526
				conn, STAC92HD83_DAC_COUNT + 1) - 1;
5527
	/* skip non-DAC connections */
5528
	while (num_dacs >= 0 &&
5529
			(get_wcaps_type(get_wcaps(codec, conn[num_dacs]))
5530
					!= AC_WID_AUD_OUT))
5531
		num_dacs--;
5532
	/* set port E and F to select the last DAC */
5533
	if (num_dacs >= 0) {
5534
		snd_hda_codec_write_cache(codec, 0xE, 0,
5535
			AC_VERB_SET_CONNECT_SEL, num_dacs);
5536
		snd_hda_codec_write_cache(codec, 0xF, 0,
5537
			AC_VERB_SET_CONNECT_SEL, num_dacs);
5538
	}
5539

5540
	codec->proc_widget_hook = stac92hd_proc_hook;
5541

5542
	return 0;
5543
}
5544

5545
static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec,
5546
					  hda_nid_t dig0pin)
5547
{
5548
	struct sigmatel_spec *spec = codec->spec;
5549
	int idx;
5550

5551
	for (idx = 0; idx < spec->num_pins; idx++)
5552
		if (spec->pin_nids[idx] == dig0pin)
5553
			break;
5554
	if ((idx + 2) >= spec->num_pins)
5555
		return 0;
5556

5557
	/* dig1pin case */
5558
	if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE)
5559
		return 2;
5560

5561
	/* dig0pin + dig2pin case */
5562
	if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE)
5563
		return 2;
5564
	if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE)
5565
		return 1;
5566
	else
5567
		return 0;
5568
}
5569

5570
/* HP dv7 bass switch - GPIO5 */
5571
#define stac_hp_bass_gpio_info	snd_ctl_boolean_mono_info
5572
static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol,
5573
				 struct snd_ctl_elem_value *ucontrol)
5574
{
5575
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5576
	struct sigmatel_spec *spec = codec->spec;
5577
	ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20);
5578
	return 0;
5579
}
5580

5581
static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol,
5582
				 struct snd_ctl_elem_value *ucontrol)
5583
{
5584
	struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5585
	struct sigmatel_spec *spec = codec->spec;
5586
	unsigned int gpio_data;
5587

5588
	gpio_data = (spec->gpio_data & ~0x20) |
5589
		(ucontrol->value.integer.value[0] ? 0x20 : 0);
5590
	if (gpio_data == spec->gpio_data)
5591
		return 0;
5592
	spec->gpio_data = gpio_data;
5593
	stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data);
5594
	return 1;
5595
}
5596

5597
static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = {
5598
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5599
	.info = stac_hp_bass_gpio_info,
5600
	.get = stac_hp_bass_gpio_get,
5601
	.put = stac_hp_bass_gpio_put,
5602
};
5603

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

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

5612
	spec->gpio_mask |= 0x20;
5613
	spec->gpio_dir |= 0x20;
5614
	spec->gpio_data |= 0x20;
5615
	return 0;
5616
}
5617

5618
static int patch_stac92hd71bxx(struct hda_codec *codec)
5619
{
5620
	struct sigmatel_spec *spec;
5621
	const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init;
5622
	unsigned int pin_cfg;
5623
	int err = 0;
5624

5625
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5626
	if (spec == NULL)
5627
		return -ENOMEM;
5628

5629
	codec->no_trigger_sense = 1;
5630
	codec->spec = spec;
5631
	spec->linear_tone_beep = 0;
5632
	codec->patch_ops = stac92xx_patch_ops;
5633
	spec->num_pins = STAC92HD71BXX_NUM_PINS;
5634
	switch (codec->vendor_id) {
5635
	case 0x111d76b6:
5636
	case 0x111d76b7:
5637
		spec->pin_nids = stac92hd71bxx_pin_nids_4port;
5638
		break;
5639
	case 0x111d7603:
5640
	case 0x111d7608:
5641
		/* On 92HD75Bx 0x27 isn't a pin nid */
5642
		spec->num_pins--;
5643
		/* fallthrough */
5644
	default:
5645
		spec->pin_nids = stac92hd71bxx_pin_nids_6port;
5646
	}
5647
	spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids);
5648
	spec->board_config = snd_hda_check_board_config(codec,
5649
							STAC_92HD71BXX_MODELS,
5650
							stac92hd71bxx_models,
5651
							stac92hd71bxx_cfg_tbl);
5652
again:
5653
	if (spec->board_config < 0)
5654
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5655
			    codec->chip_name);
5656
	else
5657
		stac92xx_set_config_regs(codec,
5658
				stac92hd71bxx_brd_tbl[spec->board_config]);
5659

5660
	if (spec->board_config != STAC_92HD71BXX_REF) {
5661
		/* GPIO0 = EAPD */
5662
		spec->gpio_mask = 0x01;
5663
		spec->gpio_dir = 0x01;
5664
		spec->gpio_data = 0x01;
5665
	}
5666

5667
	spec->dmic_nids = stac92hd71bxx_dmic_nids;
5668
	spec->dmux_nids = stac92hd71bxx_dmux_nids;
5669

5670
	spec->num_caps = STAC92HD71BXX_NUM_CAPS;
5671
	spec->capvols = stac92hd71bxx_capvols;
5672
	spec->capsws = stac92hd71bxx_capsws;
5673

5674
	switch (codec->vendor_id) {
5675
	case 0x111d76b6: /* 4 Port without Analog Mixer */
5676
	case 0x111d76b7:
5677
		unmute_init++;
5678
		/* fallthru */
5679
	case 0x111d76b4: /* 6 Port without Analog Mixer */
5680
	case 0x111d76b5:
5681
		spec->init = stac92hd71bxx_core_init;
5682
		codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5683
		spec->num_dmics = stac92xx_connected_ports(codec,
5684
					stac92hd71bxx_dmic_nids,
5685
					STAC92HD71BXX_NUM_DMICS);
5686
		break;
5687
	case 0x111d7608: /* 5 Port with Analog Mixer */
5688
		switch (spec->board_config) {
5689
		case STAC_HP_M4:
5690
			/* Enable VREF power saving on GPIO1 detect */
5691
			err = stac_add_event(spec, codec->afg,
5692
					     STAC_VREF_EVENT, 0x02);
5693
			if (err < 0)
5694
				return err;
5695
			snd_hda_codec_write_cache(codec, codec->afg, 0,
5696
				AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02);
5697
			snd_hda_codec_write_cache(codec, codec->afg, 0,
5698
				AC_VERB_SET_UNSOLICITED_ENABLE,
5699
				AC_USRSP_EN | err);
5700
			spec->gpio_mask |= 0x02;
5701
			break;
5702
		}
5703
		if ((codec->revision_id & 0xf) == 0 ||
5704
		    (codec->revision_id & 0xf) == 1)
5705
			spec->stream_delay = 40; /* 40 milliseconds */
5706

5707
		/* no output amps */
5708
		spec->num_pwrs = 0;
5709
		/* disable VSW */
5710
		spec->init = stac92hd71bxx_core_init;
5711
		unmute_init++;
5712
		snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0);
5713
		snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3);
5714
		spec->dmic_nids = stac92hd71bxx_dmic_5port_nids;
5715
		spec->num_dmics = stac92xx_connected_ports(codec,
5716
					stac92hd71bxx_dmic_5port_nids,
5717
					STAC92HD71BXX_NUM_DMICS - 1);
5718
		break;
5719
	case 0x111d7603: /* 6 Port with Analog Mixer */
5720
		if ((codec->revision_id & 0xf) == 1)
5721
			spec->stream_delay = 40; /* 40 milliseconds */
5722

5723
		/* no output amps */
5724
		spec->num_pwrs = 0;
5725
		/* fallthru */
5726
	default:
5727
		spec->init = stac92hd71bxx_core_init;
5728
		codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs;
5729
		spec->num_dmics = stac92xx_connected_ports(codec,
5730
					stac92hd71bxx_dmic_nids,
5731
					STAC92HD71BXX_NUM_DMICS);
5732
		break;
5733
	}
5734

5735
	if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP)
5736
		snd_hda_sequence_write_cache(codec, unmute_init);
5737

5738
	spec->aloopback_ctl = stac92hd71bxx_loopback;
5739
	spec->aloopback_mask = 0x50;
5740
	spec->aloopback_shift = 0;
5741

5742
	spec->powerdown_adcs = 1;
5743
	spec->digbeep_nid = 0x26;
5744
	spec->mux_nids = stac92hd71bxx_mux_nids;
5745
	spec->adc_nids = stac92hd71bxx_adc_nids;
5746
	spec->smux_nids = stac92hd71bxx_smux_nids;
5747
	spec->pwr_nids = stac92hd71bxx_pwr_nids;
5748

5749
	spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids);
5750
	spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids);
5751
	spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids);
5752
	spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e);
5753

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

5756
	switch (spec->board_config) {
5757
	case STAC_HP_M4:
5758
		/* enable internal microphone */
5759
		snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040);
5760
		stac92xx_auto_set_pinctl(codec, 0x0e,
5761
			AC_PINCTL_IN_EN | AC_PINCTL_VREF_80);
5762
		/* fallthru */
5763
	case STAC_DELL_M4_2:
5764
		spec->num_dmics = 0;
5765
		spec->num_smuxes = 0;
5766
		spec->num_dmuxes = 0;
5767
		break;
5768
	case STAC_DELL_M4_1:
5769
	case STAC_DELL_M4_3:
5770
		spec->num_dmics = 1;
5771
		spec->num_smuxes = 0;
5772
		spec->num_dmuxes = 1;
5773
		break;
5774
	case STAC_HP_DV4_1222NR:
5775
		spec->num_dmics = 1;
5776
		/* I don't know if it needs 1 or 2 smuxes - will wait for
5777
		 * bug reports to fix if needed
5778
		 */
5779
		spec->num_smuxes = 1;
5780
		spec->num_dmuxes = 1;
5781
		/* fallthrough */
5782
	case STAC_HP_DV4:
5783
		spec->gpio_led = 0x01;
5784
		/* fallthrough */
5785
	case STAC_HP_DV5:
5786
		snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010);
5787
		stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN);
5788
		/* HP dv6 gives the headphone pin as a line-out.  Thus we
5789
		 * need to set hp_detect flag here to force to enable HP
5790
		 * detection.
5791
		 */
5792
		spec->hp_detect = 1;
5793
		break;
5794
	case STAC_HP_HDX:
5795
		spec->num_dmics = 1;
5796
		spec->num_dmuxes = 1;
5797
		spec->num_smuxes = 1;
5798
		spec->gpio_led = 0x08;
5799
		break;
5800
	}
5801

5802
	if (hp_blike_system(codec->subsystem_id)) {
5803
		pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f);
5804
		if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT ||
5805
			get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER  ||
5806
			get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) {
5807
			/* It was changed in the BIOS to just satisfy MS DTM.
5808
			 * Lets turn it back into slaved HP
5809
			 */
5810
			pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE))
5811
					| (AC_JACK_HP_OUT <<
5812
						AC_DEFCFG_DEVICE_SHIFT);
5813
			pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC
5814
							| AC_DEFCFG_SEQUENCE)))
5815
								| 0x1f;
5816
			snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg);
5817
		}
5818
	}
5819

5820
	if (find_mute_led_gpio(codec, 1))
5821
		snd_printd("mute LED gpio %d polarity %d\n",
5822
				spec->gpio_led,
5823
				spec->gpio_led_polarity);
5824

5825
#ifdef CONFIG_SND_HDA_POWER_SAVE
5826
	if (spec->gpio_led) {
5827
		spec->gpio_mask |= spec->gpio_led;
5828
		spec->gpio_dir |= spec->gpio_led;
5829
		spec->gpio_data |= spec->gpio_led;
5830
		/* register check_power_status callback. */
5831
		codec->patch_ops.check_power_status =
5832
			stac92xx_hp_check_power_status;
5833
	}
5834
#endif	
5835

5836
	spec->multiout.dac_nids = spec->dac_nids;
5837

5838
	err = stac92xx_parse_auto_config(codec, 0x21, 0);
5839
	if (!err) {
5840
		if (spec->board_config < 0) {
5841
			printk(KERN_WARNING "hda_codec: No auto-config is "
5842
			       "available, default to model=ref\n");
5843
			spec->board_config = STAC_92HD71BXX_REF;
5844
			goto again;
5845
		}
5846
		err = -EINVAL;
5847
	}
5848

5849
	if (err < 0) {
5850
		stac92xx_free(codec);
5851
		return err;
5852
	}
5853

5854
	/* enable bass on HP dv7 */
5855
	if (spec->board_config == STAC_HP_DV4 ||
5856
	    spec->board_config == STAC_HP_DV5) {
5857
		unsigned int cap;
5858
		cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP);
5859
		cap &= AC_GPIO_IO_COUNT;
5860
		if (cap >= 6)
5861
			stac_add_hp_bass_switch(codec);
5862
	}
5863

5864
	codec->proc_widget_hook = stac92hd7x_proc_hook;
5865

5866
	return 0;
5867
}
5868

5869
static int patch_stac922x(struct hda_codec *codec)
5870
{
5871
	struct sigmatel_spec *spec;
5872
	int err;
5873

5874
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5875
	if (spec == NULL)
5876
		return -ENOMEM;
5877

5878
	codec->no_trigger_sense = 1;
5879
	codec->spec = spec;
5880
	spec->linear_tone_beep = 1;
5881
	spec->num_pins = ARRAY_SIZE(stac922x_pin_nids);
5882
	spec->pin_nids = stac922x_pin_nids;
5883
	spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS,
5884
							stac922x_models,
5885
							stac922x_cfg_tbl);
5886
	if (spec->board_config == STAC_INTEL_MAC_AUTO) {
5887
		spec->gpio_mask = spec->gpio_dir = 0x03;
5888
		spec->gpio_data = 0x03;
5889
		/* Intel Macs have all same PCI SSID, so we need to check
5890
		 * codec SSID to distinguish the exact models
5891
		 */
5892
		printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id);
5893
		switch (codec->subsystem_id) {
5894

5895
		case 0x106b0800:
5896
			spec->board_config = STAC_INTEL_MAC_V1;
5897
			break;
5898
		case 0x106b0600:
5899
		case 0x106b0700:
5900
			spec->board_config = STAC_INTEL_MAC_V2;
5901
			break;
5902
		case 0x106b0e00:
5903
		case 0x106b0f00:
5904
		case 0x106b1600:
5905
		case 0x106b1700:
5906
		case 0x106b0200:
5907
		case 0x106b1e00:
5908
			spec->board_config = STAC_INTEL_MAC_V3;
5909
			break;
5910
		case 0x106b1a00:
5911
		case 0x00000100:
5912
			spec->board_config = STAC_INTEL_MAC_V4;
5913
			break;
5914
		case 0x106b0a00:
5915
		case 0x106b2200:
5916
			spec->board_config = STAC_INTEL_MAC_V5;
5917
			break;
5918
		default:
5919
			spec->board_config = STAC_INTEL_MAC_V3;
5920
			break;
5921
		}
5922
	}
5923

5924
 again:
5925
	if (spec->board_config < 0)
5926
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5927
			    codec->chip_name);
5928
	else
5929
		stac92xx_set_config_regs(codec,
5930
				stac922x_brd_tbl[spec->board_config]);
5931

5932
	spec->adc_nids = stac922x_adc_nids;
5933
	spec->mux_nids = stac922x_mux_nids;
5934
	spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids);
5935
	spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids);
5936
	spec->num_dmics = 0;
5937
	spec->num_pwrs = 0;
5938

5939
	spec->init = stac922x_core_init;
5940

5941
	spec->num_caps = STAC922X_NUM_CAPS;
5942
	spec->capvols = stac922x_capvols;
5943
	spec->capsws = stac922x_capsws;
5944

5945
	spec->multiout.dac_nids = spec->dac_nids;
5946
	
5947
	err = stac92xx_parse_auto_config(codec, 0x08, 0x09);
5948
	if (!err) {
5949
		if (spec->board_config < 0) {
5950
			printk(KERN_WARNING "hda_codec: No auto-config is "
5951
			       "available, default to model=ref\n");
5952
			spec->board_config = STAC_D945_REF;
5953
			goto again;
5954
		}
5955
		err = -EINVAL;
5956
	}
5957
	if (err < 0) {
5958
		stac92xx_free(codec);
5959
		return err;
5960
	}
5961

5962
	codec->patch_ops = stac92xx_patch_ops;
5963

5964
	/* Fix Mux capture level; max to 2 */
5965
	snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT,
5966
				  (0 << AC_AMPCAP_OFFSET_SHIFT) |
5967
				  (2 << AC_AMPCAP_NUM_STEPS_SHIFT) |
5968
				  (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) |
5969
				  (0 << AC_AMPCAP_MUTE_SHIFT));
5970

5971
	return 0;
5972
}
5973

5974
static int patch_stac927x(struct hda_codec *codec)
5975
{
5976
	struct sigmatel_spec *spec;
5977
	int err;
5978

5979
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
5980
	if (spec == NULL)
5981
		return -ENOMEM;
5982

5983
	codec->no_trigger_sense = 1;
5984
	codec->spec = spec;
5985
	spec->linear_tone_beep = 1;
5986
	codec->slave_dig_outs = stac927x_slave_dig_outs;
5987
	spec->num_pins = ARRAY_SIZE(stac927x_pin_nids);
5988
	spec->pin_nids = stac927x_pin_nids;
5989
	spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS,
5990
							stac927x_models,
5991
							stac927x_cfg_tbl);
5992
 again:
5993
	if (spec->board_config < 0)
5994
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5995
			    codec->chip_name);
5996
	else
5997
		stac92xx_set_config_regs(codec,
5998
				stac927x_brd_tbl[spec->board_config]);
5999

6000
	spec->digbeep_nid = 0x23;
6001
	spec->adc_nids = stac927x_adc_nids;
6002
	spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids);
6003
	spec->mux_nids = stac927x_mux_nids;
6004
	spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids);
6005
	spec->smux_nids = stac927x_smux_nids;
6006
	spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids);
6007
	spec->spdif_labels = stac927x_spdif_labels;
6008
	spec->dac_list = stac927x_dac_nids;
6009
	spec->multiout.dac_nids = spec->dac_nids;
6010

6011
	if (spec->board_config != STAC_D965_REF) {
6012
		/* GPIO0 High = Enable EAPD */
6013
		spec->eapd_mask = spec->gpio_mask = 0x01;
6014
		spec->gpio_dir = spec->gpio_data = 0x01;
6015
	}
6016

6017
	switch (spec->board_config) {
6018
	case STAC_D965_3ST:
6019
	case STAC_D965_5ST:
6020
		/* GPIO0 High = Enable EAPD */
6021
		spec->num_dmics = 0;
6022
		spec->init = d965_core_init;
6023
		break;
6024
	case STAC_DELL_BIOS:
6025
		switch (codec->subsystem_id) {
6026
		case 0x10280209:
6027
		case 0x1028022e:
6028
			/* correct the device field to SPDIF out */
6029
			snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070);
6030
			break;
6031
		}
6032
		/* configure the analog microphone on some laptops */
6033
		snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130);
6034
		/* correct the front output jack as a hp out */
6035
		snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f);
6036
		/* correct the front input jack as a mic */
6037
		snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130);
6038
		/* fallthru */
6039
	case STAC_DELL_3ST:
6040
		if (codec->subsystem_id != 0x1028022f) {
6041
			/* GPIO2 High = Enable EAPD */
6042
			spec->eapd_mask = spec->gpio_mask = 0x04;
6043
			spec->gpio_dir = spec->gpio_data = 0x04;
6044
		}
6045
		spec->dmic_nids = stac927x_dmic_nids;
6046
		spec->num_dmics = STAC927X_NUM_DMICS;
6047

6048
		spec->init = dell_3st_core_init;
6049
		spec->dmux_nids = stac927x_dmux_nids;
6050
		spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids);
6051
		break;
6052
	case STAC_927X_VOLKNOB:
6053
		spec->num_dmics = 0;
6054
		spec->init = stac927x_volknob_core_init;
6055
		break;
6056
	default:
6057
		spec->num_dmics = 0;
6058
		spec->init = stac927x_core_init;
6059
		break;
6060
	}
6061

6062
	spec->num_caps = STAC927X_NUM_CAPS;
6063
	spec->capvols = stac927x_capvols;
6064
	spec->capsws = stac927x_capsws;
6065

6066
	spec->num_pwrs = 0;
6067
	spec->aloopback_ctl = stac927x_loopback;
6068
	spec->aloopback_mask = 0x40;
6069
	spec->aloopback_shift = 0;
6070
	spec->eapd_switch = 1;
6071

6072
	err = stac92xx_parse_auto_config(codec, 0x1e, 0x20);
6073
	if (!err) {
6074
		if (spec->board_config < 0) {
6075
			printk(KERN_WARNING "hda_codec: No auto-config is "
6076
			       "available, default to model=ref\n");
6077
			spec->board_config = STAC_D965_REF;
6078
			goto again;
6079
		}
6080
		err = -EINVAL;
6081
	}
6082
	if (err < 0) {
6083
		stac92xx_free(codec);
6084
		return err;
6085
	}
6086

6087
	codec->patch_ops = stac92xx_patch_ops;
6088

6089
	codec->proc_widget_hook = stac927x_proc_hook;
6090

6091
	/*
6092
	 * !!FIXME!!
6093
	 * The STAC927x seem to require fairly long delays for certain
6094
	 * command sequences.  With too short delays (even if the answer
6095
	 * is set to RIRB properly), it results in the silence output
6096
	 * on some hardwares like Dell.
6097
	 *
6098
	 * The below flag enables the longer delay (see get_response
6099
	 * in hda_intel.c).
6100
	 */
6101
	codec->bus->needs_damn_long_delay = 1;
6102

6103
	/* no jack detecion for ref-no-jd model */
6104
	if (spec->board_config == STAC_D965_REF_NO_JD)
6105
		spec->hp_detect = 0;
6106

6107
	return 0;
6108
}
6109

6110
static int patch_stac9205(struct hda_codec *codec)
6111
{
6112
	struct sigmatel_spec *spec;
6113
	int err;
6114

6115
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
6116
	if (spec == NULL)
6117
		return -ENOMEM;
6118

6119
	codec->no_trigger_sense = 1;
6120
	codec->spec = spec;
6121
	spec->linear_tone_beep = 1;
6122
	spec->num_pins = ARRAY_SIZE(stac9205_pin_nids);
6123
	spec->pin_nids = stac9205_pin_nids;
6124
	spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS,
6125
							stac9205_models,
6126
							stac9205_cfg_tbl);
6127
 again:
6128
	if (spec->board_config < 0)
6129
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6130
			    codec->chip_name);
6131
	else
6132
		stac92xx_set_config_regs(codec,
6133
					 stac9205_brd_tbl[spec->board_config]);
6134

6135
	spec->digbeep_nid = 0x23;
6136
	spec->adc_nids = stac9205_adc_nids;
6137
	spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids);
6138
	spec->mux_nids = stac9205_mux_nids;
6139
	spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids);
6140
	spec->smux_nids = stac9205_smux_nids;
6141
	spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids);
6142
	spec->dmic_nids = stac9205_dmic_nids;
6143
	spec->num_dmics = STAC9205_NUM_DMICS;
6144
	spec->dmux_nids = stac9205_dmux_nids;
6145
	spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids);
6146
	spec->num_pwrs = 0;
6147

6148
	spec->init = stac9205_core_init;
6149
	spec->aloopback_ctl = stac9205_loopback;
6150

6151
	spec->num_caps = STAC9205_NUM_CAPS;
6152
	spec->capvols = stac9205_capvols;
6153
	spec->capsws = stac9205_capsws;
6154

6155
	spec->aloopback_mask = 0x40;
6156
	spec->aloopback_shift = 0;
6157
	/* Turn on/off EAPD per HP plugging */
6158
	if (spec->board_config != STAC_9205_EAPD)
6159
		spec->eapd_switch = 1;
6160
	spec->multiout.dac_nids = spec->dac_nids;
6161
	
6162
	switch (spec->board_config){
6163
	case STAC_9205_DELL_M43:
6164
		/* Enable SPDIF in/out */
6165
		snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030);
6166
		snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030);
6167

6168
		/* Enable unsol response for GPIO4/Dock HP connection */
6169
		err = stac_add_event(spec, codec->afg, STAC_VREF_EVENT, 0x01);
6170
		if (err < 0)
6171
			return err;
6172
		snd_hda_codec_write_cache(codec, codec->afg, 0,
6173
			AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10);
6174
		snd_hda_codec_write_cache(codec, codec->afg, 0,
6175
					  AC_VERB_SET_UNSOLICITED_ENABLE,
6176
					  AC_USRSP_EN | err);
6177

6178
		spec->gpio_dir = 0x0b;
6179
		spec->eapd_mask = 0x01;
6180
		spec->gpio_mask = 0x1b;
6181
		spec->gpio_mute = 0x10;
6182
		/* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute,
6183
		 * GPIO3 Low = DRM
6184
		 */
6185
		spec->gpio_data = 0x01;
6186
		break;
6187
	case STAC_9205_REF:
6188
		/* SPDIF-In enabled */
6189
		break;
6190
	default:
6191
		/* GPIO0 High = EAPD */
6192
		spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1;
6193
		spec->gpio_data = 0x01;
6194
		break;
6195
	}
6196

6197
	err = stac92xx_parse_auto_config(codec, 0x1f, 0x20);
6198
	if (!err) {
6199
		if (spec->board_config < 0) {
6200
			printk(KERN_WARNING "hda_codec: No auto-config is "
6201
			       "available, default to model=ref\n");
6202
			spec->board_config = STAC_9205_REF;
6203
			goto again;
6204
		}
6205
		err = -EINVAL;
6206
	}
6207
	if (err < 0) {
6208
		stac92xx_free(codec);
6209
		return err;
6210
	}
6211

6212
	codec->patch_ops = stac92xx_patch_ops;
6213

6214
	codec->proc_widget_hook = stac9205_proc_hook;
6215

6216
	return 0;
6217
}
6218

6219
/*
6220
 * STAC9872 hack
6221
 */
6222

6223
static const struct hda_verb stac9872_core_init[] = {
6224
	{0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */
6225
	{0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */
6226
	{}
6227
};
6228

6229
static const hda_nid_t stac9872_pin_nids[] = {
6230
	0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
6231
	0x11, 0x13, 0x14,
6232
};
6233

6234
static const hda_nid_t stac9872_adc_nids[] = {
6235
	0x8 /*,0x6*/
6236
};
6237

6238
static const hda_nid_t stac9872_mux_nids[] = {
6239
	0x15
6240
};
6241

6242
static const unsigned long stac9872_capvols[] = {
6243
	HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
6244
};
6245
#define stac9872_capsws		stac9872_capvols
6246

6247
static const unsigned int stac9872_vaio_pin_configs[9] = {
6248
	0x03211020, 0x411111f0, 0x411111f0, 0x03a15030,
6249
	0x411111f0, 0x90170110, 0x411111f0, 0x411111f0,
6250
	0x90a7013e
6251
};
6252

6253
static const char * const stac9872_models[STAC_9872_MODELS] = {
6254
	[STAC_9872_AUTO] = "auto",
6255
	[STAC_9872_VAIO] = "vaio",
6256
};
6257

6258
static const unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = {
6259
	[STAC_9872_VAIO] = stac9872_vaio_pin_configs,
6260
};
6261

6262
static const struct snd_pci_quirk stac9872_cfg_tbl[] = {
6263
	SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0,
6264
			   "Sony VAIO F/S", STAC_9872_VAIO),
6265
	{} /* terminator */
6266
};
6267

6268
static int patch_stac9872(struct hda_codec *codec)
6269
{
6270
	struct sigmatel_spec *spec;
6271
	int err;
6272

6273
	spec  = kzalloc(sizeof(*spec), GFP_KERNEL);
6274
	if (spec == NULL)
6275
		return -ENOMEM;
6276
	codec->no_trigger_sense = 1;
6277
	codec->spec = spec;
6278
	spec->linear_tone_beep = 1;
6279
	spec->num_pins = ARRAY_SIZE(stac9872_pin_nids);
6280
	spec->pin_nids = stac9872_pin_nids;
6281

6282
	spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS,
6283
							stac9872_models,
6284
							stac9872_cfg_tbl);
6285
	if (spec->board_config < 0)
6286
		snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6287
			    codec->chip_name);
6288
	else
6289
		stac92xx_set_config_regs(codec,
6290
					 stac9872_brd_tbl[spec->board_config]);
6291

6292
	spec->multiout.dac_nids = spec->dac_nids;
6293
	spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids);
6294
	spec->adc_nids = stac9872_adc_nids;
6295
	spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids);
6296
	spec->mux_nids = stac9872_mux_nids;
6297
	spec->init = stac9872_core_init;
6298
	spec->num_caps = 1;
6299
	spec->capvols = stac9872_capvols;
6300
	spec->capsws = stac9872_capsws;
6301

6302
	err = stac92xx_parse_auto_config(codec, 0x10, 0x12);
6303
	if (err < 0) {
6304
		stac92xx_free(codec);
6305
		return -EINVAL;
6306
	}
6307
	spec->input_mux = &spec->private_imux;
6308
	codec->patch_ops = stac92xx_patch_ops;
6309
	return 0;
6310
}
6311

6312

6313
/*
6314
 * patch entries
6315
 */
6316
static const struct hda_codec_preset snd_hda_preset_sigmatel[] = {
6317
 	{ .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 },
6318
 	{ .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x },
6319
 	{ .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x },
6320
 	{ .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x },
6321
 	{ .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x },
6322
 	{ .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x },
6323
 	{ .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x },
6324
 	{ .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x },
6325
 	{ .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x },
6326
 	{ .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x },
6327
 	{ .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x },
6328
 	{ .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x },
6329
 	{ .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x },
6330
 	{ .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x },
6331
 	{ .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x },
6332
 	{ .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x },
6333
 	{ .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x },
6334
 	{ .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x },
6335
 	{ .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x },
6336
 	{ .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x },
6337
 	{ .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x },
6338
 	{ .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x },
6339
 	{ .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x },
6340
	{ .id = 0x83847632, .name = "STAC9202",  .patch = patch_stac925x },
6341
	{ .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x },
6342
	{ .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x },
6343
	{ .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x },
6344
	{ .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x },
6345
	{ .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x },
6346
	{ .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x },
6347
	{ .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x },
6348
 	/* The following does not take into account .id=0x83847661 when subsys =
6349
 	 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are
6350
 	 * currently not fully supported.
6351
 	 */
6352
 	{ .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 },
6353
 	{ .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 },
6354
 	{ .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 },
6355
	{ .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 },
6356
 	{ .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 },
6357
 	{ .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 },
6358
 	{ .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 },
6359
 	{ .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 },
6360
 	{ .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 },
6361
 	{ .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 },
6362
 	{ .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 },
6363
 	{ .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 },
6364
	{ .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx},
6365
	{ .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx},
6366
	{ .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx},
6367
	{ .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx},
6368
	{ .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx},
6369
	{ .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx},
6370
	{ .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx},
6371
	{ .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx},
6372
	{ .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx},
6373
	{ .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx},
6374
	{ .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx},
6375
	{ .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx},
6376
	{ .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx },
6377
	{ .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx },
6378
	{ .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx },
6379
	{ .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6380
	{ .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx },
6381
	{ .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6382
	{ .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx },
6383
	{ .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6384
	{ .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx },
6385
	{ .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6386
	{ .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx },
6387
	{ .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx },
6388
	{ .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx },
6389
	{ .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx },
6390
	{ .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx },
6391
	{ .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx },
6392
	{ .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx },
6393
	{ .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx },
6394
	{ .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx },
6395
	{ .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx },
6396
	{ .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx },
6397
	{ .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx },
6398
	{ .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx },
6399
	{ .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx },
6400
	{ .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx },
6401
	{ .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx },
6402
	{ .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx},
6403
	{ .id = 0x111d76e3, .name = "92HD98BXX", .patch = patch_stac92hd83xxx},
6404
	{ .id = 0x111d76e5, .name = "92HD99BXX", .patch = patch_stac92hd83xxx},
6405
	{ .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx},
6406
	{} /* terminator */
6407
};
6408

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

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

6415
static struct hda_codec_preset_list sigmatel_list = {
6416
	.preset = snd_hda_preset_sigmatel,
6417
	.owner = THIS_MODULE,
6418
};
6419

6420
static int __init patch_sigmatel_init(void)
6421
{
6422
	return snd_hda_add_codec_preset(&sigmatel_list);
6423
}
6424

6425
static void __exit patch_sigmatel_exit(void)
6426
{
6427
	snd_hda_delete_codec_preset(&sigmatel_list);
6428
}
6429

6430
module_init(patch_sigmatel_init)
6431
module_exit(patch_sigmatel_exit)
6432

6433
Product

Resources

Company
