drivers/mfd/cpcap-audio-core.c

   1 /*
   2  * Copyright (C) 2007 - 2009 Motorola, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  16  * 02111-1307, USA
  17  *
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/proc_fs.h>
  22 #include <linux/smp_lock.h>
  23 #include <linux/module.h>
  24 #include <linux/uaccess.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/dma-mapping.h>
  27 #include <linux/delay.h>
  28 #include <linux/poll.h>
  29 #include <linux/spi/cpcap.h>
  30 #include <linux/regulator/consumer.h>
  31
  32 #include <mach/cpcap_audio.h>
  33
  34 #define MICBIAS_WARMUP_TIME_MS          39
  35 #define SLEEP_ACTIVATE_POWER_DELAY_MS   2
  36 #define STM_STDAC_ACTIVATE_RAMP_TIME    1
  37 #define CLOCK_TREE_RESET_DELAY_MS       1
  38
  39 #define CPCAP_AUDIO_SPI_READBACK        1
  40
  41 #define STM_STDAC_EN_TEST_PRE           0x090C
  42 #define STM_STDAC_EN_TEST_POST          0x0000
  43 #define STM_STDAC_EN_ST_TEST1_PRE       0x2400
  44 #define STM_STDAC_EN_ST_TEST1_POST      0x0400
  45
  46 #define E(args...)  pr_err("cpcap-audio: " args)
  47
  48 static struct cpcap_audio_state current_state = {
  49         .cpcap                          = NULL,
  50         .mode                           = CPCAP_AUDIO_MODE_NORMAL,
  51
  52         .codec_mode                     = CPCAP_AUDIO_CODEC_OFF,
  53         .codec_rate                     = CPCAP_AUDIO_CODEC_RATE_8000_HZ,
  54         .codec_mute                     = CPCAP_AUDIO_CODEC_MUTE,
  55
  56         .stdac_mode                     = CPCAP_AUDIO_STDAC_OFF,
  57         .stdac_rate                     = CPCAP_AUDIO_STDAC_RATE_8000_HZ,
  58         .stdac_mute                     = CPCAP_AUDIO_STDAC_MUTE,
  59
  60         .analog_source                  = CPCAP_AUDIO_ANALOG_SOURCE_OFF,
  61
  62         .codec_primary_speaker          = CPCAP_AUDIO_OUT_NONE,
  63         .codec_secondary_speaker        = CPCAP_AUDIO_OUT_NONE,
  64
  65         .stdac_primary_speaker          = CPCAP_AUDIO_OUT_NONE,
  66         .stdac_secondary_speaker        = CPCAP_AUDIO_OUT_NONE,
  67
  68         .ext_primary_speaker            = CPCAP_AUDIO_OUT_NONE,
  69         .ext_secondary_speaker          = CPCAP_AUDIO_OUT_NONE,
  70
  71         .codec_primary_balance          = CPCAP_AUDIO_BALANCE_NEUTRAL,
  72         .stdac_primary_balance          = CPCAP_AUDIO_BALANCE_NEUTRAL,
  73         .ext_primary_balance            = CPCAP_AUDIO_BALANCE_NEUTRAL,
  74
  75         .output_gain                    = 0,
  76         .microphone                     = CPCAP_AUDIO_IN_NONE,
  77         .input_gain                     = 0,
  78         .rat_type                       = CPCAP_AUDIO_RAT_NONE
  79 };
  80
  81 /* Define regulator to turn on the audio portion of cpcap */
  82 struct regulator *audio_reg;
  83
  84 static inline bool is_mic_stereo(int microphone)
  85 {
  86         return microphone == CPCAP_AUDIO_IN_DUAL_INTERNAL ||
  87                 microphone == CPCAP_AUDIO_IN_DUAL_EXTERNAL;
  88 }
  89
  90 static inline bool is_codec_changed(struct cpcap_audio_state *state,
  91                                         struct cpcap_audio_state *prev)
  92 {
  93         return state->codec_mode != prev->codec_mode ||
  94                 state->codec_rate != prev->codec_rate ||
  95                 state->rat_type != prev->rat_type ||
  96                 state->microphone != prev->microphone;
  97 }
  98
  99 static inline bool is_stdac_changed(struct cpcap_audio_state *state,
 100                                         struct cpcap_audio_state *prev)
 101 {
 102         return state->stdac_mode != prev->stdac_mode ||
 103                 state->rat_type != prev->rat_type ||
 104                 state->stdac_rate != prev->stdac_rate;
 105 }
 106
 107 static inline bool is_output_bt_only(struct cpcap_audio_state *state)
 108 {
 109         if (state->codec_primary_speaker == CPCAP_AUDIO_OUT_BT_MONO &&
 110                         state->codec_secondary_speaker == CPCAP_AUDIO_OUT_NONE)
 111                 return true;
 112
 113         if (state->stdac_primary_speaker == CPCAP_AUDIO_OUT_BT_MONO &&
 114                         state->stdac_secondary_speaker == CPCAP_AUDIO_OUT_NONE)
 115                 return true;
 116
 117         if (state->ext_primary_speaker == CPCAP_AUDIO_OUT_BT_MONO &&
 118                         state->ext_secondary_speaker == CPCAP_AUDIO_OUT_NONE)
 119                 return true;
 120
 121         return false;
 122 }
 123
 124 static inline bool is_output_headset(struct cpcap_audio_state *state)
 125 {
 126         if (state->codec_primary_speaker == CPCAP_AUDIO_OUT_STEREO_HEADSET ||
 127                         state->codec_primary_speaker ==
 128                                 CPCAP_AUDIO_OUT_MONO_HEADSET ||
 129                         state->codec_secondary_speaker ==
 130                                 CPCAP_AUDIO_OUT_STEREO_HEADSET ||
 131                         state->codec_secondary_speaker ==
 132                                 CPCAP_AUDIO_OUT_MONO_HEADSET)
 133                 return true;
 134
 135         if (state->stdac_primary_speaker == CPCAP_AUDIO_OUT_STEREO_HEADSET ||
 136                         state->stdac_primary_speaker ==
 137                                 CPCAP_AUDIO_OUT_MONO_HEADSET ||
 138                         state->stdac_secondary_speaker ==
 139                                 CPCAP_AUDIO_OUT_STEREO_HEADSET ||
 140                         state->stdac_secondary_speaker ==
 141                                 CPCAP_AUDIO_OUT_MONO_HEADSET)
 142                 return true;
 143
 144         if (state->ext_primary_speaker == CPCAP_AUDIO_OUT_STEREO_HEADSET ||
 145                         state->ext_primary_speaker ==
 146                                 CPCAP_AUDIO_OUT_MONO_HEADSET ||
 147                         state->ext_secondary_speaker ==
 148                                 CPCAP_AUDIO_OUT_STEREO_HEADSET ||
 149                         state->ext_secondary_speaker ==
 150                                 CPCAP_AUDIO_OUT_MONO_HEADSET)
 151                 return true;
 152
 153         return false;
 154 }
 155
 156 static inline int is_output_whisper_emu(struct cpcap_audio_state *state)
 157 {
 158         if (state->codec_primary_speaker == CPCAP_AUDIO_OUT_EMU_STEREO
 159             || state->codec_secondary_speaker == CPCAP_AUDIO_OUT_EMU_STEREO
 160             || state->stdac_primary_speaker == CPCAP_AUDIO_OUT_EMU_STEREO
 161             || state->stdac_secondary_speaker == CPCAP_AUDIO_OUT_EMU_STEREO
 162             || state->ext_primary_speaker == CPCAP_AUDIO_OUT_EMU_STEREO
 163             || state->ext_secondary_speaker == CPCAP_AUDIO_OUT_EMU_STEREO) {
 164                 pr_debug("%s() returning TRUE\n", __func__);
 165                 return 1;
 166         }
 167
 168         pr_debug("%s() returning FALSE\n", __func__);
 169         return 0;
 170 }
 171
 172 static inline bool is_speaker_turning_off(struct cpcap_audio_state *state,
 173                                         struct cpcap_audio_state *prev)
 174 {
 175         return (prev->codec_primary_speaker != CPCAP_AUDIO_OUT_NONE &&
 176                         state->codec_primary_speaker ==
 177                                 CPCAP_AUDIO_OUT_NONE) ||
 178                 (prev->codec_secondary_speaker != CPCAP_AUDIO_OUT_NONE &&
 179                         state->codec_secondary_speaker ==
 180                                 CPCAP_AUDIO_OUT_NONE) ||
 181                 (prev->stdac_primary_speaker != CPCAP_AUDIO_OUT_NONE &&
 182                         state->stdac_primary_speaker ==
 183                                 CPCAP_AUDIO_OUT_NONE) ||
 184                 (prev->stdac_secondary_speaker != CPCAP_AUDIO_OUT_NONE &&
 185                         state->stdac_secondary_speaker ==
 186                                 CPCAP_AUDIO_OUT_NONE) ||
 187                 (prev->ext_primary_speaker != CPCAP_AUDIO_OUT_NONE &&
 188                         state->ext_primary_speaker ==
 189                                 CPCAP_AUDIO_OUT_NONE) ||
 190                 (prev->ext_secondary_speaker != CPCAP_AUDIO_OUT_NONE &&
 191                         state->ext_secondary_speaker ==
 192                                 CPCAP_AUDIO_OUT_NONE);
 193 }
 194
 195 static inline bool is_output_changed(struct cpcap_audio_state *state,
 196                         struct cpcap_audio_state *prev)
 197 {
 198         if (state->codec_primary_speaker != prev->codec_primary_speaker ||
 199                         state->codec_primary_balance !=
 200                                 prev->codec_primary_balance ||
 201                         state->codec_secondary_speaker !=
 202                                 prev->codec_secondary_speaker)
 203                 return true;
 204
 205         if (state->stdac_primary_speaker != prev->stdac_primary_speaker ||
 206                         state->stdac_primary_balance !=
 207                                 prev->stdac_primary_balance ||
 208                         state->stdac_secondary_speaker !=
 209                                 prev->stdac_secondary_speaker)
 210                 return true;
 211
 212         if (state->ext_primary_speaker != prev->ext_primary_speaker ||
 213                         state->ext_primary_balance !=
 214                                 prev->ext_primary_balance ||
 215                         state->ext_secondary_speaker !=
 216                                 prev->ext_secondary_speaker)
 217                 return true;
 218
 219         return false;
 220 }
 221
 222 /* this is only true for audio registers, but those are the only ones we use */
 223 #define CPCAP_REG_FOR_POWERIC_REG(a) ((a) + (0x200 - CPCAP_REG_VAUDIOC))
 224
 225 static void logged_cpcap_write(struct cpcap_device *cpcap, unsigned int reg,
 226                         unsigned short int value, unsigned short int mask)
 227 {
 228         if (mask != 0) {
 229                 int ret_val = 0;
 230                 pr_debug("%s: audio: reg %u, value 0x%x,mask 0x%x\n", __func__,
 231                         CPCAP_REG_FOR_POWERIC_REG(reg), value, mask);
 232                 ret_val = cpcap_regacc_write(cpcap, reg, value, mask);
 233                 if (ret_val != 0)
 234                         E("%s: w %04x m %04x -> r %u failed: %d\n", __func__,
 235                                 value, mask, reg, ret_val);
 236 #if CPCAP_AUDIO_SPI_READBACK
 237                 ret_val = cpcap_regacc_read(cpcap, reg, &value);
 238                 if (ret_val == 0)
 239                         pr_debug("%s: audio verify: reg %u: value 0x%x\n",
 240                                 __func__,
 241                                 CPCAP_REG_FOR_POWERIC_REG(reg), value);
 242                 else
 243                         E("%s: audio verify: reg %u FAILED\n", __func__,
 244                                 CPCAP_REG_FOR_POWERIC_REG(reg));
 245 #endif
 246         }
 247 }
 248
 249 static unsigned short int cpcap_audio_get_codec_output_amp_switches(
 250                                                 int speaker, int balance)
 251 {
 252         unsigned short int value = CPCAP_BIT_PGA_CDC_EN;
 253
 254         pr_debug("%s() called with speaker = %d\n", __func__,
 255                           speaker);
 256
 257         switch (speaker) {
 258         case CPCAP_AUDIO_OUT_HANDSET:
 259                 value |= CPCAP_BIT_A1_EAR_CDC_SW;
 260                 break;
 261
 262         case CPCAP_AUDIO_OUT_LOUDSPEAKER:
 263                 value |= CPCAP_BIT_A2_LDSP_L_CDC_SW;
 264                 break;
 265
 266         case CPCAP_AUDIO_OUT_MONO_HEADSET:
 267         case CPCAP_AUDIO_OUT_STEREO_HEADSET:
 268                 if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
 269                         value |= CPCAP_BIT_ARIGHT_HS_CDC_SW;
 270                 if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
 271                         value |= CPCAP_BIT_ALEFT_HS_CDC_SW;
 272                 break;
 273
 274         case CPCAP_AUDIO_OUT_EMU_STEREO:
 275                 if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
 276                         value |= CPCAP_BIT_PGA_OUTR_USBDP_CDC_SW;
 277                 if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
 278                         value |= CPCAP_BIT_PGA_OUTL_USBDN_CDC_SW;
 279                 break;
 280
 281         case CPCAP_AUDIO_OUT_LINEOUT:
 282                 value |= CPCAP_BIT_A4_LINEOUT_R_CDC_SW |
 283                         CPCAP_BIT_A4_LINEOUT_L_CDC_SW;
 284                 break;
 285
 286         case CPCAP_AUDIO_OUT_BT_MONO:
 287         default:
 288                 value = 0;
 289                 break;
 290         }
 291
 292         pr_debug("Exiting %s() with return value = %d\n", __func__,
 293                           value);
 294         return value;
 295 }
 296
 297 static unsigned short int cpcap_audio_get_stdac_output_amp_switches(
 298                                                 int speaker, int balance)
 299 {
 300         unsigned short int value = CPCAP_BIT_PGA_DAC_EN;
 301
 302         pr_debug("%s() called with speaker = %d\n", __func__,
 303                           speaker);
 304
 305         switch (speaker) {
 306         case CPCAP_AUDIO_OUT_HANDSET:
 307                 value |= CPCAP_BIT_A1_EAR_DAC_SW;
 308                 break;
 309
 310         case CPCAP_AUDIO_OUT_MONO_HEADSET:
 311         case CPCAP_AUDIO_OUT_STEREO_HEADSET:
 312                 if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
 313                         value |= CPCAP_BIT_ALEFT_HS_DAC_SW;
 314                 if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
 315                         value |= CPCAP_BIT_ARIGHT_HS_DAC_SW;
 316                 break;
 317
 318         case CPCAP_AUDIO_OUT_EMU_STEREO:
 319                 if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
 320                         value |= CPCAP_BIT_PGA_OUTR_USBDP_DAC_SW;
 321                 if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
 322                         value |= CPCAP_BIT_PGA_OUTL_USBDN_DAC_SW;
 323                 break;
 324
 325         case CPCAP_AUDIO_OUT_LOUDSPEAKER:
 326                 value |= CPCAP_BIT_A2_LDSP_L_DAC_SW | CPCAP_BIT_MONO_DAC0 |
 327                         CPCAP_BIT_MONO_DAC1;
 328                 break;
 329
 330         case CPCAP_AUDIO_OUT_LINEOUT:
 331                 value |= CPCAP_BIT_A4_LINEOUT_R_DAC_SW |
 332                         CPCAP_BIT_A4_LINEOUT_L_DAC_SW;
 333                 break;
 334
 335         case CPCAP_AUDIO_OUT_BT_MONO:
 336         default:
 337                 value = 0;
 338                 break;
 339         }
 340
 341         pr_debug("Exiting %s() with return value = %d\n", __func__,
 342                           value);
 343         return value;
 344 }
 345
 346 static unsigned short int cpcap_audio_get_ext_output_amp_switches(
 347                                                 int speaker, int balance)
 348 {
 349         unsigned short int value = 0;
 350         pr_debug("%s() called with speaker %d\n", __func__,
 351                                                                 speaker);
 352         switch (speaker) {
 353         case CPCAP_AUDIO_OUT_HANDSET:
 354                 value = CPCAP_BIT_A1_EAR_EXT_SW | CPCAP_BIT_PGA_EXT_R_EN;
 355                 break;
 356
 357         case CPCAP_AUDIO_OUT_MONO_HEADSET:
 358         case CPCAP_AUDIO_OUT_STEREO_HEADSET:
 359                 if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
 360                         value = CPCAP_BIT_ARIGHT_HS_EXT_SW |
 361                                 CPCAP_BIT_PGA_EXT_R_EN;
 362                 if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
 363                         value |= CPCAP_BIT_ALEFT_HS_EXT_SW |
 364                                 CPCAP_BIT_PGA_EXT_L_EN;
 365                 break;
 366
 367         case CPCAP_AUDIO_OUT_EMU_STEREO:
 368                 if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
 369                         value |= CPCAP_BIT_PGA_OUTR_USBDP_EXT_SW;
 370                 if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
 371                         value |= CPCAP_BIT_PGA_OUTL_USBDN_EXT_SW;
 372                 break;
 373
 374         case CPCAP_AUDIO_OUT_LOUDSPEAKER:
 375                 value = CPCAP_BIT_A2_LDSP_L_EXT_SW | CPCAP_BIT_PGA_EXT_L_EN;
 376                 break;
 377
 378         case CPCAP_AUDIO_OUT_LINEOUT:
 379                 value = CPCAP_BIT_A4_LINEOUT_R_EXT_SW |
 380                         CPCAP_BIT_A4_LINEOUT_L_EXT_SW |
 381                         CPCAP_BIT_PGA_EXT_L_EN | CPCAP_BIT_PGA_EXT_R_EN;
 382                 break;
 383
 384         case CPCAP_AUDIO_OUT_BT_MONO:
 385         default:
 386                 value = 0;
 387                 break;
 388         }
 389
 390         pr_debug("Exiting %s() with return value = %d\n", __func__,
 391                           value);
 392         return value;
 393 }
 394
 395 static void cpcap_audio_set_output_amp_switches(struct cpcap_audio_state *state)
 396 {
 397         static unsigned int codec_prev_settings;
 398         static unsigned int stdac_prev_settings;
 399         static unsigned int ext_prev_settings;
 400
 401         struct cpcap_regacc reg_changes;
 402         unsigned short int value1 = 0, value2 = 0;
 403
 404         /* First set codec output amp switches */
 405         value1 = cpcap_audio_get_codec_output_amp_switches(state->
 406                         codec_primary_speaker, state->codec_primary_balance);
 407         value2 = cpcap_audio_get_codec_output_amp_switches(state->
 408                         codec_secondary_speaker, state->codec_primary_balance);
 409
 410         reg_changes.mask = value1 | value2 | codec_prev_settings;
 411         reg_changes.value = value1 | value2;
 412         codec_prev_settings = reg_changes.value;
 413
 414         logged_cpcap_write(state->cpcap, CPCAP_REG_RXCOA, reg_changes.value,
 415                                                         reg_changes.mask);
 416
 417         /* Second Stdac switches */
 418         value1 = cpcap_audio_get_stdac_output_amp_switches(state->
 419                         stdac_primary_speaker, state->stdac_primary_balance);
 420         value2 = cpcap_audio_get_stdac_output_amp_switches(state->
 421                         stdac_secondary_speaker, state->stdac_primary_balance);
 422
 423         reg_changes.mask = value1 | value2 | stdac_prev_settings;
 424         reg_changes.value = value1 | value2;
 425
 426         if ((state->stdac_primary_speaker == CPCAP_AUDIO_OUT_STEREO_HEADSET &&
 427                 state->stdac_secondary_speaker == CPCAP_AUDIO_OUT_LOUDSPEAKER)
 428                 || (state->stdac_primary_speaker == CPCAP_AUDIO_OUT_LOUDSPEAKER
 429                 && state->stdac_secondary_speaker ==
 430                                                 CPCAP_AUDIO_OUT_STEREO_HEADSET))
 431                 reg_changes.value &= ~(CPCAP_BIT_MONO_DAC0 |
 432                                         CPCAP_BIT_MONO_DAC1);
 433
 434         stdac_prev_settings = reg_changes.value;
 435
 436         logged_cpcap_write(state->cpcap, CPCAP_REG_RXSDOA, reg_changes.value,
 437                                                         reg_changes.mask);
 438
 439         /* Last External source switches */
 440         value1 =
 441             cpcap_audio_get_ext_output_amp_switches(state->
 442                                 ext_primary_speaker,
 443                                 state->ext_primary_balance);
 444         value2 =
 445             cpcap_audio_get_ext_output_amp_switches(state->
 446                                 ext_secondary_speaker,
 447                                 state->ext_primary_balance);
 448
 449         reg_changes.mask = value1 | value2 | ext_prev_settings;
 450         reg_changes.value = value1 | value2;
 451         ext_prev_settings = reg_changes.value;
 452
 453         logged_cpcap_write(state->cpcap, CPCAP_REG_RXEPOA,
 454                         reg_changes.value, reg_changes.mask);
 455 }
 456
 457 static bool cpcap_audio_set_bits_for_speaker(int speaker, int balance,
 458                                                 unsigned short int *message)
 459 {
 460         /* Get the data required to enable each possible path */
 461         switch (speaker) {
 462         case CPCAP_AUDIO_OUT_HANDSET:
 463                 (*message) |= CPCAP_BIT_A1_EAR_EN;
 464                 break;
 465
 466         case CPCAP_AUDIO_OUT_MONO_HEADSET:
 467         case CPCAP_AUDIO_OUT_STEREO_HEADSET:
 468                 if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
 469                         (*message) |= CPCAP_BIT_HS_L_EN;
 470                 if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
 471                         (*message) |= CPCAP_BIT_HS_R_EN;
 472                 break;
 473
 474         case CPCAP_AUDIO_OUT_EMU_STEREO:
 475                 if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
 476                         (*message) |= CPCAP_BIT_EMU_SPKR_R_EN;
 477                 if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
 478                         (*message) |= CPCAP_BIT_EMU_SPKR_L_EN;
 479                 break;
 480
 481         case CPCAP_AUDIO_OUT_LOUDSPEAKER:
 482                 (*message) |= CPCAP_BIT_A2_LDSP_L_EN;
 483                 break;
 484
 485         case CPCAP_AUDIO_OUT_LINEOUT:
 486                 (*message) |= CPCAP_BIT_A4_LINEOUT_R_EN |
 487                                 CPCAP_BIT_A4_LINEOUT_L_EN;
 488                 break;
 489
 490         case CPCAP_AUDIO_OUT_BT_MONO:
 491         default:
 492                 (*message) |= 0;
 493                 break;
 494         }
 495
 496         return false; /* There is no external loudspeaker on this product */
 497 }
 498
 499 static void cpcap_audio_configure_aud_mute(struct cpcap_audio_state *state,
 500                                 struct cpcap_audio_state *prev)
 501 {
 502         struct cpcap_regacc reg_changes = { 0 };
 503         unsigned short int value1 = 0, value2 = 0;
 504
 505         if (state->codec_mute != prev->codec_mute) {
 506                 value1 = cpcap_audio_get_codec_output_amp_switches(
 507                                 prev->codec_primary_speaker,
 508                                 prev->codec_primary_balance);
 509
 510                 value2 = cpcap_audio_get_codec_output_amp_switches(
 511                                 prev->codec_secondary_speaker,
 512                                 prev->codec_primary_balance);
 513
 514                 reg_changes.mask = value1 | value2 | CPCAP_BIT_CDC_SW;
 515
 516                 if (state->codec_mute == CPCAP_AUDIO_CODEC_UNMUTE)
 517                         reg_changes.value = reg_changes.mask;
 518
 519                 logged_cpcap_write(state->cpcap, CPCAP_REG_RXCOA,
 520                                         reg_changes.value, reg_changes.mask);
 521         }
 522
 523         if (state->stdac_mute != prev->stdac_mute) {
 524                 value1 = cpcap_audio_get_stdac_output_amp_switches(
 525                                 prev->stdac_primary_speaker,
 526                                 prev->stdac_primary_balance);
 527
 528                 value2 = cpcap_audio_get_stdac_output_amp_switches(
 529                                 prev->stdac_secondary_speaker,
 530                                 prev->stdac_primary_balance);
 531
 532                 reg_changes.mask = value1 | value2 | CPCAP_BIT_ST_DAC_SW;
 533
 534                 if (state->stdac_mute == CPCAP_AUDIO_STDAC_UNMUTE)
 535                         reg_changes.value = reg_changes.mask;
 536
 537                 logged_cpcap_write(state->cpcap, CPCAP_REG_RXSDOA,
 538                                         reg_changes.value, reg_changes.mask);
 539         }
 540 }
 541
 542 static void cpcap_audio_configure_codec(struct cpcap_audio_state *state,
 543                                 struct cpcap_audio_state *prev)
 544 {
 545         unsigned int temp_codec_rate = state->codec_rate;
 546         struct cpcap_regacc cdai_changes = { 0 };
 547         struct cpcap_regacc codec_changes = { 0 };
 548         int codec_freq_config = 0;
 549
 550         const unsigned int CODEC_FREQ_MASK = CPCAP_BIT_CDC_CLK0
 551                 | CPCAP_BIT_CDC_CLK1 | CPCAP_BIT_CDC_CLK2;
 552         const unsigned int CODEC_RESET_FREQ_MASK = CODEC_FREQ_MASK
 553                 | CPCAP_BIT_CDC_CLOCK_TREE_RESET;
 554
 555         static unsigned int prev_codec_data = 0x0, prev_cdai_data = 0x0;
 556
 557         if (!is_codec_changed(state, prev))
 558                 return;
 559
 560         if (state->rat_type == CPCAP_AUDIO_RAT_CDMA)
 561                 codec_freq_config = (CPCAP_BIT_CDC_CLK0
 562                                 | CPCAP_BIT_CDC_CLK1) ; /* 19.2Mhz */
 563         else
 564                 codec_freq_config = CPCAP_BIT_CDC_CLK2 ; /* 26Mhz */
 565
 566         /* If a codec is already in use, reset codec to initial state */
 567         if (prev->codec_mode != CPCAP_AUDIO_CODEC_OFF) {
 568                 codec_changes.mask = prev_codec_data
 569                         | CPCAP_BIT_DF_RESET
 570                         | CPCAP_BIT_CDC_CLOCK_TREE_RESET;
 571
 572                 logged_cpcap_write(state->cpcap, CPCAP_REG_CC,
 573                         codec_changes.value, codec_changes.mask);
 574
 575                 prev_codec_data = 0;
 576                 prev->codec_mode = CPCAP_AUDIO_CODEC_OFF;
 577         }
 578
 579         temp_codec_rate &= 0x0000000F;
 580         temp_codec_rate = temp_codec_rate << 9;
 581
 582         switch (state->codec_mode) {
 583         case CPCAP_AUDIO_CODEC_LOOPBACK:
 584         case CPCAP_AUDIO_CODEC_ON:
 585                 if (state->codec_primary_speaker !=
 586                         CPCAP_AUDIO_OUT_NONE) {
 587                         codec_changes.value |= CPCAP_BIT_CDC_EN_RX;
 588                 }
 589
 590                 /* Turning on the input HPF */
 591                 if (state->microphone != CPCAP_AUDIO_IN_NONE)
 592                         codec_changes.value |= CPCAP_BIT_AUDIHPF_0 |
 593                                                 CPCAP_BIT_AUDIHPF_1;
 594
 595 #if 1
 596                 if (state->microphone != CPCAP_AUDIO_IN_NONE) {
 597                         codec_changes.value |= CPCAP_BIT_MIC1_CDC_EN;
 598                         codec_changes.value |= CPCAP_BIT_MIC2_CDC_EN;
 599                 }
 600 #else
 601                 if (state->microphone != CPCAP_AUDIO_IN_AUX_INTERNAL &&
 602                         state->microphone != CPCAP_AUDIO_IN_NONE)
 603                         codec_changes.value |= CPCAP_BIT_MIC1_CDC_EN |
 604                                                 CPCAP_BIT_MIC2_CDC_EN;
 605
 606                 if (state->microphone == CPCAP_AUDIO_IN_AUX_INTERNAL ||
 607                         is_mic_stereo(state->microphone))
 608                         codec_changes.value |= CPCAP_BIT_MIC2_CDC_EN;
 609 #endif
 610
 611         /* falling through intentionally */
 612         case CPCAP_AUDIO_CODEC_CLOCK_ONLY:
 613                 codec_changes.value |=
 614                         (codec_freq_config | temp_codec_rate |
 615                         CPCAP_BIT_DF_RESET);
 616                 cdai_changes.value |= CPCAP_BIT_CDC_CLK_EN;
 617                 break;
 618
 619         case CPCAP_AUDIO_CODEC_OFF:
 620                 cdai_changes.value |= CPCAP_BIT_SMB_CDC;
 621                 break;
 622
 623         default:
 624                 break;
 625         }
 626
 627         /* Multimedia uses CLK_IN0, incall uses CLK_IN1 */
 628         if (state->rat_type != CPCAP_AUDIO_RAT_NONE)
 629                 cdai_changes.value |= CPCAP_BIT_CLK_IN_SEL;
 630
 631         cdai_changes.value |= CPCAP_BIT_CDC_PLL_SEL;
 632 #if 0
 633         cdai_changes.value |= CPCAP_BIT_DIG_AUD_IN;
 634 #endif
 635
 636 #ifdef CODEC_IS_I2S_MODE
 637         cdai_changes.value |= CPCAP_BIT_CLK_INV;
 638         /* Setting I2S mode */
 639         cdai_changes.value |= CPCAP_BIT_CDC_DIG_AUD_FS0 |
 640                         CPCAP_BIT_CDC_DIG_AUD_FS1 |
 641                         CPCAP_BIT_MIC2_TIMESLOT0;
 642 #else
 643         /* Setting CODEC mode */
 644         /* FS:  Not inverted.
 645          * Clk: Not inverted.
 646          * TS2/TS1/TS0 not set, using timeslot 0 for mic1.
 647          */
 648         cdai_changes.value |= CPCAP_BIT_CDC_DIG_AUD_FS0;
 649 #endif
 650
 651         /* OK, now start paranoid codec sequence */
 652         /* FIRST, make sure the frequency config is right... */
 653         logged_cpcap_write(state->cpcap, CPCAP_REG_CC,
 654                                 codec_freq_config, CODEC_FREQ_MASK);
 655
 656         /* Next, write the CDAI if it's changed */
 657         if (prev_cdai_data != cdai_changes.value) {
 658                 cdai_changes.mask = cdai_changes.value
 659                         | prev_cdai_data;
 660                 prev_cdai_data = cdai_changes.value;
 661
 662                 logged_cpcap_write(state->cpcap, CPCAP_REG_CDI,
 663                                 cdai_changes.value, cdai_changes.mask);
 664
 665                 /* Clock tree change -- reset and wait */
 666                 codec_freq_config |= CPCAP_BIT_CDC_CLOCK_TREE_RESET;
 667
 668                 logged_cpcap_write(state->cpcap, CPCAP_REG_CC,
 669                         codec_freq_config, CODEC_RESET_FREQ_MASK);
 670
 671                 /* Wait for clock tree reset to complete */
 672                 mdelay(CLOCK_TREE_RESET_DELAY_MS);
 673         }
 674
 675         /* Clear old settings */
 676         codec_changes.mask = codec_changes.value | prev_codec_data;
 677         prev_codec_data    = codec_changes.value;
 678
 679         logged_cpcap_write(state->cpcap, CPCAP_REG_CC,
 680                         codec_changes.value, codec_changes.mask);
 681 }
 682
 683 static void cpcap_audio_configure_stdac(struct cpcap_audio_state *state,
 684                                 struct cpcap_audio_state *prev)
 685 {
 686         const unsigned int SDAC_FREQ_MASK = CPCAP_BIT_ST_DAC_CLK0
 687                         | CPCAP_BIT_ST_DAC_CLK1 | CPCAP_BIT_ST_DAC_CLK2;
 688         const unsigned int SDAC_RESET_FREQ_MASK = SDAC_FREQ_MASK
 689                                         | CPCAP_BIT_ST_CLOCK_TREE_RESET;
 690         static unsigned int prev_stdac_data, prev_sdai_data;
 691
 692         if (is_stdac_changed(state, prev)) {
 693                 unsigned int temp_stdac_rate = state->stdac_rate;
 694                 struct cpcap_regacc sdai_changes = { 0 };
 695                 struct cpcap_regacc stdac_changes = { 0 };
 696
 697                 int stdac_freq_config = 0;
 698                 if (state->rat_type == CPCAP_AUDIO_RAT_CDMA)
 699                         stdac_freq_config = (CPCAP_BIT_ST_DAC_CLK0
 700                                         | CPCAP_BIT_ST_DAC_CLK1) ; /*19.2Mhz*/
 701                 else
 702                         stdac_freq_config = CPCAP_BIT_ST_DAC_CLK2 ; /* 26Mhz */
 703
 704                 /* We need to turn off stdac before changing its settings */
 705                 if (prev->stdac_mode != CPCAP_AUDIO_STDAC_OFF) {
 706                         stdac_changes.mask = prev_stdac_data |
 707                                         CPCAP_BIT_DF_RESET_ST_DAC |
 708                                         CPCAP_BIT_ST_CLOCK_TREE_RESET;
 709
 710                         logged_cpcap_write(state->cpcap, CPCAP_REG_SDAC,
 711                                 stdac_changes.value, stdac_changes.mask);
 712
 713                         prev_stdac_data = 0;
 714                         prev->stdac_mode = CPCAP_AUDIO_STDAC_OFF;
 715                 }
 716
 717                 temp_stdac_rate &= 0x0000000F;
 718                 temp_stdac_rate = temp_stdac_rate << 4;
 719
 720                 switch (state->stdac_mode) {
 721                 case CPCAP_AUDIO_STDAC_ON:
 722                         stdac_changes.value |= CPCAP_BIT_ST_DAC_EN;
 723                 /* falling through intentionally */
 724                 case CPCAP_AUDIO_STDAC_CLOCK_ONLY:
 725                         stdac_changes.value |= temp_stdac_rate |
 726                                 CPCAP_BIT_DF_RESET_ST_DAC | stdac_freq_config;
 727                         sdai_changes.value |= CPCAP_BIT_ST_CLK_EN;
 728                         break;
 729
 730                 case CPCAP_AUDIO_STDAC_OFF:
 731                 default:
 732                         break;
 733                 }
 734
 735                 if (state->rat_type != CPCAP_AUDIO_RAT_NONE)
 736                         sdai_changes.value |= CPCAP_BIT_ST_DAC_CLK_IN_SEL;
 737                 /* begin everest change */
 738                 /*
 739                 sdai_changes.value |= CPCAP_BIT_ST_DIG_AUD_FS0 |
 740                         CPCAP_BIT_DIG_AUD_IN_ST_DAC | CPCAP_BIT_ST_L_TIMESLOT0;
 741                 */
 742                 /* I2S Mode, ignore timeslots, invert bit clock */
 743                 sdai_changes.value |= CPCAP_BIT_ST_DIG_AUD_FS0 |
 744                         CPCAP_BIT_DIG_AUD_IN_ST_DAC |
 745                         CPCAP_BIT_ST_DIG_AUD_FS1 | CPCAP_BIT_ST_CLK_INV;
 746                 /* end everest change */
 747
 748                 logged_cpcap_write(state->cpcap, CPCAP_REG_SDAC,
 749                                 stdac_freq_config, SDAC_FREQ_MASK);
 750
 751                 /* Next, write the SDACDI if it's changed */
 752                 if (prev_sdai_data != sdai_changes.value) {
 753                         sdai_changes.mask = sdai_changes.value
 754                                                 | prev_sdai_data;
 755                         prev_sdai_data = sdai_changes.value;
 756
 757                         logged_cpcap_write(state->cpcap, CPCAP_REG_SDACDI,
 758                                         sdai_changes.value, sdai_changes.mask);
 759
 760                         /* Clock tree change -- reset and wait */
 761                         stdac_freq_config |= CPCAP_BIT_ST_CLOCK_TREE_RESET;
 762
 763                         logged_cpcap_write(state->cpcap, CPCAP_REG_SDAC,
 764                                 stdac_freq_config, SDAC_RESET_FREQ_MASK);
 765
 766                         /* Wait for clock tree reset to complete */
 767                         mdelay(CLOCK_TREE_RESET_DELAY_MS);
 768                 }
 769
 770                 /* Clear old settings */
 771                 stdac_changes.mask = stdac_changes.value | prev_stdac_data;
 772                 prev_stdac_data = stdac_changes.value;
 773
 774                 if ((stdac_changes.value | CPCAP_BIT_ST_DAC_EN) &&
 775                     (state->cpcap->vendor == CPCAP_VENDOR_ST)) {
 776                         logged_cpcap_write(state->cpcap, CPCAP_REG_TEST,
 777                                            STM_STDAC_EN_TEST_PRE, 0xFFFF);
 778                         logged_cpcap_write(state->cpcap, CPCAP_REG_ST_TEST1,
 779                                            STM_STDAC_EN_ST_TEST1_PRE, 0xFFFF);
 780                 }
 781
 782                 logged_cpcap_write(state->cpcap, CPCAP_REG_SDAC,
 783                         stdac_changes.value, stdac_changes.mask);
 784
 785                 if ((stdac_changes.value | CPCAP_BIT_ST_DAC_EN) &&
 786                     (state->cpcap->vendor == CPCAP_VENDOR_ST)) {
 787                         msleep(STM_STDAC_ACTIVATE_RAMP_TIME);
 788                         logged_cpcap_write(state->cpcap, CPCAP_REG_ST_TEST1,
 789                                            STM_STDAC_EN_ST_TEST1_POST, 0xFFFF);
 790                         logged_cpcap_write(state->cpcap, CPCAP_REG_TEST,
 791                                            STM_STDAC_EN_TEST_POST, 0xFFFF);
 792                 }
 793         }
 794 }
 795
 796 static void cpcap_audio_configure_analog_source(
 797         struct cpcap_audio_state *state,
 798         struct cpcap_audio_state *prev)
 799 {
 800         if (state->analog_source != prev->analog_source) {
 801                 struct cpcap_regacc ext_changes = { 0 };
 802                 static unsigned int prev_ext_data;
 803                 switch (state->analog_source) {
 804                 case CPCAP_AUDIO_ANALOG_SOURCE_STEREO:
 805                         ext_changes.value |= CPCAP_BIT_MONO_EXT0 |
 806                                 CPCAP_BIT_PGA_IN_R_SW | CPCAP_BIT_PGA_IN_L_SW;
 807                         break;
 808                 case CPCAP_AUDIO_ANALOG_SOURCE_L:
 809                         ext_changes.value |= CPCAP_BIT_MONO_EXT1 |
 810                                                 CPCAP_BIT_PGA_IN_L_SW;
 811                         break;
 812                 case CPCAP_AUDIO_ANALOG_SOURCE_R:
 813                         ext_changes.value |= CPCAP_BIT_MONO_EXT1 |
 814                                                 CPCAP_BIT_PGA_IN_R_SW;
 815                         break;
 816                 default:
 817                         break;
 818                 }
 819
 820                 ext_changes.mask = ext_changes.value | prev_ext_data;
 821
 822                 prev_ext_data = ext_changes.value;
 823
 824                 logged_cpcap_write(state->cpcap, CPCAP_REG_RXEPOA,
 825                                 ext_changes.value, ext_changes.mask);
 826         }
 827 }
 828
 829 static void cpcap_audio_configure_input_gains(
 830         struct cpcap_audio_state *state,
 831         struct cpcap_audio_state *prev)
 832 {
 833         if (state->input_gain != prev->input_gain) {
 834                 struct cpcap_regacc reg_changes = { 0 };
 835                 unsigned int temp_input_gain = state->input_gain & 0x0000001F;
 836
 837                 reg_changes.value |= ((temp_input_gain << 5) | temp_input_gain);
 838
 839                 reg_changes.mask = 0x3FF;
 840
 841                 logged_cpcap_write(state->cpcap, CPCAP_REG_TXMP,
 842                                 reg_changes.value, reg_changes.mask);
 843         }
 844 }
 845
 846 static void cpcap_audio_configure_output_gains(
 847         struct cpcap_audio_state *state,
 848         struct cpcap_audio_state *prev)
 849 {
 850         if (state->output_gain != prev->output_gain) {
 851                 struct cpcap_regacc reg_changes = { 0 };
 852                 unsigned int temp_output_gain = state->output_gain & 0x0000000F;
 853
 854                 reg_changes.value |=
 855                     ((temp_output_gain << 2) | (temp_output_gain << 8));
 856                 /* VOL_EXTx is disabled, it's not connected, disable to reduce
 857                  * noise.  If you need it, add | (temp_output_gain << 12)
 858                  */
 859                 reg_changes.mask = 0xFF3C;
 860
 861                 logged_cpcap_write(state->cpcap, CPCAP_REG_RXVC,
 862                                 reg_changes.value, reg_changes.mask);
 863         }
 864 }
 865
 866 static void cpcap_audio_configure_output(
 867         struct cpcap_audio_state *state,
 868         struct cpcap_audio_state *prev)
 869 {
 870         static unsigned int prev_aud_out_data;
 871
 872         bool activate_ext_loudspeaker = false;
 873         struct cpcap_regacc reg_changes = { 0 };
 874
 875         if (!is_output_changed(prev, state) &&
 876                         !is_codec_changed(prev, state) &&
 877                         !is_stdac_changed(prev, state))
 878                 return;
 879
 880         cpcap_audio_set_output_amp_switches(state);
 881
 882         activate_ext_loudspeaker = cpcap_audio_set_bits_for_speaker(
 883                                         state->codec_primary_speaker,
 884                                          state->codec_primary_balance,
 885                                          &(reg_changes.value));
 886
 887         activate_ext_loudspeaker = activate_ext_loudspeaker ||
 888                                 cpcap_audio_set_bits_for_speaker(
 889                                         state->codec_secondary_speaker,
 890                                          CPCAP_AUDIO_BALANCE_NEUTRAL,
 891                                          &(reg_changes.value));
 892
 893         activate_ext_loudspeaker = activate_ext_loudspeaker ||
 894                                 cpcap_audio_set_bits_for_speaker(
 895                                         state->stdac_primary_speaker,
 896                                          state->stdac_primary_balance,
 897                                          &(reg_changes.value));
 898
 899         activate_ext_loudspeaker = activate_ext_loudspeaker ||
 900                                 cpcap_audio_set_bits_for_speaker(
 901                                         state->stdac_secondary_speaker,
 902                                          CPCAP_AUDIO_BALANCE_NEUTRAL,
 903                                          &(reg_changes.value));
 904
 905         activate_ext_loudspeaker = activate_ext_loudspeaker ||
 906                                 cpcap_audio_set_bits_for_speaker(
 907                                         state->ext_primary_speaker,
 908                                          state->ext_primary_balance,
 909                                          &(reg_changes.value));
 910
 911         activate_ext_loudspeaker = activate_ext_loudspeaker ||
 912                                 cpcap_audio_set_bits_for_speaker(
 913                                         state->ext_secondary_speaker,
 914                                          CPCAP_AUDIO_BALANCE_NEUTRAL,
 915                                          &(reg_changes.value));
 916
 917         reg_changes.mask = reg_changes.value | prev_aud_out_data;
 918
 919         prev_aud_out_data = reg_changes.value;
 920
 921         /* Sleep for 300ms if we are getting into a call to allow the switch to
 922          * settle.  If we don't do this, it causes a loud pop at the beginning
 923          * of the call.
 924          */
 925         if (state->rat_type == CPCAP_AUDIO_RAT_CDMA &&
 926                         state->ext_primary_speaker != CPCAP_AUDIO_OUT_NONE &&
 927                         prev->ext_primary_speaker == CPCAP_AUDIO_OUT_NONE)
 928                 msleep(300);
 929
 930         logged_cpcap_write(state->cpcap, CPCAP_REG_RXOA,
 931                                 reg_changes.value, reg_changes.mask);
 932 }
 933
 934 static inline bool codec_loopback_changed(struct cpcap_audio_state *new,
 935                         struct cpcap_audio_state *old)
 936 {
 937         return (new->codec_mode != old->codec_mode) &&
 938                 (new->codec_mode == CPCAP_AUDIO_CODEC_LOOPBACK ||
 939                  old->codec_mode == CPCAP_AUDIO_CODEC_LOOPBACK);
 940 }
 941
 942 static void cpcap_audio_configure_input(struct cpcap_audio_state *state,
 943                         struct cpcap_audio_state *prev)
 944 {
 945         static unsigned int prev_input_data = 0x0;
 946         struct cpcap_regacc reg_changes = { 0 };
 947         bool bias_settle = false;
 948
 949         if (state->microphone == prev->microphone &&
 950                         !codec_loopback_changed(state, prev))
 951                 return;
 952
 953         if (state->codec_mode == CPCAP_AUDIO_CODEC_LOOPBACK)
 954                 reg_changes.value |= CPCAP_BIT_DLM;
 955
 956         if (prev->microphone == CPCAP_AUDIO_IN_HEADSET)
 957                 logged_cpcap_write(state->cpcap, CPCAP_REG_GPIO4,
 958                                                 0, CPCAP_BIT_GPIO4DRV);
 959
 960         switch (state->microphone) {
 961         case CPCAP_AUDIO_IN_HANDSET:
 962                 pr_debug("%s: handset\n", __func__);
 963                 reg_changes.value |= CPCAP_BIT_MB_ON1R
 964                         | CPCAP_BIT_MIC1_MUX | CPCAP_BIT_MIC1_PGA_EN;
 965                 bias_settle = true;
 966                 break;
 967
 968         case CPCAP_AUDIO_IN_HEADSET:
 969                 pr_debug("%s: headset\n", __func__);
 970                 reg_changes.value |= CPCAP_BIT_HS_MIC_MUX
 971                         | CPCAP_BIT_MIC1_PGA_EN;
 972                 if (state->rat_type == CPCAP_AUDIO_RAT_CDMA)
 973                         logged_cpcap_write(state->cpcap, CPCAP_REG_GPIO4,
 974                                 CPCAP_BIT_GPIO4DRV, CPCAP_BIT_GPIO4DRV);
 975                 bias_settle = true;
 976                 break;
 977
 978         case CPCAP_AUDIO_IN_EXT_BUS:
 979                 reg_changes.value |=  CPCAP_BIT_EMU_MIC_MUX
 980                         | CPCAP_BIT_MIC1_PGA_EN;
 981                 break;
 982
 983         case CPCAP_AUDIO_IN_AUX_INTERNAL:
 984                 reg_changes.value |= CPCAP_BIT_MB_ON1L
 985                         | CPCAP_BIT_MIC2_MUX | CPCAP_BIT_MIC2_PGA_EN;
 986                 break;
 987
 988         case CPCAP_AUDIO_IN_DUAL_INTERNAL:
 989                 reg_changes.value |= CPCAP_BIT_MB_ON1R
 990                         | CPCAP_BIT_MIC1_MUX | CPCAP_BIT_MIC1_PGA_EN
 991                         | CPCAP_BIT_MB_ON1L | CPCAP_BIT_MIC2_MUX
 992                         | CPCAP_BIT_MIC2_PGA_EN;
 993                 break;
 994
 995         case CPCAP_AUDIO_IN_DUAL_EXTERNAL:
 996                 reg_changes.value |= CPCAP_BIT_RX_R_ENCODE
 997                         | CPCAP_BIT_RX_L_ENCODE;
 998                 break;
 999
1000         case CPCAP_AUDIO_IN_BT_MONO:
1001         default:
1002                 reg_changes.value = 0;
1003                 break;
1004         }
1005
1006         reg_changes.mask = reg_changes.value | prev_input_data;
1007         prev_input_data = reg_changes.value;
1008
1009         logged_cpcap_write(state->cpcap, CPCAP_REG_TXI,
1010                                 reg_changes.value, reg_changes.mask);
1011         if (bias_settle)
1012                 msleep(MICBIAS_WARMUP_TIME_MS);
1013 }
1014
1015 static void cpcap_audio_configure_power(int power)
1016 {
1017         static int previous_power;
1018
1019         pr_debug("%s() called with power= %d\n", __func__, power);
1020
1021         if (power == previous_power)
1022                 return;
1023
1024         if (IS_ERR_OR_NULL(audio_reg)) {
1025                 E("audio_reg not valid for regulator setup\n");
1026                 return;
1027         }
1028
1029         if (power) {
1030                 pr_info("%s: regulator -> enable\n", __func__);
1031                 regulator_enable(audio_reg);
1032                 regulator_set_mode(audio_reg, REGULATOR_MODE_NORMAL);
1033                 mdelay(SLEEP_ACTIVATE_POWER_DELAY_MS);
1034         } else {
1035                 pr_info("%s: regulator -> standby\n", __func__);
1036                 regulator_set_mode(audio_reg, REGULATOR_MODE_STANDBY);
1037                 regulator_disable(audio_reg);
1038         }
1039
1040         previous_power = power;
1041 }
1042
1043 static void cpcap_activate_whisper_emu_audio(struct cpcap_audio_state *state)
1044 {
1045         struct cpcap_regacc reg_changes;
1046
1047         pr_debug("%s() called\n", __func__);
1048
1049         if (is_output_whisper_emu(state)) {
1050                 reg_changes.mask |= CPCAP_BIT_DIG_AUD_IN;
1051                 reg_changes.value = 0;
1052                 logged_cpcap_write(state->cpcap, CPCAP_REG_CDI,
1053                                    reg_changes.value, reg_changes.mask);
1054         }
1055 }
1056
1057 void cpcap_audio_state_dump(struct cpcap_audio_state *state)
1058 {
1059         pr_info("mode = %d",  state->mode);
1060         pr_info("codec_mode = %d", state->codec_mode);
1061         pr_info("codec_rate = %d", state->codec_rate);
1062         pr_info("codec_mute = %d", state->codec_mute);
1063         pr_info("stdac_mode = %d", state->stdac_mode);
1064         pr_info("stdac_rate = %d", state->stdac_rate);
1065         pr_info("stdac_mute = %d", state->stdac_mute);
1066         pr_info("analog_source = %d", state->analog_source);
1067         pr_info("codec_primary_speaker = %d", state->codec_primary_speaker);
1068         pr_info("codec_secondary_speaker = %d", state->codec_secondary_speaker);
1069         pr_info("stdac_primary_speaker = %d", state->stdac_primary_speaker);
1070         pr_info("stdac_secondary_speaker = %d", state->stdac_secondary_speaker);
1071         pr_info("ext_primary_speaker = %d", state->ext_primary_speaker);
1072         pr_info("ext_secondary_speaker = %d", state->ext_secondary_speaker);
1073         pr_info("codec_primary_balance = %d", state->codec_primary_balance);
1074         pr_info("stdac_primary_balance = %d", state->stdac_primary_balance);
1075         pr_info("ext_primary_balance = %d", state->ext_primary_balance);
1076         pr_info("output_gain = %d", state->output_gain);
1077         pr_info("microphone = %d",  state->microphone);
1078         pr_info("input_gain = %d", state->input_gain);
1079         pr_info("rat_type = %d\n", state->rat_type);
1080 }
1081
1082 void cpcap_audio_register_dump(struct cpcap_audio_state *state)
1083 {
1084         unsigned short reg_val = 0;
1085
1086         cpcap_regacc_read(state->cpcap, CPCAP_REG_VAUDIOC, &reg_val);
1087         printk(KERN_INFO "0x200[512] = %x\n", reg_val);
1088         cpcap_regacc_read(state->cpcap, CPCAP_REG_CC, &reg_val);
1089         printk(KERN_INFO "0x201[513] = %x\n", reg_val);
1090         cpcap_regacc_read(state->cpcap, CPCAP_REG_CDI, &reg_val);
1091         printk(KERN_INFO "0x202[514] = %x\n", reg_val);
1092         cpcap_regacc_read(state->cpcap, CPCAP_REG_SDAC, &reg_val);
1093         printk(KERN_INFO "0x203[515] = %x\n", reg_val);
1094         cpcap_regacc_read(state->cpcap, CPCAP_REG_SDACDI, &reg_val);
1095         printk(KERN_INFO "0x204[516] = %x\n", reg_val);
1096         cpcap_regacc_read(state->cpcap, CPCAP_REG_TXI, &reg_val);
1097         printk(KERN_INFO "0x205[517] = %x\n", reg_val);
1098         cpcap_regacc_read(state->cpcap, CPCAP_REG_TXMP, &reg_val);
1099         printk(KERN_INFO "0x206[518] = %x\n", reg_val);
1100         cpcap_regacc_read(state->cpcap, CPCAP_REG_RXOA, &reg_val);
1101         printk(KERN_INFO "0x207[519] = %x\n", reg_val);
1102         cpcap_regacc_read(state->cpcap, CPCAP_REG_RXVC, &reg_val);
1103         printk(KERN_INFO "0x208[520] = %x\n", reg_val);
1104         cpcap_regacc_read(state->cpcap, CPCAP_REG_RXCOA, &reg_val);
1105         printk(KERN_INFO "0x209[521] = %x\n", reg_val);
1106         cpcap_regacc_read(state->cpcap, CPCAP_REG_RXSDOA, &reg_val);
1107         printk(KERN_INFO "0x20A[522] = %x\n", reg_val);
1108         cpcap_regacc_read(state->cpcap, CPCAP_REG_RXEPOA, &reg_val);
1109         printk(KERN_INFO "0x20B[523] = %x\n", reg_val);
1110         cpcap_regacc_read(state->cpcap, CPCAP_REG_RXLL, &reg_val);
1111         printk(KERN_INFO "0x20C[524] = %x\n", reg_val);
1112         cpcap_regacc_read(state->cpcap, CPCAP_REG_A2LA, &reg_val);
1113         printk(KERN_INFO "0x20D[525] = %x\n", reg_val);
1114         cpcap_regacc_read(state->cpcap, CPCAP_REG_USBC2, &reg_val);
1115         printk(KERN_INFO "0x381[897] = %x\n", reg_val);
1116 }
1117
1118 static inline bool should_power_on(struct cpcap_audio_state *state)
1119 {
1120         if (state->codec_mode != CPCAP_AUDIO_CODEC_OFF &&
1121                         state->codec_mode != CPCAP_AUDIO_CODEC_CLOCK_ONLY)
1122                 return true;
1123
1124         if (state->stdac_mode != CPCAP_AUDIO_STDAC_OFF)
1125                 return true;
1126
1127         if (state->codec_primary_speaker != CPCAP_AUDIO_OUT_NONE &&
1128                         state->codec_primary_speaker !=
1129                                 CPCAP_AUDIO_OUT_BT_MONO)
1130                 return true;
1131
1132         if (state->stdac_primary_speaker != CPCAP_AUDIO_OUT_NONE)
1133                 return true;
1134
1135         if (state->ext_primary_speaker != CPCAP_AUDIO_OUT_NONE)
1136                 return true;
1137
1138         if (state->microphone != CPCAP_AUDIO_IN_NONE &&
1139                         state->microphone != CPCAP_AUDIO_IN_BT_MONO)
1140                 return true;
1141
1142         return false;
1143 }
1144
1145 void cpcap_audio_set_audio_state(struct cpcap_audio_state *state)
1146 {
1147         bool power_on;
1148         struct cpcap_audio_state *prev = &current_state;
1149
1150         if (state->codec_mute == CPCAP_AUDIO_CODEC_BYPASS_LOOP)
1151                 state->codec_mode = CPCAP_AUDIO_CODEC_ON;
1152
1153         if (state->codec_mode == CPCAP_AUDIO_CODEC_OFF ||
1154                         state->codec_mode == CPCAP_AUDIO_CODEC_CLOCK_ONLY ||
1155                         state->rat_type == CPCAP_AUDIO_RAT_CDMA)
1156                 state->codec_mute = CPCAP_AUDIO_CODEC_MUTE;
1157         else
1158                 state->codec_mute = CPCAP_AUDIO_CODEC_UNMUTE;
1159
1160         if (state->stdac_mode != CPCAP_AUDIO_STDAC_ON)
1161                 state->stdac_mute = CPCAP_AUDIO_STDAC_MUTE;
1162         else
1163                 state->stdac_mute = CPCAP_AUDIO_STDAC_UNMUTE;
1164
1165         if (state->stdac_mode == CPCAP_AUDIO_STDAC_CLOCK_ONLY)
1166                 state->stdac_mode = CPCAP_AUDIO_STDAC_ON;
1167
1168         power_on = should_power_on(state);
1169
1170         if (power_on)
1171                 cpcap_audio_configure_power(1);
1172
1173         if (is_speaker_turning_off(state, prev))
1174                 cpcap_audio_configure_output(state, prev);
1175
1176         cpcap_audio_configure_analog_source(state, prev);
1177
1178         cpcap_audio_configure_input(state, prev);
1179
1180         cpcap_audio_configure_input_gains(state, prev);
1181
1182         if (is_codec_changed(state, prev) || is_stdac_changed(state, prev)) {
1183                 int codec_mute = state->codec_mute;
1184                 int stdac_mute = state->stdac_mute;
1185
1186                 if (is_codec_changed(state, prev))
1187                         state->codec_mute = CPCAP_AUDIO_CODEC_MUTE;
1188                 if (is_stdac_changed(state, prev))
1189                         state->stdac_mute = CPCAP_AUDIO_STDAC_MUTE;
1190
1191                 cpcap_audio_configure_aud_mute(state, prev);
1192
1193                 prev->codec_mute = state->codec_mute;
1194                 prev->stdac_mute = state->stdac_mute;
1195
1196                 state->codec_mute = codec_mute;
1197                 state->stdac_mute = stdac_mute;
1198
1199                 cpcap_audio_configure_codec(state, prev);
1200                 cpcap_audio_configure_stdac(state, prev);
1201         }
1202
1203         cpcap_audio_configure_output(state, prev);
1204
1205         cpcap_audio_configure_output_gains(state, prev);
1206
1207         cpcap_audio_configure_aud_mute(state, prev);
1208
1209         cpcap_activate_whisper_emu_audio(state);
1210
1211         if (!power_on)
1212                 cpcap_audio_configure_power(0);
1213
1214         current_state = *state;
1215 }
1216
1217 int cpcap_audio_init(struct cpcap_audio_state *state, const char *regulator)
1218 {
1219         logged_cpcap_write(state->cpcap, CPCAP_REG_CC, 0, 0xFFFF);
1220         logged_cpcap_write(state->cpcap, CPCAP_REG_CDI, 0, 0xBFFF);
1221         logged_cpcap_write(state->cpcap, CPCAP_REG_SDAC, 0, 0xFFF);
1222         logged_cpcap_write(state->cpcap, CPCAP_REG_SDACDI, 0, 0x3FFF);
1223         logged_cpcap_write(state->cpcap, CPCAP_REG_TXI, 0, 0xFDF);
1224         logged_cpcap_write(state->cpcap, CPCAP_REG_TXMP, 0, 0xFFF);
1225         logged_cpcap_write(state->cpcap, CPCAP_REG_RXOA, 0, 0x1FF);
1226         /* logged_cpcap_write(state->cpcap, CPCAP_REG_RXVC, 0, 0xFFF); */
1227         logged_cpcap_write(state->cpcap, CPCAP_REG_RXCOA, 0, 0x7FF);
1228         logged_cpcap_write(state->cpcap, CPCAP_REG_RXSDOA, 0, 0x1FFF);
1229         logged_cpcap_write(state->cpcap, CPCAP_REG_RXEPOA, 0, 0x7FFF);
1230
1231         /* Use free running clock for amplifiers */
1232         logged_cpcap_write(state->cpcap, CPCAP_REG_A2LA,
1233                 CPCAP_BIT_A2_FREE_RUN,
1234                 CPCAP_BIT_A2_FREE_RUN);
1235
1236         logged_cpcap_write(state->cpcap, CPCAP_REG_GPIO4,
1237                            CPCAP_BIT_GPIO4DIR, CPCAP_BIT_GPIO4DIR);
1238
1239         audio_reg = regulator_get(NULL, regulator);
1240
1241         if (IS_ERR(audio_reg)) {
1242                 E("could not get regulator for audio\n");
1243                 return PTR_ERR(audio_reg);
1244         }
1245
1246         return 0;
1247 }
1248
1249 #ifdef CONFIG_DEBUG_FS
1250
1251 #include <linux/debugfs.h>
1252 #include <linux/seq_file.h>
1253
1254 enum {
1255         DEBUG_CPCAP_AUDIO_MODE,
1256         DEBUG_CPCAP_AUDIO_CODEC_MODE,
1257         DEBUG_CPCAP_AUDIO_CODEC_RATE,
1258         DEBUG_CPCAP_AUDIO_CODEC_MUTE,
1259         DEBUG_CPCAP_AUDIO_STDAC_MODE,
1260         DEBUG_CPCAP_AUDIO_STDAC_RATE,
1261         DEBUG_CPCAP_AUDIO_STDAC_MUTE,
1262         DEBUG_CPCAP_AUDIO_ANALOG_SOURCE,
1263         DEBUG_CPCAP_AUDIO_CODEC_PRIMARY_SPEAKER,
1264         DEBUG_CPCAP_AUDIO_CODEC_SECONDARY_SPEAKER,
1265         DEBUG_CPCAP_AUDIO_STDAC_PRIMARY_SPEAKER,
1266         DEBUG_CPCAP_AUDIO_STDAC_SECONDARY_SPEAKER,
1267         DEBUG_CPCAP_AUDIO_EXT_PRIMARY_SPEAKER,
1268         DEBUG_CPCAP_AUDIO_EXT_SECONDARY_SPEAKER,
1269         DEBUG_CPCAP_AUDIO_CODEC_PRIMARY_BALANCE,
1270         DEBUG_CPCAP_AUDIO_STDAC_PRIMARY_BALANCE,
1271         DEBUG_CPCAP_AUDIO_EXT_PRIMARY_BALANCE,
1272         DEBUG_CPCAP_AUDIO_OUTPUT_GAIN,
1273         DEBUG_CPCAP_AUDIO_MICROPHONE,
1274         DEBUG_CPCAP_AUDIO_INPUT_GAIN,
1275         DEBUG_CPCAP_RAT_TYPE,
1276         DEBUG_CPCAP_NUM_FIELDS,
1277 };
1278 static struct cpcap_audio_state debug_state;
1279
1280 struct debug_audio_entry {
1281         int id;
1282         char *name;
1283         int min;
1284         int max;
1285         int *dbg_val;
1286         int *cur_val;
1287 };
1288
1289 #define DBG_ENTRY(_id, _min, _max, _fld)        \
1290 {                                               \
1291         .id = _id,                              \
1292         .name = #_fld,                          \
1293         .min = _min,                            \
1294         .max = _max,                            \
1295         .dbg_val = &debug_state._fld,           \
1296         .cur_val = &current_state._fld,         \
1297 }
1298
1299 static struct debug_audio_entry values[] = {
1300         DBG_ENTRY(DEBUG_CPCAP_AUDIO_MODE,
1301                   CPCAP_AUDIO_MODE_NORMAL, CPCAP_AUDIO_MODE_TTY,
1302                   mode),
1303
1304         DBG_ENTRY(DEBUG_CPCAP_AUDIO_CODEC_MODE,
1305                   CPCAP_AUDIO_CODEC_OFF, CPCAP_AUDIO_CODEC_LOOPBACK,
1306                   codec_mode),
1307         DBG_ENTRY(DEBUG_CPCAP_AUDIO_CODEC_RATE,
1308                   CPCAP_AUDIO_CODEC_RATE_8000_HZ,
1309                   CPCAP_AUDIO_CODEC_RATE_48000_HZ,
1310                   codec_rate),
1311         DBG_ENTRY(DEBUG_CPCAP_AUDIO_CODEC_MUTE,
1312                   CPCAP_AUDIO_CODEC_UNMUTE, CPCAP_AUDIO_CODEC_BYPASS_LOOP,
1313                   codec_mute),
1314
1315         DBG_ENTRY(DEBUG_CPCAP_AUDIO_STDAC_MODE,
1316                   CPCAP_AUDIO_STDAC_OFF, CPCAP_AUDIO_STDAC_ON,
1317                   stdac_mode),
1318         DBG_ENTRY(DEBUG_CPCAP_AUDIO_STDAC_RATE,
1319                   CPCAP_AUDIO_STDAC_RATE_8000_HZ,
1320                   CPCAP_AUDIO_STDAC_RATE_48000_HZ,
1321                   stdac_rate),
1322         DBG_ENTRY(DEBUG_CPCAP_AUDIO_STDAC_MUTE,
1323                   CPCAP_AUDIO_STDAC_UNMUTE, CPCAP_AUDIO_STDAC_MUTE,
1324                   stdac_mute),
1325
1326         DBG_ENTRY(DEBUG_CPCAP_AUDIO_ANALOG_SOURCE,
1327                   CPCAP_AUDIO_ANALOG_SOURCE_OFF,
1328                   CPCAP_AUDIO_ANALOG_SOURCE_STEREO,
1329                   analog_source),
1330
1331         DBG_ENTRY(DEBUG_CPCAP_AUDIO_CODEC_PRIMARY_SPEAKER,
1332                   CPCAP_AUDIO_OUT_NONE,
1333                   CPCAP_AUDIO_OUT_NUM_OF_PATHS - 1, codec_primary_speaker),
1334         DBG_ENTRY(DEBUG_CPCAP_AUDIO_CODEC_SECONDARY_SPEAKER,
1335                   CPCAP_AUDIO_OUT_NONE,
1336                   CPCAP_AUDIO_OUT_NUM_OF_PATHS - 1 , codec_secondary_speaker),
1337         DBG_ENTRY(DEBUG_CPCAP_AUDIO_STDAC_PRIMARY_SPEAKER,
1338                   CPCAP_AUDIO_OUT_NONE,
1339                   CPCAP_AUDIO_OUT_NUM_OF_PATHS - 1, stdac_primary_speaker),
1340         DBG_ENTRY(DEBUG_CPCAP_AUDIO_STDAC_SECONDARY_SPEAKER,
1341                   CPCAP_AUDIO_OUT_NONE,
1342                   CPCAP_AUDIO_OUT_NUM_OF_PATHS - 1, stdac_secondary_speaker),
1343         DBG_ENTRY(DEBUG_CPCAP_AUDIO_EXT_PRIMARY_SPEAKER,
1344                   CPCAP_AUDIO_OUT_NONE,
1345                   CPCAP_AUDIO_OUT_NUM_OF_PATHS - 1, ext_primary_speaker),
1346         DBG_ENTRY(DEBUG_CPCAP_AUDIO_EXT_SECONDARY_SPEAKER,
1347                   CPCAP_AUDIO_OUT_NONE,
1348                   CPCAP_AUDIO_OUT_NUM_OF_PATHS - 1, ext_secondary_speaker),
1349         DBG_ENTRY(DEBUG_CPCAP_AUDIO_CODEC_PRIMARY_BALANCE,
1350                   CPCAP_AUDIO_BALANCE_NEUTRAL,
1351                   CPCAP_AUDIO_BALANCE_L_ONLY, codec_primary_balance),
1352         DBG_ENTRY(DEBUG_CPCAP_AUDIO_STDAC_PRIMARY_BALANCE,
1353                   CPCAP_AUDIO_BALANCE_NEUTRAL,
1354                   CPCAP_AUDIO_BALANCE_L_ONLY, stdac_primary_balance),
1355         DBG_ENTRY(DEBUG_CPCAP_AUDIO_EXT_PRIMARY_BALANCE,
1356                   CPCAP_AUDIO_BALANCE_NEUTRAL,
1357                   CPCAP_AUDIO_BALANCE_L_ONLY, ext_primary_balance),
1358         DBG_ENTRY(DEBUG_CPCAP_AUDIO_OUTPUT_GAIN, 0, 50, output_gain),
1359         DBG_ENTRY(DEBUG_CPCAP_AUDIO_MICROPHONE, CPCAP_AUDIO_IN_NONE,
1360                   CPCAP_AUDIO_IN_NUM_OF_PATHS - 1, microphone),
1361         DBG_ENTRY(DEBUG_CPCAP_AUDIO_INPUT_GAIN, 0, 50, input_gain),
1362         DBG_ENTRY(DEBUG_CPCAP_RAT_TYPE,
1363                   CPCAP_AUDIO_RAT_NONE, CPCAP_AUDIO_RAT_CDMA,
1364                   rat_type),
1365 };
1366
1367 static int tegra_audio_debug_show(struct seq_file *s, void *data)
1368 {
1369         int field = (int) s->private;
1370
1371         if (field < DEBUG_CPCAP_NUM_FIELDS)
1372                 seq_printf(s, "%d\n", *values[field].cur_val);
1373
1374         return 0;
1375 }
1376
1377 static int tegra_audio_debug_open(struct inode *inode, struct file *file)
1378 {
1379         return single_open(file, tegra_audio_debug_show, inode->i_private);
1380 }
1381
1382 static int tegra_audio_debug_write(struct file *file,
1383                 const char __user *user_buf, size_t count, loff_t *ppos)
1384 {
1385         char buf[32];
1386         int buf_sz;
1387         long ival;
1388         struct seq_file *s = file->private_data;
1389         int field = (int) s->private;
1390
1391         buf_sz = min(count, (sizeof(buf)-1));
1392         if (copy_from_user(buf, user_buf, buf_sz))
1393                 return -EFAULT;
1394         buf[buf_sz] = 0;
1395
1396         debug_state = current_state;
1397
1398         if (strict_strtol(buf, 0, &ival))
1399                 return -EINVAL;
1400         if (ival < values[field].min || ival > values[field].max) {
1401                 pr_err("%s: invalid value %ld\n", __func__, ival);
1402                 return -EINVAL;
1403         }
1404
1405         *values[field].dbg_val = ival;
1406
1407         pr_info("%s setting %s to %ld\n", __func__,
1408                 values[field].name, ival);
1409
1410         cpcap_audio_set_audio_state(&debug_state);
1411         return count;
1412 }
1413
1414 static const struct file_operations tegra_audio_debug_fops = {
1415         .open       = tegra_audio_debug_open,
1416         .write      = tegra_audio_debug_write,
1417         .read       = seq_read,
1418         .llseek     = seq_lseek,
1419         .release    = single_release,
1420 };
1421
1422 static int __init tegra_audio_debug_init(void)
1423 {
1424         int i;
1425         struct dentry *d, *f;
1426
1427         d = debugfs_create_dir("cpcap_audio", NULL);
1428
1429         for (i = 0; i < DEBUG_CPCAP_NUM_FIELDS; i++) {
1430                 f = debugfs_create_file(values[i].name, 0755, d,
1431                                         (void *) values[i].id,
1432                                         &tegra_audio_debug_fops);
1433         }
1434
1435         return 0;
1436 }
1437
1438 late_initcall(tegra_audio_debug_init);
1439 #endif /* CONFIG_DEBUG_FS */