kernel/sound/pci/hda/patch_ca0132.c

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