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