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