2 * intel_sst_v0_control.c - Intel SST Driver for audio engine
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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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 1
29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
31 #include <linux/pci.h>
32 #include <linux/file.h>
33 #include <sound/control.h>
34 #include "intel_sst.h"
35 #include "intelmid_snd_control.h"
43 MISCVOICECTRL = 0x184,
51 VOICEDACCTRL1 = 0x18C,
52 STEREOADCCTRL = 0x18D,
62 HEADSETDETECTINT = 0x197,
63 HEADSETDETECTINTMASK = 0x198,
68 static bool jack_det_enabled;
71 * fs_init_card - initialize the sound card
73 * This initializes the audio paths to know values in case of this sound card
75 static int fs_init_card(void)
77 struct sc_reg_access sc_access[] = {
107 snd_pmic_ops_fs.card_status = SND_CARD_INIT_DONE;
108 snd_pmic_ops_fs.master_mute = UNMUTE;
109 snd_pmic_ops_fs.mute_status = UNMUTE;
110 snd_pmic_ops_fs.num_channel = 2;
111 return sst_sc_reg_access(sc_access, PMIC_WRITE, 27);
114 static int fs_enable_audiodac(int value)
116 struct sc_reg_access sc_access[3];
117 sc_access[0].reg_addr = AUD16;
118 sc_access[1].reg_addr = AUD17;
119 sc_access[2].reg_addr = AUD15;
120 sc_access[0].mask = sc_access[1].mask = sc_access[2].mask = MASK7;
122 if (snd_pmic_ops_fs.mute_status == MUTE)
125 sc_access[0].value = sc_access[1].value =
126 sc_access[2].value = 0x80;
129 sc_access[0].value = sc_access[1].value =
130 sc_access[2].value = 0x0;
132 if (snd_pmic_ops_fs.num_channel == 1)
133 sc_access[1].value = sc_access[2].value = 0x80;
134 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
138 static int fs_power_up_pb(unsigned int port)
140 struct sc_reg_access sc_access[] = {
141 {AUDIOBIAS, 0x00, MASK7},
142 {POWERCTRL1, 0xC6, 0xC6},
143 {POWERCTRL2, 0x30, 0x30},
148 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
149 retval = fs_init_card();
152 retval = fs_enable_audiodac(MUTE);
153 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
158 pr_debug("in fs power up pb\n");
159 return fs_enable_audiodac(UNMUTE);
162 static int fs_power_down_pb(unsigned int device)
164 struct sc_reg_access sc_access[] = {
165 {POWERCTRL1, 0x00, 0xC6},
166 {POWERCTRL2, 0x00, 0x30},
170 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
171 retval = fs_init_card();
174 retval = fs_enable_audiodac(MUTE);
175 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
180 pr_debug("in fsl power down pb\n");
181 return fs_enable_audiodac(UNMUTE);
184 static int fs_power_up_cp(unsigned int port)
186 struct sc_reg_access sc_access[] = {
187 {POWERCTRL2, 0x32, 0x32}, /*NOTE power up A ADC only as*/
188 {AUDIOBIAS, 0x00, MASK7},
189 /*as turning on V ADC causes noise*/
193 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
194 retval = fs_init_card();
197 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
200 static int fs_power_down_cp(unsigned int device)
202 struct sc_reg_access sc_access[] = {
203 {POWERCTRL2, 0x00, 0x03},
207 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
208 retval = fs_init_card();
211 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
214 static int fs_power_down(void)
217 struct sc_reg_access sc_access[] = {
218 {AUDIOBIAS, MASK7, MASK7},
221 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
222 retval = fs_init_card();
225 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
228 static int fs_set_pcm_voice_params(void)
230 struct sc_reg_access sc_access[] = {
260 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
261 retval = fs_init_card();
264 return sst_sc_reg_access(sc_access, PMIC_WRITE, 26);
267 static int fs_set_audio_port(int status)
269 struct sc_reg_access sc_access[2];
272 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
273 retval = fs_init_card();
276 if (status == DEACTIVATE) {
277 /* Deactivate audio port-tristate and power */
278 sc_access[0].value = 0x00;
279 sc_access[0].mask = MASK6|MASK7;
280 sc_access[0].reg_addr = AUDIOPORT1;
281 sc_access[1].value = 0x00;
282 sc_access[1].mask = MASK4|MASK5;
283 sc_access[1].reg_addr = POWERCTRL2;
284 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
285 } else if (status == ACTIVATE) {
286 /* activate audio port */
287 sc_access[0].value = 0xC0;
288 sc_access[0].mask = MASK6|MASK7;
289 sc_access[0].reg_addr = AUDIOPORT1;
290 sc_access[1].value = 0x30;
291 sc_access[1].mask = MASK4|MASK5;
292 sc_access[1].reg_addr = POWERCTRL2;
293 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
298 static int fs_set_voice_port(int status)
300 struct sc_reg_access sc_access[2];
303 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
304 retval = fs_init_card();
307 if (status == DEACTIVATE) {
308 /* Deactivate audio port-tristate and power */
309 sc_access[0].value = 0x00;
310 sc_access[0].mask = MASK6|MASK7;
311 sc_access[0].reg_addr = VOICEPORT1;
312 sc_access[1].value = 0x00;
313 sc_access[1].mask = MASK0|MASK1;
314 sc_access[1].reg_addr = POWERCTRL2;
315 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
316 } else if (status == ACTIVATE) {
317 /* activate audio port */
318 sc_access[0].value = 0xC0;
319 sc_access[0].mask = MASK6|MASK7;
320 sc_access[0].reg_addr = VOICEPORT1;
321 sc_access[1].value = 0x03;
322 sc_access[1].mask = MASK0|MASK1;
323 sc_access[1].reg_addr = POWERCTRL2;
324 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
329 static int fs_set_pcm_audio_params(int sfreq, int word_size, int num_channel)
332 struct sc_reg_access sc_access[4];
333 int retval = 0, num_value = 0;
335 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
336 retval = fs_init_card();
371 snd_pmic_ops_fs.num_channel = num_channel;
372 if (snd_pmic_ops_fs.num_channel == 1) {
373 sc_access[0].reg_addr = AUD17;
374 sc_access[1].reg_addr = AUD15;
375 sc_access[0].mask = sc_access[1].mask = MASK7;
376 sc_access[0].value = sc_access[1].value = 0x80;
377 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
380 sc_access[0].reg_addr = AUD17;
381 sc_access[1].reg_addr = AUD15;
382 sc_access[0].mask = sc_access[1].mask = MASK7;
383 sc_access[0].value = sc_access[1].value = 0x00;
384 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
387 pr_debug("sfreq:%d,Register value = %x\n", sfreq, config1);
389 if (word_size == 24) {
390 sc_access[0].reg_addr = AUDIOPORT1;
391 sc_access[0].mask = MASK0|MASK1|MASK2|MASK3;
392 sc_access[0].value = 0xFB;
395 sc_access[1].reg_addr = AUDIOPORT2;
396 sc_access[1].value = config1 | 0x10;
397 sc_access[1].mask = MASK0 | MASK1 | MASK2 | MASK3
398 | MASK4 | MASK5 | MASK6;
400 sc_access[2].reg_addr = MISCAUDCTRL;
401 sc_access[2].value = 0x02;
402 sc_access[2].mask = 0x02;
408 sc_access[0].reg_addr = AUDIOPORT2;
409 sc_access[0].value = config1;
410 sc_access[0].mask = MASK0|MASK1|MASK2|MASK3;
412 sc_access[1].reg_addr = MISCAUDCTRL;
413 sc_access[1].value = 0x00;
414 sc_access[1].mask = 0x02;
417 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, num_value);
421 static int fs_set_selected_input_dev(u8 value)
423 struct sc_reg_access sc_access_dmic[] = {
424 {MICCTRL, 0x81, 0xf7},
425 {MICLICTRL3, 0x00, 0xE0},
427 struct sc_reg_access sc_access_mic[] = {
428 {MICCTRL, 0x40, MASK2|MASK4|MASK5|MASK6|MASK7},
429 {MICLICTRL3, 0x00, 0xE0},
431 struct sc_reg_access sc_access_hsmic[] = {
432 {MICCTRL, 0x10, MASK2|MASK4|MASK5|MASK6|MASK7},
433 {MICLICTRL3, 0x00, 0xE0},
438 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
439 retval = fs_init_card();
445 pr_debug("Selecting amic not supported in mono cfg\n");
446 return sst_sc_reg_access(sc_access_mic, PMIC_READ_MODIFY, 2);
450 pr_debug("Selecting hsmic\n");
451 return sst_sc_reg_access(sc_access_hsmic,
452 PMIC_READ_MODIFY, 2);
456 pr_debug("Selecting dmic\n");
457 return sst_sc_reg_access(sc_access_dmic, PMIC_READ_MODIFY, 2);
466 static int fs_set_selected_output_dev(u8 value)
468 struct sc_reg_access sc_access_hp[] = {
472 struct sc_reg_access sc_access_is[] = {
478 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
479 retval = fs_init_card();
484 case STEREO_HEADPHONE:
485 pr_debug("SST DBG:Selecting headphone\n");
486 return sst_sc_reg_access(sc_access_hp, PMIC_WRITE, 2);
490 pr_debug("SST DBG:Selecting internal spkr\n");
491 return sst_sc_reg_access(sc_access_is, PMIC_READ_MODIFY, 2);
500 static int fs_set_mute(int dev_id, u8 value)
502 struct sc_reg_access sc_access[6] = {{0,},};
506 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
507 retval = fs_init_card();
512 pr_debug("dev_id:0x%x value:0x%x\n", dev_id, value);
514 case PMIC_SND_DMIC_MUTE:
515 sc_access[0].reg_addr = MICCTRL;
516 sc_access[1].reg_addr = MICLICTRL1;
517 sc_access[2].reg_addr = MICLICTRL2;
518 sc_access[0].mask = MASK5;
519 sc_access[1].mask = sc_access[2].mask = MASK6;
521 sc_access[0].value = 0x20;
522 sc_access[2].value = sc_access[1].value = 0x40;
524 sc_access[0].value = sc_access[1].value
525 = sc_access[2].value = 0x0;
528 case PMIC_SND_HP_MIC_MUTE:
529 case PMIC_SND_AMIC_MUTE:
530 sc_access[0].reg_addr = MICLICTRL1;
531 sc_access[1].reg_addr = MICLICTRL2;
532 sc_access[0].mask = sc_access[1].mask = MASK6;
534 sc_access[0].value = sc_access[1].value = 0x40;
536 sc_access[0].value = sc_access[1].value = 0x0;
539 case PMIC_SND_LEFT_SPEAKER_MUTE:
540 case PMIC_SND_LEFT_HP_MUTE:
541 sc_access[0].reg_addr = AUD16;
542 sc_access[1].reg_addr = AUD15;
544 sc_access[0].mask = sc_access[1].mask = MASK7;
546 sc_access[0].value = sc_access[1].value = 0x80;
548 sc_access[0].value = sc_access[1].value = 0x0;
550 snd_pmic_ops_fs.mute_status = value;
552 case PMIC_SND_RIGHT_HP_MUTE:
553 case PMIC_SND_RIGHT_SPEAKER_MUTE:
554 sc_access[0].reg_addr = AUD17;
555 sc_access[1].reg_addr = AUD15;
556 sc_access[0].mask = sc_access[1].mask = MASK7;
558 sc_access[0].value = sc_access[1].value = 0x80;
560 sc_access[0].value = sc_access[1].value = 0x0;
561 snd_pmic_ops_fs.mute_status = value;
562 if (snd_pmic_ops_fs.num_channel == 1)
563 sc_access[0].value = sc_access[1].value = 0x80;
566 case PMIC_SND_MUTE_ALL:
567 sc_access[0].reg_addr = AUD16;
568 sc_access[1].reg_addr = AUD17;
569 sc_access[2].reg_addr = AUD15;
570 sc_access[3].reg_addr = MICCTRL;
571 sc_access[4].reg_addr = MICLICTRL1;
572 sc_access[5].reg_addr = MICLICTRL2;
573 sc_access[0].mask = sc_access[1].mask =
574 sc_access[2].mask = MASK7;
575 sc_access[3].mask = MASK5;
576 sc_access[4].mask = sc_access[5].mask = MASK6;
580 sc_access[1].value = sc_access[2].value = 0x80;
581 sc_access[3].value = 0x20;
582 sc_access[4].value = sc_access[5].value = 0x40;
585 sc_access[0].value = sc_access[1].value =
586 sc_access[2].value = sc_access[3].value =
587 sc_access[4].value = sc_access[5].value = 0x0;
589 if (snd_pmic_ops_fs.num_channel == 1)
590 sc_access[1].value = sc_access[2].value = 0x80;
592 snd_pmic_ops_fs.mute_status = value;
593 snd_pmic_ops_fs.master_mute = value;
597 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, reg_num);
600 static int fs_set_vol(int dev_id, int value)
602 struct sc_reg_access sc_acces, sc_access[4] = {{0},};
606 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
607 retval = fs_init_card();
612 case PMIC_SND_LEFT_PB_VOL:
613 pr_debug("PMIC_SND_LEFT_PB_VOL:%d\n", value);
614 sc_access[0].value = sc_access[1].value = value;
615 sc_access[0].reg_addr = AUD16;
616 sc_access[1].reg_addr = AUD15;
617 sc_access[0].mask = sc_access[1].mask =
618 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
622 case PMIC_SND_RIGHT_PB_VOL:
623 pr_debug("PMIC_SND_RIGHT_PB_VOL:%d\n", value);
624 sc_access[0].value = sc_access[1].value = value;
625 sc_access[0].reg_addr = AUD17;
626 sc_access[1].reg_addr = AUD15;
627 sc_access[0].mask = sc_access[1].mask =
628 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
629 if (snd_pmic_ops_fs.num_channel == 1) {
630 sc_access[0].value = sc_access[1].value = 0x80;
631 sc_access[0].mask = sc_access[1].mask = MASK7;
635 case PMIC_SND_CAPTURE_VOL:
636 pr_debug("PMIC_SND_CAPTURE_VOL:%d\n", value);
637 sc_access[0].reg_addr = MICLICTRL1;
638 sc_access[1].reg_addr = MICLICTRL2;
639 sc_access[2].reg_addr = DMICCTRL1;
640 sc_access[2].value = value;
641 sc_access[0].value = sc_access[1].value = value;
642 sc_acces.reg_addr = MICLICTRL3;
643 sc_acces.value = value;
644 sc_acces.mask = (MASK0|MASK1|MASK2|MASK3|MASK5|MASK6|MASK7);
645 retval = sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
646 sc_access[0].mask = sc_access[1].mask =
647 sc_access[2].mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
655 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, reg_num);
658 static int fs_get_mute(int dev_id, u8 *value)
660 struct sc_reg_access sc_access[6] = {{0,},};
662 int retval = 0, temp_value = 0, mask = 0;
664 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
665 retval = fs_init_card();
671 case PMIC_SND_AMIC_MUTE:
672 case PMIC_SND_HP_MIC_MUTE:
673 sc_access[0].reg_addr = MICLICTRL1;
675 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
676 if (sc_access[0].value & mask)
681 case PMIC_SND_DMIC_MUTE:
682 sc_access[0].reg_addr = MICCTRL;
684 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
685 temp_value = (sc_access[0].value & mask);
692 case PMIC_SND_LEFT_HP_MUTE:
693 case PMIC_SND_LEFT_SPEAKER_MUTE:
694 sc_access[0].reg_addr = AUD16;
696 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
697 temp_value = sc_access[0].value & mask;
703 case PMIC_SND_RIGHT_HP_MUTE:
704 case PMIC_SND_RIGHT_SPEAKER_MUTE:
705 sc_access[0].reg_addr = AUD17;
707 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
708 temp_value = sc_access[0].value & mask;
721 static int fs_get_vol(int dev_id, int *value)
723 struct sc_reg_access sc_access = {0,};
724 int retval = 0, mask = 0;
726 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
727 retval = fs_init_card();
732 case PMIC_SND_CAPTURE_VOL:
733 pr_debug("PMIC_SND_CAPTURE_VOL\n");
734 sc_access.reg_addr = MICLICTRL1;
735 mask = (MASK5|MASK4|MASK3|MASK2|MASK1|MASK0);
737 case PMIC_SND_LEFT_PB_VOL:
738 pr_debug("PMIC_SND_LEFT_PB_VOL\n");
739 sc_access.reg_addr = AUD16;
740 mask = (MASK5|MASK4|MASK3|MASK2|MASK1|MASK0);
742 case PMIC_SND_RIGHT_PB_VOL:
743 pr_debug("PMIC_SND_RT_PB_VOL\n");
744 sc_access.reg_addr = AUD17;
745 mask = (MASK5|MASK4|MASK3|MASK2|MASK1|MASK0);
751 retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
752 pr_debug("value read = 0x%x\n", sc_access.value);
753 *value = (int) (sc_access.value & mask);
754 pr_debug("value returned = 0x%x\n", *value);
758 static void fs_pmic_irq_enable(void *data)
760 struct snd_intelmad *intelmaddata = data;
761 struct sc_reg_access sc_access[] = {
762 {0x187, 0x00, MASK7},
763 {0x188, 0x10, MASK4},
764 {0x18b, 0x10, MASK4},
767 struct sc_reg_access sc_access_write[] = {
770 pr_debug("Audio interrupt enable\n");
771 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
772 sst_sc_reg_access(sc_access_write, PMIC_WRITE, 1);
774 intelmaddata->jack[0].jack_status = 0;
775 /*intelmaddata->jack[1].jack_status = 0;*/
777 jack_det_enabled = true;
781 static void fs_pmic_irq_cb(void *cb_data, u8 value)
783 struct mad_jack *mjack = NULL;
784 struct snd_intelmad *intelmaddata = cb_data;
785 unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
787 mjack = &intelmaddata->jack[0];
790 if (!jack_det_enabled)
791 fs_pmic_irq_enable(intelmaddata);
793 /* send headphone detect */
794 pr_debug(":MAD headphone %d\n", value & 0x4);
795 present = !(mjack->jack_status);
796 mjack->jack_status = present;
798 mjack->jack.type = SND_JACK_HEADPHONE;
802 /* send short push */
803 pr_debug(":MAD short push %d\n", value & 0x2);
807 mjack->jack.type = MID_JACK_HS_SHORT_PRESS;
812 pr_debug(":MAD long push %d\n", value & 0x1);
816 mjack->jack.type = MID_JACK_HS_LONG_PRESS;
820 if (!jack_det_enabled)
821 fs_pmic_irq_enable(intelmaddata);
822 /* send headset detect */
823 pr_debug(":MAD headset = %d\n", value & 0x8);
824 present = !(mjack->jack_status);
825 mjack->jack_status = present;
827 mjack->jack.type = SND_JACK_HEADSET;
832 sst_mad_send_jack_report(&mjack->jack,
833 buttonpressflag, present);
837 static int fs_jack_enable(void)
842 struct snd_pmic_ops snd_pmic_ops_fs = {
843 .set_input_dev = fs_set_selected_input_dev,
844 .set_output_dev = fs_set_selected_output_dev,
845 .set_mute = fs_set_mute,
846 .get_mute = fs_get_mute,
847 .set_vol = fs_set_vol,
848 .get_vol = fs_get_vol,
849 .init_card = fs_init_card,
850 .set_pcm_audio_params = fs_set_pcm_audio_params,
851 .set_pcm_voice_params = fs_set_pcm_voice_params,
852 .set_voice_port = fs_set_voice_port,
853 .set_audio_port = fs_set_audio_port,
854 .power_up_pmic_pb = fs_power_up_pb,
855 .power_up_pmic_cp = fs_power_up_cp,
856 .power_down_pmic_pb = fs_power_down_pb,
857 .power_down_pmic_cp = fs_power_down_cp,
858 .power_down_pmic = fs_power_down,
859 .pmic_irq_cb = fs_pmic_irq_cb,
861 * Jack detection enabling
862 * need be delayed till first IRQ happen.
864 .pmic_irq_enable = NULL,
865 .pmic_jack_enable = fs_jack_enable,