1 /* 2 * HD audio interface patch for Creative CA0132 chip 3 * 4 * Copyright (c) 2011, Creative Technology Ltd. 5 * 6 * Based on patch_ca0110.c 7 * Copyright (c) 2008 Takashi Iwai <tiwai@suse.de> 8 * 9 * This driver is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This driver is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 */ 23 24 #include <linux/init.h> 25 #include <linux/delay.h> 26 #include <linux/slab.h> 27 #include <linux/pci.h> 28 #include <linux/mutex.h> 29 #include <linux/module.h> 30 #include <sound/core.h> 31 #include "hda_codec.h" 32 #include "hda_local.h" 33 34 #define WIDGET_CHIP_CTRL 0x15 35 #define WIDGET_DSP_CTRL 0x16 36 37 #define WUH_MEM_CONNID 10 38 #define DSP_MEM_CONNID 16 39 40 enum hda_cmd_vendor_io { 41 /* for DspIO node */ 42 VENDOR_DSPIO_SCP_WRITE_DATA_LOW = 0x000, 43 VENDOR_DSPIO_SCP_WRITE_DATA_HIGH = 0x100, 44 45 VENDOR_DSPIO_STATUS = 0xF01, 46 VENDOR_DSPIO_SCP_POST_READ_DATA = 0x702, 47 VENDOR_DSPIO_SCP_READ_DATA = 0xF02, 48 VENDOR_DSPIO_DSP_INIT = 0x703, 49 VENDOR_DSPIO_SCP_POST_COUNT_QUERY = 0x704, 50 VENDOR_DSPIO_SCP_READ_COUNT = 0xF04, 51 52 /* for ChipIO node */ 53 VENDOR_CHIPIO_ADDRESS_LOW = 0x000, 54 VENDOR_CHIPIO_ADDRESS_HIGH = 0x100, 55 VENDOR_CHIPIO_STREAM_FORMAT = 0x200, 56 VENDOR_CHIPIO_DATA_LOW = 0x300, 57 VENDOR_CHIPIO_DATA_HIGH = 0x400, 58 59 VENDOR_CHIPIO_GET_PARAMETER = 0xF00, 60 VENDOR_CHIPIO_STATUS = 0xF01, 61 VENDOR_CHIPIO_HIC_POST_READ = 0x702, 62 VENDOR_CHIPIO_HIC_READ_DATA = 0xF03, 63 64 VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE = 0x70A, 65 66 VENDOR_CHIPIO_PLL_PMU_WRITE = 0x70C, 67 VENDOR_CHIPIO_PLL_PMU_READ = 0xF0C, 68 VENDOR_CHIPIO_8051_ADDRESS_LOW = 0x70D, 69 VENDOR_CHIPIO_8051_ADDRESS_HIGH = 0x70E, 70 VENDOR_CHIPIO_FLAG_SET = 0x70F, 71 VENDOR_CHIPIO_FLAGS_GET = 0xF0F, 72 VENDOR_CHIPIO_PARAMETER_SET = 0x710, 73 VENDOR_CHIPIO_PARAMETER_GET = 0xF10, 74 75 VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET = 0x711, 76 VENDOR_CHIPIO_PORT_ALLOC_SET = 0x712, 77 VENDOR_CHIPIO_PORT_ALLOC_GET = 0xF12, 78 VENDOR_CHIPIO_PORT_FREE_SET = 0x713, 79 80 VENDOR_CHIPIO_PARAMETER_EX_ID_GET = 0xF17, 81 VENDOR_CHIPIO_PARAMETER_EX_ID_SET = 0x717, 82 VENDOR_CHIPIO_PARAMETER_EX_VALUE_GET = 0xF18, 83 VENDOR_CHIPIO_PARAMETER_EX_VALUE_SET = 0x718 84 }; 85 86 /* 87 * Control flag IDs 88 */ 89 enum control_flag_id { 90 /* Connection manager stream setup is bypassed/enabled */ 91 CONTROL_FLAG_C_MGR = 0, 92 /* DSP DMA is bypassed/enabled */ 93 CONTROL_FLAG_DMA = 1, 94 /* 8051 'idle' mode is disabled/enabled */ 95 CONTROL_FLAG_IDLE_ENABLE = 2, 96 /* Tracker for the SPDIF-in path is bypassed/enabled */ 97 CONTROL_FLAG_TRACKER = 3, 98 /* DigitalOut to Spdif2Out connection is disabled/enabled */ 99 CONTROL_FLAG_SPDIF2OUT = 4, 100 /* Digital Microphone is disabled/enabled */ 101 CONTROL_FLAG_DMIC = 5, 102 /* ADC_B rate is 48 kHz/96 kHz */ 103 CONTROL_FLAG_ADC_B_96KHZ = 6, 104 /* ADC_C rate is 48 kHz/96 kHz */ 105 CONTROL_FLAG_ADC_C_96KHZ = 7, 106 /* DAC rate is 48 kHz/96 kHz (affects all DACs) */ 107 CONTROL_FLAG_DAC_96KHZ = 8, 108 /* DSP rate is 48 kHz/96 kHz */ 109 CONTROL_FLAG_DSP_96KHZ = 9, 110 /* SRC clock is 98 MHz/196 MHz (196 MHz forces rate to 96 KHz) */ 111 CONTROL_FLAG_SRC_CLOCK_196MHZ = 10, 112 /* SRC rate is 48 kHz/96 kHz (48 kHz disabled when clock is 196 MHz) */ 113 CONTROL_FLAG_SRC_RATE_96KHZ = 11, 114 /* Decode Loop (DSP->SRC->DSP) is disabled/enabled */ 115 CONTROL_FLAG_DECODE_LOOP = 12, 116 /* De-emphasis filter on DAC-1 disabled/enabled */ 117 CONTROL_FLAG_DAC1_DEEMPHASIS = 13, 118 /* De-emphasis filter on DAC-2 disabled/enabled */ 119 CONTROL_FLAG_DAC2_DEEMPHASIS = 14, 120 /* De-emphasis filter on DAC-3 disabled/enabled */ 121 CONTROL_FLAG_DAC3_DEEMPHASIS = 15, 122 /* High-pass filter on ADC_B disabled/enabled */ 123 CONTROL_FLAG_ADC_B_HIGH_PASS = 16, 124 /* High-pass filter on ADC_C disabled/enabled */ 125 CONTROL_FLAG_ADC_C_HIGH_PASS = 17, 126 /* Common mode on Port_A disabled/enabled */ 127 CONTROL_FLAG_PORT_A_COMMON_MODE = 18, 128 /* Common mode on Port_D disabled/enabled */ 129 CONTROL_FLAG_PORT_D_COMMON_MODE = 19, 130 /* Impedance for ramp generator on Port_A 16 Ohm/10K Ohm */ 131 CONTROL_FLAG_PORT_A_10KOHM_LOAD = 20, 132 /* Impedance for ramp generator on Port_D, 16 Ohm/10K Ohm */ 133 CONTROL_FLAG_PORT_D_10K0HM_LOAD = 21, 134 /* ASI rate is 48kHz/96kHz */ 135 CONTROL_FLAG_ASI_96KHZ = 22, 136 /* DAC power settings able to control attached ports no/yes */ 137 CONTROL_FLAG_DACS_CONTROL_PORTS = 23, 138 /* Clock Stop OK reporting is disabled/enabled */ 139 CONTROL_FLAG_CONTROL_STOP_OK_ENABLE = 24, 140 /* Number of control flags */ 141 CONTROL_FLAGS_MAX = (CONTROL_FLAG_CONTROL_STOP_OK_ENABLE+1) 142 }; 143 144 /* 145 * Control parameter IDs 146 */ 147 enum control_parameter_id { 148 /* 0: force HDA, 1: allow DSP if HDA Spdif1Out stream is idle */ 149 CONTROL_PARAM_SPDIF1_SOURCE = 2, 150 151 /* Stream Control */ 152 153 /* Select stream with the given ID */ 154 CONTROL_PARAM_STREAM_ID = 24, 155 /* Source connection point for the selected stream */ 156 CONTROL_PARAM_STREAM_SOURCE_CONN_POINT = 25, 157 /* Destination connection point for the selected stream */ 158 CONTROL_PARAM_STREAM_DEST_CONN_POINT = 26, 159 /* Number of audio channels in the selected stream */ 160 CONTROL_PARAM_STREAMS_CHANNELS = 27, 161 /*Enable control for the selected stream */ 162 CONTROL_PARAM_STREAM_CONTROL = 28, 163 164 /* Connection Point Control */ 165 166 /* Select connection point with the given ID */ 167 CONTROL_PARAM_CONN_POINT_ID = 29, 168 /* Connection point sample rate */ 169 CONTROL_PARAM_CONN_POINT_SAMPLE_RATE = 30, 170 171 /* Node Control */ 172 173 /* Select HDA node with the given ID */ 174 CONTROL_PARAM_NODE_ID = 31 175 }; 176 177 /* 178 * Dsp Io Status codes 179 */ 180 enum hda_vendor_status_dspio { 181 /* Success */ 182 VENDOR_STATUS_DSPIO_OK = 0x00, 183 /* Busy, unable to accept new command, the host must retry */ 184 VENDOR_STATUS_DSPIO_BUSY = 0x01, 185 /* SCP command queue is full */ 186 VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL = 0x02, 187 /* SCP response queue is empty */ 188 VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY = 0x03 189 }; 190 191 /* 192 * Chip Io Status codes 193 */ 194 enum hda_vendor_status_chipio { 195 /* Success */ 196 VENDOR_STATUS_CHIPIO_OK = 0x00, 197 /* Busy, unable to accept new command, the host must retry */ 198 VENDOR_STATUS_CHIPIO_BUSY = 0x01 199 }; 200 201 /* 202 * CA0132 sample rate 203 */ 204 enum ca0132_sample_rate { 205 SR_6_000 = 0x00, 206 SR_8_000 = 0x01, 207 SR_9_600 = 0x02, 208 SR_11_025 = 0x03, 209 SR_16_000 = 0x04, 210 SR_22_050 = 0x05, 211 SR_24_000 = 0x06, 212 SR_32_000 = 0x07, 213 SR_44_100 = 0x08, 214 SR_48_000 = 0x09, 215 SR_88_200 = 0x0A, 216 SR_96_000 = 0x0B, 217 SR_144_000 = 0x0C, 218 SR_176_400 = 0x0D, 219 SR_192_000 = 0x0E, 220 SR_384_000 = 0x0F, 221 222 SR_COUNT = 0x10, 223 224 SR_RATE_UNKNOWN = 0x1F 225 }; 226 227 /* 228 * Scp Helper function 229 */ 230 enum get_set { 231 IS_SET = 0, 232 IS_GET = 1, 233 }; 234 235 /* 236 * Duplicated from ca0110 codec 237 */ 238 239 static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac) 240 { 241 if (pin) { 242 snd_hda_codec_write(codec, pin, 0, 243 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP); 244 if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP) 245 snd_hda_codec_write(codec, pin, 0, 246 AC_VERB_SET_AMP_GAIN_MUTE, 247 AMP_OUT_UNMUTE); 248 } 249 if (dac) 250 snd_hda_codec_write(codec, dac, 0, 251 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO); 252 } 253 254 static void init_input(struct hda_codec *codec, hda_nid_t pin, hda_nid_t adc) 255 { 256 if (pin) { 257 snd_hda_codec_write(codec, pin, 0, 258 AC_VERB_SET_PIN_WIDGET_CONTROL, 259 PIN_VREF80); 260 if (get_wcaps(codec, pin) & AC_WCAP_IN_AMP) 261 snd_hda_codec_write(codec, pin, 0, 262 AC_VERB_SET_AMP_GAIN_MUTE, 263 AMP_IN_UNMUTE(0)); 264 } 265 if (adc) 266 snd_hda_codec_write(codec, adc, 0, AC_VERB_SET_AMP_GAIN_MUTE, 267 AMP_IN_UNMUTE(0)); 268 } 269 270 static char *dirstr[2] = { "Playback", "Capture" }; 271 272 static int _add_switch(struct hda_codec *codec, hda_nid_t nid, const char *pfx, 273 int chan, int dir) 274 { 275 char namestr[44]; 276 int type = dir ? HDA_INPUT : HDA_OUTPUT; 277 struct snd_kcontrol_new knew = 278 HDA_CODEC_MUTE_MONO(namestr, nid, chan, 0, type); 279 sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]); 280 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); 281 } 282 283 static int _add_volume(struct hda_codec *codec, hda_nid_t nid, const char *pfx, 284 int chan, int dir) 285 { 286 char namestr[44]; 287 int type = dir ? HDA_INPUT : HDA_OUTPUT; 288 struct snd_kcontrol_new knew = 289 HDA_CODEC_VOLUME_MONO(namestr, nid, chan, 0, type); 290 sprintf(namestr, "%s %s Volume", pfx, dirstr[dir]); 291 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); 292 } 293 294 #define add_out_switch(codec, nid, pfx) _add_switch(codec, nid, pfx, 3, 0) 295 #define add_out_volume(codec, nid, pfx) _add_volume(codec, nid, pfx, 3, 0) 296 #define add_in_switch(codec, nid, pfx) _add_switch(codec, nid, pfx, 3, 1) 297 #define add_in_volume(codec, nid, pfx) _add_volume(codec, nid, pfx, 3, 1) 298 #define add_mono_switch(codec, nid, pfx, chan) \ 299 _add_switch(codec, nid, pfx, chan, 0) 300 #define add_mono_volume(codec, nid, pfx, chan) \ 301 _add_volume(codec, nid, pfx, chan, 0) 302 #define add_in_mono_switch(codec, nid, pfx, chan) \ 303 _add_switch(codec, nid, pfx, chan, 1) 304 #define add_in_mono_volume(codec, nid, pfx, chan) \ 305 _add_volume(codec, nid, pfx, chan, 1) 306 307 308 /* 309 * CA0132 specific 310 */ 311 312 struct ca0132_spec { 313 struct auto_pin_cfg autocfg; 314 struct hda_multi_out multiout; 315 hda_nid_t out_pins[AUTO_CFG_MAX_OUTS]; 316 hda_nid_t dacs[AUTO_CFG_MAX_OUTS]; 317 hda_nid_t hp_dac; 318 hda_nid_t input_pins[AUTO_PIN_LAST]; 319 hda_nid_t adcs[AUTO_PIN_LAST]; 320 hda_nid_t dig_out; 321 hda_nid_t dig_in; 322 unsigned int num_inputs; 323 long curr_hp_switch; 324 long curr_hp_volume[2]; 325 long curr_speaker_switch; 326 struct mutex chipio_mutex; 327 const char *input_labels[AUTO_PIN_LAST]; 328 struct hda_pcm pcm_rec[2]; /* PCM information */ 329 }; 330 331 /* Chip access helper function */ 332 static int chipio_send(struct hda_codec *codec, 333 unsigned int reg, 334 unsigned int data) 335 { 336 unsigned int res; 337 int retry = 50; 338 339 /* send bits of data specified by reg */ 340 do { 341 res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0, 342 reg, data); 343 if (res == VENDOR_STATUS_CHIPIO_OK) 344 return 0; 345 } while (--retry); 346 return -EIO; 347 } 348 349 /* 350 * Write chip address through the vendor widget -- NOT protected by the Mutex! 351 */ 352 static int chipio_write_address(struct hda_codec *codec, 353 unsigned int chip_addx) 354 { 355 int res; 356 357 /* send low 16 bits of the address */ 358 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_LOW, 359 chip_addx & 0xffff); 360 361 if (res != -EIO) { 362 /* send high 16 bits of the address */ 363 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_HIGH, 364 chip_addx >> 16); 365 } 366 367 return res; 368 } 369 370 /* 371 * Write data through the vendor widget -- NOT protected by the Mutex! 372 */ 373 374 static int chipio_write_data(struct hda_codec *codec, unsigned int data) 375 { 376 int res; 377 378 /* send low 16 bits of the data */ 379 res = chipio_send(codec, VENDOR_CHIPIO_DATA_LOW, data & 0xffff); 380 381 if (res != -EIO) { 382 /* send high 16 bits of the data */ 383 res = chipio_send(codec, VENDOR_CHIPIO_DATA_HIGH, 384 data >> 16); 385 } 386 387 return res; 388 } 389 390 /* 391 * Read data through the vendor widget -- NOT protected by the Mutex! 392 */ 393 static int chipio_read_data(struct hda_codec *codec, unsigned int *data) 394 { 395 int res; 396 397 /* post read */ 398 res = chipio_send(codec, VENDOR_CHIPIO_HIC_POST_READ, 0); 399 400 if (res != -EIO) { 401 /* read status */ 402 res = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0); 403 } 404 405 if (res != -EIO) { 406 /* read data */ 407 *data = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0, 408 VENDOR_CHIPIO_HIC_READ_DATA, 409 0); 410 } 411 412 return res; 413 } 414 415 /* 416 * Write given value to the given address through the chip I/O widget. 417 * protected by the Mutex 418 */ 419 static int chipio_write(struct hda_codec *codec, 420 unsigned int chip_addx, const unsigned int data) 421 { 422 struct ca0132_spec *spec = codec->spec; 423 int err; 424 425 mutex_lock(&spec->chipio_mutex); 426 427 /* write the address, and if successful proceed to write data */ 428 err = chipio_write_address(codec, chip_addx); 429 if (err < 0) 430 goto exit; 431 432 err = chipio_write_data(codec, data); 433 if (err < 0) 434 goto exit; 435 436 exit: 437 mutex_unlock(&spec->chipio_mutex); 438 return err; 439 } 440 441 /* 442 * Read the given address through the chip I/O widget 443 * protected by the Mutex 444 */ 445 static int chipio_read(struct hda_codec *codec, 446 unsigned int chip_addx, unsigned int *data) 447 { 448 struct ca0132_spec *spec = codec->spec; 449 int err; 450 451 mutex_lock(&spec->chipio_mutex); 452 453 /* write the address, and if successful proceed to write data */ 454 err = chipio_write_address(codec, chip_addx); 455 if (err < 0) 456 goto exit; 457 458 err = chipio_read_data(codec, data); 459 if (err < 0) 460 goto exit; 461 462 exit: 463 mutex_unlock(&spec->chipio_mutex); 464 return err; 465 } 466 467 /* 468 * PCM stuffs 469 */ 470 static void ca0132_setup_stream(struct hda_codec *codec, hda_nid_t nid, 471 u32 stream_tag, 472 int channel_id, int format) 473 { 474 unsigned int oldval, newval; 475 476 if (!nid) 477 return; 478 479 snd_printdd("ca0132_setup_stream: " 480 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n", 481 nid, stream_tag, channel_id, format); 482 483 /* update the format-id if changed */ 484 oldval = snd_hda_codec_read(codec, nid, 0, 485 AC_VERB_GET_STREAM_FORMAT, 486 0); 487 if (oldval != format) { 488 msleep(20); 489 snd_hda_codec_write(codec, nid, 0, 490 AC_VERB_SET_STREAM_FORMAT, 491 format); 492 } 493 494 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0); 495 newval = (stream_tag << 4) | channel_id; 496 if (oldval != newval) { 497 snd_hda_codec_write(codec, nid, 0, 498 AC_VERB_SET_CHANNEL_STREAMID, 499 newval); 500 } 501 } 502 503 static void ca0132_cleanup_stream(struct hda_codec *codec, hda_nid_t nid) 504 { 505 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0); 506 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0); 507 } 508 509 /* 510 * PCM callbacks 511 */ 512 static int ca0132_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 513 struct hda_codec *codec, 514 unsigned int stream_tag, 515 unsigned int format, 516 struct snd_pcm_substream *substream) 517 { 518 struct ca0132_spec *spec = codec->spec; 519 520 ca0132_setup_stream(codec, spec->dacs[0], stream_tag, 0, format); 521 522 return 0; 523 } 524 525 static int ca0132_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 526 struct hda_codec *codec, 527 struct snd_pcm_substream *substream) 528 { 529 struct ca0132_spec *spec = codec->spec; 530 531 ca0132_cleanup_stream(codec, spec->dacs[0]); 532 533 return 0; 534 } 535 536 /* 537 * Digital out 538 */ 539 static int ca0132_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 540 struct hda_codec *codec, 541 unsigned int stream_tag, 542 unsigned int format, 543 struct snd_pcm_substream *substream) 544 { 545 struct ca0132_spec *spec = codec->spec; 546 547 ca0132_setup_stream(codec, spec->dig_out, stream_tag, 0, format); 548 549 return 0; 550 } 551 552 static int ca0132_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 553 struct hda_codec *codec, 554 struct snd_pcm_substream *substream) 555 { 556 struct ca0132_spec *spec = codec->spec; 557 558 ca0132_cleanup_stream(codec, spec->dig_out); 559 560 return 0; 561 } 562 563 /* 564 * Analog capture 565 */ 566 static int ca0132_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 567 struct hda_codec *codec, 568 unsigned int stream_tag, 569 unsigned int format, 570 struct snd_pcm_substream *substream) 571 { 572 struct ca0132_spec *spec = codec->spec; 573 574 ca0132_setup_stream(codec, spec->adcs[substream->number], 575 stream_tag, 0, format); 576 577 return 0; 578 } 579 580 static int ca0132_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 581 struct hda_codec *codec, 582 struct snd_pcm_substream *substream) 583 { 584 struct ca0132_spec *spec = codec->spec; 585 586 ca0132_cleanup_stream(codec, spec->adcs[substream->number]); 587 588 return 0; 589 } 590 591 /* 592 * Digital capture 593 */ 594 static int ca0132_dig_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 595 struct hda_codec *codec, 596 unsigned int stream_tag, 597 unsigned int format, 598 struct snd_pcm_substream *substream) 599 { 600 struct ca0132_spec *spec = codec->spec; 601 602 ca0132_setup_stream(codec, spec->dig_in, stream_tag, 0, format); 603 604 return 0; 605 } 606 607 static int ca0132_dig_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 608 struct hda_codec *codec, 609 struct snd_pcm_substream *substream) 610 { 611 struct ca0132_spec *spec = codec->spec; 612 613 ca0132_cleanup_stream(codec, spec->dig_in); 614 615 return 0; 616 } 617 618 /* 619 */ 620 static struct hda_pcm_stream ca0132_pcm_analog_playback = { 621 .substreams = 1, 622 .channels_min = 2, 623 .channels_max = 2, 624 .ops = { 625 .prepare = ca0132_playback_pcm_prepare, 626 .cleanup = ca0132_playback_pcm_cleanup 627 }, 628 }; 629 630 static struct hda_pcm_stream ca0132_pcm_analog_capture = { 631 .substreams = 1, 632 .channels_min = 2, 633 .channels_max = 2, 634 .ops = { 635 .prepare = ca0132_capture_pcm_prepare, 636 .cleanup = ca0132_capture_pcm_cleanup 637 }, 638 }; 639 640 static struct hda_pcm_stream ca0132_pcm_digital_playback = { 641 .substreams = 1, 642 .channels_min = 2, 643 .channels_max = 2, 644 .ops = { 645 .prepare = ca0132_dig_playback_pcm_prepare, 646 .cleanup = ca0132_dig_playback_pcm_cleanup 647 }, 648 }; 649 650 static struct hda_pcm_stream ca0132_pcm_digital_capture = { 651 .substreams = 1, 652 .channels_min = 2, 653 .channels_max = 2, 654 .ops = { 655 .prepare = ca0132_dig_capture_pcm_prepare, 656 .cleanup = ca0132_dig_capture_pcm_cleanup 657 }, 658 }; 659 660 static int ca0132_build_pcms(struct hda_codec *codec) 661 { 662 struct ca0132_spec *spec = codec->spec; 663 struct hda_pcm *info = spec->pcm_rec; 664 665 codec->pcm_info = info; 666 codec->num_pcms = 0; 667 668 info->name = "CA0132 Analog"; 669 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ca0132_pcm_analog_playback; 670 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dacs[0]; 671 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 672 spec->multiout.max_channels; 673 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture; 674 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_inputs; 675 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[0]; 676 codec->num_pcms++; 677 678 if (!spec->dig_out && !spec->dig_in) 679 return 0; 680 681 info++; 682 info->name = "CA0132 Digital"; 683 info->pcm_type = HDA_PCM_TYPE_SPDIF; 684 if (spec->dig_out) { 685 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 686 ca0132_pcm_digital_playback; 687 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dig_out; 688 } 689 if (spec->dig_in) { 690 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 691 ca0132_pcm_digital_capture; 692 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in; 693 } 694 codec->num_pcms++; 695 696 return 0; 697 } 698 699 #define REG_CODEC_MUTE 0x18b014 700 #define REG_CODEC_HP_VOL_L 0x18b070 701 #define REG_CODEC_HP_VOL_R 0x18b074 702 703 static int ca0132_hp_switch_get(struct snd_kcontrol *kcontrol, 704 struct snd_ctl_elem_value *ucontrol) 705 { 706 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 707 struct ca0132_spec *spec = codec->spec; 708 long *valp = ucontrol->value.integer.value; 709 710 *valp = spec->curr_hp_switch; 711 return 0; 712 } 713 714 static int ca0132_hp_switch_put(struct snd_kcontrol *kcontrol, 715 struct snd_ctl_elem_value *ucontrol) 716 { 717 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 718 struct ca0132_spec *spec = codec->spec; 719 long *valp = ucontrol->value.integer.value; 720 unsigned int data; 721 int err; 722 723 /* any change? */ 724 if (spec->curr_hp_switch == *valp) 725 return 0; 726 727 snd_hda_power_up(codec); 728 729 err = chipio_read(codec, REG_CODEC_MUTE, &data); 730 if (err < 0) 731 goto exit; 732 733 /* *valp 0 is mute, 1 is unmute */ 734 data = (data & 0x7f) | (*valp ? 0 : 0x80); 735 err = chipio_write(codec, REG_CODEC_MUTE, data); 736 if (err < 0) 737 goto exit; 738 739 spec->curr_hp_switch = *valp; 740 741 exit: 742 snd_hda_power_down(codec); 743 return err < 0 ? err : 1; 744 } 745 746 static int ca0132_speaker_switch_get(struct snd_kcontrol *kcontrol, 747 struct snd_ctl_elem_value *ucontrol) 748 { 749 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 750 struct ca0132_spec *spec = codec->spec; 751 long *valp = ucontrol->value.integer.value; 752 753 *valp = spec->curr_speaker_switch; 754 return 0; 755 } 756 757 static int ca0132_speaker_switch_put(struct snd_kcontrol *kcontrol, 758 struct snd_ctl_elem_value *ucontrol) 759 { 760 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 761 struct ca0132_spec *spec = codec->spec; 762 long *valp = ucontrol->value.integer.value; 763 unsigned int data; 764 int err; 765 766 /* any change? */ 767 if (spec->curr_speaker_switch == *valp) 768 return 0; 769 770 snd_hda_power_up(codec); 771 772 err = chipio_read(codec, REG_CODEC_MUTE, &data); 773 if (err < 0) 774 goto exit; 775 776 /* *valp 0 is mute, 1 is unmute */ 777 data = (data & 0xef) | (*valp ? 0 : 0x10); 778 err = chipio_write(codec, REG_CODEC_MUTE, data); 779 if (err < 0) 780 goto exit; 781 782 spec->curr_speaker_switch = *valp; 783 784 exit: 785 snd_hda_power_down(codec); 786 return err < 0 ? err : 1; 787 } 788 789 static int ca0132_hp_volume_get(struct snd_kcontrol *kcontrol, 790 struct snd_ctl_elem_value *ucontrol) 791 { 792 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 793 struct ca0132_spec *spec = codec->spec; 794 long *valp = ucontrol->value.integer.value; 795 796 *valp++ = spec->curr_hp_volume[0]; 797 *valp = spec->curr_hp_volume[1]; 798 return 0; 799 } 800 801 static int ca0132_hp_volume_put(struct snd_kcontrol *kcontrol, 802 struct snd_ctl_elem_value *ucontrol) 803 { 804 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 805 struct ca0132_spec *spec = codec->spec; 806 long *valp = ucontrol->value.integer.value; 807 long left_vol, right_vol; 808 unsigned int data; 809 int val; 810 int err; 811 812 left_vol = *valp++; 813 right_vol = *valp; 814 815 /* any change? */ 816 if ((spec->curr_hp_volume[0] == left_vol) && 817 (spec->curr_hp_volume[1] == right_vol)) 818 return 0; 819 820 snd_hda_power_up(codec); 821 822 err = chipio_read(codec, REG_CODEC_HP_VOL_L, &data); 823 if (err < 0) 824 goto exit; 825 826 val = 31 - left_vol; 827 data = (data & 0xe0) | val; 828 err = chipio_write(codec, REG_CODEC_HP_VOL_L, data); 829 if (err < 0) 830 goto exit; 831 832 val = 31 - right_vol; 833 data = (data & 0xe0) | val; 834 err = chipio_write(codec, REG_CODEC_HP_VOL_R, data); 835 if (err < 0) 836 goto exit; 837 838 spec->curr_hp_volume[0] = left_vol; 839 spec->curr_hp_volume[1] = right_vol; 840 841 exit: 842 snd_hda_power_down(codec); 843 return err < 0 ? err : 1; 844 } 845 846 static int add_hp_switch(struct hda_codec *codec, hda_nid_t nid) 847 { 848 struct snd_kcontrol_new knew = 849 HDA_CODEC_MUTE_MONO("Headphone Playback Switch", 850 nid, 1, 0, HDA_OUTPUT); 851 knew.get = ca0132_hp_switch_get; 852 knew.put = ca0132_hp_switch_put; 853 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); 854 } 855 856 static int add_hp_volume(struct hda_codec *codec, hda_nid_t nid) 857 { 858 struct snd_kcontrol_new knew = 859 HDA_CODEC_VOLUME_MONO("Headphone Playback Volume", 860 nid, 3, 0, HDA_OUTPUT); 861 knew.get = ca0132_hp_volume_get; 862 knew.put = ca0132_hp_volume_put; 863 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); 864 } 865 866 static int add_speaker_switch(struct hda_codec *codec, hda_nid_t nid) 867 { 868 struct snd_kcontrol_new knew = 869 HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 870 nid, 1, 0, HDA_OUTPUT); 871 knew.get = ca0132_speaker_switch_get; 872 knew.put = ca0132_speaker_switch_put; 873 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); 874 } 875 876 static void ca0132_fix_hp_caps(struct hda_codec *codec) 877 { 878 struct ca0132_spec *spec = codec->spec; 879 struct auto_pin_cfg *cfg = &spec->autocfg; 880 unsigned int caps; 881 882 /* set mute-capable, 1db step, 32 steps, ofs 6 */ 883 caps = 0x80031f06; 884 snd_hda_override_amp_caps(codec, cfg->hp_pins[0], HDA_OUTPUT, caps); 885 } 886 887 static int ca0132_build_controls(struct hda_codec *codec) 888 { 889 struct ca0132_spec *spec = codec->spec; 890 struct auto_pin_cfg *cfg = &spec->autocfg; 891 int i, err; 892 893 if (spec->multiout.num_dacs) { 894 err = add_speaker_switch(codec, spec->out_pins[0]); 895 if (err < 0) 896 return err; 897 } 898 899 if (cfg->hp_outs) { 900 ca0132_fix_hp_caps(codec); 901 err = add_hp_switch(codec, cfg->hp_pins[0]); 902 if (err < 0) 903 return err; 904 err = add_hp_volume(codec, cfg->hp_pins[0]); 905 if (err < 0) 906 return err; 907 } 908 909 for (i = 0; i < spec->num_inputs; i++) { 910 const char *label = spec->input_labels[i]; 911 912 err = add_in_switch(codec, spec->adcs[i], label); 913 if (err < 0) 914 return err; 915 err = add_in_volume(codec, spec->adcs[i], label); 916 if (err < 0) 917 return err; 918 if (cfg->inputs[i].type == AUTO_PIN_MIC) { 919 /* add Mic-Boost */ 920 err = add_in_mono_volume(codec, spec->input_pins[i], 921 "Mic Boost", 1); 922 if (err < 0) 923 return err; 924 } 925 } 926 927 if (spec->dig_out) { 928 err = snd_hda_create_spdif_out_ctls(codec, spec->dig_out, 929 spec->dig_out); 930 if (err < 0) 931 return err; 932 err = add_out_volume(codec, spec->dig_out, "IEC958"); 933 if (err < 0) 934 return err; 935 } 936 937 if (spec->dig_in) { 938 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in); 939 if (err < 0) 940 return err; 941 err = add_in_volume(codec, spec->dig_in, "IEC958"); 942 if (err < 0) 943 return err; 944 } 945 return 0; 946 } 947 948 949 static void ca0132_set_ct_ext(struct hda_codec *codec, int enable) 950 { 951 /* Set Creative extension */ 952 snd_printdd("SET CREATIVE EXTENSION\n"); 953 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 954 VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 955 enable); 956 msleep(20); 957 } 958 959 960 static void ca0132_config(struct hda_codec *codec) 961 { 962 struct ca0132_spec *spec = codec->spec; 963 struct auto_pin_cfg *cfg = &spec->autocfg; 964 965 /* line-outs */ 966 cfg->line_outs = 1; 967 cfg->line_out_pins[0] = 0x0b; /* front */ 968 cfg->line_out_type = AUTO_PIN_LINE_OUT; 969 970 spec->dacs[0] = 0x02; 971 spec->out_pins[0] = 0x0b; 972 spec->multiout.dac_nids = spec->dacs; 973 spec->multiout.num_dacs = 1; 974 spec->multiout.max_channels = 2; 975 976 /* headphone */ 977 cfg->hp_outs = 1; 978 cfg->hp_pins[0] = 0x0f; 979 980 spec->hp_dac = 0; 981 spec->multiout.hp_nid = 0; 982 983 /* inputs */ 984 cfg->num_inputs = 2; /* Mic-in and line-in */ 985 cfg->inputs[0].pin = 0x12; 986 cfg->inputs[0].type = AUTO_PIN_MIC; 987 cfg->inputs[1].pin = 0x11; 988 cfg->inputs[1].type = AUTO_PIN_LINE_IN; 989 990 /* Mic-in */ 991 spec->input_pins[0] = 0x12; 992 spec->input_labels[0] = "Mic-In"; 993 spec->adcs[0] = 0x07; 994 995 /* Line-In */ 996 spec->input_pins[1] = 0x11; 997 spec->input_labels[1] = "Line-In"; 998 spec->adcs[1] = 0x08; 999 spec->num_inputs = 2; 1000 } 1001 1002 static void ca0132_init_chip(struct hda_codec *codec) 1003 { 1004 struct ca0132_spec *spec = codec->spec; 1005 1006 mutex_init(&spec->chipio_mutex); 1007 } 1008 1009 static void ca0132_exit_chip(struct hda_codec *codec) 1010 { 1011 /* put any chip cleanup stuffs here. */ 1012 } 1013 1014 static int ca0132_init(struct hda_codec *codec) 1015 { 1016 struct ca0132_spec *spec = codec->spec; 1017 struct auto_pin_cfg *cfg = &spec->autocfg; 1018 int i; 1019 1020 for (i = 0; i < spec->multiout.num_dacs; i++) { 1021 init_output(codec, spec->out_pins[i], 1022 spec->multiout.dac_nids[i]); 1023 } 1024 init_output(codec, cfg->hp_pins[0], spec->hp_dac); 1025 init_output(codec, cfg->dig_out_pins[0], spec->dig_out); 1026 1027 for (i = 0; i < spec->num_inputs; i++) 1028 init_input(codec, spec->input_pins[i], spec->adcs[i]); 1029 1030 init_input(codec, cfg->dig_in_pin, spec->dig_in); 1031 1032 ca0132_set_ct_ext(codec, 1); 1033 1034 return 0; 1035 } 1036 1037 1038 static void ca0132_free(struct hda_codec *codec) 1039 { 1040 ca0132_set_ct_ext(codec, 0); 1041 ca0132_exit_chip(codec); 1042 kfree(codec->spec); 1043 } 1044 1045 static struct hda_codec_ops ca0132_patch_ops = { 1046 .build_controls = ca0132_build_controls, 1047 .build_pcms = ca0132_build_pcms, 1048 .init = ca0132_init, 1049 .free = ca0132_free, 1050 }; 1051 1052 1053 1054 static int patch_ca0132(struct hda_codec *codec) 1055 { 1056 struct ca0132_spec *spec; 1057 1058 snd_printdd("patch_ca0132\n"); 1059 1060 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 1061 if (!spec) 1062 return -ENOMEM; 1063 codec->spec = spec; 1064 1065 ca0132_init_chip(codec); 1066 1067 ca0132_config(codec); 1068 1069 codec->patch_ops = ca0132_patch_ops; 1070 1071 return 0; 1072 } 1073 1074 /* 1075 * patch entries 1076 */ 1077 static struct hda_codec_preset snd_hda_preset_ca0132[] = { 1078 { .id = 0x11020011, .name = "CA0132", .patch = patch_ca0132 }, 1079 {} /* terminator */ 1080 }; 1081 1082 MODULE_ALIAS("snd-hda-codec-id:11020011"); 1083 1084 MODULE_LICENSE("GPL"); 1085 MODULE_DESCRIPTION("Creative CA0132, CA0132 HD-audio codec"); 1086 1087 static struct hda_codec_preset_list ca0132_list = { 1088 .preset = snd_hda_preset_ca0132, 1089 .owner = THIS_MODULE, 1090 }; 1091 1092 static int __init patch_ca0132_init(void) 1093 { 1094 return snd_hda_add_codec_preset(&ca0132_list); 1095 } 1096 1097 static void __exit patch_ca0132_exit(void) 1098 { 1099 snd_hda_delete_codec_preset(&ca0132_list); 1100 } 1101 1102 module_init(patch_ca0132_init) 1103 module_exit(patch_ca0132_exit) 1104