sound/pci/hda/patch_cirrus.c

   1 /*
   2  * HD audio interface patch for Cirrus Logic CS420x chip
   3  *
   4  * Copyright (c) 2009 Takashi Iwai <tiwai@suse.de>
   5  *
   6  *  This driver is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This driver is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19  */
  20
  21 #include <linux/init.h>
  22 #include <linux/delay.h>
  23 #include <linux/slab.h>
  24 #include <linux/pci.h>
  25 #include <linux/module.h>
  26 #include <sound/core.h>
  27 #include "hda_codec.h"
  28 #include "hda_local.h"
  29 #include "hda_auto_parser.h"
  30 #include "hda_jack.h"
  31 #include <sound/tlv.h>
  32
  33 /*
  34  */
  35
  36 struct cs_spec {
  37         struct hda_gen_spec gen;
  38
  39         struct auto_pin_cfg autocfg;
  40         struct hda_multi_out multiout;
  41         struct snd_kcontrol *vmaster_sw;
  42         struct snd_kcontrol *vmaster_vol;
  43
  44         hda_nid_t dac_nid[AUTO_CFG_MAX_OUTS];
  45         hda_nid_t slave_dig_outs[2];
  46
  47         unsigned int input_idx[AUTO_PIN_LAST];
  48         unsigned int capsrc_idx[AUTO_PIN_LAST];
  49         hda_nid_t adc_nid[AUTO_PIN_LAST];
  50         unsigned int adc_idx[AUTO_PIN_LAST];
  51         unsigned int num_inputs;
  52         unsigned int cur_input;
  53         unsigned int automic_idx;
  54         hda_nid_t cur_adc;
  55         unsigned int cur_adc_stream_tag;
  56         unsigned int cur_adc_format;
  57         hda_nid_t dig_in;
  58
  59         const struct hda_bind_ctls *capture_bind[2];
  60
  61         unsigned int gpio_mask;
  62         unsigned int gpio_dir;
  63         unsigned int gpio_data;
  64         unsigned int gpio_eapd_hp; /* EAPD GPIO bit for headphones */
  65         unsigned int gpio_eapd_speaker; /* EAPD GPIO bit for speakers */
  66
  67         struct hda_pcm pcm_rec[2];      /* PCM information */
  68
  69         unsigned int hp_detect:1;
  70         unsigned int mic_detect:1;
  71         /* CS421x */
  72         unsigned int spdif_detect:1;
  73         unsigned int sense_b:1;
  74         hda_nid_t vendor_nid;
  75         struct hda_input_mux input_mux;
  76         unsigned int last_input;
  77 };
  78
  79 /* available models with CS420x */
  80 enum {
  81         CS420X_MBP53,
  82         CS420X_MBP55,
  83         CS420X_IMAC27,
  84         CS420X_GPIO_13,
  85         CS420X_GPIO_23,
  86         CS420X_MBP101,
  87         CS420X_MBP101_COEF,
  88         CS420X_AUTO,
  89         /* aliases */
  90         CS420X_IMAC27_122 = CS420X_GPIO_23,
  91         CS420X_APPLE = CS420X_GPIO_13,
  92 };
  93
  94 /* CS421x boards */
  95 enum {
  96         CS421X_CDB4210,
  97         CS421X_SENSE_B,
  98 };
  99
 100 /* Vendor-specific processing widget */
 101 #define CS420X_VENDOR_NID       0x11
 102 #define CS_DIG_OUT1_PIN_NID     0x10
 103 #define CS_DIG_OUT2_PIN_NID     0x15
 104 #define CS_DMIC1_PIN_NID        0x0e
 105 #define CS_DMIC2_PIN_NID        0x12
 106
 107 /* coef indices */
 108 #define IDX_SPDIF_STAT          0x0000
 109 #define IDX_SPDIF_CTL           0x0001
 110 #define IDX_ADC_CFG             0x0002
 111 /* SZC bitmask, 4 modes below:
 112  * 0 = immediate,
 113  * 1 = digital immediate, analog zero-cross
 114  * 2 = digtail & analog soft-ramp
 115  * 3 = digital soft-ramp, analog zero-cross
 116  */
 117 #define   CS_COEF_ADC_SZC_MASK          (3 << 0)
 118 #define   CS_COEF_ADC_MIC_SZC_MODE      (3 << 0) /* SZC setup for mic */
 119 #define   CS_COEF_ADC_LI_SZC_MODE       (3 << 0) /* SZC setup for line-in */
 120 /* PGA mode: 0 = differential, 1 = signle-ended */
 121 #define   CS_COEF_ADC_MIC_PGA_MODE      (1 << 5) /* PGA setup for mic */
 122 #define   CS_COEF_ADC_LI_PGA_MODE       (1 << 6) /* PGA setup for line-in */
 123 #define IDX_DAC_CFG             0x0003
 124 /* SZC bitmask, 4 modes below:
 125  * 0 = Immediate
 126  * 1 = zero-cross
 127  * 2 = soft-ramp
 128  * 3 = soft-ramp on zero-cross
 129  */
 130 #define   CS_COEF_DAC_HP_SZC_MODE       (3 << 0) /* nid 0x02 */
 131 #define   CS_COEF_DAC_LO_SZC_MODE       (3 << 2) /* nid 0x03 */
 132 #define   CS_COEF_DAC_SPK_SZC_MODE      (3 << 4) /* nid 0x04 */
 133
 134 #define IDX_BEEP_CFG            0x0004
 135 /* 0x0008 - test reg key */
 136 /* 0x0009 - 0x0014 -> 12 test regs */
 137 /* 0x0015 - visibility reg */
 138
 139 /*
 140  * Cirrus Logic CS4210
 141  *
 142  * 1 DAC => HP(sense) / Speakers,
 143  * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
 144  * 1 SPDIF OUT => SPDIF Trasmitter(sense)
 145 */
 146 #define CS4210_DAC_NID          0x02
 147 #define CS4210_ADC_NID          0x03
 148 #define CS4210_VENDOR_NID       0x0B
 149 #define CS421X_DMIC_PIN_NID     0x09 /* Port E */
 150 #define CS421X_SPDIF_PIN_NID    0x0A /* Port H */
 151
 152 #define CS421X_IDX_DEV_CFG      0x01
 153 #define CS421X_IDX_ADC_CFG      0x02
 154 #define CS421X_IDX_DAC_CFG      0x03
 155 #define CS421X_IDX_SPK_CTL      0x04
 156
 157 #define SPDIF_EVENT             0x04
 158
 159 /* Cirrus Logic CS4213 is like CS4210 but does not have SPDIF input/output */
 160 #define CS4213_VENDOR_NID       0x09
 161
 162
 163 static inline int cs_vendor_coef_get(struct hda_codec *codec, unsigned int idx)
 164 {
 165         struct cs_spec *spec = codec->spec;
 166         snd_hda_codec_write(codec, spec->vendor_nid, 0,
 167                             AC_VERB_SET_COEF_INDEX, idx);
 168         return snd_hda_codec_read(codec, spec->vendor_nid, 0,
 169                                   AC_VERB_GET_PROC_COEF, 0);
 170 }
 171
 172 static inline void cs_vendor_coef_set(struct hda_codec *codec, unsigned int idx,
 173                                       unsigned int coef)
 174 {
 175         struct cs_spec *spec = codec->spec;
 176         snd_hda_codec_write(codec, spec->vendor_nid, 0,
 177                             AC_VERB_SET_COEF_INDEX, idx);
 178         snd_hda_codec_write(codec, spec->vendor_nid, 0,
 179                             AC_VERB_SET_PROC_COEF, coef);
 180 }
 181
 182
 183 #define HP_EVENT        1
 184 #define MIC_EVENT       2
 185
 186 /*
 187  * PCM callbacks
 188  */
 189 static int cs_playback_pcm_open(struct hda_pcm_stream *hinfo,
 190                                 struct hda_codec *codec,
 191                                 struct snd_pcm_substream *substream)
 192 {
 193         struct cs_spec *spec = codec->spec;
 194         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
 195                                              hinfo);
 196 }
 197
 198 static int cs_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 199                                    struct hda_codec *codec,
 200                                    unsigned int stream_tag,
 201                                    unsigned int format,
 202                                    struct snd_pcm_substream *substream)
 203 {
 204         struct cs_spec *spec = codec->spec;
 205         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
 206                                                 stream_tag, format, substream);
 207 }
 208
 209 static int cs_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 210                                    struct hda_codec *codec,
 211                                    struct snd_pcm_substream *substream)
 212 {
 213         struct cs_spec *spec = codec->spec;
 214         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
 215 }
 216
 217 /*
 218  * Digital out
 219  */
 220 static int cs_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
 221                                     struct hda_codec *codec,
 222                                     struct snd_pcm_substream *substream)
 223 {
 224         struct cs_spec *spec = codec->spec;
 225         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
 226 }
 227
 228 static int cs_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
 229                                      struct hda_codec *codec,
 230                                      struct snd_pcm_substream *substream)
 231 {
 232         struct cs_spec *spec = codec->spec;
 233         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
 234 }
 235
 236 static int cs_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
 237                                        struct hda_codec *codec,
 238                                        unsigned int stream_tag,
 239                                        unsigned int format,
 240                                        struct snd_pcm_substream *substream)
 241 {
 242         struct cs_spec *spec = codec->spec;
 243         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
 244                                              format, substream);
 245 }
 246
 247 static int cs_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
 248                                        struct hda_codec *codec,
 249                                        struct snd_pcm_substream *substream)
 250 {
 251         struct cs_spec *spec = codec->spec;
 252         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
 253 }
 254
 255 static void cs_update_input_select(struct hda_codec *codec)
 256 {
 257         struct cs_spec *spec = codec->spec;
 258         if (spec->cur_adc)
 259                 snd_hda_codec_write(codec, spec->cur_adc, 0,
 260                                     AC_VERB_SET_CONNECT_SEL,
 261                                     spec->adc_idx[spec->cur_input]);
 262 }
 263
 264 /*
 265  * Analog capture
 266  */
 267 static int cs_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
 268                                   struct hda_codec *codec,
 269                                   unsigned int stream_tag,
 270                                   unsigned int format,
 271                                   struct snd_pcm_substream *substream)
 272 {
 273         struct cs_spec *spec = codec->spec;
 274         spec->cur_adc = spec->adc_nid[spec->cur_input];
 275         spec->cur_adc_stream_tag = stream_tag;
 276         spec->cur_adc_format = format;
 277         cs_update_input_select(codec);
 278         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
 279         return 0;
 280 }
 281
 282 static int cs_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
 283                                   struct hda_codec *codec,
 284                                   struct snd_pcm_substream *substream)
 285 {
 286         struct cs_spec *spec = codec->spec;
 287         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
 288         spec->cur_adc = 0;
 289         return 0;
 290 }
 291
 292 /*
 293  */
 294 static const struct hda_pcm_stream cs_pcm_analog_playback = {
 295         .substreams = 1,
 296         .channels_min = 2,
 297         .channels_max = 2,
 298         .ops = {
 299                 .open = cs_playback_pcm_open,
 300                 .prepare = cs_playback_pcm_prepare,
 301                 .cleanup = cs_playback_pcm_cleanup
 302         },
 303 };
 304
 305 static const struct hda_pcm_stream cs_pcm_analog_capture = {
 306         .substreams = 1,
 307         .channels_min = 2,
 308         .channels_max = 2,
 309         .ops = {
 310                 .prepare = cs_capture_pcm_prepare,
 311                 .cleanup = cs_capture_pcm_cleanup
 312         },
 313 };
 314
 315 static const struct hda_pcm_stream cs_pcm_digital_playback = {
 316         .substreams = 1,
 317         .channels_min = 2,
 318         .channels_max = 2,
 319         .ops = {
 320                 .open = cs_dig_playback_pcm_open,
 321                 .close = cs_dig_playback_pcm_close,
 322                 .prepare = cs_dig_playback_pcm_prepare,
 323                 .cleanup = cs_dig_playback_pcm_cleanup
 324         },
 325 };
 326
 327 static const struct hda_pcm_stream cs_pcm_digital_capture = {
 328         .substreams = 1,
 329         .channels_min = 2,
 330         .channels_max = 2,
 331 };
 332
 333 static int cs_build_pcms(struct hda_codec *codec)
 334 {
 335         struct cs_spec *spec = codec->spec;
 336         struct hda_pcm *info = spec->pcm_rec;
 337
 338         codec->pcm_info = info;
 339         codec->num_pcms = 0;
 340
 341         info->name = "Cirrus Analog";
 342         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = cs_pcm_analog_playback;
 343         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dac_nid[0];
 344         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
 345                 spec->multiout.max_channels;
 346         info->stream[SNDRV_PCM_STREAM_CAPTURE] = cs_pcm_analog_capture;
 347         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
 348                 spec->adc_nid[spec->cur_input];
 349         codec->num_pcms++;
 350
 351         if (!spec->multiout.dig_out_nid && !spec->dig_in)
 352                 return 0;
 353
 354         info++;
 355         info->name = "Cirrus Digital";
 356         info->pcm_type = spec->autocfg.dig_out_type[0];
 357         if (!info->pcm_type)
 358                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
 359         if (spec->multiout.dig_out_nid) {
 360                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
 361                         cs_pcm_digital_playback;
 362                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
 363                         spec->multiout.dig_out_nid;
 364         }
 365         if (spec->dig_in) {
 366                 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
 367                         cs_pcm_digital_capture;
 368                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in;
 369         }
 370         codec->num_pcms++;
 371
 372         return 0;
 373 }
 374
 375 /*
 376  * parse codec topology
 377  */
 378
 379 static hda_nid_t get_dac(struct hda_codec *codec, hda_nid_t pin)
 380 {
 381         hda_nid_t dac;
 382         if (!pin)
 383                 return 0;
 384         if (snd_hda_get_connections(codec, pin, &dac, 1) != 1)
 385                 return 0;
 386         return dac;
 387 }
 388
 389 static int is_ext_mic(struct hda_codec *codec, unsigned int idx)
 390 {
 391         struct cs_spec *spec = codec->spec;
 392         struct auto_pin_cfg *cfg = &spec->autocfg;
 393         hda_nid_t pin = cfg->inputs[idx].pin;
 394         unsigned int val;
 395         if (!is_jack_detectable(codec, pin))
 396                 return 0;
 397         val = snd_hda_codec_get_pincfg(codec, pin);
 398         return (snd_hda_get_input_pin_attr(val) != INPUT_PIN_ATTR_INT);
 399 }
 400
 401 static hda_nid_t get_adc(struct hda_codec *codec, hda_nid_t pin,
 402                          unsigned int *idxp)
 403 {
 404         int i, idx;
 405         hda_nid_t nid;
 406
 407         nid = codec->start_nid;
 408         for (i = 0; i < codec->num_nodes; i++, nid++) {
 409                 unsigned int type;
 410                 type = get_wcaps_type(get_wcaps(codec, nid));
 411                 if (type != AC_WID_AUD_IN)
 412                         continue;
 413                 idx = snd_hda_get_conn_index(codec, nid, pin, false);
 414                 if (idx >= 0) {
 415                         *idxp = idx;
 416                         return nid;
 417                 }
 418         }
 419         return 0;
 420 }
 421
 422 static int is_active_pin(struct hda_codec *codec, hda_nid_t nid)
 423 {
 424         unsigned int val;
 425         val = snd_hda_codec_get_pincfg(codec, nid);
 426         return (get_defcfg_connect(val) != AC_JACK_PORT_NONE);
 427 }
 428
 429 static int parse_output(struct hda_codec *codec)
 430 {
 431         struct cs_spec *spec = codec->spec;
 432         struct auto_pin_cfg *cfg = &spec->autocfg;
 433         int i, extra_nids;
 434         hda_nid_t dac;
 435
 436         for (i = 0; i < cfg->line_outs; i++) {
 437                 dac = get_dac(codec, cfg->line_out_pins[i]);
 438                 if (!dac)
 439                         break;
 440                 spec->dac_nid[i] = dac;
 441         }
 442         spec->multiout.num_dacs = i;
 443         spec->multiout.dac_nids = spec->dac_nid;
 444         spec->multiout.max_channels = i * 2;
 445
 446         /* add HP and speakers */
 447         extra_nids = 0;
 448         for (i = 0; i < cfg->hp_outs; i++) {
 449                 dac = get_dac(codec, cfg->hp_pins[i]);
 450                 if (!dac)
 451                         break;
 452                 if (!i)
 453                         spec->multiout.hp_nid = dac;
 454                 else
 455                         spec->multiout.extra_out_nid[extra_nids++] = dac;
 456         }
 457         for (i = 0; i < cfg->speaker_outs; i++) {
 458                 dac = get_dac(codec, cfg->speaker_pins[i]);
 459                 if (!dac)
 460                         break;
 461                 spec->multiout.extra_out_nid[extra_nids++] = dac;
 462         }
 463
 464         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
 465                 cfg->speaker_outs = cfg->line_outs;
 466                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
 467                        sizeof(cfg->speaker_pins));
 468                 cfg->line_outs = 0;
 469         }
 470
 471         return 0;
 472 }
 473
 474 static int parse_input(struct hda_codec *codec)
 475 {
 476         struct cs_spec *spec = codec->spec;
 477         struct auto_pin_cfg *cfg = &spec->autocfg;
 478         int i;
 479
 480         for (i = 0; i < cfg->num_inputs; i++) {
 481                 hda_nid_t pin = cfg->inputs[i].pin;
 482                 spec->input_idx[spec->num_inputs] = i;
 483                 spec->capsrc_idx[i] = spec->num_inputs++;
 484                 spec->cur_input = i;
 485                 spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
 486         }
 487         if (!spec->num_inputs)
 488                 return 0;
 489
 490         /* check whether the automatic mic switch is available */
 491         if (spec->num_inputs == 2 &&
 492             cfg->inputs[0].type == AUTO_PIN_MIC &&
 493             cfg->inputs[1].type == AUTO_PIN_MIC) {
 494                 if (is_ext_mic(codec, cfg->inputs[0].pin)) {
 495                         if (!is_ext_mic(codec, cfg->inputs[1].pin)) {
 496                                 spec->mic_detect = 1;
 497                                 spec->automic_idx = 0;
 498                         }
 499                 } else {
 500                         if (is_ext_mic(codec, cfg->inputs[1].pin)) {
 501                                 spec->mic_detect = 1;
 502                                 spec->automic_idx = 1;
 503                         }
 504                 }
 505         }
 506         return 0;
 507 }
 508
 509
 510 static int parse_digital_output(struct hda_codec *codec)
 511 {
 512         struct cs_spec *spec = codec->spec;
 513         struct auto_pin_cfg *cfg = &spec->autocfg;
 514         hda_nid_t nid;
 515
 516         if (!cfg->dig_outs)
 517                 return 0;
 518         if (snd_hda_get_connections(codec, cfg->dig_out_pins[0], &nid, 1) < 1)
 519                 return 0;
 520         spec->multiout.dig_out_nid = nid;
 521         spec->multiout.share_spdif = 1;
 522         if (cfg->dig_outs > 1 &&
 523             snd_hda_get_connections(codec, cfg->dig_out_pins[1], &nid, 1) > 0) {
 524                 spec->slave_dig_outs[0] = nid;
 525                 codec->slave_dig_outs = spec->slave_dig_outs;
 526         }
 527         return 0;
 528 }
 529
 530 static int parse_digital_input(struct hda_codec *codec)
 531 {
 532         struct cs_spec *spec = codec->spec;
 533         struct auto_pin_cfg *cfg = &spec->autocfg;
 534         int idx;
 535
 536         if (cfg->dig_in_pin)
 537                 spec->dig_in = get_adc(codec, cfg->dig_in_pin, &idx);
 538         return 0;
 539 }
 540
 541 /*
 542  * create mixer controls
 543  */
 544
 545 static const char * const dir_sfx[2] = { "Playback", "Capture" };
 546
 547 static int add_mute(struct hda_codec *codec, const char *name, int index,
 548                     unsigned int pval, int dir, struct snd_kcontrol **kctlp)
 549 {
 550         char tmp[44];
 551         struct snd_kcontrol_new knew =
 552                 HDA_CODEC_MUTE_IDX(tmp, index, 0, 0, HDA_OUTPUT);
 553         knew.private_value = pval;
 554         snprintf(tmp, sizeof(tmp), "%s %s Switch", name, dir_sfx[dir]);
 555         *kctlp = snd_ctl_new1(&knew, codec);
 556         (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG;
 557         return snd_hda_ctl_add(codec, 0, *kctlp);
 558 }
 559
 560 static int add_volume(struct hda_codec *codec, const char *name,
 561                       int index, unsigned int pval, int dir,
 562                       struct snd_kcontrol **kctlp)
 563 {
 564         char tmp[44];
 565         struct snd_kcontrol_new knew =
 566                 HDA_CODEC_VOLUME_IDX(tmp, index, 0, 0, HDA_OUTPUT);
 567         knew.private_value = pval;
 568         snprintf(tmp, sizeof(tmp), "%s %s Volume", name, dir_sfx[dir]);
 569         *kctlp = snd_ctl_new1(&knew, codec);
 570         (*kctlp)->id.subdevice = HDA_SUBDEV_AMP_FLAG;
 571         return snd_hda_ctl_add(codec, 0, *kctlp);
 572 }
 573
 574 static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac)
 575 {
 576         unsigned int caps;
 577
 578         /* set the upper-limit for mixer amp to 0dB */
 579         caps = query_amp_caps(codec, dac, HDA_OUTPUT);
 580         caps &= ~(0x7f << AC_AMPCAP_NUM_STEPS_SHIFT);
 581         caps |= ((caps >> AC_AMPCAP_OFFSET_SHIFT) & 0x7f)
 582                 << AC_AMPCAP_NUM_STEPS_SHIFT;
 583         snd_hda_override_amp_caps(codec, dac, HDA_OUTPUT, caps);
 584 }
 585
 586 static int add_vmaster(struct hda_codec *codec, hda_nid_t dac)
 587 {
 588         struct cs_spec *spec = codec->spec;
 589         unsigned int tlv[4];
 590         int err;
 591
 592         spec->vmaster_sw =
 593                 snd_ctl_make_virtual_master("Master Playback Switch", NULL);
 594         err = snd_hda_ctl_add(codec, dac, spec->vmaster_sw);
 595         if (err < 0)
 596                 return err;
 597
 598         snd_hda_set_vmaster_tlv(codec, dac, HDA_OUTPUT, tlv);
 599         spec->vmaster_vol =
 600                 snd_ctl_make_virtual_master("Master Playback Volume", tlv);
 601         err = snd_hda_ctl_add(codec, dac, spec->vmaster_vol);
 602         if (err < 0)
 603                 return err;
 604         return 0;
 605 }
 606
 607 static int add_output(struct hda_codec *codec, hda_nid_t dac, int idx,
 608                       int num_ctls, int type)
 609 {
 610         struct cs_spec *spec = codec->spec;
 611         const char *name;
 612         int err, index;
 613         struct snd_kcontrol *kctl;
 614         static const char * const speakers[] = {
 615                 "Front Speaker", "Surround Speaker", "Bass Speaker"
 616         };
 617         static const char * const line_outs[] = {
 618                 "Front Line Out", "Surround Line Out", "Bass Line Out"
 619         };
 620
 621         fix_volume_caps(codec, dac);
 622         if (!spec->vmaster_sw) {
 623                 err = add_vmaster(codec, dac);
 624                 if (err < 0)
 625                         return err;
 626         }
 627
 628         index = 0;
 629         switch (type) {
 630         case AUTO_PIN_HP_OUT:
 631                 name = "Headphone";
 632                 index = idx;
 633                 break;
 634         case AUTO_PIN_SPEAKER_OUT:
 635                 if (num_ctls > 1)
 636                         name = speakers[idx];
 637                 else
 638                         name = "Speaker";
 639                 break;
 640         default:
 641                 if (num_ctls > 1)
 642                         name = line_outs[idx];
 643                 else
 644                         name = "Line Out";
 645                 break;
 646         }
 647
 648         err = add_mute(codec, name, index,
 649                        HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
 650         if (err < 0)
 651                 return err;
 652         err = snd_ctl_add_slave(spec->vmaster_sw, kctl);
 653         if (err < 0)
 654                 return err;
 655
 656         err = add_volume(codec, name, index,
 657                          HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
 658         if (err < 0)
 659                 return err;
 660         err = snd_ctl_add_slave(spec->vmaster_vol, kctl);
 661         if (err < 0)
 662                 return err;
 663
 664         return 0;
 665 }
 666
 667 static int build_output(struct hda_codec *codec)
 668 {
 669         struct cs_spec *spec = codec->spec;
 670         struct auto_pin_cfg *cfg = &spec->autocfg;
 671         int i, err;
 672
 673         for (i = 0; i < cfg->line_outs; i++) {
 674                 err = add_output(codec, get_dac(codec, cfg->line_out_pins[i]),
 675                                  i, cfg->line_outs, cfg->line_out_type);
 676                 if (err < 0)
 677                         return err;
 678         }
 679         for (i = 0; i < cfg->hp_outs; i++) {
 680                 err = add_output(codec, get_dac(codec, cfg->hp_pins[i]),
 681                                  i, cfg->hp_outs, AUTO_PIN_HP_OUT);
 682                 if (err < 0)
 683                         return err;
 684         }
 685         for (i = 0; i < cfg->speaker_outs; i++) {
 686                 err = add_output(codec, get_dac(codec, cfg->speaker_pins[i]),
 687                                  i, cfg->speaker_outs, AUTO_PIN_SPEAKER_OUT);
 688                 if (err < 0)
 689                         return err;
 690         }
 691         return 0;
 692 }
 693
 694 /*
 695  */
 696
 697 static const struct snd_kcontrol_new cs_capture_ctls[] = {
 698         HDA_BIND_SW("Capture Switch", 0),
 699         HDA_BIND_VOL("Capture Volume", 0),
 700 };
 701
 702 static int change_cur_input(struct hda_codec *codec, unsigned int idx,
 703                             int force)
 704 {
 705         struct cs_spec *spec = codec->spec;
 706
 707         if (spec->cur_input == idx && !force)
 708                 return 0;
 709         if (spec->cur_adc && spec->cur_adc != spec->adc_nid[idx]) {
 710                 /* stream is running, let's swap the current ADC */
 711                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
 712                 spec->cur_adc = spec->adc_nid[idx];
 713                 snd_hda_codec_setup_stream(codec, spec->cur_adc,
 714                                            spec->cur_adc_stream_tag, 0,
 715                                            spec->cur_adc_format);
 716         }
 717         spec->cur_input = idx;
 718         cs_update_input_select(codec);
 719         return 1;
 720 }
 721
 722 static int cs_capture_source_info(struct snd_kcontrol *kcontrol,
 723                                   struct snd_ctl_elem_info *uinfo)
 724 {
 725         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 726         struct cs_spec *spec = codec->spec;
 727         struct auto_pin_cfg *cfg = &spec->autocfg;
 728         unsigned int idx;
 729
 730         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 731         uinfo->count = 1;
 732         uinfo->value.enumerated.items = spec->num_inputs;
 733         if (uinfo->value.enumerated.item >= spec->num_inputs)
 734                 uinfo->value.enumerated.item = spec->num_inputs - 1;
 735         idx = spec->input_idx[uinfo->value.enumerated.item];
 736         snd_hda_get_pin_label(codec, cfg->inputs[idx].pin, cfg,
 737                               uinfo->value.enumerated.name,
 738                               sizeof(uinfo->value.enumerated.name), NULL);
 739         return 0;
 740 }
 741
 742 static int cs_capture_source_get(struct snd_kcontrol *kcontrol,
 743                                  struct snd_ctl_elem_value *ucontrol)
 744 {
 745         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 746         struct cs_spec *spec = codec->spec;
 747         ucontrol->value.enumerated.item[0] = spec->capsrc_idx[spec->cur_input];
 748         return 0;
 749 }
 750
 751 static int cs_capture_source_put(struct snd_kcontrol *kcontrol,
 752                                  struct snd_ctl_elem_value *ucontrol)
 753 {
 754         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 755         struct cs_spec *spec = codec->spec;
 756         unsigned int idx = ucontrol->value.enumerated.item[0];
 757
 758         if (idx >= spec->num_inputs)
 759                 return -EINVAL;
 760         idx = spec->input_idx[idx];
 761         return change_cur_input(codec, idx, 0);
 762 }
 763
 764 static const struct snd_kcontrol_new cs_capture_source = {
 765         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 766         .name = "Capture Source",
 767         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 768         .info = cs_capture_source_info,
 769         .get = cs_capture_source_get,
 770         .put = cs_capture_source_put,
 771 };
 772
 773 static const struct hda_bind_ctls *make_bind_capture(struct hda_codec *codec,
 774                                                struct hda_ctl_ops *ops)
 775 {
 776         struct cs_spec *spec = codec->spec;
 777         struct hda_bind_ctls *bind;
 778         int i, n;
 779
 780         bind = kzalloc(sizeof(*bind) + sizeof(long) * (spec->num_inputs + 1),
 781                        GFP_KERNEL);
 782         if (!bind)
 783                 return NULL;
 784         bind->ops = ops;
 785         n = 0;
 786         for (i = 0; i < AUTO_PIN_LAST; i++) {
 787                 if (!spec->adc_nid[i])
 788                         continue;
 789                 bind->values[n++] =
 790                         HDA_COMPOSE_AMP_VAL(spec->adc_nid[i], 3,
 791                                             spec->adc_idx[i], HDA_INPUT);
 792         }
 793         return bind;
 794 }
 795
 796 /* add a (input-boost) volume control to the given input pin */
 797 static int add_input_volume_control(struct hda_codec *codec,
 798                                     struct auto_pin_cfg *cfg,
 799                                     int item)
 800 {
 801         hda_nid_t pin = cfg->inputs[item].pin;
 802         u32 caps;
 803         const char *label;
 804         struct snd_kcontrol *kctl;
 805
 806         if (!(get_wcaps(codec, pin) & AC_WCAP_IN_AMP))
 807                 return 0;
 808         caps = query_amp_caps(codec, pin, HDA_INPUT);
 809         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
 810         if (caps <= 1)
 811                 return 0;
 812         label = hda_get_autocfg_input_label(codec, cfg, item);
 813         return add_volume(codec, label, 0,
 814                           HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT), 1, &kctl);
 815 }
 816
 817 static int build_input(struct hda_codec *codec)
 818 {
 819         struct cs_spec *spec = codec->spec;
 820         int i, err;
 821
 822         if (!spec->num_inputs)
 823                 return 0;
 824
 825         /* make bind-capture */
 826         spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
 827         spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
 828         for (i = 0; i < 2; i++) {
 829                 struct snd_kcontrol *kctl;
 830                 int n;
 831                 if (!spec->capture_bind[i])
 832                         return -ENOMEM;
 833                 kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
 834                 if (!kctl)
 835                         return -ENOMEM;
 836                 kctl->private_value = (long)spec->capture_bind[i];
 837                 err = snd_hda_ctl_add(codec, 0, kctl);
 838                 if (err < 0)
 839                         return err;
 840                 for (n = 0; n < AUTO_PIN_LAST; n++) {
 841                         if (!spec->adc_nid[n])
 842                                 continue;
 843                         err = snd_hda_add_nid(codec, kctl, 0, spec->adc_nid[n]);
 844                         if (err < 0)
 845                                 return err;
 846                 }
 847         }
 848
 849         if (spec->num_inputs > 1 && !spec->mic_detect) {
 850                 err = snd_hda_ctl_add(codec, 0,
 851                                       snd_ctl_new1(&cs_capture_source, codec));
 852                 if (err < 0)
 853                         return err;
 854         }
 855
 856         for (i = 0; i < spec->num_inputs; i++) {
 857                 err = add_input_volume_control(codec, &spec->autocfg, i);
 858                 if (err < 0)
 859                         return err;
 860         }
 861
 862         return 0;
 863 }
 864
 865 /*
 866  */
 867
 868 static int build_digital_output(struct hda_codec *codec)
 869 {
 870         struct cs_spec *spec = codec->spec;
 871         int err;
 872
 873         if (!spec->multiout.dig_out_nid)
 874                 return 0;
 875
 876         err = snd_hda_create_dig_out_ctls(codec, spec->multiout.dig_out_nid,
 877                                           spec->multiout.dig_out_nid,
 878                                           spec->pcm_rec[1].pcm_type);
 879         if (err < 0)
 880                 return err;
 881         err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
 882         if (err < 0)
 883                 return err;
 884         return 0;
 885 }
 886
 887 static int build_digital_input(struct hda_codec *codec)
 888 {
 889         struct cs_spec *spec = codec->spec;
 890         if (spec->dig_in)
 891                 return snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
 892         return 0;
 893 }
 894
 895 /*
 896  * auto-mute and auto-mic switching
 897  * CS421x auto-output redirecting
 898  * HP/SPK/SPDIF
 899  */
 900
 901 static void cs_automute(struct hda_codec *codec, struct hda_jack_tbl *tbl)
 902 {
 903         struct cs_spec *spec = codec->spec;
 904         struct auto_pin_cfg *cfg = &spec->autocfg;
 905         unsigned int hp_present;
 906         unsigned int spdif_present;
 907         hda_nid_t nid;
 908         int i;
 909
 910         spdif_present = 0;
 911         if (cfg->dig_outs) {
 912                 nid = cfg->dig_out_pins[0];
 913                 if (is_jack_detectable(codec, nid)) {
 914                         /*
 915                         TODO: SPDIF output redirect when SENSE_B is enabled.
 916                         Shared (SENSE_A) jack (e.g HP/mini-TOSLINK)
 917                         assumed.
 918                         */
 919                         if (snd_hda_jack_detect(codec, nid)
 920                                 /* && spec->sense_b */)
 921                                 spdif_present = 1;
 922                 }
 923         }
 924
 925         hp_present = 0;
 926         for (i = 0; i < cfg->hp_outs; i++) {
 927                 nid = cfg->hp_pins[i];
 928                 if (!is_jack_detectable(codec, nid))
 929                         continue;
 930                 hp_present = snd_hda_jack_detect(codec, nid);
 931                 if (hp_present)
 932                         break;
 933         }
 934
 935         /* mute speakers if spdif or hp jack is plugged in */
 936         for (i = 0; i < cfg->speaker_outs; i++) {
 937                 int pin_ctl = hp_present ? 0 : PIN_OUT;
 938                 /* detect on spdif is specific to CS4210 */
 939                 if (spdif_present && (spec->vendor_nid == CS4210_VENDOR_NID))
 940                         pin_ctl = 0;
 941
 942                 nid = cfg->speaker_pins[i];
 943                 snd_hda_set_pin_ctl(codec, nid, pin_ctl);
 944         }
 945         if (spec->gpio_eapd_hp) {
 946                 unsigned int gpio = hp_present ?
 947                         spec->gpio_eapd_hp : spec->gpio_eapd_speaker;
 948                 snd_hda_codec_write(codec, 0x01, 0,
 949                                     AC_VERB_SET_GPIO_DATA, gpio);
 950         }
 951
 952         /* specific to CS4210 */
 953         if (spec->vendor_nid == CS4210_VENDOR_NID) {
 954                 /* mute HPs if spdif jack (SENSE_B) is present */
 955                 for (i = 0; i < cfg->hp_outs; i++) {
 956                         nid = cfg->hp_pins[i];
 957                         snd_hda_set_pin_ctl(codec, nid,
 958                                 (spdif_present && spec->sense_b) ? 0 : PIN_HP);
 959                 }
 960
 961                 /* SPDIF TX on/off */
 962                 if (cfg->dig_outs) {
 963                         nid = cfg->dig_out_pins[0];
 964                         snd_hda_set_pin_ctl(codec, nid,
 965                                 spdif_present ? PIN_OUT : 0);
 966
 967                 }
 968                 /* Update board GPIOs if neccessary ... */
 969         }
 970 }
 971
 972 /*
 973  * Auto-input redirect for CS421x
 974  * Switch max 3 inputs of a single ADC (nid 3)
 975 */
 976
 977 static void cs_automic(struct hda_codec *codec, struct hda_jack_tbl *tbl)
 978 {
 979         struct cs_spec *spec = codec->spec;
 980         struct auto_pin_cfg *cfg = &spec->autocfg;
 981         hda_nid_t nid;
 982         unsigned int present;
 983
 984         nid = cfg->inputs[spec->automic_idx].pin;
 985         present = snd_hda_jack_detect(codec, nid);
 986
 987         /* specific to CS421x, single ADC */
 988         if (spec->vendor_nid == CS420X_VENDOR_NID) {
 989                 if (present)
 990                         change_cur_input(codec, spec->automic_idx, 0);
 991                 else
 992                         change_cur_input(codec, !spec->automic_idx, 0);
 993         } else {
 994                 if (present) {
 995                         if (spec->cur_input != spec->automic_idx) {
 996                                 spec->last_input = spec->cur_input;
 997                                 spec->cur_input = spec->automic_idx;
 998                         }
 999                 } else  {
1000                         spec->cur_input = spec->last_input;
1001                 }
1002                 cs_update_input_select(codec);
1003         }
1004 }
1005
1006 /*
1007  */
1008
1009 static void init_output(struct hda_codec *codec)
1010 {
1011         struct cs_spec *spec = codec->spec;
1012         struct auto_pin_cfg *cfg = &spec->autocfg;
1013         int i;
1014
1015         /* mute first */
1016         for (i = 0; i < spec->multiout.num_dacs; i++)
1017                 snd_hda_codec_write(codec, spec->multiout.dac_nids[i], 0,
1018                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1019         if (spec->multiout.hp_nid)
1020                 snd_hda_codec_write(codec, spec->multiout.hp_nid, 0,
1021                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1022         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
1023                 if (!spec->multiout.extra_out_nid[i])
1024                         break;
1025                 snd_hda_codec_write(codec, spec->multiout.extra_out_nid[i], 0,
1026                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1027         }
1028
1029         /* set appropriate pin controls */
1030         for (i = 0; i < cfg->line_outs; i++)
1031                 snd_hda_set_pin_ctl(codec, cfg->line_out_pins[i], PIN_OUT);
1032         /* HP */
1033         for (i = 0; i < cfg->hp_outs; i++) {
1034                 hda_nid_t nid = cfg->hp_pins[i];
1035                 snd_hda_set_pin_ctl(codec, nid, PIN_HP);
1036                 if (!cfg->speaker_outs)
1037                         continue;
1038                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
1039                         snd_hda_jack_detect_enable_callback(codec, nid, HP_EVENT, cs_automute);
1040                         spec->hp_detect = 1;
1041                 }
1042         }
1043
1044         /* Speaker */
1045         for (i = 0; i < cfg->speaker_outs; i++)
1046                 snd_hda_set_pin_ctl(codec, cfg->speaker_pins[i], PIN_OUT);
1047
1048         /* SPDIF is enabled on presence detect for CS421x */
1049         if (spec->hp_detect || spec->spdif_detect)
1050                 cs_automute(codec, NULL);
1051 }
1052
1053 static void init_input(struct hda_codec *codec)
1054 {
1055         struct cs_spec *spec = codec->spec;
1056         struct auto_pin_cfg *cfg = &spec->autocfg;
1057         unsigned int coef;
1058         int i;
1059
1060         for (i = 0; i < cfg->num_inputs; i++) {
1061                 unsigned int ctl;
1062                 hda_nid_t pin = cfg->inputs[i].pin;
1063                 if (!spec->adc_nid[i])
1064                         continue;
1065                 /* set appropriate pin control and mute first */
1066                 ctl = PIN_IN;
1067                 if (cfg->inputs[i].type == AUTO_PIN_MIC)
1068                         ctl |= snd_hda_get_default_vref(codec, pin);
1069                 snd_hda_set_pin_ctl(codec, pin, ctl);
1070                 snd_hda_codec_write(codec, spec->adc_nid[i], 0,
1071                                     AC_VERB_SET_AMP_GAIN_MUTE,
1072                                     AMP_IN_MUTE(spec->adc_idx[i]));
1073                 if (spec->mic_detect && spec->automic_idx == i)
1074                         snd_hda_jack_detect_enable_callback(codec, pin, MIC_EVENT, cs_automic);
1075         }
1076         /* CS420x has multiple ADC, CS421x has single ADC */
1077         if (spec->vendor_nid == CS420X_VENDOR_NID) {
1078                 change_cur_input(codec, spec->cur_input, 1);
1079                 if (spec->mic_detect)
1080                         cs_automic(codec, NULL);
1081
1082                 coef = 0x000a; /* ADC1/2 - Digital and Analog Soft Ramp */
1083                 cs_vendor_coef_set(codec, IDX_ADC_CFG, coef);
1084
1085                 coef = cs_vendor_coef_get(codec, IDX_BEEP_CFG);
1086                 if (is_active_pin(codec, CS_DMIC2_PIN_NID))
1087                         coef |= 1 << 4; /* DMIC2 2 chan on, GPIO1 off */
1088                 if (is_active_pin(codec, CS_DMIC1_PIN_NID))
1089                         coef |= 1 << 3; /* DMIC1 2 chan on, GPIO0 off
1090                                          * No effect if SPDIF_OUT2 is
1091                                          * selected in IDX_SPDIF_CTL.
1092                                         */
1093
1094                 cs_vendor_coef_set(codec, IDX_BEEP_CFG, coef);
1095         } else {
1096                 if (spec->mic_detect)
1097                         cs_automic(codec, NULL);
1098                 else  {
1099                         spec->cur_adc = spec->adc_nid[spec->cur_input];
1100                         cs_update_input_select(codec);
1101                 }
1102         }
1103 }
1104
1105 static const struct hda_verb cs_coef_init_verbs[] = {
1106         {0x11, AC_VERB_SET_PROC_STATE, 1},
1107         {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
1108         {0x11, AC_VERB_SET_PROC_COEF,
1109          (0x002a /* DAC1/2/3 SZCMode Soft Ramp */
1110           | 0x0040 /* Mute DACs on FIFO error */
1111           | 0x1000 /* Enable DACs High Pass Filter */
1112           | 0x0400 /* Disable Coefficient Auto increment */
1113           )},
1114         /* Beep */
1115         {0x11, AC_VERB_SET_COEF_INDEX, IDX_BEEP_CFG},
1116         {0x11, AC_VERB_SET_PROC_COEF, 0x0007}, /* Enable Beep thru DAC1/2/3 */
1117
1118         {} /* terminator */
1119 };
1120
1121 /* Errata: CS4207 rev C0/C1/C2 Silicon
1122  *
1123  * http://www.cirrus.com/en/pubs/errata/ER880C3.pdf
1124  *
1125  * 6. At high temperature (TA > +85°C), the digital supply current (IVD)
1126  * may be excessive (up to an additional 200 μA), which is most easily
1127  * observed while the part is being held in reset (RESET# active low).
1128  *
1129  * Root Cause: At initial powerup of the device, the logic that drives
1130  * the clock and write enable to the S/PDIF SRC RAMs is not properly
1131  * initialized.
1132  * Certain random patterns will cause a steady leakage current in those
1133  * RAM cells. The issue will resolve once the SRCs are used (turned on).
1134  *
1135  * Workaround: The following verb sequence briefly turns on the S/PDIF SRC
1136  * blocks, which will alleviate the issue.
1137  */
1138
1139 static const struct hda_verb cs_errata_init_verbs[] = {
1140         {0x01, AC_VERB_SET_POWER_STATE, 0x00}, /* AFG: D0 */
1141         {0x11, AC_VERB_SET_PROC_STATE, 0x01},  /* VPW: processing on */
1142
1143         {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1144         {0x11, AC_VERB_SET_PROC_COEF, 0x9999},
1145         {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1146         {0x11, AC_VERB_SET_PROC_COEF, 0xa412},
1147         {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1148         {0x11, AC_VERB_SET_PROC_COEF, 0x0009},
1149
1150         {0x07, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Rx: D0 */
1151         {0x08, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Tx: D0 */
1152
1153         {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1154         {0x11, AC_VERB_SET_PROC_COEF, 0x2412},
1155         {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1156         {0x11, AC_VERB_SET_PROC_COEF, 0x0000},
1157         {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1158         {0x11, AC_VERB_SET_PROC_COEF, 0x0008},
1159         {0x11, AC_VERB_SET_PROC_STATE, 0x00},
1160
1161 #if 0 /* Don't to set to D3 as we are in power-up sequence */
1162         {0x07, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Rx: D3 */
1163         {0x08, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Tx: D3 */
1164         /*{0x01, AC_VERB_SET_POWER_STATE, 0x03},*/ /* AFG: D3 This is already handled */
1165 #endif
1166
1167         {} /* terminator */
1168 };
1169
1170 static const struct hda_verb mbp101_init_verbs[] = {
1171         {0x11, AC_VERB_SET_COEF_INDEX, 0x0002},
1172         {0x11, AC_VERB_SET_PROC_COEF, 0x100a},
1173         {0x11, AC_VERB_SET_COEF_INDEX, 0x0004},
1174         {0x11, AC_VERB_SET_PROC_COEF, 0x000f},
1175         {}
1176 };
1177
1178 /* SPDIF setup */
1179 static void init_digital(struct hda_codec *codec)
1180 {
1181         unsigned int coef;
1182
1183         coef = 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */
1184         coef |= 0x0008; /* Replace with mute on error */
1185         if (is_active_pin(codec, CS_DIG_OUT2_PIN_NID))
1186                 coef |= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2
1187                                  * SPDIF_OUT2 is shared with GPIO1 and
1188                                  * DMIC_SDA2.
1189                                  */
1190         cs_vendor_coef_set(codec, IDX_SPDIF_CTL, coef);
1191 }
1192
1193 static int cs_init(struct hda_codec *codec)
1194 {
1195         struct cs_spec *spec = codec->spec;
1196
1197         /* init_verb sequence for C0/C1/C2 errata*/
1198         snd_hda_sequence_write(codec, cs_errata_init_verbs);
1199
1200         snd_hda_sequence_write(codec, cs_coef_init_verbs);
1201
1202         if (spec->gpio_mask) {
1203                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1204                                     spec->gpio_mask);
1205                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1206                                     spec->gpio_dir);
1207                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1208                                     spec->gpio_data);
1209         }
1210
1211         init_output(codec);
1212         init_input(codec);
1213         init_digital(codec);
1214
1215         return 0;
1216 }
1217
1218 static int cs_build_controls(struct hda_codec *codec)
1219 {
1220         struct cs_spec *spec = codec->spec;
1221         int err;
1222
1223         err = build_output(codec);
1224         if (err < 0)
1225                 return err;
1226         err = build_input(codec);
1227         if (err < 0)
1228                 return err;
1229         err = build_digital_output(codec);
1230         if (err < 0)
1231                 return err;
1232         err = build_digital_input(codec);
1233         if (err < 0)
1234                 return err;
1235         err = cs_init(codec);
1236         if (err < 0)
1237                 return err;
1238
1239         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1240         if (err < 0)
1241                 return err;
1242
1243         return 0;
1244 }
1245
1246 static void cs_free(struct hda_codec *codec)
1247 {
1248         struct cs_spec *spec = codec->spec;
1249         kfree(spec->capture_bind[0]);
1250         kfree(spec->capture_bind[1]);
1251         snd_hda_gen_free(&spec->gen);
1252         kfree(codec->spec);
1253 }
1254
1255 static const struct hda_codec_ops cs_patch_ops = {
1256         .build_controls = cs_build_controls,
1257         .build_pcms = cs_build_pcms,
1258         .init = cs_init,
1259         .free = cs_free,
1260         .unsol_event = snd_hda_jack_unsol_event,
1261 };
1262
1263 static int cs_parse_auto_config(struct hda_codec *codec)
1264 {
1265         struct cs_spec *spec = codec->spec;
1266         int err;
1267
1268         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1269         if (err < 0)
1270                 return err;
1271
1272         err = parse_output(codec);
1273         if (err < 0)
1274                 return err;
1275         err = parse_input(codec);
1276         if (err < 0)
1277                 return err;
1278         err = parse_digital_output(codec);
1279         if (err < 0)
1280                 return err;
1281         err = parse_digital_input(codec);
1282         if (err < 0)
1283                 return err;
1284         return 0;
1285 }
1286
1287 static const struct hda_model_fixup cs420x_models[] = {
1288         { .id = CS420X_MBP53, .name = "mbp53" },
1289         { .id = CS420X_MBP55, .name = "mbp55" },
1290         { .id = CS420X_IMAC27, .name = "imac27" },
1291         { .id = CS420X_IMAC27_122, .name = "imac27_122" },
1292         { .id = CS420X_APPLE, .name = "apple" },
1293         { .id = CS420X_MBP101, .name = "mbp101" },
1294         {}
1295 };
1296
1297 static const struct snd_pci_quirk cs420x_fixup_tbl[] = {
1298         SND_PCI_QUIRK(0x10de, 0x0ac0, "MacBookPro 5,3", CS420X_MBP53),
1299         SND_PCI_QUIRK(0x10de, 0x0d94, "MacBookAir 3,1(2)", CS420X_MBP55),
1300         SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
1301         SND_PCI_QUIRK(0x10de, 0xcb89, "MacBookPro 7,1", CS420X_MBP55),
1302         /* this conflicts with too many other models */
1303         /*SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27),*/
1304
1305         /* codec SSID */
1306         SND_PCI_QUIRK(0x106b, 0x2000, "iMac 12,2", CS420X_IMAC27_122),
1307         SND_PCI_QUIRK(0x106b, 0x2800, "MacBookPro 10,1", CS420X_MBP101),
1308         SND_PCI_QUIRK_VENDOR(0x106b, "Apple", CS420X_APPLE),
1309         {} /* terminator */
1310 };
1311
1312 static const struct hda_pintbl mbp53_pincfgs[] = {
1313         { 0x09, 0x012b4050 },
1314         { 0x0a, 0x90100141 },
1315         { 0x0b, 0x90100140 },
1316         { 0x0c, 0x018b3020 },
1317         { 0x0d, 0x90a00110 },
1318         { 0x0e, 0x400000f0 },
1319         { 0x0f, 0x01cbe030 },
1320         { 0x10, 0x014be060 },
1321         { 0x12, 0x400000f0 },
1322         { 0x15, 0x400000f0 },
1323         {} /* terminator */
1324 };
1325
1326 static const struct hda_pintbl mbp55_pincfgs[] = {
1327         { 0x09, 0x012b4030 },
1328         { 0x0a, 0x90100121 },
1329         { 0x0b, 0x90100120 },
1330         { 0x0c, 0x400000f0 },
1331         { 0x0d, 0x90a00110 },
1332         { 0x0e, 0x400000f0 },
1333         { 0x0f, 0x400000f0 },
1334         { 0x10, 0x014be040 },
1335         { 0x12, 0x400000f0 },
1336         { 0x15, 0x400000f0 },
1337         {} /* terminator */
1338 };
1339
1340 static const struct hda_pintbl imac27_pincfgs[] = {
1341         { 0x09, 0x012b4050 },
1342         { 0x0a, 0x90100140 },
1343         { 0x0b, 0x90100142 },
1344         { 0x0c, 0x018b3020 },
1345         { 0x0d, 0x90a00110 },
1346         { 0x0e, 0x400000f0 },
1347         { 0x0f, 0x01cbe030 },
1348         { 0x10, 0x014be060 },
1349         { 0x12, 0x01ab9070 },
1350         { 0x15, 0x400000f0 },
1351         {} /* terminator */
1352 };
1353
1354 static const struct hda_pintbl mbp101_pincfgs[] = {
1355         { 0x0d, 0x40ab90f0 },
1356         { 0x0e, 0x90a600f0 },
1357         { 0x12, 0x50a600f0 },
1358         {} /* terminator */
1359 };
1360
1361 static void cs420x_fixup_gpio_13(struct hda_codec *codec,
1362                                  const struct hda_fixup *fix, int action)
1363 {
1364         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1365                 struct cs_spec *spec = codec->spec;
1366                 spec->gpio_eapd_hp = 2; /* GPIO1 = headphones */
1367                 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
1368                 spec->gpio_mask = spec->gpio_dir =
1369                         spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
1370         }
1371 }
1372
1373 static void cs420x_fixup_gpio_23(struct hda_codec *codec,
1374                                  const struct hda_fixup *fix, int action)
1375 {
1376         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1377                 struct cs_spec *spec = codec->spec;
1378                 spec->gpio_eapd_hp = 4; /* GPIO2 = headphones */
1379                 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
1380                 spec->gpio_mask = spec->gpio_dir =
1381                         spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
1382         }
1383 }
1384
1385 static const struct hda_fixup cs420x_fixups[] = {
1386         [CS420X_MBP53] = {
1387                 .type = HDA_FIXUP_PINS,
1388                 .v.pins = mbp53_pincfgs,
1389                 .chained = true,
1390                 .chain_id = CS420X_APPLE,
1391         },
1392         [CS420X_MBP55] = {
1393                 .type = HDA_FIXUP_PINS,
1394                 .v.pins = mbp55_pincfgs,
1395                 .chained = true,
1396                 .chain_id = CS420X_GPIO_13,
1397         },
1398         [CS420X_IMAC27] = {
1399                 .type = HDA_FIXUP_PINS,
1400                 .v.pins = imac27_pincfgs,
1401                 .chained = true,
1402                 .chain_id = CS420X_GPIO_13,
1403         },
1404         [CS420X_GPIO_13] = {
1405                 .type = HDA_FIXUP_FUNC,
1406                 .v.func = cs420x_fixup_gpio_13,
1407         },
1408         [CS420X_GPIO_23] = {
1409                 .type = HDA_FIXUP_FUNC,
1410                 .v.func = cs420x_fixup_gpio_23,
1411         },
1412         [CS420X_MBP101] = {
1413                 .type = HDA_FIXUP_PINS,
1414                 .v.pins = mbp101_pincfgs,
1415                 .chained = true,
1416                 .chain_id = CS420X_MBP101_COEF,
1417         },
1418         [CS420X_MBP101_COEF] = {
1419                 .type = HDA_FIXUP_VERBS,
1420                 .v.verbs = mbp101_init_verbs,
1421                 .chained = true,
1422                 .chain_id = CS420X_GPIO_13,
1423         },
1424 };
1425
1426 static int patch_cs420x(struct hda_codec *codec)
1427 {
1428         struct cs_spec *spec;
1429         int err;
1430
1431         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1432         if (!spec)
1433                 return -ENOMEM;
1434         codec->spec = spec;
1435         snd_hda_gen_init(&spec->gen);
1436
1437         spec->vendor_nid = CS420X_VENDOR_NID;
1438
1439         snd_hda_pick_fixup(codec, cs420x_models, cs420x_fixup_tbl,
1440                            cs420x_fixups);
1441         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1442
1443         err = cs_parse_auto_config(codec);
1444         if (err < 0)
1445                 goto error;
1446
1447         codec->patch_ops = cs_patch_ops;
1448
1449         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1450
1451         return 0;
1452
1453  error:
1454         cs_free(codec);
1455         codec->spec = NULL;
1456         return err;
1457 }
1458
1459 /*
1460  * Cirrus Logic CS4210
1461  *
1462  * 1 DAC => HP(sense) / Speakers,
1463  * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
1464  * 1 SPDIF OUT => SPDIF Trasmitter(sense)
1465 */
1466
1467 /* CS4210 board names */
1468 static const struct hda_model_fixup cs421x_models[] = {
1469         { .id = CS421X_CDB4210, .name = "cdb4210" },
1470         {}
1471 };
1472
1473 static const struct snd_pci_quirk cs421x_fixup_tbl[] = {
1474         /* Test Intel board + CDB2410  */
1475         SND_PCI_QUIRK(0x8086, 0x5001, "DP45SG/CDB4210", CS421X_CDB4210),
1476         {} /* terminator */
1477 };
1478
1479 /* CS4210 board pinconfigs */
1480 /* Default CS4210 (CDB4210)*/
1481 static const struct hda_pintbl cdb4210_pincfgs[] = {
1482         { 0x05, 0x0321401f },
1483         { 0x06, 0x90170010 },
1484         { 0x07, 0x03813031 },
1485         { 0x08, 0xb7a70037 },
1486         { 0x09, 0xb7a6003e },
1487         { 0x0a, 0x034510f0 },
1488         {} /* terminator */
1489 };
1490
1491 /* Setup GPIO/SENSE for each board (if used) */
1492 static void cs421x_fixup_sense_b(struct hda_codec *codec,
1493                                  const struct hda_fixup *fix, int action)
1494 {
1495         struct cs_spec *spec = codec->spec;
1496         if (action == HDA_FIXUP_ACT_PRE_PROBE)
1497                 spec->sense_b = 1;
1498 }
1499
1500 static const struct hda_fixup cs421x_fixups[] = {
1501         [CS421X_CDB4210] = {
1502                 .type = HDA_FIXUP_PINS,
1503                 .v.pins = cdb4210_pincfgs,
1504                 .chained = true,
1505                 .chain_id = CS421X_SENSE_B,
1506         },
1507         [CS421X_SENSE_B] = {
1508                 .type = HDA_FIXUP_FUNC,
1509                 .v.func = cs421x_fixup_sense_b,
1510         }
1511 };
1512
1513 static const struct hda_verb cs421x_coef_init_verbs[] = {
1514         {0x0B, AC_VERB_SET_PROC_STATE, 1},
1515         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DEV_CFG},
1516         /*
1517             Disable Coefficient Index Auto-Increment(DAI)=1,
1518             PDREF=0
1519         */
1520         {0x0B, AC_VERB_SET_PROC_COEF, 0x0001 },
1521
1522         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_ADC_CFG},
1523         /* ADC SZCMode = Digital Soft Ramp */
1524         {0x0B, AC_VERB_SET_PROC_COEF, 0x0002 },
1525
1526         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DAC_CFG},
1527         {0x0B, AC_VERB_SET_PROC_COEF,
1528          (0x0002 /* DAC SZCMode = Digital Soft Ramp */
1529           | 0x0004 /* Mute DAC on FIFO error */
1530           | 0x0008 /* Enable DAC High Pass Filter */
1531           )},
1532         {} /* terminator */
1533 };
1534
1535 /* Errata: CS4210 rev A1 Silicon
1536  *
1537  * http://www.cirrus.com/en/pubs/errata/
1538  *
1539  * Description:
1540  * 1. Performance degredation is present in the ADC.
1541  * 2. Speaker output is not completely muted upon HP detect.
1542  * 3. Noise is present when clipping occurs on the amplified
1543  *    speaker outputs.
1544  *
1545  * Workaround:
1546  * The following verb sequence written to the registers during
1547  * initialization will correct the issues listed above.
1548  */
1549
1550 static const struct hda_verb cs421x_coef_init_verbs_A1_silicon_fixes[] = {
1551         {0x0B, AC_VERB_SET_PROC_STATE, 0x01},  /* VPW: processing on */
1552
1553         {0x0B, AC_VERB_SET_COEF_INDEX, 0x0006},
1554         {0x0B, AC_VERB_SET_PROC_COEF, 0x9999}, /* Test mode: on */
1555
1556         {0x0B, AC_VERB_SET_COEF_INDEX, 0x000A},
1557         {0x0B, AC_VERB_SET_PROC_COEF, 0x14CB}, /* Chop double */
1558
1559         {0x0B, AC_VERB_SET_COEF_INDEX, 0x0011},
1560         {0x0B, AC_VERB_SET_PROC_COEF, 0xA2D0}, /* Increase ADC current */
1561
1562         {0x0B, AC_VERB_SET_COEF_INDEX, 0x001A},
1563         {0x0B, AC_VERB_SET_PROC_COEF, 0x02A9}, /* Mute speaker */
1564
1565         {0x0B, AC_VERB_SET_COEF_INDEX, 0x001B},
1566         {0x0B, AC_VERB_SET_PROC_COEF, 0X1006}, /* Remove noise */
1567
1568         {} /* terminator */
1569 };
1570
1571 /* Speaker Amp Gain is controlled by the vendor widget's coef 4 */
1572 static const DECLARE_TLV_DB_SCALE(cs421x_speaker_boost_db_scale, 900, 300, 0);
1573
1574 static int cs421x_boost_vol_info(struct snd_kcontrol *kcontrol,
1575                                 struct snd_ctl_elem_info *uinfo)
1576 {
1577         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1578         uinfo->count = 1;
1579         uinfo->value.integer.min = 0;
1580         uinfo->value.integer.max = 3;
1581         return 0;
1582 }
1583
1584 static int cs421x_boost_vol_get(struct snd_kcontrol *kcontrol,
1585                                 struct snd_ctl_elem_value *ucontrol)
1586 {
1587         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1588
1589         ucontrol->value.integer.value[0] =
1590                 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL) & 0x0003;
1591         return 0;
1592 }
1593
1594 static int cs421x_boost_vol_put(struct snd_kcontrol *kcontrol,
1595                                 struct snd_ctl_elem_value *ucontrol)
1596 {
1597         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1598
1599         unsigned int vol = ucontrol->value.integer.value[0];
1600         unsigned int coef =
1601                 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL);
1602         unsigned int original_coef = coef;
1603
1604         coef &= ~0x0003;
1605         coef |= (vol & 0x0003);
1606         if (original_coef == coef)
1607                 return 0;
1608         else {
1609                 cs_vendor_coef_set(codec, CS421X_IDX_SPK_CTL, coef);
1610                 return 1;
1611         }
1612 }
1613
1614 static const struct snd_kcontrol_new cs421x_speaker_bost_ctl = {
1615
1616         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1617         .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
1618                         SNDRV_CTL_ELEM_ACCESS_TLV_READ),
1619         .name = "Speaker Boost Playback Volume",
1620         .info = cs421x_boost_vol_info,
1621         .get = cs421x_boost_vol_get,
1622         .put = cs421x_boost_vol_put,
1623         .tlv = { .p = cs421x_speaker_boost_db_scale },
1624 };
1625
1626 static void cs4210_pinmux_init(struct hda_codec *codec)
1627 {
1628         struct cs_spec *spec = codec->spec;
1629         unsigned int def_conf, coef;
1630
1631         /* GPIO, DMIC_SCL, DMIC_SDA and SENSE_B are multiplexed */
1632         coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1633
1634         if (spec->gpio_mask)
1635                 coef |= 0x0008; /* B1,B2 are GPIOs */
1636         else
1637                 coef &= ~0x0008;
1638
1639         if (spec->sense_b)
1640                 coef |= 0x0010; /* B2 is SENSE_B, not inverted  */
1641         else
1642                 coef &= ~0x0010;
1643
1644         cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1645
1646         if ((spec->gpio_mask || spec->sense_b) &&
1647             is_active_pin(codec, CS421X_DMIC_PIN_NID)) {
1648
1649                 /*
1650                     GPIO or SENSE_B forced - disconnect the DMIC pin.
1651                 */
1652                 def_conf = snd_hda_codec_get_pincfg(codec, CS421X_DMIC_PIN_NID);
1653                 def_conf &= ~AC_DEFCFG_PORT_CONN;
1654                 def_conf |= (AC_JACK_PORT_NONE << AC_DEFCFG_PORT_CONN_SHIFT);
1655                 snd_hda_codec_set_pincfg(codec, CS421X_DMIC_PIN_NID, def_conf);
1656         }
1657 }
1658
1659 static void init_cs421x_digital(struct hda_codec *codec)
1660 {
1661         struct cs_spec *spec = codec->spec;
1662         struct auto_pin_cfg *cfg = &spec->autocfg;
1663         int i;
1664
1665
1666         for (i = 0; i < cfg->dig_outs; i++) {
1667                 hda_nid_t nid = cfg->dig_out_pins[i];
1668                 if (!cfg->speaker_outs)
1669                         continue;
1670                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
1671                         snd_hda_jack_detect_enable_callback(codec, nid, SPDIF_EVENT, cs_automute);
1672                         spec->spdif_detect = 1;
1673                 }
1674         }
1675 }
1676
1677 static int cs421x_init(struct hda_codec *codec)
1678 {
1679         struct cs_spec *spec = codec->spec;
1680
1681         if (spec->vendor_nid == CS4210_VENDOR_NID) {
1682                 snd_hda_sequence_write(codec, cs421x_coef_init_verbs);
1683                 snd_hda_sequence_write(codec, cs421x_coef_init_verbs_A1_silicon_fixes);
1684                 cs4210_pinmux_init(codec);
1685         }
1686
1687         if (spec->gpio_mask) {
1688                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1689                                     spec->gpio_mask);
1690                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1691                                     spec->gpio_dir);
1692                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1693                                     spec->gpio_data);
1694         }
1695
1696         init_output(codec);
1697         init_input(codec);
1698         init_cs421x_digital(codec);
1699
1700         return 0;
1701 }
1702
1703 /*
1704  * CS4210 Input MUX (1 ADC)
1705  */
1706 static int cs421x_mux_enum_info(struct snd_kcontrol *kcontrol,
1707                                         struct snd_ctl_elem_info *uinfo)
1708 {
1709         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1710         struct cs_spec *spec = codec->spec;
1711
1712         return snd_hda_input_mux_info(&spec->input_mux, uinfo);
1713 }
1714
1715 static int cs421x_mux_enum_get(struct snd_kcontrol *kcontrol,
1716                                         struct snd_ctl_elem_value *ucontrol)
1717 {
1718         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1719         struct cs_spec *spec = codec->spec;
1720
1721         ucontrol->value.enumerated.item[0] = spec->cur_input;
1722         return 0;
1723 }
1724
1725 static int cs421x_mux_enum_put(struct snd_kcontrol *kcontrol,
1726                                         struct snd_ctl_elem_value *ucontrol)
1727 {
1728         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1729         struct cs_spec *spec = codec->spec;
1730
1731         return snd_hda_input_mux_put(codec, &spec->input_mux, ucontrol,
1732                                 spec->adc_nid[0], &spec->cur_input);
1733
1734 }
1735
1736 static const struct snd_kcontrol_new cs421x_capture_source = {
1737         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1738         .name = "Capture Source",
1739         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1740         .info = cs421x_mux_enum_info,
1741         .get = cs421x_mux_enum_get,
1742         .put = cs421x_mux_enum_put,
1743 };
1744
1745 static int cs421x_add_input_volume_control(struct hda_codec *codec, int item)
1746 {
1747         struct cs_spec *spec = codec->spec;
1748         struct auto_pin_cfg *cfg = &spec->autocfg;
1749         const struct hda_input_mux *imux = &spec->input_mux;
1750         hda_nid_t pin = cfg->inputs[item].pin;
1751         struct snd_kcontrol *kctl;
1752         u32 caps;
1753
1754         if (!(get_wcaps(codec, pin) & AC_WCAP_IN_AMP))
1755                 return 0;
1756
1757         caps = query_amp_caps(codec, pin, HDA_INPUT);
1758         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1759         if (caps <= 1)
1760                 return 0;
1761
1762         return add_volume(codec,  imux->items[item].label, 0,
1763                           HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT), 1, &kctl);
1764 }
1765
1766 /* add a (input-boost) volume control to the given input pin */
1767 static int build_cs421x_input(struct hda_codec *codec)
1768 {
1769         struct cs_spec *spec = codec->spec;
1770         struct auto_pin_cfg *cfg = &spec->autocfg;
1771         struct hda_input_mux *imux = &spec->input_mux;
1772         int i, err, type_idx;
1773         const char *label;
1774
1775         if (!spec->num_inputs)
1776                 return 0;
1777
1778         /* make bind-capture */
1779         spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
1780         spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
1781         for (i = 0; i < 2; i++) {
1782                 struct snd_kcontrol *kctl;
1783                 int n;
1784                 if (!spec->capture_bind[i])
1785                         return -ENOMEM;
1786                 kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
1787                 if (!kctl)
1788                         return -ENOMEM;
1789                 kctl->private_value = (long)spec->capture_bind[i];
1790                 err = snd_hda_ctl_add(codec, 0, kctl);
1791                 if (err < 0)
1792                         return err;
1793                 for (n = 0; n < AUTO_PIN_LAST; n++) {
1794                         if (!spec->adc_nid[n])
1795                                 continue;
1796                         err = snd_hda_add_nid(codec, kctl, 0, spec->adc_nid[n]);
1797                         if (err < 0)
1798                                 return err;
1799                 }
1800         }
1801
1802         /* Add Input MUX Items + Capture Volume/Switch */
1803         for (i = 0; i < spec->num_inputs; i++) {
1804                 label = hda_get_autocfg_input_label(codec, cfg, i);
1805                 snd_hda_add_imux_item(imux, label, spec->adc_idx[i], &type_idx);
1806
1807                 err = cs421x_add_input_volume_control(codec, i);
1808                 if (err < 0)
1809                         return err;
1810         }
1811
1812         /*
1813             Add 'Capture Source' Switch if
1814                 * 2 inputs and no mic detec
1815                 * 3 inputs
1816         */
1817         if ((spec->num_inputs == 2 && !spec->mic_detect) ||
1818             (spec->num_inputs == 3)) {
1819
1820                 err = snd_hda_ctl_add(codec, spec->adc_nid[0],
1821                               snd_ctl_new1(&cs421x_capture_source, codec));
1822                 if (err < 0)
1823                         return err;
1824         }
1825
1826         return 0;
1827 }
1828
1829 /* Single DAC (Mute/Gain) */
1830 static int build_cs421x_output(struct hda_codec *codec)
1831 {
1832         hda_nid_t dac = CS4210_DAC_NID;
1833         struct cs_spec *spec = codec->spec;
1834         struct auto_pin_cfg *cfg = &spec->autocfg;
1835         struct snd_kcontrol *kctl;
1836         int err;
1837         char *name = "Master";
1838
1839         fix_volume_caps(codec, dac);
1840
1841         err = add_mute(codec, name, 0,
1842                         HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1843         if (err < 0)
1844                 return err;
1845
1846         err = add_volume(codec, name, 0,
1847                         HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1848         if (err < 0)
1849                 return err;
1850
1851         if (cfg->speaker_outs && (spec->vendor_nid == CS4210_VENDOR_NID)) {
1852                 err = snd_hda_ctl_add(codec, 0,
1853                         snd_ctl_new1(&cs421x_speaker_bost_ctl, codec));
1854                 if (err < 0)
1855                         return err;
1856         }
1857         return err;
1858 }
1859
1860 static int cs421x_build_controls(struct hda_codec *codec)
1861 {
1862         struct cs_spec *spec = codec->spec;
1863         int err;
1864
1865         err = build_cs421x_output(codec);
1866         if (err < 0)
1867                 return err;
1868         err = build_cs421x_input(codec);
1869         if (err < 0)
1870                 return err;
1871         err = build_digital_output(codec);
1872         if (err < 0)
1873                 return err;
1874         err =  cs421x_init(codec);
1875         if (err < 0)
1876                 return err;
1877
1878         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1879         if (err < 0)
1880                 return err;
1881
1882         return 0;
1883 }
1884
1885 static int parse_cs421x_input(struct hda_codec *codec)
1886 {
1887         struct cs_spec *spec = codec->spec;
1888         struct auto_pin_cfg *cfg = &spec->autocfg;
1889         int i;
1890
1891         for (i = 0; i < cfg->num_inputs; i++) {
1892                 hda_nid_t pin = cfg->inputs[i].pin;
1893                 spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
1894                 spec->cur_input = spec->last_input = i;
1895                 spec->num_inputs++;
1896
1897                 /* check whether the automatic mic switch is available */
1898                 if (is_ext_mic(codec, i) && cfg->num_inputs >= 2) {
1899                         spec->mic_detect = 1;
1900                         spec->automic_idx = i;
1901                 }
1902         }
1903         return 0;
1904 }
1905
1906 static int cs421x_parse_auto_config(struct hda_codec *codec)
1907 {
1908         struct cs_spec *spec = codec->spec;
1909         int err;
1910
1911         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1912         if (err < 0)
1913                 return err;
1914         err = parse_output(codec);
1915         if (err < 0)
1916                 return err;
1917         err = parse_cs421x_input(codec);
1918         if (err < 0)
1919                 return err;
1920         err = parse_digital_output(codec);
1921         if (err < 0)
1922                 return err;
1923         return 0;
1924 }
1925
1926 #ifdef CONFIG_PM
1927 /*
1928         Manage PDREF, when transitioning to D3hot
1929         (DAC,ADC) -> D3, PDREF=1, AFG->D3
1930 */
1931 static int cs421x_suspend(struct hda_codec *codec)
1932 {
1933         struct cs_spec *spec = codec->spec;
1934         unsigned int coef;
1935
1936         snd_hda_shutup_pins(codec);
1937
1938         snd_hda_codec_write(codec, CS4210_DAC_NID, 0,
1939                             AC_VERB_SET_POWER_STATE,  AC_PWRST_D3);
1940         snd_hda_codec_write(codec, CS4210_ADC_NID, 0,
1941                             AC_VERB_SET_POWER_STATE,  AC_PWRST_D3);
1942
1943         if (spec->vendor_nid == CS4210_VENDOR_NID) {
1944                 coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1945                 coef |= 0x0004; /* PDREF */
1946                 cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1947         }
1948
1949         return 0;
1950 }
1951 #endif
1952
1953 static const struct hda_codec_ops cs421x_patch_ops = {
1954         .build_controls = cs421x_build_controls,
1955         .build_pcms = cs_build_pcms,
1956         .init = cs421x_init,
1957         .free = cs_free,
1958         .unsol_event = snd_hda_jack_unsol_event,
1959 #ifdef CONFIG_PM
1960         .suspend = cs421x_suspend,
1961 #endif
1962 };
1963
1964 static int patch_cs4210(struct hda_codec *codec)
1965 {
1966         struct cs_spec *spec;
1967         int err;
1968
1969         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1970         if (!spec)
1971                 return -ENOMEM;
1972         codec->spec = spec;
1973         snd_hda_gen_init(&spec->gen);
1974
1975         spec->vendor_nid = CS4210_VENDOR_NID;
1976
1977         snd_hda_pick_fixup(codec, cs421x_models, cs421x_fixup_tbl,
1978                            cs421x_fixups);
1979         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1980
1981         /*
1982             Update the GPIO/DMIC/SENSE_B pinmux before the configuration
1983             is auto-parsed. If GPIO or SENSE_B is forced, DMIC input
1984             is disabled.
1985         */
1986         cs4210_pinmux_init(codec);
1987
1988         err = cs421x_parse_auto_config(codec);
1989         if (err < 0)
1990                 goto error;
1991
1992         codec->patch_ops = cs421x_patch_ops;
1993
1994         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1995
1996         return 0;
1997
1998  error:
1999         cs_free(codec);
2000         codec->spec = NULL;
2001         return err;
2002 }
2003
2004 static int patch_cs4213(struct hda_codec *codec)
2005 {
2006         struct cs_spec *spec;
2007         int err;
2008
2009         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2010         if (!spec)
2011                 return -ENOMEM;
2012         codec->spec = spec;
2013         snd_hda_gen_init(&spec->gen);
2014
2015         spec->vendor_nid = CS4213_VENDOR_NID;
2016
2017         err = cs421x_parse_auto_config(codec);
2018         if (err < 0)
2019                 goto error;
2020
2021         codec->patch_ops = cs421x_patch_ops;
2022         return 0;
2023
2024  error:
2025         cs_free(codec);
2026         codec->spec = NULL;
2027         return err;
2028 }
2029
2030
2031 /*
2032  * patch entries
2033  */
2034 static const struct hda_codec_preset snd_hda_preset_cirrus[] = {
2035         { .id = 0x10134206, .name = "CS4206", .patch = patch_cs420x },
2036         { .id = 0x10134207, .name = "CS4207", .patch = patch_cs420x },
2037         { .id = 0x10134210, .name = "CS4210", .patch = patch_cs4210 },
2038         { .id = 0x10134213, .name = "CS4213", .patch = patch_cs4213 },
2039         {} /* terminator */
2040 };
2041
2042 MODULE_ALIAS("snd-hda-codec-id:10134206");
2043 MODULE_ALIAS("snd-hda-codec-id:10134207");
2044 MODULE_ALIAS("snd-hda-codec-id:10134210");
2045 MODULE_ALIAS("snd-hda-codec-id:10134213");
2046
2047 MODULE_LICENSE("GPL");
2048 MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
2049
2050 static struct hda_codec_preset_list cirrus_list = {
2051         .preset = snd_hda_preset_cirrus,
2052         .owner = THIS_MODULE,
2053 };
2054
2055 static int __init patch_cirrus_init(void)
2056 {
2057         return snd_hda_add_codec_preset(&cirrus_list);
2058 }
2059
2060 static void __exit patch_cirrus_exit(void)
2061 {
2062         snd_hda_delete_codec_preset(&cirrus_list);
2063 }
2064
2065 module_init(patch_cirrus_init)
2066 module_exit(patch_cirrus_exit)