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