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