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