git.oblomov.eu Git - linux-2.6/blob - sound/pci/hda/patch_sigmatel.c

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