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 "intel_sst.h"
34 #include "intelmid_snd_control.h"
42 MISCVOICECTRL = 0x184,
50 VOICEDACCTRL1 = 0x18C,
51 STEREOADCCTRL = 0x18D,
61 HEADSETDETECTINT = 0x197,
62 HEADSETDETECTINTMASK = 0x198,
69 * fs_init_card - initialize the sound card
71 * This initilizes the audio paths to know values in case of this sound card
73 static int fs_init_card(void)
75 struct sc_reg_access sc_access[] = {
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);
112 static int fs_enable_audiodac(int value)
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;
120 if (snd_pmic_ops_fs.mute_status == MUTE)
123 sc_access[0].value = sc_access[1].value =
124 sc_access[2].value = 0x80;
127 sc_access[0].value = sc_access[1].value =
128 sc_access[2].value = 0x0;
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);
136 static int fs_power_up_pb(unsigned int port)
138 struct sc_reg_access sc_access[] = {
139 {AUDIOBIAS, 0x00, MASK7},
140 {POWERCTRL1, 0xC6, 0xC6},
141 {POWERCTRL2, 0x30, 0x30},
146 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
147 retval = fs_init_card();
150 retval = fs_enable_audiodac(MUTE);
151 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
156 pr_debug("in fs power up pb\n");
157 return fs_enable_audiodac(UNMUTE);
160 static int fs_power_down_pb(void)
162 struct sc_reg_access sc_access[] = {
163 {POWERCTRL1, 0x00, 0xC6},
164 {POWERCTRL2, 0x00, 0x30},
168 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
169 retval = fs_init_card();
172 retval = fs_enable_audiodac(MUTE);
173 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
178 pr_debug("in fsl power down pb\n");
179 return fs_enable_audiodac(UNMUTE);
182 static int fs_power_up_cp(unsigned int port)
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*/
191 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
192 retval = fs_init_card();
195 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
198 static int fs_power_down_cp(void)
200 struct sc_reg_access sc_access[] = {
201 {POWERCTRL2, 0x00, 0x03},
205 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
206 retval = fs_init_card();
209 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
212 static int fs_power_down(void)
215 struct sc_reg_access sc_access[] = {
216 {AUDIOBIAS, MASK7, MASK7},
219 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
220 retval = fs_init_card();
223 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
226 static int fs_set_pcm_voice_params(void)
228 struct sc_reg_access sc_access[] = {
258 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
259 retval = fs_init_card();
262 return sst_sc_reg_access(sc_access, PMIC_WRITE, 26);
265 static int fs_set_audio_port(int status)
267 struct sc_reg_access sc_access[2];
270 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
271 retval = fs_init_card();
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);
296 static int fs_set_voice_port(int status)
298 struct sc_reg_access sc_access[2];
301 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
302 retval = fs_init_card();
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);
327 static int fs_set_pcm_audio_params(int sfreq, int word_size, int num_channel)
330 struct sc_reg_access sc_access[4];
331 int retval = 0, num_value = 0;
333 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
334 retval = fs_init_card();
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);
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);
385 pr_debug("sfreq:%d,Register value = %x\n", sfreq, config1);
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;
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;
398 sc_access[2].reg_addr = MISCAUDCTRL;
399 sc_access[2].value = 0x02;
400 sc_access[2].mask = 0x02;
406 sc_access[0].reg_addr = AUDIOPORT2;
407 sc_access[0].value = config1;
408 sc_access[0].mask = MASK0|MASK1|MASK2|MASK3;
410 sc_access[1].reg_addr = MISCAUDCTRL;
411 sc_access[1].value = 0x00;
412 sc_access[1].mask = 0x02;
415 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, num_value);
419 static int fs_set_selected_input_dev(u8 value)
421 struct sc_reg_access sc_access_dmic[] = {
422 {MICCTRL, 0x81, 0xf7},
423 {MICLICTRL3, 0x00, 0xE0},
425 struct sc_reg_access sc_access_mic[] = {
426 {MICCTRL, 0x40, MASK2|MASK4|MASK5|MASK6|MASK7},
427 {MICLICTRL3, 0x00, 0xE0},
429 struct sc_reg_access sc_access_hsmic[] = {
430 {MICCTRL, 0x10, MASK2|MASK4|MASK5|MASK6|MASK7},
431 {MICLICTRL3, 0x00, 0xE0},
436 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
437 retval = fs_init_card();
443 pr_debug("Selecting amic not supported in mono cfg\n");
444 return sst_sc_reg_access(sc_access_mic, PMIC_READ_MODIFY, 2);
448 pr_debug("Selecting hsmic\n");
449 return sst_sc_reg_access(sc_access_hsmic,
450 PMIC_READ_MODIFY, 2);
454 pr_debug("Selecting dmic\n");
455 return sst_sc_reg_access(sc_access_dmic, PMIC_READ_MODIFY, 2);
464 static int fs_set_selected_output_dev(u8 value)
466 struct sc_reg_access sc_access_hp[] = {
470 struct sc_reg_access sc_access_is[] = {
476 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
477 retval = fs_init_card();
482 case STEREO_HEADPHONE:
483 pr_debug("SST DBG:Selecting headphone\n");
484 return sst_sc_reg_access(sc_access_hp, PMIC_WRITE, 2);
488 pr_debug("SST DBG:Selecting internal spkr\n");
489 return sst_sc_reg_access(sc_access_is, PMIC_READ_MODIFY, 2);
498 static int fs_set_mute(int dev_id, u8 value)
500 struct sc_reg_access sc_access[6] = {{0,},};
504 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
505 retval = fs_init_card();
510 pr_debug("dev_id:0x%x value:0x%x\n", dev_id, value);
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;
519 sc_access[0].value = 0x20;
520 sc_access[2].value = sc_access[1].value = 0x40;
522 sc_access[0].value = sc_access[1].value
523 = sc_access[2].value = 0x0;
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;
532 sc_access[0].value = sc_access[1].value = 0x40;
534 sc_access[0].value = sc_access[1].value = 0x0;
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;
542 sc_access[0].mask = sc_access[1].mask = MASK7;
544 sc_access[0].value = sc_access[1].value = 0x80;
546 sc_access[0].value = sc_access[1].value = 0x0;
548 snd_pmic_ops_fs.mute_status = value;
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;
556 sc_access[0].value = sc_access[1].value = 0x80;
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;
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;
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;
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;
587 if (snd_pmic_ops_fs.num_channel == 1)
588 sc_access[1].value = sc_access[2].value = 0x80;
590 snd_pmic_ops_fs.mute_status = value;
591 snd_pmic_ops_fs.master_mute = value;
595 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, reg_num);
598 static int fs_set_vol(int dev_id, int value)
600 struct sc_reg_access sc_acces, sc_access[4] = {{0},};
604 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
605 retval = fs_init_card();
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);
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;
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);
653 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, reg_num);
656 static int fs_get_mute(int dev_id, u8 *value)
658 struct sc_reg_access sc_access[6] = {{0,},};
660 int retval = 0, temp_value = 0, mask = 0;
662 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
663 retval = fs_init_card();
669 case PMIC_SND_AMIC_MUTE:
670 case PMIC_SND_HP_MIC_MUTE:
671 sc_access[0].reg_addr = MICLICTRL1;
673 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
674 if (sc_access[0].value & mask)
679 case PMIC_SND_DMIC_MUTE:
680 sc_access[0].reg_addr = MICCTRL;
682 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
683 temp_value = (sc_access[0].value & mask);
690 case PMIC_SND_LEFT_HP_MUTE:
691 case PMIC_SND_LEFT_SPEAKER_MUTE:
692 sc_access[0].reg_addr = AUD16;
694 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
695 temp_value = sc_access[0].value & mask;
701 case PMIC_SND_RIGHT_HP_MUTE:
702 case PMIC_SND_RIGHT_SPEAKER_MUTE:
703 sc_access[0].reg_addr = AUD17;
705 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
706 temp_value = sc_access[0].value & mask;
719 static int fs_get_vol(int dev_id, int *value)
721 struct sc_reg_access sc_access = {0,};
722 int retval = 0, mask = 0;
724 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
725 retval = fs_init_card();
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);
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);
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);
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);
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,