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/delay.h>
34 #include <linux/file.h>
35 #include <sound/control.h>
36 #include "intel_sst.h"
37 #include "intelmid_snd_control.h"
46 ADCSAMPLERATE = 0x104,
80 LINEOUTMIXVOL = 0x126,
91 static void nc_set_amp_power(int power)
93 if (snd_pmic_ops_nc.gpio_amp)
94 gpio_set_value(snd_pmic_ops_nc.gpio_amp, power);
98 * nc_init_card - initialize the sound card
100 * This initializes the audio paths to know values in case of this sound card
102 static int nc_init_card(void)
104 struct sc_reg_access sc_access[] = {
105 {VAUDIOCNT, 0x25, 0},
106 {VOICEPORT1, 0x00, 0},
107 {VOICEPORT2, 0x00, 0},
108 {AUDIOPORT1, 0x98, 0},
109 {AUDIOPORT2, 0x09, 0},
110 {AUDIOLVOL, 0x00, 0},
111 {AUDIORVOL, 0x00, 0},
114 {POWERCTRL1, 0x00, 0},
115 {POWERCTRL2, 0x00, 0},
116 {DRVPOWERCTRL, 0x00, 0},
118 {HPLMIXSEL, 0xee, 0},
119 {HPRMIXSEL, 0xf6, 0},
120 {PCMBUFCTRL, 0x0, 0},
124 {MICCTRL, 0x51, 0x00},
125 {ADCSAMPLERATE, 0x8B, 0x00},
126 {MICSELVOL, 0x5B, 0x00},
129 {LOANTIPOP, 0x00, 0},
130 {DMICCTRL1, 0x40, 0},
133 snd_pmic_ops_nc.card_status = SND_CARD_INIT_DONE;
134 snd_pmic_ops_nc.master_mute = UNMUTE;
135 snd_pmic_ops_nc.mute_status = UNMUTE;
136 sst_sc_reg_access(sc_access, PMIC_WRITE, 27);
137 mutex_init(&snd_pmic_ops_nc.lock);
138 pr_debug("init complete!!\n");
142 static int nc_enable_audiodac(int value)
144 struct sc_reg_access sc_access[3];
147 if (snd_pmic_ops_nc.mute_status == MUTE)
150 if (((snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE) ||
151 (snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)) &&
154 if (value == UNMUTE) {
155 /* unmute the system, set the 7th bit to zero */
158 /* MUTE:Set the seventh bit */
162 sc_access[0].reg_addr = LMUTE;
163 sc_access[1].reg_addr = RMUTE;
164 sc_access[0].mask = sc_access[1].mask = MASK2;
165 sc_access[0].value = sc_access[1].value = mute_val;
167 if (snd_pmic_ops_nc.num_channel == 1)
168 sc_access[1].value = 0x04;
169 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
173 static int nc_power_up_pb(unsigned int port)
175 struct sc_reg_access sc_access[7];
178 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
179 retval = nc_init_card();
184 mutex_lock(&snd_pmic_ops_nc.lock);
185 nc_enable_audiodac(MUTE);
188 pr_debug("powering up pb....\n");
190 sc_access[0].reg_addr = VAUDIOCNT;
191 sc_access[0].value = 0x27;
192 sc_access[0].mask = 0x27;
193 sc_access[1].reg_addr = VREFPLL;
195 sc_access[1].value = 0x3A;
196 sc_access[1].mask = 0x3A;
197 } else if (port == 1) {
198 sc_access[1].value = 0x35;
199 sc_access[1].mask = 0x35;
201 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
205 sc_access[0].reg_addr = POWERCTRL1;
207 sc_access[0].value = 0x40;
208 sc_access[0].mask = 0x40;
209 } else if (port == 1) {
210 sc_access[0].value = 0x01;
211 sc_access[0].mask = 0x01;
213 sc_access[1].reg_addr = POWERCTRL2;
214 sc_access[1].value = 0x0C;
215 sc_access[1].mask = 0x0C;
217 sc_access[2].reg_addr = DRVPOWERCTRL;
218 sc_access[2].value = 0x86;
219 sc_access[2].mask = 0x86;
221 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
225 snd_pmic_ops_nc.pb_on = 1;
228 * There is a mismatch between Playback Sources and the enumerated
229 * values of output sources. This mismatch causes ALSA upper to send
230 * Item 1 for Internal Speaker, but the expected enumeration is 2! For
231 * now, treat MONO_EARPIECE and INTERNAL_SPKR identically and power up
232 * the needed resources
234 if (snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE ||
235 snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)
237 nc_enable_audiodac(UNMUTE);
238 mutex_unlock(&snd_pmic_ops_nc.lock);
242 static int nc_power_up_cp(unsigned int port)
244 struct sc_reg_access sc_access[5];
248 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
249 retval = nc_init_card();
254 pr_debug("powering up cp....\n");
258 sc_access[0].reg_addr = VAUDIOCNT;
259 sc_access[0].value = 0x27;
260 sc_access[0].mask = 0x27;
261 sc_access[1].reg_addr = VREFPLL;
263 sc_access[1].value = 0x3E;
264 sc_access[1].mask = 0x3E;
265 } else if (port == 1) {
266 sc_access[1].value = 0x35;
267 sc_access[1].mask = 0x35;
270 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
273 sc_access[0].reg_addr = POWERCTRL1;
275 sc_access[0].value = 0xB4;
276 sc_access[0].mask = 0xB4;
277 } else if (port == 1) {
278 sc_access[0].value = 0xBF;
279 sc_access[0].mask = 0xBF;
281 sc_access[1].reg_addr = POWERCTRL2;
283 sc_access[1].value = 0x0C;
284 sc_access[1].mask = 0x0C;
285 } else if (port == 1) {
286 sc_access[1].value = 0x02;
287 sc_access[1].mask = 0x02;
290 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
294 static int nc_power_down(void)
297 struct sc_reg_access sc_access[5];
299 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
300 retval = nc_init_card();
303 nc_enable_audiodac(MUTE);
306 pr_debug("powering dn nc_power_down ....\n");
308 if (snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE ||
309 snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)
314 sc_access[0].reg_addr = DRVPOWERCTRL;
315 sc_access[0].value = 0x00;
316 sc_access[0].mask = 0x00;
318 sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
320 sc_access[0].reg_addr = POWERCTRL1;
321 sc_access[0].value = 0x00;
322 sc_access[0].mask = 0x00;
324 sc_access[1].reg_addr = POWERCTRL2;
325 sc_access[1].value = 0x00;
326 sc_access[1].mask = 0x00;
330 sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
333 sc_access[0].reg_addr = VREFPLL;
334 sc_access[0].value = 0x10;
335 sc_access[0].mask = 0x10;
337 sc_access[1].reg_addr = VAUDIOCNT;
338 sc_access[1].value = 0x25;
339 sc_access[1].mask = 0x25;
342 retval = sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
345 return nc_enable_audiodac(UNMUTE);
348 static int nc_power_down_pb(unsigned int device)
352 struct sc_reg_access sc_access[5];
354 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
355 retval = nc_init_card();
359 pr_debug("powering dn pb....\n");
360 mutex_lock(&snd_pmic_ops_nc.lock);
361 nc_enable_audiodac(MUTE);
367 sc_access[0].reg_addr = DRVPOWERCTRL;
368 sc_access[0].value = 0x00;
369 sc_access[0].mask = 0x00;
371 sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
375 sc_access[0].reg_addr = POWERCTRL1;
376 sc_access[0].value = 0x00;
377 sc_access[0].mask = 0x41;
379 sc_access[1].reg_addr = POWERCTRL2;
380 sc_access[1].value = 0x00;
381 sc_access[1].mask = 0x0C;
383 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
387 snd_pmic_ops_nc.pb_on = 0;
389 nc_enable_audiodac(UNMUTE);
390 mutex_unlock(&snd_pmic_ops_nc.lock);
394 static int nc_power_down_cp(unsigned int device)
396 struct sc_reg_access sc_access[] = {
397 {POWERCTRL1, 0x00, 0xBE},
398 {POWERCTRL2, 0x00, 0x02},
402 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
403 retval = nc_init_card();
407 pr_debug("powering dn cp....\n");
408 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
411 static int nc_set_pcm_voice_params(void)
413 struct sc_reg_access sc_access[] = {
431 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
432 retval = nc_init_card();
436 sst_sc_reg_access(sc_access, PMIC_WRITE, 14);
437 pr_debug("Voice parameters set successfully!!\n");
442 static int nc_set_pcm_audio_params(int sfreq, int word_size, int num_channel)
445 struct sc_reg_access sc_access;
448 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
449 retval = nc_init_card();
483 snd_pmic_ops_nc.num_channel = num_channel;
484 if (snd_pmic_ops_nc.num_channel == 1) {
486 sc_access.value = 0x07;
487 sc_access.reg_addr = RMUTE;
488 pr_debug("RIGHT_HP_MUTE value%d\n", sc_access.value);
489 sc_access.mask = MASK2;
490 sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
492 sc_access.value = 0x00;
493 sc_access.reg_addr = RMUTE;
494 pr_debug("RIGHT_HP_MUTE value %d\n", sc_access.value);
495 sc_access.mask = MASK2;
496 sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
501 pr_debug("word_size = %d\n", word_size);
503 if (word_size == 24) {
504 sc_access.reg_addr = AUDIOPORT2;
505 sc_access.value = config2 | 0x10;
506 sc_access.mask = 0x1F;
508 sc_access.value = config2;
509 sc_access.mask = 0x1F;
510 sc_access.reg_addr = AUDIOPORT2;
512 sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
514 pr_debug("word_size = %d\n", word_size);
515 sc_access.reg_addr = AUDIOPORT1;
516 sc_access.mask = MASK5|MASK4|MASK1|MASK0;
518 sc_access.value = 0x98;
519 else if (word_size == 24)
520 sc_access.value = 0xAB;
522 return sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
528 static int nc_set_selected_output_dev(u8 value)
530 struct sc_reg_access sc_access_HP[] = {
533 {DRVPOWERCTRL, 0x06, 0x06},
535 struct sc_reg_access sc_access_IS[] = {
538 {DRVPOWERCTRL, 0x00, 0x06},
542 snd_pmic_ops_nc.output_dev_id = value;
543 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
544 retval = nc_init_card();
547 pr_debug("nc set selected output:%d\n", value);
548 mutex_lock(&snd_pmic_ops_nc.lock);
550 case STEREO_HEADPHONE:
551 if (snd_pmic_ops_nc.pb_on)
552 sst_sc_reg_access(sc_access_HP+2, PMIC_WRITE, 1);
553 retval = sst_sc_reg_access(sc_access_HP, PMIC_WRITE, 2);
558 retval = sst_sc_reg_access(sc_access_IS, PMIC_WRITE, 3);
559 if (snd_pmic_ops_nc.pb_on)
563 pr_err("rcvd illegal request: %d\n", value);
564 mutex_unlock(&snd_pmic_ops_nc.lock);
567 mutex_unlock(&snd_pmic_ops_nc.lock);
571 static int nc_audio_init(void)
573 struct sc_reg_access sc_acces, sc_access[] = {
588 sst_sc_reg_access(sc_access, PMIC_WRITE, 12);
589 pr_debug("Audio Init successfully!!\n");
591 /*set output device */
592 nc_set_selected_output_dev(snd_pmic_ops_nc.output_dev_id);
594 if (snd_pmic_ops_nc.num_channel == 1) {
595 sc_acces.value = 0x07;
596 sc_acces.reg_addr = RMUTE;
597 pr_debug("RIGHT_HP_MUTE value%d\n", sc_acces.value);
598 sc_acces.mask = MASK2;
599 sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
601 sc_acces.value = 0x00;
602 sc_acces.reg_addr = RMUTE;
603 pr_debug("RIGHT_HP_MUTE value%d\n", sc_acces.value);
604 sc_acces.mask = MASK2;
605 sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
611 static int nc_set_audio_port(int status)
613 struct sc_reg_access sc_access[2] = {{0,},};
616 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
617 retval = nc_init_card();
621 if (status == DEACTIVATE) {
622 /* Deactivate audio port-tristate and power */
623 sc_access[0].value = 0x00;
624 sc_access[0].mask = MASK4|MASK5;
625 sc_access[0].reg_addr = AUDIOPORT1;
626 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
627 } else if (status == ACTIVATE) {
628 /* activate audio port */
630 sc_access[0].value = 0x10;
631 sc_access[0].mask = MASK4|MASK5 ;
632 sc_access[0].reg_addr = AUDIOPORT1;
633 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
639 static int nc_set_voice_port(int status)
641 struct sc_reg_access sc_access[2] = {{0,},};
644 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
645 retval = nc_init_card();
649 if (status == DEACTIVATE) {
650 /* Activate Voice port */
651 sc_access[0].value = 0x00;
652 sc_access[0].mask = MASK4;
653 sc_access[0].reg_addr = VOICEPORT1;
654 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
655 } else if (status == ACTIVATE) {
656 /* Deactivate voice port */
657 nc_set_pcm_voice_params();
658 sc_access[0].value = 0x10;
659 sc_access[0].mask = MASK4;
660 sc_access[0].reg_addr = VOICEPORT1;
661 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
666 static int nc_set_mute(int dev_id, u8 value)
668 struct sc_reg_access sc_access[3];
669 u8 mute_val, cap_mute;
672 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
673 retval = nc_init_card();
677 pr_debug("set device id::%d, value %d\n", dev_id, value);
680 case PMIC_SND_MUTE_ALL:
681 pr_debug("PMIC_SND_MUTE_ALL value %d\n", value);
682 snd_pmic_ops_nc.mute_status = value;
683 snd_pmic_ops_nc.master_mute = value;
684 if (value == UNMUTE) {
685 /* unmute the system, set the 7th bit to zero */
686 mute_val = cap_mute = 0x00;
688 /* MUTE:Set the seventh bit */
692 sc_access[0].reg_addr = AUDIOLVOL;
693 sc_access[1].reg_addr = AUDIORVOL;
694 sc_access[0].mask = sc_access[1].mask = MASK7;
695 sc_access[0].value = sc_access[1].value = mute_val;
696 if (snd_pmic_ops_nc.num_channel == 1)
697 sc_access[1].value = 0x80;
698 if (!sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2)) {
699 sc_access[0].reg_addr = 0x109;
700 sc_access[1].reg_addr = 0x10a;
701 sc_access[2].reg_addr = 0x105;
702 sc_access[0].mask = sc_access[1].mask =
703 sc_access[2].mask = MASK6;
704 sc_access[0].value = sc_access[1].value =
705 sc_access[2].value = cap_mute;
707 if ((snd_pmic_ops_nc.input_dev_id == AMIC) ||
708 (snd_pmic_ops_nc.input_dev_id == DMIC))
709 sc_access[1].value = 0x40;
710 if (snd_pmic_ops_nc.input_dev_id == HS_MIC)
711 sc_access[0].value = 0x40;
712 retval = sst_sc_reg_access(sc_access,
713 PMIC_READ_MODIFY, 3);
716 case PMIC_SND_HP_MIC_MUTE:
717 pr_debug("PMIC_SND_HPMIC_MUTE value %d\n", value);
718 if (value == UNMUTE) {
719 /* unmute the system, set the 6th bit to one */
720 sc_access[0].value = 0x00;
722 /* mute the system, reset the 6th bit to zero */
723 sc_access[0].value = 0x40;
725 sc_access[0].reg_addr = LIRSEL;
726 sc_access[0].mask = MASK6;
727 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
729 case PMIC_SND_AMIC_MUTE:
730 pr_debug("PMIC_SND_AMIC_MUTE value %d\n", value);
731 if (value == UNMUTE) {
732 /* unmute the system, set the 6th bit to one */
733 sc_access[0].value = 0x00;
735 /* mute the system, reset the 6th bit to zero */
736 sc_access[0].value = 0x40;
738 sc_access[0].reg_addr = LILSEL;
739 sc_access[0].mask = MASK6;
740 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
743 case PMIC_SND_DMIC_MUTE:
744 pr_debug("INPUT_MUTE_DMIC value%d\n", value);
745 if (value == UNMUTE) {
746 /* unmute the system, set the 6th bit to one */
747 sc_access[1].value = 0x00;
748 sc_access[0].value = 0x00;
750 /* mute the system, reset the 6th bit to zero */
751 sc_access[1].value = 0x40;
752 sc_access[0].value = 0x40;
754 sc_access[0].reg_addr = DMICCTRL1;
755 sc_access[0].mask = MASK6;
756 sc_access[1].reg_addr = LILSEL;
757 sc_access[1].mask = MASK6;
758 retval = sst_sc_reg_access(sc_access,
759 PMIC_READ_MODIFY, 2);
762 case PMIC_SND_LEFT_HP_MUTE:
763 case PMIC_SND_RIGHT_HP_MUTE:
764 snd_pmic_ops_nc.mute_status = value;
766 sc_access[0].value = 0x0;
768 sc_access[0].value = 0x04;
770 if (dev_id == PMIC_SND_LEFT_HP_MUTE) {
771 sc_access[0].reg_addr = LMUTE;
772 pr_debug("LEFT_HP_MUTE value %d\n",
775 if (snd_pmic_ops_nc.num_channel == 1)
776 sc_access[0].value = 0x04;
777 sc_access[0].reg_addr = RMUTE;
778 pr_debug("RIGHT_HP_MUTE value %d\n",
781 sc_access[0].mask = MASK2;
782 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
784 case PMIC_SND_LEFT_SPEAKER_MUTE:
785 case PMIC_SND_RIGHT_SPEAKER_MUTE:
787 sc_access[0].value = 0x00;
789 sc_access[0].value = 0x03;
790 sc_access[0].reg_addr = LMUTE;
791 pr_debug("SPEAKER_MUTE %d\n", sc_access[0].value);
792 sc_access[0].mask = MASK1;
793 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
802 static int nc_set_vol(int dev_id, int value)
804 struct sc_reg_access sc_access[3];
805 int retval = 0, entries = 0;
807 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
808 retval = nc_init_card();
812 pr_debug("set volume:%d\n", dev_id);
814 case PMIC_SND_CAPTURE_VOL:
815 pr_debug("PMIC_SND_CAPTURE_VOL:value::%d\n", value);
816 sc_access[0].value = sc_access[1].value =
817 sc_access[2].value = -value;
818 sc_access[0].mask = sc_access[1].mask = sc_access[2].mask =
819 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
820 sc_access[0].reg_addr = 0x10a;
821 sc_access[1].reg_addr = 0x109;
822 sc_access[2].reg_addr = 0x105;
826 case PMIC_SND_LEFT_PB_VOL:
827 pr_debug("PMIC_SND_LEFT_HP_VOL %d\n", value);
828 sc_access[0].value = -value;
829 sc_access[0].reg_addr = HPLVOL;
830 sc_access[0].mask = (MASK0|MASK1|MASK2|MASK3|MASK4);
834 case PMIC_SND_RIGHT_PB_VOL:
835 pr_debug("PMIC_SND_RIGHT_HP_VOL value %d\n", value);
836 if (snd_pmic_ops_nc.num_channel == 1) {
837 sc_access[0].value = 0x04;
838 sc_access[0].reg_addr = RMUTE;
839 sc_access[0].mask = MASK2;
841 sc_access[0].value = -value;
842 sc_access[0].reg_addr = HPRVOL;
843 sc_access[0].mask = (MASK0|MASK1|MASK2|MASK3|MASK4);
848 case PMIC_SND_LEFT_MASTER_VOL:
849 pr_debug("PMIC_SND_LEFT_MASTER_VOL value %d\n", value);
850 sc_access[0].value = -value;
851 sc_access[0].reg_addr = AUDIOLVOL;
853 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
857 case PMIC_SND_RIGHT_MASTER_VOL:
858 pr_debug("PMIC_SND_RIGHT_MASTER_VOL value %d\n", value);
859 sc_access[0].value = -value;
860 sc_access[0].reg_addr = AUDIORVOL;
862 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
870 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, entries);
873 static int nc_set_selected_input_dev(u8 value)
875 struct sc_reg_access sc_access[6];
879 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
880 retval = nc_init_card();
883 snd_pmic_ops_nc.input_dev_id = value;
885 pr_debug("nc set selected input:%d\n", value);
889 pr_debug("Selecting AMIC\n");
890 sc_access[0].reg_addr = 0x107;
891 sc_access[0].value = 0x40;
892 sc_access[0].mask = MASK6|MASK3|MASK1|MASK0;
893 sc_access[1].reg_addr = 0x10a;
894 sc_access[1].value = 0x40;
895 sc_access[1].mask = MASK6;
896 sc_access[2].reg_addr = 0x109;
897 sc_access[2].value = 0x00;
898 sc_access[2].mask = MASK6;
899 sc_access[3].reg_addr = 0x105;
900 sc_access[3].value = 0x40;
901 sc_access[3].mask = MASK6;
906 pr_debug("Selecting HS_MIC\n");
907 sc_access[0].reg_addr = MICCTRL;
908 sc_access[0].mask = MASK6|MASK3|MASK1|MASK0;
909 sc_access[0].value = 0x00;
910 sc_access[1].reg_addr = 0x109;
911 sc_access[1].mask = MASK6;
912 sc_access[1].value = 0x40;
913 sc_access[2].reg_addr = 0x10a;
914 sc_access[2].mask = MASK6;
915 sc_access[2].value = 0x00;
916 sc_access[3].reg_addr = 0x105;
917 sc_access[3].value = 0x40;
918 sc_access[3].mask = MASK6;
919 sc_access[4].reg_addr = ADCSAMPLERATE;
920 sc_access[4].mask = MASK7|MASK6|MASK5|MASK4|MASK3;
921 sc_access[4].value = 0xc8;
927 sc_access[0].reg_addr = MICCTRL;
928 sc_access[0].mask = MASK6|MASK3|MASK1|MASK0;
929 sc_access[0].value = 0x0B;
930 sc_access[1].reg_addr = 0x105;
931 sc_access[1].value = 0x80;
932 sc_access[1].mask = MASK7|MASK6;
933 sc_access[2].reg_addr = 0x10a;
934 sc_access[2].value = 0x40;
935 sc_access[2].mask = MASK6;
936 sc_access[3].reg_addr = LILSEL;
937 sc_access[3].mask = MASK6;
938 sc_access[3].value = 0x00;
939 sc_access[4].reg_addr = ADCSAMPLERATE;
940 sc_access[4].mask = MASK7|MASK6|MASK5|MASK4|MASK3;
941 sc_access[4].value = 0x33;
947 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, num_val);
950 static int nc_get_mute(int dev_id, u8 *value)
952 int retval = 0, mask = 0;
953 struct sc_reg_access sc_access = {0,};
955 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
956 retval = nc_init_card();
960 pr_debug("get mute::%d\n", dev_id);
963 case PMIC_SND_AMIC_MUTE:
964 pr_debug("PMIC_SND_INPUT_MUTE_MIC1\n");
965 sc_access.reg_addr = LILSEL;
968 case PMIC_SND_HP_MIC_MUTE:
969 pr_debug("PMIC_SND_INPUT_MUTE_MIC2\n");
970 sc_access.reg_addr = LIRSEL;
973 case PMIC_SND_LEFT_HP_MUTE:
974 case PMIC_SND_RIGHT_HP_MUTE:
976 pr_debug("PMIC_SN_LEFT/RIGHT_HP_MUTE\n");
977 if (dev_id == PMIC_SND_RIGHT_HP_MUTE)
978 sc_access.reg_addr = RMUTE;
980 sc_access.reg_addr = LMUTE;
983 case PMIC_SND_LEFT_SPEAKER_MUTE:
984 pr_debug("PMIC_MONO_EARPIECE_MUTE\n");
985 sc_access.reg_addr = RMUTE;
988 case PMIC_SND_DMIC_MUTE:
989 pr_debug("PMIC_SND_INPUT_MUTE_DMIC\n");
990 sc_access.reg_addr = 0x105;
997 retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
998 pr_debug("reg value = %d\n", sc_access.value);
1001 *value = (sc_access.value) & mask;
1002 pr_debug("masked value = %d\n", *value);
1007 pr_debug("value returned = 0x%x\n", *value);
1011 static int nc_get_vol(int dev_id, int *value)
1013 int retval = 0, mask = 0;
1014 struct sc_reg_access sc_access = {0,};
1016 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
1017 retval = nc_init_card();
1022 case PMIC_SND_CAPTURE_VOL:
1023 pr_debug("PMIC_SND_INPUT_CAPTURE_VOL\n");
1024 sc_access.reg_addr = LILSEL;
1025 mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
1028 case PMIC_SND_LEFT_MASTER_VOL:
1029 pr_debug("GET_VOLUME_PMIC_LEFT_MASTER_VOL\n");
1030 sc_access.reg_addr = AUDIOLVOL;
1031 mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
1034 case PMIC_SND_RIGHT_MASTER_VOL:
1035 pr_debug("GET_VOLUME_PMIC_RIGHT_MASTER_VOL\n");
1036 sc_access.reg_addr = AUDIORVOL;
1037 mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
1040 case PMIC_SND_RIGHT_PB_VOL:
1041 pr_debug("GET_VOLUME_PMIC_RIGHT_HP_VOL\n");
1042 sc_access.reg_addr = HPRVOL;
1043 mask = (MASK0|MASK1|MASK2|MASK3|MASK4);
1046 case PMIC_SND_LEFT_PB_VOL:
1047 pr_debug("GET_VOLUME_PMIC_LEFT_HP_VOL\n");
1048 sc_access.reg_addr = HPLVOL;
1049 mask = (MASK0|MASK1|MASK2|MASK3|MASK4);
1056 retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
1057 pr_debug("value read = 0x%x\n", sc_access.value);
1058 *value = -((sc_access.value) & mask);
1059 pr_debug("get vol value returned = %d\n", *value);
1063 static void hp_automute(enum snd_jack_types type, int present)
1066 u8 out = INTERNAL_SPKR;
1068 if (type == SND_JACK_HEADSET)
1070 out = STEREO_HEADPHONE;
1072 nc_set_selected_input_dev(in);
1073 nc_set_selected_output_dev(out);
1076 static void nc_pmic_irq_cb(void *cb_data, u8 intsts)
1079 struct mad_jack *mjack = NULL;
1080 unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
1081 struct snd_intelmad *intelmaddata = cb_data;
1082 struct sc_reg_access sc_access_read = {0,};
1084 sc_access_read.reg_addr = 0x132;
1085 sst_sc_reg_access(&sc_access_read, PMIC_READ, 1);
1086 value = (sc_access_read.value);
1087 pr_debug("value returned = 0x%x\n", value);
1089 mjack = &intelmaddata->jack[0];
1091 pr_debug("SST DBG:MAD headset detected\n");
1092 /* send headset detect/undetect */
1093 present = (value == 0x1) ? 1 : 0;
1094 jack_event_flag = 1;
1095 mjack->jack.type = SND_JACK_HEADSET;
1096 hp_automute(SND_JACK_HEADSET, present);
1100 pr_debug(":MAD headphone detected\n");
1101 /* send headphone detect/undetect */
1102 present = (value == 0x2) ? 1 : 0;
1103 jack_event_flag = 1;
1104 mjack->jack.type = SND_JACK_HEADPHONE;
1105 hp_automute(SND_JACK_HEADPHONE, present);
1109 pr_debug("MAD short push detected\n");
1110 /* send short push */
1112 jack_event_flag = 1;
1113 buttonpressflag = 1;
1114 mjack->jack.type = MID_JACK_HS_SHORT_PRESS;
1118 pr_debug(":MAD long push detected\n");
1119 /* send long push */
1121 jack_event_flag = 1;
1122 buttonpressflag = 1;
1123 mjack->jack.type = MID_JACK_HS_LONG_PRESS;
1126 if (jack_event_flag)
1127 sst_mad_send_jack_report(&mjack->jack,
1128 buttonpressflag, present);
1130 static int nc_jack_enable(void)
1135 struct snd_pmic_ops snd_pmic_ops_nc = {
1136 .input_dev_id = DMIC,
1137 .output_dev_id = INTERNAL_SPKR,
1138 .set_input_dev = nc_set_selected_input_dev,
1139 .set_output_dev = nc_set_selected_output_dev,
1140 .set_mute = nc_set_mute,
1141 .get_mute = nc_get_mute,
1142 .set_vol = nc_set_vol,
1143 .get_vol = nc_get_vol,
1144 .init_card = nc_init_card,
1145 .set_pcm_audio_params = nc_set_pcm_audio_params,
1146 .set_pcm_voice_params = nc_set_pcm_voice_params,
1147 .set_voice_port = nc_set_voice_port,
1148 .set_audio_port = nc_set_audio_port,
1149 .power_up_pmic_pb = nc_power_up_pb,
1150 .power_up_pmic_cp = nc_power_up_cp,
1151 .power_down_pmic_pb = nc_power_down_pb,
1152 .power_down_pmic_cp = nc_power_down_cp,
1153 .power_down_pmic = nc_power_down,
1154 .pmic_irq_cb = nc_pmic_irq_cb,
1155 .pmic_jack_enable = nc_jack_enable,