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/mutex.h> 28 #include <linux/module.h> 29 #include <linux/firmware.h> 30 #include <sound/core.h> 31 #include "hda_codec.h" 32 #include "hda_local.h" 33 #include "hda_auto_parser.h" 34 #include "hda_jack.h" 35 36 #include "ca0132_regs.h" 37 38 /* Enable this to see controls for tuning purpose. */ 39 /*#define ENABLE_TUNING_CONTROLS*/ 40 41 #define FLOAT_ZERO 0x00000000 42 #define FLOAT_ONE 0x3f800000 43 #define FLOAT_TWO 0x40000000 44 #define FLOAT_MINUS_5 0xc0a00000 45 46 #define UNSOL_TAG_HP 0x10 47 #define UNSOL_TAG_AMIC1 0x12 48 #define UNSOL_TAG_DSP 0x16 49 50 #define DSP_DMA_WRITE_BUFLEN_INIT (1UL<<18) 51 #define DSP_DMA_WRITE_BUFLEN_OVLY (1UL<<15) 52 53 #define DMA_TRANSFER_FRAME_SIZE_NWORDS 8 54 #define DMA_TRANSFER_MAX_FRAME_SIZE_NWORDS 32 55 #define DMA_OVERLAY_FRAME_SIZE_NWORDS 2 56 57 #define MASTERCONTROL 0x80 58 #define MASTERCONTROL_ALLOC_DMA_CHAN 10 59 #define MASTERCONTROL_QUERY_SPEAKER_EQ_ADDRESS 60 60 61 #define WIDGET_CHIP_CTRL 0x15 62 #define WIDGET_DSP_CTRL 0x16 63 64 #define MEM_CONNID_MICIN1 3 65 #define MEM_CONNID_MICIN2 5 66 #define MEM_CONNID_MICOUT1 12 67 #define MEM_CONNID_MICOUT2 14 68 #define MEM_CONNID_WUH 10 69 #define MEM_CONNID_DSP 16 70 #define MEM_CONNID_DMIC 100 71 72 #define SCP_SET 0 73 #define SCP_GET 1 74 75 #define EFX_FILE "ctefx.bin" 76 77 #ifdef CONFIG_SND_HDA_CODEC_CA0132_DSP 78 MODULE_FIRMWARE(EFX_FILE); 79 #endif 80 81 static char *dirstr[2] = { "Playback", "Capture" }; 82 83 enum { 84 SPEAKER_OUT, 85 HEADPHONE_OUT 86 }; 87 88 enum { 89 DIGITAL_MIC, 90 LINE_MIC_IN 91 }; 92 93 enum { 94 #define VNODE_START_NID 0x80 95 VNID_SPK = VNODE_START_NID, /* Speaker vnid */ 96 VNID_MIC, 97 VNID_HP_SEL, 98 VNID_AMIC1_SEL, 99 VNID_HP_ASEL, 100 VNID_AMIC1_ASEL, 101 VNODE_END_NID, 102 #define VNODES_COUNT (VNODE_END_NID - VNODE_START_NID) 103 104 #define EFFECT_START_NID 0x90 105 #define OUT_EFFECT_START_NID EFFECT_START_NID 106 SURROUND = OUT_EFFECT_START_NID, 107 CRYSTALIZER, 108 DIALOG_PLUS, 109 SMART_VOLUME, 110 X_BASS, 111 EQUALIZER, 112 OUT_EFFECT_END_NID, 113 #define OUT_EFFECTS_COUNT (OUT_EFFECT_END_NID - OUT_EFFECT_START_NID) 114 115 #define IN_EFFECT_START_NID OUT_EFFECT_END_NID 116 ECHO_CANCELLATION = IN_EFFECT_START_NID, 117 VOICE_FOCUS, 118 MIC_SVM, 119 NOISE_REDUCTION, 120 IN_EFFECT_END_NID, 121 #define IN_EFFECTS_COUNT (IN_EFFECT_END_NID - IN_EFFECT_START_NID) 122 123 VOICEFX = IN_EFFECT_END_NID, 124 PLAY_ENHANCEMENT, 125 CRYSTAL_VOICE, 126 EFFECT_END_NID 127 #define EFFECTS_COUNT (EFFECT_END_NID - EFFECT_START_NID) 128 }; 129 130 /* Effects values size*/ 131 #define EFFECT_VALS_MAX_COUNT 12 132 133 /* Latency introduced by DSP blocks in milliseconds. */ 134 #define DSP_CAPTURE_INIT_LATENCY 0 135 #define DSP_CRYSTAL_VOICE_LATENCY 124 136 #define DSP_PLAYBACK_INIT_LATENCY 13 137 #define DSP_PLAY_ENHANCEMENT_LATENCY 30 138 #define DSP_SPEAKER_OUT_LATENCY 7 139 140 struct ct_effect { 141 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 142 hda_nid_t nid; 143 int mid; /*effect module ID*/ 144 int reqs[EFFECT_VALS_MAX_COUNT]; /*effect module request*/ 145 int direct; /* 0:output; 1:input*/ 146 int params; /* number of default non-on/off params */ 147 /*effect default values, 1st is on/off. */ 148 unsigned int def_vals[EFFECT_VALS_MAX_COUNT]; 149 }; 150 151 #define EFX_DIR_OUT 0 152 #define EFX_DIR_IN 1 153 154 static struct ct_effect ca0132_effects[EFFECTS_COUNT] = { 155 { .name = "Surround", 156 .nid = SURROUND, 157 .mid = 0x96, 158 .reqs = {0, 1}, 159 .direct = EFX_DIR_OUT, 160 .params = 1, 161 .def_vals = {0x3F800000, 0x3F2B851F} 162 }, 163 { .name = "Crystalizer", 164 .nid = CRYSTALIZER, 165 .mid = 0x96, 166 .reqs = {7, 8}, 167 .direct = EFX_DIR_OUT, 168 .params = 1, 169 .def_vals = {0x3F800000, 0x3F266666} 170 }, 171 { .name = "Dialog Plus", 172 .nid = DIALOG_PLUS, 173 .mid = 0x96, 174 .reqs = {2, 3}, 175 .direct = EFX_DIR_OUT, 176 .params = 1, 177 .def_vals = {0x00000000, 0x3F000000} 178 }, 179 { .name = "Smart Volume", 180 .nid = SMART_VOLUME, 181 .mid = 0x96, 182 .reqs = {4, 5, 6}, 183 .direct = EFX_DIR_OUT, 184 .params = 2, 185 .def_vals = {0x3F800000, 0x3F3D70A4, 0x00000000} 186 }, 187 { .name = "X-Bass", 188 .nid = X_BASS, 189 .mid = 0x96, 190 .reqs = {24, 23, 25}, 191 .direct = EFX_DIR_OUT, 192 .params = 2, 193 .def_vals = {0x3F800000, 0x42A00000, 0x3F000000} 194 }, 195 { .name = "Equalizer", 196 .nid = EQUALIZER, 197 .mid = 0x96, 198 .reqs = {9, 10, 11, 12, 13, 14, 199 15, 16, 17, 18, 19, 20}, 200 .direct = EFX_DIR_OUT, 201 .params = 11, 202 .def_vals = {0x00000000, 0x00000000, 0x00000000, 0x00000000, 203 0x00000000, 0x00000000, 0x00000000, 0x00000000, 204 0x00000000, 0x00000000, 0x00000000, 0x00000000} 205 }, 206 { .name = "Echo Cancellation", 207 .nid = ECHO_CANCELLATION, 208 .mid = 0x95, 209 .reqs = {0, 1, 2, 3}, 210 .direct = EFX_DIR_IN, 211 .params = 3, 212 .def_vals = {0x00000000, 0x3F3A9692, 0x00000000, 0x00000000} 213 }, 214 { .name = "Voice Focus", 215 .nid = VOICE_FOCUS, 216 .mid = 0x95, 217 .reqs = {6, 7, 8, 9}, 218 .direct = EFX_DIR_IN, 219 .params = 3, 220 .def_vals = {0x3F800000, 0x3D7DF3B6, 0x41F00000, 0x41F00000} 221 }, 222 { .name = "Mic SVM", 223 .nid = MIC_SVM, 224 .mid = 0x95, 225 .reqs = {44, 45}, 226 .direct = EFX_DIR_IN, 227 .params = 1, 228 .def_vals = {0x00000000, 0x3F3D70A4} 229 }, 230 { .name = "Noise Reduction", 231 .nid = NOISE_REDUCTION, 232 .mid = 0x95, 233 .reqs = {4, 5}, 234 .direct = EFX_DIR_IN, 235 .params = 1, 236 .def_vals = {0x3F800000, 0x3F000000} 237 }, 238 { .name = "VoiceFX", 239 .nid = VOICEFX, 240 .mid = 0x95, 241 .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18}, 242 .direct = EFX_DIR_IN, 243 .params = 8, 244 .def_vals = {0x00000000, 0x43C80000, 0x44AF0000, 0x44FA0000, 245 0x3F800000, 0x3F800000, 0x3F800000, 0x00000000, 246 0x00000000} 247 } 248 }; 249 250 /* Tuning controls */ 251 #ifdef ENABLE_TUNING_CONTROLS 252 253 enum { 254 #define TUNING_CTL_START_NID 0xC0 255 WEDGE_ANGLE = TUNING_CTL_START_NID, 256 SVM_LEVEL, 257 EQUALIZER_BAND_0, 258 EQUALIZER_BAND_1, 259 EQUALIZER_BAND_2, 260 EQUALIZER_BAND_3, 261 EQUALIZER_BAND_4, 262 EQUALIZER_BAND_5, 263 EQUALIZER_BAND_6, 264 EQUALIZER_BAND_7, 265 EQUALIZER_BAND_8, 266 EQUALIZER_BAND_9, 267 TUNING_CTL_END_NID 268 #define TUNING_CTLS_COUNT (TUNING_CTL_END_NID - TUNING_CTL_START_NID) 269 }; 270 271 struct ct_tuning_ctl { 272 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 273 hda_nid_t parent_nid; 274 hda_nid_t nid; 275 int mid; /*effect module ID*/ 276 int req; /*effect module request*/ 277 int direct; /* 0:output; 1:input*/ 278 unsigned int def_val;/*effect default values*/ 279 }; 280 281 static struct ct_tuning_ctl ca0132_tuning_ctls[] = { 282 { .name = "Wedge Angle", 283 .parent_nid = VOICE_FOCUS, 284 .nid = WEDGE_ANGLE, 285 .mid = 0x95, 286 .req = 8, 287 .direct = EFX_DIR_IN, 288 .def_val = 0x41F00000 289 }, 290 { .name = "SVM Level", 291 .parent_nid = MIC_SVM, 292 .nid = SVM_LEVEL, 293 .mid = 0x95, 294 .req = 45, 295 .direct = EFX_DIR_IN, 296 .def_val = 0x3F3D70A4 297 }, 298 { .name = "EQ Band0", 299 .parent_nid = EQUALIZER, 300 .nid = EQUALIZER_BAND_0, 301 .mid = 0x96, 302 .req = 11, 303 .direct = EFX_DIR_OUT, 304 .def_val = 0x00000000 305 }, 306 { .name = "EQ Band1", 307 .parent_nid = EQUALIZER, 308 .nid = EQUALIZER_BAND_1, 309 .mid = 0x96, 310 .req = 12, 311 .direct = EFX_DIR_OUT, 312 .def_val = 0x00000000 313 }, 314 { .name = "EQ Band2", 315 .parent_nid = EQUALIZER, 316 .nid = EQUALIZER_BAND_2, 317 .mid = 0x96, 318 .req = 13, 319 .direct = EFX_DIR_OUT, 320 .def_val = 0x00000000 321 }, 322 { .name = "EQ Band3", 323 .parent_nid = EQUALIZER, 324 .nid = EQUALIZER_BAND_3, 325 .mid = 0x96, 326 .req = 14, 327 .direct = EFX_DIR_OUT, 328 .def_val = 0x00000000 329 }, 330 { .name = "EQ Band4", 331 .parent_nid = EQUALIZER, 332 .nid = EQUALIZER_BAND_4, 333 .mid = 0x96, 334 .req = 15, 335 .direct = EFX_DIR_OUT, 336 .def_val = 0x00000000 337 }, 338 { .name = "EQ Band5", 339 .parent_nid = EQUALIZER, 340 .nid = EQUALIZER_BAND_5, 341 .mid = 0x96, 342 .req = 16, 343 .direct = EFX_DIR_OUT, 344 .def_val = 0x00000000 345 }, 346 { .name = "EQ Band6", 347 .parent_nid = EQUALIZER, 348 .nid = EQUALIZER_BAND_6, 349 .mid = 0x96, 350 .req = 17, 351 .direct = EFX_DIR_OUT, 352 .def_val = 0x00000000 353 }, 354 { .name = "EQ Band7", 355 .parent_nid = EQUALIZER, 356 .nid = EQUALIZER_BAND_7, 357 .mid = 0x96, 358 .req = 18, 359 .direct = EFX_DIR_OUT, 360 .def_val = 0x00000000 361 }, 362 { .name = "EQ Band8", 363 .parent_nid = EQUALIZER, 364 .nid = EQUALIZER_BAND_8, 365 .mid = 0x96, 366 .req = 19, 367 .direct = EFX_DIR_OUT, 368 .def_val = 0x00000000 369 }, 370 { .name = "EQ Band9", 371 .parent_nid = EQUALIZER, 372 .nid = EQUALIZER_BAND_9, 373 .mid = 0x96, 374 .req = 20, 375 .direct = EFX_DIR_OUT, 376 .def_val = 0x00000000 377 } 378 }; 379 #endif 380 381 /* Voice FX Presets */ 382 #define VOICEFX_MAX_PARAM_COUNT 9 383 384 struct ct_voicefx { 385 char *name; 386 hda_nid_t nid; 387 int mid; 388 int reqs[VOICEFX_MAX_PARAM_COUNT]; /*effect module request*/ 389 }; 390 391 struct ct_voicefx_preset { 392 char *name; /*preset name*/ 393 unsigned int vals[VOICEFX_MAX_PARAM_COUNT]; 394 }; 395 396 static struct ct_voicefx ca0132_voicefx = { 397 .name = "VoiceFX Capture Switch", 398 .nid = VOICEFX, 399 .mid = 0x95, 400 .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18} 401 }; 402 403 static struct ct_voicefx_preset ca0132_voicefx_presets[] = { 404 { .name = "Neutral", 405 .vals = { 0x00000000, 0x43C80000, 0x44AF0000, 406 0x44FA0000, 0x3F800000, 0x3F800000, 407 0x3F800000, 0x00000000, 0x00000000 } 408 }, 409 { .name = "Female2Male", 410 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000, 411 0x44FA0000, 0x3F19999A, 0x3F866666, 412 0x3F800000, 0x00000000, 0x00000000 } 413 }, 414 { .name = "Male2Female", 415 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000, 416 0x450AC000, 0x4017AE14, 0x3F6B851F, 417 0x3F800000, 0x00000000, 0x00000000 } 418 }, 419 { .name = "ScrappyKid", 420 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000, 421 0x44FA0000, 0x40400000, 0x3F28F5C3, 422 0x3F800000, 0x00000000, 0x00000000 } 423 }, 424 { .name = "Elderly", 425 .vals = { 0x3F800000, 0x44324000, 0x44BB8000, 426 0x44E10000, 0x3FB33333, 0x3FB9999A, 427 0x3F800000, 0x3E3A2E43, 0x00000000 } 428 }, 429 { .name = "Orc", 430 .vals = { 0x3F800000, 0x43EA0000, 0x44A52000, 431 0x45098000, 0x3F266666, 0x3FC00000, 432 0x3F800000, 0x00000000, 0x00000000 } 433 }, 434 { .name = "Elf", 435 .vals = { 0x3F800000, 0x43C70000, 0x44AE6000, 436 0x45193000, 0x3F8E147B, 0x3F75C28F, 437 0x3F800000, 0x00000000, 0x00000000 } 438 }, 439 { .name = "Dwarf", 440 .vals = { 0x3F800000, 0x43930000, 0x44BEE000, 441 0x45007000, 0x3F451EB8, 0x3F7851EC, 442 0x3F800000, 0x00000000, 0x00000000 } 443 }, 444 { .name = "AlienBrute", 445 .vals = { 0x3F800000, 0x43BFC5AC, 0x44B28FDF, 446 0x451F6000, 0x3F266666, 0x3FA7D945, 447 0x3F800000, 0x3CF5C28F, 0x00000000 } 448 }, 449 { .name = "Robot", 450 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000, 451 0x44FA0000, 0x3FB2718B, 0x3F800000, 452 0xBC07010E, 0x00000000, 0x00000000 } 453 }, 454 { .name = "Marine", 455 .vals = { 0x3F800000, 0x43C20000, 0x44906000, 456 0x44E70000, 0x3F4CCCCD, 0x3F8A3D71, 457 0x3F0A3D71, 0x00000000, 0x00000000 } 458 }, 459 { .name = "Emo", 460 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000, 461 0x44FA0000, 0x3F800000, 0x3F800000, 462 0x3E4CCCCD, 0x00000000, 0x00000000 } 463 }, 464 { .name = "DeepVoice", 465 .vals = { 0x3F800000, 0x43A9C5AC, 0x44AA4FDF, 466 0x44FFC000, 0x3EDBB56F, 0x3F99C4CA, 467 0x3F800000, 0x00000000, 0x00000000 } 468 }, 469 { .name = "Munchkin", 470 .vals = { 0x3F800000, 0x43C80000, 0x44AF0000, 471 0x44FA0000, 0x3F800000, 0x3F1A043C, 472 0x3F800000, 0x00000000, 0x00000000 } 473 } 474 }; 475 476 enum hda_cmd_vendor_io { 477 /* for DspIO node */ 478 VENDOR_DSPIO_SCP_WRITE_DATA_LOW = 0x000, 479 VENDOR_DSPIO_SCP_WRITE_DATA_HIGH = 0x100, 480 481 VENDOR_DSPIO_STATUS = 0xF01, 482 VENDOR_DSPIO_SCP_POST_READ_DATA = 0x702, 483 VENDOR_DSPIO_SCP_READ_DATA = 0xF02, 484 VENDOR_DSPIO_DSP_INIT = 0x703, 485 VENDOR_DSPIO_SCP_POST_COUNT_QUERY = 0x704, 486 VENDOR_DSPIO_SCP_READ_COUNT = 0xF04, 487 488 /* for ChipIO node */ 489 VENDOR_CHIPIO_ADDRESS_LOW = 0x000, 490 VENDOR_CHIPIO_ADDRESS_HIGH = 0x100, 491 VENDOR_CHIPIO_STREAM_FORMAT = 0x200, 492 VENDOR_CHIPIO_DATA_LOW = 0x300, 493 VENDOR_CHIPIO_DATA_HIGH = 0x400, 494 495 VENDOR_CHIPIO_GET_PARAMETER = 0xF00, 496 VENDOR_CHIPIO_STATUS = 0xF01, 497 VENDOR_CHIPIO_HIC_POST_READ = 0x702, 498 VENDOR_CHIPIO_HIC_READ_DATA = 0xF03, 499 500 VENDOR_CHIPIO_8051_DATA_WRITE = 0x707, 501 VENDOR_CHIPIO_8051_DATA_READ = 0xF07, 502 503 VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE = 0x70A, 504 VENDOR_CHIPIO_CT_EXTENSIONS_GET = 0xF0A, 505 506 VENDOR_CHIPIO_PLL_PMU_WRITE = 0x70C, 507 VENDOR_CHIPIO_PLL_PMU_READ = 0xF0C, 508 VENDOR_CHIPIO_8051_ADDRESS_LOW = 0x70D, 509 VENDOR_CHIPIO_8051_ADDRESS_HIGH = 0x70E, 510 VENDOR_CHIPIO_FLAG_SET = 0x70F, 511 VENDOR_CHIPIO_FLAGS_GET = 0xF0F, 512 VENDOR_CHIPIO_PARAM_SET = 0x710, 513 VENDOR_CHIPIO_PARAM_GET = 0xF10, 514 515 VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET = 0x711, 516 VENDOR_CHIPIO_PORT_ALLOC_SET = 0x712, 517 VENDOR_CHIPIO_PORT_ALLOC_GET = 0xF12, 518 VENDOR_CHIPIO_PORT_FREE_SET = 0x713, 519 520 VENDOR_CHIPIO_PARAM_EX_ID_GET = 0xF17, 521 VENDOR_CHIPIO_PARAM_EX_ID_SET = 0x717, 522 VENDOR_CHIPIO_PARAM_EX_VALUE_GET = 0xF18, 523 VENDOR_CHIPIO_PARAM_EX_VALUE_SET = 0x718, 524 525 VENDOR_CHIPIO_DMIC_CTL_SET = 0x788, 526 VENDOR_CHIPIO_DMIC_CTL_GET = 0xF88, 527 VENDOR_CHIPIO_DMIC_PIN_SET = 0x789, 528 VENDOR_CHIPIO_DMIC_PIN_GET = 0xF89, 529 VENDOR_CHIPIO_DMIC_MCLK_SET = 0x78A, 530 VENDOR_CHIPIO_DMIC_MCLK_GET = 0xF8A, 531 532 VENDOR_CHIPIO_EAPD_SEL_SET = 0x78D 533 }; 534 535 /* 536 * Control flag IDs 537 */ 538 enum control_flag_id { 539 /* Connection manager stream setup is bypassed/enabled */ 540 CONTROL_FLAG_C_MGR = 0, 541 /* DSP DMA is bypassed/enabled */ 542 CONTROL_FLAG_DMA = 1, 543 /* 8051 'idle' mode is disabled/enabled */ 544 CONTROL_FLAG_IDLE_ENABLE = 2, 545 /* Tracker for the SPDIF-in path is bypassed/enabled */ 546 CONTROL_FLAG_TRACKER = 3, 547 /* DigitalOut to Spdif2Out connection is disabled/enabled */ 548 CONTROL_FLAG_SPDIF2OUT = 4, 549 /* Digital Microphone is disabled/enabled */ 550 CONTROL_FLAG_DMIC = 5, 551 /* ADC_B rate is 48 kHz/96 kHz */ 552 CONTROL_FLAG_ADC_B_96KHZ = 6, 553 /* ADC_C rate is 48 kHz/96 kHz */ 554 CONTROL_FLAG_ADC_C_96KHZ = 7, 555 /* DAC rate is 48 kHz/96 kHz (affects all DACs) */ 556 CONTROL_FLAG_DAC_96KHZ = 8, 557 /* DSP rate is 48 kHz/96 kHz */ 558 CONTROL_FLAG_DSP_96KHZ = 9, 559 /* SRC clock is 98 MHz/196 MHz (196 MHz forces rate to 96 KHz) */ 560 CONTROL_FLAG_SRC_CLOCK_196MHZ = 10, 561 /* SRC rate is 48 kHz/96 kHz (48 kHz disabled when clock is 196 MHz) */ 562 CONTROL_FLAG_SRC_RATE_96KHZ = 11, 563 /* Decode Loop (DSP->SRC->DSP) is disabled/enabled */ 564 CONTROL_FLAG_DECODE_LOOP = 12, 565 /* De-emphasis filter on DAC-1 disabled/enabled */ 566 CONTROL_FLAG_DAC1_DEEMPHASIS = 13, 567 /* De-emphasis filter on DAC-2 disabled/enabled */ 568 CONTROL_FLAG_DAC2_DEEMPHASIS = 14, 569 /* De-emphasis filter on DAC-3 disabled/enabled */ 570 CONTROL_FLAG_DAC3_DEEMPHASIS = 15, 571 /* High-pass filter on ADC_B disabled/enabled */ 572 CONTROL_FLAG_ADC_B_HIGH_PASS = 16, 573 /* High-pass filter on ADC_C disabled/enabled */ 574 CONTROL_FLAG_ADC_C_HIGH_PASS = 17, 575 /* Common mode on Port_A disabled/enabled */ 576 CONTROL_FLAG_PORT_A_COMMON_MODE = 18, 577 /* Common mode on Port_D disabled/enabled */ 578 CONTROL_FLAG_PORT_D_COMMON_MODE = 19, 579 /* Impedance for ramp generator on Port_A 16 Ohm/10K Ohm */ 580 CONTROL_FLAG_PORT_A_10KOHM_LOAD = 20, 581 /* Impedance for ramp generator on Port_D, 16 Ohm/10K Ohm */ 582 CONTROL_FLAG_PORT_D_10KOHM_LOAD = 21, 583 /* ASI rate is 48kHz/96kHz */ 584 CONTROL_FLAG_ASI_96KHZ = 22, 585 /* DAC power settings able to control attached ports no/yes */ 586 CONTROL_FLAG_DACS_CONTROL_PORTS = 23, 587 /* Clock Stop OK reporting is disabled/enabled */ 588 CONTROL_FLAG_CONTROL_STOP_OK_ENABLE = 24, 589 /* Number of control flags */ 590 CONTROL_FLAGS_MAX = (CONTROL_FLAG_CONTROL_STOP_OK_ENABLE+1) 591 }; 592 593 /* 594 * Control parameter IDs 595 */ 596 enum control_param_id { 597 /* 0: None, 1: Mic1In*/ 598 CONTROL_PARAM_VIP_SOURCE = 1, 599 /* 0: force HDA, 1: allow DSP if HDA Spdif1Out stream is idle */ 600 CONTROL_PARAM_SPDIF1_SOURCE = 2, 601 /* Port A output stage gain setting to use when 16 Ohm output 602 * impedance is selected*/ 603 CONTROL_PARAM_PORTA_160OHM_GAIN = 8, 604 /* Port D output stage gain setting to use when 16 Ohm output 605 * impedance is selected*/ 606 CONTROL_PARAM_PORTD_160OHM_GAIN = 10, 607 608 /* Stream Control */ 609 610 /* Select stream with the given ID */ 611 CONTROL_PARAM_STREAM_ID = 24, 612 /* Source connection point for the selected stream */ 613 CONTROL_PARAM_STREAM_SOURCE_CONN_POINT = 25, 614 /* Destination connection point for the selected stream */ 615 CONTROL_PARAM_STREAM_DEST_CONN_POINT = 26, 616 /* Number of audio channels in the selected stream */ 617 CONTROL_PARAM_STREAMS_CHANNELS = 27, 618 /*Enable control for the selected stream */ 619 CONTROL_PARAM_STREAM_CONTROL = 28, 620 621 /* Connection Point Control */ 622 623 /* Select connection point with the given ID */ 624 CONTROL_PARAM_CONN_POINT_ID = 29, 625 /* Connection point sample rate */ 626 CONTROL_PARAM_CONN_POINT_SAMPLE_RATE = 30, 627 628 /* Node Control */ 629 630 /* Select HDA node with the given ID */ 631 CONTROL_PARAM_NODE_ID = 31 632 }; 633 634 /* 635 * Dsp Io Status codes 636 */ 637 enum hda_vendor_status_dspio { 638 /* Success */ 639 VENDOR_STATUS_DSPIO_OK = 0x00, 640 /* Busy, unable to accept new command, the host must retry */ 641 VENDOR_STATUS_DSPIO_BUSY = 0x01, 642 /* SCP command queue is full */ 643 VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL = 0x02, 644 /* SCP response queue is empty */ 645 VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY = 0x03 646 }; 647 648 /* 649 * Chip Io Status codes 650 */ 651 enum hda_vendor_status_chipio { 652 /* Success */ 653 VENDOR_STATUS_CHIPIO_OK = 0x00, 654 /* Busy, unable to accept new command, the host must retry */ 655 VENDOR_STATUS_CHIPIO_BUSY = 0x01 656 }; 657 658 /* 659 * CA0132 sample rate 660 */ 661 enum ca0132_sample_rate { 662 SR_6_000 = 0x00, 663 SR_8_000 = 0x01, 664 SR_9_600 = 0x02, 665 SR_11_025 = 0x03, 666 SR_16_000 = 0x04, 667 SR_22_050 = 0x05, 668 SR_24_000 = 0x06, 669 SR_32_000 = 0x07, 670 SR_44_100 = 0x08, 671 SR_48_000 = 0x09, 672 SR_88_200 = 0x0A, 673 SR_96_000 = 0x0B, 674 SR_144_000 = 0x0C, 675 SR_176_400 = 0x0D, 676 SR_192_000 = 0x0E, 677 SR_384_000 = 0x0F, 678 679 SR_COUNT = 0x10, 680 681 SR_RATE_UNKNOWN = 0x1F 682 }; 683 684 enum dsp_download_state { 685 DSP_DOWNLOAD_FAILED = -1, 686 DSP_DOWNLOAD_INIT = 0, 687 DSP_DOWNLOADING = 1, 688 DSP_DOWNLOADED = 2 689 }; 690 691 /* retrieve parameters from hda format */ 692 #define get_hdafmt_chs(fmt) (fmt & 0xf) 693 #define get_hdafmt_bits(fmt) ((fmt >> 4) & 0x7) 694 #define get_hdafmt_rate(fmt) ((fmt >> 8) & 0x7f) 695 #define get_hdafmt_type(fmt) ((fmt >> 15) & 0x1) 696 697 /* 698 * CA0132 specific 699 */ 700 701 struct ca0132_spec { 702 struct snd_kcontrol_new *mixers[5]; 703 unsigned int num_mixers; 704 const struct hda_verb *base_init_verbs; 705 const struct hda_verb *base_exit_verbs; 706 const struct hda_verb *init_verbs[5]; 707 unsigned int num_init_verbs; /* exclude base init verbs */ 708 struct auto_pin_cfg autocfg; 709 710 /* Nodes configurations */ 711 struct hda_multi_out multiout; 712 hda_nid_t out_pins[AUTO_CFG_MAX_OUTS]; 713 hda_nid_t dacs[AUTO_CFG_MAX_OUTS]; 714 unsigned int num_outputs; 715 hda_nid_t input_pins[AUTO_PIN_LAST]; 716 hda_nid_t adcs[AUTO_PIN_LAST]; 717 hda_nid_t dig_out; 718 hda_nid_t dig_in; 719 unsigned int num_inputs; 720 hda_nid_t shared_mic_nid; 721 hda_nid_t shared_out_nid; 722 723 /* chip access */ 724 struct mutex chipio_mutex; /* chip access mutex */ 725 u32 curr_chip_addx; 726 727 /* DSP download related */ 728 enum dsp_download_state dsp_state; 729 unsigned int dsp_stream_id; 730 unsigned int wait_scp; 731 unsigned int wait_scp_header; 732 unsigned int wait_num_data; 733 unsigned int scp_resp_header; 734 unsigned int scp_resp_data[4]; 735 unsigned int scp_resp_count; 736 737 /* mixer and effects related */ 738 unsigned char dmic_ctl; 739 int cur_out_type; 740 int cur_mic_type; 741 long vnode_lvol[VNODES_COUNT]; 742 long vnode_rvol[VNODES_COUNT]; 743 long vnode_lswitch[VNODES_COUNT]; 744 long vnode_rswitch[VNODES_COUNT]; 745 long effects_switch[EFFECTS_COUNT]; 746 long voicefx_val; 747 long cur_mic_boost; 748 749 struct hda_codec *codec; 750 struct delayed_work unsol_hp_work; 751 752 #ifdef ENABLE_TUNING_CONTROLS 753 long cur_ctl_vals[TUNING_CTLS_COUNT]; 754 #endif 755 }; 756 757 /* 758 * CA0132 codec access 759 */ 760 static unsigned int codec_send_command(struct hda_codec *codec, hda_nid_t nid, 761 unsigned int verb, unsigned int parm, unsigned int *res) 762 { 763 unsigned int response; 764 response = snd_hda_codec_read(codec, nid, 0, verb, parm); 765 *res = response; 766 767 return ((response == -1) ? -1 : 0); 768 } 769 770 static int codec_set_converter_format(struct hda_codec *codec, hda_nid_t nid, 771 unsigned short converter_format, unsigned int *res) 772 { 773 return codec_send_command(codec, nid, VENDOR_CHIPIO_STREAM_FORMAT, 774 converter_format & 0xffff, res); 775 } 776 777 static int codec_set_converter_stream_channel(struct hda_codec *codec, 778 hda_nid_t nid, unsigned char stream, 779 unsigned char channel, unsigned int *res) 780 { 781 unsigned char converter_stream_channel = 0; 782 783 converter_stream_channel = (stream << 4) | (channel & 0x0f); 784 return codec_send_command(codec, nid, AC_VERB_SET_CHANNEL_STREAMID, 785 converter_stream_channel, res); 786 } 787 788 /* Chip access helper function */ 789 static int chipio_send(struct hda_codec *codec, 790 unsigned int reg, 791 unsigned int data) 792 { 793 unsigned int res; 794 unsigned long timeout = jiffies + msecs_to_jiffies(1000); 795 796 /* send bits of data specified by reg */ 797 do { 798 res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0, 799 reg, data); 800 if (res == VENDOR_STATUS_CHIPIO_OK) 801 return 0; 802 msleep(20); 803 } while (time_before(jiffies, timeout)); 804 805 return -EIO; 806 } 807 808 /* 809 * Write chip address through the vendor widget -- NOT protected by the Mutex! 810 */ 811 static int chipio_write_address(struct hda_codec *codec, 812 unsigned int chip_addx) 813 { 814 struct ca0132_spec *spec = codec->spec; 815 int res; 816 817 if (spec->curr_chip_addx == chip_addx) 818 return 0; 819 820 /* send low 16 bits of the address */ 821 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_LOW, 822 chip_addx & 0xffff); 823 824 if (res != -EIO) { 825 /* send high 16 bits of the address */ 826 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_HIGH, 827 chip_addx >> 16); 828 } 829 830 spec->curr_chip_addx = (res < 0) ? ~0UL : chip_addx; 831 832 return res; 833 } 834 835 /* 836 * Write data through the vendor widget -- NOT protected by the Mutex! 837 */ 838 static int chipio_write_data(struct hda_codec *codec, unsigned int data) 839 { 840 struct ca0132_spec *spec = codec->spec; 841 int res; 842 843 /* send low 16 bits of the data */ 844 res = chipio_send(codec, VENDOR_CHIPIO_DATA_LOW, data & 0xffff); 845 846 if (res != -EIO) { 847 /* send high 16 bits of the data */ 848 res = chipio_send(codec, VENDOR_CHIPIO_DATA_HIGH, 849 data >> 16); 850 } 851 852 /*If no error encountered, automatically increment the address 853 as per chip behaviour*/ 854 spec->curr_chip_addx = (res != -EIO) ? 855 (spec->curr_chip_addx + 4) : ~0UL; 856 return res; 857 } 858 859 /* 860 * Write multiple data through the vendor widget -- NOT protected by the Mutex! 861 */ 862 static int chipio_write_data_multiple(struct hda_codec *codec, 863 const u32 *data, 864 unsigned int count) 865 { 866 int status = 0; 867 868 if (data == NULL) { 869 codec_dbg(codec, "chipio_write_data null ptr\n"); 870 return -EINVAL; 871 } 872 873 while ((count-- != 0) && (status == 0)) 874 status = chipio_write_data(codec, *data++); 875 876 return status; 877 } 878 879 880 /* 881 * Read data through the vendor widget -- NOT protected by the Mutex! 882 */ 883 static int chipio_read_data(struct hda_codec *codec, unsigned int *data) 884 { 885 struct ca0132_spec *spec = codec->spec; 886 int res; 887 888 /* post read */ 889 res = chipio_send(codec, VENDOR_CHIPIO_HIC_POST_READ, 0); 890 891 if (res != -EIO) { 892 /* read status */ 893 res = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0); 894 } 895 896 if (res != -EIO) { 897 /* read data */ 898 *data = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0, 899 VENDOR_CHIPIO_HIC_READ_DATA, 900 0); 901 } 902 903 /*If no error encountered, automatically increment the address 904 as per chip behaviour*/ 905 spec->curr_chip_addx = (res != -EIO) ? 906 (spec->curr_chip_addx + 4) : ~0UL; 907 return res; 908 } 909 910 /* 911 * Write given value to the given address through the chip I/O widget. 912 * protected by the Mutex 913 */ 914 static int chipio_write(struct hda_codec *codec, 915 unsigned int chip_addx, const unsigned int data) 916 { 917 struct ca0132_spec *spec = codec->spec; 918 int err; 919 920 mutex_lock(&spec->chipio_mutex); 921 922 /* write the address, and if successful proceed to write data */ 923 err = chipio_write_address(codec, chip_addx); 924 if (err < 0) 925 goto exit; 926 927 err = chipio_write_data(codec, data); 928 if (err < 0) 929 goto exit; 930 931 exit: 932 mutex_unlock(&spec->chipio_mutex); 933 return err; 934 } 935 936 /* 937 * Write multiple values to the given address through the chip I/O widget. 938 * protected by the Mutex 939 */ 940 static int chipio_write_multiple(struct hda_codec *codec, 941 u32 chip_addx, 942 const u32 *data, 943 unsigned int count) 944 { 945 struct ca0132_spec *spec = codec->spec; 946 int status; 947 948 mutex_lock(&spec->chipio_mutex); 949 status = chipio_write_address(codec, chip_addx); 950 if (status < 0) 951 goto error; 952 953 status = chipio_write_data_multiple(codec, data, count); 954 error: 955 mutex_unlock(&spec->chipio_mutex); 956 957 return status; 958 } 959 960 /* 961 * Read the given address through the chip I/O widget 962 * protected by the Mutex 963 */ 964 static int chipio_read(struct hda_codec *codec, 965 unsigned int chip_addx, unsigned int *data) 966 { 967 struct ca0132_spec *spec = codec->spec; 968 int err; 969 970 mutex_lock(&spec->chipio_mutex); 971 972 /* write the address, and if successful proceed to write data */ 973 err = chipio_write_address(codec, chip_addx); 974 if (err < 0) 975 goto exit; 976 977 err = chipio_read_data(codec, data); 978 if (err < 0) 979 goto exit; 980 981 exit: 982 mutex_unlock(&spec->chipio_mutex); 983 return err; 984 } 985 986 /* 987 * Set chip control flags through the chip I/O widget. 988 */ 989 static void chipio_set_control_flag(struct hda_codec *codec, 990 enum control_flag_id flag_id, 991 bool flag_state) 992 { 993 unsigned int val; 994 unsigned int flag_bit; 995 996 flag_bit = (flag_state ? 1 : 0); 997 val = (flag_bit << 7) | (flag_id); 998 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 999 VENDOR_CHIPIO_FLAG_SET, val); 1000 } 1001 1002 /* 1003 * Set chip parameters through the chip I/O widget. 1004 */ 1005 static void chipio_set_control_param(struct hda_codec *codec, 1006 enum control_param_id param_id, int param_val) 1007 { 1008 struct ca0132_spec *spec = codec->spec; 1009 int val; 1010 1011 if ((param_id < 32) && (param_val < 8)) { 1012 val = (param_val << 5) | (param_id); 1013 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1014 VENDOR_CHIPIO_PARAM_SET, val); 1015 } else { 1016 mutex_lock(&spec->chipio_mutex); 1017 if (chipio_send(codec, VENDOR_CHIPIO_STATUS, 0) == 0) { 1018 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1019 VENDOR_CHIPIO_PARAM_EX_ID_SET, 1020 param_id); 1021 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1022 VENDOR_CHIPIO_PARAM_EX_VALUE_SET, 1023 param_val); 1024 } 1025 mutex_unlock(&spec->chipio_mutex); 1026 } 1027 } 1028 1029 /* 1030 * Set sampling rate of the connection point. 1031 */ 1032 static void chipio_set_conn_rate(struct hda_codec *codec, 1033 int connid, enum ca0132_sample_rate rate) 1034 { 1035 chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_ID, connid); 1036 chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_SAMPLE_RATE, 1037 rate); 1038 } 1039 1040 /* 1041 * Enable clocks. 1042 */ 1043 static void chipio_enable_clocks(struct hda_codec *codec) 1044 { 1045 struct ca0132_spec *spec = codec->spec; 1046 1047 mutex_lock(&spec->chipio_mutex); 1048 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1049 VENDOR_CHIPIO_8051_ADDRESS_LOW, 0); 1050 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1051 VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff); 1052 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1053 VENDOR_CHIPIO_8051_ADDRESS_LOW, 5); 1054 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1055 VENDOR_CHIPIO_PLL_PMU_WRITE, 0x0b); 1056 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1057 VENDOR_CHIPIO_8051_ADDRESS_LOW, 6); 1058 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1059 VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff); 1060 mutex_unlock(&spec->chipio_mutex); 1061 } 1062 1063 /* 1064 * CA0132 DSP IO stuffs 1065 */ 1066 static int dspio_send(struct hda_codec *codec, unsigned int reg, 1067 unsigned int data) 1068 { 1069 int res; 1070 unsigned long timeout = jiffies + msecs_to_jiffies(1000); 1071 1072 /* send bits of data specified by reg to dsp */ 1073 do { 1074 res = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, reg, data); 1075 if ((res >= 0) && (res != VENDOR_STATUS_DSPIO_BUSY)) 1076 return res; 1077 msleep(20); 1078 } while (time_before(jiffies, timeout)); 1079 1080 return -EIO; 1081 } 1082 1083 /* 1084 * Wait for DSP to be ready for commands 1085 */ 1086 static void dspio_write_wait(struct hda_codec *codec) 1087 { 1088 int status; 1089 unsigned long timeout = jiffies + msecs_to_jiffies(1000); 1090 1091 do { 1092 status = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, 1093 VENDOR_DSPIO_STATUS, 0); 1094 if ((status == VENDOR_STATUS_DSPIO_OK) || 1095 (status == VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY)) 1096 break; 1097 msleep(1); 1098 } while (time_before(jiffies, timeout)); 1099 } 1100 1101 /* 1102 * Write SCP data to DSP 1103 */ 1104 static int dspio_write(struct hda_codec *codec, unsigned int scp_data) 1105 { 1106 struct ca0132_spec *spec = codec->spec; 1107 int status; 1108 1109 dspio_write_wait(codec); 1110 1111 mutex_lock(&spec->chipio_mutex); 1112 status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_LOW, 1113 scp_data & 0xffff); 1114 if (status < 0) 1115 goto error; 1116 1117 status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_HIGH, 1118 scp_data >> 16); 1119 if (status < 0) 1120 goto error; 1121 1122 /* OK, now check if the write itself has executed*/ 1123 status = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, 1124 VENDOR_DSPIO_STATUS, 0); 1125 error: 1126 mutex_unlock(&spec->chipio_mutex); 1127 1128 return (status == VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL) ? 1129 -EIO : 0; 1130 } 1131 1132 /* 1133 * Write multiple SCP data to DSP 1134 */ 1135 static int dspio_write_multiple(struct hda_codec *codec, 1136 unsigned int *buffer, unsigned int size) 1137 { 1138 int status = 0; 1139 unsigned int count; 1140 1141 if ((buffer == NULL)) 1142 return -EINVAL; 1143 1144 count = 0; 1145 while (count < size) { 1146 status = dspio_write(codec, *buffer++); 1147 if (status != 0) 1148 break; 1149 count++; 1150 } 1151 1152 return status; 1153 } 1154 1155 static int dspio_read(struct hda_codec *codec, unsigned int *data) 1156 { 1157 int status; 1158 1159 status = dspio_send(codec, VENDOR_DSPIO_SCP_POST_READ_DATA, 0); 1160 if (status == -EIO) 1161 return status; 1162 1163 status = dspio_send(codec, VENDOR_DSPIO_STATUS, 0); 1164 if (status == -EIO || 1165 status == VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY) 1166 return -EIO; 1167 1168 *data = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, 1169 VENDOR_DSPIO_SCP_READ_DATA, 0); 1170 1171 return 0; 1172 } 1173 1174 static int dspio_read_multiple(struct hda_codec *codec, unsigned int *buffer, 1175 unsigned int *buf_size, unsigned int size_count) 1176 { 1177 int status = 0; 1178 unsigned int size = *buf_size; 1179 unsigned int count; 1180 unsigned int skip_count; 1181 unsigned int dummy; 1182 1183 if ((buffer == NULL)) 1184 return -1; 1185 1186 count = 0; 1187 while (count < size && count < size_count) { 1188 status = dspio_read(codec, buffer++); 1189 if (status != 0) 1190 break; 1191 count++; 1192 } 1193 1194 skip_count = count; 1195 if (status == 0) { 1196 while (skip_count < size) { 1197 status = dspio_read(codec, &dummy); 1198 if (status != 0) 1199 break; 1200 skip_count++; 1201 } 1202 } 1203 *buf_size = count; 1204 1205 return status; 1206 } 1207 1208 /* 1209 * Construct the SCP header using corresponding fields 1210 */ 1211 static inline unsigned int 1212 make_scp_header(unsigned int target_id, unsigned int source_id, 1213 unsigned int get_flag, unsigned int req, 1214 unsigned int device_flag, unsigned int resp_flag, 1215 unsigned int error_flag, unsigned int data_size) 1216 { 1217 unsigned int header = 0; 1218 1219 header = (data_size & 0x1f) << 27; 1220 header |= (error_flag & 0x01) << 26; 1221 header |= (resp_flag & 0x01) << 25; 1222 header |= (device_flag & 0x01) << 24; 1223 header |= (req & 0x7f) << 17; 1224 header |= (get_flag & 0x01) << 16; 1225 header |= (source_id & 0xff) << 8; 1226 header |= target_id & 0xff; 1227 1228 return header; 1229 } 1230 1231 /* 1232 * Extract corresponding fields from SCP header 1233 */ 1234 static inline void 1235 extract_scp_header(unsigned int header, 1236 unsigned int *target_id, unsigned int *source_id, 1237 unsigned int *get_flag, unsigned int *req, 1238 unsigned int *device_flag, unsigned int *resp_flag, 1239 unsigned int *error_flag, unsigned int *data_size) 1240 { 1241 if (data_size) 1242 *data_size = (header >> 27) & 0x1f; 1243 if (error_flag) 1244 *error_flag = (header >> 26) & 0x01; 1245 if (resp_flag) 1246 *resp_flag = (header >> 25) & 0x01; 1247 if (device_flag) 1248 *device_flag = (header >> 24) & 0x01; 1249 if (req) 1250 *req = (header >> 17) & 0x7f; 1251 if (get_flag) 1252 *get_flag = (header >> 16) & 0x01; 1253 if (source_id) 1254 *source_id = (header >> 8) & 0xff; 1255 if (target_id) 1256 *target_id = header & 0xff; 1257 } 1258 1259 #define SCP_MAX_DATA_WORDS (16) 1260 1261 /* Structure to contain any SCP message */ 1262 struct scp_msg { 1263 unsigned int hdr; 1264 unsigned int data[SCP_MAX_DATA_WORDS]; 1265 }; 1266 1267 static void dspio_clear_response_queue(struct hda_codec *codec) 1268 { 1269 unsigned int dummy = 0; 1270 int status = -1; 1271 1272 /* clear all from the response queue */ 1273 do { 1274 status = dspio_read(codec, &dummy); 1275 } while (status == 0); 1276 } 1277 1278 static int dspio_get_response_data(struct hda_codec *codec) 1279 { 1280 struct ca0132_spec *spec = codec->spec; 1281 unsigned int data = 0; 1282 unsigned int count; 1283 1284 if (dspio_read(codec, &data) < 0) 1285 return -EIO; 1286 1287 if ((data & 0x00ffffff) == spec->wait_scp_header) { 1288 spec->scp_resp_header = data; 1289 spec->scp_resp_count = data >> 27; 1290 count = spec->wait_num_data; 1291 dspio_read_multiple(codec, spec->scp_resp_data, 1292 &spec->scp_resp_count, count); 1293 return 0; 1294 } 1295 1296 return -EIO; 1297 } 1298 1299 /* 1300 * Send SCP message to DSP 1301 */ 1302 static int dspio_send_scp_message(struct hda_codec *codec, 1303 unsigned char *send_buf, 1304 unsigned int send_buf_size, 1305 unsigned char *return_buf, 1306 unsigned int return_buf_size, 1307 unsigned int *bytes_returned) 1308 { 1309 struct ca0132_spec *spec = codec->spec; 1310 int status = -1; 1311 unsigned int scp_send_size = 0; 1312 unsigned int total_size; 1313 bool waiting_for_resp = false; 1314 unsigned int header; 1315 struct scp_msg *ret_msg; 1316 unsigned int resp_src_id, resp_target_id; 1317 unsigned int data_size, src_id, target_id, get_flag, device_flag; 1318 1319 if (bytes_returned) 1320 *bytes_returned = 0; 1321 1322 /* get scp header from buffer */ 1323 header = *((unsigned int *)send_buf); 1324 extract_scp_header(header, &target_id, &src_id, &get_flag, NULL, 1325 &device_flag, NULL, NULL, &data_size); 1326 scp_send_size = data_size + 1; 1327 total_size = (scp_send_size * 4); 1328 1329 if (send_buf_size < total_size) 1330 return -EINVAL; 1331 1332 if (get_flag || device_flag) { 1333 if (!return_buf || return_buf_size < 4 || !bytes_returned) 1334 return -EINVAL; 1335 1336 spec->wait_scp_header = *((unsigned int *)send_buf); 1337 1338 /* swap source id with target id */ 1339 resp_target_id = src_id; 1340 resp_src_id = target_id; 1341 spec->wait_scp_header &= 0xffff0000; 1342 spec->wait_scp_header |= (resp_src_id << 8) | (resp_target_id); 1343 spec->wait_num_data = return_buf_size/sizeof(unsigned int) - 1; 1344 spec->wait_scp = 1; 1345 waiting_for_resp = true; 1346 } 1347 1348 status = dspio_write_multiple(codec, (unsigned int *)send_buf, 1349 scp_send_size); 1350 if (status < 0) { 1351 spec->wait_scp = 0; 1352 return status; 1353 } 1354 1355 if (waiting_for_resp) { 1356 unsigned long timeout = jiffies + msecs_to_jiffies(1000); 1357 memset(return_buf, 0, return_buf_size); 1358 do { 1359 msleep(20); 1360 } while (spec->wait_scp && time_before(jiffies, timeout)); 1361 waiting_for_resp = false; 1362 if (!spec->wait_scp) { 1363 ret_msg = (struct scp_msg *)return_buf; 1364 memcpy(&ret_msg->hdr, &spec->scp_resp_header, 4); 1365 memcpy(&ret_msg->data, spec->scp_resp_data, 1366 spec->wait_num_data); 1367 *bytes_returned = (spec->scp_resp_count + 1) * 4; 1368 status = 0; 1369 } else { 1370 status = -EIO; 1371 } 1372 spec->wait_scp = 0; 1373 } 1374 1375 return status; 1376 } 1377 1378 /** 1379 * Prepare and send the SCP message to DSP 1380 * @codec: the HDA codec 1381 * @mod_id: ID of the DSP module to send the command 1382 * @req: ID of request to send to the DSP module 1383 * @dir: SET or GET 1384 * @data: pointer to the data to send with the request, request specific 1385 * @len: length of the data, in bytes 1386 * @reply: point to the buffer to hold data returned for a reply 1387 * @reply_len: length of the reply buffer returned from GET 1388 * 1389 * Returns zero or a negative error code. 1390 */ 1391 static int dspio_scp(struct hda_codec *codec, 1392 int mod_id, int req, int dir, void *data, unsigned int len, 1393 void *reply, unsigned int *reply_len) 1394 { 1395 int status = 0; 1396 struct scp_msg scp_send, scp_reply; 1397 unsigned int ret_bytes, send_size, ret_size; 1398 unsigned int send_get_flag, reply_resp_flag, reply_error_flag; 1399 unsigned int reply_data_size; 1400 1401 memset(&scp_send, 0, sizeof(scp_send)); 1402 memset(&scp_reply, 0, sizeof(scp_reply)); 1403 1404 if ((len != 0 && data == NULL) || (len > SCP_MAX_DATA_WORDS)) 1405 return -EINVAL; 1406 1407 if (dir == SCP_GET && reply == NULL) { 1408 codec_dbg(codec, "dspio_scp get but has no buffer\n"); 1409 return -EINVAL; 1410 } 1411 1412 if (reply != NULL && (reply_len == NULL || (*reply_len == 0))) { 1413 codec_dbg(codec, "dspio_scp bad resp buf len parms\n"); 1414 return -EINVAL; 1415 } 1416 1417 scp_send.hdr = make_scp_header(mod_id, 0x20, (dir == SCP_GET), req, 1418 0, 0, 0, len/sizeof(unsigned int)); 1419 if (data != NULL && len > 0) { 1420 len = min((unsigned int)(sizeof(scp_send.data)), len); 1421 memcpy(scp_send.data, data, len); 1422 } 1423 1424 ret_bytes = 0; 1425 send_size = sizeof(unsigned int) + len; 1426 status = dspio_send_scp_message(codec, (unsigned char *)&scp_send, 1427 send_size, (unsigned char *)&scp_reply, 1428 sizeof(scp_reply), &ret_bytes); 1429 1430 if (status < 0) { 1431 codec_dbg(codec, "dspio_scp: send scp msg failed\n"); 1432 return status; 1433 } 1434 1435 /* extract send and reply headers members */ 1436 extract_scp_header(scp_send.hdr, NULL, NULL, &send_get_flag, 1437 NULL, NULL, NULL, NULL, NULL); 1438 extract_scp_header(scp_reply.hdr, NULL, NULL, NULL, NULL, NULL, 1439 &reply_resp_flag, &reply_error_flag, 1440 &reply_data_size); 1441 1442 if (!send_get_flag) 1443 return 0; 1444 1445 if (reply_resp_flag && !reply_error_flag) { 1446 ret_size = (ret_bytes - sizeof(scp_reply.hdr)) 1447 / sizeof(unsigned int); 1448 1449 if (*reply_len < ret_size*sizeof(unsigned int)) { 1450 codec_dbg(codec, "reply too long for buf\n"); 1451 return -EINVAL; 1452 } else if (ret_size != reply_data_size) { 1453 codec_dbg(codec, "RetLen and HdrLen .NE.\n"); 1454 return -EINVAL; 1455 } else { 1456 *reply_len = ret_size*sizeof(unsigned int); 1457 memcpy(reply, scp_reply.data, *reply_len); 1458 } 1459 } else { 1460 codec_dbg(codec, "reply ill-formed or errflag set\n"); 1461 return -EIO; 1462 } 1463 1464 return status; 1465 } 1466 1467 /* 1468 * Set DSP parameters 1469 */ 1470 static int dspio_set_param(struct hda_codec *codec, int mod_id, 1471 int req, void *data, unsigned int len) 1472 { 1473 return dspio_scp(codec, mod_id, req, SCP_SET, data, len, NULL, NULL); 1474 } 1475 1476 static int dspio_set_uint_param(struct hda_codec *codec, int mod_id, 1477 int req, unsigned int data) 1478 { 1479 return dspio_set_param(codec, mod_id, req, &data, sizeof(unsigned int)); 1480 } 1481 1482 /* 1483 * Allocate a DSP DMA channel via an SCP message 1484 */ 1485 static int dspio_alloc_dma_chan(struct hda_codec *codec, unsigned int *dma_chan) 1486 { 1487 int status = 0; 1488 unsigned int size = sizeof(dma_chan); 1489 1490 codec_dbg(codec, " dspio_alloc_dma_chan() -- begin\n"); 1491 status = dspio_scp(codec, MASTERCONTROL, MASTERCONTROL_ALLOC_DMA_CHAN, 1492 SCP_GET, NULL, 0, dma_chan, &size); 1493 1494 if (status < 0) { 1495 codec_dbg(codec, "dspio_alloc_dma_chan: SCP Failed\n"); 1496 return status; 1497 } 1498 1499 if ((*dma_chan + 1) == 0) { 1500 codec_dbg(codec, "no free dma channels to allocate\n"); 1501 return -EBUSY; 1502 } 1503 1504 codec_dbg(codec, "dspio_alloc_dma_chan: chan=%d\n", *dma_chan); 1505 codec_dbg(codec, " dspio_alloc_dma_chan() -- complete\n"); 1506 1507 return status; 1508 } 1509 1510 /* 1511 * Free a DSP DMA via an SCP message 1512 */ 1513 static int dspio_free_dma_chan(struct hda_codec *codec, unsigned int dma_chan) 1514 { 1515 int status = 0; 1516 unsigned int dummy = 0; 1517 1518 codec_dbg(codec, " dspio_free_dma_chan() -- begin\n"); 1519 codec_dbg(codec, "dspio_free_dma_chan: chan=%d\n", dma_chan); 1520 1521 status = dspio_scp(codec, MASTERCONTROL, MASTERCONTROL_ALLOC_DMA_CHAN, 1522 SCP_SET, &dma_chan, sizeof(dma_chan), NULL, &dummy); 1523 1524 if (status < 0) { 1525 codec_dbg(codec, "dspio_free_dma_chan: SCP Failed\n"); 1526 return status; 1527 } 1528 1529 codec_dbg(codec, " dspio_free_dma_chan() -- complete\n"); 1530 1531 return status; 1532 } 1533 1534 /* 1535 * (Re)start the DSP 1536 */ 1537 static int dsp_set_run_state(struct hda_codec *codec) 1538 { 1539 unsigned int dbg_ctrl_reg; 1540 unsigned int halt_state; 1541 int err; 1542 1543 err = chipio_read(codec, DSP_DBGCNTL_INST_OFFSET, &dbg_ctrl_reg); 1544 if (err < 0) 1545 return err; 1546 1547 halt_state = (dbg_ctrl_reg & DSP_DBGCNTL_STATE_MASK) >> 1548 DSP_DBGCNTL_STATE_LOBIT; 1549 1550 if (halt_state != 0) { 1551 dbg_ctrl_reg &= ~((halt_state << DSP_DBGCNTL_SS_LOBIT) & 1552 DSP_DBGCNTL_SS_MASK); 1553 err = chipio_write(codec, DSP_DBGCNTL_INST_OFFSET, 1554 dbg_ctrl_reg); 1555 if (err < 0) 1556 return err; 1557 1558 dbg_ctrl_reg |= (halt_state << DSP_DBGCNTL_EXEC_LOBIT) & 1559 DSP_DBGCNTL_EXEC_MASK; 1560 err = chipio_write(codec, DSP_DBGCNTL_INST_OFFSET, 1561 dbg_ctrl_reg); 1562 if (err < 0) 1563 return err; 1564 } 1565 1566 return 0; 1567 } 1568 1569 /* 1570 * Reset the DSP 1571 */ 1572 static int dsp_reset(struct hda_codec *codec) 1573 { 1574 unsigned int res; 1575 int retry = 20; 1576 1577 codec_dbg(codec, "dsp_reset\n"); 1578 do { 1579 res = dspio_send(codec, VENDOR_DSPIO_DSP_INIT, 0); 1580 retry--; 1581 } while (res == -EIO && retry); 1582 1583 if (!retry) { 1584 codec_dbg(codec, "dsp_reset timeout\n"); 1585 return -EIO; 1586 } 1587 1588 return 0; 1589 } 1590 1591 /* 1592 * Convert chip address to DSP address 1593 */ 1594 static unsigned int dsp_chip_to_dsp_addx(unsigned int chip_addx, 1595 bool *code, bool *yram) 1596 { 1597 *code = *yram = false; 1598 1599 if (UC_RANGE(chip_addx, 1)) { 1600 *code = true; 1601 return UC_OFF(chip_addx); 1602 } else if (X_RANGE_ALL(chip_addx, 1)) { 1603 return X_OFF(chip_addx); 1604 } else if (Y_RANGE_ALL(chip_addx, 1)) { 1605 *yram = true; 1606 return Y_OFF(chip_addx); 1607 } 1608 1609 return INVALID_CHIP_ADDRESS; 1610 } 1611 1612 /* 1613 * Check if the DSP DMA is active 1614 */ 1615 static bool dsp_is_dma_active(struct hda_codec *codec, unsigned int dma_chan) 1616 { 1617 unsigned int dma_chnlstart_reg; 1618 1619 chipio_read(codec, DSPDMAC_CHNLSTART_INST_OFFSET, &dma_chnlstart_reg); 1620 1621 return ((dma_chnlstart_reg & (1 << 1622 (DSPDMAC_CHNLSTART_EN_LOBIT + dma_chan))) != 0); 1623 } 1624 1625 static int dsp_dma_setup_common(struct hda_codec *codec, 1626 unsigned int chip_addx, 1627 unsigned int dma_chan, 1628 unsigned int port_map_mask, 1629 bool ovly) 1630 { 1631 int status = 0; 1632 unsigned int chnl_prop; 1633 unsigned int dsp_addx; 1634 unsigned int active; 1635 bool code, yram; 1636 1637 codec_dbg(codec, "-- dsp_dma_setup_common() -- Begin ---------\n"); 1638 1639 if (dma_chan >= DSPDMAC_DMA_CFG_CHANNEL_COUNT) { 1640 codec_dbg(codec, "dma chan num invalid\n"); 1641 return -EINVAL; 1642 } 1643 1644 if (dsp_is_dma_active(codec, dma_chan)) { 1645 codec_dbg(codec, "dma already active\n"); 1646 return -EBUSY; 1647 } 1648 1649 dsp_addx = dsp_chip_to_dsp_addx(chip_addx, &code, &yram); 1650 1651 if (dsp_addx == INVALID_CHIP_ADDRESS) { 1652 codec_dbg(codec, "invalid chip addr\n"); 1653 return -ENXIO; 1654 } 1655 1656 chnl_prop = DSPDMAC_CHNLPROP_AC_MASK; 1657 active = 0; 1658 1659 codec_dbg(codec, " dsp_dma_setup_common() start reg pgm\n"); 1660 1661 if (ovly) { 1662 status = chipio_read(codec, DSPDMAC_CHNLPROP_INST_OFFSET, 1663 &chnl_prop); 1664 1665 if (status < 0) { 1666 codec_dbg(codec, "read CHNLPROP Reg fail\n"); 1667 return status; 1668 } 1669 codec_dbg(codec, "dsp_dma_setup_common() Read CHNLPROP\n"); 1670 } 1671 1672 if (!code) 1673 chnl_prop &= ~(1 << (DSPDMAC_CHNLPROP_MSPCE_LOBIT + dma_chan)); 1674 else 1675 chnl_prop |= (1 << (DSPDMAC_CHNLPROP_MSPCE_LOBIT + dma_chan)); 1676 1677 chnl_prop &= ~(1 << (DSPDMAC_CHNLPROP_DCON_LOBIT + dma_chan)); 1678 1679 status = chipio_write(codec, DSPDMAC_CHNLPROP_INST_OFFSET, chnl_prop); 1680 if (status < 0) { 1681 codec_dbg(codec, "write CHNLPROP Reg fail\n"); 1682 return status; 1683 } 1684 codec_dbg(codec, " dsp_dma_setup_common() Write CHNLPROP\n"); 1685 1686 if (ovly) { 1687 status = chipio_read(codec, DSPDMAC_ACTIVE_INST_OFFSET, 1688 &active); 1689 1690 if (status < 0) { 1691 codec_dbg(codec, "read ACTIVE Reg fail\n"); 1692 return status; 1693 } 1694 codec_dbg(codec, "dsp_dma_setup_common() Read ACTIVE\n"); 1695 } 1696 1697 active &= (~(1 << (DSPDMAC_ACTIVE_AAR_LOBIT + dma_chan))) & 1698 DSPDMAC_ACTIVE_AAR_MASK; 1699 1700 status = chipio_write(codec, DSPDMAC_ACTIVE_INST_OFFSET, active); 1701 if (status < 0) { 1702 codec_dbg(codec, "write ACTIVE Reg fail\n"); 1703 return status; 1704 } 1705 1706 codec_dbg(codec, " dsp_dma_setup_common() Write ACTIVE\n"); 1707 1708 status = chipio_write(codec, DSPDMAC_AUDCHSEL_INST_OFFSET(dma_chan), 1709 port_map_mask); 1710 if (status < 0) { 1711 codec_dbg(codec, "write AUDCHSEL Reg fail\n"); 1712 return status; 1713 } 1714 codec_dbg(codec, " dsp_dma_setup_common() Write AUDCHSEL\n"); 1715 1716 status = chipio_write(codec, DSPDMAC_IRQCNT_INST_OFFSET(dma_chan), 1717 DSPDMAC_IRQCNT_BICNT_MASK | DSPDMAC_IRQCNT_CICNT_MASK); 1718 if (status < 0) { 1719 codec_dbg(codec, "write IRQCNT Reg fail\n"); 1720 return status; 1721 } 1722 codec_dbg(codec, " dsp_dma_setup_common() Write IRQCNT\n"); 1723 1724 codec_dbg(codec, 1725 "ChipA=0x%x,DspA=0x%x,dmaCh=%u, " 1726 "CHSEL=0x%x,CHPROP=0x%x,Active=0x%x\n", 1727 chip_addx, dsp_addx, dma_chan, 1728 port_map_mask, chnl_prop, active); 1729 1730 codec_dbg(codec, "-- dsp_dma_setup_common() -- Complete ------\n"); 1731 1732 return 0; 1733 } 1734 1735 /* 1736 * Setup the DSP DMA per-transfer-specific registers 1737 */ 1738 static int dsp_dma_setup(struct hda_codec *codec, 1739 unsigned int chip_addx, 1740 unsigned int count, 1741 unsigned int dma_chan) 1742 { 1743 int status = 0; 1744 bool code, yram; 1745 unsigned int dsp_addx; 1746 unsigned int addr_field; 1747 unsigned int incr_field; 1748 unsigned int base_cnt; 1749 unsigned int cur_cnt; 1750 unsigned int dma_cfg = 0; 1751 unsigned int adr_ofs = 0; 1752 unsigned int xfr_cnt = 0; 1753 const unsigned int max_dma_count = 1 << (DSPDMAC_XFRCNT_BCNT_HIBIT - 1754 DSPDMAC_XFRCNT_BCNT_LOBIT + 1); 1755 1756 codec_dbg(codec, "-- dsp_dma_setup() -- Begin ---------\n"); 1757 1758 if (count > max_dma_count) { 1759 codec_dbg(codec, "count too big\n"); 1760 return -EINVAL; 1761 } 1762 1763 dsp_addx = dsp_chip_to_dsp_addx(chip_addx, &code, &yram); 1764 if (dsp_addx == INVALID_CHIP_ADDRESS) { 1765 codec_dbg(codec, "invalid chip addr\n"); 1766 return -ENXIO; 1767 } 1768 1769 codec_dbg(codec, " dsp_dma_setup() start reg pgm\n"); 1770 1771 addr_field = dsp_addx << DSPDMAC_DMACFG_DBADR_LOBIT; 1772 incr_field = 0; 1773 1774 if (!code) { 1775 addr_field <<= 1; 1776 if (yram) 1777 addr_field |= (1 << DSPDMAC_DMACFG_DBADR_LOBIT); 1778 1779 incr_field = (1 << DSPDMAC_DMACFG_AINCR_LOBIT); 1780 } 1781 1782 dma_cfg = addr_field + incr_field; 1783 status = chipio_write(codec, DSPDMAC_DMACFG_INST_OFFSET(dma_chan), 1784 dma_cfg); 1785 if (status < 0) { 1786 codec_dbg(codec, "write DMACFG Reg fail\n"); 1787 return status; 1788 } 1789 codec_dbg(codec, " dsp_dma_setup() Write DMACFG\n"); 1790 1791 adr_ofs = (count - 1) << (DSPDMAC_DSPADROFS_BOFS_LOBIT + 1792 (code ? 0 : 1)); 1793 1794 status = chipio_write(codec, DSPDMAC_DSPADROFS_INST_OFFSET(dma_chan), 1795 adr_ofs); 1796 if (status < 0) { 1797 codec_dbg(codec, "write DSPADROFS Reg fail\n"); 1798 return status; 1799 } 1800 codec_dbg(codec, " dsp_dma_setup() Write DSPADROFS\n"); 1801 1802 base_cnt = (count - 1) << DSPDMAC_XFRCNT_BCNT_LOBIT; 1803 1804 cur_cnt = (count - 1) << DSPDMAC_XFRCNT_CCNT_LOBIT; 1805 1806 xfr_cnt = base_cnt | cur_cnt; 1807 1808 status = chipio_write(codec, 1809 DSPDMAC_XFRCNT_INST_OFFSET(dma_chan), xfr_cnt); 1810 if (status < 0) { 1811 codec_dbg(codec, "write XFRCNT Reg fail\n"); 1812 return status; 1813 } 1814 codec_dbg(codec, " dsp_dma_setup() Write XFRCNT\n"); 1815 1816 codec_dbg(codec, 1817 "ChipA=0x%x, cnt=0x%x, DMACFG=0x%x, " 1818 "ADROFS=0x%x, XFRCNT=0x%x\n", 1819 chip_addx, count, dma_cfg, adr_ofs, xfr_cnt); 1820 1821 codec_dbg(codec, "-- dsp_dma_setup() -- Complete ---------\n"); 1822 1823 return 0; 1824 } 1825 1826 /* 1827 * Start the DSP DMA 1828 */ 1829 static int dsp_dma_start(struct hda_codec *codec, 1830 unsigned int dma_chan, bool ovly) 1831 { 1832 unsigned int reg = 0; 1833 int status = 0; 1834 1835 codec_dbg(codec, "-- dsp_dma_start() -- Begin ---------\n"); 1836 1837 if (ovly) { 1838 status = chipio_read(codec, 1839 DSPDMAC_CHNLSTART_INST_OFFSET, ®); 1840 1841 if (status < 0) { 1842 codec_dbg(codec, "read CHNLSTART reg fail\n"); 1843 return status; 1844 } 1845 codec_dbg(codec, "-- dsp_dma_start() Read CHNLSTART\n"); 1846 1847 reg &= ~(DSPDMAC_CHNLSTART_EN_MASK | 1848 DSPDMAC_CHNLSTART_DIS_MASK); 1849 } 1850 1851 status = chipio_write(codec, DSPDMAC_CHNLSTART_INST_OFFSET, 1852 reg | (1 << (dma_chan + DSPDMAC_CHNLSTART_EN_LOBIT))); 1853 if (status < 0) { 1854 codec_dbg(codec, "write CHNLSTART reg fail\n"); 1855 return status; 1856 } 1857 codec_dbg(codec, "-- dsp_dma_start() -- Complete ---------\n"); 1858 1859 return status; 1860 } 1861 1862 /* 1863 * Stop the DSP DMA 1864 */ 1865 static int dsp_dma_stop(struct hda_codec *codec, 1866 unsigned int dma_chan, bool ovly) 1867 { 1868 unsigned int reg = 0; 1869 int status = 0; 1870 1871 codec_dbg(codec, "-- dsp_dma_stop() -- Begin ---------\n"); 1872 1873 if (ovly) { 1874 status = chipio_read(codec, 1875 DSPDMAC_CHNLSTART_INST_OFFSET, ®); 1876 1877 if (status < 0) { 1878 codec_dbg(codec, "read CHNLSTART reg fail\n"); 1879 return status; 1880 } 1881 codec_dbg(codec, "-- dsp_dma_stop() Read CHNLSTART\n"); 1882 reg &= ~(DSPDMAC_CHNLSTART_EN_MASK | 1883 DSPDMAC_CHNLSTART_DIS_MASK); 1884 } 1885 1886 status = chipio_write(codec, DSPDMAC_CHNLSTART_INST_OFFSET, 1887 reg | (1 << (dma_chan + DSPDMAC_CHNLSTART_DIS_LOBIT))); 1888 if (status < 0) { 1889 codec_dbg(codec, "write CHNLSTART reg fail\n"); 1890 return status; 1891 } 1892 codec_dbg(codec, "-- dsp_dma_stop() -- Complete ---------\n"); 1893 1894 return status; 1895 } 1896 1897 /** 1898 * Allocate router ports 1899 * 1900 * @codec: the HDA codec 1901 * @num_chans: number of channels in the stream 1902 * @ports_per_channel: number of ports per channel 1903 * @start_device: start device 1904 * @port_map: pointer to the port list to hold the allocated ports 1905 * 1906 * Returns zero or a negative error code. 1907 */ 1908 static int dsp_allocate_router_ports(struct hda_codec *codec, 1909 unsigned int num_chans, 1910 unsigned int ports_per_channel, 1911 unsigned int start_device, 1912 unsigned int *port_map) 1913 { 1914 int status = 0; 1915 int res; 1916 u8 val; 1917 1918 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0); 1919 if (status < 0) 1920 return status; 1921 1922 val = start_device << 6; 1923 val |= (ports_per_channel - 1) << 4; 1924 val |= num_chans - 1; 1925 1926 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1927 VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET, 1928 val); 1929 1930 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1931 VENDOR_CHIPIO_PORT_ALLOC_SET, 1932 MEM_CONNID_DSP); 1933 1934 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0); 1935 if (status < 0) 1936 return status; 1937 1938 res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0, 1939 VENDOR_CHIPIO_PORT_ALLOC_GET, 0); 1940 1941 *port_map = res; 1942 1943 return (res < 0) ? res : 0; 1944 } 1945 1946 /* 1947 * Free router ports 1948 */ 1949 static int dsp_free_router_ports(struct hda_codec *codec) 1950 { 1951 int status = 0; 1952 1953 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0); 1954 if (status < 0) 1955 return status; 1956 1957 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 1958 VENDOR_CHIPIO_PORT_FREE_SET, 1959 MEM_CONNID_DSP); 1960 1961 status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0); 1962 1963 return status; 1964 } 1965 1966 /* 1967 * Allocate DSP ports for the download stream 1968 */ 1969 static int dsp_allocate_ports(struct hda_codec *codec, 1970 unsigned int num_chans, 1971 unsigned int rate_multi, unsigned int *port_map) 1972 { 1973 int status; 1974 1975 codec_dbg(codec, " dsp_allocate_ports() -- begin\n"); 1976 1977 if ((rate_multi != 1) && (rate_multi != 2) && (rate_multi != 4)) { 1978 codec_dbg(codec, "bad rate multiple\n"); 1979 return -EINVAL; 1980 } 1981 1982 status = dsp_allocate_router_ports(codec, num_chans, 1983 rate_multi, 0, port_map); 1984 1985 codec_dbg(codec, " dsp_allocate_ports() -- complete\n"); 1986 1987 return status; 1988 } 1989 1990 static int dsp_allocate_ports_format(struct hda_codec *codec, 1991 const unsigned short fmt, 1992 unsigned int *port_map) 1993 { 1994 int status; 1995 unsigned int num_chans; 1996 1997 unsigned int sample_rate_div = ((get_hdafmt_rate(fmt) >> 0) & 3) + 1; 1998 unsigned int sample_rate_mul = ((get_hdafmt_rate(fmt) >> 3) & 3) + 1; 1999 unsigned int rate_multi = sample_rate_mul / sample_rate_div; 2000 2001 if ((rate_multi != 1) && (rate_multi != 2) && (rate_multi != 4)) { 2002 codec_dbg(codec, "bad rate multiple\n"); 2003 return -EINVAL; 2004 } 2005 2006 num_chans = get_hdafmt_chs(fmt) + 1; 2007 2008 status = dsp_allocate_ports(codec, num_chans, rate_multi, port_map); 2009 2010 return status; 2011 } 2012 2013 /* 2014 * free DSP ports 2015 */ 2016 static int dsp_free_ports(struct hda_codec *codec) 2017 { 2018 int status; 2019 2020 codec_dbg(codec, " dsp_free_ports() -- begin\n"); 2021 2022 status = dsp_free_router_ports(codec); 2023 if (status < 0) { 2024 codec_dbg(codec, "free router ports fail\n"); 2025 return status; 2026 } 2027 codec_dbg(codec, " dsp_free_ports() -- complete\n"); 2028 2029 return status; 2030 } 2031 2032 /* 2033 * HDA DMA engine stuffs for DSP code download 2034 */ 2035 struct dma_engine { 2036 struct hda_codec *codec; 2037 unsigned short m_converter_format; 2038 struct snd_dma_buffer *dmab; 2039 unsigned int buf_size; 2040 }; 2041 2042 2043 enum dma_state { 2044 DMA_STATE_STOP = 0, 2045 DMA_STATE_RUN = 1 2046 }; 2047 2048 static int dma_convert_to_hda_format(struct hda_codec *codec, 2049 unsigned int sample_rate, 2050 unsigned short channels, 2051 unsigned short *hda_format) 2052 { 2053 unsigned int format_val; 2054 2055 format_val = snd_hda_calc_stream_format(codec, 2056 sample_rate, 2057 channels, 2058 SNDRV_PCM_FORMAT_S32_LE, 2059 32, 0); 2060 2061 if (hda_format) 2062 *hda_format = (unsigned short)format_val; 2063 2064 return 0; 2065 } 2066 2067 /* 2068 * Reset DMA for DSP download 2069 */ 2070 static int dma_reset(struct dma_engine *dma) 2071 { 2072 struct hda_codec *codec = dma->codec; 2073 struct ca0132_spec *spec = codec->spec; 2074 int status; 2075 2076 if (dma->dmab->area) 2077 snd_hda_codec_load_dsp_cleanup(codec, dma->dmab); 2078 2079 status = snd_hda_codec_load_dsp_prepare(codec, 2080 dma->m_converter_format, 2081 dma->buf_size, 2082 dma->dmab); 2083 if (status < 0) 2084 return status; 2085 spec->dsp_stream_id = status; 2086 return 0; 2087 } 2088 2089 static int dma_set_state(struct dma_engine *dma, enum dma_state state) 2090 { 2091 bool cmd; 2092 2093 switch (state) { 2094 case DMA_STATE_STOP: 2095 cmd = false; 2096 break; 2097 case DMA_STATE_RUN: 2098 cmd = true; 2099 break; 2100 default: 2101 return 0; 2102 } 2103 2104 snd_hda_codec_load_dsp_trigger(dma->codec, cmd); 2105 return 0; 2106 } 2107 2108 static unsigned int dma_get_buffer_size(struct dma_engine *dma) 2109 { 2110 return dma->dmab->bytes; 2111 } 2112 2113 static unsigned char *dma_get_buffer_addr(struct dma_engine *dma) 2114 { 2115 return dma->dmab->area; 2116 } 2117 2118 static int dma_xfer(struct dma_engine *dma, 2119 const unsigned int *data, 2120 unsigned int count) 2121 { 2122 memcpy(dma->dmab->area, data, count); 2123 return 0; 2124 } 2125 2126 static void dma_get_converter_format( 2127 struct dma_engine *dma, 2128 unsigned short *format) 2129 { 2130 if (format) 2131 *format = dma->m_converter_format; 2132 } 2133 2134 static unsigned int dma_get_stream_id(struct dma_engine *dma) 2135 { 2136 struct ca0132_spec *spec = dma->codec->spec; 2137 2138 return spec->dsp_stream_id; 2139 } 2140 2141 struct dsp_image_seg { 2142 u32 magic; 2143 u32 chip_addr; 2144 u32 count; 2145 u32 data[0]; 2146 }; 2147 2148 static const u32 g_magic_value = 0x4c46584d; 2149 static const u32 g_chip_addr_magic_value = 0xFFFFFF01; 2150 2151 static bool is_valid(const struct dsp_image_seg *p) 2152 { 2153 return p->magic == g_magic_value; 2154 } 2155 2156 static bool is_hci_prog_list_seg(const struct dsp_image_seg *p) 2157 { 2158 return g_chip_addr_magic_value == p->chip_addr; 2159 } 2160 2161 static bool is_last(const struct dsp_image_seg *p) 2162 { 2163 return p->count == 0; 2164 } 2165 2166 static size_t dsp_sizeof(const struct dsp_image_seg *p) 2167 { 2168 return sizeof(*p) + p->count*sizeof(u32); 2169 } 2170 2171 static const struct dsp_image_seg *get_next_seg_ptr( 2172 const struct dsp_image_seg *p) 2173 { 2174 return (struct dsp_image_seg *)((unsigned char *)(p) + dsp_sizeof(p)); 2175 } 2176 2177 /* 2178 * CA0132 chip DSP transfer stuffs. For DSP download. 2179 */ 2180 #define INVALID_DMA_CHANNEL (~0U) 2181 2182 /* 2183 * Program a list of address/data pairs via the ChipIO widget. 2184 * The segment data is in the format of successive pairs of words. 2185 * These are repeated as indicated by the segment's count field. 2186 */ 2187 static int dspxfr_hci_write(struct hda_codec *codec, 2188 const struct dsp_image_seg *fls) 2189 { 2190 int status; 2191 const u32 *data; 2192 unsigned int count; 2193 2194 if (fls == NULL || fls->chip_addr != g_chip_addr_magic_value) { 2195 codec_dbg(codec, "hci_write invalid params\n"); 2196 return -EINVAL; 2197 } 2198 2199 count = fls->count; 2200 data = (u32 *)(fls->data); 2201 while (count >= 2) { 2202 status = chipio_write(codec, data[0], data[1]); 2203 if (status < 0) { 2204 codec_dbg(codec, "hci_write chipio failed\n"); 2205 return status; 2206 } 2207 count -= 2; 2208 data += 2; 2209 } 2210 return 0; 2211 } 2212 2213 /** 2214 * Write a block of data into DSP code or data RAM using pre-allocated 2215 * DMA engine. 2216 * 2217 * @codec: the HDA codec 2218 * @fls: pointer to a fast load image 2219 * @reloc: Relocation address for loading single-segment overlays, or 0 for 2220 * no relocation 2221 * @dma_engine: pointer to DMA engine to be used for DSP download 2222 * @dma_chan: The number of DMA channels used for DSP download 2223 * @port_map_mask: port mapping 2224 * @ovly: TRUE if overlay format is required 2225 * 2226 * Returns zero or a negative error code. 2227 */ 2228 static int dspxfr_one_seg(struct hda_codec *codec, 2229 const struct dsp_image_seg *fls, 2230 unsigned int reloc, 2231 struct dma_engine *dma_engine, 2232 unsigned int dma_chan, 2233 unsigned int port_map_mask, 2234 bool ovly) 2235 { 2236 int status = 0; 2237 bool comm_dma_setup_done = false; 2238 const unsigned int *data; 2239 unsigned int chip_addx; 2240 unsigned int words_to_write; 2241 unsigned int buffer_size_words; 2242 unsigned char *buffer_addx; 2243 unsigned short hda_format; 2244 unsigned int sample_rate_div; 2245 unsigned int sample_rate_mul; 2246 unsigned int num_chans; 2247 unsigned int hda_frame_size_words; 2248 unsigned int remainder_words; 2249 const u32 *data_remainder; 2250 u32 chip_addx_remainder; 2251 unsigned int run_size_words; 2252 const struct dsp_image_seg *hci_write = NULL; 2253 unsigned long timeout; 2254 bool dma_active; 2255 2256 if (fls == NULL) 2257 return -EINVAL; 2258 if (is_hci_prog_list_seg(fls)) { 2259 hci_write = fls; 2260 fls = get_next_seg_ptr(fls); 2261 } 2262 2263 if (hci_write && (!fls || is_last(fls))) { 2264 codec_dbg(codec, "hci_write\n"); 2265 return dspxfr_hci_write(codec, hci_write); 2266 } 2267 2268 if (fls == NULL || dma_engine == NULL || port_map_mask == 0) { 2269 codec_dbg(codec, "Invalid Params\n"); 2270 return -EINVAL; 2271 } 2272 2273 data = fls->data; 2274 chip_addx = fls->chip_addr, 2275 words_to_write = fls->count; 2276 2277 if (!words_to_write) 2278 return hci_write ? dspxfr_hci_write(codec, hci_write) : 0; 2279 if (reloc) 2280 chip_addx = (chip_addx & (0xFFFF0000 << 2)) + (reloc << 2); 2281 2282 if (!UC_RANGE(chip_addx, words_to_write) && 2283 !X_RANGE_ALL(chip_addx, words_to_write) && 2284 !Y_RANGE_ALL(chip_addx, words_to_write)) { 2285 codec_dbg(codec, "Invalid chip_addx Params\n"); 2286 return -EINVAL; 2287 } 2288 2289 buffer_size_words = (unsigned int)dma_get_buffer_size(dma_engine) / 2290 sizeof(u32); 2291 2292 buffer_addx = dma_get_buffer_addr(dma_engine); 2293 2294 if (buffer_addx == NULL) { 2295 codec_dbg(codec, "dma_engine buffer NULL\n"); 2296 return -EINVAL; 2297 } 2298 2299 dma_get_converter_format(dma_engine, &hda_format); 2300 sample_rate_div = ((get_hdafmt_rate(hda_format) >> 0) & 3) + 1; 2301 sample_rate_mul = ((get_hdafmt_rate(hda_format) >> 3) & 3) + 1; 2302 num_chans = get_hdafmt_chs(hda_format) + 1; 2303 2304 hda_frame_size_words = ((sample_rate_div == 0) ? 0 : 2305 (num_chans * sample_rate_mul / sample_rate_div)); 2306 2307 if (hda_frame_size_words == 0) { 2308 codec_dbg(codec, "frmsz zero\n"); 2309 return -EINVAL; 2310 } 2311 2312 buffer_size_words = min(buffer_size_words, 2313 (unsigned int)(UC_RANGE(chip_addx, 1) ? 2314 65536 : 32768)); 2315 buffer_size_words -= buffer_size_words % hda_frame_size_words; 2316 codec_dbg(codec, 2317 "chpadr=0x%08x frmsz=%u nchan=%u " 2318 "rate_mul=%u div=%u bufsz=%u\n", 2319 chip_addx, hda_frame_size_words, num_chans, 2320 sample_rate_mul, sample_rate_div, buffer_size_words); 2321 2322 if (buffer_size_words < hda_frame_size_words) { 2323 codec_dbg(codec, "dspxfr_one_seg:failed\n"); 2324 return -EINVAL; 2325 } 2326 2327 remainder_words = words_to_write % hda_frame_size_words; 2328 data_remainder = data; 2329 chip_addx_remainder = chip_addx; 2330 2331 data += remainder_words; 2332 chip_addx += remainder_words*sizeof(u32); 2333 words_to_write -= remainder_words; 2334 2335 while (words_to_write != 0) { 2336 run_size_words = min(buffer_size_words, words_to_write); 2337 codec_dbg(codec, "dspxfr (seg loop)cnt=%u rs=%u remainder=%u\n", 2338 words_to_write, run_size_words, remainder_words); 2339 dma_xfer(dma_engine, data, run_size_words*sizeof(u32)); 2340 if (!comm_dma_setup_done) { 2341 status = dsp_dma_stop(codec, dma_chan, ovly); 2342 if (status < 0) 2343 return status; 2344 status = dsp_dma_setup_common(codec, chip_addx, 2345 dma_chan, port_map_mask, ovly); 2346 if (status < 0) 2347 return status; 2348 comm_dma_setup_done = true; 2349 } 2350 2351 status = dsp_dma_setup(codec, chip_addx, 2352 run_size_words, dma_chan); 2353 if (status < 0) 2354 return status; 2355 status = dsp_dma_start(codec, dma_chan, ovly); 2356 if (status < 0) 2357 return status; 2358 if (!dsp_is_dma_active(codec, dma_chan)) { 2359 codec_dbg(codec, "dspxfr:DMA did not start\n"); 2360 return -EIO; 2361 } 2362 status = dma_set_state(dma_engine, DMA_STATE_RUN); 2363 if (status < 0) 2364 return status; 2365 if (remainder_words != 0) { 2366 status = chipio_write_multiple(codec, 2367 chip_addx_remainder, 2368 data_remainder, 2369 remainder_words); 2370 if (status < 0) 2371 return status; 2372 remainder_words = 0; 2373 } 2374 if (hci_write) { 2375 status = dspxfr_hci_write(codec, hci_write); 2376 if (status < 0) 2377 return status; 2378 hci_write = NULL; 2379 } 2380 2381 timeout = jiffies + msecs_to_jiffies(2000); 2382 do { 2383 dma_active = dsp_is_dma_active(codec, dma_chan); 2384 if (!dma_active) 2385 break; 2386 msleep(20); 2387 } while (time_before(jiffies, timeout)); 2388 if (dma_active) 2389 break; 2390 2391 codec_dbg(codec, "+++++ DMA complete\n"); 2392 dma_set_state(dma_engine, DMA_STATE_STOP); 2393 status = dma_reset(dma_engine); 2394 2395 if (status < 0) 2396 return status; 2397 2398 data += run_size_words; 2399 chip_addx += run_size_words*sizeof(u32); 2400 words_to_write -= run_size_words; 2401 } 2402 2403 if (remainder_words != 0) { 2404 status = chipio_write_multiple(codec, chip_addx_remainder, 2405 data_remainder, remainder_words); 2406 } 2407 2408 return status; 2409 } 2410 2411 /** 2412 * Write the entire DSP image of a DSP code/data overlay to DSP memories 2413 * 2414 * @codec: the HDA codec 2415 * @fls_data: pointer to a fast load image 2416 * @reloc: Relocation address for loading single-segment overlays, or 0 for 2417 * no relocation 2418 * @sample_rate: sampling rate of the stream used for DSP download 2419 * @channels: channels of the stream used for DSP download 2420 * @ovly: TRUE if overlay format is required 2421 * 2422 * Returns zero or a negative error code. 2423 */ 2424 static int dspxfr_image(struct hda_codec *codec, 2425 const struct dsp_image_seg *fls_data, 2426 unsigned int reloc, 2427 unsigned int sample_rate, 2428 unsigned short channels, 2429 bool ovly) 2430 { 2431 struct ca0132_spec *spec = codec->spec; 2432 int status; 2433 unsigned short hda_format = 0; 2434 unsigned int response; 2435 unsigned char stream_id = 0; 2436 struct dma_engine *dma_engine; 2437 unsigned int dma_chan; 2438 unsigned int port_map_mask; 2439 2440 if (fls_data == NULL) 2441 return -EINVAL; 2442 2443 dma_engine = kzalloc(sizeof(*dma_engine), GFP_KERNEL); 2444 if (!dma_engine) 2445 return -ENOMEM; 2446 2447 dma_engine->dmab = kzalloc(sizeof(*dma_engine->dmab), GFP_KERNEL); 2448 if (!dma_engine->dmab) { 2449 kfree(dma_engine); 2450 return -ENOMEM; 2451 } 2452 2453 dma_engine->codec = codec; 2454 dma_convert_to_hda_format(codec, sample_rate, channels, &hda_format); 2455 dma_engine->m_converter_format = hda_format; 2456 dma_engine->buf_size = (ovly ? DSP_DMA_WRITE_BUFLEN_OVLY : 2457 DSP_DMA_WRITE_BUFLEN_INIT) * 2; 2458 2459 dma_chan = ovly ? INVALID_DMA_CHANNEL : 0; 2460 2461 status = codec_set_converter_format(codec, WIDGET_CHIP_CTRL, 2462 hda_format, &response); 2463 2464 if (status < 0) { 2465 codec_dbg(codec, "set converter format fail\n"); 2466 goto exit; 2467 } 2468 2469 status = snd_hda_codec_load_dsp_prepare(codec, 2470 dma_engine->m_converter_format, 2471 dma_engine->buf_size, 2472 dma_engine->dmab); 2473 if (status < 0) 2474 goto exit; 2475 spec->dsp_stream_id = status; 2476 2477 if (ovly) { 2478 status = dspio_alloc_dma_chan(codec, &dma_chan); 2479 if (status < 0) { 2480 codec_dbg(codec, "alloc dmachan fail\n"); 2481 dma_chan = INVALID_DMA_CHANNEL; 2482 goto exit; 2483 } 2484 } 2485 2486 port_map_mask = 0; 2487 status = dsp_allocate_ports_format(codec, hda_format, 2488 &port_map_mask); 2489 if (status < 0) { 2490 codec_dbg(codec, "alloc ports fail\n"); 2491 goto exit; 2492 } 2493 2494 stream_id = dma_get_stream_id(dma_engine); 2495 status = codec_set_converter_stream_channel(codec, 2496 WIDGET_CHIP_CTRL, stream_id, 0, &response); 2497 if (status < 0) { 2498 codec_dbg(codec, "set stream chan fail\n"); 2499 goto exit; 2500 } 2501 2502 while ((fls_data != NULL) && !is_last(fls_data)) { 2503 if (!is_valid(fls_data)) { 2504 codec_dbg(codec, "FLS check fail\n"); 2505 status = -EINVAL; 2506 goto exit; 2507 } 2508 status = dspxfr_one_seg(codec, fls_data, reloc, 2509 dma_engine, dma_chan, 2510 port_map_mask, ovly); 2511 if (status < 0) 2512 break; 2513 2514 if (is_hci_prog_list_seg(fls_data)) 2515 fls_data = get_next_seg_ptr(fls_data); 2516 2517 if ((fls_data != NULL) && !is_last(fls_data)) 2518 fls_data = get_next_seg_ptr(fls_data); 2519 } 2520 2521 if (port_map_mask != 0) 2522 status = dsp_free_ports(codec); 2523 2524 if (status < 0) 2525 goto exit; 2526 2527 status = codec_set_converter_stream_channel(codec, 2528 WIDGET_CHIP_CTRL, 0, 0, &response); 2529 2530 exit: 2531 if (ovly && (dma_chan != INVALID_DMA_CHANNEL)) 2532 dspio_free_dma_chan(codec, dma_chan); 2533 2534 if (dma_engine->dmab->area) 2535 snd_hda_codec_load_dsp_cleanup(codec, dma_engine->dmab); 2536 kfree(dma_engine->dmab); 2537 kfree(dma_engine); 2538 2539 return status; 2540 } 2541 2542 /* 2543 * CA0132 DSP download stuffs. 2544 */ 2545 static void dspload_post_setup(struct hda_codec *codec) 2546 { 2547 codec_dbg(codec, "---- dspload_post_setup ------\n"); 2548 2549 /*set DSP speaker to 2.0 configuration*/ 2550 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x18), 0x08080080); 2551 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x19), 0x3f800000); 2552 2553 /*update write pointer*/ 2554 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x29), 0x00000002); 2555 } 2556 2557 /** 2558 * dspload_image - Download DSP from a DSP Image Fast Load structure. 2559 * 2560 * @codec: the HDA codec 2561 * @fls: pointer to a fast load image 2562 * @ovly: TRUE if overlay format is required 2563 * @reloc: Relocation address for loading single-segment overlays, or 0 for 2564 * no relocation 2565 * @autostart: TRUE if DSP starts after loading; ignored if ovly is TRUE 2566 * @router_chans: number of audio router channels to be allocated (0 means use 2567 * internal defaults; max is 32) 2568 * 2569 * Download DSP from a DSP Image Fast Load structure. This structure is a 2570 * linear, non-constant sized element array of structures, each of which 2571 * contain the count of the data to be loaded, the data itself, and the 2572 * corresponding starting chip address of the starting data location. 2573 * Returns zero or a negative error code. 2574 */ 2575 static int dspload_image(struct hda_codec *codec, 2576 const struct dsp_image_seg *fls, 2577 bool ovly, 2578 unsigned int reloc, 2579 bool autostart, 2580 int router_chans) 2581 { 2582 int status = 0; 2583 unsigned int sample_rate; 2584 unsigned short channels; 2585 2586 codec_dbg(codec, "---- dspload_image begin ------\n"); 2587 if (router_chans == 0) { 2588 if (!ovly) 2589 router_chans = DMA_TRANSFER_FRAME_SIZE_NWORDS; 2590 else 2591 router_chans = DMA_OVERLAY_FRAME_SIZE_NWORDS; 2592 } 2593 2594 sample_rate = 48000; 2595 channels = (unsigned short)router_chans; 2596 2597 while (channels > 16) { 2598 sample_rate *= 2; 2599 channels /= 2; 2600 } 2601 2602 do { 2603 codec_dbg(codec, "Ready to program DMA\n"); 2604 if (!ovly) 2605 status = dsp_reset(codec); 2606 2607 if (status < 0) 2608 break; 2609 2610 codec_dbg(codec, "dsp_reset() complete\n"); 2611 status = dspxfr_image(codec, fls, reloc, sample_rate, channels, 2612 ovly); 2613 2614 if (status < 0) 2615 break; 2616 2617 codec_dbg(codec, "dspxfr_image() complete\n"); 2618 if (autostart && !ovly) { 2619 dspload_post_setup(codec); 2620 status = dsp_set_run_state(codec); 2621 } 2622 2623 codec_dbg(codec, "LOAD FINISHED\n"); 2624 } while (0); 2625 2626 return status; 2627 } 2628 2629 #ifdef CONFIG_SND_HDA_CODEC_CA0132_DSP 2630 static bool dspload_is_loaded(struct hda_codec *codec) 2631 { 2632 unsigned int data = 0; 2633 int status = 0; 2634 2635 status = chipio_read(codec, 0x40004, &data); 2636 if ((status < 0) || (data != 1)) 2637 return false; 2638 2639 return true; 2640 } 2641 #else 2642 #define dspload_is_loaded(codec) false 2643 #endif 2644 2645 static bool dspload_wait_loaded(struct hda_codec *codec) 2646 { 2647 unsigned long timeout = jiffies + msecs_to_jiffies(2000); 2648 2649 do { 2650 if (dspload_is_loaded(codec)) { 2651 pr_info("ca0132 DOWNLOAD OK :-) DSP IS RUNNING.\n"); 2652 return true; 2653 } 2654 msleep(20); 2655 } while (time_before(jiffies, timeout)); 2656 2657 pr_err("ca0132 DOWNLOAD FAILED!!! DSP IS NOT RUNNING.\n"); 2658 return false; 2659 } 2660 2661 /* 2662 * PCM callbacks 2663 */ 2664 static int ca0132_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2665 struct hda_codec *codec, 2666 unsigned int stream_tag, 2667 unsigned int format, 2668 struct snd_pcm_substream *substream) 2669 { 2670 struct ca0132_spec *spec = codec->spec; 2671 2672 snd_hda_codec_setup_stream(codec, spec->dacs[0], stream_tag, 0, format); 2673 2674 return 0; 2675 } 2676 2677 static int ca0132_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2678 struct hda_codec *codec, 2679 struct snd_pcm_substream *substream) 2680 { 2681 struct ca0132_spec *spec = codec->spec; 2682 2683 if (spec->dsp_state == DSP_DOWNLOADING) 2684 return 0; 2685 2686 /*If Playback effects are on, allow stream some time to flush 2687 *effects tail*/ 2688 if (spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID]) 2689 msleep(50); 2690 2691 snd_hda_codec_cleanup_stream(codec, spec->dacs[0]); 2692 2693 return 0; 2694 } 2695 2696 static unsigned int ca0132_playback_pcm_delay(struct hda_pcm_stream *info, 2697 struct hda_codec *codec, 2698 struct snd_pcm_substream *substream) 2699 { 2700 struct ca0132_spec *spec = codec->spec; 2701 unsigned int latency = DSP_PLAYBACK_INIT_LATENCY; 2702 struct snd_pcm_runtime *runtime = substream->runtime; 2703 2704 if (spec->dsp_state != DSP_DOWNLOADED) 2705 return 0; 2706 2707 /* Add latency if playback enhancement and either effect is enabled. */ 2708 if (spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID]) { 2709 if ((spec->effects_switch[SURROUND - EFFECT_START_NID]) || 2710 (spec->effects_switch[DIALOG_PLUS - EFFECT_START_NID])) 2711 latency += DSP_PLAY_ENHANCEMENT_LATENCY; 2712 } 2713 2714 /* Applying Speaker EQ adds latency as well. */ 2715 if (spec->cur_out_type == SPEAKER_OUT) 2716 latency += DSP_SPEAKER_OUT_LATENCY; 2717 2718 return (latency * runtime->rate) / 1000; 2719 } 2720 2721 /* 2722 * Digital out 2723 */ 2724 static int ca0132_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 2725 struct hda_codec *codec, 2726 struct snd_pcm_substream *substream) 2727 { 2728 struct ca0132_spec *spec = codec->spec; 2729 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 2730 } 2731 2732 static int ca0132_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2733 struct hda_codec *codec, 2734 unsigned int stream_tag, 2735 unsigned int format, 2736 struct snd_pcm_substream *substream) 2737 { 2738 struct ca0132_spec *spec = codec->spec; 2739 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 2740 stream_tag, format, substream); 2741 } 2742 2743 static int ca0132_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2744 struct hda_codec *codec, 2745 struct snd_pcm_substream *substream) 2746 { 2747 struct ca0132_spec *spec = codec->spec; 2748 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 2749 } 2750 2751 static int ca0132_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 2752 struct hda_codec *codec, 2753 struct snd_pcm_substream *substream) 2754 { 2755 struct ca0132_spec *spec = codec->spec; 2756 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 2757 } 2758 2759 /* 2760 * Analog capture 2761 */ 2762 static int ca0132_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2763 struct hda_codec *codec, 2764 unsigned int stream_tag, 2765 unsigned int format, 2766 struct snd_pcm_substream *substream) 2767 { 2768 snd_hda_codec_setup_stream(codec, hinfo->nid, 2769 stream_tag, 0, format); 2770 2771 return 0; 2772 } 2773 2774 static int ca0132_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 2775 struct hda_codec *codec, 2776 struct snd_pcm_substream *substream) 2777 { 2778 struct ca0132_spec *spec = codec->spec; 2779 2780 if (spec->dsp_state == DSP_DOWNLOADING) 2781 return 0; 2782 2783 snd_hda_codec_cleanup_stream(codec, hinfo->nid); 2784 return 0; 2785 } 2786 2787 static unsigned int ca0132_capture_pcm_delay(struct hda_pcm_stream *info, 2788 struct hda_codec *codec, 2789 struct snd_pcm_substream *substream) 2790 { 2791 struct ca0132_spec *spec = codec->spec; 2792 unsigned int latency = DSP_CAPTURE_INIT_LATENCY; 2793 struct snd_pcm_runtime *runtime = substream->runtime; 2794 2795 if (spec->dsp_state != DSP_DOWNLOADED) 2796 return 0; 2797 2798 if (spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID]) 2799 latency += DSP_CRYSTAL_VOICE_LATENCY; 2800 2801 return (latency * runtime->rate) / 1000; 2802 } 2803 2804 /* 2805 * Controls stuffs. 2806 */ 2807 2808 /* 2809 * Mixer controls helpers. 2810 */ 2811 #define CA0132_CODEC_VOL_MONO(xname, nid, channel, dir) \ 2812 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2813 .name = xname, \ 2814 .subdevice = HDA_SUBDEV_AMP_FLAG, \ 2815 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 2816 SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 2817 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK, \ 2818 .info = ca0132_volume_info, \ 2819 .get = ca0132_volume_get, \ 2820 .put = ca0132_volume_put, \ 2821 .tlv = { .c = ca0132_volume_tlv }, \ 2822 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, 0, dir) } 2823 2824 #define CA0132_CODEC_MUTE_MONO(xname, nid, channel, dir) \ 2825 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2826 .name = xname, \ 2827 .subdevice = HDA_SUBDEV_AMP_FLAG, \ 2828 .info = snd_hda_mixer_amp_switch_info, \ 2829 .get = ca0132_switch_get, \ 2830 .put = ca0132_switch_put, \ 2831 .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, 0, dir) } 2832 2833 /* stereo */ 2834 #define CA0132_CODEC_VOL(xname, nid, dir) \ 2835 CA0132_CODEC_VOL_MONO(xname, nid, 3, dir) 2836 #define CA0132_CODEC_MUTE(xname, nid, dir) \ 2837 CA0132_CODEC_MUTE_MONO(xname, nid, 3, dir) 2838 2839 /* The followings are for tuning of products */ 2840 #ifdef ENABLE_TUNING_CONTROLS 2841 2842 static unsigned int voice_focus_vals_lookup[] = { 2843 0x41A00000, 0x41A80000, 0x41B00000, 0x41B80000, 0x41C00000, 0x41C80000, 2844 0x41D00000, 0x41D80000, 0x41E00000, 0x41E80000, 0x41F00000, 0x41F80000, 2845 0x42000000, 0x42040000, 0x42080000, 0x420C0000, 0x42100000, 0x42140000, 2846 0x42180000, 0x421C0000, 0x42200000, 0x42240000, 0x42280000, 0x422C0000, 2847 0x42300000, 0x42340000, 0x42380000, 0x423C0000, 0x42400000, 0x42440000, 2848 0x42480000, 0x424C0000, 0x42500000, 0x42540000, 0x42580000, 0x425C0000, 2849 0x42600000, 0x42640000, 0x42680000, 0x426C0000, 0x42700000, 0x42740000, 2850 0x42780000, 0x427C0000, 0x42800000, 0x42820000, 0x42840000, 0x42860000, 2851 0x42880000, 0x428A0000, 0x428C0000, 0x428E0000, 0x42900000, 0x42920000, 2852 0x42940000, 0x42960000, 0x42980000, 0x429A0000, 0x429C0000, 0x429E0000, 2853 0x42A00000, 0x42A20000, 0x42A40000, 0x42A60000, 0x42A80000, 0x42AA0000, 2854 0x42AC0000, 0x42AE0000, 0x42B00000, 0x42B20000, 0x42B40000, 0x42B60000, 2855 0x42B80000, 0x42BA0000, 0x42BC0000, 0x42BE0000, 0x42C00000, 0x42C20000, 2856 0x42C40000, 0x42C60000, 0x42C80000, 0x42CA0000, 0x42CC0000, 0x42CE0000, 2857 0x42D00000, 0x42D20000, 0x42D40000, 0x42D60000, 0x42D80000, 0x42DA0000, 2858 0x42DC0000, 0x42DE0000, 0x42E00000, 0x42E20000, 0x42E40000, 0x42E60000, 2859 0x42E80000, 0x42EA0000, 0x42EC0000, 0x42EE0000, 0x42F00000, 0x42F20000, 2860 0x42F40000, 0x42F60000, 0x42F80000, 0x42FA0000, 0x42FC0000, 0x42FE0000, 2861 0x43000000, 0x43010000, 0x43020000, 0x43030000, 0x43040000, 0x43050000, 2862 0x43060000, 0x43070000, 0x43080000, 0x43090000, 0x430A0000, 0x430B0000, 2863 0x430C0000, 0x430D0000, 0x430E0000, 0x430F0000, 0x43100000, 0x43110000, 2864 0x43120000, 0x43130000, 0x43140000, 0x43150000, 0x43160000, 0x43170000, 2865 0x43180000, 0x43190000, 0x431A0000, 0x431B0000, 0x431C0000, 0x431D0000, 2866 0x431E0000, 0x431F0000, 0x43200000, 0x43210000, 0x43220000, 0x43230000, 2867 0x43240000, 0x43250000, 0x43260000, 0x43270000, 0x43280000, 0x43290000, 2868 0x432A0000, 0x432B0000, 0x432C0000, 0x432D0000, 0x432E0000, 0x432F0000, 2869 0x43300000, 0x43310000, 0x43320000, 0x43330000, 0x43340000 2870 }; 2871 2872 static unsigned int mic_svm_vals_lookup[] = { 2873 0x00000000, 0x3C23D70A, 0x3CA3D70A, 0x3CF5C28F, 0x3D23D70A, 0x3D4CCCCD, 2874 0x3D75C28F, 0x3D8F5C29, 0x3DA3D70A, 0x3DB851EC, 0x3DCCCCCD, 0x3DE147AE, 2875 0x3DF5C28F, 0x3E051EB8, 0x3E0F5C29, 0x3E19999A, 0x3E23D70A, 0x3E2E147B, 2876 0x3E3851EC, 0x3E428F5C, 0x3E4CCCCD, 0x3E570A3D, 0x3E6147AE, 0x3E6B851F, 2877 0x3E75C28F, 0x3E800000, 0x3E851EB8, 0x3E8A3D71, 0x3E8F5C29, 0x3E947AE1, 2878 0x3E99999A, 0x3E9EB852, 0x3EA3D70A, 0x3EA8F5C3, 0x3EAE147B, 0x3EB33333, 2879 0x3EB851EC, 0x3EBD70A4, 0x3EC28F5C, 0x3EC7AE14, 0x3ECCCCCD, 0x3ED1EB85, 2880 0x3ED70A3D, 0x3EDC28F6, 0x3EE147AE, 0x3EE66666, 0x3EEB851F, 0x3EF0A3D7, 2881 0x3EF5C28F, 0x3EFAE148, 0x3F000000, 0x3F028F5C, 0x3F051EB8, 0x3F07AE14, 2882 0x3F0A3D71, 0x3F0CCCCD, 0x3F0F5C29, 0x3F11EB85, 0x3F147AE1, 0x3F170A3D, 2883 0x3F19999A, 0x3F1C28F6, 0x3F1EB852, 0x3F2147AE, 0x3F23D70A, 0x3F266666, 2884 0x3F28F5C3, 0x3F2B851F, 0x3F2E147B, 0x3F30A3D7, 0x3F333333, 0x3F35C28F, 2885 0x3F3851EC, 0x3F3AE148, 0x3F3D70A4, 0x3F400000, 0x3F428F5C, 0x3F451EB8, 2886 0x3F47AE14, 0x3F4A3D71, 0x3F4CCCCD, 0x3F4F5C29, 0x3F51EB85, 0x3F547AE1, 2887 0x3F570A3D, 0x3F59999A, 0x3F5C28F6, 0x3F5EB852, 0x3F6147AE, 0x3F63D70A, 2888 0x3F666666, 0x3F68F5C3, 0x3F6B851F, 0x3F6E147B, 0x3F70A3D7, 0x3F733333, 2889 0x3F75C28F, 0x3F7851EC, 0x3F7AE148, 0x3F7D70A4, 0x3F800000 2890 }; 2891 2892 static unsigned int equalizer_vals_lookup[] = { 2893 0xC1C00000, 0xC1B80000, 0xC1B00000, 0xC1A80000, 0xC1A00000, 0xC1980000, 2894 0xC1900000, 0xC1880000, 0xC1800000, 0xC1700000, 0xC1600000, 0xC1500000, 2895 0xC1400000, 0xC1300000, 0xC1200000, 0xC1100000, 0xC1000000, 0xC0E00000, 2896 0xC0C00000, 0xC0A00000, 0xC0800000, 0xC0400000, 0xC0000000, 0xBF800000, 2897 0x00000000, 0x3F800000, 0x40000000, 0x40400000, 0x40800000, 0x40A00000, 2898 0x40C00000, 0x40E00000, 0x41000000, 0x41100000, 0x41200000, 0x41300000, 2899 0x41400000, 0x41500000, 0x41600000, 0x41700000, 0x41800000, 0x41880000, 2900 0x41900000, 0x41980000, 0x41A00000, 0x41A80000, 0x41B00000, 0x41B80000, 2901 0x41C00000 2902 }; 2903 2904 static int tuning_ctl_set(struct hda_codec *codec, hda_nid_t nid, 2905 unsigned int *lookup, int idx) 2906 { 2907 int i = 0; 2908 2909 for (i = 0; i < TUNING_CTLS_COUNT; i++) 2910 if (nid == ca0132_tuning_ctls[i].nid) 2911 break; 2912 2913 snd_hda_power_up(codec); 2914 dspio_set_param(codec, ca0132_tuning_ctls[i].mid, 2915 ca0132_tuning_ctls[i].req, 2916 &(lookup[idx]), sizeof(unsigned int)); 2917 snd_hda_power_down(codec); 2918 2919 return 1; 2920 } 2921 2922 static int tuning_ctl_get(struct snd_kcontrol *kcontrol, 2923 struct snd_ctl_elem_value *ucontrol) 2924 { 2925 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2926 struct ca0132_spec *spec = codec->spec; 2927 hda_nid_t nid = get_amp_nid(kcontrol); 2928 long *valp = ucontrol->value.integer.value; 2929 int idx = nid - TUNING_CTL_START_NID; 2930 2931 *valp = spec->cur_ctl_vals[idx]; 2932 return 0; 2933 } 2934 2935 static int voice_focus_ctl_info(struct snd_kcontrol *kcontrol, 2936 struct snd_ctl_elem_info *uinfo) 2937 { 2938 int chs = get_amp_channels(kcontrol); 2939 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2940 uinfo->count = chs == 3 ? 2 : 1; 2941 uinfo->value.integer.min = 20; 2942 uinfo->value.integer.max = 180; 2943 uinfo->value.integer.step = 1; 2944 2945 return 0; 2946 } 2947 2948 static int voice_focus_ctl_put(struct snd_kcontrol *kcontrol, 2949 struct snd_ctl_elem_value *ucontrol) 2950 { 2951 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2952 struct ca0132_spec *spec = codec->spec; 2953 hda_nid_t nid = get_amp_nid(kcontrol); 2954 long *valp = ucontrol->value.integer.value; 2955 int idx; 2956 2957 idx = nid - TUNING_CTL_START_NID; 2958 /* any change? */ 2959 if (spec->cur_ctl_vals[idx] == *valp) 2960 return 0; 2961 2962 spec->cur_ctl_vals[idx] = *valp; 2963 2964 idx = *valp - 20; 2965 tuning_ctl_set(codec, nid, voice_focus_vals_lookup, idx); 2966 2967 return 1; 2968 } 2969 2970 static int mic_svm_ctl_info(struct snd_kcontrol *kcontrol, 2971 struct snd_ctl_elem_info *uinfo) 2972 { 2973 int chs = get_amp_channels(kcontrol); 2974 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2975 uinfo->count = chs == 3 ? 2 : 1; 2976 uinfo->value.integer.min = 0; 2977 uinfo->value.integer.max = 100; 2978 uinfo->value.integer.step = 1; 2979 2980 return 0; 2981 } 2982 2983 static int mic_svm_ctl_put(struct snd_kcontrol *kcontrol, 2984 struct snd_ctl_elem_value *ucontrol) 2985 { 2986 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2987 struct ca0132_spec *spec = codec->spec; 2988 hda_nid_t nid = get_amp_nid(kcontrol); 2989 long *valp = ucontrol->value.integer.value; 2990 int idx; 2991 2992 idx = nid - TUNING_CTL_START_NID; 2993 /* any change? */ 2994 if (spec->cur_ctl_vals[idx] == *valp) 2995 return 0; 2996 2997 spec->cur_ctl_vals[idx] = *valp; 2998 2999 idx = *valp; 3000 tuning_ctl_set(codec, nid, mic_svm_vals_lookup, idx); 3001 3002 return 0; 3003 } 3004 3005 static int equalizer_ctl_info(struct snd_kcontrol *kcontrol, 3006 struct snd_ctl_elem_info *uinfo) 3007 { 3008 int chs = get_amp_channels(kcontrol); 3009 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 3010 uinfo->count = chs == 3 ? 2 : 1; 3011 uinfo->value.integer.min = 0; 3012 uinfo->value.integer.max = 48; 3013 uinfo->value.integer.step = 1; 3014 3015 return 0; 3016 } 3017 3018 static int equalizer_ctl_put(struct snd_kcontrol *kcontrol, 3019 struct snd_ctl_elem_value *ucontrol) 3020 { 3021 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3022 struct ca0132_spec *spec = codec->spec; 3023 hda_nid_t nid = get_amp_nid(kcontrol); 3024 long *valp = ucontrol->value.integer.value; 3025 int idx; 3026 3027 idx = nid - TUNING_CTL_START_NID; 3028 /* any change? */ 3029 if (spec->cur_ctl_vals[idx] == *valp) 3030 return 0; 3031 3032 spec->cur_ctl_vals[idx] = *valp; 3033 3034 idx = *valp; 3035 tuning_ctl_set(codec, nid, equalizer_vals_lookup, idx); 3036 3037 return 1; 3038 } 3039 3040 static const DECLARE_TLV_DB_SCALE(voice_focus_db_scale, 2000, 100, 0); 3041 static const DECLARE_TLV_DB_SCALE(eq_db_scale, -2400, 100, 0); 3042 3043 static int add_tuning_control(struct hda_codec *codec, 3044 hda_nid_t pnid, hda_nid_t nid, 3045 const char *name, int dir) 3046 { 3047 char namestr[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 3048 int type = dir ? HDA_INPUT : HDA_OUTPUT; 3049 struct snd_kcontrol_new knew = 3050 HDA_CODEC_VOLUME_MONO(namestr, nid, 1, 0, type); 3051 3052 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 3053 SNDRV_CTL_ELEM_ACCESS_TLV_READ; 3054 knew.tlv.c = 0; 3055 knew.tlv.p = 0; 3056 switch (pnid) { 3057 case VOICE_FOCUS: 3058 knew.info = voice_focus_ctl_info; 3059 knew.get = tuning_ctl_get; 3060 knew.put = voice_focus_ctl_put; 3061 knew.tlv.p = voice_focus_db_scale; 3062 break; 3063 case MIC_SVM: 3064 knew.info = mic_svm_ctl_info; 3065 knew.get = tuning_ctl_get; 3066 knew.put = mic_svm_ctl_put; 3067 break; 3068 case EQUALIZER: 3069 knew.info = equalizer_ctl_info; 3070 knew.get = tuning_ctl_get; 3071 knew.put = equalizer_ctl_put; 3072 knew.tlv.p = eq_db_scale; 3073 break; 3074 default: 3075 return 0; 3076 } 3077 knew.private_value = 3078 HDA_COMPOSE_AMP_VAL(nid, 1, 0, type); 3079 sprintf(namestr, "%s %s Volume", name, dirstr[dir]); 3080 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); 3081 } 3082 3083 static int add_tuning_ctls(struct hda_codec *codec) 3084 { 3085 int i; 3086 int err; 3087 3088 for (i = 0; i < TUNING_CTLS_COUNT; i++) { 3089 err = add_tuning_control(codec, 3090 ca0132_tuning_ctls[i].parent_nid, 3091 ca0132_tuning_ctls[i].nid, 3092 ca0132_tuning_ctls[i].name, 3093 ca0132_tuning_ctls[i].direct); 3094 if (err < 0) 3095 return err; 3096 } 3097 3098 return 0; 3099 } 3100 3101 static void ca0132_init_tuning_defaults(struct hda_codec *codec) 3102 { 3103 struct ca0132_spec *spec = codec->spec; 3104 int i; 3105 3106 /* Wedge Angle defaults to 30. 10 below is 30 - 20. 20 is min. */ 3107 spec->cur_ctl_vals[WEDGE_ANGLE - TUNING_CTL_START_NID] = 10; 3108 /* SVM level defaults to 0.74. */ 3109 spec->cur_ctl_vals[SVM_LEVEL - TUNING_CTL_START_NID] = 74; 3110 3111 /* EQ defaults to 0dB. */ 3112 for (i = 2; i < TUNING_CTLS_COUNT; i++) 3113 spec->cur_ctl_vals[i] = 24; 3114 } 3115 #endif /*ENABLE_TUNING_CONTROLS*/ 3116 3117 /* 3118 * Select the active output. 3119 * If autodetect is enabled, output will be selected based on jack detection. 3120 * If jack inserted, headphone will be selected, else built-in speakers 3121 * If autodetect is disabled, output will be selected based on selection. 3122 */ 3123 static int ca0132_select_out(struct hda_codec *codec) 3124 { 3125 struct ca0132_spec *spec = codec->spec; 3126 unsigned int pin_ctl; 3127 int jack_present; 3128 int auto_jack; 3129 unsigned int tmp; 3130 int err; 3131 3132 codec_dbg(codec, "ca0132_select_out\n"); 3133 3134 snd_hda_power_up_pm(codec); 3135 3136 auto_jack = spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID]; 3137 3138 if (auto_jack) 3139 jack_present = snd_hda_jack_detect(codec, spec->out_pins[1]); 3140 else 3141 jack_present = 3142 spec->vnode_lswitch[VNID_HP_SEL - VNODE_START_NID]; 3143 3144 if (jack_present) 3145 spec->cur_out_type = HEADPHONE_OUT; 3146 else 3147 spec->cur_out_type = SPEAKER_OUT; 3148 3149 if (spec->cur_out_type == SPEAKER_OUT) { 3150 codec_dbg(codec, "ca0132_select_out speaker\n"); 3151 /*speaker out config*/ 3152 tmp = FLOAT_ONE; 3153 err = dspio_set_uint_param(codec, 0x80, 0x04, tmp); 3154 if (err < 0) 3155 goto exit; 3156 /*enable speaker EQ*/ 3157 tmp = FLOAT_ONE; 3158 err = dspio_set_uint_param(codec, 0x8f, 0x00, tmp); 3159 if (err < 0) 3160 goto exit; 3161 3162 /* Setup EAPD */ 3163 snd_hda_codec_write(codec, spec->out_pins[1], 0, 3164 VENDOR_CHIPIO_EAPD_SEL_SET, 0x02); 3165 snd_hda_codec_write(codec, spec->out_pins[0], 0, 3166 AC_VERB_SET_EAPD_BTLENABLE, 0x00); 3167 snd_hda_codec_write(codec, spec->out_pins[0], 0, 3168 VENDOR_CHIPIO_EAPD_SEL_SET, 0x00); 3169 snd_hda_codec_write(codec, spec->out_pins[0], 0, 3170 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 3171 3172 /* disable headphone node */ 3173 pin_ctl = snd_hda_codec_read(codec, spec->out_pins[1], 0, 3174 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3175 snd_hda_set_pin_ctl(codec, spec->out_pins[1], 3176 pin_ctl & ~PIN_HP); 3177 /* enable speaker node */ 3178 pin_ctl = snd_hda_codec_read(codec, spec->out_pins[0], 0, 3179 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3180 snd_hda_set_pin_ctl(codec, spec->out_pins[0], 3181 pin_ctl | PIN_OUT); 3182 } else { 3183 codec_dbg(codec, "ca0132_select_out hp\n"); 3184 /*headphone out config*/ 3185 tmp = FLOAT_ZERO; 3186 err = dspio_set_uint_param(codec, 0x80, 0x04, tmp); 3187 if (err < 0) 3188 goto exit; 3189 /*disable speaker EQ*/ 3190 tmp = FLOAT_ZERO; 3191 err = dspio_set_uint_param(codec, 0x8f, 0x00, tmp); 3192 if (err < 0) 3193 goto exit; 3194 3195 /* Setup EAPD */ 3196 snd_hda_codec_write(codec, spec->out_pins[0], 0, 3197 VENDOR_CHIPIO_EAPD_SEL_SET, 0x00); 3198 snd_hda_codec_write(codec, spec->out_pins[0], 0, 3199 AC_VERB_SET_EAPD_BTLENABLE, 0x00); 3200 snd_hda_codec_write(codec, spec->out_pins[1], 0, 3201 VENDOR_CHIPIO_EAPD_SEL_SET, 0x02); 3202 snd_hda_codec_write(codec, spec->out_pins[0], 0, 3203 AC_VERB_SET_EAPD_BTLENABLE, 0x02); 3204 3205 /* disable speaker*/ 3206 pin_ctl = snd_hda_codec_read(codec, spec->out_pins[0], 0, 3207 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3208 snd_hda_set_pin_ctl(codec, spec->out_pins[0], 3209 pin_ctl & ~PIN_HP); 3210 /* enable headphone*/ 3211 pin_ctl = snd_hda_codec_read(codec, spec->out_pins[1], 0, 3212 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3213 snd_hda_set_pin_ctl(codec, spec->out_pins[1], 3214 pin_ctl | PIN_HP); 3215 } 3216 3217 exit: 3218 snd_hda_power_down_pm(codec); 3219 3220 return err < 0 ? err : 0; 3221 } 3222 3223 static void ca0132_unsol_hp_delayed(struct work_struct *work) 3224 { 3225 struct ca0132_spec *spec = container_of( 3226 to_delayed_work(work), struct ca0132_spec, unsol_hp_work); 3227 struct hda_jack_tbl *jack; 3228 3229 ca0132_select_out(spec->codec); 3230 jack = snd_hda_jack_tbl_get(spec->codec, UNSOL_TAG_HP); 3231 if (jack) { 3232 jack->block_report = 0; 3233 snd_hda_jack_report_sync(spec->codec); 3234 } 3235 } 3236 3237 static void ca0132_set_dmic(struct hda_codec *codec, int enable); 3238 static int ca0132_mic_boost_set(struct hda_codec *codec, long val); 3239 static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val); 3240 3241 /* 3242 * Select the active VIP source 3243 */ 3244 static int ca0132_set_vipsource(struct hda_codec *codec, int val) 3245 { 3246 struct ca0132_spec *spec = codec->spec; 3247 unsigned int tmp; 3248 3249 if (spec->dsp_state != DSP_DOWNLOADED) 3250 return 0; 3251 3252 /* if CrystalVoice if off, vipsource should be 0 */ 3253 if (!spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] || 3254 (val == 0)) { 3255 chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, 0); 3256 chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000); 3257 chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000); 3258 if (spec->cur_mic_type == DIGITAL_MIC) 3259 tmp = FLOAT_TWO; 3260 else 3261 tmp = FLOAT_ONE; 3262 dspio_set_uint_param(codec, 0x80, 0x00, tmp); 3263 tmp = FLOAT_ZERO; 3264 dspio_set_uint_param(codec, 0x80, 0x05, tmp); 3265 } else { 3266 chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_16_000); 3267 chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_16_000); 3268 if (spec->cur_mic_type == DIGITAL_MIC) 3269 tmp = FLOAT_TWO; 3270 else 3271 tmp = FLOAT_ONE; 3272 dspio_set_uint_param(codec, 0x80, 0x00, tmp); 3273 tmp = FLOAT_ONE; 3274 dspio_set_uint_param(codec, 0x80, 0x05, tmp); 3275 msleep(20); 3276 chipio_set_control_param(codec, CONTROL_PARAM_VIP_SOURCE, val); 3277 } 3278 3279 return 1; 3280 } 3281 3282 /* 3283 * Select the active microphone. 3284 * If autodetect is enabled, mic will be selected based on jack detection. 3285 * If jack inserted, ext.mic will be selected, else built-in mic 3286 * If autodetect is disabled, mic will be selected based on selection. 3287 */ 3288 static int ca0132_select_mic(struct hda_codec *codec) 3289 { 3290 struct ca0132_spec *spec = codec->spec; 3291 int jack_present; 3292 int auto_jack; 3293 3294 codec_dbg(codec, "ca0132_select_mic\n"); 3295 3296 snd_hda_power_up_pm(codec); 3297 3298 auto_jack = spec->vnode_lswitch[VNID_AMIC1_ASEL - VNODE_START_NID]; 3299 3300 if (auto_jack) 3301 jack_present = snd_hda_jack_detect(codec, spec->input_pins[0]); 3302 else 3303 jack_present = 3304 spec->vnode_lswitch[VNID_AMIC1_SEL - VNODE_START_NID]; 3305 3306 if (jack_present) 3307 spec->cur_mic_type = LINE_MIC_IN; 3308 else 3309 spec->cur_mic_type = DIGITAL_MIC; 3310 3311 if (spec->cur_mic_type == DIGITAL_MIC) { 3312 /* enable digital Mic */ 3313 chipio_set_conn_rate(codec, MEM_CONNID_DMIC, SR_32_000); 3314 ca0132_set_dmic(codec, 1); 3315 ca0132_mic_boost_set(codec, 0); 3316 /* set voice focus */ 3317 ca0132_effects_set(codec, VOICE_FOCUS, 3318 spec->effects_switch 3319 [VOICE_FOCUS - EFFECT_START_NID]); 3320 } else { 3321 /* disable digital Mic */ 3322 chipio_set_conn_rate(codec, MEM_CONNID_DMIC, SR_96_000); 3323 ca0132_set_dmic(codec, 0); 3324 ca0132_mic_boost_set(codec, spec->cur_mic_boost); 3325 /* disable voice focus */ 3326 ca0132_effects_set(codec, VOICE_FOCUS, 0); 3327 } 3328 3329 snd_hda_power_down_pm(codec); 3330 3331 return 0; 3332 } 3333 3334 /* 3335 * Check if VNODE settings take effect immediately. 3336 */ 3337 static bool ca0132_is_vnode_effective(struct hda_codec *codec, 3338 hda_nid_t vnid, 3339 hda_nid_t *shared_nid) 3340 { 3341 struct ca0132_spec *spec = codec->spec; 3342 hda_nid_t nid; 3343 3344 switch (vnid) { 3345 case VNID_SPK: 3346 nid = spec->shared_out_nid; 3347 break; 3348 case VNID_MIC: 3349 nid = spec->shared_mic_nid; 3350 break; 3351 default: 3352 return false; 3353 } 3354 3355 if (shared_nid) 3356 *shared_nid = nid; 3357 3358 return true; 3359 } 3360 3361 /* 3362 * The following functions are control change helpers. 3363 * They return 0 if no changed. Return 1 if changed. 3364 */ 3365 static int ca0132_voicefx_set(struct hda_codec *codec, int enable) 3366 { 3367 struct ca0132_spec *spec = codec->spec; 3368 unsigned int tmp; 3369 3370 /* based on CrystalVoice state to enable VoiceFX. */ 3371 if (enable) { 3372 tmp = spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] ? 3373 FLOAT_ONE : FLOAT_ZERO; 3374 } else { 3375 tmp = FLOAT_ZERO; 3376 } 3377 3378 dspio_set_uint_param(codec, ca0132_voicefx.mid, 3379 ca0132_voicefx.reqs[0], tmp); 3380 3381 return 1; 3382 } 3383 3384 /* 3385 * Set the effects parameters 3386 */ 3387 static int ca0132_effects_set(struct hda_codec *codec, hda_nid_t nid, long val) 3388 { 3389 struct ca0132_spec *spec = codec->spec; 3390 unsigned int on; 3391 int num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT; 3392 int err = 0; 3393 int idx = nid - EFFECT_START_NID; 3394 3395 if ((idx < 0) || (idx >= num_fx)) 3396 return 0; /* no changed */ 3397 3398 /* for out effect, qualify with PE */ 3399 if ((nid >= OUT_EFFECT_START_NID) && (nid < OUT_EFFECT_END_NID)) { 3400 /* if PE if off, turn off out effects. */ 3401 if (!spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID]) 3402 val = 0; 3403 } 3404 3405 /* for in effect, qualify with CrystalVoice */ 3406 if ((nid >= IN_EFFECT_START_NID) && (nid < IN_EFFECT_END_NID)) { 3407 /* if CrystalVoice if off, turn off in effects. */ 3408 if (!spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID]) 3409 val = 0; 3410 3411 /* Voice Focus applies to 2-ch Mic, Digital Mic */ 3412 if ((nid == VOICE_FOCUS) && (spec->cur_mic_type != DIGITAL_MIC)) 3413 val = 0; 3414 } 3415 3416 codec_dbg(codec, "ca0132_effect_set: nid=0x%x, val=%ld\n", 3417 nid, val); 3418 3419 on = (val == 0) ? FLOAT_ZERO : FLOAT_ONE; 3420 err = dspio_set_uint_param(codec, ca0132_effects[idx].mid, 3421 ca0132_effects[idx].reqs[0], on); 3422 3423 if (err < 0) 3424 return 0; /* no changed */ 3425 3426 return 1; 3427 } 3428 3429 /* 3430 * Turn on/off Playback Enhancements 3431 */ 3432 static int ca0132_pe_switch_set(struct hda_codec *codec) 3433 { 3434 struct ca0132_spec *spec = codec->spec; 3435 hda_nid_t nid; 3436 int i, ret = 0; 3437 3438 codec_dbg(codec, "ca0132_pe_switch_set: val=%ld\n", 3439 spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID]); 3440 3441 i = OUT_EFFECT_START_NID - EFFECT_START_NID; 3442 nid = OUT_EFFECT_START_NID; 3443 /* PE affects all out effects */ 3444 for (; nid < OUT_EFFECT_END_NID; nid++, i++) 3445 ret |= ca0132_effects_set(codec, nid, spec->effects_switch[i]); 3446 3447 return ret; 3448 } 3449 3450 /* Check if Mic1 is streaming, if so, stop streaming */ 3451 static int stop_mic1(struct hda_codec *codec) 3452 { 3453 struct ca0132_spec *spec = codec->spec; 3454 unsigned int oldval = snd_hda_codec_read(codec, spec->adcs[0], 0, 3455 AC_VERB_GET_CONV, 0); 3456 if (oldval != 0) 3457 snd_hda_codec_write(codec, spec->adcs[0], 0, 3458 AC_VERB_SET_CHANNEL_STREAMID, 3459 0); 3460 return oldval; 3461 } 3462 3463 /* Resume Mic1 streaming if it was stopped. */ 3464 static void resume_mic1(struct hda_codec *codec, unsigned int oldval) 3465 { 3466 struct ca0132_spec *spec = codec->spec; 3467 /* Restore the previous stream and channel */ 3468 if (oldval != 0) 3469 snd_hda_codec_write(codec, spec->adcs[0], 0, 3470 AC_VERB_SET_CHANNEL_STREAMID, 3471 oldval); 3472 } 3473 3474 /* 3475 * Turn on/off CrystalVoice 3476 */ 3477 static int ca0132_cvoice_switch_set(struct hda_codec *codec) 3478 { 3479 struct ca0132_spec *spec = codec->spec; 3480 hda_nid_t nid; 3481 int i, ret = 0; 3482 unsigned int oldval; 3483 3484 codec_dbg(codec, "ca0132_cvoice_switch_set: val=%ld\n", 3485 spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID]); 3486 3487 i = IN_EFFECT_START_NID - EFFECT_START_NID; 3488 nid = IN_EFFECT_START_NID; 3489 /* CrystalVoice affects all in effects */ 3490 for (; nid < IN_EFFECT_END_NID; nid++, i++) 3491 ret |= ca0132_effects_set(codec, nid, spec->effects_switch[i]); 3492 3493 /* including VoiceFX */ 3494 ret |= ca0132_voicefx_set(codec, (spec->voicefx_val ? 1 : 0)); 3495 3496 /* set correct vipsource */ 3497 oldval = stop_mic1(codec); 3498 ret |= ca0132_set_vipsource(codec, 1); 3499 resume_mic1(codec, oldval); 3500 return ret; 3501 } 3502 3503 static int ca0132_mic_boost_set(struct hda_codec *codec, long val) 3504 { 3505 struct ca0132_spec *spec = codec->spec; 3506 int ret = 0; 3507 3508 if (val) /* on */ 3509 ret = snd_hda_codec_amp_update(codec, spec->input_pins[0], 0, 3510 HDA_INPUT, 0, HDA_AMP_VOLMASK, 3); 3511 else /* off */ 3512 ret = snd_hda_codec_amp_update(codec, spec->input_pins[0], 0, 3513 HDA_INPUT, 0, HDA_AMP_VOLMASK, 0); 3514 3515 return ret; 3516 } 3517 3518 static int ca0132_vnode_switch_set(struct snd_kcontrol *kcontrol, 3519 struct snd_ctl_elem_value *ucontrol) 3520 { 3521 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3522 hda_nid_t nid = get_amp_nid(kcontrol); 3523 hda_nid_t shared_nid = 0; 3524 bool effective; 3525 int ret = 0; 3526 struct ca0132_spec *spec = codec->spec; 3527 int auto_jack; 3528 3529 if (nid == VNID_HP_SEL) { 3530 auto_jack = 3531 spec->vnode_lswitch[VNID_HP_ASEL - VNODE_START_NID]; 3532 if (!auto_jack) 3533 ca0132_select_out(codec); 3534 return 1; 3535 } 3536 3537 if (nid == VNID_AMIC1_SEL) { 3538 auto_jack = 3539 spec->vnode_lswitch[VNID_AMIC1_ASEL - VNODE_START_NID]; 3540 if (!auto_jack) 3541 ca0132_select_mic(codec); 3542 return 1; 3543 } 3544 3545 if (nid == VNID_HP_ASEL) { 3546 ca0132_select_out(codec); 3547 return 1; 3548 } 3549 3550 if (nid == VNID_AMIC1_ASEL) { 3551 ca0132_select_mic(codec); 3552 return 1; 3553 } 3554 3555 /* if effective conditions, then update hw immediately. */ 3556 effective = ca0132_is_vnode_effective(codec, nid, &shared_nid); 3557 if (effective) { 3558 int dir = get_amp_direction(kcontrol); 3559 int ch = get_amp_channels(kcontrol); 3560 unsigned long pval; 3561 3562 mutex_lock(&codec->control_mutex); 3563 pval = kcontrol->private_value; 3564 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(shared_nid, ch, 3565 0, dir); 3566 ret = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 3567 kcontrol->private_value = pval; 3568 mutex_unlock(&codec->control_mutex); 3569 } 3570 3571 return ret; 3572 } 3573 /* End of control change helpers. */ 3574 3575 static int ca0132_voicefx_info(struct snd_kcontrol *kcontrol, 3576 struct snd_ctl_elem_info *uinfo) 3577 { 3578 unsigned int items = sizeof(ca0132_voicefx_presets) 3579 / sizeof(struct ct_voicefx_preset); 3580 3581 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3582 uinfo->count = 1; 3583 uinfo->value.enumerated.items = items; 3584 if (uinfo->value.enumerated.item >= items) 3585 uinfo->value.enumerated.item = items - 1; 3586 strcpy(uinfo->value.enumerated.name, 3587 ca0132_voicefx_presets[uinfo->value.enumerated.item].name); 3588 return 0; 3589 } 3590 3591 static int ca0132_voicefx_get(struct snd_kcontrol *kcontrol, 3592 struct snd_ctl_elem_value *ucontrol) 3593 { 3594 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3595 struct ca0132_spec *spec = codec->spec; 3596 3597 ucontrol->value.enumerated.item[0] = spec->voicefx_val; 3598 return 0; 3599 } 3600 3601 static int ca0132_voicefx_put(struct snd_kcontrol *kcontrol, 3602 struct snd_ctl_elem_value *ucontrol) 3603 { 3604 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3605 struct ca0132_spec *spec = codec->spec; 3606 int i, err = 0; 3607 int sel = ucontrol->value.enumerated.item[0]; 3608 unsigned int items = sizeof(ca0132_voicefx_presets) 3609 / sizeof(struct ct_voicefx_preset); 3610 3611 if (sel >= items) 3612 return 0; 3613 3614 codec_dbg(codec, "ca0132_voicefx_put: sel=%d, preset=%s\n", 3615 sel, ca0132_voicefx_presets[sel].name); 3616 3617 /* 3618 * Idx 0 is default. 3619 * Default needs to qualify with CrystalVoice state. 3620 */ 3621 for (i = 0; i < VOICEFX_MAX_PARAM_COUNT; i++) { 3622 err = dspio_set_uint_param(codec, ca0132_voicefx.mid, 3623 ca0132_voicefx.reqs[i], 3624 ca0132_voicefx_presets[sel].vals[i]); 3625 if (err < 0) 3626 break; 3627 } 3628 3629 if (err >= 0) { 3630 spec->voicefx_val = sel; 3631 /* enable voice fx */ 3632 ca0132_voicefx_set(codec, (sel ? 1 : 0)); 3633 } 3634 3635 return 1; 3636 } 3637 3638 static int ca0132_switch_get(struct snd_kcontrol *kcontrol, 3639 struct snd_ctl_elem_value *ucontrol) 3640 { 3641 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3642 struct ca0132_spec *spec = codec->spec; 3643 hda_nid_t nid = get_amp_nid(kcontrol); 3644 int ch = get_amp_channels(kcontrol); 3645 long *valp = ucontrol->value.integer.value; 3646 3647 /* vnode */ 3648 if ((nid >= VNODE_START_NID) && (nid < VNODE_END_NID)) { 3649 if (ch & 1) { 3650 *valp = spec->vnode_lswitch[nid - VNODE_START_NID]; 3651 valp++; 3652 } 3653 if (ch & 2) { 3654 *valp = spec->vnode_rswitch[nid - VNODE_START_NID]; 3655 valp++; 3656 } 3657 return 0; 3658 } 3659 3660 /* effects, include PE and CrystalVoice */ 3661 if ((nid >= EFFECT_START_NID) && (nid < EFFECT_END_NID)) { 3662 *valp = spec->effects_switch[nid - EFFECT_START_NID]; 3663 return 0; 3664 } 3665 3666 /* mic boost */ 3667 if (nid == spec->input_pins[0]) { 3668 *valp = spec->cur_mic_boost; 3669 return 0; 3670 } 3671 3672 return 0; 3673 } 3674 3675 static int ca0132_switch_put(struct snd_kcontrol *kcontrol, 3676 struct snd_ctl_elem_value *ucontrol) 3677 { 3678 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3679 struct ca0132_spec *spec = codec->spec; 3680 hda_nid_t nid = get_amp_nid(kcontrol); 3681 int ch = get_amp_channels(kcontrol); 3682 long *valp = ucontrol->value.integer.value; 3683 int changed = 1; 3684 3685 codec_dbg(codec, "ca0132_switch_put: nid=0x%x, val=%ld\n", 3686 nid, *valp); 3687 3688 snd_hda_power_up(codec); 3689 /* vnode */ 3690 if ((nid >= VNODE_START_NID) && (nid < VNODE_END_NID)) { 3691 if (ch & 1) { 3692 spec->vnode_lswitch[nid - VNODE_START_NID] = *valp; 3693 valp++; 3694 } 3695 if (ch & 2) { 3696 spec->vnode_rswitch[nid - VNODE_START_NID] = *valp; 3697 valp++; 3698 } 3699 changed = ca0132_vnode_switch_set(kcontrol, ucontrol); 3700 goto exit; 3701 } 3702 3703 /* PE */ 3704 if (nid == PLAY_ENHANCEMENT) { 3705 spec->effects_switch[nid - EFFECT_START_NID] = *valp; 3706 changed = ca0132_pe_switch_set(codec); 3707 goto exit; 3708 } 3709 3710 /* CrystalVoice */ 3711 if (nid == CRYSTAL_VOICE) { 3712 spec->effects_switch[nid - EFFECT_START_NID] = *valp; 3713 changed = ca0132_cvoice_switch_set(codec); 3714 goto exit; 3715 } 3716 3717 /* out and in effects */ 3718 if (((nid >= OUT_EFFECT_START_NID) && (nid < OUT_EFFECT_END_NID)) || 3719 ((nid >= IN_EFFECT_START_NID) && (nid < IN_EFFECT_END_NID))) { 3720 spec->effects_switch[nid - EFFECT_START_NID] = *valp; 3721 changed = ca0132_effects_set(codec, nid, *valp); 3722 goto exit; 3723 } 3724 3725 /* mic boost */ 3726 if (nid == spec->input_pins[0]) { 3727 spec->cur_mic_boost = *valp; 3728 3729 /* Mic boost does not apply to Digital Mic */ 3730 if (spec->cur_mic_type != DIGITAL_MIC) 3731 changed = ca0132_mic_boost_set(codec, *valp); 3732 goto exit; 3733 } 3734 3735 exit: 3736 snd_hda_power_down(codec); 3737 return changed; 3738 } 3739 3740 /* 3741 * Volume related 3742 */ 3743 static int ca0132_volume_info(struct snd_kcontrol *kcontrol, 3744 struct snd_ctl_elem_info *uinfo) 3745 { 3746 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3747 struct ca0132_spec *spec = codec->spec; 3748 hda_nid_t nid = get_amp_nid(kcontrol); 3749 int ch = get_amp_channels(kcontrol); 3750 int dir = get_amp_direction(kcontrol); 3751 unsigned long pval; 3752 int err; 3753 3754 switch (nid) { 3755 case VNID_SPK: 3756 /* follow shared_out info */ 3757 nid = spec->shared_out_nid; 3758 mutex_lock(&codec->control_mutex); 3759 pval = kcontrol->private_value; 3760 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir); 3761 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo); 3762 kcontrol->private_value = pval; 3763 mutex_unlock(&codec->control_mutex); 3764 break; 3765 case VNID_MIC: 3766 /* follow shared_mic info */ 3767 nid = spec->shared_mic_nid; 3768 mutex_lock(&codec->control_mutex); 3769 pval = kcontrol->private_value; 3770 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir); 3771 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo); 3772 kcontrol->private_value = pval; 3773 mutex_unlock(&codec->control_mutex); 3774 break; 3775 default: 3776 err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo); 3777 } 3778 return err; 3779 } 3780 3781 static int ca0132_volume_get(struct snd_kcontrol *kcontrol, 3782 struct snd_ctl_elem_value *ucontrol) 3783 { 3784 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3785 struct ca0132_spec *spec = codec->spec; 3786 hda_nid_t nid = get_amp_nid(kcontrol); 3787 int ch = get_amp_channels(kcontrol); 3788 long *valp = ucontrol->value.integer.value; 3789 3790 /* store the left and right volume */ 3791 if (ch & 1) { 3792 *valp = spec->vnode_lvol[nid - VNODE_START_NID]; 3793 valp++; 3794 } 3795 if (ch & 2) { 3796 *valp = spec->vnode_rvol[nid - VNODE_START_NID]; 3797 valp++; 3798 } 3799 return 0; 3800 } 3801 3802 static int ca0132_volume_put(struct snd_kcontrol *kcontrol, 3803 struct snd_ctl_elem_value *ucontrol) 3804 { 3805 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3806 struct ca0132_spec *spec = codec->spec; 3807 hda_nid_t nid = get_amp_nid(kcontrol); 3808 int ch = get_amp_channels(kcontrol); 3809 long *valp = ucontrol->value.integer.value; 3810 hda_nid_t shared_nid = 0; 3811 bool effective; 3812 int changed = 1; 3813 3814 /* store the left and right volume */ 3815 if (ch & 1) { 3816 spec->vnode_lvol[nid - VNODE_START_NID] = *valp; 3817 valp++; 3818 } 3819 if (ch & 2) { 3820 spec->vnode_rvol[nid - VNODE_START_NID] = *valp; 3821 valp++; 3822 } 3823 3824 /* if effective conditions, then update hw immediately. */ 3825 effective = ca0132_is_vnode_effective(codec, nid, &shared_nid); 3826 if (effective) { 3827 int dir = get_amp_direction(kcontrol); 3828 unsigned long pval; 3829 3830 snd_hda_power_up(codec); 3831 mutex_lock(&codec->control_mutex); 3832 pval = kcontrol->private_value; 3833 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(shared_nid, ch, 3834 0, dir); 3835 changed = snd_hda_mixer_amp_volume_put(kcontrol, ucontrol); 3836 kcontrol->private_value = pval; 3837 mutex_unlock(&codec->control_mutex); 3838 snd_hda_power_down(codec); 3839 } 3840 3841 return changed; 3842 } 3843 3844 static int ca0132_volume_tlv(struct snd_kcontrol *kcontrol, int op_flag, 3845 unsigned int size, unsigned int __user *tlv) 3846 { 3847 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3848 struct ca0132_spec *spec = codec->spec; 3849 hda_nid_t nid = get_amp_nid(kcontrol); 3850 int ch = get_amp_channels(kcontrol); 3851 int dir = get_amp_direction(kcontrol); 3852 unsigned long pval; 3853 int err; 3854 3855 switch (nid) { 3856 case VNID_SPK: 3857 /* follow shared_out tlv */ 3858 nid = spec->shared_out_nid; 3859 mutex_lock(&codec->control_mutex); 3860 pval = kcontrol->private_value; 3861 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir); 3862 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv); 3863 kcontrol->private_value = pval; 3864 mutex_unlock(&codec->control_mutex); 3865 break; 3866 case VNID_MIC: 3867 /* follow shared_mic tlv */ 3868 nid = spec->shared_mic_nid; 3869 mutex_lock(&codec->control_mutex); 3870 pval = kcontrol->private_value; 3871 kcontrol->private_value = HDA_COMPOSE_AMP_VAL(nid, ch, 0, dir); 3872 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv); 3873 kcontrol->private_value = pval; 3874 mutex_unlock(&codec->control_mutex); 3875 break; 3876 default: 3877 err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv); 3878 } 3879 return err; 3880 } 3881 3882 static int add_fx_switch(struct hda_codec *codec, hda_nid_t nid, 3883 const char *pfx, int dir) 3884 { 3885 char namestr[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 3886 int type = dir ? HDA_INPUT : HDA_OUTPUT; 3887 struct snd_kcontrol_new knew = 3888 CA0132_CODEC_MUTE_MONO(namestr, nid, 1, type); 3889 sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]); 3890 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec)); 3891 } 3892 3893 static int add_voicefx(struct hda_codec *codec) 3894 { 3895 struct snd_kcontrol_new knew = 3896 HDA_CODEC_MUTE_MONO(ca0132_voicefx.name, 3897 VOICEFX, 1, 0, HDA_INPUT); 3898 knew.info = ca0132_voicefx_info; 3899 knew.get = ca0132_voicefx_get; 3900 knew.put = ca0132_voicefx_put; 3901 return snd_hda_ctl_add(codec, VOICEFX, snd_ctl_new1(&knew, codec)); 3902 } 3903 3904 /* 3905 * When changing Node IDs for Mixer Controls below, make sure to update 3906 * Node IDs in ca0132_config() as well. 3907 */ 3908 static struct snd_kcontrol_new ca0132_mixer[] = { 3909 CA0132_CODEC_VOL("Master Playback Volume", VNID_SPK, HDA_OUTPUT), 3910 CA0132_CODEC_MUTE("Master Playback Switch", VNID_SPK, HDA_OUTPUT), 3911 CA0132_CODEC_VOL("Capture Volume", VNID_MIC, HDA_INPUT), 3912 CA0132_CODEC_MUTE("Capture Switch", VNID_MIC, HDA_INPUT), 3913 HDA_CODEC_VOLUME("Analog-Mic2 Capture Volume", 0x08, 0, HDA_INPUT), 3914 HDA_CODEC_MUTE("Analog-Mic2 Capture Switch", 0x08, 0, HDA_INPUT), 3915 HDA_CODEC_VOLUME("What U Hear Capture Volume", 0x0a, 0, HDA_INPUT), 3916 HDA_CODEC_MUTE("What U Hear Capture Switch", 0x0a, 0, HDA_INPUT), 3917 CA0132_CODEC_MUTE_MONO("Mic1-Boost (30dB) Capture Switch", 3918 0x12, 1, HDA_INPUT), 3919 CA0132_CODEC_MUTE_MONO("HP/Speaker Playback Switch", 3920 VNID_HP_SEL, 1, HDA_OUTPUT), 3921 CA0132_CODEC_MUTE_MONO("AMic1/DMic Capture Switch", 3922 VNID_AMIC1_SEL, 1, HDA_INPUT), 3923 CA0132_CODEC_MUTE_MONO("HP/Speaker Auto Detect Playback Switch", 3924 VNID_HP_ASEL, 1, HDA_OUTPUT), 3925 CA0132_CODEC_MUTE_MONO("AMic1/DMic Auto Detect Capture Switch", 3926 VNID_AMIC1_ASEL, 1, HDA_INPUT), 3927 { } /* end */ 3928 }; 3929 3930 static int ca0132_build_controls(struct hda_codec *codec) 3931 { 3932 struct ca0132_spec *spec = codec->spec; 3933 int i, num_fx; 3934 int err = 0; 3935 3936 /* Add Mixer controls */ 3937 for (i = 0; i < spec->num_mixers; i++) { 3938 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 3939 if (err < 0) 3940 return err; 3941 } 3942 3943 /* Add in and out effects controls. 3944 * VoiceFX, PE and CrystalVoice are added separately. 3945 */ 3946 num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT; 3947 for (i = 0; i < num_fx; i++) { 3948 err = add_fx_switch(codec, ca0132_effects[i].nid, 3949 ca0132_effects[i].name, 3950 ca0132_effects[i].direct); 3951 if (err < 0) 3952 return err; 3953 } 3954 3955 err = add_fx_switch(codec, PLAY_ENHANCEMENT, "PlayEnhancement", 0); 3956 if (err < 0) 3957 return err; 3958 3959 err = add_fx_switch(codec, CRYSTAL_VOICE, "CrystalVoice", 1); 3960 if (err < 0) 3961 return err; 3962 3963 add_voicefx(codec); 3964 3965 #ifdef ENABLE_TUNING_CONTROLS 3966 add_tuning_ctls(codec); 3967 #endif 3968 3969 err = snd_hda_jack_add_kctls(codec, &spec->autocfg); 3970 if (err < 0) 3971 return err; 3972 3973 if (spec->dig_out) { 3974 err = snd_hda_create_spdif_out_ctls(codec, spec->dig_out, 3975 spec->dig_out); 3976 if (err < 0) 3977 return err; 3978 err = snd_hda_create_spdif_share_sw(codec, &spec->multiout); 3979 if (err < 0) 3980 return err; 3981 /* spec->multiout.share_spdif = 1; */ 3982 } 3983 3984 if (spec->dig_in) { 3985 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in); 3986 if (err < 0) 3987 return err; 3988 } 3989 return 0; 3990 } 3991 3992 /* 3993 * PCM 3994 */ 3995 static struct hda_pcm_stream ca0132_pcm_analog_playback = { 3996 .substreams = 1, 3997 .channels_min = 2, 3998 .channels_max = 6, 3999 .ops = { 4000 .prepare = ca0132_playback_pcm_prepare, 4001 .cleanup = ca0132_playback_pcm_cleanup, 4002 .get_delay = ca0132_playback_pcm_delay, 4003 }, 4004 }; 4005 4006 static struct hda_pcm_stream ca0132_pcm_analog_capture = { 4007 .substreams = 1, 4008 .channels_min = 2, 4009 .channels_max = 2, 4010 .ops = { 4011 .prepare = ca0132_capture_pcm_prepare, 4012 .cleanup = ca0132_capture_pcm_cleanup, 4013 .get_delay = ca0132_capture_pcm_delay, 4014 }, 4015 }; 4016 4017 static struct hda_pcm_stream ca0132_pcm_digital_playback = { 4018 .substreams = 1, 4019 .channels_min = 2, 4020 .channels_max = 2, 4021 .ops = { 4022 .open = ca0132_dig_playback_pcm_open, 4023 .close = ca0132_dig_playback_pcm_close, 4024 .prepare = ca0132_dig_playback_pcm_prepare, 4025 .cleanup = ca0132_dig_playback_pcm_cleanup 4026 }, 4027 }; 4028 4029 static struct hda_pcm_stream ca0132_pcm_digital_capture = { 4030 .substreams = 1, 4031 .channels_min = 2, 4032 .channels_max = 2, 4033 }; 4034 4035 static int ca0132_build_pcms(struct hda_codec *codec) 4036 { 4037 struct ca0132_spec *spec = codec->spec; 4038 struct hda_pcm *info; 4039 4040 info = snd_hda_codec_pcm_new(codec, "CA0132 Analog"); 4041 if (!info) 4042 return -ENOMEM; 4043 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ca0132_pcm_analog_playback; 4044 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dacs[0]; 4045 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 4046 spec->multiout.max_channels; 4047 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture; 4048 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1; 4049 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[0]; 4050 4051 info = snd_hda_codec_pcm_new(codec, "CA0132 Analog Mic-In2"); 4052 if (!info) 4053 return -ENOMEM; 4054 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture; 4055 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1; 4056 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[1]; 4057 4058 info = snd_hda_codec_pcm_new(codec, "CA0132 What U Hear"); 4059 if (!info) 4060 return -ENOMEM; 4061 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture; 4062 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = 1; 4063 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[2]; 4064 4065 if (!spec->dig_out && !spec->dig_in) 4066 return 0; 4067 4068 info = snd_hda_codec_pcm_new(codec, "CA0132 Digital"); 4069 if (!info) 4070 return -ENOMEM; 4071 info->pcm_type = HDA_PCM_TYPE_SPDIF; 4072 if (spec->dig_out) { 4073 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = 4074 ca0132_pcm_digital_playback; 4075 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dig_out; 4076 } 4077 if (spec->dig_in) { 4078 info->stream[SNDRV_PCM_STREAM_CAPTURE] = 4079 ca0132_pcm_digital_capture; 4080 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in; 4081 } 4082 4083 return 0; 4084 } 4085 4086 static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac) 4087 { 4088 if (pin) { 4089 snd_hda_set_pin_ctl(codec, pin, PIN_HP); 4090 if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP) 4091 snd_hda_codec_write(codec, pin, 0, 4092 AC_VERB_SET_AMP_GAIN_MUTE, 4093 AMP_OUT_UNMUTE); 4094 } 4095 if (dac && (get_wcaps(codec, dac) & AC_WCAP_OUT_AMP)) 4096 snd_hda_codec_write(codec, dac, 0, 4097 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO); 4098 } 4099 4100 static void init_input(struct hda_codec *codec, hda_nid_t pin, hda_nid_t adc) 4101 { 4102 if (pin) { 4103 snd_hda_set_pin_ctl(codec, pin, PIN_VREF80); 4104 if (get_wcaps(codec, pin) & AC_WCAP_IN_AMP) 4105 snd_hda_codec_write(codec, pin, 0, 4106 AC_VERB_SET_AMP_GAIN_MUTE, 4107 AMP_IN_UNMUTE(0)); 4108 } 4109 if (adc && (get_wcaps(codec, adc) & AC_WCAP_IN_AMP)) { 4110 snd_hda_codec_write(codec, adc, 0, AC_VERB_SET_AMP_GAIN_MUTE, 4111 AMP_IN_UNMUTE(0)); 4112 4113 /* init to 0 dB and unmute. */ 4114 snd_hda_codec_amp_stereo(codec, adc, HDA_INPUT, 0, 4115 HDA_AMP_VOLMASK, 0x5a); 4116 snd_hda_codec_amp_stereo(codec, adc, HDA_INPUT, 0, 4117 HDA_AMP_MUTE, 0); 4118 } 4119 } 4120 4121 static void refresh_amp_caps(struct hda_codec *codec, hda_nid_t nid, int dir) 4122 { 4123 unsigned int caps; 4124 4125 caps = snd_hda_param_read(codec, nid, dir == HDA_OUTPUT ? 4126 AC_PAR_AMP_OUT_CAP : AC_PAR_AMP_IN_CAP); 4127 snd_hda_override_amp_caps(codec, nid, dir, caps); 4128 } 4129 4130 /* 4131 * Switch between Digital built-in mic and analog mic. 4132 */ 4133 static void ca0132_set_dmic(struct hda_codec *codec, int enable) 4134 { 4135 struct ca0132_spec *spec = codec->spec; 4136 unsigned int tmp; 4137 u8 val; 4138 unsigned int oldval; 4139 4140 codec_dbg(codec, "ca0132_set_dmic: enable=%d\n", enable); 4141 4142 oldval = stop_mic1(codec); 4143 ca0132_set_vipsource(codec, 0); 4144 if (enable) { 4145 /* set DMic input as 2-ch */ 4146 tmp = FLOAT_TWO; 4147 dspio_set_uint_param(codec, 0x80, 0x00, tmp); 4148 4149 val = spec->dmic_ctl; 4150 val |= 0x80; 4151 snd_hda_codec_write(codec, spec->input_pins[0], 0, 4152 VENDOR_CHIPIO_DMIC_CTL_SET, val); 4153 4154 if (!(spec->dmic_ctl & 0x20)) 4155 chipio_set_control_flag(codec, CONTROL_FLAG_DMIC, 1); 4156 } else { 4157 /* set AMic input as mono */ 4158 tmp = FLOAT_ONE; 4159 dspio_set_uint_param(codec, 0x80, 0x00, tmp); 4160 4161 val = spec->dmic_ctl; 4162 /* clear bit7 and bit5 to disable dmic */ 4163 val &= 0x5f; 4164 snd_hda_codec_write(codec, spec->input_pins[0], 0, 4165 VENDOR_CHIPIO_DMIC_CTL_SET, val); 4166 4167 if (!(spec->dmic_ctl & 0x20)) 4168 chipio_set_control_flag(codec, CONTROL_FLAG_DMIC, 0); 4169 } 4170 ca0132_set_vipsource(codec, 1); 4171 resume_mic1(codec, oldval); 4172 } 4173 4174 /* 4175 * Initialization for Digital Mic. 4176 */ 4177 static void ca0132_init_dmic(struct hda_codec *codec) 4178 { 4179 struct ca0132_spec *spec = codec->spec; 4180 u8 val; 4181 4182 /* Setup Digital Mic here, but don't enable. 4183 * Enable based on jack detect. 4184 */ 4185 4186 /* MCLK uses MPIO1, set to enable. 4187 * Bit 2-0: MPIO select 4188 * Bit 3: set to disable 4189 * Bit 7-4: reserved 4190 */ 4191 val = 0x01; 4192 snd_hda_codec_write(codec, spec->input_pins[0], 0, 4193 VENDOR_CHIPIO_DMIC_MCLK_SET, val); 4194 4195 /* Data1 uses MPIO3. Data2 not use 4196 * Bit 2-0: Data1 MPIO select 4197 * Bit 3: set disable Data1 4198 * Bit 6-4: Data2 MPIO select 4199 * Bit 7: set disable Data2 4200 */ 4201 val = 0x83; 4202 snd_hda_codec_write(codec, spec->input_pins[0], 0, 4203 VENDOR_CHIPIO_DMIC_PIN_SET, val); 4204 4205 /* Use Ch-0 and Ch-1. Rate is 48K, mode 1. Disable DMic first. 4206 * Bit 3-0: Channel mask 4207 * Bit 4: set for 48KHz, clear for 32KHz 4208 * Bit 5: mode 4209 * Bit 6: set to select Data2, clear for Data1 4210 * Bit 7: set to enable DMic, clear for AMic 4211 */ 4212 val = 0x23; 4213 /* keep a copy of dmic ctl val for enable/disable dmic purpuse */ 4214 spec->dmic_ctl = val; 4215 snd_hda_codec_write(codec, spec->input_pins[0], 0, 4216 VENDOR_CHIPIO_DMIC_CTL_SET, val); 4217 } 4218 4219 /* 4220 * Initialization for Analog Mic 2 4221 */ 4222 static void ca0132_init_analog_mic2(struct hda_codec *codec) 4223 { 4224 struct ca0132_spec *spec = codec->spec; 4225 4226 mutex_lock(&spec->chipio_mutex); 4227 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 4228 VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x20); 4229 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 4230 VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x19); 4231 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 4232 VENDOR_CHIPIO_8051_DATA_WRITE, 0x00); 4233 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 4234 VENDOR_CHIPIO_8051_ADDRESS_LOW, 0x2D); 4235 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 4236 VENDOR_CHIPIO_8051_ADDRESS_HIGH, 0x19); 4237 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, 4238 VENDOR_CHIPIO_8051_DATA_WRITE, 0x00); 4239 mutex_unlock(&spec->chipio_mutex); 4240 } 4241 4242 static void ca0132_refresh_widget_caps(struct hda_codec *codec) 4243 { 4244 struct ca0132_spec *spec = codec->spec; 4245 int i; 4246 4247 codec_dbg(codec, "ca0132_refresh_widget_caps.\n"); 4248 snd_hda_codec_update_widgets(codec); 4249 4250 for (i = 0; i < spec->multiout.num_dacs; i++) 4251 refresh_amp_caps(codec, spec->dacs[i], HDA_OUTPUT); 4252 4253 for (i = 0; i < spec->num_outputs; i++) 4254 refresh_amp_caps(codec, spec->out_pins[i], HDA_OUTPUT); 4255 4256 for (i = 0; i < spec->num_inputs; i++) { 4257 refresh_amp_caps(codec, spec->adcs[i], HDA_INPUT); 4258 refresh_amp_caps(codec, spec->input_pins[i], HDA_INPUT); 4259 } 4260 } 4261 4262 /* 4263 * Setup default parameters for DSP 4264 */ 4265 static void ca0132_setup_defaults(struct hda_codec *codec) 4266 { 4267 struct ca0132_spec *spec = codec->spec; 4268 unsigned int tmp; 4269 int num_fx; 4270 int idx, i; 4271 4272 if (spec->dsp_state != DSP_DOWNLOADED) 4273 return; 4274 4275 /* out, in effects + voicefx */ 4276 num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT + 1; 4277 for (idx = 0; idx < num_fx; idx++) { 4278 for (i = 0; i <= ca0132_effects[idx].params; i++) { 4279 dspio_set_uint_param(codec, ca0132_effects[idx].mid, 4280 ca0132_effects[idx].reqs[i], 4281 ca0132_effects[idx].def_vals[i]); 4282 } 4283 } 4284 4285 /*remove DSP headroom*/ 4286 tmp = FLOAT_ZERO; 4287 dspio_set_uint_param(codec, 0x96, 0x3C, tmp); 4288 4289 /*set speaker EQ bypass attenuation*/ 4290 dspio_set_uint_param(codec, 0x8f, 0x01, tmp); 4291 4292 /* set AMic1 and AMic2 as mono mic */ 4293 tmp = FLOAT_ONE; 4294 dspio_set_uint_param(codec, 0x80, 0x00, tmp); 4295 dspio_set_uint_param(codec, 0x80, 0x01, tmp); 4296 4297 /* set AMic1 as CrystalVoice input */ 4298 tmp = FLOAT_ONE; 4299 dspio_set_uint_param(codec, 0x80, 0x05, tmp); 4300 4301 /* set WUH source */ 4302 tmp = FLOAT_TWO; 4303 dspio_set_uint_param(codec, 0x31, 0x00, tmp); 4304 } 4305 4306 /* 4307 * Initialization of flags in chip 4308 */ 4309 static void ca0132_init_flags(struct hda_codec *codec) 4310 { 4311 chipio_set_control_flag(codec, CONTROL_FLAG_IDLE_ENABLE, 0); 4312 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_COMMON_MODE, 0); 4313 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_COMMON_MODE, 0); 4314 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_A_10KOHM_LOAD, 0); 4315 chipio_set_control_flag(codec, CONTROL_FLAG_PORT_D_10KOHM_LOAD, 0); 4316 chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_HIGH_PASS, 1); 4317 } 4318 4319 /* 4320 * Initialization of parameters in chip 4321 */ 4322 static void ca0132_init_params(struct hda_codec *codec) 4323 { 4324 chipio_set_control_param(codec, CONTROL_PARAM_PORTA_160OHM_GAIN, 6); 4325 chipio_set_control_param(codec, CONTROL_PARAM_PORTD_160OHM_GAIN, 6); 4326 } 4327 4328 static void ca0132_set_dsp_msr(struct hda_codec *codec, bool is96k) 4329 { 4330 chipio_set_control_flag(codec, CONTROL_FLAG_DSP_96KHZ, is96k); 4331 chipio_set_control_flag(codec, CONTROL_FLAG_DAC_96KHZ, is96k); 4332 chipio_set_control_flag(codec, CONTROL_FLAG_SRC_RATE_96KHZ, is96k); 4333 chipio_set_control_flag(codec, CONTROL_FLAG_SRC_CLOCK_196MHZ, is96k); 4334 chipio_set_control_flag(codec, CONTROL_FLAG_ADC_B_96KHZ, is96k); 4335 chipio_set_control_flag(codec, CONTROL_FLAG_ADC_C_96KHZ, is96k); 4336 4337 chipio_set_conn_rate(codec, MEM_CONNID_MICIN1, SR_96_000); 4338 chipio_set_conn_rate(codec, MEM_CONNID_MICOUT1, SR_96_000); 4339 chipio_set_conn_rate(codec, MEM_CONNID_WUH, SR_48_000); 4340 } 4341 4342 static bool ca0132_download_dsp_images(struct hda_codec *codec) 4343 { 4344 bool dsp_loaded = false; 4345 const struct dsp_image_seg *dsp_os_image; 4346 const struct firmware *fw_entry; 4347 4348 if (request_firmware(&fw_entry, EFX_FILE, codec->card->dev) != 0) 4349 return false; 4350 4351 dsp_os_image = (struct dsp_image_seg *)(fw_entry->data); 4352 if (dspload_image(codec, dsp_os_image, 0, 0, true, 0)) { 4353 pr_err("ca0132 dspload_image failed.\n"); 4354 goto exit_download; 4355 } 4356 4357 dsp_loaded = dspload_wait_loaded(codec); 4358 4359 exit_download: 4360 release_firmware(fw_entry); 4361 4362 return dsp_loaded; 4363 } 4364 4365 static void ca0132_download_dsp(struct hda_codec *codec) 4366 { 4367 struct ca0132_spec *spec = codec->spec; 4368 4369 #ifndef CONFIG_SND_HDA_CODEC_CA0132_DSP 4370 return; /* NOP */ 4371 #endif 4372 4373 if (spec->dsp_state == DSP_DOWNLOAD_FAILED) 4374 return; /* don't retry failures */ 4375 4376 chipio_enable_clocks(codec); 4377 spec->dsp_state = DSP_DOWNLOADING; 4378 if (!ca0132_download_dsp_images(codec)) 4379 spec->dsp_state = DSP_DOWNLOAD_FAILED; 4380 else 4381 spec->dsp_state = DSP_DOWNLOADED; 4382 4383 if (spec->dsp_state == DSP_DOWNLOADED) 4384 ca0132_set_dsp_msr(codec, true); 4385 } 4386 4387 static void ca0132_process_dsp_response(struct hda_codec *codec, 4388 struct hda_jack_callback *callback) 4389 { 4390 struct ca0132_spec *spec = codec->spec; 4391 4392 codec_dbg(codec, "ca0132_process_dsp_response\n"); 4393 if (spec->wait_scp) { 4394 if (dspio_get_response_data(codec) >= 0) 4395 spec->wait_scp = 0; 4396 } 4397 4398 dspio_clear_response_queue(codec); 4399 } 4400 4401 static void hp_callback(struct hda_codec *codec, struct hda_jack_callback *cb) 4402 { 4403 struct ca0132_spec *spec = codec->spec; 4404 4405 /* Delay enabling the HP amp, to let the mic-detection 4406 * state machine run. 4407 */ 4408 cancel_delayed_work_sync(&spec->unsol_hp_work); 4409 schedule_delayed_work(&spec->unsol_hp_work, msecs_to_jiffies(500)); 4410 cb->tbl->block_report = 1; 4411 } 4412 4413 static void amic_callback(struct hda_codec *codec, struct hda_jack_callback *cb) 4414 { 4415 ca0132_select_mic(codec); 4416 } 4417 4418 static void ca0132_init_unsol(struct hda_codec *codec) 4419 { 4420 snd_hda_jack_detect_enable_callback(codec, UNSOL_TAG_HP, hp_callback); 4421 snd_hda_jack_detect_enable_callback(codec, UNSOL_TAG_AMIC1, 4422 amic_callback); 4423 snd_hda_jack_detect_enable_callback(codec, UNSOL_TAG_DSP, 4424 ca0132_process_dsp_response); 4425 } 4426 4427 /* 4428 * Verbs tables. 4429 */ 4430 4431 /* Sends before DSP download. */ 4432 static struct hda_verb ca0132_base_init_verbs[] = { 4433 /*enable ct extension*/ 4434 {0x15, VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 0x1}, 4435 {} 4436 }; 4437 4438 /* Send at exit. */ 4439 static struct hda_verb ca0132_base_exit_verbs[] = { 4440 /*set afg to D3*/ 4441 {0x01, AC_VERB_SET_POWER_STATE, 0x03}, 4442 /*disable ct extension*/ 4443 {0x15, VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE, 0}, 4444 {} 4445 }; 4446 4447 /* Other verbs tables. Sends after DSP download. */ 4448 static struct hda_verb ca0132_init_verbs0[] = { 4449 /* chip init verbs */ 4450 {0x15, 0x70D, 0xF0}, 4451 {0x15, 0x70E, 0xFE}, 4452 {0x15, 0x707, 0x75}, 4453 {0x15, 0x707, 0xD3}, 4454 {0x15, 0x707, 0x09}, 4455 {0x15, 0x707, 0x53}, 4456 {0x15, 0x707, 0xD4}, 4457 {0x15, 0x707, 0xEF}, 4458 {0x15, 0x707, 0x75}, 4459 {0x15, 0x707, 0xD3}, 4460 {0x15, 0x707, 0x09}, 4461 {0x15, 0x707, 0x02}, 4462 {0x15, 0x707, 0x37}, 4463 {0x15, 0x707, 0x78}, 4464 {0x15, 0x53C, 0xCE}, 4465 {0x15, 0x575, 0xC9}, 4466 {0x15, 0x53D, 0xCE}, 4467 {0x15, 0x5B7, 0xC9}, 4468 {0x15, 0x70D, 0xE8}, 4469 {0x15, 0x70E, 0xFE}, 4470 {0x15, 0x707, 0x02}, 4471 {0x15, 0x707, 0x68}, 4472 {0x15, 0x707, 0x62}, 4473 {0x15, 0x53A, 0xCE}, 4474 {0x15, 0x546, 0xC9}, 4475 {0x15, 0x53B, 0xCE}, 4476 {0x15, 0x5E8, 0xC9}, 4477 {0x15, 0x717, 0x0D}, 4478 {0x15, 0x718, 0x20}, 4479 {} 4480 }; 4481 4482 static struct hda_verb ca0132_init_verbs1[] = { 4483 {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_HP}, 4484 {0x12, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | UNSOL_TAG_AMIC1}, 4485 /* config EAPD */ 4486 {0x0b, 0x78D, 0x00}, 4487 /*{0x0b, AC_VERB_SET_EAPD_BTLENABLE, 0x02},*/ 4488 /*{0x10, 0x78D, 0x02},*/ 4489 /*{0x10, AC_VERB_SET_EAPD_BTLENABLE, 0x02},*/ 4490 {} 4491 }; 4492 4493 static void ca0132_init_chip(struct hda_codec *codec) 4494 { 4495 struct ca0132_spec *spec = codec->spec; 4496 int num_fx; 4497 int i; 4498 unsigned int on; 4499 4500 mutex_init(&spec->chipio_mutex); 4501 4502 spec->cur_out_type = SPEAKER_OUT; 4503 spec->cur_mic_type = DIGITAL_MIC; 4504 spec->cur_mic_boost = 0; 4505 4506 for (i = 0; i < VNODES_COUNT; i++) { 4507 spec->vnode_lvol[i] = 0x5a; 4508 spec->vnode_rvol[i] = 0x5a; 4509 spec->vnode_lswitch[i] = 0; 4510 spec->vnode_rswitch[i] = 0; 4511 } 4512 4513 /* 4514 * Default states for effects are in ca0132_effects[]. 4515 */ 4516 num_fx = OUT_EFFECTS_COUNT + IN_EFFECTS_COUNT; 4517 for (i = 0; i < num_fx; i++) { 4518 on = (unsigned int)ca0132_effects[i].reqs[0]; 4519 spec->effects_switch[i] = on ? 1 : 0; 4520 } 4521 4522 spec->voicefx_val = 0; 4523 spec->effects_switch[PLAY_ENHANCEMENT - EFFECT_START_NID] = 1; 4524 spec->effects_switch[CRYSTAL_VOICE - EFFECT_START_NID] = 0; 4525 4526 #ifdef ENABLE_TUNING_CONTROLS 4527 ca0132_init_tuning_defaults(codec); 4528 #endif 4529 } 4530 4531 static void ca0132_exit_chip(struct hda_codec *codec) 4532 { 4533 /* put any chip cleanup stuffs here. */ 4534 4535 if (dspload_is_loaded(codec)) 4536 dsp_reset(codec); 4537 } 4538 4539 static int ca0132_init(struct hda_codec *codec) 4540 { 4541 struct ca0132_spec *spec = codec->spec; 4542 struct auto_pin_cfg *cfg = &spec->autocfg; 4543 int i; 4544 4545 if (spec->dsp_state != DSP_DOWNLOAD_FAILED) 4546 spec->dsp_state = DSP_DOWNLOAD_INIT; 4547 spec->curr_chip_addx = INVALID_CHIP_ADDRESS; 4548 4549 snd_hda_power_up_pm(codec); 4550 4551 ca0132_init_unsol(codec); 4552 4553 ca0132_init_params(codec); 4554 ca0132_init_flags(codec); 4555 snd_hda_sequence_write(codec, spec->base_init_verbs); 4556 ca0132_download_dsp(codec); 4557 ca0132_refresh_widget_caps(codec); 4558 ca0132_setup_defaults(codec); 4559 ca0132_init_analog_mic2(codec); 4560 ca0132_init_dmic(codec); 4561 4562 for (i = 0; i < spec->num_outputs; i++) 4563 init_output(codec, spec->out_pins[i], spec->dacs[0]); 4564 4565 init_output(codec, cfg->dig_out_pins[0], spec->dig_out); 4566 4567 for (i = 0; i < spec->num_inputs; i++) 4568 init_input(codec, spec->input_pins[i], spec->adcs[i]); 4569 4570 init_input(codec, cfg->dig_in_pin, spec->dig_in); 4571 4572 for (i = 0; i < spec->num_init_verbs; i++) 4573 snd_hda_sequence_write(codec, spec->init_verbs[i]); 4574 4575 ca0132_select_out(codec); 4576 ca0132_select_mic(codec); 4577 4578 snd_hda_jack_report_sync(codec); 4579 4580 snd_hda_power_down_pm(codec); 4581 4582 return 0; 4583 } 4584 4585 static void ca0132_free(struct hda_codec *codec) 4586 { 4587 struct ca0132_spec *spec = codec->spec; 4588 4589 cancel_delayed_work_sync(&spec->unsol_hp_work); 4590 snd_hda_power_up(codec); 4591 snd_hda_sequence_write(codec, spec->base_exit_verbs); 4592 ca0132_exit_chip(codec); 4593 snd_hda_power_down(codec); 4594 kfree(codec->spec); 4595 } 4596 4597 static struct hda_codec_ops ca0132_patch_ops = { 4598 .build_controls = ca0132_build_controls, 4599 .build_pcms = ca0132_build_pcms, 4600 .init = ca0132_init, 4601 .free = ca0132_free, 4602 .unsol_event = snd_hda_jack_unsol_event, 4603 }; 4604 4605 static void ca0132_config(struct hda_codec *codec) 4606 { 4607 struct ca0132_spec *spec = codec->spec; 4608 struct auto_pin_cfg *cfg = &spec->autocfg; 4609 4610 spec->dacs[0] = 0x2; 4611 spec->dacs[1] = 0x3; 4612 spec->dacs[2] = 0x4; 4613 4614 spec->multiout.dac_nids = spec->dacs; 4615 spec->multiout.num_dacs = 3; 4616 spec->multiout.max_channels = 2; 4617 4618 spec->num_outputs = 2; 4619 spec->out_pins[0] = 0x0b; /* speaker out */ 4620 spec->out_pins[1] = 0x10; /* headphone out */ 4621 spec->shared_out_nid = 0x2; 4622 4623 spec->num_inputs = 3; 4624 spec->adcs[0] = 0x7; /* digital mic / analog mic1 */ 4625 spec->adcs[1] = 0x8; /* analog mic2 */ 4626 spec->adcs[2] = 0xa; /* what u hear */ 4627 spec->shared_mic_nid = 0x7; 4628 4629 spec->input_pins[0] = 0x12; 4630 spec->input_pins[1] = 0x11; 4631 spec->input_pins[2] = 0x13; 4632 4633 /* SPDIF I/O */ 4634 spec->dig_out = 0x05; 4635 spec->multiout.dig_out_nid = spec->dig_out; 4636 cfg->dig_out_pins[0] = 0x0c; 4637 cfg->dig_outs = 1; 4638 cfg->dig_out_type[0] = HDA_PCM_TYPE_SPDIF; 4639 spec->dig_in = 0x09; 4640 cfg->dig_in_pin = 0x0e; 4641 cfg->dig_in_type = HDA_PCM_TYPE_SPDIF; 4642 } 4643 4644 static int patch_ca0132(struct hda_codec *codec) 4645 { 4646 struct ca0132_spec *spec; 4647 int err; 4648 4649 codec_dbg(codec, "patch_ca0132\n"); 4650 4651 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4652 if (!spec) 4653 return -ENOMEM; 4654 codec->spec = spec; 4655 spec->codec = codec; 4656 4657 spec->dsp_state = DSP_DOWNLOAD_INIT; 4658 spec->num_mixers = 1; 4659 spec->mixers[0] = ca0132_mixer; 4660 4661 spec->base_init_verbs = ca0132_base_init_verbs; 4662 spec->base_exit_verbs = ca0132_base_exit_verbs; 4663 spec->init_verbs[0] = ca0132_init_verbs0; 4664 spec->init_verbs[1] = ca0132_init_verbs1; 4665 spec->num_init_verbs = 2; 4666 4667 INIT_DELAYED_WORK(&spec->unsol_hp_work, ca0132_unsol_hp_delayed); 4668 4669 ca0132_init_chip(codec); 4670 4671 ca0132_config(codec); 4672 4673 err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); 4674 if (err < 0) 4675 return err; 4676 4677 codec->patch_ops = ca0132_patch_ops; 4678 codec->pcm_format_first = 1; 4679 codec->no_sticky_stream = 1; 4680 4681 return 0; 4682 } 4683 4684 /* 4685 * patch entries 4686 */ 4687 static struct hda_codec_preset snd_hda_preset_ca0132[] = { 4688 { .id = 0x11020011, .name = "CA0132", .patch = patch_ca0132 }, 4689 {} /* terminator */ 4690 }; 4691 4692 MODULE_ALIAS("snd-hda-codec-id:11020011"); 4693 4694 MODULE_LICENSE("GPL"); 4695 MODULE_DESCRIPTION("Creative Sound Core3D codec"); 4696 4697 static struct hda_codec_driver ca0132_driver = { 4698 .preset = snd_hda_preset_ca0132, 4699 }; 4700 4701 module_hda_codec_driver(ca0132_driver); 4702