drivers/staging/intel_sst/intelmid_v0_control.c

   1 /*
   2  *  intel_sst_v0_control.c - Intel SST Driver for audio engine
   3  *
   4  *  Copyright (C) 2008-10 Intel Corporation
   5  *  Authors:    Vinod Koul <vinod.koul@intel.com>
   6  *              Harsha Priya <priya.harsha@intel.com>
   7  *              Dharageswari R <dharageswari.r@intel.com>
   8  *              KP Jeeja <jeeja.kp@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 1
  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
  35 enum _reg_v1 {
  36         VOICEPORT1 = 0x180,
  37         VOICEPORT2 = 0x181,
  38         AUDIOPORT1 = 0x182,
  39         AUDIOPORT2 = 0x183,
  40         MISCVOICECTRL = 0x184,
  41         MISCAUDCTRL = 0x185,
  42         DMICCTRL1 = 0x186,
  43         AUDIOBIAS = 0x187,
  44         MICCTRL = 0x188,
  45         MICLICTRL1 = 0x189,
  46         MICLICTRL2 = 0x18A,
  47         MICLICTRL3 = 0x18B,
  48         VOICEDACCTRL1 = 0x18C,
  49         STEREOADCCTRL = 0x18D,
  50         AUD15 = 0x18E,
  51         AUD16 = 0x18F,
  52         AUD17 = 0x190,
  53         AUD18 = 0x191,
  54         RMIXOUTSEL = 0x192,
  55         ANALOGLBR = 0x193,
  56         ANALOGLBL = 0x194,
  57         POWERCTRL1 = 0x195,
  58         POWERCTRL2 = 0x196,
  59         HEADSETDETECTINT = 0x197,
  60         HEADSETDETECTINTMASK = 0x198,
  61         TRIMENABLE = 0x199,
  62 };
  63
  64 int rev_id = 0x20;
  65
  66 /****
  67  * fs_init_card - initialize the sound card
  68  *
  69  * This initilizes the audio paths to know values in case of this sound card
  70  */
  71 static int fs_init_card(void)
  72 {
  73         struct sc_reg_access sc_access[] = {
  74                 {0x180, 0x00, 0x0},
  75                 {0x181, 0x00, 0x0},
  76                 {0x182, 0xF8, 0x0},
  77                 {0x183, 0x08, 0x0},
  78                 {0x184, 0x00, 0x0},
  79                 {0x185, 0x40, 0x0},
  80                 {0x186, 0x06, 0x0},
  81                 {0x187, 0x80, 0x0},
  82                 {0x188, 0x40, 0x0},
  83                 {0x189, 0x39, 0x0},
  84                 {0x18a, 0x39, 0x0},
  85                 {0x18b, 0x1F, 0x0},
  86                 {0x18c, 0x00, 0x0},
  87                 {0x18d, 0x00, 0x0},
  88                 {0x18e, 0x39, 0x0},
  89                 {0x18f, 0x39, 0x0},
  90                 {0x190, 0x39, 0x0},
  91                 {0x191, 0x11, 0x0},
  92                 {0x192, 0x0E, 0x0},
  93                 {0x193, 0x00, 0x0},
  94                 {0x194, 0x00, 0x0},
  95                 {0x195, 0x00, 0x0},
  96                 {0x196, 0x7C, 0x0},
  97                 {0x197, 0x00, 0x0},
  98                 {0x198, 0x0B, 0x0},
  99                 {0x199, 0x00, 0x0},
 100                 {0x037, 0x3F, 0x0},
 101         };
 102
 103         snd_pmic_ops_fs.card_status = SND_CARD_INIT_DONE;
 104         snd_pmic_ops_fs.master_mute = UNMUTE;
 105         snd_pmic_ops_fs.mute_status = UNMUTE;
 106         snd_pmic_ops_fs.num_channel = 2;
 107         return sst_sc_reg_access(sc_access, PMIC_WRITE, 27);
 108 }
 109
 110 static int fs_enable_audiodac(int value)
 111 {
 112         struct sc_reg_access sc_access[3];
 113         sc_access[0].reg_addr = AUD16;
 114         sc_access[1].reg_addr = AUD17;
 115         sc_access[2].reg_addr = AUD15;
 116         sc_access[0].mask = sc_access[1].mask = sc_access[2].mask = MASK7;
 117
 118         if (snd_pmic_ops_fs.mute_status == MUTE)
 119                 return 0;
 120         if (value == MUTE) {
 121                         sc_access[0].value = sc_access[1].value =
 122                                 sc_access[2].value = 0x80;
 123
 124                 } else {
 125                         sc_access[0].value = sc_access[1].value =
 126                         sc_access[2].value =  0x0;
 127                 }
 128         if (snd_pmic_ops_fs.num_channel == 1)
 129                 sc_access[1].value = sc_access[2].value = 0x80;
 130         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
 131
 132 }
 133
 134 static int fs_power_up_pb(unsigned int port)
 135 {
 136         struct sc_reg_access sc_access[] = {
 137                 {AUDIOBIAS, 0x00, MASK7},
 138                 {POWERCTRL1, 0xC6, 0xC6},
 139                 {POWERCTRL2, 0x30, 0x30},
 140
 141         };
 142         int retval = 0;
 143
 144         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 145                 retval = fs_init_card();
 146         if (retval)
 147                 return retval;
 148         retval = fs_enable_audiodac(MUTE);
 149         retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
 150
 151         if (retval)
 152                 return retval;
 153
 154         pr_debug("sst: in fs power up pb\n");
 155         return fs_enable_audiodac(UNMUTE);
 156 }
 157
 158 static int fs_power_down_pb(void)
 159 {
 160         struct sc_reg_access sc_access[] = {
 161                 {POWERCTRL1, 0x00, 0xC6},
 162                 {POWERCTRL2, 0x00, 0x30},
 163         };
 164         int retval = 0;
 165
 166         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 167                 retval = fs_init_card();
 168         if (retval)
 169                 return retval;
 170         retval = fs_enable_audiodac(MUTE);
 171         retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 172
 173         if (retval)
 174                 return retval;
 175
 176         pr_debug("sst: in fsl power down pb\n");
 177         return fs_enable_audiodac(UNMUTE);
 178 }
 179
 180 static int fs_power_up_cp(unsigned int port)
 181 {
 182         struct sc_reg_access sc_access[] = {
 183                 {POWERCTRL2, 0x32, 0x32}, /*NOTE power up A ADC only as*/
 184                 {AUDIOBIAS, 0x00, MASK7},
 185                                         /*as turning on V ADC causes noise*/
 186         };
 187         int retval = 0;
 188
 189         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 190                 retval = fs_init_card();
 191         if (retval)
 192                 return retval;
 193         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 194 }
 195
 196 static int fs_power_down_cp(void)
 197 {
 198         struct sc_reg_access sc_access[] = {
 199                 {POWERCTRL2, 0x00, 0x03},
 200         };
 201         int retval = 0;
 202
 203         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 204                 retval = fs_init_card();
 205         if (retval)
 206                 return retval;
 207         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 208 }
 209
 210 static int fs_power_down(void)
 211 {
 212         int retval = 0;
 213         struct sc_reg_access sc_access[] = {
 214                 {AUDIOBIAS, MASK7, MASK7},
 215         };
 216
 217         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 218                 retval = fs_init_card();
 219         if (retval)
 220                 return retval;
 221         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
 222 }
 223
 224 static int fs_set_pcm_voice_params(void)
 225 {
 226         struct sc_reg_access sc_access[] = {
 227                 {0x180, 0xA0, 0},
 228                 {0x181, 0x04, 0},
 229                 {0x182, 0x0, 0},
 230                 {0x183, 0x0, 0},
 231                 {0x184, 0x18, 0},
 232                 {0x185, 0x40, 0},
 233                 {0x186, 0x06, 0},
 234                 {0x187, 0x0, 0},
 235                 {0x188, 0x10, 0},
 236                 {0x189, 0x39, 0},
 237                 {0x18a, 0x39, 0},
 238                 {0x18b, 0x02, 0},
 239                 {0x18c, 0x0, 0},
 240                 {0x18d, 0x0, 0},
 241                 {0x18e, 0x39, 0},
 242                 {0x18f, 0x0, 0},
 243                 {0x190, 0x0, 0},
 244                 {0x191, 0x20, 0},
 245                 {0x192, 0x20, 0},
 246                 {0x193, 0x0, 0},
 247                 {0x194, 0x0, 0},
 248                 {0x195, 0x06, 0},
 249                 {0x196, 0x25, 0},
 250                 {0x197, 0x0, 0},
 251                 {0x198, 0xF, 0},
 252                 {0x199, 0x0, 0},
 253         };
 254         int retval = 0;
 255
 256         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 257                 retval = fs_init_card();
 258         if (retval)
 259                 return retval;
 260         return sst_sc_reg_access(sc_access, PMIC_WRITE, 26);
 261 }
 262
 263 static int fs_set_audio_port(int status)
 264 {
 265         struct sc_reg_access sc_access[2];
 266         int retval = 0;
 267
 268         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 269                 retval = fs_init_card();
 270         if (retval)
 271                 return retval;
 272         if (status == DEACTIVATE) {
 273                 /* Deactivate audio port-tristate and power */
 274                 sc_access[0].value = 0x00;
 275                 sc_access[0].mask = MASK6|MASK7;
 276                 sc_access[0].reg_addr = AUDIOPORT1;
 277                 sc_access[1].value = 0x00;
 278                 sc_access[1].mask = MASK4|MASK5;
 279                 sc_access[1].reg_addr = POWERCTRL2;
 280                 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 281         } else if (status == ACTIVATE) {
 282                 /* activate audio port */
 283                 sc_access[0].value = 0xC0;
 284                 sc_access[0].mask = MASK6|MASK7;
 285                 sc_access[0].reg_addr = AUDIOPORT1;
 286                 sc_access[1].value = 0x30;
 287                 sc_access[1].mask = MASK4|MASK5;
 288                 sc_access[1].reg_addr = POWERCTRL2;
 289                 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 290         } else
 291                 return -EINVAL;
 292 }
 293
 294 static int fs_set_voice_port(int status)
 295 {
 296         struct sc_reg_access sc_access[2];
 297         int retval = 0;
 298
 299         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 300                 retval = fs_init_card();
 301         if (retval)
 302                 return retval;
 303         if (status == DEACTIVATE) {
 304                 /* Deactivate audio port-tristate and power */
 305                 sc_access[0].value = 0x00;
 306                 sc_access[0].mask = MASK6|MASK7;
 307                 sc_access[0].reg_addr = VOICEPORT1;
 308                 sc_access[1].value = 0x00;
 309                 sc_access[1].mask = MASK0|MASK1;
 310                 sc_access[1].reg_addr = POWERCTRL2;
 311                 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 312         } else if (status == ACTIVATE) {
 313                 /* activate audio port */
 314                 sc_access[0].value = 0xC0;
 315                 sc_access[0].mask = MASK6|MASK7;
 316                 sc_access[0].reg_addr = VOICEPORT1;
 317                 sc_access[1].value = 0x03;
 318                 sc_access[1].mask = MASK0|MASK1;
 319                 sc_access[1].reg_addr = POWERCTRL2;
 320                 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 321         } else
 322                 return -EINVAL;
 323 }
 324
 325 static int fs_set_pcm_audio_params(int sfreq, int word_size, int num_channel)
 326 {
 327         u8 config1 = 0;
 328         struct sc_reg_access sc_access[4];
 329         int retval = 0, num_value = 0;
 330
 331         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 332                 retval = fs_init_card();
 333         if (retval)
 334                 return retval;
 335         switch (sfreq) {
 336         case 8000:
 337                 config1 = 0x00;
 338                 break;
 339         case 11025:
 340                 config1 = 0x01;
 341                 break;
 342         case 12000:
 343                 config1 = 0x02;
 344                 break;
 345         case 16000:
 346                 config1 = 0x03;
 347                 break;
 348         case 22050:
 349                 config1 = 0x04;
 350                 break;
 351         case 24000:
 352                 config1 = 0x05;
 353                 break;
 354         case 26000:
 355                 config1 = 0x06;
 356                 break;
 357         case 32000:
 358                 config1 = 0x07;
 359                 break;
 360         case 44100:
 361                 config1 = 0x08;
 362                 break;
 363         case 48000:
 364                 config1 = 0x09;
 365                 break;
 366         }
 367         snd_pmic_ops_fs.num_channel = num_channel;
 368         if (snd_pmic_ops_fs.num_channel == 1)   {
 369                 sc_access[0].reg_addr = AUD17;
 370                 sc_access[1].reg_addr = AUD15;
 371                 sc_access[0].mask = sc_access[1].mask = MASK7;
 372                 sc_access[0].value = sc_access[1].value = 0x80;
 373                 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 374
 375         } else {
 376                 sc_access[0].reg_addr = AUD17;
 377                 sc_access[1].reg_addr = AUD15;
 378                 sc_access[0].mask = sc_access[1].mask = MASK7;
 379                 sc_access[0].value = sc_access[1].value = 0x00;
 380                 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
 381
 382         }
 383         pr_debug("sst: sfreq:%d,Register value = %x\n", sfreq, config1);
 384
 385         if (word_size == 24) {
 386                 sc_access[0].reg_addr  = AUDIOPORT1;
 387                 sc_access[0].mask = MASK0|MASK1|MASK2|MASK3;
 388                 sc_access[0].value = 0xFB;
 389
 390
 391                 sc_access[1].reg_addr  = AUDIOPORT2;
 392                 sc_access[1].value = config1 | 0x10;
 393                 sc_access[1].mask = MASK0 | MASK1 | MASK2 | MASK3
 394                                         | MASK4 | MASK5 | MASK6;
 395
 396                 sc_access[2].reg_addr  = MISCAUDCTRL;
 397                 sc_access[2].value = 0x02;
 398                 sc_access[2].mask = 0x02;
 399
 400                 num_value = 3 ;
 401
 402         } else {
 403
 404                 sc_access[0].reg_addr  = AUDIOPORT2;
 405                 sc_access[0].value = config1;
 406                 sc_access[0].mask = MASK0|MASK1|MASK2|MASK3;
 407
 408                 sc_access[1].reg_addr  = MISCAUDCTRL;
 409                 sc_access[1].value = 0x00;
 410                 sc_access[1].mask = 0x02;
 411                 num_value = 2;
 412         }
 413         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, num_value);
 414
 415 }
 416
 417 static int fs_set_selected_input_dev(u8 value)
 418 {
 419         struct sc_reg_access sc_access_dmic[] = {
 420                 {MICCTRL, 0x81, 0xf7},
 421                 {MICLICTRL3, 0x00, 0xE0},
 422         };
 423         struct sc_reg_access sc_access_mic[] = {
 424                 {MICCTRL, 0x40, MASK2|MASK4|MASK5|MASK6|MASK7},
 425                 {MICLICTRL3, 0x00, 0xE0},
 426         };
 427         struct sc_reg_access sc_access_hsmic[] = {
 428                 {MICCTRL, 0x10, MASK2|MASK4|MASK5|MASK6|MASK7},
 429                 {MICLICTRL3, 0x00, 0xE0},
 430         };
 431
 432         int retval = 0;
 433
 434         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 435                 retval = fs_init_card();
 436         if (retval)
 437                 return retval;
 438
 439         switch (value) {
 440         case AMIC:
 441                 pr_debug("sst: Selecting amic not supported in mono cfg\n");
 442                 return sst_sc_reg_access(sc_access_mic, PMIC_READ_MODIFY, 2);
 443                 break;
 444
 445         case HS_MIC:
 446                 pr_debug("sst: Selecting hsmic\n");
 447                 return sst_sc_reg_access(sc_access_hsmic,
 448                                 PMIC_READ_MODIFY, 2);
 449                 break;
 450
 451         case DMIC:
 452                 pr_debug("sst: Selecting dmic\n");
 453                 return sst_sc_reg_access(sc_access_dmic, PMIC_READ_MODIFY, 2);
 454                 break;
 455
 456         default:
 457                 return -EINVAL;
 458
 459         }
 460 }
 461
 462 static int fs_set_selected_output_dev(u8 value)
 463 {
 464         struct sc_reg_access sc_access_hp[] = {
 465                 {0x191, 0x11, 0x0},
 466                 {0x192, 0x0E, 0x0},
 467         };
 468         struct sc_reg_access sc_access_is[] = {
 469                 {0x191, 0x17, 0xFF},
 470                 {0x192, 0x08, 0xFF},
 471         };
 472         int retval = 0;
 473
 474         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 475                 retval = fs_init_card();
 476         if (retval)
 477                 return retval;
 478
 479         switch (value) {
 480         case STEREO_HEADPHONE:
 481                 pr_debug("SST DBG:Selecting headphone\n");
 482                 return sst_sc_reg_access(sc_access_hp, PMIC_WRITE, 2);
 483                 break;
 484         case MONO_EARPIECE:
 485         case INTERNAL_SPKR:
 486                 pr_debug("SST DBG:Selecting internal spkr\n");
 487                 return sst_sc_reg_access(sc_access_is, PMIC_READ_MODIFY, 2);
 488                 break;
 489
 490         default:
 491                 return -EINVAL;
 492
 493         }
 494 }
 495
 496 static int fs_set_mute(int dev_id, u8 value)
 497 {
 498         struct sc_reg_access sc_access[6] = {{0,},};
 499         int reg_num = 0;
 500         int retval = 0;
 501
 502         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 503                 retval = fs_init_card();
 504         if (retval)
 505                 return retval;
 506
 507
 508         pr_debug("sst: dev_id:0x%x value:0x%x\n", dev_id, value);
 509         switch (dev_id) {
 510         case PMIC_SND_DMIC_MUTE:
 511                 sc_access[0].reg_addr = MICCTRL;
 512                 sc_access[1].reg_addr = MICLICTRL1;
 513                 sc_access[2].reg_addr = MICLICTRL2;
 514                 sc_access[0].mask = MASK5;
 515                 sc_access[1].mask = sc_access[2].mask = MASK6;
 516                 if (value == MUTE) {
 517                         sc_access[0].value = 0x20;
 518                         sc_access[2].value = sc_access[1].value = 0x40;
 519                 } else
 520                         sc_access[0].value = sc_access[1].value
 521                         = sc_access[2].value = 0x0;
 522                 reg_num = 3;
 523                 break;
 524         case PMIC_SND_HP_MIC_MUTE:
 525         case PMIC_SND_AMIC_MUTE:
 526                 sc_access[0].reg_addr = MICLICTRL1;
 527                 sc_access[1].reg_addr = MICLICTRL2;
 528                 sc_access[0].mask = sc_access[1].mask = MASK6;
 529                 if (value == MUTE)
 530                         sc_access[0].value = sc_access[1].value = 0x40;
 531                 else
 532                         sc_access[0].value = sc_access[1].value = 0x0;
 533                 reg_num = 2;
 534                 break;
 535         case PMIC_SND_LEFT_SPEAKER_MUTE:
 536         case PMIC_SND_LEFT_HP_MUTE:
 537                 sc_access[0].reg_addr = AUD16;
 538                 sc_access[1].reg_addr = AUD15;
 539
 540                 sc_access[0].mask = sc_access[1].mask = MASK7;
 541                 if (value == MUTE)
 542                         sc_access[0].value = sc_access[1].value = 0x80;
 543                 else
 544                         sc_access[0].value = sc_access[1].value = 0x0;
 545                 reg_num = 2;
 546                 snd_pmic_ops_fs.mute_status = value;
 547                 break;
 548         case PMIC_SND_RIGHT_HP_MUTE:
 549         case PMIC_SND_RIGHT_SPEAKER_MUTE:
 550                 sc_access[0].reg_addr = AUD17;
 551                 sc_access[1].reg_addr = AUD15;
 552                 sc_access[0].mask = sc_access[1].mask = MASK7;
 553                 if (value == MUTE)
 554                         sc_access[0].value = sc_access[1].value = 0x80;
 555                 else
 556                         sc_access[0].value = sc_access[1].value = 0x0;
 557                 snd_pmic_ops_fs.mute_status = value;
 558                 if (snd_pmic_ops_fs.num_channel == 1)
 559                         sc_access[0].value = sc_access[1].value = 0x80;
 560                 reg_num = 2;
 561                 break;
 562         case PMIC_SND_MUTE_ALL:
 563                 sc_access[0].reg_addr = AUD16;
 564                 sc_access[1].reg_addr = AUD17;
 565                 sc_access[2].reg_addr = AUD15;
 566                 sc_access[3].reg_addr = MICCTRL;
 567                 sc_access[4].reg_addr = MICLICTRL1;
 568                 sc_access[5].reg_addr = MICLICTRL2;
 569                 sc_access[0].mask = sc_access[1].mask =
 570                                 sc_access[2].mask = MASK7;
 571                 sc_access[3].mask = MASK5;
 572                 sc_access[4].mask = sc_access[5].mask = MASK6;
 573
 574                 if (value == MUTE) {
 575                         sc_access[0].value =
 576                         sc_access[1].value = sc_access[2].value = 0x80;
 577                         sc_access[3].value = 0x20;
 578                         sc_access[4].value = sc_access[5].value = 0x40;
 579
 580                 } else {
 581                         sc_access[0].value = sc_access[1].value =
 582                         sc_access[2].value = sc_access[3].value =
 583                         sc_access[4].value = sc_access[5].value = 0x0;
 584                 }
 585                 if (snd_pmic_ops_fs.num_channel == 1)
 586                         sc_access[1].value = sc_access[2].value = 0x80;
 587                 reg_num = 6;
 588                 snd_pmic_ops_fs.mute_status = value;
 589                 snd_pmic_ops_fs.master_mute = value;
 590                 break;
 591
 592         }
 593         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, reg_num);
 594 }
 595
 596 static int fs_set_vol(int dev_id, int value)
 597 {
 598         struct sc_reg_access sc_acces, sc_access[4] = {{0},};
 599         int reg_num = 0;
 600         int retval = 0;
 601
 602         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 603                 retval = fs_init_card();
 604         if (retval)
 605                 return retval;
 606
 607         switch (dev_id) {
 608         case PMIC_SND_LEFT_PB_VOL:
 609                 pr_debug("sst: PMIC_SND_LEFT_PB_VOL:%d\n", value);
 610                 sc_access[0].value = sc_access[1].value = value;
 611                 sc_access[0].reg_addr = AUD16;
 612                 sc_access[1].reg_addr = AUD15;
 613                 sc_access[0].mask = sc_access[1].mask =
 614                         (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
 615                 reg_num = 2;
 616                 break;
 617
 618         case PMIC_SND_RIGHT_PB_VOL:
 619                 pr_debug("sst: PMIC_SND_RIGHT_PB_VOL:%d\n", value);
 620                 sc_access[0].value = sc_access[1].value = value;
 621                 sc_access[0].reg_addr = AUD17;
 622                 sc_access[1].reg_addr = AUD15;
 623                 sc_access[0].mask = sc_access[1].mask =
 624                         (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
 625                 if (snd_pmic_ops_fs.num_channel == 1) {
 626                         sc_access[0].value = sc_access[1].value = 0x80;
 627                         sc_access[0].mask = sc_access[1].mask = MASK7;
 628                 }
 629                 reg_num = 2;
 630                 break;
 631         case PMIC_SND_CAPTURE_VOL:
 632                 pr_debug("sst: PMIC_SND_CAPTURE_VOL:%d\n", value);
 633                 sc_access[0].reg_addr = MICLICTRL1;
 634                 sc_access[1].reg_addr = MICLICTRL2;
 635                 sc_access[2].reg_addr = DMICCTRL1;
 636                 sc_access[2].value = value;
 637                 sc_access[0].value = sc_access[1].value = value;
 638                 sc_acces.reg_addr = MICLICTRL3;
 639                 sc_acces.value = value;
 640                 sc_acces.mask = (MASK0|MASK1|MASK2|MASK3|MASK5|MASK6|MASK7);
 641                 retval = sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
 642                 sc_access[0].mask = sc_access[1].mask =
 643                 sc_access[2].mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
 644                 reg_num = 3;
 645                 break;
 646
 647         default:
 648                 return -EINVAL;
 649         }
 650
 651         return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, reg_num);
 652 }
 653
 654 static int fs_get_mute(int dev_id, u8 *value)
 655 {
 656         struct sc_reg_access sc_access[6] = {{0,},};
 657
 658         int retval = 0, temp_value = 0, mask = 0;
 659
 660         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 661                 retval = fs_init_card();
 662         if (retval)
 663                 return retval;
 664
 665         switch (dev_id) {
 666
 667         case PMIC_SND_AMIC_MUTE:
 668         case PMIC_SND_HP_MIC_MUTE:
 669                 sc_access[0].reg_addr = MICLICTRL1;
 670                 mask = MASK6;
 671                 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
 672                 if (sc_access[0].value & mask)
 673                         *value = MUTE;
 674                 else
 675                         *value = UNMUTE;
 676                 break;
 677         case PMIC_SND_DMIC_MUTE:
 678                 sc_access[0].reg_addr = MICCTRL;
 679                 mask = MASK5;
 680                 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
 681                 temp_value = (sc_access[0].value & mask);
 682                 if (temp_value == 0)
 683                         *value = UNMUTE;
 684                 else
 685                         *value = MUTE;
 686                 break;
 687
 688         case PMIC_SND_LEFT_HP_MUTE:
 689         case PMIC_SND_LEFT_SPEAKER_MUTE:
 690                 sc_access[0].reg_addr = AUD16;
 691                 mask = MASK7;
 692                 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
 693                 temp_value = sc_access[0].value & mask;
 694                 if (temp_value == 0)
 695                         *value = UNMUTE;
 696                 else
 697                         *value = MUTE;
 698                 break;
 699         case PMIC_SND_RIGHT_HP_MUTE:
 700         case PMIC_SND_RIGHT_SPEAKER_MUTE:
 701                 sc_access[0].reg_addr = AUD17;
 702                 mask = MASK7;
 703                 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
 704                 temp_value = sc_access[0].value & mask;
 705                 if (temp_value == 0)
 706                         *value = UNMUTE;
 707                 else
 708                         *value = MUTE;
 709                 break;
 710         default:
 711                 return -EINVAL;
 712         }
 713
 714         return retval;
 715 }
 716
 717 static int fs_get_vol(int dev_id, int *value)
 718 {
 719         struct sc_reg_access sc_access = {0,};
 720         int retval = 0, mask = 0;
 721
 722         if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
 723                 retval = fs_init_card();
 724         if (retval)
 725                 return retval;
 726
 727         switch (dev_id) {
 728         case PMIC_SND_CAPTURE_VOL:
 729                 pr_debug("sst: PMIC_SND_CAPTURE_VOL\n");
 730                 sc_access.reg_addr = MICLICTRL1;
 731                 mask = (MASK5|MASK4|MASK3|MASK2|MASK1|MASK0);
 732                 break;
 733         case PMIC_SND_LEFT_PB_VOL:
 734                 pr_debug("sst: PMIC_SND_LEFT_PB_VOL\n");
 735                 sc_access.reg_addr = AUD16;
 736                 mask = (MASK5|MASK4|MASK3|MASK2|MASK1|MASK0);
 737                 break;
 738         case PMIC_SND_RIGHT_PB_VOL:
 739                 pr_debug("sst: PMIC_SND_RT_PB_VOL\n");
 740                 sc_access.reg_addr = AUD17;
 741                 mask = (MASK5|MASK4|MASK3|MASK2|MASK1|MASK0);
 742                 break;
 743         default:
 744                 return -EINVAL;
 745         }
 746
 747         retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
 748         pr_debug("sst: value read = 0x%x\n", sc_access.value);
 749         *value = (int) (sc_access.value & mask);
 750         pr_debug("sst: value returned = 0x%x\n", *value);
 751         return retval;
 752 }
 753
 754 struct snd_pmic_ops snd_pmic_ops_fs = {
 755         .set_input_dev = fs_set_selected_input_dev,
 756         .set_output_dev = fs_set_selected_output_dev,
 757         .set_mute = fs_set_mute,
 758         .get_mute = fs_get_mute,
 759         .set_vol = fs_set_vol,
 760         .get_vol = fs_get_vol,
 761         .init_card = fs_init_card,
 762         .set_pcm_audio_params = fs_set_pcm_audio_params,
 763         .set_pcm_voice_params = fs_set_pcm_voice_params,
 764         .set_voice_port = fs_set_voice_port,
 765         .set_audio_port = fs_set_audio_port,
 766         .power_up_pmic_pb = fs_power_up_pb,
 767         .power_up_pmic_cp = fs_power_up_cp,
 768         .power_down_pmic_pb = fs_power_down_pb,
 769         .power_down_pmic_cp = fs_power_down_cp,
 770         .power_down_pmic = fs_power_down,
 771 };