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        0x12
 105 #define CS_DMIC2_PIN_NID        0x0e
 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_spdif_out_ctls(codec, spec->multiout.dig_out_nid,
 877                                             spec->multiout.dig_out_nid);
 878         if (err < 0)
 879                 return err;
 880         err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
 881         if (err < 0)
 882                 return err;
 883         return 0;
 884 }
 885
 886 static int build_digital_input(struct hda_codec *codec)
 887 {
 888         struct cs_spec *spec = codec->spec;
 889         if (spec->dig_in)
 890                 return snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
 891         return 0;
 892 }
 893
 894 /*
 895  * auto-mute and auto-mic switching
 896  * CS421x auto-output redirecting
 897  * HP/SPK/SPDIF
 898  */
 899
 900 static void cs_automute(struct hda_codec *codec, struct hda_jack_tbl *tbl)
 901 {
 902         struct cs_spec *spec = codec->spec;
 903         struct auto_pin_cfg *cfg = &spec->autocfg;
 904         unsigned int hp_present;
 905         unsigned int spdif_present;
 906         hda_nid_t nid;
 907         int i;
 908
 909         spdif_present = 0;
 910         if (cfg->dig_outs) {
 911                 nid = cfg->dig_out_pins[0];
 912                 if (is_jack_detectable(codec, nid)) {
 913                         /*
 914                         TODO: SPDIF output redirect when SENSE_B is enabled.
 915                         Shared (SENSE_A) jack (e.g HP/mini-TOSLINK)
 916                         assumed.
 917                         */
 918                         if (snd_hda_jack_detect(codec, nid)
 919                                 /* && spec->sense_b */)
 920                                 spdif_present = 1;
 921                 }
 922         }
 923
 924         hp_present = 0;
 925         for (i = 0; i < cfg->hp_outs; i++) {
 926                 nid = cfg->hp_pins[i];
 927                 if (!is_jack_detectable(codec, nid))
 928                         continue;
 929                 hp_present = snd_hda_jack_detect(codec, nid);
 930                 if (hp_present)
 931                         break;
 932         }
 933
 934         /* mute speakers if spdif or hp jack is plugged in */
 935         for (i = 0; i < cfg->speaker_outs; i++) {
 936                 int pin_ctl = hp_present ? 0 : PIN_OUT;
 937                 /* detect on spdif is specific to CS4210 */
 938                 if (spdif_present && (spec->vendor_nid == CS4210_VENDOR_NID))
 939                         pin_ctl = 0;
 940
 941                 nid = cfg->speaker_pins[i];
 942                 snd_hda_set_pin_ctl(codec, nid, pin_ctl);
 943         }
 944         if (spec->gpio_eapd_hp) {
 945                 unsigned int gpio = hp_present ?
 946                         spec->gpio_eapd_hp : spec->gpio_eapd_speaker;
 947                 snd_hda_codec_write(codec, 0x01, 0,
 948                                     AC_VERB_SET_GPIO_DATA, gpio);
 949         }
 950
 951         /* specific to CS4210 */
 952         if (spec->vendor_nid == CS4210_VENDOR_NID) {
 953                 /* mute HPs if spdif jack (SENSE_B) is present */
 954                 for (i = 0; i < cfg->hp_outs; i++) {
 955                         nid = cfg->hp_pins[i];
 956                         snd_hda_set_pin_ctl(codec, nid,
 957                                 (spdif_present && spec->sense_b) ? 0 : PIN_HP);
 958                 }
 959
 960                 /* SPDIF TX on/off */
 961                 if (cfg->dig_outs) {
 962                         nid = cfg->dig_out_pins[0];
 963                         snd_hda_set_pin_ctl(codec, nid,
 964                                 spdif_present ? PIN_OUT : 0);
 965
 966                 }
 967                 /* Update board GPIOs if neccessary ... */
 968         }
 969 }
 970
 971 /*
 972  * Auto-input redirect for CS421x
 973  * Switch max 3 inputs of a single ADC (nid 3)
 974 */
 975
 976 static void cs_automic(struct hda_codec *codec, struct hda_jack_tbl *tbl)
 977 {
 978         struct cs_spec *spec = codec->spec;
 979         struct auto_pin_cfg *cfg = &spec->autocfg;
 980         hda_nid_t nid;
 981         unsigned int present;
 982
 983         nid = cfg->inputs[spec->automic_idx].pin;
 984         present = snd_hda_jack_detect(codec, nid);
 985
 986         /* specific to CS421x, single ADC */
 987         if (spec->vendor_nid == CS420X_VENDOR_NID) {
 988                 if (present)
 989                         change_cur_input(codec, spec->automic_idx, 0);
 990                 else
 991                         change_cur_input(codec, !spec->automic_idx, 0);
 992         } else {
 993                 if (present) {
 994                         if (spec->cur_input != spec->automic_idx) {
 995                                 spec->last_input = spec->cur_input;
 996                                 spec->cur_input = spec->automic_idx;
 997                         }
 998                 } else  {
 999                         spec->cur_input = spec->last_input;
1000                 }
1001                 cs_update_input_select(codec);
1002         }
1003 }
1004
1005 /*
1006  */
1007
1008 static void init_output(struct hda_codec *codec)
1009 {
1010         struct cs_spec *spec = codec->spec;
1011         struct auto_pin_cfg *cfg = &spec->autocfg;
1012         int i;
1013
1014         /* mute first */
1015         for (i = 0; i < spec->multiout.num_dacs; i++)
1016                 snd_hda_codec_write(codec, spec->multiout.dac_nids[i], 0,
1017                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1018         if (spec->multiout.hp_nid)
1019                 snd_hda_codec_write(codec, spec->multiout.hp_nid, 0,
1020                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1021         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
1022                 if (!spec->multiout.extra_out_nid[i])
1023                         break;
1024                 snd_hda_codec_write(codec, spec->multiout.extra_out_nid[i], 0,
1025                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
1026         }
1027
1028         /* set appropriate pin controls */
1029         for (i = 0; i < cfg->line_outs; i++)
1030                 snd_hda_set_pin_ctl(codec, cfg->line_out_pins[i], PIN_OUT);
1031         /* HP */
1032         for (i = 0; i < cfg->hp_outs; i++) {
1033                 hda_nid_t nid = cfg->hp_pins[i];
1034                 snd_hda_set_pin_ctl(codec, nid, PIN_HP);
1035                 if (!cfg->speaker_outs)
1036                         continue;
1037                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
1038                         snd_hda_jack_detect_enable_callback(codec, nid, HP_EVENT, cs_automute);
1039                         spec->hp_detect = 1;
1040                 }
1041         }
1042
1043         /* Speaker */
1044         for (i = 0; i < cfg->speaker_outs; i++)
1045                 snd_hda_set_pin_ctl(codec, cfg->speaker_pins[i], PIN_OUT);
1046
1047         /* SPDIF is enabled on presence detect for CS421x */
1048         if (spec->hp_detect || spec->spdif_detect)
1049                 cs_automute(codec, NULL);
1050 }
1051
1052 static void init_input(struct hda_codec *codec)
1053 {
1054         struct cs_spec *spec = codec->spec;
1055         struct auto_pin_cfg *cfg = &spec->autocfg;
1056         unsigned int coef;
1057         int i;
1058
1059         for (i = 0; i < cfg->num_inputs; i++) {
1060                 unsigned int ctl;
1061                 hda_nid_t pin = cfg->inputs[i].pin;
1062                 if (!spec->adc_nid[i])
1063                         continue;
1064                 /* set appropriate pin control and mute first */
1065                 ctl = PIN_IN;
1066                 if (cfg->inputs[i].type == AUTO_PIN_MIC)
1067                         ctl |= snd_hda_get_default_vref(codec, pin);
1068                 snd_hda_set_pin_ctl(codec, pin, ctl);
1069                 snd_hda_codec_write(codec, spec->adc_nid[i], 0,
1070                                     AC_VERB_SET_AMP_GAIN_MUTE,
1071                                     AMP_IN_MUTE(spec->adc_idx[i]));
1072                 if (spec->mic_detect && spec->automic_idx == i)
1073                         snd_hda_jack_detect_enable_callback(codec, pin, MIC_EVENT, cs_automic);
1074         }
1075         /* CS420x has multiple ADC, CS421x has single ADC */
1076         if (spec->vendor_nid == CS420X_VENDOR_NID) {
1077                 change_cur_input(codec, spec->cur_input, 1);
1078                 if (spec->mic_detect)
1079                         cs_automic(codec, NULL);
1080
1081                 coef = 0x000a; /* ADC1/2 - Digital and Analog Soft Ramp */
1082                 if (is_active_pin(codec, CS_DMIC2_PIN_NID))
1083                         coef |= 0x0500; /* DMIC2 2 chan on, GPIO1 off */
1084                 if (is_active_pin(codec, CS_DMIC1_PIN_NID))
1085                         coef |= 0x1800; /* DMIC1 2 chan on, GPIO0 off
1086                                          * No effect if SPDIF_OUT2 is
1087                                          * selected in IDX_SPDIF_CTL.
1088                                         */
1089                 cs_vendor_coef_set(codec, IDX_ADC_CFG, coef);
1090         } else {
1091                 if (spec->mic_detect)
1092                         cs_automic(codec, NULL);
1093                 else  {
1094                         spec->cur_adc = spec->adc_nid[spec->cur_input];
1095                         cs_update_input_select(codec);
1096                 }
1097         }
1098 }
1099
1100 static const struct hda_verb cs_coef_init_verbs[] = {
1101         {0x11, AC_VERB_SET_PROC_STATE, 1},
1102         {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
1103         {0x11, AC_VERB_SET_PROC_COEF,
1104          (0x002a /* DAC1/2/3 SZCMode Soft Ramp */
1105           | 0x0040 /* Mute DACs on FIFO error */
1106           | 0x1000 /* Enable DACs High Pass Filter */
1107           | 0x0400 /* Disable Coefficient Auto increment */
1108           )},
1109         /* Beep */
1110         {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
1111         {0x11, AC_VERB_SET_PROC_COEF, 0x0007}, /* Enable Beep thru DAC1/2/3 */
1112
1113         {} /* terminator */
1114 };
1115
1116 /* Errata: CS4207 rev C0/C1/C2 Silicon
1117  *
1118  * http://www.cirrus.com/en/pubs/errata/ER880C3.pdf
1119  *
1120  * 6. At high temperature (TA > +85°C), the digital supply current (IVD)
1121  * may be excessive (up to an additional 200 μA), which is most easily
1122  * observed while the part is being held in reset (RESET# active low).
1123  *
1124  * Root Cause: At initial powerup of the device, the logic that drives
1125  * the clock and write enable to the S/PDIF SRC RAMs is not properly
1126  * initialized.
1127  * Certain random patterns will cause a steady leakage current in those
1128  * RAM cells. The issue will resolve once the SRCs are used (turned on).
1129  *
1130  * Workaround: The following verb sequence briefly turns on the S/PDIF SRC
1131  * blocks, which will alleviate the issue.
1132  */
1133
1134 static const struct hda_verb cs_errata_init_verbs[] = {
1135         {0x01, AC_VERB_SET_POWER_STATE, 0x00}, /* AFG: D0 */
1136         {0x11, AC_VERB_SET_PROC_STATE, 0x01},  /* VPW: processing on */
1137
1138         {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1139         {0x11, AC_VERB_SET_PROC_COEF, 0x9999},
1140         {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1141         {0x11, AC_VERB_SET_PROC_COEF, 0xa412},
1142         {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1143         {0x11, AC_VERB_SET_PROC_COEF, 0x0009},
1144
1145         {0x07, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Rx: D0 */
1146         {0x08, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Tx: D0 */
1147
1148         {0x11, AC_VERB_SET_COEF_INDEX, 0x0017},
1149         {0x11, AC_VERB_SET_PROC_COEF, 0x2412},
1150         {0x11, AC_VERB_SET_COEF_INDEX, 0x0008},
1151         {0x11, AC_VERB_SET_PROC_COEF, 0x0000},
1152         {0x11, AC_VERB_SET_COEF_INDEX, 0x0001},
1153         {0x11, AC_VERB_SET_PROC_COEF, 0x0008},
1154         {0x11, AC_VERB_SET_PROC_STATE, 0x00},
1155
1156 #if 0 /* Don't to set to D3 as we are in power-up sequence */
1157         {0x07, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Rx: D3 */
1158         {0x08, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Tx: D3 */
1159         /*{0x01, AC_VERB_SET_POWER_STATE, 0x03},*/ /* AFG: D3 This is already handled */
1160 #endif
1161
1162         {} /* terminator */
1163 };
1164
1165 static const struct hda_verb mbp101_init_verbs[] = {
1166         {0x11, AC_VERB_SET_COEF_INDEX, 0x0002},
1167         {0x11, AC_VERB_SET_PROC_COEF, 0x100a},
1168         {0x11, AC_VERB_SET_COEF_INDEX, 0x0004},
1169         {0x11, AC_VERB_SET_PROC_COEF, 0x000f},
1170         {}
1171 };
1172
1173 /* SPDIF setup */
1174 static void init_digital(struct hda_codec *codec)
1175 {
1176         unsigned int coef;
1177
1178         coef = 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */
1179         coef |= 0x0008; /* Replace with mute on error */
1180         if (is_active_pin(codec, CS_DIG_OUT2_PIN_NID))
1181                 coef |= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2
1182                                  * SPDIF_OUT2 is shared with GPIO1 and
1183                                  * DMIC_SDA2.
1184                                  */
1185         cs_vendor_coef_set(codec, IDX_SPDIF_CTL, coef);
1186 }
1187
1188 static int cs_init(struct hda_codec *codec)
1189 {
1190         struct cs_spec *spec = codec->spec;
1191
1192         /* init_verb sequence for C0/C1/C2 errata*/
1193         snd_hda_sequence_write(codec, cs_errata_init_verbs);
1194
1195         snd_hda_sequence_write(codec, cs_coef_init_verbs);
1196
1197         if (spec->gpio_mask) {
1198                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1199                                     spec->gpio_mask);
1200                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1201                                     spec->gpio_dir);
1202                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1203                                     spec->gpio_data);
1204         }
1205
1206         init_output(codec);
1207         init_input(codec);
1208         init_digital(codec);
1209
1210         return 0;
1211 }
1212
1213 static int cs_build_controls(struct hda_codec *codec)
1214 {
1215         struct cs_spec *spec = codec->spec;
1216         int err;
1217
1218         err = build_output(codec);
1219         if (err < 0)
1220                 return err;
1221         err = build_input(codec);
1222         if (err < 0)
1223                 return err;
1224         err = build_digital_output(codec);
1225         if (err < 0)
1226                 return err;
1227         err = build_digital_input(codec);
1228         if (err < 0)
1229                 return err;
1230         err = cs_init(codec);
1231         if (err < 0)
1232                 return err;
1233
1234         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1235         if (err < 0)
1236                 return err;
1237
1238         return 0;
1239 }
1240
1241 static void cs_free(struct hda_codec *codec)
1242 {
1243         struct cs_spec *spec = codec->spec;
1244         kfree(spec->capture_bind[0]);
1245         kfree(spec->capture_bind[1]);
1246         snd_hda_gen_free(&spec->gen);
1247         kfree(codec->spec);
1248 }
1249
1250 static const struct hda_codec_ops cs_patch_ops = {
1251         .build_controls = cs_build_controls,
1252         .build_pcms = cs_build_pcms,
1253         .init = cs_init,
1254         .free = cs_free,
1255         .unsol_event = snd_hda_jack_unsol_event,
1256 };
1257
1258 static int cs_parse_auto_config(struct hda_codec *codec)
1259 {
1260         struct cs_spec *spec = codec->spec;
1261         int err;
1262
1263         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1264         if (err < 0)
1265                 return err;
1266
1267         err = parse_output(codec);
1268         if (err < 0)
1269                 return err;
1270         err = parse_input(codec);
1271         if (err < 0)
1272                 return err;
1273         err = parse_digital_output(codec);
1274         if (err < 0)
1275                 return err;
1276         err = parse_digital_input(codec);
1277         if (err < 0)
1278                 return err;
1279         return 0;
1280 }
1281
1282 static const struct hda_model_fixup cs420x_models[] = {
1283         { .id = CS420X_MBP53, .name = "mbp53" },
1284         { .id = CS420X_MBP55, .name = "mbp55" },
1285         { .id = CS420X_IMAC27, .name = "imac27" },
1286         { .id = CS420X_IMAC27_122, .name = "imac27_122" },
1287         { .id = CS420X_APPLE, .name = "apple" },
1288         { .id = CS420X_MBP101, .name = "mbp101" },
1289         {}
1290 };
1291
1292 static const struct snd_pci_quirk cs420x_fixup_tbl[] = {
1293         SND_PCI_QUIRK(0x10de, 0x0ac0, "MacBookPro 5,3", CS420X_MBP53),
1294         SND_PCI_QUIRK(0x10de, 0x0d94, "MacBookAir 3,1(2)", CS420X_MBP55),
1295         SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
1296         SND_PCI_QUIRK(0x10de, 0xcb89, "MacBookPro 7,1", CS420X_MBP55),
1297         /* this conflicts with too many other models */
1298         /*SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27),*/
1299
1300         /* codec SSID */
1301         SND_PCI_QUIRK(0x106b, 0x2000, "iMac 12,2", CS420X_IMAC27_122),
1302         SND_PCI_QUIRK(0x106b, 0x2800, "MacBookPro 10,1", CS420X_MBP101),
1303         SND_PCI_QUIRK_VENDOR(0x106b, "Apple", CS420X_APPLE),
1304         {} /* terminator */
1305 };
1306
1307 static const struct hda_pintbl mbp53_pincfgs[] = {
1308         { 0x09, 0x012b4050 },
1309         { 0x0a, 0x90100141 },
1310         { 0x0b, 0x90100140 },
1311         { 0x0c, 0x018b3020 },
1312         { 0x0d, 0x90a00110 },
1313         { 0x0e, 0x400000f0 },
1314         { 0x0f, 0x01cbe030 },
1315         { 0x10, 0x014be060 },
1316         { 0x12, 0x400000f0 },
1317         { 0x15, 0x400000f0 },
1318         {} /* terminator */
1319 };
1320
1321 static const struct hda_pintbl mbp55_pincfgs[] = {
1322         { 0x09, 0x012b4030 },
1323         { 0x0a, 0x90100121 },
1324         { 0x0b, 0x90100120 },
1325         { 0x0c, 0x400000f0 },
1326         { 0x0d, 0x90a00110 },
1327         { 0x0e, 0x400000f0 },
1328         { 0x0f, 0x400000f0 },
1329         { 0x10, 0x014be040 },
1330         { 0x12, 0x400000f0 },
1331         { 0x15, 0x400000f0 },
1332         {} /* terminator */
1333 };
1334
1335 static const struct hda_pintbl imac27_pincfgs[] = {
1336         { 0x09, 0x012b4050 },
1337         { 0x0a, 0x90100140 },
1338         { 0x0b, 0x90100142 },
1339         { 0x0c, 0x018b3020 },
1340         { 0x0d, 0x90a00110 },
1341         { 0x0e, 0x400000f0 },
1342         { 0x0f, 0x01cbe030 },
1343         { 0x10, 0x014be060 },
1344         { 0x12, 0x01ab9070 },
1345         { 0x15, 0x400000f0 },
1346         {} /* terminator */
1347 };
1348
1349 static const struct hda_pintbl mbp101_pincfgs[] = {
1350         { 0x0d, 0x40ab90f0 },
1351         { 0x0e, 0x90a600f0 },
1352         { 0x12, 0x50a600f0 },
1353         {} /* terminator */
1354 };
1355
1356 static void cs420x_fixup_gpio_13(struct hda_codec *codec,
1357                                  const struct hda_fixup *fix, int action)
1358 {
1359         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1360                 struct cs_spec *spec = codec->spec;
1361                 spec->gpio_eapd_hp = 2; /* GPIO1 = headphones */
1362                 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
1363                 spec->gpio_mask = spec->gpio_dir =
1364                         spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
1365         }
1366 }
1367
1368 static void cs420x_fixup_gpio_23(struct hda_codec *codec,
1369                                  const struct hda_fixup *fix, int action)
1370 {
1371         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
1372                 struct cs_spec *spec = codec->spec;
1373                 spec->gpio_eapd_hp = 4; /* GPIO2 = headphones */
1374                 spec->gpio_eapd_speaker = 8; /* GPIO3 = speakers */
1375                 spec->gpio_mask = spec->gpio_dir =
1376                         spec->gpio_eapd_hp | spec->gpio_eapd_speaker;
1377         }
1378 }
1379
1380 static const struct hda_fixup cs420x_fixups[] = {
1381         [CS420X_MBP53] = {
1382                 .type = HDA_FIXUP_PINS,
1383                 .v.pins = mbp53_pincfgs,
1384                 .chained = true,
1385                 .chain_id = CS420X_APPLE,
1386         },
1387         [CS420X_MBP55] = {
1388                 .type = HDA_FIXUP_PINS,
1389                 .v.pins = mbp55_pincfgs,
1390                 .chained = true,
1391                 .chain_id = CS420X_GPIO_13,
1392         },
1393         [CS420X_IMAC27] = {
1394                 .type = HDA_FIXUP_PINS,
1395                 .v.pins = imac27_pincfgs,
1396                 .chained = true,
1397                 .chain_id = CS420X_GPIO_13,
1398         },
1399         [CS420X_GPIO_13] = {
1400                 .type = HDA_FIXUP_FUNC,
1401                 .v.func = cs420x_fixup_gpio_13,
1402         },
1403         [CS420X_GPIO_23] = {
1404                 .type = HDA_FIXUP_FUNC,
1405                 .v.func = cs420x_fixup_gpio_23,
1406         },
1407         [CS420X_MBP101] = {
1408                 .type = HDA_FIXUP_PINS,
1409                 .v.pins = mbp101_pincfgs,
1410                 .chained = true,
1411                 .chain_id = CS420X_MBP101_COEF,
1412         },
1413         [CS420X_MBP101_COEF] = {
1414                 .type = HDA_FIXUP_VERBS,
1415                 .v.verbs = mbp101_init_verbs,
1416                 .chained = true,
1417                 .chain_id = CS420X_GPIO_13,
1418         },
1419 };
1420
1421 static int patch_cs420x(struct hda_codec *codec)
1422 {
1423         struct cs_spec *spec;
1424         int err;
1425
1426         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1427         if (!spec)
1428                 return -ENOMEM;
1429         codec->spec = spec;
1430         snd_hda_gen_init(&spec->gen);
1431
1432         spec->vendor_nid = CS420X_VENDOR_NID;
1433
1434         snd_hda_pick_fixup(codec, cs420x_models, cs420x_fixup_tbl,
1435                            cs420x_fixups);
1436         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1437
1438         err = cs_parse_auto_config(codec);
1439         if (err < 0)
1440                 goto error;
1441
1442         codec->patch_ops = cs_patch_ops;
1443
1444         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1445
1446         return 0;
1447
1448  error:
1449         cs_free(codec);
1450         codec->spec = NULL;
1451         return err;
1452 }
1453
1454 /*
1455  * Cirrus Logic CS4210
1456  *
1457  * 1 DAC => HP(sense) / Speakers,
1458  * 1 ADC <= LineIn(sense) / MicIn / DMicIn,
1459  * 1 SPDIF OUT => SPDIF Trasmitter(sense)
1460 */
1461
1462 /* CS4210 board names */
1463 static const struct hda_model_fixup cs421x_models[] = {
1464         { .id = CS421X_CDB4210, .name = "cdb4210" },
1465         {}
1466 };
1467
1468 static const struct snd_pci_quirk cs421x_fixup_tbl[] = {
1469         /* Test Intel board + CDB2410  */
1470         SND_PCI_QUIRK(0x8086, 0x5001, "DP45SG/CDB4210", CS421X_CDB4210),
1471         {} /* terminator */
1472 };
1473
1474 /* CS4210 board pinconfigs */
1475 /* Default CS4210 (CDB4210)*/
1476 static const struct hda_pintbl cdb4210_pincfgs[] = {
1477         { 0x05, 0x0321401f },
1478         { 0x06, 0x90170010 },
1479         { 0x07, 0x03813031 },
1480         { 0x08, 0xb7a70037 },
1481         { 0x09, 0xb7a6003e },
1482         { 0x0a, 0x034510f0 },
1483         {} /* terminator */
1484 };
1485
1486 /* Setup GPIO/SENSE for each board (if used) */
1487 static void cs421x_fixup_sense_b(struct hda_codec *codec,
1488                                  const struct hda_fixup *fix, int action)
1489 {
1490         struct cs_spec *spec = codec->spec;
1491         if (action == HDA_FIXUP_ACT_PRE_PROBE)
1492                 spec->sense_b = 1;
1493 }
1494
1495 static const struct hda_fixup cs421x_fixups[] = {
1496         [CS421X_CDB4210] = {
1497                 .type = HDA_FIXUP_PINS,
1498                 .v.pins = cdb4210_pincfgs,
1499                 .chained = true,
1500                 .chain_id = CS421X_SENSE_B,
1501         },
1502         [CS421X_SENSE_B] = {
1503                 .type = HDA_FIXUP_FUNC,
1504                 .v.func = cs421x_fixup_sense_b,
1505         }
1506 };
1507
1508 static const struct hda_verb cs421x_coef_init_verbs[] = {
1509         {0x0B, AC_VERB_SET_PROC_STATE, 1},
1510         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DEV_CFG},
1511         /*
1512             Disable Coefficient Index Auto-Increment(DAI)=1,
1513             PDREF=0
1514         */
1515         {0x0B, AC_VERB_SET_PROC_COEF, 0x0001 },
1516
1517         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_ADC_CFG},
1518         /* ADC SZCMode = Digital Soft Ramp */
1519         {0x0B, AC_VERB_SET_PROC_COEF, 0x0002 },
1520
1521         {0x0B, AC_VERB_SET_COEF_INDEX, CS421X_IDX_DAC_CFG},
1522         {0x0B, AC_VERB_SET_PROC_COEF,
1523          (0x0002 /* DAC SZCMode = Digital Soft Ramp */
1524           | 0x0004 /* Mute DAC on FIFO error */
1525           | 0x0008 /* Enable DAC High Pass Filter */
1526           )},
1527         {} /* terminator */
1528 };
1529
1530 /* Errata: CS4210 rev A1 Silicon
1531  *
1532  * http://www.cirrus.com/en/pubs/errata/
1533  *
1534  * Description:
1535  * 1. Performance degredation is present in the ADC.
1536  * 2. Speaker output is not completely muted upon HP detect.
1537  * 3. Noise is present when clipping occurs on the amplified
1538  *    speaker outputs.
1539  *
1540  * Workaround:
1541  * The following verb sequence written to the registers during
1542  * initialization will correct the issues listed above.
1543  */
1544
1545 static const struct hda_verb cs421x_coef_init_verbs_A1_silicon_fixes[] = {
1546         {0x0B, AC_VERB_SET_PROC_STATE, 0x01},  /* VPW: processing on */
1547
1548         {0x0B, AC_VERB_SET_COEF_INDEX, 0x0006},
1549         {0x0B, AC_VERB_SET_PROC_COEF, 0x9999}, /* Test mode: on */
1550
1551         {0x0B, AC_VERB_SET_COEF_INDEX, 0x000A},
1552         {0x0B, AC_VERB_SET_PROC_COEF, 0x14CB}, /* Chop double */
1553
1554         {0x0B, AC_VERB_SET_COEF_INDEX, 0x0011},
1555         {0x0B, AC_VERB_SET_PROC_COEF, 0xA2D0}, /* Increase ADC current */
1556
1557         {0x0B, AC_VERB_SET_COEF_INDEX, 0x001A},
1558         {0x0B, AC_VERB_SET_PROC_COEF, 0x02A9}, /* Mute speaker */
1559
1560         {0x0B, AC_VERB_SET_COEF_INDEX, 0x001B},
1561         {0x0B, AC_VERB_SET_PROC_COEF, 0X1006}, /* Remove noise */
1562
1563         {} /* terminator */
1564 };
1565
1566 /* Speaker Amp Gain is controlled by the vendor widget's coef 4 */
1567 static const DECLARE_TLV_DB_SCALE(cs421x_speaker_boost_db_scale, 900, 300, 0);
1568
1569 static int cs421x_boost_vol_info(struct snd_kcontrol *kcontrol,
1570                                 struct snd_ctl_elem_info *uinfo)
1571 {
1572         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1573         uinfo->count = 1;
1574         uinfo->value.integer.min = 0;
1575         uinfo->value.integer.max = 3;
1576         return 0;
1577 }
1578
1579 static int cs421x_boost_vol_get(struct snd_kcontrol *kcontrol,
1580                                 struct snd_ctl_elem_value *ucontrol)
1581 {
1582         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1583
1584         ucontrol->value.integer.value[0] =
1585                 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL) & 0x0003;
1586         return 0;
1587 }
1588
1589 static int cs421x_boost_vol_put(struct snd_kcontrol *kcontrol,
1590                                 struct snd_ctl_elem_value *ucontrol)
1591 {
1592         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1593
1594         unsigned int vol = ucontrol->value.integer.value[0];
1595         unsigned int coef =
1596                 cs_vendor_coef_get(codec, CS421X_IDX_SPK_CTL);
1597         unsigned int original_coef = coef;
1598
1599         coef &= ~0x0003;
1600         coef |= (vol & 0x0003);
1601         if (original_coef == coef)
1602                 return 0;
1603         else {
1604                 cs_vendor_coef_set(codec, CS421X_IDX_SPK_CTL, coef);
1605                 return 1;
1606         }
1607 }
1608
1609 static const struct snd_kcontrol_new cs421x_speaker_bost_ctl = {
1610
1611         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1612         .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE |
1613                         SNDRV_CTL_ELEM_ACCESS_TLV_READ),
1614         .name = "Speaker Boost Playback Volume",
1615         .info = cs421x_boost_vol_info,
1616         .get = cs421x_boost_vol_get,
1617         .put = cs421x_boost_vol_put,
1618         .tlv = { .p = cs421x_speaker_boost_db_scale },
1619 };
1620
1621 static void cs4210_pinmux_init(struct hda_codec *codec)
1622 {
1623         struct cs_spec *spec = codec->spec;
1624         unsigned int def_conf, coef;
1625
1626         /* GPIO, DMIC_SCL, DMIC_SDA and SENSE_B are multiplexed */
1627         coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1628
1629         if (spec->gpio_mask)
1630                 coef |= 0x0008; /* B1,B2 are GPIOs */
1631         else
1632                 coef &= ~0x0008;
1633
1634         if (spec->sense_b)
1635                 coef |= 0x0010; /* B2 is SENSE_B, not inverted  */
1636         else
1637                 coef &= ~0x0010;
1638
1639         cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1640
1641         if ((spec->gpio_mask || spec->sense_b) &&
1642             is_active_pin(codec, CS421X_DMIC_PIN_NID)) {
1643
1644                 /*
1645                     GPIO or SENSE_B forced - disconnect the DMIC pin.
1646                 */
1647                 def_conf = snd_hda_codec_get_pincfg(codec, CS421X_DMIC_PIN_NID);
1648                 def_conf &= ~AC_DEFCFG_PORT_CONN;
1649                 def_conf |= (AC_JACK_PORT_NONE << AC_DEFCFG_PORT_CONN_SHIFT);
1650                 snd_hda_codec_set_pincfg(codec, CS421X_DMIC_PIN_NID, def_conf);
1651         }
1652 }
1653
1654 static void init_cs421x_digital(struct hda_codec *codec)
1655 {
1656         struct cs_spec *spec = codec->spec;
1657         struct auto_pin_cfg *cfg = &spec->autocfg;
1658         int i;
1659
1660
1661         for (i = 0; i < cfg->dig_outs; i++) {
1662                 hda_nid_t nid = cfg->dig_out_pins[i];
1663                 if (!cfg->speaker_outs)
1664                         continue;
1665                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
1666                         snd_hda_jack_detect_enable_callback(codec, nid, SPDIF_EVENT, cs_automute);
1667                         spec->spdif_detect = 1;
1668                 }
1669         }
1670 }
1671
1672 static int cs421x_init(struct hda_codec *codec)
1673 {
1674         struct cs_spec *spec = codec->spec;
1675
1676         if (spec->vendor_nid == CS4210_VENDOR_NID) {
1677                 snd_hda_sequence_write(codec, cs421x_coef_init_verbs);
1678                 snd_hda_sequence_write(codec, cs421x_coef_init_verbs_A1_silicon_fixes);
1679                 cs4210_pinmux_init(codec);
1680         }
1681
1682         if (spec->gpio_mask) {
1683                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_MASK,
1684                                     spec->gpio_mask);
1685                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DIRECTION,
1686                                     spec->gpio_dir);
1687                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA,
1688                                     spec->gpio_data);
1689         }
1690
1691         init_output(codec);
1692         init_input(codec);
1693         init_cs421x_digital(codec);
1694
1695         return 0;
1696 }
1697
1698 /*
1699  * CS4210 Input MUX (1 ADC)
1700  */
1701 static int cs421x_mux_enum_info(struct snd_kcontrol *kcontrol,
1702                                         struct snd_ctl_elem_info *uinfo)
1703 {
1704         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1705         struct cs_spec *spec = codec->spec;
1706
1707         return snd_hda_input_mux_info(&spec->input_mux, uinfo);
1708 }
1709
1710 static int cs421x_mux_enum_get(struct snd_kcontrol *kcontrol,
1711                                         struct snd_ctl_elem_value *ucontrol)
1712 {
1713         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1714         struct cs_spec *spec = codec->spec;
1715
1716         ucontrol->value.enumerated.item[0] = spec->cur_input;
1717         return 0;
1718 }
1719
1720 static int cs421x_mux_enum_put(struct snd_kcontrol *kcontrol,
1721                                         struct snd_ctl_elem_value *ucontrol)
1722 {
1723         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1724         struct cs_spec *spec = codec->spec;
1725
1726         return snd_hda_input_mux_put(codec, &spec->input_mux, ucontrol,
1727                                 spec->adc_nid[0], &spec->cur_input);
1728
1729 }
1730
1731 static struct snd_kcontrol_new cs421x_capture_source = {
1732
1733         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1734         .name = "Capture Source",
1735         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1736         .info = cs421x_mux_enum_info,
1737         .get = cs421x_mux_enum_get,
1738         .put = cs421x_mux_enum_put,
1739 };
1740
1741 static int cs421x_add_input_volume_control(struct hda_codec *codec, int item)
1742 {
1743         struct cs_spec *spec = codec->spec;
1744         struct auto_pin_cfg *cfg = &spec->autocfg;
1745         const struct hda_input_mux *imux = &spec->input_mux;
1746         hda_nid_t pin = cfg->inputs[item].pin;
1747         struct snd_kcontrol *kctl;
1748         u32 caps;
1749
1750         if (!(get_wcaps(codec, pin) & AC_WCAP_IN_AMP))
1751                 return 0;
1752
1753         caps = query_amp_caps(codec, pin, HDA_INPUT);
1754         caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT;
1755         if (caps <= 1)
1756                 return 0;
1757
1758         return add_volume(codec,  imux->items[item].label, 0,
1759                           HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT), 1, &kctl);
1760 }
1761
1762 /* add a (input-boost) volume control to the given input pin */
1763 static int build_cs421x_input(struct hda_codec *codec)
1764 {
1765         struct cs_spec *spec = codec->spec;
1766         struct auto_pin_cfg *cfg = &spec->autocfg;
1767         struct hda_input_mux *imux = &spec->input_mux;
1768         int i, err, type_idx;
1769         const char *label;
1770
1771         if (!spec->num_inputs)
1772                 return 0;
1773
1774         /* make bind-capture */
1775         spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
1776         spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
1777         for (i = 0; i < 2; i++) {
1778                 struct snd_kcontrol *kctl;
1779                 int n;
1780                 if (!spec->capture_bind[i])
1781                         return -ENOMEM;
1782                 kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
1783                 if (!kctl)
1784                         return -ENOMEM;
1785                 kctl->private_value = (long)spec->capture_bind[i];
1786                 err = snd_hda_ctl_add(codec, 0, kctl);
1787                 if (err < 0)
1788                         return err;
1789                 for (n = 0; n < AUTO_PIN_LAST; n++) {
1790                         if (!spec->adc_nid[n])
1791                                 continue;
1792                         err = snd_hda_add_nid(codec, kctl, 0, spec->adc_nid[n]);
1793                         if (err < 0)
1794                                 return err;
1795                 }
1796         }
1797
1798         /* Add Input MUX Items + Capture Volume/Switch */
1799         for (i = 0; i < spec->num_inputs; i++) {
1800                 label = hda_get_autocfg_input_label(codec, cfg, i);
1801                 snd_hda_add_imux_item(imux, label, spec->adc_idx[i], &type_idx);
1802
1803                 err = cs421x_add_input_volume_control(codec, i);
1804                 if (err < 0)
1805                         return err;
1806         }
1807
1808         /*
1809             Add 'Capture Source' Switch if
1810                 * 2 inputs and no mic detec
1811                 * 3 inputs
1812         */
1813         if ((spec->num_inputs == 2 && !spec->mic_detect) ||
1814             (spec->num_inputs == 3)) {
1815
1816                 err = snd_hda_ctl_add(codec, spec->adc_nid[0],
1817                               snd_ctl_new1(&cs421x_capture_source, codec));
1818                 if (err < 0)
1819                         return err;
1820         }
1821
1822         return 0;
1823 }
1824
1825 /* Single DAC (Mute/Gain) */
1826 static int build_cs421x_output(struct hda_codec *codec)
1827 {
1828         hda_nid_t dac = CS4210_DAC_NID;
1829         struct cs_spec *spec = codec->spec;
1830         struct auto_pin_cfg *cfg = &spec->autocfg;
1831         struct snd_kcontrol *kctl;
1832         int err;
1833         char *name = "Master";
1834
1835         fix_volume_caps(codec, dac);
1836
1837         err = add_mute(codec, name, 0,
1838                         HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1839         if (err < 0)
1840                 return err;
1841
1842         err = add_volume(codec, name, 0,
1843                         HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
1844         if (err < 0)
1845                 return err;
1846
1847         if (cfg->speaker_outs && (spec->vendor_nid == CS4210_VENDOR_NID)) {
1848                 err = snd_hda_ctl_add(codec, 0,
1849                         snd_ctl_new1(&cs421x_speaker_bost_ctl, codec));
1850                 if (err < 0)
1851                         return err;
1852         }
1853         return err;
1854 }
1855
1856 static int cs421x_build_controls(struct hda_codec *codec)
1857 {
1858         struct cs_spec *spec = codec->spec;
1859         int err;
1860
1861         err = build_cs421x_output(codec);
1862         if (err < 0)
1863                 return err;
1864         err = build_cs421x_input(codec);
1865         if (err < 0)
1866                 return err;
1867         err = build_digital_output(codec);
1868         if (err < 0)
1869                 return err;
1870         err =  cs421x_init(codec);
1871         if (err < 0)
1872                 return err;
1873
1874         err = snd_hda_jack_add_kctls(codec, &spec->autocfg);
1875         if (err < 0)
1876                 return err;
1877
1878         return 0;
1879 }
1880
1881 static int parse_cs421x_input(struct hda_codec *codec)
1882 {
1883         struct cs_spec *spec = codec->spec;
1884         struct auto_pin_cfg *cfg = &spec->autocfg;
1885         int i;
1886
1887         for (i = 0; i < cfg->num_inputs; i++) {
1888                 hda_nid_t pin = cfg->inputs[i].pin;
1889                 spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
1890                 spec->cur_input = spec->last_input = i;
1891                 spec->num_inputs++;
1892
1893                 /* check whether the automatic mic switch is available */
1894                 if (is_ext_mic(codec, i) && cfg->num_inputs >= 2) {
1895                         spec->mic_detect = 1;
1896                         spec->automic_idx = i;
1897                 }
1898         }
1899         return 0;
1900 }
1901
1902 static int cs421x_parse_auto_config(struct hda_codec *codec)
1903 {
1904         struct cs_spec *spec = codec->spec;
1905         int err;
1906
1907         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1908         if (err < 0)
1909                 return err;
1910         err = parse_output(codec);
1911         if (err < 0)
1912                 return err;
1913         err = parse_cs421x_input(codec);
1914         if (err < 0)
1915                 return err;
1916         err = parse_digital_output(codec);
1917         if (err < 0)
1918                 return err;
1919         return 0;
1920 }
1921
1922 #ifdef CONFIG_PM
1923 /*
1924         Manage PDREF, when transitioning to D3hot
1925         (DAC,ADC) -> D3, PDREF=1, AFG->D3
1926 */
1927 static int cs421x_suspend(struct hda_codec *codec)
1928 {
1929         struct cs_spec *spec = codec->spec;
1930         unsigned int coef;
1931
1932         snd_hda_shutup_pins(codec);
1933
1934         snd_hda_codec_write(codec, CS4210_DAC_NID, 0,
1935                             AC_VERB_SET_POWER_STATE,  AC_PWRST_D3);
1936         snd_hda_codec_write(codec, CS4210_ADC_NID, 0,
1937                             AC_VERB_SET_POWER_STATE,  AC_PWRST_D3);
1938
1939         if (spec->vendor_nid == CS4210_VENDOR_NID) {
1940                 coef = cs_vendor_coef_get(codec, CS421X_IDX_DEV_CFG);
1941                 coef |= 0x0004; /* PDREF */
1942                 cs_vendor_coef_set(codec, CS421X_IDX_DEV_CFG, coef);
1943         }
1944
1945         return 0;
1946 }
1947 #endif
1948
1949 static struct hda_codec_ops cs421x_patch_ops = {
1950         .build_controls = cs421x_build_controls,
1951         .build_pcms = cs_build_pcms,
1952         .init = cs421x_init,
1953         .free = cs_free,
1954         .unsol_event = snd_hda_jack_unsol_event,
1955 #ifdef CONFIG_PM
1956         .suspend = cs421x_suspend,
1957 #endif
1958 };
1959
1960 static int patch_cs4210(struct hda_codec *codec)
1961 {
1962         struct cs_spec *spec;
1963         int err;
1964
1965         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1966         if (!spec)
1967                 return -ENOMEM;
1968         codec->spec = spec;
1969         snd_hda_gen_init(&spec->gen);
1970
1971         spec->vendor_nid = CS4210_VENDOR_NID;
1972
1973         snd_hda_pick_fixup(codec, cs421x_models, cs421x_fixup_tbl,
1974                            cs421x_fixups);
1975         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PRE_PROBE);
1976
1977         /*
1978             Update the GPIO/DMIC/SENSE_B pinmux before the configuration
1979             is auto-parsed. If GPIO or SENSE_B is forced, DMIC input
1980             is disabled.
1981         */
1982         cs4210_pinmux_init(codec);
1983
1984         err = cs421x_parse_auto_config(codec);
1985         if (err < 0)
1986                 goto error;
1987
1988         codec->patch_ops = cs421x_patch_ops;
1989
1990         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
1991
1992         return 0;
1993
1994  error:
1995         cs_free(codec);
1996         codec->spec = NULL;
1997         return err;
1998 }
1999
2000 static int patch_cs4213(struct hda_codec *codec)
2001 {
2002         struct cs_spec *spec;
2003         int err;
2004
2005         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
2006         if (!spec)
2007                 return -ENOMEM;
2008         codec->spec = spec;
2009         snd_hda_gen_init(&spec->gen);
2010
2011         spec->vendor_nid = CS4213_VENDOR_NID;
2012
2013         err = cs421x_parse_auto_config(codec);
2014         if (err < 0)
2015                 goto error;
2016
2017         codec->patch_ops = cs421x_patch_ops;
2018         return 0;
2019
2020  error:
2021         cs_free(codec);
2022         codec->spec = NULL;
2023         return err;
2024 }
2025
2026
2027 /*
2028  * patch entries
2029  */
2030 static const struct hda_codec_preset snd_hda_preset_cirrus[] = {
2031         { .id = 0x10134206, .name = "CS4206", .patch = patch_cs420x },
2032         { .id = 0x10134207, .name = "CS4207", .patch = patch_cs420x },
2033         { .id = 0x10134210, .name = "CS4210", .patch = patch_cs4210 },
2034         { .id = 0x10134213, .name = "CS4213", .patch = patch_cs4213 },
2035         {} /* terminator */
2036 };
2037
2038 MODULE_ALIAS("snd-hda-codec-id:10134206");
2039 MODULE_ALIAS("snd-hda-codec-id:10134207");
2040 MODULE_ALIAS("snd-hda-codec-id:10134210");
2041 MODULE_ALIAS("snd-hda-codec-id:10134213");
2042
2043 MODULE_LICENSE("GPL");
2044 MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
2045
2046 static struct hda_codec_preset_list cirrus_list = {
2047         .preset = snd_hda_preset_cirrus,
2048         .owner = THIS_MODULE,
2049 };
2050
2051 static int __init patch_cirrus_init(void)
2052 {
2053         return snd_hda_add_codec_preset(&cirrus_list);
2054 }
2055
2056 static void __exit patch_cirrus_exit(void)
2057 {
2058         snd_hda_delete_codec_preset(&cirrus_list);
2059 }
2060
2061 module_init(patch_cirrus_init)
2062 module_exit(patch_cirrus_exit)