SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/pci/hda/patch_sigmatel.c

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