linux/sound/pci/hda/patch_sigmatel.c
<<
>>
Prefs
   1/*
   2 * Universal Interface for Intel High Definition Audio Codec
   3 *
   4 * HD audio interface patch for SigmaTel STAC92xx
   5 *
   6 * Copyright (c) 2005 Embedded Alley Solutions, Inc.
   7 * Matt Porter <mporter@embeddedalley.com>
   8 *
   9 * Based on patch_cmedia.c and patch_realtek.c
  10 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
  11 *
  12 *  This driver is free software; you can redistribute it and/or modify
  13 *  it under the terms of the GNU General Public License as published by
  14 *  the Free Software Foundation; either version 2 of the License, or
  15 *  (at your option) any later version.
  16 *
  17 *  This driver is distributed in the hope that it will be useful,
  18 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 *  GNU General Public License for more details.
  21 *
  22 *  You should have received a copy of the GNU General Public License
  23 *  along with this program; if not, write to the Free Software
  24 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  25 */
  26
  27#include <linux/init.h>
  28#include <linux/delay.h>
  29#include <linux/slab.h>
  30#include <linux/pci.h>
  31#include <linux/dmi.h>
  32#include <sound/core.h>
  33#include <sound/asoundef.h>
  34#include <sound/jack.h>
  35#include <sound/tlv.h>
  36#include "hda_codec.h"
  37#include "hda_local.h"
  38#include "hda_beep.h"
  39
  40enum {
  41        STAC_VREF_EVENT = 1,
  42        STAC_INSERT_EVENT,
  43        STAC_PWR_EVENT,
  44        STAC_HP_EVENT,
  45        STAC_LO_EVENT,
  46        STAC_MIC_EVENT,
  47};
  48
  49enum {
  50        STAC_AUTO,
  51        STAC_REF,
  52        STAC_9200_OQO,
  53        STAC_9200_DELL_D21,
  54        STAC_9200_DELL_D22,
  55        STAC_9200_DELL_D23,
  56        STAC_9200_DELL_M21,
  57        STAC_9200_DELL_M22,
  58        STAC_9200_DELL_M23,
  59        STAC_9200_DELL_M24,
  60        STAC_9200_DELL_M25,
  61        STAC_9200_DELL_M26,
  62        STAC_9200_DELL_M27,
  63        STAC_9200_M4,
  64        STAC_9200_M4_2,
  65        STAC_9200_PANASONIC,
  66        STAC_9200_MODELS
  67};
  68
  69enum {
  70        STAC_9205_AUTO,
  71        STAC_9205_REF,
  72        STAC_9205_DELL_M42,
  73        STAC_9205_DELL_M43,
  74        STAC_9205_DELL_M44,
  75        STAC_9205_EAPD,
  76        STAC_9205_MODELS
  77};
  78
  79enum {
  80        STAC_92HD73XX_AUTO,
  81        STAC_92HD73XX_NO_JD, /* no jack-detection */
  82        STAC_92HD73XX_REF,
  83        STAC_92HD73XX_INTEL,
  84        STAC_DELL_M6_AMIC,
  85        STAC_DELL_M6_DMIC,
  86        STAC_DELL_M6_BOTH,
  87        STAC_DELL_EQ,
  88        STAC_ALIENWARE_M17X,
  89        STAC_92HD73XX_MODELS
  90};
  91
  92enum {
  93        STAC_92HD83XXX_AUTO,
  94        STAC_92HD83XXX_REF,
  95        STAC_92HD83XXX_PWR_REF,
  96        STAC_DELL_S14,
  97        STAC_92HD83XXX_HP,
  98        STAC_HP_DV7_4000,
  99        STAC_92HD83XXX_MODELS
 100};
 101
 102enum {
 103        STAC_92HD71BXX_AUTO,
 104        STAC_92HD71BXX_REF,
 105        STAC_DELL_M4_1,
 106        STAC_DELL_M4_2,
 107        STAC_DELL_M4_3,
 108        STAC_HP_M4,
 109        STAC_HP_DV4,
 110        STAC_HP_DV5,
 111        STAC_HP_HDX,
 112        STAC_HP_DV4_1222NR,
 113        STAC_92HD71BXX_MODELS
 114};
 115
 116enum {
 117        STAC_925x_AUTO,
 118        STAC_925x_REF,
 119        STAC_M1,
 120        STAC_M1_2,
 121        STAC_M2,
 122        STAC_M2_2,
 123        STAC_M3,
 124        STAC_M5,
 125        STAC_M6,
 126        STAC_925x_MODELS
 127};
 128
 129enum {
 130        STAC_922X_AUTO,
 131        STAC_D945_REF,
 132        STAC_D945GTP3,
 133        STAC_D945GTP5,
 134        STAC_INTEL_MAC_V1,
 135        STAC_INTEL_MAC_V2,
 136        STAC_INTEL_MAC_V3,
 137        STAC_INTEL_MAC_V4,
 138        STAC_INTEL_MAC_V5,
 139        STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter
 140                              * is given, one of the above models will be
 141                              * chosen according to the subsystem id. */
 142        /* for backward compatibility */
 143        STAC_MACMINI,
 144        STAC_MACBOOK,
 145        STAC_MACBOOK_PRO_V1,
 146        STAC_MACBOOK_PRO_V2,
 147        STAC_IMAC_INTEL,
 148        STAC_IMAC_INTEL_20,
 149        STAC_ECS_202,
 150        STAC_922X_DELL_D81,
 151        STAC_922X_DELL_D82,
 152        STAC_922X_DELL_M81,
 153        STAC_922X_DELL_M82,
 154        STAC_922X_MODELS
 155};
 156
 157enum {
 158        STAC_927X_AUTO,
 159        STAC_D965_REF_NO_JD, /* no jack-detection */
 160        STAC_D965_REF,
 161        STAC_D965_3ST,
 162        STAC_D965_5ST,
 163        STAC_D965_5ST_NO_FP,
 164        STAC_DELL_3ST,
 165        STAC_DELL_BIOS,
 166        STAC_927X_VOLKNOB,
 167        STAC_927X_MODELS
 168};
 169
 170enum {
 171        STAC_9872_AUTO,
 172        STAC_9872_VAIO,
 173        STAC_9872_MODELS
 174};
 175
 176struct sigmatel_event {
 177        hda_nid_t nid;
 178        unsigned char type;
 179        unsigned char tag;
 180        int data;
 181};
 182
 183struct sigmatel_mic_route {
 184        hda_nid_t pin;
 185        signed char mux_idx;
 186        signed char dmux_idx;
 187};
 188
 189#define MAX_PINS_NUM 16
 190#define MAX_ADCS_NUM 4
 191#define MAX_DMICS_NUM 4
 192
 193struct sigmatel_spec {
 194        struct snd_kcontrol_new *mixers[4];
 195        unsigned int num_mixers;
 196
 197        int board_config;
 198        unsigned int eapd_switch: 1;
 199        unsigned int surr_switch: 1;
 200        unsigned int alt_switch: 1;
 201        unsigned int hp_detect: 1;
 202        unsigned int spdif_mute: 1;
 203        unsigned int check_volume_offset:1;
 204        unsigned int auto_mic:1;
 205        unsigned int linear_tone_beep:1;
 206
 207        /* gpio lines */
 208        unsigned int eapd_mask;
 209        unsigned int gpio_mask;
 210        unsigned int gpio_dir;
 211        unsigned int gpio_data;
 212        unsigned int gpio_mute;
 213        unsigned int gpio_led;
 214        unsigned int gpio_led_polarity;
 215
 216        /* stream */
 217        unsigned int stream_delay;
 218
 219        /* analog loopback */
 220        struct snd_kcontrol_new *aloopback_ctl;
 221        unsigned char aloopback_mask;
 222        unsigned char aloopback_shift;
 223
 224        /* power management */
 225        unsigned int num_pwrs;
 226        unsigned int *pwr_mapping;
 227        hda_nid_t *pwr_nids;
 228        hda_nid_t *dac_list;
 229
 230        /* events */
 231        struct snd_array events;
 232
 233        /* playback */
 234        struct hda_input_mux *mono_mux;
 235        unsigned int cur_mmux;
 236        struct hda_multi_out multiout;
 237        hda_nid_t dac_nids[5];
 238        hda_nid_t hp_dacs[5];
 239        hda_nid_t speaker_dacs[5];
 240
 241        int volume_offset;
 242
 243        /* capture */
 244        hda_nid_t *adc_nids;
 245        unsigned int num_adcs;
 246        hda_nid_t *mux_nids;
 247        unsigned int num_muxes;
 248        hda_nid_t *dmic_nids;
 249        unsigned int num_dmics;
 250        hda_nid_t *dmux_nids;
 251        unsigned int num_dmuxes;
 252        hda_nid_t *smux_nids;
 253        unsigned int num_smuxes;
 254        unsigned int num_analog_muxes;
 255
 256        unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */
 257        unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */
 258        unsigned int num_caps; /* number of capture volume/switch elements */
 259
 260        struct sigmatel_mic_route ext_mic;
 261        struct sigmatel_mic_route int_mic;
 262        struct sigmatel_mic_route dock_mic;
 263
 264        const char * const *spdif_labels;
 265
 266        hda_nid_t dig_in_nid;
 267        hda_nid_t mono_nid;
 268        hda_nid_t anabeep_nid;
 269        hda_nid_t digbeep_nid;
 270
 271        /* pin widgets */
 272        hda_nid_t *pin_nids;
 273        unsigned int num_pins;
 274
 275        /* codec specific stuff */
 276        struct hda_verb *init;
 277        struct snd_kcontrol_new *mixer;
 278
 279        /* capture source */
 280        struct hda_input_mux *dinput_mux;
 281        unsigned int cur_dmux[2];
 282        struct hda_input_mux *input_mux;
 283        unsigned int cur_mux[3];
 284        struct hda_input_mux *sinput_mux;
 285        unsigned int cur_smux[2];
 286        unsigned int cur_amux;
 287        hda_nid_t *amp_nids;
 288        unsigned int powerdown_adcs;
 289
 290        /* i/o switches */
 291        unsigned int io_switch[2];
 292        unsigned int clfe_swap;
 293        hda_nid_t line_switch;  /* shared line-in for input and output */
 294        hda_nid_t mic_switch;   /* shared mic-in for input and output */
 295        hda_nid_t hp_switch; /* NID of HP as line-out */
 296        unsigned int aloopback;
 297
 298        struct hda_pcm pcm_rec[2];      /* PCM information */
 299
 300        /* dynamic controls and input_mux */
 301        struct auto_pin_cfg autocfg;
 302        struct snd_array kctls;
 303        struct hda_input_mux private_dimux;
 304        struct hda_input_mux private_imux;
 305        struct hda_input_mux private_smux;
 306        struct hda_input_mux private_mono_mux;
 307
 308        /* auto spec */
 309        unsigned auto_pin_cnt;
 310        hda_nid_t auto_pin_nids[MAX_PINS_NUM];
 311        unsigned auto_adc_cnt;
 312        hda_nid_t auto_adc_nids[MAX_ADCS_NUM];
 313        hda_nid_t auto_mux_nids[MAX_ADCS_NUM];
 314        hda_nid_t auto_dmux_nids[MAX_ADCS_NUM];
 315        unsigned long auto_capvols[MAX_ADCS_NUM];
 316        unsigned auto_dmic_cnt;
 317        hda_nid_t auto_dmic_nids[MAX_DMICS_NUM];
 318};
 319
 320static hda_nid_t stac9200_adc_nids[1] = {
 321        0x03,
 322};
 323
 324static hda_nid_t stac9200_mux_nids[1] = {
 325        0x0c,
 326};
 327
 328static hda_nid_t stac9200_dac_nids[1] = {
 329        0x02,
 330};
 331
 332static hda_nid_t stac92hd73xx_pwr_nids[8] = {
 333        0x0a, 0x0b, 0x0c, 0xd, 0x0e,
 334        0x0f, 0x10, 0x11
 335};
 336
 337static hda_nid_t stac92hd73xx_slave_dig_outs[2] = {
 338        0x26, 0,
 339};
 340
 341static hda_nid_t stac92hd73xx_adc_nids[2] = {
 342        0x1a, 0x1b
 343};
 344
 345#define STAC92HD73XX_NUM_DMICS  2
 346static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = {
 347        0x13, 0x14, 0
 348};
 349
 350#define STAC92HD73_DAC_COUNT 5
 351
 352static hda_nid_t stac92hd73xx_mux_nids[2] = {
 353        0x20, 0x21,
 354};
 355
 356static hda_nid_t stac92hd73xx_dmux_nids[2] = {
 357        0x20, 0x21,
 358};
 359
 360static hda_nid_t stac92hd73xx_smux_nids[2] = {
 361        0x22, 0x23,
 362};
 363
 364#define STAC92HD73XX_NUM_CAPS   2
 365static unsigned long stac92hd73xx_capvols[] = {
 366        HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT),
 367        HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
 368};
 369#define stac92hd73xx_capsws     stac92hd73xx_capvols
 370
 371#define STAC92HD83_DAC_COUNT 3
 372
 373static hda_nid_t stac92hd83xxx_pwr_nids[4] = {
 374        0xa, 0xb, 0xd, 0xe,
 375};
 376
 377static hda_nid_t stac92hd83xxx_slave_dig_outs[2] = {
 378        0x1e, 0,
 379};
 380
 381static unsigned int stac92hd83xxx_pwr_mapping[4] = {
 382        0x03, 0x0c, 0x20, 0x40,
 383};
 384
 385static hda_nid_t stac92hd83xxx_dmic_nids[] = {
 386                0x11, 0x20,
 387};
 388
 389static hda_nid_t stac92hd71bxx_pwr_nids[3] = {
 390        0x0a, 0x0d, 0x0f
 391};
 392
 393static hda_nid_t stac92hd71bxx_adc_nids[2] = {
 394        0x12, 0x13,
 395};
 396
 397static hda_nid_t stac92hd71bxx_mux_nids[2] = {
 398        0x1a, 0x1b
 399};
 400
 401static hda_nid_t stac92hd71bxx_dmux_nids[2] = {
 402        0x1c, 0x1d,
 403};
 404
 405static hda_nid_t stac92hd71bxx_smux_nids[2] = {
 406        0x24, 0x25,
 407};
 408
 409#define STAC92HD71BXX_NUM_DMICS 2
 410static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = {
 411        0x18, 0x19, 0
 412};
 413
 414static hda_nid_t stac92hd71bxx_slave_dig_outs[2] = {
 415        0x22, 0
 416};
 417
 418#define STAC92HD71BXX_NUM_CAPS          2
 419static unsigned long stac92hd71bxx_capvols[] = {
 420        HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
 421        HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
 422};
 423#define stac92hd71bxx_capsws    stac92hd71bxx_capvols
 424
 425static hda_nid_t stac925x_adc_nids[1] = {
 426        0x03,
 427};
 428
 429static hda_nid_t stac925x_mux_nids[1] = {
 430        0x0f,
 431};
 432
 433static hda_nid_t stac925x_dac_nids[1] = {
 434        0x02,
 435};
 436
 437#define STAC925X_NUM_DMICS      1
 438static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = {
 439        0x15, 0
 440};
 441
 442static hda_nid_t stac925x_dmux_nids[1] = {
 443        0x14,
 444};
 445
 446static unsigned long stac925x_capvols[] = {
 447        HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
 448};
 449static unsigned long stac925x_capsws[] = {
 450        HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
 451};
 452
 453static hda_nid_t stac922x_adc_nids[2] = {
 454        0x06, 0x07,
 455};
 456
 457static hda_nid_t stac922x_mux_nids[2] = {
 458        0x12, 0x13,
 459};
 460
 461#define STAC922X_NUM_CAPS       2
 462static unsigned long stac922x_capvols[] = {
 463        HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT),
 464        HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
 465};
 466#define stac922x_capsws         stac922x_capvols
 467
 468static hda_nid_t stac927x_slave_dig_outs[2] = {
 469        0x1f, 0,
 470};
 471
 472static hda_nid_t stac927x_adc_nids[3] = {
 473        0x07, 0x08, 0x09
 474};
 475
 476static hda_nid_t stac927x_mux_nids[3] = {
 477        0x15, 0x16, 0x17
 478};
 479
 480static hda_nid_t stac927x_smux_nids[1] = {
 481        0x21,
 482};
 483
 484static hda_nid_t stac927x_dac_nids[6] = {
 485        0x02, 0x03, 0x04, 0x05, 0x06, 0
 486};
 487
 488static hda_nid_t stac927x_dmux_nids[1] = {
 489        0x1b,
 490};
 491
 492#define STAC927X_NUM_DMICS 2
 493static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = {
 494        0x13, 0x14, 0
 495};
 496
 497#define STAC927X_NUM_CAPS       3
 498static unsigned long stac927x_capvols[] = {
 499        HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT),
 500        HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT),
 501        HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT),
 502};
 503static unsigned long stac927x_capsws[] = {
 504        HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
 505        HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT),
 506        HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
 507};
 508
 509static const char * const stac927x_spdif_labels[5] = {
 510        "Digital Playback", "ADAT", "Analog Mux 1",
 511        "Analog Mux 2", "Analog Mux 3"
 512};
 513
 514static hda_nid_t stac9205_adc_nids[2] = {
 515        0x12, 0x13
 516};
 517
 518static hda_nid_t stac9205_mux_nids[2] = {
 519        0x19, 0x1a
 520};
 521
 522static hda_nid_t stac9205_dmux_nids[1] = {
 523        0x1d,
 524};
 525
 526static hda_nid_t stac9205_smux_nids[1] = {
 527        0x21,
 528};
 529
 530#define STAC9205_NUM_DMICS      2
 531static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = {
 532        0x17, 0x18, 0
 533};
 534
 535#define STAC9205_NUM_CAPS       2
 536static unsigned long stac9205_capvols[] = {
 537        HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT),
 538        HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT),
 539};
 540static unsigned long stac9205_capsws[] = {
 541        HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT),
 542        HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT),
 543};
 544
 545static hda_nid_t stac9200_pin_nids[8] = {
 546        0x08, 0x09, 0x0d, 0x0e, 
 547        0x0f, 0x10, 0x11, 0x12,
 548};
 549
 550static hda_nid_t stac925x_pin_nids[8] = {
 551        0x07, 0x08, 0x0a, 0x0b, 
 552        0x0c, 0x0d, 0x10, 0x11,
 553};
 554
 555static hda_nid_t stac922x_pin_nids[10] = {
 556        0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 557        0x0f, 0x10, 0x11, 0x15, 0x1b,
 558};
 559
 560static hda_nid_t stac92hd73xx_pin_nids[13] = {
 561        0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 562        0x0f, 0x10, 0x11, 0x12, 0x13,
 563        0x14, 0x22, 0x23
 564};
 565
 566#define STAC92HD71BXX_NUM_PINS 13
 567static hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = {
 568        0x0a, 0x0b, 0x0c, 0x0d, 0x00,
 569        0x00, 0x14, 0x18, 0x19, 0x1e,
 570        0x1f, 0x20, 0x27
 571};
 572static hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = {
 573        0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 574        0x0f, 0x14, 0x18, 0x19, 0x1e,
 575        0x1f, 0x20, 0x27
 576};
 577
 578static hda_nid_t stac927x_pin_nids[14] = {
 579        0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 580        0x0f, 0x10, 0x11, 0x12, 0x13,
 581        0x14, 0x21, 0x22, 0x23,
 582};
 583
 584static hda_nid_t stac9205_pin_nids[12] = {
 585        0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
 586        0x0f, 0x14, 0x16, 0x17, 0x18,
 587        0x21, 0x22,
 588};
 589
 590static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol,
 591                                   struct snd_ctl_elem_info *uinfo)
 592{
 593        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 594        struct sigmatel_spec *spec = codec->spec;
 595        return snd_hda_input_mux_info(spec->dinput_mux, uinfo);
 596}
 597
 598static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol,
 599                                  struct snd_ctl_elem_value *ucontrol)
 600{
 601        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 602        struct sigmatel_spec *spec = codec->spec;
 603        unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 604
 605        ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx];
 606        return 0;
 607}
 608
 609static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol,
 610                                  struct snd_ctl_elem_value *ucontrol)
 611{
 612        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 613        struct sigmatel_spec *spec = codec->spec;
 614        unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 615
 616        return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol,
 617                        spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]);
 618}
 619
 620static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol,
 621                                   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->sinput_mux, uinfo);
 626}
 627
 628static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol,
 629                                  struct snd_ctl_elem_value *ucontrol)
 630{
 631        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 632        struct sigmatel_spec *spec = codec->spec;
 633        unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 634
 635        ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx];
 636        return 0;
 637}
 638
 639static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol,
 640                                  struct snd_ctl_elem_value *ucontrol)
 641{
 642        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 643        struct sigmatel_spec *spec = codec->spec;
 644        struct hda_input_mux *smux = &spec->private_smux;
 645        unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 646        int err, val;
 647        hda_nid_t nid;
 648
 649        err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol,
 650                        spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]);
 651        if (err < 0)
 652                return err;
 653
 654        if (spec->spdif_mute) {
 655                if (smux_idx == 0)
 656                        nid = spec->multiout.dig_out_nid;
 657                else
 658                        nid = codec->slave_dig_outs[smux_idx - 1];
 659                if (spec->cur_smux[smux_idx] == smux->num_items - 1)
 660                        val = HDA_AMP_MUTE;
 661                else
 662                        val = 0;
 663                /* un/mute SPDIF out */
 664                snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 665                                         HDA_AMP_MUTE, val);
 666        }
 667        return 0;
 668}
 669
 670static unsigned int stac92xx_vref_set(struct hda_codec *codec,
 671                                        hda_nid_t nid, unsigned int new_vref)
 672{
 673        int error;
 674        unsigned int pincfg;
 675        pincfg = snd_hda_codec_read(codec, nid, 0,
 676                                AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 677
 678        pincfg &= 0xff;
 679        pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN);
 680        pincfg |= new_vref;
 681
 682        if (new_vref == AC_PINCTL_VREF_HIZ)
 683                pincfg |= AC_PINCTL_OUT_EN;
 684        else
 685                pincfg |= AC_PINCTL_IN_EN;
 686
 687        error = snd_hda_codec_write_cache(codec, nid, 0,
 688                                        AC_VERB_SET_PIN_WIDGET_CONTROL, pincfg);
 689        if (error < 0)
 690                return error;
 691        else
 692                return 1;
 693}
 694
 695static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid)
 696{
 697        unsigned int vref;
 698        vref = snd_hda_codec_read(codec, nid, 0,
 699                                AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 700        vref &= AC_PINCTL_VREFEN;
 701        return vref;
 702}
 703
 704static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
 705{
 706        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 707        struct sigmatel_spec *spec = codec->spec;
 708        return snd_hda_input_mux_info(spec->input_mux, uinfo);
 709}
 710
 711static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 712{
 713        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 714        struct sigmatel_spec *spec = codec->spec;
 715        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 716
 717        ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 718        return 0;
 719}
 720
 721static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 722{
 723        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 724        struct sigmatel_spec *spec = codec->spec;
 725        unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 726        const struct hda_input_mux *imux = spec->input_mux;
 727        unsigned int idx, prev_idx, didx;
 728
 729        idx = ucontrol->value.enumerated.item[0];
 730        if (idx >= imux->num_items)
 731                idx = imux->num_items - 1;
 732        prev_idx = spec->cur_mux[adc_idx];
 733        if (prev_idx == idx)
 734                return 0;
 735        if (idx < spec->num_analog_muxes) {
 736                snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0,
 737                                          AC_VERB_SET_CONNECT_SEL,
 738                                          imux->items[idx].index);
 739                if (prev_idx >= spec->num_analog_muxes &&
 740                    spec->mux_nids[adc_idx] != spec->dmux_nids[adc_idx]) {
 741                        imux = spec->dinput_mux;
 742                        /* 0 = analog */
 743                        snd_hda_codec_write_cache(codec,
 744                                                  spec->dmux_nids[adc_idx], 0,
 745                                                  AC_VERB_SET_CONNECT_SEL,
 746                                                  imux->items[0].index);
 747                }
 748        } else {
 749                imux = spec->dinput_mux;
 750                /* first dimux item is hardcoded to select analog imux,
 751                 * so lets skip it
 752                 */
 753                didx = idx - spec->num_analog_muxes + 1;
 754                snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0,
 755                                          AC_VERB_SET_CONNECT_SEL,
 756                                          imux->items[didx].index);
 757        }
 758        spec->cur_mux[adc_idx] = idx;
 759        return 1;
 760}
 761
 762static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol,
 763        struct snd_ctl_elem_info *uinfo)
 764{
 765        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 766        struct sigmatel_spec *spec = codec->spec;
 767        return snd_hda_input_mux_info(spec->mono_mux, uinfo);
 768}
 769
 770static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol,
 771        struct snd_ctl_elem_value *ucontrol)
 772{
 773        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 774        struct sigmatel_spec *spec = codec->spec;
 775
 776        ucontrol->value.enumerated.item[0] = spec->cur_mmux;
 777        return 0;
 778}
 779
 780static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol,
 781        struct snd_ctl_elem_value *ucontrol)
 782{
 783        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 784        struct sigmatel_spec *spec = codec->spec;
 785
 786        return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol,
 787                                     spec->mono_nid, &spec->cur_mmux);
 788}
 789
 790#define stac92xx_aloopback_info snd_ctl_boolean_mono_info
 791
 792static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol,
 793        struct snd_ctl_elem_value *ucontrol)
 794{
 795        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 796        unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 797        struct sigmatel_spec *spec = codec->spec;
 798
 799        ucontrol->value.integer.value[0] = !!(spec->aloopback &
 800                                              (spec->aloopback_mask << idx));
 801        return 0;
 802}
 803
 804static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol,
 805                struct snd_ctl_elem_value *ucontrol)
 806{
 807        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 808        struct sigmatel_spec *spec = codec->spec;
 809        unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 810        unsigned int dac_mode;
 811        unsigned int val, idx_val;
 812
 813        idx_val = spec->aloopback_mask << idx;
 814        if (ucontrol->value.integer.value[0])
 815                val = spec->aloopback | idx_val;
 816        else
 817                val = spec->aloopback & ~idx_val;
 818        if (spec->aloopback == val)
 819                return 0;
 820
 821        spec->aloopback = val;
 822
 823        /* Only return the bits defined by the shift value of the
 824         * first two bytes of the mask
 825         */
 826        dac_mode = snd_hda_codec_read(codec, codec->afg, 0,
 827                                      kcontrol->private_value & 0xFFFF, 0x0);
 828        dac_mode >>= spec->aloopback_shift;
 829
 830        if (spec->aloopback & idx_val) {
 831                snd_hda_power_up(codec);
 832                dac_mode |= idx_val;
 833        } else {
 834                snd_hda_power_down(codec);
 835                dac_mode &= ~idx_val;
 836        }
 837
 838        snd_hda_codec_write_cache(codec, codec->afg, 0,
 839                kcontrol->private_value >> 16, dac_mode);
 840
 841        return 1;
 842}
 843
 844static struct hda_verb stac9200_core_init[] = {
 845        /* set dac0mux for dac converter */
 846        { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 847        {}
 848};
 849
 850static struct hda_verb stac9200_eapd_init[] = {
 851        /* set dac0mux for dac converter */
 852        {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
 853        {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
 854        {}
 855};
 856
 857static struct hda_verb dell_eq_core_init[] = {
 858        /* set master volume to max value without distortion
 859         * and direct control */
 860        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec},
 861        {}
 862};
 863
 864static struct hda_verb stac92hd73xx_core_init[] = {
 865        /* set master volume and direct control */
 866        { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 867        {}
 868};
 869
 870static struct hda_verb stac92hd83xxx_core_init[] = {
 871        /* power state controls amps */
 872        { 0x01, AC_VERB_SET_EAPD, 1 << 2},
 873        {}
 874};
 875
 876static struct hda_verb stac92hd71bxx_core_init[] = {
 877        /* set master volume and direct control */
 878        { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 879        {}
 880};
 881
 882static struct hda_verb stac92hd71bxx_unmute_core_init[] = {
 883        /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */
 884        { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 885        { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 886        { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
 887        {}
 888};
 889
 890static struct hda_verb stac925x_core_init[] = {
 891        /* set dac0mux for dac converter */
 892        { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00},
 893        /* mute the master volume */
 894        { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
 895        {}
 896};
 897
 898static struct hda_verb stac922x_core_init[] = {
 899        /* set master volume and direct control */      
 900        { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 901        {}
 902};
 903
 904static struct hda_verb d965_core_init[] = {
 905        /* set master volume and direct control */      
 906        { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 907        /* unmute node 0x1b */
 908        { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 909        /* select node 0x03 as DAC */   
 910        { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
 911        {}
 912};
 913
 914static struct hda_verb dell_3st_core_init[] = {
 915        /* don't set delta bit */
 916        {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
 917        /* unmute node 0x1b */
 918        {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
 919        /* select node 0x03 as DAC */
 920        {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01},
 921        {}
 922};
 923
 924static struct hda_verb stac927x_core_init[] = {
 925        /* set master volume and direct control */      
 926        { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 927        /* enable analog pc beep path */
 928        { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
 929        {}
 930};
 931
 932static struct hda_verb stac927x_volknob_core_init[] = {
 933        /* don't set delta bit */
 934        {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f},
 935        /* enable analog pc beep path */
 936        {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
 937        {}
 938};
 939
 940static struct hda_verb stac9205_core_init[] = {
 941        /* set master volume and direct control */      
 942        { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff},
 943        /* enable analog pc beep path */
 944        { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5},
 945        {}
 946};
 947
 948#define STAC_MONO_MUX \
 949        { \
 950                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 951                .name = "Mono Mux", \
 952                .count = 1, \
 953                .info = stac92xx_mono_mux_enum_info, \
 954                .get = stac92xx_mono_mux_enum_get, \
 955                .put = stac92xx_mono_mux_enum_put, \
 956        }
 957
 958#define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \
 959        { \
 960                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 961                .name  = "Analog Loopback", \
 962                .count = cnt, \
 963                .info  = stac92xx_aloopback_info, \
 964                .get   = stac92xx_aloopback_get, \
 965                .put   = stac92xx_aloopback_put, \
 966                .private_value = verb_read | (verb_write << 16), \
 967        }
 968
 969#define DC_BIAS(xname, idx, nid) \
 970        { \
 971                .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
 972                .name = xname, \
 973                .index = idx, \
 974                .info = stac92xx_dc_bias_info, \
 975                .get = stac92xx_dc_bias_get, \
 976                .put = stac92xx_dc_bias_put, \
 977                .private_value = nid, \
 978        }
 979
 980static struct snd_kcontrol_new stac9200_mixer[] = {
 981        HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xb, 0, HDA_OUTPUT),
 982        HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT),
 983        HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT),
 984        HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT),
 985        { } /* end */
 986};
 987
 988static struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = {
 989        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3),
 990        {}
 991};
 992
 993static struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = {
 994        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4),
 995        {}
 996};
 997
 998static struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = {
 999        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5),
1000        {}
1001};
1002
1003
1004static struct snd_kcontrol_new stac92hd71bxx_loopback[] = {
1005        STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2)
1006};
1007
1008static struct snd_kcontrol_new stac925x_mixer[] = {
1009        HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xe, 0, HDA_OUTPUT),
1010        HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT),
1011        { } /* end */
1012};
1013
1014static struct snd_kcontrol_new stac9205_loopback[] = {
1015        STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1),
1016        {}
1017};
1018
1019static struct snd_kcontrol_new stac927x_loopback[] = {
1020        STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1),
1021        {}
1022};
1023
1024static struct snd_kcontrol_new stac_dmux_mixer = {
1025        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1026        .name = "Digital Input Source",
1027        /* count set later */
1028        .info = stac92xx_dmux_enum_info,
1029        .get = stac92xx_dmux_enum_get,
1030        .put = stac92xx_dmux_enum_put,
1031};
1032
1033static struct snd_kcontrol_new stac_smux_mixer = {
1034        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1035        .name = "IEC958 Playback Source",
1036        /* count set later */
1037        .info = stac92xx_smux_enum_info,
1038        .get = stac92xx_smux_enum_get,
1039        .put = stac92xx_smux_enum_put,
1040};
1041
1042static const char * const slave_vols[] = {
1043        "Front Playback Volume",
1044        "Surround Playback Volume",
1045        "Center Playback Volume",
1046        "LFE Playback Volume",
1047        "Side Playback Volume",
1048        "Headphone Playback Volume",
1049        "Speaker Playback Volume",
1050        NULL
1051};
1052
1053static const char * const slave_sws[] = {
1054        "Front Playback Switch",
1055        "Surround Playback Switch",
1056        "Center Playback Switch",
1057        "LFE Playback Switch",
1058        "Side Playback Switch",
1059        "Headphone Playback Switch",
1060        "Speaker Playback Switch",
1061        "IEC958 Playback Switch",
1062        NULL
1063};
1064
1065static void stac92xx_free_kctls(struct hda_codec *codec);
1066static int stac92xx_add_jack(struct hda_codec *codec, hda_nid_t nid, int type);
1067
1068static int stac92xx_build_controls(struct hda_codec *codec)
1069{
1070        struct sigmatel_spec *spec = codec->spec;
1071        struct auto_pin_cfg *cfg = &spec->autocfg;
1072        hda_nid_t nid;
1073        int err;
1074        int i;
1075
1076        if (spec->mixer) {
1077                err = snd_hda_add_new_ctls(codec, spec->mixer);
1078                if (err < 0)
1079                        return err;
1080        }
1081
1082        for (i = 0; i < spec->num_mixers; i++) {
1083                err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
1084                if (err < 0)
1085                        return err;
1086        }
1087        if (!spec->auto_mic && spec->num_dmuxes > 0 &&
1088            snd_hda_get_bool_hint(codec, "separate_dmux") == 1) {
1089                stac_dmux_mixer.count = spec->num_dmuxes;
1090                err = snd_hda_ctl_add(codec, 0,
1091                                  snd_ctl_new1(&stac_dmux_mixer, codec));
1092                if (err < 0)
1093                        return err;
1094        }
1095        if (spec->num_smuxes > 0) {
1096                int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid);
1097                struct hda_input_mux *smux = &spec->private_smux;
1098                /* check for mute support on SPDIF out */
1099                if (wcaps & AC_WCAP_OUT_AMP) {
1100                        snd_hda_add_imux_item(smux, "Off", 0, NULL);
1101                        spec->spdif_mute = 1;
1102                }
1103                stac_smux_mixer.count = spec->num_smuxes;
1104                err = snd_hda_ctl_add(codec, 0,
1105                                  snd_ctl_new1(&stac_smux_mixer, codec));
1106                if (err < 0)
1107                        return err;
1108        }
1109
1110        if (spec->multiout.dig_out_nid) {
1111                err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
1112                if (err < 0)
1113                        return err;
1114                err = snd_hda_create_spdif_share_sw(codec,
1115                                                    &spec->multiout);
1116                if (err < 0)
1117                        return err;
1118                spec->multiout.share_spdif = 1;
1119        }
1120        if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) {
1121                err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
1122                if (err < 0)
1123                        return err;
1124        }
1125
1126        /* if we have no master control, let's create it */
1127        if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
1128                unsigned int vmaster_tlv[4];
1129                snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0],
1130                                        HDA_OUTPUT, vmaster_tlv);
1131                /* correct volume offset */
1132                vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset;
1133                /* minimum value is actually mute */
1134                vmaster_tlv[3] |= TLV_DB_SCALE_MUTE;
1135                err = snd_hda_add_vmaster(codec, "Master Playback Volume",
1136                                          vmaster_tlv, slave_vols);
1137                if (err < 0)
1138                        return err;
1139        }
1140        if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
1141                err = snd_hda_add_vmaster(codec, "Master Playback Switch",
1142                                          NULL, slave_sws);
1143                if (err < 0)
1144                        return err;
1145        }
1146
1147        if (spec->aloopback_ctl &&
1148            snd_hda_get_bool_hint(codec, "loopback") == 1) {
1149                err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl);
1150                if (err < 0)
1151                        return err;
1152        }
1153
1154        stac92xx_free_kctls(codec); /* no longer needed */
1155
1156        /* create jack input elements */
1157        if (spec->hp_detect) {
1158                for (i = 0; i < cfg->hp_outs; i++) {
1159                        int type = SND_JACK_HEADPHONE;
1160                        nid = cfg->hp_pins[i];
1161                        /* jack detection */
1162                        if (cfg->hp_outs == i)
1163                                type |= SND_JACK_LINEOUT;
1164                        err = stac92xx_add_jack(codec, nid, type);
1165                        if (err < 0)
1166                                return err;
1167                }
1168        }
1169        for (i = 0; i < cfg->line_outs; i++) {
1170                err = stac92xx_add_jack(codec, cfg->line_out_pins[i],
1171                                        SND_JACK_LINEOUT);
1172                if (err < 0)
1173                        return err;
1174        }
1175        for (i = 0; i < cfg->num_inputs; i++) {
1176                nid = cfg->inputs[i].pin;
1177                err = stac92xx_add_jack(codec, nid, SND_JACK_MICROPHONE);
1178                if (err < 0)
1179                        return err;
1180        }
1181
1182        return 0;       
1183}
1184
1185static unsigned int ref9200_pin_configs[8] = {
1186        0x01c47010, 0x01447010, 0x0221401f, 0x01114010,
1187        0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1188};
1189
1190static unsigned int gateway9200_m4_pin_configs[8] = {
1191        0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1192        0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1193};
1194static unsigned int gateway9200_m4_2_pin_configs[8] = {
1195        0x400000fe, 0x404500f4, 0x400100f0, 0x90110010,
1196        0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3,
1197};
1198
1199/*
1200    STAC 9200 pin configs for
1201    102801A8
1202    102801DE
1203    102801E8
1204*/
1205static unsigned int dell9200_d21_pin_configs[8] = {
1206        0x400001f0, 0x400001f1, 0x02214030, 0x01014010, 
1207        0x02a19020, 0x01a19021, 0x90100140, 0x01813122,
1208};
1209
1210/* 
1211    STAC 9200 pin configs for
1212    102801C0
1213    102801C1
1214*/
1215static unsigned int dell9200_d22_pin_configs[8] = {
1216        0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
1217        0x01813020, 0x02a19021, 0x90100140, 0x400001f2,
1218};
1219
1220/* 
1221    STAC 9200 pin configs for
1222    102801C4 (Dell Dimension E310)
1223    102801C5
1224    102801C7
1225    102801D9
1226    102801DA
1227    102801E3
1228*/
1229static unsigned int dell9200_d23_pin_configs[8] = {
1230        0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 
1231        0x01813020, 0x01a19021, 0x90100140, 0x400001f2, 
1232};
1233
1234
1235/* 
1236    STAC 9200-32 pin configs for
1237    102801B5 (Dell Inspiron 630m)
1238    102801D8 (Dell Inspiron 640m)
1239*/
1240static unsigned int dell9200_m21_pin_configs[8] = {
1241        0x40c003fa, 0x03441340, 0x0321121f, 0x90170310,
1242        0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd,
1243};
1244
1245/* 
1246    STAC 9200-32 pin configs for
1247    102801C2 (Dell Latitude D620)
1248    102801C8 
1249    102801CC (Dell Latitude D820)
1250    102801D4 
1251    102801D6 
1252*/
1253static unsigned int dell9200_m22_pin_configs[8] = {
1254        0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310, 
1255        0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc,
1256};
1257
1258/* 
1259    STAC 9200-32 pin configs for
1260    102801CE (Dell XPS M1710)
1261    102801CF (Dell Precision M90)
1262*/
1263static unsigned int dell9200_m23_pin_configs[8] = {
1264        0x40c003fa, 0x01441340, 0x0421421f, 0x90170310,
1265        0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc,
1266};
1267
1268/*
1269    STAC 9200-32 pin configs for 
1270    102801C9
1271    102801CA
1272    102801CB (Dell Latitude 120L)
1273    102801D3
1274*/
1275static unsigned int dell9200_m24_pin_configs[8] = {
1276        0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310, 
1277        0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe, 
1278};
1279
1280/*
1281    STAC 9200-32 pin configs for
1282    102801BD (Dell Inspiron E1505n)
1283    102801EE
1284    102801EF
1285*/
1286static unsigned int dell9200_m25_pin_configs[8] = {
1287        0x40c003fa, 0x01441340, 0x0421121f, 0x90170310, 
1288        0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd,
1289};
1290
1291/*
1292    STAC 9200-32 pin configs for
1293    102801F5 (Dell Inspiron 1501)
1294    102801F6
1295*/
1296static unsigned int dell9200_m26_pin_configs[8] = {
1297        0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310, 
1298        0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe,
1299};
1300
1301/*
1302    STAC 9200-32
1303    102801CD (Dell Inspiron E1705/9400)
1304*/
1305static unsigned int dell9200_m27_pin_configs[8] = {
1306        0x40c003fa, 0x01441340, 0x0421121f, 0x90170310,
1307        0x90170310, 0x04a11020, 0x90170310, 0x40f003fc,
1308};
1309
1310static unsigned int oqo9200_pin_configs[8] = {
1311        0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210,
1312        0x90170111, 0x90a70120, 0x400000f2, 0x400000f3,
1313};
1314
1315
1316static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = {
1317        [STAC_REF] = ref9200_pin_configs,
1318        [STAC_9200_OQO] = oqo9200_pin_configs,
1319        [STAC_9200_DELL_D21] = dell9200_d21_pin_configs,
1320        [STAC_9200_DELL_D22] = dell9200_d22_pin_configs,
1321        [STAC_9200_DELL_D23] = dell9200_d23_pin_configs,
1322        [STAC_9200_DELL_M21] = dell9200_m21_pin_configs,
1323        [STAC_9200_DELL_M22] = dell9200_m22_pin_configs,
1324        [STAC_9200_DELL_M23] = dell9200_m23_pin_configs,
1325        [STAC_9200_DELL_M24] = dell9200_m24_pin_configs,
1326        [STAC_9200_DELL_M25] = dell9200_m25_pin_configs,
1327        [STAC_9200_DELL_M26] = dell9200_m26_pin_configs,
1328        [STAC_9200_DELL_M27] = dell9200_m27_pin_configs,
1329        [STAC_9200_M4] = gateway9200_m4_pin_configs,
1330        [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs,
1331        [STAC_9200_PANASONIC] = ref9200_pin_configs,
1332};
1333
1334static const char * const stac9200_models[STAC_9200_MODELS] = {
1335        [STAC_AUTO] = "auto",
1336        [STAC_REF] = "ref",
1337        [STAC_9200_OQO] = "oqo",
1338        [STAC_9200_DELL_D21] = "dell-d21",
1339        [STAC_9200_DELL_D22] = "dell-d22",
1340        [STAC_9200_DELL_D23] = "dell-d23",
1341        [STAC_9200_DELL_M21] = "dell-m21",
1342        [STAC_9200_DELL_M22] = "dell-m22",
1343        [STAC_9200_DELL_M23] = "dell-m23",
1344        [STAC_9200_DELL_M24] = "dell-m24",
1345        [STAC_9200_DELL_M25] = "dell-m25",
1346        [STAC_9200_DELL_M26] = "dell-m26",
1347        [STAC_9200_DELL_M27] = "dell-m27",
1348        [STAC_9200_M4] = "gateway-m4",
1349        [STAC_9200_M4_2] = "gateway-m4-2",
1350        [STAC_9200_PANASONIC] = "panasonic",
1351};
1352
1353static struct snd_pci_quirk stac9200_cfg_tbl[] = {
1354        /* SigmaTel reference board */
1355        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1356                      "DFI LanParty", STAC_REF),
1357        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1358                      "DFI LanParty", STAC_REF),
1359        /* Dell laptops have BIOS problem */
1360        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8,
1361                      "unknown Dell", STAC_9200_DELL_D21),
1362        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5,
1363                      "Dell Inspiron 630m", STAC_9200_DELL_M21),
1364        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd,
1365                      "Dell Inspiron E1505n", STAC_9200_DELL_M25),
1366        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0,
1367                      "unknown Dell", STAC_9200_DELL_D22),
1368        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1,
1369                      "unknown Dell", STAC_9200_DELL_D22),
1370        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2,
1371                      "Dell Latitude D620", STAC_9200_DELL_M22),
1372        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5,
1373                      "unknown Dell", STAC_9200_DELL_D23),
1374        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7,
1375                      "unknown Dell", STAC_9200_DELL_D23),
1376        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8,
1377                      "unknown Dell", STAC_9200_DELL_M22),
1378        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9,
1379                      "unknown Dell", STAC_9200_DELL_M24),
1380        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca,
1381                      "unknown Dell", STAC_9200_DELL_M24),
1382        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb,
1383                      "Dell Latitude 120L", STAC_9200_DELL_M24),
1384        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc,
1385                      "Dell Latitude D820", STAC_9200_DELL_M22),
1386        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd,
1387                      "Dell Inspiron E1705/9400", STAC_9200_DELL_M27),
1388        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce,
1389                      "Dell XPS M1710", STAC_9200_DELL_M23),
1390        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf,
1391                      "Dell Precision M90", STAC_9200_DELL_M23),
1392        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3,
1393                      "unknown Dell", STAC_9200_DELL_M22),
1394        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4,
1395                      "unknown Dell", STAC_9200_DELL_M22),
1396        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6,
1397                      "unknown Dell", STAC_9200_DELL_M22),
1398        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8,
1399                      "Dell Inspiron 640m", STAC_9200_DELL_M21),
1400        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9,
1401                      "unknown Dell", STAC_9200_DELL_D23),
1402        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da,
1403                      "unknown Dell", STAC_9200_DELL_D23),
1404        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de,
1405                      "unknown Dell", STAC_9200_DELL_D21),
1406        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3,
1407                      "unknown Dell", STAC_9200_DELL_D23),
1408        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8,
1409                      "unknown Dell", STAC_9200_DELL_D21),
1410        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee,
1411                      "unknown Dell", STAC_9200_DELL_M25),
1412        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef,
1413                      "unknown Dell", STAC_9200_DELL_M25),
1414        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5,
1415                      "Dell Inspiron 1501", STAC_9200_DELL_M26),
1416        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6,
1417                      "unknown Dell", STAC_9200_DELL_M26),
1418        /* Panasonic */
1419        SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC),
1420        /* Gateway machines needs EAPD to be set on resume */
1421        SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4),
1422        SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2),
1423        SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2),
1424        /* OQO Mobile */
1425        SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO),
1426        {} /* terminator */
1427};
1428
1429static unsigned int ref925x_pin_configs[8] = {
1430        0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021,
1431        0x90a70320, 0x02214210, 0x01019020, 0x9033032e,
1432};
1433
1434static unsigned int stac925xM1_pin_configs[8] = {
1435        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1436        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1437};
1438
1439static unsigned int stac925xM1_2_pin_configs[8] = {
1440        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1441        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1442};
1443
1444static unsigned int stac925xM2_pin_configs[8] = {
1445        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1446        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1447};
1448
1449static unsigned int stac925xM2_2_pin_configs[8] = {
1450        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1451        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1452};
1453
1454static unsigned int stac925xM3_pin_configs[8] = {
1455        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1456        0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3,
1457};
1458
1459static unsigned int stac925xM5_pin_configs[8] = {
1460        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1461        0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e,
1462};
1463
1464static unsigned int stac925xM6_pin_configs[8] = {
1465        0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020,
1466        0x40a000f0, 0x90100210, 0x400003f1, 0x90330320,
1467};
1468
1469static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = {
1470        [STAC_REF] = ref925x_pin_configs,
1471        [STAC_M1] = stac925xM1_pin_configs,
1472        [STAC_M1_2] = stac925xM1_2_pin_configs,
1473        [STAC_M2] = stac925xM2_pin_configs,
1474        [STAC_M2_2] = stac925xM2_2_pin_configs,
1475        [STAC_M3] = stac925xM3_pin_configs,
1476        [STAC_M5] = stac925xM5_pin_configs,
1477        [STAC_M6] = stac925xM6_pin_configs,
1478};
1479
1480static const char * const stac925x_models[STAC_925x_MODELS] = {
1481        [STAC_925x_AUTO] = "auto",
1482        [STAC_REF] = "ref",
1483        [STAC_M1] = "m1",
1484        [STAC_M1_2] = "m1-2",
1485        [STAC_M2] = "m2",
1486        [STAC_M2_2] = "m2-2",
1487        [STAC_M3] = "m3",
1488        [STAC_M5] = "m5",
1489        [STAC_M6] = "m6",
1490};
1491
1492static struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = {
1493        SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2),
1494        SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5),
1495        SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1),
1496        SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2),
1497        SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2),
1498        /* Not sure about the brand name for those */
1499        SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1),
1500        SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3),
1501        SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6),
1502        SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2),
1503        {} /* terminator */
1504};
1505
1506static struct snd_pci_quirk stac925x_cfg_tbl[] = {
1507        /* SigmaTel reference board */
1508        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF),
1509        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF),
1510        SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF),
1511
1512        /* Default table for unknown ID */
1513        SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2),
1514
1515        {} /* terminator */
1516};
1517
1518static unsigned int ref92hd73xx_pin_configs[13] = {
1519        0x02214030, 0x02a19040, 0x01a19020, 0x02214030,
1520        0x0181302e, 0x01014010, 0x01014020, 0x01014030,
1521        0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050,
1522        0x01452050,
1523};
1524
1525static unsigned int dell_m6_pin_configs[13] = {
1526        0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110,
1527        0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0,
1528        0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1529        0x4f0000f0,
1530};
1531
1532static unsigned int alienware_m17x_pin_configs[13] = {
1533        0x0321101f, 0x0321101f, 0x03a11020, 0x03014020,
1534        0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0,
1535        0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0,
1536        0x904601b0,
1537};
1538
1539static unsigned int intel_dg45id_pin_configs[13] = {
1540        0x02214230, 0x02A19240, 0x01013214, 0x01014210,
1541        0x01A19250, 0x01011212, 0x01016211
1542};
1543
1544static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = {
1545        [STAC_92HD73XX_REF]     = ref92hd73xx_pin_configs,
1546        [STAC_DELL_M6_AMIC]     = dell_m6_pin_configs,
1547        [STAC_DELL_M6_DMIC]     = dell_m6_pin_configs,
1548        [STAC_DELL_M6_BOTH]     = dell_m6_pin_configs,
1549        [STAC_DELL_EQ]  = dell_m6_pin_configs,
1550        [STAC_ALIENWARE_M17X]   = alienware_m17x_pin_configs,
1551        [STAC_92HD73XX_INTEL]   = intel_dg45id_pin_configs,
1552};
1553
1554static const char * const stac92hd73xx_models[STAC_92HD73XX_MODELS] = {
1555        [STAC_92HD73XX_AUTO] = "auto",
1556        [STAC_92HD73XX_NO_JD] = "no-jd",
1557        [STAC_92HD73XX_REF] = "ref",
1558        [STAC_92HD73XX_INTEL] = "intel",
1559        [STAC_DELL_M6_AMIC] = "dell-m6-amic",
1560        [STAC_DELL_M6_DMIC] = "dell-m6-dmic",
1561        [STAC_DELL_M6_BOTH] = "dell-m6",
1562        [STAC_DELL_EQ] = "dell-eq",
1563        [STAC_ALIENWARE_M17X] = "alienware",
1564};
1565
1566static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = {
1567        /* SigmaTel reference board */
1568        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1569                                "DFI LanParty", STAC_92HD73XX_REF),
1570        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1571                                "DFI LanParty", STAC_92HD73XX_REF),
1572        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002,
1573                                "Intel DG45ID", STAC_92HD73XX_INTEL),
1574        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003,
1575                                "Intel DG45FC", STAC_92HD73XX_INTEL),
1576        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254,
1577                                "Dell Studio 1535", STAC_DELL_M6_DMIC),
1578        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255,
1579                                "unknown Dell", STAC_DELL_M6_DMIC),
1580        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256,
1581                                "unknown Dell", STAC_DELL_M6_BOTH),
1582        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257,
1583                                "unknown Dell", STAC_DELL_M6_BOTH),
1584        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e,
1585                                "unknown Dell", STAC_DELL_M6_AMIC),
1586        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f,
1587                                "unknown Dell", STAC_DELL_M6_AMIC),
1588        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271,
1589                                "unknown Dell", STAC_DELL_M6_DMIC),
1590        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272,
1591                                "unknown Dell", STAC_DELL_M6_DMIC),
1592        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f,
1593                                "Dell Studio 1537", STAC_DELL_M6_DMIC),
1594        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0,
1595                                "Dell Studio 17", STAC_DELL_M6_DMIC),
1596        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be,
1597                                "Dell Studio 1555", STAC_DELL_M6_DMIC),
1598        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd,
1599                                "Dell Studio 1557", STAC_DELL_M6_DMIC),
1600        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe,
1601                                "Dell Studio XPS 1645", STAC_DELL_M6_BOTH),
1602        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413,
1603                                "Dell Studio 1558", STAC_DELL_M6_BOTH),
1604        {} /* terminator */
1605};
1606
1607static struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = {
1608        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1,
1609                      "Alienware M17x", STAC_ALIENWARE_M17X),
1610        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a,
1611                      "Alienware M17x", STAC_ALIENWARE_M17X),
1612        {} /* terminator */
1613};
1614
1615static unsigned int ref92hd83xxx_pin_configs[10] = {
1616        0x02214030, 0x02211010, 0x02a19020, 0x02170130,
1617        0x01014050, 0x01819040, 0x01014020, 0x90a3014e,
1618        0x01451160, 0x98560170,
1619};
1620
1621static unsigned int dell_s14_pin_configs[10] = {
1622        0x0221403f, 0x0221101f, 0x02a19020, 0x90170110,
1623        0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160,
1624        0x40f000f0, 0x40f000f0,
1625};
1626
1627static unsigned int hp_dv7_4000_pin_configs[10] = {
1628        0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110,
1629        0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140,
1630        0x40f000f0, 0x40f000f0,
1631};
1632
1633static unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = {
1634        [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs,
1635        [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs,
1636        [STAC_DELL_S14] = dell_s14_pin_configs,
1637        [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs,
1638};
1639
1640static const char * const stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = {
1641        [STAC_92HD83XXX_AUTO] = "auto",
1642        [STAC_92HD83XXX_REF] = "ref",
1643        [STAC_92HD83XXX_PWR_REF] = "mic-ref",
1644        [STAC_DELL_S14] = "dell-s14",
1645        [STAC_92HD83XXX_HP] = "hp",
1646        [STAC_HP_DV7_4000] = "hp-dv7-4000",
1647};
1648
1649static struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = {
1650        /* SigmaTel reference board */
1651        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1652                      "DFI LanParty", STAC_92HD83XXX_REF),
1653        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1654                      "DFI LanParty", STAC_92HD83XXX_REF),
1655        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba,
1656                      "unknown Dell", STAC_DELL_S14),
1657        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xff00, 0x3600,
1658                      "HP", STAC_92HD83XXX_HP),
1659        {} /* terminator */
1660};
1661
1662static unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1663        0x02214030, 0x02a19040, 0x01a19020, 0x01014010,
1664        0x0181302e, 0x01014010, 0x01019020, 0x90a000f0,
1665        0x90a000f0, 0x01452050, 0x01452050, 0x00000000,
1666        0x00000000
1667};
1668
1669static unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1670        0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110,
1671        0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0,
1672        0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000,
1673        0x00000000
1674};
1675
1676static unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1677        0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1678        0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0,
1679        0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1680        0x00000000
1681};
1682
1683static unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = {
1684        0x0421101f, 0x04a11221, 0x90a70330, 0x90170110,
1685        0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0,
1686        0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000,
1687        0x00000000
1688};
1689
1690static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = {
1691        [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs,
1692        [STAC_DELL_M4_1]        = dell_m4_1_pin_configs,
1693        [STAC_DELL_M4_2]        = dell_m4_2_pin_configs,
1694        [STAC_DELL_M4_3]        = dell_m4_3_pin_configs,
1695        [STAC_HP_M4]            = NULL,
1696        [STAC_HP_DV4]           = NULL,
1697        [STAC_HP_DV5]           = NULL,
1698        [STAC_HP_HDX]           = NULL,
1699        [STAC_HP_DV4_1222NR]    = NULL,
1700};
1701
1702static const char * const stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = {
1703        [STAC_92HD71BXX_AUTO] = "auto",
1704        [STAC_92HD71BXX_REF] = "ref",
1705        [STAC_DELL_M4_1] = "dell-m4-1",
1706        [STAC_DELL_M4_2] = "dell-m4-2",
1707        [STAC_DELL_M4_3] = "dell-m4-3",
1708        [STAC_HP_M4] = "hp-m4",
1709        [STAC_HP_DV4] = "hp-dv4",
1710        [STAC_HP_DV5] = "hp-dv5",
1711        [STAC_HP_HDX] = "hp-hdx",
1712        [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr",
1713};
1714
1715static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = {
1716        /* SigmaTel reference board */
1717        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1718                      "DFI LanParty", STAC_92HD71BXX_REF),
1719        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1720                      "DFI LanParty", STAC_92HD71BXX_REF),
1721        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb,
1722                      "HP dv4-1222nr", STAC_HP_DV4_1222NR),
1723        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720,
1724                          "HP", STAC_HP_DV5),
1725        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080,
1726                      "HP", STAC_HP_DV5),
1727        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0,
1728                      "HP dv4-7", STAC_HP_DV4),
1729        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600,
1730                      "HP dv4-7", STAC_HP_DV5),
1731        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610,
1732                      "HP HDX", STAC_HP_HDX),  /* HDX18 */
1733        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a,
1734                      "HP mini 1000", STAC_HP_M4),
1735        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b,
1736                      "HP HDX", STAC_HP_HDX),  /* HDX16 */
1737        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620,
1738                      "HP dv6", STAC_HP_DV5),
1739        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061,
1740                      "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */
1741        SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e,
1742                      "HP DV6", STAC_HP_DV5),
1743        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010,
1744                      "HP", STAC_HP_DV5),
1745        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233,
1746                                "unknown Dell", STAC_DELL_M4_1),
1747        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234,
1748                                "unknown Dell", STAC_DELL_M4_1),
1749        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250,
1750                                "unknown Dell", STAC_DELL_M4_1),
1751        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f,
1752                                "unknown Dell", STAC_DELL_M4_1),
1753        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d,
1754                                "unknown Dell", STAC_DELL_M4_1),
1755        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251,
1756                                "unknown Dell", STAC_DELL_M4_1),
1757        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277,
1758                                "unknown Dell", STAC_DELL_M4_1),
1759        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263,
1760                                "unknown Dell", STAC_DELL_M4_2),
1761        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265,
1762                                "unknown Dell", STAC_DELL_M4_2),
1763        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262,
1764                                "unknown Dell", STAC_DELL_M4_2),
1765        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264,
1766                                "unknown Dell", STAC_DELL_M4_2),
1767        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa,
1768                                "unknown Dell", STAC_DELL_M4_3),
1769        {} /* terminator */
1770};
1771
1772static unsigned int ref922x_pin_configs[10] = {
1773        0x01014010, 0x01016011, 0x01012012, 0x0221401f,
1774        0x01813122, 0x01011014, 0x01441030, 0x01c41030,
1775        0x40000100, 0x40000100,
1776};
1777
1778/*
1779    STAC 922X pin configs for
1780    102801A7
1781    102801AB
1782    102801A9
1783    102801D1
1784    102801D2
1785*/
1786static unsigned int dell_922x_d81_pin_configs[10] = {
1787        0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1788        0x02a19020, 0x01117011, 0x400001f0, 0x400001f1,
1789        0x01813122, 0x400001f2,
1790};
1791
1792/*
1793    STAC 922X pin configs for
1794    102801AC
1795    102801D0
1796*/
1797static unsigned int dell_922x_d82_pin_configs[10] = {
1798        0x02214030, 0x01a19021, 0x01111012, 0x01114010,
1799        0x02a19020, 0x01117011, 0x01451140, 0x400001f0,
1800        0x01813122, 0x400001f1,
1801};
1802
1803/*
1804    STAC 922X pin configs for
1805    102801BF
1806*/
1807static unsigned int dell_922x_m81_pin_configs[10] = {
1808        0x0321101f, 0x01112024, 0x01111222, 0x91174220,
1809        0x03a11050, 0x01116221, 0x90a70330, 0x01452340, 
1810        0x40C003f1, 0x405003f0,
1811};
1812
1813/*
1814    STAC 9221 A1 pin configs for
1815    102801D7 (Dell XPS M1210)
1816*/
1817static unsigned int dell_922x_m82_pin_configs[10] = {
1818        0x02211211, 0x408103ff, 0x02a1123e, 0x90100310, 
1819        0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2, 
1820        0x508003f3, 0x405003f4, 
1821};
1822
1823static unsigned int d945gtp3_pin_configs[10] = {
1824        0x0221401f, 0x01a19022, 0x01813021, 0x01014010,
1825        0x40000100, 0x40000100, 0x40000100, 0x40000100,
1826        0x02a19120, 0x40000100,
1827};
1828
1829static unsigned int d945gtp5_pin_configs[10] = {
1830        0x0221401f, 0x01011012, 0x01813024, 0x01014010,
1831        0x01a19021, 0x01016011, 0x01452130, 0x40000100,
1832        0x02a19320, 0x40000100,
1833};
1834
1835static unsigned int intel_mac_v1_pin_configs[10] = {
1836        0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd,
1837        0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240,
1838        0x400000fc, 0x400000fb,
1839};
1840
1841static unsigned int intel_mac_v2_pin_configs[10] = {
1842        0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1843        0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa,
1844        0x400000fc, 0x400000fb,
1845};
1846
1847static unsigned int intel_mac_v3_pin_configs[10] = {
1848        0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd,
1849        0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240,
1850        0x400000fc, 0x400000fb,
1851};
1852
1853static unsigned int intel_mac_v4_pin_configs[10] = {
1854        0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1855        0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1856        0x400000fc, 0x400000fb,
1857};
1858
1859static unsigned int intel_mac_v5_pin_configs[10] = {
1860        0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f,
1861        0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240,
1862        0x400000fc, 0x400000fb,
1863};
1864
1865static unsigned int ecs202_pin_configs[10] = {
1866        0x0221401f, 0x02a19020, 0x01a19020, 0x01114010,
1867        0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1,
1868        0x9037012e, 0x40e000f2,
1869};
1870
1871static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = {
1872        [STAC_D945_REF] = ref922x_pin_configs,
1873        [STAC_D945GTP3] = d945gtp3_pin_configs,
1874        [STAC_D945GTP5] = d945gtp5_pin_configs,
1875        [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs,
1876        [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs,
1877        [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs,
1878        [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs,
1879        [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs,
1880        [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs,
1881        /* for backward compatibility */
1882        [STAC_MACMINI] = intel_mac_v3_pin_configs,
1883        [STAC_MACBOOK] = intel_mac_v5_pin_configs,
1884        [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs,
1885        [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs,
1886        [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs,
1887        [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs,
1888        [STAC_ECS_202] = ecs202_pin_configs,
1889        [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs,
1890        [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs,       
1891        [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs,
1892        [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs,       
1893};
1894
1895static const char * const stac922x_models[STAC_922X_MODELS] = {
1896        [STAC_922X_AUTO] = "auto",
1897        [STAC_D945_REF] = "ref",
1898        [STAC_D945GTP5] = "5stack",
1899        [STAC_D945GTP3] = "3stack",
1900        [STAC_INTEL_MAC_V1] = "intel-mac-v1",
1901        [STAC_INTEL_MAC_V2] = "intel-mac-v2",
1902        [STAC_INTEL_MAC_V3] = "intel-mac-v3",
1903        [STAC_INTEL_MAC_V4] = "intel-mac-v4",
1904        [STAC_INTEL_MAC_V5] = "intel-mac-v5",
1905        [STAC_INTEL_MAC_AUTO] = "intel-mac-auto",
1906        /* for backward compatibility */
1907        [STAC_MACMINI]  = "macmini",
1908        [STAC_MACBOOK]  = "macbook",
1909        [STAC_MACBOOK_PRO_V1]   = "macbook-pro-v1",
1910        [STAC_MACBOOK_PRO_V2]   = "macbook-pro",
1911        [STAC_IMAC_INTEL] = "imac-intel",
1912        [STAC_IMAC_INTEL_20] = "imac-intel-20",
1913        [STAC_ECS_202] = "ecs202",
1914        [STAC_922X_DELL_D81] = "dell-d81",
1915        [STAC_922X_DELL_D82] = "dell-d82",
1916        [STAC_922X_DELL_M81] = "dell-m81",
1917        [STAC_922X_DELL_M82] = "dell-m82",
1918};
1919
1920static struct snd_pci_quirk stac922x_cfg_tbl[] = {
1921        /* SigmaTel reference board */
1922        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
1923                      "DFI LanParty", STAC_D945_REF),
1924        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
1925                      "DFI LanParty", STAC_D945_REF),
1926        /* Intel 945G based systems */
1927        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101,
1928                      "Intel D945G", STAC_D945GTP3),
1929        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202,
1930                      "Intel D945G", STAC_D945GTP3),
1931        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606,
1932                      "Intel D945G", STAC_D945GTP3),
1933        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601,
1934                      "Intel D945G", STAC_D945GTP3),
1935        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111,
1936                      "Intel D945G", STAC_D945GTP3),
1937        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115,
1938                      "Intel D945G", STAC_D945GTP3),
1939        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116,
1940                      "Intel D945G", STAC_D945GTP3),
1941        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117,
1942                      "Intel D945G", STAC_D945GTP3),
1943        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118,
1944                      "Intel D945G", STAC_D945GTP3),
1945        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119,
1946                      "Intel D945G", STAC_D945GTP3),
1947        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826,
1948                      "Intel D945G", STAC_D945GTP3),
1949        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049,
1950                      "Intel D945G", STAC_D945GTP3),
1951        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055,
1952                      "Intel D945G", STAC_D945GTP3),
1953        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048,
1954                      "Intel D945G", STAC_D945GTP3),
1955        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110,
1956                      "Intel D945G", STAC_D945GTP3),
1957        /* Intel D945G 5-stack systems */
1958        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404,
1959                      "Intel D945G", STAC_D945GTP5),
1960        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303,
1961                      "Intel D945G", STAC_D945GTP5),
1962        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013,
1963                      "Intel D945G", STAC_D945GTP5),
1964        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417,
1965                      "Intel D945G", STAC_D945GTP5),
1966        /* Intel 945P based systems */
1967        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b,
1968                      "Intel D945P", STAC_D945GTP3),
1969        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112,
1970                      "Intel D945P", STAC_D945GTP3),
1971        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d,
1972                      "Intel D945P", STAC_D945GTP3),
1973        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909,
1974                      "Intel D945P", STAC_D945GTP3),
1975        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505,
1976                      "Intel D945P", STAC_D945GTP3),
1977        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707,
1978                      "Intel D945P", STAC_D945GTP5),
1979        /* other intel */
1980        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204,
1981                      "Intel D945", STAC_D945_REF),
1982        /* other systems  */
1983        /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */
1984        SND_PCI_QUIRK(0x8384, 0x7680,
1985                      "Mac", STAC_INTEL_MAC_AUTO),
1986        /* Dell systems  */
1987        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7,
1988                      "unknown Dell", STAC_922X_DELL_D81),
1989        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9,
1990                      "unknown Dell", STAC_922X_DELL_D81),
1991        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab,
1992                      "unknown Dell", STAC_922X_DELL_D81),
1993        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac,
1994                      "unknown Dell", STAC_922X_DELL_D82),
1995        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf,
1996                      "unknown Dell", STAC_922X_DELL_M81),
1997        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0,
1998                      "unknown Dell", STAC_922X_DELL_D82),
1999        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1,
2000                      "unknown Dell", STAC_922X_DELL_D81),
2001        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2,
2002                      "unknown Dell", STAC_922X_DELL_D81),
2003        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7,
2004                      "Dell XPS M1210", STAC_922X_DELL_M82),
2005        /* ECS/PC Chips boards */
2006        SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000,
2007                      "ECS/PC chips", STAC_ECS_202),
2008        {} /* terminator */
2009};
2010
2011static unsigned int ref927x_pin_configs[14] = {
2012        0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2013        0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 
2014        0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070,
2015        0x01c42190, 0x40000100,
2016};
2017
2018static unsigned int d965_3st_pin_configs[14] = {
2019        0x0221401f, 0x02a19120, 0x40000100, 0x01014011,
2020        0x01a19021, 0x01813024, 0x40000100, 0x40000100,
2021        0x40000100, 0x40000100, 0x40000100, 0x40000100,
2022        0x40000100, 0x40000100
2023};
2024
2025static unsigned int d965_5st_pin_configs[14] = {
2026        0x02214020, 0x02a19080, 0x0181304e, 0x01014010,
2027        0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2028        0x40000100, 0x40000100, 0x40000100, 0x01442070,
2029        0x40000100, 0x40000100
2030};
2031
2032static unsigned int d965_5st_no_fp_pin_configs[14] = {
2033        0x40000100, 0x40000100, 0x0181304e, 0x01014010,
2034        0x01a19040, 0x01011012, 0x01016011, 0x40000100,
2035        0x40000100, 0x40000100, 0x40000100, 0x01442070,
2036        0x40000100, 0x40000100
2037};
2038
2039static unsigned int dell_3st_pin_configs[14] = {
2040        0x02211230, 0x02a11220, 0x01a19040, 0x01114210,
2041        0x01111212, 0x01116211, 0x01813050, 0x01112214,
2042        0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb,
2043        0x40c003fc, 0x40000100
2044};
2045
2046static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = {
2047        [STAC_D965_REF_NO_JD] = ref927x_pin_configs,
2048        [STAC_D965_REF]  = ref927x_pin_configs,
2049        [STAC_D965_3ST]  = d965_3st_pin_configs,
2050        [STAC_D965_5ST]  = d965_5st_pin_configs,
2051        [STAC_D965_5ST_NO_FP]  = d965_5st_no_fp_pin_configs,
2052        [STAC_DELL_3ST]  = dell_3st_pin_configs,
2053        [STAC_DELL_BIOS] = NULL,
2054        [STAC_927X_VOLKNOB] = NULL,
2055};
2056
2057static const char * const stac927x_models[STAC_927X_MODELS] = {
2058        [STAC_927X_AUTO]        = "auto",
2059        [STAC_D965_REF_NO_JD]   = "ref-no-jd",
2060        [STAC_D965_REF]         = "ref",
2061        [STAC_D965_3ST]         = "3stack",
2062        [STAC_D965_5ST]         = "5stack",
2063        [STAC_D965_5ST_NO_FP]   = "5stack-no-fp",
2064        [STAC_DELL_3ST]         = "dell-3stack",
2065        [STAC_DELL_BIOS]        = "dell-bios",
2066        [STAC_927X_VOLKNOB]     = "volknob",
2067};
2068
2069static struct snd_pci_quirk stac927x_cfg_tbl[] = {
2070        /* SigmaTel reference board */
2071        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2072                      "DFI LanParty", STAC_D965_REF),
2073        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2074                      "DFI LanParty", STAC_D965_REF),
2075         /* Intel 946 based systems */
2076        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST),
2077        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST),
2078        /* 965 based 3 stack systems */
2079        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100,
2080                           "Intel D965", STAC_D965_3ST),
2081        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000,
2082                           "Intel D965", STAC_D965_3ST),
2083        /* Dell 3 stack systems */
2084        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01dd, "Dell Dimension E520", STAC_DELL_3ST),
2085        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01ed, "Dell     ", STAC_DELL_3ST),
2086        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f4, "Dell     ", STAC_DELL_3ST),
2087        /* Dell 3 stack systems with verb table in BIOS */
2088        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS),
2089        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x01f7, "Dell XPS M1730", STAC_DELL_BIOS),
2090        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0227, "Dell Vostro 1400  ", STAC_DELL_BIOS),
2091        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022e, "Dell     ", STAC_DELL_BIOS),
2092        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS),
2093        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0242, "Dell     ", STAC_DELL_BIOS),
2094        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0243, "Dell     ", STAC_DELL_BIOS),
2095        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x02ff, "Dell     ", STAC_DELL_BIOS),
2096        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL,  0x0209, "Dell XPS 1330", STAC_DELL_BIOS),
2097        /* 965 based 5 stack systems */
2098        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300,
2099                           "Intel D965", STAC_D965_5ST),
2100        SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500,
2101                           "Intel D965", STAC_D965_5ST),
2102        /* volume-knob fixes */
2103        SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB),
2104        {} /* terminator */
2105};
2106
2107static unsigned int ref9205_pin_configs[12] = {
2108        0x40000100, 0x40000100, 0x01016011, 0x01014010,
2109        0x01813122, 0x01a19021, 0x01019020, 0x40000100,
2110        0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030
2111};
2112
2113/*
2114    STAC 9205 pin configs for
2115    102801F1
2116    102801F2
2117    102801FC
2118    102801FD
2119    10280204
2120    1028021F
2121    10280228 (Dell Vostro 1500)
2122    10280229 (Dell Vostro 1700)
2123*/
2124static unsigned int dell_9205_m42_pin_configs[12] = {
2125        0x0321101F, 0x03A11020, 0x400003FA, 0x90170310,
2126        0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9,
2127        0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE,
2128};
2129
2130/*
2131    STAC 9205 pin configs for
2132    102801F9
2133    102801FA
2134    102801FE
2135    102801FF (Dell Precision M4300)
2136    10280206
2137    10280200
2138    10280201
2139*/
2140static unsigned int dell_9205_m43_pin_configs[12] = {
2141        0x0321101f, 0x03a11020, 0x90a70330, 0x90170310,
2142        0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9,
2143        0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8,
2144};
2145
2146static unsigned int dell_9205_m44_pin_configs[12] = {
2147        0x0421101f, 0x04a11020, 0x400003fa, 0x90170310,
2148        0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9,
2149        0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe,
2150};
2151
2152static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = {
2153        [STAC_9205_REF] = ref9205_pin_configs,
2154        [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs,
2155        [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs,
2156        [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs,
2157        [STAC_9205_EAPD] = NULL,
2158};
2159
2160static const char * const stac9205_models[STAC_9205_MODELS] = {
2161        [STAC_9205_AUTO] = "auto",
2162        [STAC_9205_REF] = "ref",
2163        [STAC_9205_DELL_M42] = "dell-m42",
2164        [STAC_9205_DELL_M43] = "dell-m43",
2165        [STAC_9205_DELL_M44] = "dell-m44",
2166        [STAC_9205_EAPD] = "eapd",
2167};
2168
2169static struct snd_pci_quirk stac9205_cfg_tbl[] = {
2170        /* SigmaTel reference board */
2171        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668,
2172                      "DFI LanParty", STAC_9205_REF),
2173        SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30,
2174                      "SigmaTel", STAC_9205_REF),
2175        SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101,
2176                      "DFI LanParty", STAC_9205_REF),
2177        /* Dell */
2178        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1,
2179                      "unknown Dell", STAC_9205_DELL_M42),
2180        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2,
2181                      "unknown Dell", STAC_9205_DELL_M42),
2182        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8,
2183                      "Dell Precision", STAC_9205_DELL_M43),
2184        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9,
2185                      "Dell Precision", STAC_9205_DELL_M43),
2186        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa,
2187                      "Dell Precision", STAC_9205_DELL_M43),
2188        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc,
2189                      "unknown Dell", STAC_9205_DELL_M42),
2190        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd,
2191                      "unknown Dell", STAC_9205_DELL_M42),
2192        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe,
2193                      "Dell Precision", STAC_9205_DELL_M43),
2194        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff,
2195                      "Dell Precision M4300", STAC_9205_DELL_M43),
2196        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204,
2197                      "unknown Dell", STAC_9205_DELL_M42),
2198        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206,
2199                      "Dell Precision", STAC_9205_DELL_M43),
2200        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b,
2201                      "Dell Precision", STAC_9205_DELL_M43),
2202        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c,
2203                      "Dell Precision", STAC_9205_DELL_M43),
2204        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f,
2205                      "Dell Inspiron", STAC_9205_DELL_M44),
2206        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228,
2207                      "Dell Vostro 1500", STAC_9205_DELL_M42),
2208        SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229,
2209                      "Dell Vostro 1700", STAC_9205_DELL_M42),
2210        /* Gateway */
2211        SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD),
2212        SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD),
2213        {} /* terminator */
2214};
2215
2216static void stac92xx_set_config_regs(struct hda_codec *codec,
2217                                     unsigned int *pincfgs)
2218{
2219        int i;
2220        struct sigmatel_spec *spec = codec->spec;
2221
2222        if (!pincfgs)
2223                return;
2224
2225        for (i = 0; i < spec->num_pins; i++)
2226                if (spec->pin_nids[i] && pincfgs[i])
2227                        snd_hda_codec_set_pincfg(codec, spec->pin_nids[i],
2228                                                 pincfgs[i]);
2229}
2230
2231/*
2232 * Analog playback callbacks
2233 */
2234static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo,
2235                                      struct hda_codec *codec,
2236                                      struct snd_pcm_substream *substream)
2237{
2238        struct sigmatel_spec *spec = codec->spec;
2239        if (spec->stream_delay)
2240                msleep(spec->stream_delay);
2241        return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
2242                                             hinfo);
2243}
2244
2245static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2246                                         struct hda_codec *codec,
2247                                         unsigned int stream_tag,
2248                                         unsigned int format,
2249                                         struct snd_pcm_substream *substream)
2250{
2251        struct sigmatel_spec *spec = codec->spec;
2252        return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream);
2253}
2254
2255static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2256                                        struct hda_codec *codec,
2257                                        struct snd_pcm_substream *substream)
2258{
2259        struct sigmatel_spec *spec = codec->spec;
2260        return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
2261}
2262
2263/*
2264 * Digital playback callbacks
2265 */
2266static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
2267                                          struct hda_codec *codec,
2268                                          struct snd_pcm_substream *substream)
2269{
2270        struct sigmatel_spec *spec = codec->spec;
2271        return snd_hda_multi_out_dig_open(codec, &spec->multiout);
2272}
2273
2274static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
2275                                           struct hda_codec *codec,
2276                                           struct snd_pcm_substream *substream)
2277{
2278        struct sigmatel_spec *spec = codec->spec;
2279        return snd_hda_multi_out_dig_close(codec, &spec->multiout);
2280}
2281
2282static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
2283                                         struct hda_codec *codec,
2284                                         unsigned int stream_tag,
2285                                         unsigned int format,
2286                                         struct snd_pcm_substream *substream)
2287{
2288        struct sigmatel_spec *spec = codec->spec;
2289        return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
2290                                             stream_tag, format, substream);
2291}
2292
2293static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
2294                                        struct hda_codec *codec,
2295                                        struct snd_pcm_substream *substream)
2296{
2297        struct sigmatel_spec *spec = codec->spec;
2298        return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
2299}
2300
2301
2302/*
2303 * Analog capture callbacks
2304 */
2305static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
2306                                        struct hda_codec *codec,
2307                                        unsigned int stream_tag,
2308                                        unsigned int format,
2309                                        struct snd_pcm_substream *substream)
2310{
2311        struct sigmatel_spec *spec = codec->spec;
2312        hda_nid_t nid = spec->adc_nids[substream->number];
2313
2314        if (spec->powerdown_adcs) {
2315                msleep(40);
2316                snd_hda_codec_write(codec, nid, 0,
2317                        AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
2318        }
2319        snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format);
2320        return 0;
2321}
2322
2323static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
2324                                        struct hda_codec *codec,
2325                                        struct snd_pcm_substream *substream)
2326{
2327        struct sigmatel_spec *spec = codec->spec;
2328        hda_nid_t nid = spec->adc_nids[substream->number];
2329
2330        snd_hda_codec_cleanup_stream(codec, nid);
2331        if (spec->powerdown_adcs)
2332                snd_hda_codec_write(codec, nid, 0,
2333                        AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
2334        return 0;
2335}
2336
2337static struct hda_pcm_stream stac92xx_pcm_digital_playback = {
2338        .substreams = 1,
2339        .channels_min = 2,
2340        .channels_max = 2,
2341        /* NID is set in stac92xx_build_pcms */
2342        .ops = {
2343                .open = stac92xx_dig_playback_pcm_open,
2344                .close = stac92xx_dig_playback_pcm_close,
2345                .prepare = stac92xx_dig_playback_pcm_prepare,
2346                .cleanup = stac92xx_dig_playback_pcm_cleanup
2347        },
2348};
2349
2350static struct hda_pcm_stream stac92xx_pcm_digital_capture = {
2351        .substreams = 1,
2352        .channels_min = 2,
2353        .channels_max = 2,
2354        /* NID is set in stac92xx_build_pcms */
2355};
2356
2357static struct hda_pcm_stream stac92xx_pcm_analog_playback = {
2358        .substreams = 1,
2359        .channels_min = 2,
2360        .channels_max = 8,
2361        .nid = 0x02, /* NID to query formats and rates */
2362        .ops = {
2363                .open = stac92xx_playback_pcm_open,
2364                .prepare = stac92xx_playback_pcm_prepare,
2365                .cleanup = stac92xx_playback_pcm_cleanup
2366        },
2367};
2368
2369static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = {
2370        .substreams = 1,
2371        .channels_min = 2,
2372        .channels_max = 2,
2373        .nid = 0x06, /* NID to query formats and rates */
2374        .ops = {
2375                .open = stac92xx_playback_pcm_open,
2376                .prepare = stac92xx_playback_pcm_prepare,
2377                .cleanup = stac92xx_playback_pcm_cleanup
2378        },
2379};
2380
2381static struct hda_pcm_stream stac92xx_pcm_analog_capture = {
2382        .channels_min = 2,
2383        .channels_max = 2,
2384        /* NID + .substreams is set in stac92xx_build_pcms */
2385        .ops = {
2386                .prepare = stac92xx_capture_pcm_prepare,
2387                .cleanup = stac92xx_capture_pcm_cleanup
2388        },
2389};
2390
2391static int stac92xx_build_pcms(struct hda_codec *codec)
2392{
2393        struct sigmatel_spec *spec = codec->spec;
2394        struct hda_pcm *info = spec->pcm_rec;
2395
2396        codec->num_pcms = 1;
2397        codec->pcm_info = info;
2398
2399        info->name = "STAC92xx Analog";
2400        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback;
2401        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
2402                spec->multiout.dac_nids[0];
2403        info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture;
2404        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
2405        info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs;
2406
2407        if (spec->alt_switch) {
2408                codec->num_pcms++;
2409                info++;
2410                info->name = "STAC92xx Analog Alt";
2411                info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback;
2412        }
2413
2414        if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
2415                codec->num_pcms++;
2416                info++;
2417                info->name = "STAC92xx Digital";
2418                info->pcm_type = spec->autocfg.dig_out_type[0];
2419                if (spec->multiout.dig_out_nid) {
2420                        info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback;
2421                        info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
2422                }
2423                if (spec->dig_in_nid) {
2424                        info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture;
2425                        info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
2426                }
2427        }
2428
2429        return 0;
2430}
2431
2432static unsigned int stac92xx_get_default_vref(struct hda_codec *codec,
2433                                        hda_nid_t nid)
2434{
2435        unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
2436        pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
2437        if (pincap & AC_PINCAP_VREF_100)
2438                return AC_PINCTL_VREF_100;
2439        if (pincap & AC_PINCAP_VREF_80)
2440                return AC_PINCTL_VREF_80;
2441        if (pincap & AC_PINCAP_VREF_50)
2442                return AC_PINCTL_VREF_50;
2443        if (pincap & AC_PINCAP_VREF_GRD)
2444                return AC_PINCTL_VREF_GRD;
2445        return 0;
2446}
2447
2448static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type)
2449
2450{
2451        snd_hda_codec_write_cache(codec, nid, 0,
2452                                  AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type);
2453}
2454
2455#define stac92xx_hp_switch_info         snd_ctl_boolean_mono_info
2456
2457static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol,
2458                        struct snd_ctl_elem_value *ucontrol)
2459{
2460        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2461        struct sigmatel_spec *spec = codec->spec;
2462
2463        ucontrol->value.integer.value[0] = !!spec->hp_switch;
2464        return 0;
2465}
2466
2467static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid);
2468
2469static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol,
2470                        struct snd_ctl_elem_value *ucontrol)
2471{
2472        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2473        struct sigmatel_spec *spec = codec->spec;
2474        int nid = kcontrol->private_value;
2475 
2476        spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0;
2477
2478        /* check to be sure that the ports are up to date with
2479         * switch changes
2480         */
2481        stac_issue_unsol_event(codec, nid);
2482
2483        return 1;
2484}
2485
2486static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol,
2487                                struct snd_ctl_elem_info *uinfo)
2488{
2489        int i;
2490        static char *texts[] = {
2491                "Mic In", "Line In", "Line Out"
2492        };
2493
2494        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2495        struct sigmatel_spec *spec = codec->spec;
2496        hda_nid_t nid = kcontrol->private_value;
2497
2498        if (nid == spec->mic_switch || nid == spec->line_switch)
2499                i = 3;
2500        else
2501                i = 2;
2502
2503        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2504        uinfo->value.enumerated.items = i;
2505        uinfo->count = 1;
2506        if (uinfo->value.enumerated.item >= i)
2507                uinfo->value.enumerated.item = i-1;
2508        strcpy(uinfo->value.enumerated.name,
2509                texts[uinfo->value.enumerated.item]);
2510
2511        return 0;
2512}
2513
2514static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol,
2515                                struct snd_ctl_elem_value *ucontrol)
2516{
2517        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2518        hda_nid_t nid = kcontrol->private_value;
2519        unsigned int vref = stac92xx_vref_get(codec, nid);
2520
2521        if (vref == stac92xx_get_default_vref(codec, nid))
2522                ucontrol->value.enumerated.item[0] = 0;
2523        else if (vref == AC_PINCTL_VREF_GRD)
2524                ucontrol->value.enumerated.item[0] = 1;
2525        else if (vref == AC_PINCTL_VREF_HIZ)
2526                ucontrol->value.enumerated.item[0] = 2;
2527
2528        return 0;
2529}
2530
2531static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol,
2532                                struct snd_ctl_elem_value *ucontrol)
2533{
2534        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2535        unsigned int new_vref = 0;
2536        int error;
2537        hda_nid_t nid = kcontrol->private_value;
2538
2539        if (ucontrol->value.enumerated.item[0] == 0)
2540                new_vref = stac92xx_get_default_vref(codec, nid);
2541        else if (ucontrol->value.enumerated.item[0] == 1)
2542                new_vref = AC_PINCTL_VREF_GRD;
2543        else if (ucontrol->value.enumerated.item[0] == 2)
2544                new_vref = AC_PINCTL_VREF_HIZ;
2545        else
2546                return 0;
2547
2548        if (new_vref != stac92xx_vref_get(codec, nid)) {
2549                error = stac92xx_vref_set(codec, nid, new_vref);
2550                return error;
2551        }
2552
2553        return 0;
2554}
2555
2556static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol,
2557                                struct snd_ctl_elem_info *uinfo)
2558{
2559        static char *texts[2];
2560        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2561        struct sigmatel_spec *spec = codec->spec;
2562
2563        if (kcontrol->private_value == spec->line_switch)
2564                texts[0] = "Line In";
2565        else
2566                texts[0] = "Mic In";
2567        texts[1] = "Line Out";
2568        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2569        uinfo->value.enumerated.items = 2;
2570        uinfo->count = 1;
2571
2572        if (uinfo->value.enumerated.item >= 2)
2573                uinfo->value.enumerated.item = 1;
2574        strcpy(uinfo->value.enumerated.name,
2575                texts[uinfo->value.enumerated.item]);
2576
2577        return 0;
2578}
2579
2580static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2581{
2582        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2583        struct sigmatel_spec *spec = codec->spec;
2584        hda_nid_t nid = kcontrol->private_value;
2585        int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2586
2587        ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx];
2588        return 0;
2589}
2590
2591static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
2592{
2593        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2594        struct sigmatel_spec *spec = codec->spec;
2595        hda_nid_t nid = kcontrol->private_value;
2596        int io_idx = (nid == spec->mic_switch) ? 1 : 0;
2597        unsigned short val = !!ucontrol->value.enumerated.item[0];
2598
2599        spec->io_switch[io_idx] = val;
2600
2601        if (val)
2602                stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
2603        else {
2604                unsigned int pinctl = AC_PINCTL_IN_EN;
2605                if (io_idx) /* set VREF for mic */
2606                        pinctl |= stac92xx_get_default_vref(codec, nid);
2607                stac92xx_auto_set_pinctl(codec, nid, pinctl);
2608        }
2609
2610        /* check the auto-mute again: we need to mute/unmute the speaker
2611         * appropriately according to the pin direction
2612         */
2613        if (spec->hp_detect)
2614                stac_issue_unsol_event(codec, nid);
2615
2616        return 1;
2617}
2618
2619#define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info
2620
2621static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol,
2622                struct snd_ctl_elem_value *ucontrol)
2623{
2624        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2625        struct sigmatel_spec *spec = codec->spec;
2626
2627        ucontrol->value.integer.value[0] = spec->clfe_swap;
2628        return 0;
2629}
2630
2631static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol,
2632                struct snd_ctl_elem_value *ucontrol)
2633{
2634        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2635        struct sigmatel_spec *spec = codec->spec;
2636        hda_nid_t nid = kcontrol->private_value & 0xff;
2637        unsigned int val = !!ucontrol->value.integer.value[0];
2638
2639        if (spec->clfe_swap == val)
2640                return 0;
2641
2642        spec->clfe_swap = val;
2643
2644        snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
2645                spec->clfe_swap ? 0x4 : 0x0);
2646
2647        return 1;
2648}
2649
2650#define STAC_CODEC_HP_SWITCH(xname) \
2651        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2652          .name = xname, \
2653          .index = 0, \
2654          .info = stac92xx_hp_switch_info, \
2655          .get = stac92xx_hp_switch_get, \
2656          .put = stac92xx_hp_switch_put, \
2657        }
2658
2659#define STAC_CODEC_IO_SWITCH(xname, xpval) \
2660        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2661          .name = xname, \
2662          .index = 0, \
2663          .info = stac92xx_io_switch_info, \
2664          .get = stac92xx_io_switch_get, \
2665          .put = stac92xx_io_switch_put, \
2666          .private_value = xpval, \
2667        }
2668
2669#define STAC_CODEC_CLFE_SWITCH(xname, xpval) \
2670        { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2671          .name = xname, \
2672          .index = 0, \
2673          .info = stac92xx_clfe_switch_info, \
2674          .get = stac92xx_clfe_switch_get, \
2675          .put = stac92xx_clfe_switch_put, \
2676          .private_value = xpval, \
2677        }
2678
2679enum {
2680        STAC_CTL_WIDGET_VOL,
2681        STAC_CTL_WIDGET_MUTE,
2682        STAC_CTL_WIDGET_MUTE_BEEP,
2683        STAC_CTL_WIDGET_MONO_MUX,
2684        STAC_CTL_WIDGET_HP_SWITCH,
2685        STAC_CTL_WIDGET_IO_SWITCH,
2686        STAC_CTL_WIDGET_CLFE_SWITCH,
2687        STAC_CTL_WIDGET_DC_BIAS
2688};
2689
2690static struct snd_kcontrol_new stac92xx_control_templates[] = {
2691        HDA_CODEC_VOLUME(NULL, 0, 0, 0),
2692        HDA_CODEC_MUTE(NULL, 0, 0, 0),
2693        HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0),
2694        STAC_MONO_MUX,
2695        STAC_CODEC_HP_SWITCH(NULL),
2696        STAC_CODEC_IO_SWITCH(NULL, 0),
2697        STAC_CODEC_CLFE_SWITCH(NULL, 0),
2698        DC_BIAS(NULL, 0, 0),
2699};
2700
2701/* add dynamic controls */
2702static struct snd_kcontrol_new *
2703stac_control_new(struct sigmatel_spec *spec,
2704                 struct snd_kcontrol_new *ktemp,
2705                 const char *name,
2706                 unsigned int subdev)
2707{
2708        struct snd_kcontrol_new *knew;
2709
2710        snd_array_init(&spec->kctls, sizeof(*knew), 32);
2711        knew = snd_array_new(&spec->kctls);
2712        if (!knew)
2713                return NULL;
2714        *knew = *ktemp;
2715        knew->name = kstrdup(name, GFP_KERNEL);
2716        if (!knew->name) {
2717                /* roolback */
2718                memset(knew, 0, sizeof(*knew));
2719                spec->kctls.alloced--;
2720                return NULL;
2721        }
2722        knew->subdevice = subdev;
2723        return knew;
2724}
2725
2726static int stac92xx_add_control_temp(struct sigmatel_spec *spec,
2727                                     struct snd_kcontrol_new *ktemp,
2728                                     int idx, const char *name,
2729                                     unsigned long val)
2730{
2731        struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name,
2732                                                         HDA_SUBDEV_AMP_FLAG);
2733        if (!knew)
2734                return -ENOMEM;
2735        knew->index = idx;
2736        knew->private_value = val;
2737        return 0;
2738}
2739
2740static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec,
2741                                           int type, int idx, const char *name,
2742                                           unsigned long val)
2743{
2744        return stac92xx_add_control_temp(spec,
2745                                         &stac92xx_control_templates[type],
2746                                         idx, name, val);
2747}
2748
2749
2750/* add dynamic controls */
2751static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type,
2752                                       const char *name, unsigned long val)
2753{
2754        return stac92xx_add_control_idx(spec, type, 0, name, val);
2755}
2756
2757static struct snd_kcontrol_new stac_input_src_temp = {
2758        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2759        .name = "Input Source",
2760        .info = stac92xx_mux_enum_info,
2761        .get = stac92xx_mux_enum_get,
2762        .put = stac92xx_mux_enum_put,
2763};
2764
2765static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec,
2766                                                hda_nid_t nid, int idx)
2767{
2768        int def_conf = snd_hda_codec_get_pincfg(codec, nid);
2769        int control = 0;
2770        struct sigmatel_spec *spec = codec->spec;
2771        char name[22];
2772
2773        if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2774                if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD
2775                        && nid == spec->line_switch)
2776                        control = STAC_CTL_WIDGET_IO_SWITCH;
2777                else if (snd_hda_query_pin_caps(codec, nid)
2778                        & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT))
2779                        control = STAC_CTL_WIDGET_DC_BIAS;
2780                else if (nid == spec->mic_switch)
2781                        control = STAC_CTL_WIDGET_IO_SWITCH;
2782        }
2783
2784        if (control) {
2785                strcpy(name, hda_get_input_pin_label(codec, nid, 1));
2786                return stac92xx_add_control(codec->spec, control,
2787                                        strcat(name, " Jack Mode"), nid);
2788        }
2789
2790        return 0;
2791}
2792
2793static int stac92xx_add_input_source(struct sigmatel_spec *spec)
2794{
2795        struct snd_kcontrol_new *knew;
2796        struct hda_input_mux *imux = &spec->private_imux;
2797
2798        if (spec->auto_mic)
2799                return 0; /* no need for input source */
2800        if (!spec->num_adcs || imux->num_items <= 1)
2801                return 0; /* no need for input source control */
2802        knew = stac_control_new(spec, &stac_input_src_temp,
2803                                stac_input_src_temp.name, 0);
2804        if (!knew)
2805                return -ENOMEM;
2806        knew->count = spec->num_adcs;
2807        return 0;
2808}
2809
2810/* check whether the line-input can be used as line-out */
2811static hda_nid_t check_line_out_switch(struct hda_codec *codec)
2812{
2813        struct sigmatel_spec *spec = codec->spec;
2814        struct auto_pin_cfg *cfg = &spec->autocfg;
2815        hda_nid_t nid;
2816        unsigned int pincap;
2817        int i;
2818
2819        if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2820                return 0;
2821        for (i = 0; i < cfg->num_inputs; i++) {
2822                if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) {
2823                        nid = cfg->inputs[i].pin;
2824                        pincap = snd_hda_query_pin_caps(codec, nid);
2825                        if (pincap & AC_PINCAP_OUT)
2826                                return nid;
2827                }
2828        }
2829        return 0;
2830}
2831
2832static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid);
2833
2834/* check whether the mic-input can be used as line-out */
2835static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac)
2836{
2837        struct sigmatel_spec *spec = codec->spec;
2838        struct auto_pin_cfg *cfg = &spec->autocfg;
2839        unsigned int def_conf, pincap;
2840        int i;
2841
2842        *dac = 0;
2843        if (cfg->line_out_type != AUTO_PIN_LINE_OUT)
2844                return 0;
2845        for (i = 0; i < cfg->num_inputs; i++) {
2846                hda_nid_t nid = cfg->inputs[i].pin;
2847                if (cfg->inputs[i].type != AUTO_PIN_MIC)
2848                        continue;
2849                def_conf = snd_hda_codec_get_pincfg(codec, nid);
2850                /* some laptops have an internal analog microphone
2851                 * which can't be used as a output */
2852                if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) {
2853                        pincap = snd_hda_query_pin_caps(codec, nid);
2854                        if (pincap & AC_PINCAP_OUT) {
2855                                *dac = get_unassigned_dac(codec, nid);
2856                                if (*dac)
2857                                        return nid;
2858                        }
2859                }
2860        }
2861        return 0;
2862}
2863
2864static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2865{
2866        int i;
2867        
2868        for (i = 0; i < spec->multiout.num_dacs; i++) {
2869                if (spec->multiout.dac_nids[i] == nid)
2870                        return 1;
2871        }
2872
2873        return 0;
2874}
2875
2876static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid)
2877{
2878        int i;
2879        if (is_in_dac_nids(spec, nid))
2880                return 1;
2881        for (i = 0; i < spec->autocfg.hp_outs; i++)
2882                if (spec->hp_dacs[i] == nid)
2883                        return 1;
2884        for (i = 0; i < spec->autocfg.speaker_outs; i++)
2885                if (spec->speaker_dacs[i] == nid)
2886                        return 1;
2887        return 0;
2888}
2889
2890static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid)
2891{
2892        struct sigmatel_spec *spec = codec->spec;
2893        int j, conn_len;
2894        hda_nid_t conn[HDA_MAX_CONNECTIONS];
2895        unsigned int wcaps, wtype;
2896
2897        conn_len = snd_hda_get_connections(codec, nid, conn,
2898                                           HDA_MAX_CONNECTIONS);
2899        /* 92HD88: trace back up the link of nids to find the DAC */
2900        while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0]))
2901                                        != AC_WID_AUD_OUT)) {
2902                nid = conn[0];
2903                conn_len = snd_hda_get_connections(codec, nid, conn,
2904                        HDA_MAX_CONNECTIONS);
2905        }
2906        for (j = 0; j < conn_len; j++) {
2907                wcaps = get_wcaps(codec, conn[j]);
2908                wtype = get_wcaps_type(wcaps);
2909                /* we check only analog outputs */
2910                if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL))
2911                        continue;
2912                /* if this route has a free DAC, assign it */
2913                if (!check_all_dac_nids(spec, conn[j])) {
2914                        if (conn_len > 1) {
2915                                /* select this DAC in the pin's input mux */
2916                                snd_hda_codec_write_cache(codec, nid, 0,
2917                                                  AC_VERB_SET_CONNECT_SEL, j);
2918                        }
2919                        return conn[j];
2920                }
2921        }
2922        /* if all DACs are already assigned, connect to the primary DAC */
2923        if (conn_len > 1) {
2924                for (j = 0; j < conn_len; j++) {
2925                        if (conn[j] == spec->multiout.dac_nids[0]) {
2926                                snd_hda_codec_write_cache(codec, nid, 0,
2927                                                  AC_VERB_SET_CONNECT_SEL, j);
2928                                break;
2929                        }
2930                }
2931        }
2932        return 0;
2933}
2934
2935static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2936static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid);
2937
2938/*
2939 * Fill in the dac_nids table from the parsed pin configuration
2940 * This function only works when every pin in line_out_pins[]
2941 * contains atleast one DAC in its connection list. Some 92xx
2942 * codecs are not connected directly to a DAC, such as the 9200
2943 * and 9202/925x. For those, dac_nids[] must be hard-coded.
2944 */
2945static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec)
2946{
2947        struct sigmatel_spec *spec = codec->spec;
2948        struct auto_pin_cfg *cfg = &spec->autocfg;
2949        int i;
2950        hda_nid_t nid, dac;
2951        
2952        for (i = 0; i < cfg->line_outs; i++) {
2953                nid = cfg->line_out_pins[i];
2954                dac = get_unassigned_dac(codec, nid);
2955                if (!dac) {
2956                        if (spec->multiout.num_dacs > 0) {
2957                                /* we have already working output pins,
2958                                 * so let's drop the broken ones again
2959                                 */
2960                                cfg->line_outs = spec->multiout.num_dacs;
2961                                break;
2962                        }
2963                        /* error out, no available DAC found */
2964                        snd_printk(KERN_ERR
2965                                   "%s: No available DAC for pin 0x%x\n",
2966                                   __func__, nid);
2967                        return -ENODEV;
2968                }
2969                add_spec_dacs(spec, dac);
2970        }
2971
2972        for (i = 0; i < cfg->hp_outs; i++) {
2973                nid = cfg->hp_pins[i];
2974                dac = get_unassigned_dac(codec, nid);
2975                if (dac) {
2976                        if (!spec->multiout.hp_nid)
2977                                spec->multiout.hp_nid = dac;
2978                        else
2979                                add_spec_extra_dacs(spec, dac);
2980                }
2981                spec->hp_dacs[i] = dac;
2982        }
2983
2984        for (i = 0; i < cfg->speaker_outs; i++) {
2985                nid = cfg->speaker_pins[i];
2986                dac = get_unassigned_dac(codec, nid);
2987                if (dac)
2988                        add_spec_extra_dacs(spec, dac);
2989                spec->speaker_dacs[i] = dac;
2990        }
2991
2992        /* add line-in as output */
2993        nid = check_line_out_switch(codec);
2994        if (nid) {
2995                dac = get_unassigned_dac(codec, nid);
2996                if (dac) {
2997                        snd_printdd("STAC: Add line-in 0x%x as output %d\n",
2998                                    nid, cfg->line_outs);
2999                        cfg->line_out_pins[cfg->line_outs] = nid;
3000                        cfg->line_outs++;
3001                        spec->line_switch = nid;
3002                        add_spec_dacs(spec, dac);
3003                }
3004        }
3005        /* add mic as output */
3006        nid = check_mic_out_switch(codec, &dac);
3007        if (nid && dac) {
3008                snd_printdd("STAC: Add mic-in 0x%x as output %d\n",
3009                            nid, cfg->line_outs);
3010                cfg->line_out_pins[cfg->line_outs] = nid;
3011                cfg->line_outs++;
3012                spec->mic_switch = nid;
3013                add_spec_dacs(spec, dac);
3014        }
3015
3016        snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n",
3017                   spec->multiout.num_dacs,
3018                   spec->multiout.dac_nids[0],
3019                   spec->multiout.dac_nids[1],
3020                   spec->multiout.dac_nids[2],
3021                   spec->multiout.dac_nids[3],
3022                   spec->multiout.dac_nids[4]);
3023
3024        return 0;
3025}
3026
3027/* create volume control/switch for the given prefx type */
3028static int create_controls_idx(struct hda_codec *codec, const char *pfx,
3029                               int idx, hda_nid_t nid, int chs)
3030{
3031        struct sigmatel_spec *spec = codec->spec;
3032        char name[32];
3033        int err;
3034
3035        if (!spec->check_volume_offset) {
3036                unsigned int caps, step, nums, db_scale;
3037                caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3038                step = (caps & AC_AMPCAP_STEP_SIZE) >>
3039                        AC_AMPCAP_STEP_SIZE_SHIFT;
3040                step = (step + 1) * 25; /* in .01dB unit */
3041                nums = (caps & AC_AMPCAP_NUM_STEPS) >>
3042                        AC_AMPCAP_NUM_STEPS_SHIFT;
3043                db_scale = nums * step;
3044                /* if dB scale is over -64dB, and finer enough,
3045                 * let's reduce it to half
3046                 */
3047                if (db_scale > 6400 && nums >= 0x1f)
3048                        spec->volume_offset = nums / 2;
3049                spec->check_volume_offset = 1;
3050        }
3051
3052        sprintf(name, "%s Playback Volume", pfx);
3053        err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name,
3054                HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT,
3055                                        spec->volume_offset));
3056        if (err < 0)
3057                return err;
3058        sprintf(name, "%s Playback Switch", pfx);
3059        err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name,
3060                                   HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
3061        if (err < 0)
3062                return err;
3063        return 0;
3064}
3065
3066#define create_controls(codec, pfx, nid, chs) \
3067        create_controls_idx(codec, pfx, 0, nid, chs)
3068
3069static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3070{
3071        if (spec->multiout.num_dacs > 4) {
3072                printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid);
3073                return 1;
3074        } else {
3075                spec->multiout.dac_nids[spec->multiout.num_dacs] = nid;
3076                spec->multiout.num_dacs++;
3077        }
3078        return 0;
3079}
3080
3081static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid)
3082{
3083        int i;
3084        for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
3085                if (!spec->multiout.extra_out_nid[i]) {
3086                        spec->multiout.extra_out_nid[i] = nid;
3087                        return 0;
3088                }
3089        }
3090        printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid);
3091        return 1;
3092}
3093
3094/* Create output controls
3095 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT)
3096 */
3097static int create_multi_out_ctls(struct hda_codec *codec, int num_outs,
3098                                 const hda_nid_t *pins,
3099                                 const hda_nid_t *dac_nids,
3100                                 int type)
3101{
3102        struct sigmatel_spec *spec = codec->spec;
3103        static const char * const chname[4] = {
3104                "Front", "Surround", NULL /*CLFE*/, "Side"
3105        };
3106        hda_nid_t nid;
3107        int i, err;
3108        unsigned int wid_caps;
3109
3110        for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) {
3111                if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) {
3112                        wid_caps = get_wcaps(codec, pins[i]);
3113                        if (wid_caps & AC_WCAP_UNSOL_CAP)
3114                                spec->hp_detect = 1;
3115                }
3116                nid = dac_nids[i];
3117                if (!nid)
3118                        continue;
3119                if (type != AUTO_PIN_HP_OUT && i == 2) {
3120                        /* Center/LFE */
3121                        err = create_controls(codec, "Center", nid, 1);
3122                        if (err < 0)
3123                                return err;
3124                        err = create_controls(codec, "LFE", nid, 2);
3125                        if (err < 0)
3126                                return err;
3127
3128                        wid_caps = get_wcaps(codec, nid);
3129
3130                        if (wid_caps & AC_WCAP_LR_SWAP) {
3131                                err = stac92xx_add_control(spec,
3132                                        STAC_CTL_WIDGET_CLFE_SWITCH,
3133                                        "Swap Center/LFE Playback Switch", nid);
3134
3135                                if (err < 0)
3136                                        return err;
3137                        }
3138
3139                } else {
3140                        const char *name;
3141                        int idx;
3142                        switch (type) {
3143                        case AUTO_PIN_HP_OUT:
3144                                name = "Headphone";
3145                                idx = i;
3146                                break;
3147                        case AUTO_PIN_SPEAKER_OUT:
3148                                name = "Speaker";
3149                                idx = i;
3150                                break;
3151                        default:
3152                                name = chname[i];
3153                                idx = 0;
3154                                break;
3155                        }
3156                        err = create_controls_idx(codec, name, idx, nid, 3);
3157                        if (err < 0)
3158                                return err;
3159                }
3160        }
3161        return 0;
3162}
3163
3164static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol,
3165                                    unsigned long sw, int idx)
3166{
3167        int err;
3168        err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx,
3169                                       "Capture Volume", vol);
3170        if (err < 0)
3171                return err;
3172        err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx,
3173                                       "Capture Switch", sw);
3174        if (err < 0)
3175                return err;
3176        return 0;
3177}
3178
3179/* add playback controls from the parsed DAC table */
3180static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec,
3181                                               const struct auto_pin_cfg *cfg)
3182{
3183        struct sigmatel_spec *spec = codec->spec;
3184        hda_nid_t nid;
3185        int err;
3186        int idx;
3187
3188        err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins,
3189                                    spec->multiout.dac_nids,
3190                                    cfg->line_out_type);
3191        if (err < 0)
3192                return err;
3193
3194        if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) {
3195                err = stac92xx_add_control(spec,
3196                        STAC_CTL_WIDGET_HP_SWITCH,
3197                        "Headphone as Line Out Switch",
3198                        cfg->hp_pins[cfg->hp_outs - 1]);
3199                if (err < 0)
3200                        return err;
3201        }
3202
3203        for (idx = 0; idx < cfg->num_inputs; idx++) {
3204                if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN)
3205                        break;
3206                nid = cfg->inputs[idx].pin;
3207                err = stac92xx_add_jack_mode_control(codec, nid, idx);
3208                if (err < 0)
3209                        return err;
3210        }
3211
3212        return 0;
3213}
3214
3215/* add playback controls for Speaker and HP outputs */
3216static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec,
3217                                        struct auto_pin_cfg *cfg)
3218{
3219        struct sigmatel_spec *spec = codec->spec;
3220        int err;
3221
3222        err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins,
3223                                    spec->hp_dacs, AUTO_PIN_HP_OUT);
3224        if (err < 0)
3225                return err;
3226
3227        err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins,
3228                                    spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT);
3229        if (err < 0)
3230                return err;
3231
3232        return 0;
3233}
3234
3235/* labels for mono mux outputs */
3236static const char * const stac92xx_mono_labels[4] = {
3237        "DAC0", "DAC1", "Mixer", "DAC2"
3238};
3239
3240/* create mono mux for mono out on capable codecs */
3241static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec)
3242{
3243        struct sigmatel_spec *spec = codec->spec;
3244        struct hda_input_mux *mono_mux = &spec->private_mono_mux;
3245        int i, num_cons;
3246        hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)];
3247
3248        num_cons = snd_hda_get_connections(codec,
3249                                spec->mono_nid,
3250                                con_lst,
3251                                HDA_MAX_NUM_INPUTS);
3252        if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels))
3253                return -EINVAL;
3254
3255        for (i = 0; i < num_cons; i++)
3256                snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i,
3257                                      NULL);
3258
3259        return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX,
3260                                "Mono Mux", spec->mono_nid);
3261}
3262
3263/* create PC beep volume controls */
3264static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec,
3265                                                hda_nid_t nid)
3266{
3267        struct sigmatel_spec *spec = codec->spec;
3268        u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3269        int err, type = STAC_CTL_WIDGET_MUTE_BEEP;
3270
3271        if (spec->anabeep_nid == nid)
3272                type = STAC_CTL_WIDGET_MUTE;
3273
3274        /* check for mute support for the the amp */
3275        if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) {
3276                err = stac92xx_add_control(spec, type,
3277                        "Beep Playback Switch",
3278                        HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3279                        if (err < 0)
3280                                return err;
3281        }
3282
3283        /* check to see if there is volume support for the amp */
3284        if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3285                err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL,
3286                        "Beep Playback Volume",
3287                        HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT));
3288                        if (err < 0)
3289                                return err;
3290        }
3291        return 0;
3292}
3293
3294#ifdef CONFIG_SND_HDA_INPUT_BEEP
3295#define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info
3296
3297static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol,
3298                                        struct snd_ctl_elem_value *ucontrol)
3299{
3300        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3301        ucontrol->value.integer.value[0] = codec->beep->enabled;
3302        return 0;
3303}
3304
3305static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol,
3306                                        struct snd_ctl_elem_value *ucontrol)
3307{
3308        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3309        return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]);
3310}
3311
3312static struct snd_kcontrol_new stac92xx_dig_beep_ctrl = {
3313        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3314        .info = stac92xx_dig_beep_switch_info,
3315        .get = stac92xx_dig_beep_switch_get,
3316        .put = stac92xx_dig_beep_switch_put,
3317};
3318
3319static int stac92xx_beep_switch_ctl(struct hda_codec *codec)
3320{
3321        return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl,
3322                                         0, "Beep Playback Switch", 0);
3323}
3324#endif
3325
3326static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec)
3327{
3328        struct sigmatel_spec *spec = codec->spec;
3329        int i, j, err = 0;
3330
3331        for (i = 0; i < spec->num_muxes; i++) {
3332                hda_nid_t nid;
3333                unsigned int wcaps;
3334                unsigned long val;
3335
3336                nid = spec->mux_nids[i];
3337                wcaps = get_wcaps(codec, nid);
3338                if (!(wcaps & AC_WCAP_OUT_AMP))
3339                        continue;
3340
3341                /* check whether already the same control was created as
3342                 * normal Capture Volume.
3343                 */
3344                val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
3345                for (j = 0; j < spec->num_caps; j++) {
3346                        if (spec->capvols[j] == val)
3347                                break;
3348                }
3349                if (j < spec->num_caps)
3350                        continue;
3351
3352                err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i,
3353                                               "Mux Capture Volume", val);
3354                if (err < 0)
3355                        return err;
3356        }
3357        return 0;
3358};
3359
3360static const char * const stac92xx_spdif_labels[3] = {
3361        "Digital Playback", "Analog Mux 1", "Analog Mux 2",
3362};
3363
3364static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec)
3365{
3366        struct sigmatel_spec *spec = codec->spec;
3367        struct hda_input_mux *spdif_mux = &spec->private_smux;
3368        const char * const *labels = spec->spdif_labels;
3369        int i, num_cons;
3370        hda_nid_t con_lst[HDA_MAX_NUM_INPUTS];
3371
3372        num_cons = snd_hda_get_connections(codec,
3373                                spec->smux_nids[0],
3374                                con_lst,
3375                                HDA_MAX_NUM_INPUTS);
3376        if (num_cons <= 0)
3377                return -EINVAL;
3378
3379        if (!labels)
3380                labels = stac92xx_spdif_labels;
3381
3382        for (i = 0; i < num_cons; i++)
3383                snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL);
3384
3385        return 0;
3386}
3387
3388/* labels for dmic mux inputs */
3389static const char * const stac92xx_dmic_labels[5] = {
3390        "Analog Inputs", "Digital Mic 1", "Digital Mic 2",
3391        "Digital Mic 3", "Digital Mic 4"
3392};
3393
3394static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux,
3395                                    int idx)
3396{
3397        hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3398        int nums;
3399        nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3400        if (idx >= 0 && idx < nums)
3401                return conn[idx];
3402        return 0;
3403}
3404
3405static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
3406                                hda_nid_t nid)
3407{
3408        hda_nid_t conn[HDA_MAX_NUM_INPUTS];
3409        int i, nums;
3410
3411        if (!(get_wcaps(codec, mux) & AC_WCAP_CONN_LIST))
3412                return -1;
3413
3414        nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
3415        for (i = 0; i < nums; i++)
3416                if (conn[i] == nid)
3417                        return i;
3418
3419        for (i = 0; i < nums; i++) {
3420                unsigned int wid_caps = get_wcaps(codec, conn[i]);
3421                unsigned int wid_type = get_wcaps_type(wid_caps);
3422
3423                if (wid_type != AC_WID_PIN && wid_type != AC_WID_AUD_MIX)
3424                        if (get_connection_index(codec, conn[i], nid) >= 0)
3425                                return i;
3426        }
3427        return -1;
3428}
3429
3430/* create a volume assigned to the given pin (only if supported) */
3431/* return 1 if the volume control is created */
3432static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid,
3433                                   const char *label, int idx, int direction)
3434{
3435        unsigned int caps, nums;
3436        char name[32];
3437        int err;
3438
3439        if (direction == HDA_OUTPUT)
3440                caps = AC_WCAP_OUT_AMP;
3441        else
3442                caps = AC_WCAP_IN_AMP;
3443        if (!(get_wcaps(codec, nid) & caps))
3444                return 0;
3445        caps = query_amp_caps(codec, nid, direction);
3446        nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
3447        if (!nums)
3448                return 0;
3449        snprintf(name, sizeof(name), "%s Capture Volume", label);
3450        err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name,
3451                                       HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction));
3452        if (err < 0)
3453                return err;
3454        return 1;
3455}
3456
3457/* create playback/capture controls for input pins on dmic capable codecs */
3458static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec,
3459                                                const struct auto_pin_cfg *cfg)
3460{
3461        struct sigmatel_spec *spec = codec->spec;
3462        struct hda_input_mux *imux = &spec->private_imux;
3463        struct hda_input_mux *dimux = &spec->private_dimux;
3464        int err, i;
3465        unsigned int def_conf;
3466
3467        snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL);
3468
3469        for (i = 0; i < spec->num_dmics; i++) {
3470                hda_nid_t nid;
3471                int index, type_idx;
3472                const char *label;
3473
3474                nid = spec->dmic_nids[i];
3475                if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
3476                        continue;
3477                def_conf = snd_hda_codec_get_pincfg(codec, nid);
3478                if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE)
3479                        continue;
3480
3481                index = get_connection_index(codec, spec->dmux_nids[0], nid);
3482                if (index < 0)
3483                        continue;
3484
3485                label = hda_get_input_pin_label(codec, nid, 1);
3486                snd_hda_add_imux_item(dimux, label, index, &type_idx);
3487                if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1)
3488                        snd_hda_add_imux_item(imux, label, index, &type_idx);
3489
3490                err = create_elem_capture_vol(codec, nid, label, type_idx,
3491                                              HDA_INPUT);
3492                if (err < 0)
3493                        return err;
3494                if (!err) {
3495                        err = create_elem_capture_vol(codec, nid, label,
3496                                                      type_idx, HDA_OUTPUT);
3497                        if (err < 0)
3498                                return err;
3499                        if (!err) {
3500                                nid = get_connected_node(codec,
3501                                                spec->dmux_nids[0], index);
3502                                if (nid)
3503                                        err = create_elem_capture_vol(codec,
3504                                                        nid, label,
3505                                                        type_idx, HDA_INPUT);
3506                                if (err < 0)
3507                                        return err;
3508                        }
3509                }
3510        }
3511
3512        return 0;
3513}
3514
3515static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid,
3516                         hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock)
3517{
3518        unsigned int cfg;
3519
3520        if (!nid)
3521                return 0;
3522        cfg = snd_hda_codec_get_pincfg(codec, nid);
3523        switch (snd_hda_get_input_pin_attr(cfg)) {
3524        case INPUT_PIN_ATTR_INT:
3525                if (*fixed)
3526                        return 1; /* already occupied */
3527                *fixed = nid;
3528                break;
3529        case INPUT_PIN_ATTR_UNUSED:
3530                break;
3531        case INPUT_PIN_ATTR_DOCK:
3532                if (*dock)
3533                        return 1; /* already occupied */
3534                *dock = nid;
3535                break;
3536        default:
3537                if (*ext)
3538                        return 1; /* already occupied */
3539                *ext = nid;
3540                break;
3541        }
3542        return 0;
3543}
3544
3545static int set_mic_route(struct hda_codec *codec,
3546                         struct sigmatel_mic_route *mic,
3547                         hda_nid_t pin)
3548{
3549        struct sigmatel_spec *spec = codec->spec;
3550        struct auto_pin_cfg *cfg = &spec->autocfg;
3551        int i;
3552
3553        mic->pin = pin;
3554        if (pin == 0)
3555                return 0;
3556        for (i = 0; i < cfg->num_inputs; i++) {
3557                if (pin == cfg->inputs[i].pin)
3558                        break;
3559        }
3560        if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) {
3561                /* analog pin */
3562                i = get_connection_index(codec, spec->mux_nids[0], pin);
3563                if (i < 0)
3564                        return -1;
3565                mic->mux_idx = i;
3566                mic->dmux_idx = -1;
3567                if (spec->dmux_nids)
3568                        mic->dmux_idx = get_connection_index(codec,
3569                                                             spec->dmux_nids[0],
3570                                                             spec->mux_nids[0]);
3571        }  else if (spec->dmux_nids) {
3572                /* digital pin */
3573                i = get_connection_index(codec, spec->dmux_nids[0], pin);
3574                if (i < 0)
3575                        return -1;
3576                mic->dmux_idx = i;
3577                mic->mux_idx = -1;
3578                if (spec->mux_nids)
3579                        mic->mux_idx = get_connection_index(codec,
3580                                                            spec->mux_nids[0],
3581                                                            spec->dmux_nids[0]);
3582        }
3583        return 0;
3584}
3585
3586/* return non-zero if the device is for automatic mic switch */
3587static int stac_check_auto_mic(struct hda_codec *codec)
3588{
3589        struct sigmatel_spec *spec = codec->spec;
3590        struct auto_pin_cfg *cfg = &spec->autocfg;
3591        hda_nid_t fixed, ext, dock;
3592        int i;
3593
3594        for (i = 0; i < cfg->num_inputs; i++) {
3595                if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN)
3596                        return 0; /* must be exclusively mics */
3597        }
3598        fixed = ext = dock = 0;
3599        for (i = 0; i < cfg->num_inputs; i++)
3600                if (check_mic_pin(codec, cfg->inputs[i].pin,
3601                    &fixed, &ext, &dock))
3602                        return 0;
3603        for (i = 0; i < spec->num_dmics; i++)
3604                if (check_mic_pin(codec, spec->dmic_nids[i],
3605                    &fixed, &ext, &dock))
3606                        return 0;
3607        if (!fixed || (!ext && !dock))
3608                return 0; /* no input to switch */
3609        if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
3610                return 0; /* no unsol support */
3611        if (set_mic_route(codec, &spec->ext_mic, ext) ||
3612            set_mic_route(codec, &spec->int_mic, fixed) ||
3613            set_mic_route(codec, &spec->dock_mic, dock))
3614                return 0; /* something is wrong */
3615        return 1;
3616}
3617
3618/* create playback/capture controls for input pins */
3619static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg)
3620{
3621        struct sigmatel_spec *spec = codec->spec;
3622        struct hda_input_mux *imux = &spec->private_imux;
3623        int i, j;
3624        const char *label;
3625
3626        for (i = 0; i < cfg->num_inputs; i++) {
3627                hda_nid_t nid = cfg->inputs[i].pin;
3628                int index, err, type_idx;
3629
3630                index = -1;
3631                for (j = 0; j < spec->num_muxes; j++) {
3632                        index = get_connection_index(codec, spec->mux_nids[j],
3633                                                     nid);
3634                        if (index >= 0)
3635                                break;
3636                }
3637                if (index < 0)
3638                        continue;
3639
3640                label = hda_get_autocfg_input_label(codec, cfg, i);
3641                snd_hda_add_imux_item(imux, label, index, &type_idx);
3642
3643                err = create_elem_capture_vol(codec, nid,
3644                                              label, type_idx,
3645                                              HDA_INPUT);
3646                if (err < 0)
3647                        return err;
3648        }
3649        spec->num_analog_muxes = imux->num_items;
3650
3651        if (imux->num_items) {
3652                /*
3653                 * Set the current input for the muxes.
3654                 * The STAC9221 has two input muxes with identical source
3655                 * NID lists.  Hopefully this won't get confused.
3656                 */
3657                for (i = 0; i < spec->num_muxes; i++) {
3658                        snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0,
3659                                                  AC_VERB_SET_CONNECT_SEL,
3660                                                  imux->items[0].index);
3661                }
3662        }
3663
3664        return 0;
3665}
3666
3667static void stac92xx_auto_init_multi_out(struct hda_codec *codec)
3668{
3669        struct sigmatel_spec *spec = codec->spec;
3670        int i;
3671
3672        for (i = 0; i < spec->autocfg.line_outs; i++) {
3673                hda_nid_t nid = spec->autocfg.line_out_pins[i];
3674                stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN);
3675        }
3676}
3677
3678static void stac92xx_auto_init_hp_out(struct hda_codec *codec)
3679{
3680        struct sigmatel_spec *spec = codec->spec;
3681        int i;
3682
3683        for (i = 0; i < spec->autocfg.hp_outs; i++) {
3684                hda_nid_t pin;
3685                pin = spec->autocfg.hp_pins[i];
3686                if (pin) /* connect to front */
3687                        stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN);
3688        }
3689        for (i = 0; i < spec->autocfg.speaker_outs; i++) {
3690                hda_nid_t pin;
3691                pin = spec->autocfg.speaker_pins[i];
3692                if (pin) /* connect to front */
3693                        stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN);
3694        }
3695}
3696
3697static int is_dual_headphones(struct hda_codec *codec)
3698{
3699        struct sigmatel_spec *spec = codec->spec;
3700        int i, valid_hps;
3701
3702        if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT ||
3703            spec->autocfg.hp_outs <= 1)
3704                return 0;
3705        valid_hps = 0;
3706        for (i = 0; i < spec->autocfg.hp_outs; i++) {
3707                hda_nid_t nid = spec->autocfg.hp_pins[i];
3708                unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid);
3709                if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE)
3710                        continue;
3711                valid_hps++;
3712        }
3713        return (valid_hps > 1);
3714}
3715
3716
3717static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in)
3718{
3719        struct sigmatel_spec *spec = codec->spec;
3720        int hp_swap = 0;
3721        int i, err;
3722
3723        if ((err = snd_hda_parse_pin_def_config(codec,
3724                                                &spec->autocfg,
3725                                                spec->dmic_nids)) < 0)
3726                return err;
3727        if (! spec->autocfg.line_outs)
3728                return 0; /* can't find valid pin config */
3729
3730        /* If we have no real line-out pin and multiple hp-outs, HPs should
3731         * be set up as multi-channel outputs.
3732         */
3733        if (is_dual_headphones(codec)) {
3734                /* Copy hp_outs to line_outs, backup line_outs in
3735                 * speaker_outs so that the following routines can handle
3736                 * HP pins as primary outputs.
3737                 */
3738                snd_printdd("stac92xx: Enabling multi-HPs workaround\n");
3739                memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins,
3740                       sizeof(spec->autocfg.line_out_pins));
3741                spec->autocfg.speaker_outs = spec->autocfg.line_outs;
3742                memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins,
3743                       sizeof(spec->autocfg.hp_pins));
3744                spec->autocfg.line_outs = spec->autocfg.hp_outs;
3745                spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3746                spec->autocfg.hp_outs = 0;
3747                hp_swap = 1;
3748        }
3749        if (spec->autocfg.mono_out_pin) {
3750                int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) &
3751                        (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP);
3752                u32 caps = query_amp_caps(codec,
3753                                spec->autocfg.mono_out_pin, dir);
3754                hda_nid_t conn_list[1];
3755
3756                /* get the mixer node and then the mono mux if it exists */
3757                if (snd_hda_get_connections(codec,
3758                                spec->autocfg.mono_out_pin, conn_list, 1) &&
3759                                snd_hda_get_connections(codec, conn_list[0],
3760                                conn_list, 1) > 0) {
3761
3762                                int wcaps = get_wcaps(codec, conn_list[0]);
3763                                int wid_type = get_wcaps_type(wcaps);
3764                                /* LR swap check, some stac925x have a mux that
3765                                 * changes the DACs output path instead of the
3766                                 * mono-mux path.
3767                                 */
3768                                if (wid_type == AC_WID_AUD_SEL &&
3769                                                !(wcaps & AC_WCAP_LR_SWAP))
3770                                        spec->mono_nid = conn_list[0];
3771                }
3772                if (dir) {
3773                        hda_nid_t nid = spec->autocfg.mono_out_pin;
3774
3775                        /* most mono outs have a least a mute/unmute switch */
3776                        dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT;
3777                        err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE,
3778                                "Mono Playback Switch",
3779                                HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3780                        if (err < 0)
3781                                return err;
3782                        /* check for volume support for the amp */
3783                        if ((caps & AC_AMPCAP_NUM_STEPS)
3784                                        >> AC_AMPCAP_NUM_STEPS_SHIFT) {
3785                                err = stac92xx_add_control(spec,
3786                                        STAC_CTL_WIDGET_VOL,
3787                                        "Mono Playback Volume",
3788                                HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir));
3789                                if (err < 0)
3790                                        return err;
3791                        }
3792                }
3793
3794                stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin,
3795                                         AC_PINCTL_OUT_EN);
3796        }
3797
3798        if (!spec->multiout.num_dacs) {
3799                err = stac92xx_auto_fill_dac_nids(codec);
3800                if (err < 0)
3801                        return err;
3802                err = stac92xx_auto_create_multi_out_ctls(codec,
3803                                                          &spec->autocfg);
3804                if (err < 0)
3805                        return err;
3806        }
3807
3808        /* setup analog beep controls */
3809        if (spec->anabeep_nid > 0) {
3810                err = stac92xx_auto_create_beep_ctls(codec,
3811                        spec->anabeep_nid);
3812                if (err < 0)
3813                        return err;
3814        }
3815
3816        /* setup digital beep controls and input device */
3817#ifdef CONFIG_SND_HDA_INPUT_BEEP
3818        if (spec->digbeep_nid > 0) {
3819                hda_nid_t nid = spec->digbeep_nid;
3820                unsigned int caps;
3821
3822                err = stac92xx_auto_create_beep_ctls(codec, nid);
3823                if (err < 0)
3824                        return err;
3825                err = snd_hda_attach_beep_device(codec, nid);
3826                if (err < 0)
3827                        return err;
3828                if (codec->beep) {
3829                        /* IDT/STAC codecs have linear beep tone parameter */
3830                        codec->beep->linear_tone = spec->linear_tone_beep;
3831                        /* if no beep switch is available, make its own one */
3832                        caps = query_amp_caps(codec, nid, HDA_OUTPUT);
3833                        if (!(caps & AC_AMPCAP_MUTE)) {
3834                                err = stac92xx_beep_switch_ctl(codec);
3835                                if (err < 0)
3836                                        return err;
3837                        }
3838                }
3839        }
3840#endif
3841
3842        err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg);
3843        if (err < 0)
3844                return err;
3845
3846        /* All output parsing done, now restore the swapped hp pins */
3847        if (hp_swap) {
3848                memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins,
3849                       sizeof(spec->autocfg.hp_pins));
3850                spec->autocfg.hp_outs = spec->autocfg.line_outs;
3851                spec->autocfg.line_out_type = AUTO_PIN_HP_OUT;
3852                spec->autocfg.line_outs = 0;
3853        }
3854
3855        if (stac_check_auto_mic(codec)) {
3856                spec->auto_mic = 1;
3857                /* only one capture for auto-mic */
3858                spec->num_adcs = 1;
3859                spec->num_caps = 1;
3860                spec->num_muxes = 1;
3861        }
3862
3863        for (i = 0; i < spec->num_caps; i++) {
3864                err = stac92xx_add_capvol_ctls(codec, spec->capvols[i],
3865                                               spec->capsws[i], i);
3866                if (err < 0)
3867                        return err;
3868        }
3869
3870        err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg);
3871        if (err < 0)
3872                return err;
3873
3874        if (spec->mono_nid > 0) {
3875                err = stac92xx_auto_create_mono_output_ctls(codec);
3876                if (err < 0)
3877                        return err;
3878        }
3879        if (spec->num_dmics > 0 && !spec->dinput_mux)
3880                if ((err = stac92xx_auto_create_dmic_input_ctls(codec,
3881                                                &spec->autocfg)) < 0)
3882                        return err;
3883        if (spec->num_muxes > 0) {
3884                err = stac92xx_auto_create_mux_input_ctls(codec);
3885                if (err < 0)
3886                        return err;
3887        }
3888        if (spec->num_smuxes > 0) {
3889                err = stac92xx_auto_create_spdif_mux_ctls(codec);
3890                if (err < 0)
3891                        return err;
3892        }
3893
3894        err = stac92xx_add_input_source(spec);
3895        if (err < 0)
3896                return err;
3897
3898        spec->multiout.max_channels = spec->multiout.num_dacs * 2;
3899        if (spec->multiout.max_channels > 2)
3900                spec->surr_switch = 1;
3901
3902        if (spec->autocfg.dig_outs)
3903                spec->multiout.dig_out_nid = dig_out;
3904        if (dig_in && spec->autocfg.dig_in_pin)
3905                spec->dig_in_nid = dig_in;
3906
3907        if (spec->kctls.list)
3908                spec->mixers[spec->num_mixers++] = spec->kctls.list;
3909
3910        spec->input_mux = &spec->private_imux;
3911        if (!spec->dinput_mux)
3912                spec->dinput_mux = &spec->private_dimux;
3913        spec->sinput_mux = &spec->private_smux;
3914        spec->mono_mux = &spec->private_mono_mux;
3915        return 1;
3916}
3917
3918/* add playback controls for HP output */
3919static int stac9200_auto_create_hp_ctls(struct hda_codec *codec,
3920                                        struct auto_pin_cfg *cfg)
3921{
3922        struct sigmatel_spec *spec = codec->spec;
3923        hda_nid_t pin = cfg->hp_pins[0];
3924        unsigned int wid_caps;
3925
3926        if (! pin)
3927                return 0;
3928
3929        wid_caps = get_wcaps(codec, pin);
3930        if (wid_caps & AC_WCAP_UNSOL_CAP)
3931                spec->hp_detect = 1;
3932
3933        return 0;
3934}
3935
3936/* add playback controls for LFE output */
3937static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec,
3938                                        struct auto_pin_cfg *cfg)
3939{
3940        struct sigmatel_spec *spec = codec->spec;
3941        int err;
3942        hda_nid_t lfe_pin = 0x0;
3943        int i;
3944
3945        /*
3946         * search speaker outs and line outs for a mono speaker pin
3947         * with an amp.  If one is found, add LFE controls
3948         * for it.
3949         */
3950        for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) {
3951                hda_nid_t pin = spec->autocfg.speaker_pins[i];
3952                unsigned int wcaps = get_wcaps(codec, pin);
3953                wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3954                if (wcaps == AC_WCAP_OUT_AMP)
3955                        /* found a mono speaker with an amp, must be lfe */
3956                        lfe_pin = pin;
3957        }
3958
3959        /* if speaker_outs is 0, then speakers may be in line_outs */
3960        if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) {
3961                for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) {
3962                        hda_nid_t pin = spec->autocfg.line_out_pins[i];
3963                        unsigned int defcfg;
3964                        defcfg = snd_hda_codec_get_pincfg(codec, pin);
3965                        if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) {
3966                                unsigned int wcaps = get_wcaps(codec, pin);
3967                                wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP);
3968                                if (wcaps == AC_WCAP_OUT_AMP)
3969                                        /* found a mono speaker with an amp,
3970                                           must be lfe */
3971                                        lfe_pin = pin;
3972                        }
3973                }
3974        }
3975
3976        if (lfe_pin) {
3977                err = create_controls(codec, "LFE", lfe_pin, 1);
3978                if (err < 0)
3979                        return err;
3980        }
3981
3982        return 0;
3983}
3984
3985static int stac9200_parse_auto_config(struct hda_codec *codec)
3986{
3987        struct sigmatel_spec *spec = codec->spec;
3988        int err;
3989
3990        if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0)
3991                return err;
3992
3993        if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0)
3994                return err;
3995
3996        if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0)
3997                return err;
3998
3999        if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0)
4000                return err;
4001
4002        if (spec->num_muxes > 0) {
4003                err = stac92xx_auto_create_mux_input_ctls(codec);
4004                if (err < 0)
4005                        return err;
4006        }
4007
4008        err = stac92xx_add_input_source(spec);
4009        if (err < 0)
4010                return err;
4011
4012        if (spec->autocfg.dig_outs)
4013                spec->multiout.dig_out_nid = 0x05;
4014        if (spec->autocfg.dig_in_pin)
4015                spec->dig_in_nid = 0x04;
4016
4017        if (spec->kctls.list)
4018                spec->mixers[spec->num_mixers++] = spec->kctls.list;
4019
4020        spec->input_mux = &spec->private_imux;
4021        spec->dinput_mux = &spec->private_dimux;
4022
4023        return 1;
4024}
4025
4026/*
4027 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a
4028 * funky external mute control using GPIO pins.
4029 */
4030
4031static void stac_gpio_set(struct hda_codec *codec, unsigned int mask,
4032                          unsigned int dir_mask, unsigned int data)
4033{
4034        unsigned int gpiostate, gpiomask, gpiodir;
4035
4036        gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
4037                                       AC_VERB_GET_GPIO_DATA, 0);
4038        gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask);
4039
4040        gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
4041                                      AC_VERB_GET_GPIO_MASK, 0);
4042        gpiomask |= mask;
4043
4044        gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
4045                                     AC_VERB_GET_GPIO_DIRECTION, 0);
4046        gpiodir |= dir_mask;
4047
4048        /* Configure GPIOx as CMOS */
4049        snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0);
4050
4051        snd_hda_codec_write(codec, codec->afg, 0,
4052                            AC_VERB_SET_GPIO_MASK, gpiomask);
4053        snd_hda_codec_read(codec, codec->afg, 0,
4054                           AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */
4055
4056        msleep(1);
4057
4058        snd_hda_codec_read(codec, codec->afg, 0,
4059                           AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */
4060}
4061
4062static int stac92xx_add_jack(struct hda_codec *codec,
4063                hda_nid_t nid, int type)
4064{
4065#ifdef CONFIG_SND_HDA_INPUT_JACK
4066        int def_conf = snd_hda_codec_get_pincfg(codec, nid);
4067        int connectivity = get_defcfg_connect(def_conf);
4068        char name[32];
4069        int err;
4070
4071        if (connectivity && connectivity != AC_JACK_PORT_FIXED)
4072                return 0;
4073
4074        snprintf(name, sizeof(name), "%s at %s %s Jack",
4075                snd_hda_get_jack_type(def_conf),
4076                snd_hda_get_jack_connectivity(def_conf),
4077                snd_hda_get_jack_location(def_conf));
4078
4079        err = snd_hda_input_jack_add(codec, nid, type, name);
4080        if (err < 0)
4081                return err;
4082#endif /* CONFIG_SND_HDA_INPUT_JACK */
4083        return 0;
4084}
4085
4086static int stac_add_event(struct sigmatel_spec *spec, hda_nid_t nid,
4087                          unsigned char type, int data)
4088{
4089        struct sigmatel_event *event;
4090
4091        snd_array_init(&spec->events, sizeof(*event), 32);
4092        event = snd_array_new(&spec->events);
4093        if (!event)
4094                return -ENOMEM;
4095        event->nid = nid;
4096        event->type = type;
4097        event->tag = spec->events.used;
4098        event->data = data;
4099
4100        return event->tag;
4101}
4102
4103static struct sigmatel_event *stac_get_event(struct hda_codec *codec,
4104                                             hda_nid_t nid)
4105{
4106        struct sigmatel_spec *spec = codec->spec;
4107        struct sigmatel_event *event = spec->events.list;
4108        int i;
4109
4110        for (i = 0; i < spec->events.used; i++, event++) {
4111                if (event->nid == nid)
4112                        return event;
4113        }
4114        return NULL;
4115}
4116
4117static struct sigmatel_event *stac_get_event_from_tag(struct hda_codec *codec,
4118                                                      unsigned char tag)
4119{
4120        struct sigmatel_spec *spec = codec->spec;
4121        struct sigmatel_event *event = spec->events.list;
4122        int i;
4123
4124        for (i = 0; i < spec->events.used; i++, event++) {
4125                if (event->tag == tag)
4126                        return event;
4127        }
4128        return NULL;
4129}
4130
4131/* check if given nid is a valid pin and no other events are assigned
4132 * to it.  If OK, assign the event, set the unsol flag, and returns 1.
4133 * Otherwise, returns zero.
4134 */
4135static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid,
4136                             unsigned int type)
4137{
4138        struct sigmatel_event *event;
4139        int tag;
4140
4141        if (!(get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP))
4142                return 0;
4143        event = stac_get_event(codec, nid);
4144        if (event) {
4145                if (event->type != type)
4146                        return 0;
4147                tag = event->tag;
4148        } else {
4149                tag = stac_add_event(codec->spec, nid, type, 0);
4150                if (tag < 0)
4151                        return 0;
4152        }
4153        snd_hda_codec_write_cache(codec, nid, 0,
4154                                  AC_VERB_SET_UNSOLICITED_ENABLE,
4155                                  AC_USRSP_EN | tag);
4156        return 1;
4157}
4158
4159static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid)
4160{
4161        int i;
4162        for (i = 0; i < cfg->hp_outs; i++)
4163                if (cfg->hp_pins[i] == nid)
4164                        return 1; /* nid is a HP-Out */
4165
4166        return 0; /* nid is not a HP-Out */
4167};
4168
4169static void stac92xx_power_down(struct hda_codec *codec)
4170{
4171        struct sigmatel_spec *spec = codec->spec;
4172
4173        /* power down inactive DACs */
4174        hda_nid_t *dac;
4175        for (dac = spec->dac_list; *dac; dac++)
4176                if (!check_all_dac_nids(spec, *dac))
4177                        snd_hda_codec_write(codec, *dac, 0,
4178                                        AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4179}
4180
4181static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid,
4182                                  int enable);
4183
4184static inline int get_int_hint(struct hda_codec *codec, const char *key,
4185                               int *valp)
4186{
4187        const char *p;
4188        p = snd_hda_get_hint(codec, key);
4189        if (p) {
4190                unsigned long val;
4191                if (!strict_strtoul(p, 0, &val)) {
4192                        *valp = val;
4193                        return 1;
4194                }
4195        }
4196        return 0;
4197}
4198
4199/* override some hints from the hwdep entry */
4200static void stac_store_hints(struct hda_codec *codec)
4201{
4202        struct sigmatel_spec *spec = codec->spec;
4203        int val;
4204
4205        val = snd_hda_get_bool_hint(codec, "hp_detect");
4206        if (val >= 0)
4207                spec->hp_detect = val;
4208        if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) {
4209                spec->eapd_mask = spec->gpio_dir = spec->gpio_data =
4210                        spec->gpio_mask;
4211        }
4212        if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir))
4213                spec->gpio_mask &= spec->gpio_mask;
4214        if (get_int_hint(codec, "gpio_data", &spec->gpio_data))
4215                spec->gpio_dir &= spec->gpio_mask;
4216        if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask))
4217                spec->eapd_mask &= spec->gpio_mask;
4218        if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute))
4219                spec->gpio_mute &= spec->gpio_mask;
4220        val = snd_hda_get_bool_hint(codec, "eapd_switch");
4221        if (val >= 0)
4222                spec->eapd_switch = val;
4223        get_int_hint(codec, "gpio_led_polarity", &spec->gpio_led_polarity);
4224        if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) {
4225                spec->gpio_mask |= spec->gpio_led;
4226                spec->gpio_dir |= spec->gpio_led;
4227                if (spec->gpio_led_polarity)
4228                        spec->gpio_data |= spec->gpio_led;
4229        }
4230}
4231
4232static int stac92xx_init(struct hda_codec *codec)
4233{
4234        struct sigmatel_spec *spec = codec->spec;
4235        struct auto_pin_cfg *cfg = &spec->autocfg;
4236        unsigned int gpio;
4237        int i;
4238
4239        snd_hda_sequence_write(codec, spec->init);
4240
4241        /* power down adcs initially */
4242        if (spec->powerdown_adcs)
4243                for (i = 0; i < spec->num_adcs; i++)
4244                        snd_hda_codec_write(codec,
4245                                spec->adc_nids[i], 0,
4246                                AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
4247
4248        /* override some hints */
4249        stac_store_hints(codec);
4250
4251        /* set up GPIO */
4252        gpio = spec->gpio_data;
4253        /* turn on EAPD statically when spec->eapd_switch isn't set.
4254         * otherwise, unsol event will turn it on/off dynamically
4255         */
4256        if (!spec->eapd_switch)
4257                gpio |= spec->eapd_mask;
4258        stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio);
4259
4260        /* set up pins */
4261        if (spec->hp_detect) {
4262                /* Enable unsolicited responses on the HP widget */
4263                for (i = 0; i < cfg->hp_outs; i++) {
4264                        hda_nid_t nid = cfg->hp_pins[i];
4265                        enable_pin_detect(codec, nid, STAC_HP_EVENT);
4266                }
4267                if (cfg->line_out_type == AUTO_PIN_LINE_OUT &&
4268                    cfg->speaker_outs > 0) {
4269                        /* enable pin-detect for line-outs as well */
4270                        for (i = 0; i < cfg->line_outs; i++) {
4271                                hda_nid_t nid = cfg->line_out_pins[i];
4272                                enable_pin_detect(codec, nid, STAC_LO_EVENT);
4273                        }
4274                }
4275
4276                /* force to enable the first line-out; the others are set up
4277                 * in unsol_event
4278                 */
4279                stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0],
4280                                AC_PINCTL_OUT_EN);
4281                /* fake event to set up pins */
4282                if (cfg->hp_pins[0])
4283                        stac_issue_unsol_event(codec, cfg->hp_pins[0]);
4284                else if (cfg->line_out_pins[0])
4285                        stac_issue_unsol_event(codec, cfg->line_out_pins[0]);
4286        } else {
4287                stac92xx_auto_init_multi_out(codec);
4288                stac92xx_auto_init_hp_out(codec);
4289                for (i = 0; i < cfg->hp_outs; i++)
4290                        stac_toggle_power_map(codec, cfg->hp_pins[i], 1);
4291        }
4292        if (spec->auto_mic) {
4293                /* initialize connection to analog input */
4294                if (spec->dmux_nids)
4295                        snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0,
4296                                          AC_VERB_SET_CONNECT_SEL, 0);
4297                if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT))
4298                        stac_issue_unsol_event(codec, spec->ext_mic.pin);
4299                if (enable_pin_detect(codec, spec->dock_mic.pin,
4300                    STAC_MIC_EVENT))
4301                        stac_issue_unsol_event(codec, spec->dock_mic.pin);
4302        }
4303        for (i = 0; i < cfg->num_inputs; i++) {
4304                hda_nid_t nid = cfg->inputs[