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