2 * intelmid_v2_control.c - Intel Sound card driver for MID
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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
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.
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
26 * This file contains the control operations of vendor 3
29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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"
45 ADCSAMPLERATE = 0x104,
79 LINEOUTMIXVOL = 0x126,
90 static void nc_set_amp_power(int power)
92 if (snd_pmic_ops_nc.gpio_amp)
93 gpio_set_value(snd_pmic_ops_nc.gpio_amp, power);
97 * nc_init_card - initialize the sound card
99 * This initializes the audio paths to know values in case of this sound card
101 static int nc_init_card(void)
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},
113 {POWERCTRL1, 0x00, 0},
114 {POWERCTRL2, 0x00, 0},
115 {DRVPOWERCTRL, 0x00, 0},
117 {HPLMIXSEL, 0xee, 0},
118 {HPRMIXSEL, 0xf6, 0},
119 {PCMBUFCTRL, 0x0, 0},
123 {MICCTRL, 0x51, 0x00},
124 {ADCSAMPLERATE, 0x8B, 0x00},
125 {MICSELVOL, 0x5B, 0x00},
128 {LOANTIPOP, 0x00, 0},
129 {DMICCTRL1, 0x40, 0},
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");
141 static int nc_enable_audiodac(int value)
143 struct sc_reg_access sc_access[3];
146 if (snd_pmic_ops_nc.mute_status == MUTE)
149 if (((snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE) ||
150 (snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)) &&
153 if (value == UNMUTE) {
154 /* unmute the system, set the 7th bit to zero */
157 /* MUTE:Set the seventh bit */
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;
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);
172 static int nc_power_up_pb(unsigned int port)
174 struct sc_reg_access sc_access[7];
177 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
178 retval = nc_init_card();
183 mutex_lock(&snd_pmic_ops_nc.lock);
184 nc_enable_audiodac(MUTE);
187 pr_debug("powering up pb....\n");
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;
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;
200 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
204 sc_access[0].reg_addr = POWERCTRL1;
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;
212 sc_access[1].reg_addr = POWERCTRL2;
213 sc_access[1].value = 0x0C;
214 sc_access[1].mask = 0x0C;
216 sc_access[2].reg_addr = DRVPOWERCTRL;
217 sc_access[2].value = 0x86;
218 sc_access[2].mask = 0x86;
220 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
224 snd_pmic_ops_nc.pb_on = 1;
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
233 if (snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE ||
234 snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)
236 nc_enable_audiodac(UNMUTE);
237 mutex_unlock(&snd_pmic_ops_nc.lock);
241 static int nc_power_up_cp(unsigned int port)
243 struct sc_reg_access sc_access[5];
247 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
248 retval = nc_init_card();
253 pr_debug("powering up cp....\n");
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;
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;
269 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
272 sc_access[0].reg_addr = POWERCTRL1;
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;
280 sc_access[1].reg_addr = POWERCTRL2;
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;
289 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
293 static int nc_power_down(void)
296 struct sc_reg_access sc_access[5];
298 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
299 retval = nc_init_card();
302 nc_enable_audiodac(MUTE);
305 pr_debug("powering dn nc_power_down ....\n");
307 if (snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE ||
308 snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)
313 sc_access[0].reg_addr = DRVPOWERCTRL;
314 sc_access[0].value = 0x00;
315 sc_access[0].mask = 0x00;
317 sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
319 sc_access[0].reg_addr = POWERCTRL1;
320 sc_access[0].value = 0x00;
321 sc_access[0].mask = 0x00;
323 sc_access[1].reg_addr = POWERCTRL2;
324 sc_access[1].value = 0x00;
325 sc_access[1].mask = 0x00;
329 sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
332 sc_access[0].reg_addr = VREFPLL;
333 sc_access[0].value = 0x10;
334 sc_access[0].mask = 0x10;
336 sc_access[1].reg_addr = VAUDIOCNT;
337 sc_access[1].value = 0x25;
338 sc_access[1].mask = 0x25;
341 retval = sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
344 return nc_enable_audiodac(UNMUTE);
347 static int nc_power_down_pb(unsigned int device)
351 struct sc_reg_access sc_access[5];
353 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
354 retval = nc_init_card();
358 pr_debug("powering dn pb....\n");
359 mutex_lock(&snd_pmic_ops_nc.lock);
360 nc_enable_audiodac(MUTE);
366 sc_access[0].reg_addr = DRVPOWERCTRL;
367 sc_access[0].value = 0x00;
368 sc_access[0].mask = 0x00;
370 sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
374 sc_access[0].reg_addr = POWERCTRL1;
375 sc_access[0].value = 0x00;
376 sc_access[0].mask = 0x41;
378 sc_access[1].reg_addr = POWERCTRL2;
379 sc_access[1].value = 0x00;
380 sc_access[1].mask = 0x0C;
382 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
386 snd_pmic_ops_nc.pb_on = 0;
388 nc_enable_audiodac(UNMUTE);
389 mutex_unlock(&snd_pmic_ops_nc.lock);
393 static int nc_power_down_cp(unsigned int device)
395 struct sc_reg_access sc_access[] = {
396 {POWERCTRL1, 0x00, 0xBE},
397 {POWERCTRL2, 0x00, 0x02},
401 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
402 retval = nc_init_card();
406 pr_debug("powering dn cp....\n");
407 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
410 static int nc_set_pcm_voice_params(void)
412 struct sc_reg_access sc_access[] = {
430 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
431 retval = nc_init_card();
435 sst_sc_reg_access(sc_access, PMIC_WRITE, 14);
436 pr_debug("Voice parameters set successfully!!\n");
441 static int nc_set_pcm_audio_params(int sfreq, int word_size, int num_channel)
444 struct sc_reg_access sc_access;
447 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
448 retval = nc_init_card();
482 snd_pmic_ops_nc.num_channel = num_channel;
483 if (snd_pmic_ops_nc.num_channel == 1) {
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);
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);
500 pr_debug("word_size = %d\n", word_size);
502 if (word_size == 24) {
503 sc_access.reg_addr = AUDIOPORT2;
504 sc_access.value = config2 | 0x10;
505 sc_access.mask = 0x1F;
507 sc_access.value = config2;
508 sc_access.mask = 0x1F;
509 sc_access.reg_addr = AUDIOPORT2;
511 sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
513 pr_debug("word_size = %d\n", word_size);
514 sc_access.reg_addr = AUDIOPORT1;
515 sc_access.mask = MASK5|MASK4|MASK1|MASK0;
517 sc_access.value = 0x98;
518 else if (word_size == 24)
519 sc_access.value = 0xAB;
521 return sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
527 static int nc_set_selected_output_dev(u8 value)
529 struct sc_reg_access sc_access_HP[] = {
532 {DRVPOWERCTRL, 0x06, 0x06},
534 struct sc_reg_access sc_access_IS[] = {
537 {DRVPOWERCTRL, 0x00, 0x06},
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();
546 pr_debug("nc set selected output:%d\n", value);
547 mutex_lock(&snd_pmic_ops_nc.lock);
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);
557 retval = sst_sc_reg_access(sc_access_IS, PMIC_WRITE, 3);
558 if (snd_pmic_ops_nc.pb_on)
562 pr_err("rcvd illegal request: %d\n", value);
563 mutex_unlock(&snd_pmic_ops_nc.lock);
566 mutex_unlock(&snd_pmic_ops_nc.lock);
570 static int nc_audio_init(void)
572 struct sc_reg_access sc_acces, sc_access[] = {
587 sst_sc_reg_access(sc_access, PMIC_WRITE, 12);
588 pr_debug("Audio Init successfully!!\n");
590 /*set output device */
591 nc_set_selected_output_dev(snd_pmic_ops_nc.output_dev_id);
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);
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);
610 static int nc_set_audio_port(int status)
612 struct sc_reg_access sc_access[2] = {{0,},};
615 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
616 retval = nc_init_card();
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 */
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);
638 static int nc_set_voice_port(int status)
640 struct sc_reg_access sc_access[2] = {{0,},};
643 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
644 retval = nc_init_card();
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);
665 static int nc_set_mute(int dev_id, u8 value)
667 struct sc_reg_access sc_access[3];
668 u8 mute_val, cap_mute;
671 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
672 retval = nc_init_card();
676 pr_debug("set device id::%d, value %d\n", dev_id, value);
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;
687 /* MUTE:Set the seventh bit */
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;
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);
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;
721 /* mute the system, reset the 6th bit to zero */
722 sc_access[0].value = 0x40;
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);
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;
734 /* mute the system, reset the 6th bit to zero */
735 sc_access[0].value = 0x40;
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);
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;
749 /* mute the system, reset the 6th bit to zero */
750 sc_access[1].value = 0x40;
751 sc_access[0].value = 0x40;
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);
761 case PMIC_SND_LEFT_HP_MUTE:
762 case PMIC_SND_RIGHT_HP_MUTE:
763 snd_pmic_ops_nc.mute_status = value;
765 sc_access[0].value = 0x0;
767 sc_access[0].value = 0x04;
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",
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",
780 sc_access[0].mask = MASK2;
781 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
783 case PMIC_SND_LEFT_SPEAKER_MUTE:
784 case PMIC_SND_RIGHT_SPEAKER_MUTE:
786 sc_access[0].value = 0x00;
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);
801 static int nc_set_vol(int dev_id, int value)
803 struct sc_reg_access sc_access[3];
804 int retval = 0, entries = 0;
806 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
807 retval = nc_init_card();
811 pr_debug("set volume:%d\n", 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;
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);
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;
840 sc_access[0].value = -value;
841 sc_access[0].reg_addr = HPRVOL;
842 sc_access[0].mask = (MASK0|MASK1|MASK2|MASK3|MASK4);
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;
852 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
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;
861 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
869 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, entries);
872 static int nc_set_selected_input_dev(u8 value)
874 struct sc_reg_access sc_access[6];
878 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
879 retval = nc_init_card();
882 snd_pmic_ops_nc.input_dev_id = value;
884 pr_debug("nc set selected input:%d\n", value);
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;
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;
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;
946 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, num_val);
949 static int nc_get_mute(int dev_id, u8 *value)
951 int retval = 0, mask = 0;
952 struct sc_reg_access sc_access = {0,};
954 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
955 retval = nc_init_card();
959 pr_debug("get mute::%d\n", dev_id);
962 case PMIC_SND_AMIC_MUTE:
963 pr_debug("PMIC_SND_INPUT_MUTE_MIC1\n");
964 sc_access.reg_addr = LILSEL;
967 case PMIC_SND_HP_MIC_MUTE:
968 pr_debug("PMIC_SND_INPUT_MUTE_MIC2\n");
969 sc_access.reg_addr = LIRSEL;
972 case PMIC_SND_LEFT_HP_MUTE:
973 case PMIC_SND_RIGHT_HP_MUTE:
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;
979 sc_access.reg_addr = LMUTE;
982 case PMIC_SND_LEFT_SPEAKER_MUTE:
983 pr_debug("PMIC_MONO_EARPIECE_MUTE\n");
984 sc_access.reg_addr = RMUTE;
987 case PMIC_SND_DMIC_MUTE:
988 pr_debug("PMIC_SND_INPUT_MUTE_DMIC\n");
989 sc_access.reg_addr = 0x105;
996 retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
997 pr_debug("reg value = %d\n", sc_access.value);
1000 *value = (sc_access.value) & mask;
1001 pr_debug("masked value = %d\n", *value);
1006 pr_debug("value returned = 0x%x\n", *value);
1010 static int nc_get_vol(int dev_id, int *value)
1012 int retval = 0, mask = 0;
1013 struct sc_reg_access sc_access = {0,};
1015 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
1016 retval = nc_init_card();
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);
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);
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);
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);
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);
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);
1062 static void hp_automute(enum snd_jack_types type, int present)
1065 u8 out = INTERNAL_SPKR;
1067 if (type == SND_JACK_HEADSET)
1069 out = STEREO_HEADPHONE;
1071 nc_set_selected_input_dev(in);
1072 nc_set_selected_output_dev(out);
1075 static void nc_pmic_irq_cb(void *cb_data, u8 intsts)
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,};
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);
1088 mjack = &intelmaddata->jack[0];
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);
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);
1108 pr_debug("MAD short push detected\n");
1109 /* send short push */
1111 jack_event_flag = 1;
1112 buttonpressflag = 1;
1113 mjack->jack.type = MID_JACK_HS_SHORT_PRESS;
1117 pr_debug(":MAD long push detected\n");
1118 /* send long push */
1120 jack_event_flag = 1;
1121 buttonpressflag = 1;
1122 mjack->jack.type = MID_JACK_HS_LONG_PRESS;
1125 if (jack_event_flag)
1126 sst_mad_send_jack_report(&mjack->jack,
1127 buttonpressflag, present);
1129 static int nc_jack_enable(void)
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,