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