drivers/staging/intel_sst/intelmid_v2_control.c

   1 /*
   2  *  intelmid_v2_control.c - Intel Sound card driver for MID
   3  *
   4  *  Copyright (C) 2008-10 Intel Corp
   5  *  Authors:    Vinod Koul <vinod.koul@intel.com>
   6  *              Harsha Priya <priya.harsha@intel.com>
   7  *              KP Jeeja <jeeja.kp@intel.com>
   8  *              Dharageswari R <dharageswari.r@intel.com>
   9  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; version 2 of the License.
  14  *
  15  *  This program is distributed in the hope that it will be useful, but
  16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  *  General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License along
  21  *  with this program; if not, write to the Free Software Foundation, Inc.,
  22  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  23  *
  24  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  25  *
  26  *  This file contains the control operations of vendor 3
  27  */
  28
  29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  30
  31 #include <linux/pci.h>
  32 #include <linux/file.h>
  33 #include "intel_sst.h"
  34 #include "intelmid_snd_control.h"
  35
  36 enum reg_v3 {
  37         VAUDIOCNT = 0x51,
  38         VOICEPORT1 = 0x100,
  39         VOICEPORT2 = 0x101,
  40         AUDIOPORT1 = 0x102,
  41         AUDIOPORT2 = 0x103,
  42         ADCSAMPLERATE = 0x104,
  43         DMICCTRL1 = 0x105,
  44         DMICCTRL2 = 0x106,
  45         MICCTRL = 0x107,
  46         MICSELVOL = 0x108,
  47         LILSEL = 0x109,
  48         LIRSEL = 0x10a,
  49         VOICEVOL = 0x10b,
  50         AUDIOLVOL = 0x10c,
  51         AUDIORVOL = 0x10d,
  52         LMUTE = 0x10e,
  53         RMUTE = 0x10f,
  54         POWERCTRL1 = 0x110,
  55         POWERCTRL2 = 0x111,
  56         DRVPOWERCTRL = 0x112,
  57         VREFPLL = 0x113,
  58         PCMBUFCTRL = 0x114,
  59         SOFTMUTE = 0x115,
  60         DTMFPATH = 0x116,
  61         DTMFVOL = 0x117,
  62         DTMFFREQ = 0x118,
  63         DTMFHFREQ = 0x119,
  64         DTMFLFREQ = 0x11a,
  65         DTMFCTRL = 0x11b,
  66         DTMFASON = 0x11c,
  67         DTMFASOFF = 0x11d,
  68         DTMFASINUM = 0x11e,
  69         CLASSDVOL = 0x11f,
  70         VOICEDACAVOL = 0x120,
  71         AUDDACAVOL = 0x121,
  72         LOMUTEVOL = 0x122,
  73         HPLVOL = 0x123,
  74         HPRVOL = 0x124,
  75         MONOVOL = 0x125,
  76         LINEOUTMIXVOL = 0x126,
  77         EPMIXVOL = 0x127,
  78         LINEOUTLSEL = 0x128,
  79         LINEOUTRSEL = 0x129,
  80         EPMIXOUTSEL = 0x12a,
  81         HPLMIXSEL = 0x12b,
  82         HPRMIXSEL = 0x12c,
  83         LOANTIPOP = 0x12d,
  84 };
  85
  86 /****
  87  * nc_init_card - initialize the sound card
  88  *
  89  * This initializes the audio paths to know values in case of this sound card
  90  */
  91 static int nc_init_card(void)
  92 {
  93         struct sc_reg_access sc_access[] = {
  94                 {VAUDIOCNT, 0x25, 0},
  95                 {VOICEPORT1, 0x00, 0},
  96                 {VOICEPORT2, 0x00, 0},
  97                 {AUDIOPORT1, 0x98, 0},
  98                 {AUDIOPORT2, 0x09, 0},
  99                 {AUDIOLVOL, 0x00, 0},
 100                 {AUDIORVOL, 0x00, 0},
 101                 {LMUTE, 0x03, 0},
 102                 {RMUTE, 0x03, 0},
 103                 {POWERCTRL1, 0x00, 0},
 104                 {POWERCTRL2, 0x00, 0},
 105                 {DRVPOWERCTRL, 0x00, 0},
 106                 {VREFPLL, 0x10, 0},
 107                 {HPLMIXSEL, 0xee, 0},
 108                 {HPRMIXSEL, 0xf6, 0},
 109                 {PCMBUFCTRL, 0x0, 0},
 110                 {VOICEVOL, 0x0e, 0},
 111                 {HPLVOL, 0x06, 0},
 112                 {HPRVOL, 0x06, 0},
 113                 {MICCTRL, 0x41, 0x00},
 114                 {ADCSAMPLERATE, 0x8B, 0x00},
 115                 {MICSELVOL, 0x5B, 0x00},
 116                 {LILSEL, 0x06, 0},
 117                 {LIRSEL, 0x46, 0},
 118                 {LOANTIPOP, 0x00, 0},
 119                 {DMICCTRL1, 0x40, 0},
 120         };
 121         snd_pmic_ops_nc.card_status = SND_CARD_INIT_DONE;
 122         snd_pmic_ops_nc.master_mute = UNMUTE;
 123         snd_pmic_ops_nc.mute_status = UNMUTE;
 124         sst_sc_reg_access(sc_access, PMIC_WRITE, 26);
 125         pr_debug("init complete!!\n");
 126         return 0;
 127 }
 128
 129 static int nc_enable_audiodac(int value)
 130 {
 131         struct sc_reg_access sc_access[3];
 132         int mute_val = 0;
 133
 134         if (snd_pmic_ops_nc.mute_status == MUTE)
 135                 return 0;
 136
 137         if (((snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE) ||
 138                 (snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)) &&
 139                 (value == UNMUTE))
 140                 return 0;
 141         if (value == UNMUTE) {
 142                         /* unmute the system, set the 7th bit to zero */
 143                         mute_val = 0x00;
 144                 } else {
 145                         /* MUTE:Set the seventh bit */
 146                         mute_val = 0x04;
 147
 148                 }
 149                 sc_access[0].reg_addr = LMUTE;
 150                 sc_access[1].reg_addr = RMUTE;
 151                 sc_access[0].mask = sc_access[1].mask = MASK2;
 152                 sc_access[0].value = sc_access[1].value = mute_val;
 153
 154                 if (snd_pmic_ops_nc.num_channel == 1)
 155                         sc_access[1].value = 0x04;
 156                 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 157
 158 }
 159
 160 static int nc_power_up_pb(unsigned int port)
 161 {
 162         struct sc_reg_access sc_access[7];
 163         int retval = 0;
 164
 165         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 166                 retval = nc_init_card();
 167         if (retval)
 168                 return retval;
 169         if (port == 0xFF)
 170                 return 0;
 171         nc_enable_audiodac(MUTE);
 172         msleep(30);
 173
 174         pr_debug("powering up pb....\n");
 175
 176         sc_access[0].reg_addr = VAUDIOCNT;
 177         sc_access[0].value = 0x27;
 178         sc_access[0].mask = 0x27;
 179         sc_access[1].reg_addr = VREFPLL;
 180         if (port == 0) {
 181                 sc_access[1].value = 0x3A;
 182                 sc_access[1].mask = 0x3A;
 183         } else if (port == 1) {
 184                 sc_access[1].value = 0x35;
 185                 sc_access[1].mask = 0x35;
 186         }
 187         retval =  sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 188
 189
 190
 191         sc_access[0].reg_addr = POWERCTRL1;
 192         if (port == 0) {
 193                 sc_access[0].value = 0x40;
 194                 sc_access[0].mask = 0x40;
 195         } else if (port == 1) {
 196                 sc_access[0].value = 0x01;
 197                 sc_access[0].mask = 0x01;
 198         }
 199         sc_access[1].reg_addr = POWERCTRL2;
 200         sc_access[1].value = 0x0C;
 201         sc_access[1].mask = 0x0C;
 202
 203         sc_access[2].reg_addr = DRVPOWERCTRL;
 204         sc_access[2].value = 0x86;
 205         sc_access[2].mask = 0x86;
 206
 207         sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
 208
 209         msleep(30);
 210
 211         return nc_enable_audiodac(UNMUTE);
 212
 213 }
 214
 215 static int nc_power_up_cp(unsigned int port)
 216 {
 217         struct sc_reg_access sc_access[5];
 218         int retval = 0;
 219
 220
 221         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 222                 retval = nc_init_card();
 223         if (retval)
 224                 return retval;
 225
 226
 227         pr_debug("powering up cp....\n");
 228
 229         if (port == 0xFF)
 230                 return 0;
 231         sc_access[0].reg_addr = VAUDIOCNT;
 232         sc_access[0].value = 0x27;
 233         sc_access[0].mask = 0x27;
 234         sc_access[1].reg_addr = VREFPLL;
 235         if (port == 0) {
 236                 sc_access[1].value = 0x3E;
 237                 sc_access[1].mask = 0x3E;
 238         } else if (port == 1) {
 239                 sc_access[1].value = 0x35;
 240                 sc_access[1].mask = 0x35;
 241         }
 242
 243         retval =  sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 244
 245
 246         sc_access[0].reg_addr = POWERCTRL1;
 247         if (port == 0) {
 248                 sc_access[0].value = 0xB4;
 249                 sc_access[0].mask = 0xB4;
 250         } else if (port == 1) {
 251                 sc_access[0].value = 0xBF;
 252                 sc_access[0].mask = 0xBF;
 253         }
 254         sc_access[1].reg_addr = POWERCTRL2;
 255         if (port == 0) {
 256                 sc_access[1].value = 0x0C;
 257                 sc_access[1].mask = 0x0C;
 258         } else if (port == 1) {
 259                 sc_access[1].value = 0x02;
 260                 sc_access[1].mask = 0x02;
 261         }
 262
 263         return  sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 264
 265 }
 266
 267 static int nc_power_down(void)
 268 {
 269         int retval = 0;
 270         struct sc_reg_access sc_access[5];
 271
 272
 273         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 274                 retval = nc_init_card();
 275         if (retval)
 276                 return retval;
 277         nc_enable_audiodac(MUTE);
 278
 279
 280         pr_debug("powering dn nc_power_down ....\n");
 281
 282         msleep(30);
 283
 284         sc_access[0].reg_addr = DRVPOWERCTRL;
 285         sc_access[0].value = 0x00;
 286         sc_access[0].mask = 0x00;
 287
 288         sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
 289
 290         sc_access[0].reg_addr = POWERCTRL1;
 291         sc_access[0].value = 0x00;
 292         sc_access[0].mask = 0x00;
 293
 294         sc_access[1].reg_addr = POWERCTRL2;
 295         sc_access[1].value = 0x00;
 296         sc_access[1].mask = 0x00;
 297
 298
 299
 300         sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
 301
 302         msleep(30);
 303         sc_access[0].reg_addr = VREFPLL;
 304         sc_access[0].value = 0x10;
 305         sc_access[0].mask = 0x10;
 306
 307         sc_access[1].reg_addr = VAUDIOCNT;
 308         sc_access[1].value = 0x25;
 309         sc_access[1].mask = 0x25;
 310
 311
 312         retval =  sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
 313
 314         msleep(30);
 315         return nc_enable_audiodac(UNMUTE);
 316 }
 317
 318 static int nc_power_down_pb(void)
 319 {
 320
 321         int retval = 0;
 322         struct sc_reg_access sc_access[5];
 323
 324         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 325                 retval = nc_init_card();
 326         if (retval)
 327                 return retval;
 328
 329         pr_debug("powering dn pb....\n");
 330
 331         nc_enable_audiodac(MUTE);
 332
 333
 334         msleep(30);
 335
 336
 337         sc_access[0].reg_addr = DRVPOWERCTRL;
 338         sc_access[0].value = 0x00;
 339         sc_access[0].mask = 0x00;
 340
 341         sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
 342
 343         msleep(30);
 344
 345         sc_access[0].reg_addr = POWERCTRL1;
 346         sc_access[0].value = 0x00;
 347         sc_access[0].mask = 0x41;
 348
 349         sc_access[1].reg_addr = POWERCTRL2;
 350         sc_access[1].value = 0x00;
 351         sc_access[1].mask = 0x0C;
 352
 353         sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 354
 355         msleep(30);
 356
 357         return nc_enable_audiodac(UNMUTE);
 358
 359
 360 }
 361
 362 static int nc_power_down_cp(void)
 363 {
 364         struct sc_reg_access sc_access[] = {
 365                 {POWERCTRL1, 0x00, 0xBE},
 366                 {POWERCTRL2, 0x00, 0x02},
 367         };
 368         int retval = 0;
 369
 370         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 371                 retval = nc_init_card();
 372         if (retval)
 373                 return retval;
 374
 375         pr_debug("powering dn cp....\n");
 376         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 377 }
 378
 379 static int nc_set_pcm_voice_params(void)
 380 {
 381         struct sc_reg_access sc_access[] = {
 382                         {0x100, 0xD5, 0},
 383                         {0x101, 0x08, 0},
 384                         {0x104, 0x03, 0},
 385                         {0x107, 0x10, 0},
 386                         {0x10B, 0x0E, 0},
 387                         {0x10E, 0x03, 0},
 388                         {0x10F, 0x03, 0},
 389                         {0x114, 0x13, 0},
 390                         {0x115, 0x00, 0},
 391                         {0x128, 0xFE, 0},
 392                         {0x129, 0xFE, 0},
 393                         {0x12A, 0xFE, 0},
 394                         {0x12B, 0xDE, 0},
 395                         {0x12C, 0xDE, 0},
 396         };
 397         int retval = 0;
 398
 399         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 400                 retval = nc_init_card();
 401         if (retval)
 402                 return retval;
 403
 404         sst_sc_reg_access(sc_access, PMIC_WRITE, 14);
 405         pr_debug("Voice parameters set successfully!!\n");
 406         return 0;
 407 }
 408
 409
 410 static int nc_set_pcm_audio_params(int sfreq, int word_size, int num_channel)
 411 {
 412         int config2 = 0;
 413         struct sc_reg_access sc_access;
 414         int retval = 0;
 415
 416         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 417                 retval = nc_init_card();
 418         if (retval)
 419                 return retval;
 420
 421         switch (sfreq) {
 422         case 8000:
 423                 config2 = 0x00;
 424                 break;
 425         case 11025:
 426                 config2 = 0x01;
 427                 break;
 428         case 12000:
 429                 config2 = 0x02;
 430                 break;
 431         case 16000:
 432                 config2 = 0x03;
 433                 break;
 434         case 22050:
 435                 config2 = 0x04;
 436                 break;
 437         case 24000:
 438                 config2 = 0x05;
 439                 break;
 440         case 32000:
 441                 config2 = 0x07;
 442                 break;
 443         case 44100:
 444                 config2 = 0x08;
 445                 break;
 446         case 48000:
 447                 config2 = 0x09;
 448                 break;
 449         }
 450
 451         snd_pmic_ops_nc.num_channel = num_channel;
 452         if (snd_pmic_ops_nc.num_channel == 1)   {
 453
 454                 sc_access.value = 0x07;
 455                 sc_access.reg_addr = RMUTE;
 456                 pr_debug("RIGHT_HP_MUTE value%d\n", sc_access.value);
 457                 sc_access.mask = MASK2;
 458                 sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
 459         } else {
 460                 sc_access.value = 0x00;
 461                 sc_access.reg_addr = RMUTE;
 462                 pr_debug("RIGHT_HP_MUTE value %d\n", sc_access.value);
 463                 sc_access.mask = MASK2;
 464                 sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
 465
 466
 467         }
 468
 469         pr_debug("word_size = %d\n", word_size);
 470
 471         if (word_size == 24) {
 472                 sc_access.reg_addr = AUDIOPORT2;
 473                 sc_access.value = config2 | 0x10;
 474                 sc_access.mask = 0x1F;
 475         } else {
 476                 sc_access.value = config2;
 477                 sc_access.mask = 0x1F;
 478                 sc_access.reg_addr = AUDIOPORT2;
 479         }
 480         sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
 481
 482         pr_debug("word_size = %d\n", word_size);
 483         sc_access.reg_addr = AUDIOPORT1;
 484         sc_access.mask = MASK5|MASK4|MASK1|MASK0;
 485         if (word_size == 16)
 486                 sc_access.value = 0x98;
 487         else if (word_size == 24)
 488                 sc_access.value = 0xAB;
 489
 490         return sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
 491
 492
 493
 494 }
 495
 496 static int nc_set_selected_output_dev(u8 value)
 497 {
 498         struct sc_reg_access sc_access_HP[] = {
 499                 {LMUTE, 0x02, 0x06},
 500                 {RMUTE, 0x02, 0x06}
 501         };
 502         struct sc_reg_access sc_access_IS[] = {
 503                 {LMUTE, 0x04, 0x06},
 504                 {RMUTE, 0x04, 0x06}
 505         };
 506         int retval = 0;
 507
 508         snd_pmic_ops_nc.output_dev_id = value;
 509         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 510                 retval = nc_init_card();
 511         if (retval)
 512                 return retval;
 513         pr_debug("nc set selected output:%d\n", value);
 514         switch (value) {
 515         case STEREO_HEADPHONE:
 516                 retval = sst_sc_reg_access(sc_access_HP, PMIC_WRITE, 2);
 517                 break;
 518         case INTERNAL_SPKR:
 519                 retval = sst_sc_reg_access(sc_access_IS, PMIC_WRITE, 2);
 520                 break;
 521         default:
 522                 pr_err("rcvd illegal request: %d\n", value);
 523                 return -EINVAL;
 524         }
 525         return retval;
 526 }
 527
 528 static int nc_audio_init(void)
 529 {
 530         struct sc_reg_access sc_acces, sc_access[] = {
 531                         {0x100, 0x00, 0},
 532                         {0x101, 0x00, 0},
 533                         {0x104, 0x8B, 0},
 534                         {0x107, 0x11, 0},
 535                         {0x10B, 0x0E, 0},
 536                         {0x114, 0x00, 0},
 537                         {0x115, 0x00, 0},
 538                         {0x128, 0x00, 0},
 539                         {0x129, 0x00, 0},
 540                         {0x12A, 0x00, 0},
 541                         {0x12B, 0xee, 0},
 542                         {0x12C, 0xf6, 0},
 543         };
 544
 545         sst_sc_reg_access(sc_access, PMIC_WRITE, 12);
 546         pr_debug("Audio Init successfully!!\n");
 547
 548         /*set output device */
 549         nc_set_selected_output_dev(snd_pmic_ops_nc.output_dev_id);
 550
 551         if (snd_pmic_ops_nc.num_channel == 1) {
 552                 sc_acces.value = 0x07;
 553                 sc_acces.reg_addr = RMUTE;
 554                 pr_debug("RIGHT_HP_MUTE value%d\n", sc_acces.value);
 555                 sc_acces.mask = MASK2;
 556                 sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
 557         } else {
 558                 sc_acces.value = 0x00;
 559                 sc_acces.reg_addr = RMUTE;
 560                 pr_debug("RIGHT_HP_MUTE value%d\n", sc_acces.value);
 561                 sc_acces.mask = MASK2;
 562                 sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
 563         }
 564
 565         return 0;
 566 }
 567
 568 static int nc_set_audio_port(int status)
 569 {
 570         struct sc_reg_access sc_access[2] = {{0,},};
 571         int retval = 0;
 572
 573         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 574                 retval = nc_init_card();
 575         if (retval)
 576                 return retval;
 577
 578         if (status == DEACTIVATE) {
 579                 /* Deactivate audio port-tristate and power */
 580                 sc_access[0].value = 0x00;
 581                 sc_access[0].mask = MASK4|MASK5;
 582                 sc_access[0].reg_addr = AUDIOPORT1;
 583                 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 584         } else if (status == ACTIVATE) {
 585                 /* activate audio port */
 586                 nc_audio_init();
 587                 sc_access[0].value = 0x10;
 588                 sc_access[0].mask =  MASK4|MASK5 ;
 589                 sc_access[0].reg_addr = AUDIOPORT1;
 590                 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 591         } else
 592                 return -EINVAL;
 593
 594 }
 595
 596 static int nc_set_voice_port(int status)
 597 {
 598         struct sc_reg_access sc_access[2] = {{0,},};
 599         int retval = 0;
 600
 601         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 602                 retval = nc_init_card();
 603         if (retval)
 604                 return retval;
 605
 606         if (status == DEACTIVATE) {
 607                 /* Activate Voice port */
 608                 sc_access[0].value = 0x00;
 609                 sc_access[0].mask = MASK4;
 610                 sc_access[0].reg_addr = VOICEPORT1;
 611                 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 612         } else if (status == ACTIVATE) {
 613                 /* Deactivate voice port */
 614                 nc_set_pcm_voice_params();
 615                 sc_access[0].value = 0x10;
 616                 sc_access[0].mask = MASK4;
 617                 sc_access[0].reg_addr = VOICEPORT1;
 618                 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 619         } else
 620                 return -EINVAL;
 621 }
 622
 623 static int nc_set_mute(int dev_id, u8 value)
 624 {
 625         struct sc_reg_access sc_access[3];
 626         u8 mute_val, cap_mute;
 627         int retval = 0;
 628
 629         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 630                 retval = nc_init_card();
 631         if (retval)
 632                 return retval;
 633
 634         pr_debug("set device id::%d, value %d\n", dev_id, value);
 635
 636         switch (dev_id) {
 637         case PMIC_SND_MUTE_ALL:
 638                 pr_debug("PMIC_SND_MUTE_ALL value %d\n", value);
 639                 snd_pmic_ops_nc.mute_status = value;
 640                 snd_pmic_ops_nc.master_mute = value;
 641                 if (value == UNMUTE) {
 642                         /* unmute the system, set the 7th bit to zero */
 643                         mute_val = cap_mute = 0x00;
 644                 } else {
 645                         /* MUTE:Set the seventh bit */
 646                         mute_val = 0x80;
 647                         cap_mute = 0x40;
 648                 }
 649                 sc_access[0].reg_addr = AUDIOLVOL;
 650                 sc_access[1].reg_addr = AUDIORVOL;
 651                 sc_access[0].mask = sc_access[1].mask = MASK7;
 652                 sc_access[0].value = sc_access[1].value = mute_val;
 653                 if (snd_pmic_ops_nc.num_channel == 1)
 654                                 sc_access[1].value = 0x80;
 655                 if (!sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2)) {
 656                         sc_access[0].reg_addr = 0x109;
 657                         sc_access[1].reg_addr = 0x10a;
 658                         sc_access[2].reg_addr = 0x105;
 659                         sc_access[0].mask = sc_access[1].mask =
 660                                 sc_access[2].mask = MASK6;
 661                         sc_access[0].value = sc_access[1].value =
 662                                 sc_access[2].value = cap_mute;
 663
 664                         if ((snd_pmic_ops_nc.input_dev_id == AMIC) ||
 665                                 (snd_pmic_ops_nc.input_dev_id == DMIC))
 666                                         sc_access[1].value = 0x40;
 667                         if (snd_pmic_ops_nc.input_dev_id == HS_MIC)
 668                                         sc_access[0].value = 0x40;
 669                         retval = sst_sc_reg_access(sc_access,
 670                                         PMIC_READ_MODIFY, 3);
 671                 }
 672                 break;
 673         case PMIC_SND_HP_MIC_MUTE:
 674                 pr_debug("PMIC_SND_HPMIC_MUTE value %d\n", value);
 675                 if (value == UNMUTE) {
 676                         /* unmute the system, set the 6th bit to one */
 677                         sc_access[0].value = 0x00;
 678                 } else {
 679                         /* mute the system, reset the 6th bit to zero */
 680                         sc_access[0].value = 0x40;
 681                 }
 682                 sc_access[0].reg_addr = LIRSEL;
 683                 sc_access[0].mask = MASK6;
 684                 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 685                 break;
 686         case PMIC_SND_AMIC_MUTE:
 687                 pr_debug("PMIC_SND_AMIC_MUTE value %d\n", value);
 688                 if (value == UNMUTE) {
 689                         /* unmute the system, set the 6th bit to one */
 690                         sc_access[0].value = 0x00;
 691                 } else {
 692                         /* mute the system, reset the 6th bit to zero */
 693                         sc_access[0].value = 0x40;
 694                 }
 695                 sc_access[0].reg_addr = LILSEL;
 696                 sc_access[0].mask = MASK6;
 697                 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 698                 break;
 699
 700         case PMIC_SND_DMIC_MUTE:
 701                 pr_debug("INPUT_MUTE_DMIC value%d\n", value);
 702                 if (value == UNMUTE) {
 703                         /* unmute the system, set the 6th bit to one */
 704                         sc_access[1].value = 0x00;
 705                         sc_access[0].value = 0x00;
 706                 } else {
 707                         /* mute the system, reset the 6th bit to zero */
 708                         sc_access[1].value = 0x40;
 709                         sc_access[0].value = 0x40;
 710                 }
 711                 sc_access[0].reg_addr = DMICCTRL1;
 712                 sc_access[0].mask = MASK6;
 713                 sc_access[1].reg_addr = LILSEL;
 714                 sc_access[1].mask = MASK6;
 715                 retval = sst_sc_reg_access(sc_access,
 716                                         PMIC_READ_MODIFY, 2);
 717                 break;
 718
 719         case PMIC_SND_LEFT_HP_MUTE:
 720         case PMIC_SND_RIGHT_HP_MUTE:
 721                 snd_pmic_ops_nc.mute_status = value;
 722                 if (value == UNMUTE)
 723                         sc_access[0].value = 0x0;
 724                 else
 725                         sc_access[0].value = 0x04;
 726
 727                 if (dev_id == PMIC_SND_LEFT_HP_MUTE) {
 728                         sc_access[0].reg_addr = LMUTE;
 729                         pr_debug("LEFT_HP_MUTE value %d\n",
 730                                         sc_access[0].value);
 731                 } else {
 732                         if (snd_pmic_ops_nc.num_channel == 1)
 733                                 sc_access[0].value = 0x04;
 734                         sc_access[0].reg_addr = RMUTE;
 735                         pr_debug("RIGHT_HP_MUTE value %d\n",
 736                                         sc_access[0].value);
 737                 }
 738                 sc_access[0].mask = MASK2;
 739                 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 740                 break;
 741         case PMIC_SND_LEFT_SPEAKER_MUTE:
 742         case PMIC_SND_RIGHT_SPEAKER_MUTE:
 743                 if (value == UNMUTE)
 744                         sc_access[0].value = 0x00;
 745                 else
 746                         sc_access[0].value = 0x03;
 747                 sc_access[0].reg_addr = LMUTE;
 748                 pr_debug("SPEAKER_MUTE %d\n", sc_access[0].value);
 749                 sc_access[0].mask = MASK1;
 750                 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 751                 break;
 752         default:
 753                 return -EINVAL;
 754         }
 755         return retval ;
 756
 757 }
 758
 759 static int nc_set_vol(int dev_id, int value)
 760 {
 761         struct sc_reg_access sc_access[3];
 762         int retval = 0, entries = 0;
 763
 764         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 765                 retval = nc_init_card();
 766         if (retval)
 767                 return retval;
 768
 769         pr_debug("set volume:%d\n", dev_id);
 770         switch (dev_id) {
 771         case PMIC_SND_CAPTURE_VOL:
 772                 pr_debug("PMIC_SND_CAPTURE_VOL:value::%d\n", value);
 773                 sc_access[0].value = sc_access[1].value =
 774                                         sc_access[2].value = -value;
 775                 sc_access[0].mask = sc_access[1].mask = sc_access[2].mask =
 776                                         (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
 777                 sc_access[0].reg_addr = 0x10a;
 778                 sc_access[1].reg_addr = 0x109;
 779                 sc_access[2].reg_addr = 0x105;
 780                 entries = 3;
 781                 break;
 782
 783         case PMIC_SND_LEFT_PB_VOL:
 784                 pr_debug("PMIC_SND_LEFT_HP_VOL %d\n", value);
 785                 sc_access[0].value = -value;
 786                 sc_access[0].reg_addr  = AUDIOLVOL;
 787                 sc_access[0].mask =
 788                         (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
 789                 entries = 1;
 790                 break;
 791
 792         case PMIC_SND_RIGHT_PB_VOL:
 793                 pr_debug("PMIC_SND_RIGHT_HP_VOL value %d\n", value);
 794                 if (snd_pmic_ops_nc.num_channel == 1) {
 795                         sc_access[0].value = 0x04;
 796                     sc_access[0].reg_addr = RMUTE;
 797                         sc_access[0].mask = MASK2;
 798                 } else {
 799                 sc_access[0].value = -value;
 800                 sc_access[0].reg_addr  = AUDIORVOL;
 801                 sc_access[0].mask =
 802                                 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
 803                 entries = 1;
 804                 }
 805                 break;
 806
 807         default:
 808                 return -EINVAL;
 809
 810         }
 811         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, entries);
 812 }
 813
 814 static int nc_set_selected_input_dev(u8 value)
 815 {
 816         struct sc_reg_access sc_access[6];
 817         u8 num_val;
 818         int retval = 0;
 819
 820         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 821                 retval = nc_init_card();
 822         if (retval)
 823                 return retval;
 824         snd_pmic_ops_nc.input_dev_id = value;
 825
 826         pr_debug("nc set selected input:%d\n", value);
 827
 828         switch (value) {
 829         case AMIC:
 830                 pr_debug("Selecting AMIC\n");
 831                 sc_access[0].reg_addr = 0x107;
 832                 sc_access[0].value = 0x40;
 833                 sc_access[0].mask =  MASK6|MASK4|MASK3|MASK1|MASK0;
 834                 sc_access[1].reg_addr = 0x10a;
 835                 sc_access[1].value = 0x40;
 836                 sc_access[1].mask = MASK6;
 837                 sc_access[2].reg_addr = 0x109;
 838                 sc_access[2].value = 0x00;
 839                 sc_access[2].mask = MASK6;
 840                 sc_access[3].reg_addr = 0x105;
 841                 sc_access[3].value = 0x40;
 842                 sc_access[3].mask = MASK6;
 843                 num_val = 4;
 844                 break;
 845
 846         case HS_MIC:
 847                 pr_debug("Selecting HS_MIC\n");
 848                 sc_access[0].reg_addr = 0x107;
 849                 sc_access[0].mask =  MASK6|MASK4|MASK3|MASK1|MASK0;
 850                 sc_access[0].value = 0x10;
 851                 sc_access[1].reg_addr = 0x109;
 852                 sc_access[1].mask = MASK6;
 853                 sc_access[1].value = 0x40;
 854                 sc_access[2].reg_addr = 0x10a;
 855                 sc_access[2].mask = MASK6;
 856                 sc_access[2].value = 0x00;
 857                 sc_access[3].reg_addr = 0x105;
 858                 sc_access[3].value = 0x40;
 859                 sc_access[3].mask = MASK6;
 860                 num_val = 4;
 861                 break;
 862
 863         case DMIC:
 864                 pr_debug("DMIC\n");
 865                 sc_access[0].reg_addr = 0x107;
 866                 sc_access[0].mask = MASK6|MASK4|MASK3|MASK1|MASK0;
 867                 sc_access[0].value = 0x0B;
 868                 sc_access[1].reg_addr = 0x105;
 869                 sc_access[1].value = 0x80;
 870                 sc_access[1].mask = MASK7|MASK6;
 871                 sc_access[2].reg_addr = 0x10a;
 872                 sc_access[2].value = 0x40;
 873                 sc_access[2].mask = MASK6;
 874                 sc_access[3].reg_addr = 0x109;
 875                 sc_access[3].mask = MASK6;
 876                 sc_access[3].value = 0x00;
 877                 sc_access[4].reg_addr = 0x104;
 878                 sc_access[4].value = 0x3C;
 879                 sc_access[4].mask = 0xff;
 880                 num_val = 5;
 881                 break;
 882         default:
 883                 return -EINVAL;
 884         }
 885         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, num_val);
 886 }
 887
 888 static int nc_get_mute(int dev_id, u8 *value)
 889 {
 890         int retval = 0, mask = 0;
 891         struct sc_reg_access sc_access = {0,};
 892
 893         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 894                 retval = nc_init_card();
 895         if (retval)
 896                 return retval;
 897
 898         pr_debug("get mute::%d\n", dev_id);
 899
 900         switch (dev_id) {
 901         case PMIC_SND_AMIC_MUTE:
 902                 pr_debug("PMIC_SND_INPUT_MUTE_MIC1\n");
 903                 sc_access.reg_addr = LILSEL;
 904                 mask = MASK6;
 905                 break;
 906         case PMIC_SND_HP_MIC_MUTE:
 907                 pr_debug("PMIC_SND_INPUT_MUTE_MIC2\n");
 908                 sc_access.reg_addr = LIRSEL;
 909                 mask = MASK6;
 910                 break;
 911         case PMIC_SND_LEFT_HP_MUTE:
 912         case PMIC_SND_RIGHT_HP_MUTE:
 913                 mask = MASK2;
 914                 pr_debug("PMIC_SN_LEFT/RIGHT_HP_MUTE\n");
 915                 if (dev_id == PMIC_SND_RIGHT_HP_MUTE)
 916                         sc_access.reg_addr = RMUTE;
 917                 else
 918                         sc_access.reg_addr = LMUTE;
 919                 break;
 920
 921         case PMIC_SND_LEFT_SPEAKER_MUTE:
 922                 pr_debug("PMIC_MONO_EARPIECE_MUTE\n");
 923                 sc_access.reg_addr = RMUTE;
 924                 mask = MASK1;
 925                 break;
 926         case PMIC_SND_DMIC_MUTE:
 927                 pr_debug("PMIC_SND_INPUT_MUTE_DMIC\n");
 928                 sc_access.reg_addr = 0x105;
 929                 mask = MASK6;
 930                 break;
 931         default:
 932                 return -EINVAL;
 933
 934         }
 935         retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
 936         pr_debug("reg value = %d\n", sc_access.value);
 937         if (retval)
 938                 return retval;
 939         *value = (sc_access.value) & mask;
 940         pr_debug("masked value = %d\n", *value);
 941         if (*value)
 942                 *value = 0;
 943         else
 944                 *value = 1;
 945         pr_debug("value returned = 0x%x\n", *value);
 946         return retval;
 947 }
 948
 949 static int nc_get_vol(int dev_id, int *value)
 950 {
 951         int retval = 0, mask = 0;
 952         struct sc_reg_access sc_access = {0,};
 953
 954         if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
 955                 retval = nc_init_card();
 956         if (retval)
 957                 return retval;
 958
 959         switch (dev_id) {
 960         case PMIC_SND_CAPTURE_VOL:
 961                 pr_debug("PMIC_SND_INPUT_CAPTURE_VOL\n");
 962                 sc_access.reg_addr =  LILSEL;
 963                 mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
 964                 break;
 965
 966         case PMIC_SND_RIGHT_PB_VOL:
 967                 pr_debug("GET_VOLUME_PMIC_LEFT_HP_VOL\n");
 968                 sc_access.reg_addr = AUDIOLVOL;
 969                 mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
 970                 break;
 971
 972         case PMIC_SND_LEFT_PB_VOL:
 973                 pr_debug("GET_VOLUME_PMIC_RIGHT_HP_VOL\n");
 974                 sc_access.reg_addr = AUDIORVOL;
 975                 mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
 976                 break;
 977
 978         default:
 979                 return -EINVAL;
 980
 981         }
 982         retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
 983         pr_debug("value read = 0x%x\n", sc_access.value);
 984         *value = -((sc_access.value) & mask);
 985         pr_debug("get vol value returned = %d\n", *value);
 986         return retval;
 987 }
 988
 989 struct snd_pmic_ops snd_pmic_ops_nc = {
 990         .set_input_dev  =       nc_set_selected_input_dev,
 991         .set_output_dev =       nc_set_selected_output_dev,
 992         .set_mute       =       nc_set_mute,
 993         .get_mute       =       nc_get_mute,
 994         .set_vol        =       nc_set_vol,
 995         .get_vol        =       nc_get_vol,
 996         .init_card      =       nc_init_card,
 997         .set_pcm_audio_params   = nc_set_pcm_audio_params,
 998         .set_pcm_voice_params   = nc_set_pcm_voice_params,
 999         .set_voice_port = nc_set_voice_port,
1000         .set_audio_port = nc_set_audio_port,
1001         .power_up_pmic_pb =     nc_power_up_pb,
1002         .power_up_pmic_cp =     nc_power_up_cp,
1003         .power_down_pmic_pb =   nc_power_down_pb,
1004         .power_down_pmic_cp =   nc_power_down_cp,
1005         .power_down_pmic =      nc_power_down,
1006 };