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