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 #include <linux/pci.h>
30 #include <linux/file.h>
31 #include "intel_sst.h"
32 #include "intelmid_snd_control.h"
40 MISCVOICECTRL = 0x184,
48 VOICEDACCTRL1 = 0x18C,
49 STEREOADCCTRL = 0x18D,
59 HEADSETDETECTINT = 0x197,
60 HEADSETDETECTINTMASK = 0x198,
67 * fs_init_card - initialize the sound card
69 * This initilizes the audio paths to know values in case of this sound card
71 static int fs_init_card(void)
73 struct sc_reg_access sc_access[] = {
103 snd_pmic_ops_fs.card_status = SND_CARD_INIT_DONE;
104 snd_pmic_ops_fs.master_mute = UNMUTE;
105 snd_pmic_ops_fs.mute_status = UNMUTE;
106 snd_pmic_ops_fs.num_channel = 2;
107 return sst_sc_reg_access(sc_access, PMIC_WRITE, 27);
110 static int fs_enable_audiodac(int value)
112 struct sc_reg_access sc_access[3];
113 sc_access[0].reg_addr = AUD16;
114 sc_access[1].reg_addr = AUD17;
115 sc_access[2].reg_addr = AUD15;
116 sc_access[0].mask = sc_access[1].mask = sc_access[2].mask = MASK7;
118 if (snd_pmic_ops_fs.mute_status == MUTE)
121 sc_access[0].value = sc_access[1].value =
122 sc_access[2].value = 0x80;
125 sc_access[0].value = sc_access[1].value =
126 sc_access[2].value = 0x0;
128 if (snd_pmic_ops_fs.num_channel == 1)
129 sc_access[1].value = sc_access[2].value = 0x80;
130 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
134 static int fs_power_up_pb(unsigned int port)
136 struct sc_reg_access sc_access[] = {
137 {AUDIOBIAS, 0x00, MASK7},
138 {POWERCTRL1, 0xC6, 0xC6},
139 {POWERCTRL2, 0x30, 0x30},
144 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
145 retval = fs_init_card();
148 retval = fs_enable_audiodac(MUTE);
149 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
154 pr_debug("sst: in fs power up pb\n");
155 return fs_enable_audiodac(UNMUTE);
158 static int fs_power_down_pb(void)
160 struct sc_reg_access sc_access[] = {
161 {POWERCTRL1, 0x00, 0xC6},
162 {POWERCTRL2, 0x00, 0x30},
166 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
167 retval = fs_init_card();
170 retval = fs_enable_audiodac(MUTE);
171 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
176 pr_debug("sst: in fsl power down pb\n");
177 return fs_enable_audiodac(UNMUTE);
180 static int fs_power_up_cp(unsigned int port)
182 struct sc_reg_access sc_access[] = {
183 {POWERCTRL2, 0x32, 0x32}, /*NOTE power up A ADC only as*/
184 {AUDIOBIAS, 0x00, MASK7},
185 /*as turning on V ADC causes noise*/
189 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
190 retval = fs_init_card();
193 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
196 static int fs_power_down_cp(void)
198 struct sc_reg_access sc_access[] = {
199 {POWERCTRL2, 0x00, 0x03},
203 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
204 retval = fs_init_card();
207 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
210 static int fs_power_down(void)
213 struct sc_reg_access sc_access[] = {
214 {AUDIOBIAS, MASK7, MASK7},
217 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
218 retval = fs_init_card();
221 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
224 static int fs_set_pcm_voice_params(void)
226 struct sc_reg_access sc_access[] = {
256 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
257 retval = fs_init_card();
260 return sst_sc_reg_access(sc_access, PMIC_WRITE, 26);
263 static int fs_set_audio_port(int status)
265 struct sc_reg_access sc_access[2];
268 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
269 retval = fs_init_card();
272 if (status == DEACTIVATE) {
273 /* Deactivate audio port-tristate and power */
274 sc_access[0].value = 0x00;
275 sc_access[0].mask = MASK6|MASK7;
276 sc_access[0].reg_addr = AUDIOPORT1;
277 sc_access[1].value = 0x00;
278 sc_access[1].mask = MASK4|MASK5;
279 sc_access[1].reg_addr = POWERCTRL2;
280 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
281 } else if (status == ACTIVATE) {
282 /* activate audio port */
283 sc_access[0].value = 0xC0;
284 sc_access[0].mask = MASK6|MASK7;
285 sc_access[0].reg_addr = AUDIOPORT1;
286 sc_access[1].value = 0x30;
287 sc_access[1].mask = MASK4|MASK5;
288 sc_access[1].reg_addr = POWERCTRL2;
289 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
294 static int fs_set_voice_port(int status)
296 struct sc_reg_access sc_access[2];
299 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
300 retval = fs_init_card();
303 if (status == DEACTIVATE) {
304 /* Deactivate audio port-tristate and power */
305 sc_access[0].value = 0x00;
306 sc_access[0].mask = MASK6|MASK7;
307 sc_access[0].reg_addr = VOICEPORT1;
308 sc_access[1].value = 0x00;
309 sc_access[1].mask = MASK0|MASK1;
310 sc_access[1].reg_addr = POWERCTRL2;
311 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
312 } else if (status == ACTIVATE) {
313 /* activate audio port */
314 sc_access[0].value = 0xC0;
315 sc_access[0].mask = MASK6|MASK7;
316 sc_access[0].reg_addr = VOICEPORT1;
317 sc_access[1].value = 0x03;
318 sc_access[1].mask = MASK0|MASK1;
319 sc_access[1].reg_addr = POWERCTRL2;
320 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
325 static int fs_set_pcm_audio_params(int sfreq, int word_size, int num_channel)
328 struct sc_reg_access sc_access[4];
329 int retval = 0, num_value = 0;
331 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
332 retval = fs_init_card();
367 snd_pmic_ops_fs.num_channel = num_channel;
368 if (snd_pmic_ops_fs.num_channel == 1) {
369 sc_access[0].reg_addr = AUD17;
370 sc_access[1].reg_addr = AUD15;
371 sc_access[0].mask = sc_access[1].mask = MASK7;
372 sc_access[0].value = sc_access[1].value = 0x80;
373 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
376 sc_access[0].reg_addr = AUD17;
377 sc_access[1].reg_addr = AUD15;
378 sc_access[0].mask = sc_access[1].mask = MASK7;
379 sc_access[0].value = sc_access[1].value = 0x00;
380 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
383 pr_debug("sst: sfreq:%d,Register value = %x\n", sfreq, config1);
385 if (word_size == 24) {
386 sc_access[0].reg_addr = AUDIOPORT1;
387 sc_access[0].mask = MASK0|MASK1|MASK2|MASK3;
388 sc_access[0].value = 0xFB;
391 sc_access[1].reg_addr = AUDIOPORT2;
392 sc_access[1].value = config1 | 0x10;
393 sc_access[1].mask = MASK0 | MASK1 | MASK2 | MASK3
394 | MASK4 | MASK5 | MASK6;
396 sc_access[2].reg_addr = MISCAUDCTRL;
397 sc_access[2].value = 0x02;
398 sc_access[2].mask = 0x02;
404 sc_access[0].reg_addr = AUDIOPORT2;
405 sc_access[0].value = config1;
406 sc_access[0].mask = MASK0|MASK1|MASK2|MASK3;
408 sc_access[1].reg_addr = MISCAUDCTRL;
409 sc_access[1].value = 0x00;
410 sc_access[1].mask = 0x02;
413 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, num_value);
417 static int fs_set_selected_input_dev(u8 value)
419 struct sc_reg_access sc_access_dmic[] = {
420 {MICCTRL, 0x81, 0xf7},
421 {MICLICTRL3, 0x00, 0xE0},
423 struct sc_reg_access sc_access_mic[] = {
424 {MICCTRL, 0x40, MASK2|MASK4|MASK5|MASK6|MASK7},
425 {MICLICTRL3, 0x00, 0xE0},
427 struct sc_reg_access sc_access_hsmic[] = {
428 {MICCTRL, 0x10, MASK2|MASK4|MASK5|MASK6|MASK7},
429 {MICLICTRL3, 0x00, 0xE0},
434 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
435 retval = fs_init_card();
441 pr_debug("sst: Selecting amic not supported in mono cfg\n");
442 return sst_sc_reg_access(sc_access_mic, PMIC_READ_MODIFY, 2);
446 pr_debug("sst: Selecting hsmic\n");
447 return sst_sc_reg_access(sc_access_hsmic,
448 PMIC_READ_MODIFY, 2);
452 pr_debug("sst: Selecting dmic\n");
453 return sst_sc_reg_access(sc_access_dmic, PMIC_READ_MODIFY, 2);
462 static int fs_set_selected_output_dev(u8 value)
464 struct sc_reg_access sc_access_hp[] = {
468 struct sc_reg_access sc_access_is[] = {
474 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
475 retval = fs_init_card();
480 case STEREO_HEADPHONE:
481 pr_debug("SST DBG:Selecting headphone\n");
482 return sst_sc_reg_access(sc_access_hp, PMIC_WRITE, 2);
486 pr_debug("SST DBG:Selecting internal spkr\n");
487 return sst_sc_reg_access(sc_access_is, PMIC_READ_MODIFY, 2);
496 static int fs_set_mute(int dev_id, u8 value)
498 struct sc_reg_access sc_access[6] = {{0,},};
502 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
503 retval = fs_init_card();
508 pr_debug("sst: dev_id:0x%x value:0x%x\n", dev_id, value);
510 case PMIC_SND_DMIC_MUTE:
511 sc_access[0].reg_addr = MICCTRL;
512 sc_access[1].reg_addr = MICLICTRL1;
513 sc_access[2].reg_addr = MICLICTRL2;
514 sc_access[0].mask = MASK5;
515 sc_access[1].mask = sc_access[2].mask = MASK6;
517 sc_access[0].value = 0x20;
518 sc_access[2].value = sc_access[1].value = 0x40;
520 sc_access[0].value = sc_access[1].value
521 = sc_access[2].value = 0x0;
524 case PMIC_SND_HP_MIC_MUTE:
525 case PMIC_SND_AMIC_MUTE:
526 sc_access[0].reg_addr = MICLICTRL1;
527 sc_access[1].reg_addr = MICLICTRL2;
528 sc_access[0].mask = sc_access[1].mask = MASK6;
530 sc_access[0].value = sc_access[1].value = 0x40;
532 sc_access[0].value = sc_access[1].value = 0x0;
535 case PMIC_SND_LEFT_SPEAKER_MUTE:
536 case PMIC_SND_LEFT_HP_MUTE:
537 sc_access[0].reg_addr = AUD16;
538 sc_access[1].reg_addr = AUD15;
540 sc_access[0].mask = sc_access[1].mask = MASK7;
542 sc_access[0].value = sc_access[1].value = 0x80;
544 sc_access[0].value = sc_access[1].value = 0x0;
546 snd_pmic_ops_fs.mute_status = value;
548 case PMIC_SND_RIGHT_HP_MUTE:
549 case PMIC_SND_RIGHT_SPEAKER_MUTE:
550 sc_access[0].reg_addr = AUD17;
551 sc_access[1].reg_addr = AUD15;
552 sc_access[0].mask = sc_access[1].mask = MASK7;
554 sc_access[0].value = sc_access[1].value = 0x80;
556 sc_access[0].value = sc_access[1].value = 0x0;
557 snd_pmic_ops_fs.mute_status = value;
558 if (snd_pmic_ops_fs.num_channel == 1)
559 sc_access[0].value = sc_access[1].value = 0x80;
562 case PMIC_SND_MUTE_ALL:
563 sc_access[0].reg_addr = AUD16;
564 sc_access[1].reg_addr = AUD17;
565 sc_access[2].reg_addr = AUD15;
566 sc_access[3].reg_addr = MICCTRL;
567 sc_access[4].reg_addr = MICLICTRL1;
568 sc_access[5].reg_addr = MICLICTRL2;
569 sc_access[0].mask = sc_access[1].mask =
570 sc_access[2].mask = MASK7;
571 sc_access[3].mask = MASK5;
572 sc_access[4].mask = sc_access[5].mask = MASK6;
576 sc_access[1].value = sc_access[2].value = 0x80;
577 sc_access[3].value = 0x20;
578 sc_access[4].value = sc_access[5].value = 0x40;
581 sc_access[0].value = sc_access[1].value =
582 sc_access[2].value = sc_access[3].value =
583 sc_access[4].value = sc_access[5].value = 0x0;
585 if (snd_pmic_ops_fs.num_channel == 1)
586 sc_access[1].value = sc_access[2].value = 0x80;
588 snd_pmic_ops_fs.mute_status = value;
589 snd_pmic_ops_fs.master_mute = value;
593 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, reg_num);
596 static int fs_set_vol(int dev_id, int value)
598 struct sc_reg_access sc_acces, sc_access[4] = {{0},};
602 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
603 retval = fs_init_card();
608 case PMIC_SND_LEFT_PB_VOL:
609 pr_debug("sst: PMIC_SND_LEFT_PB_VOL:%d\n", value);
610 sc_access[0].value = sc_access[1].value = value;
611 sc_access[0].reg_addr = AUD16;
612 sc_access[1].reg_addr = AUD15;
613 sc_access[0].mask = sc_access[1].mask =
614 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
618 case PMIC_SND_RIGHT_PB_VOL:
619 pr_debug("sst: PMIC_SND_RIGHT_PB_VOL:%d\n", value);
620 sc_access[0].value = sc_access[1].value = value;
621 sc_access[0].reg_addr = AUD17;
622 sc_access[1].reg_addr = AUD15;
623 sc_access[0].mask = sc_access[1].mask =
624 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
625 if (snd_pmic_ops_fs.num_channel == 1) {
626 sc_access[0].value = sc_access[1].value = 0x80;
627 sc_access[0].mask = sc_access[1].mask = MASK7;
631 case PMIC_SND_CAPTURE_VOL:
632 pr_debug("sst: PMIC_SND_CAPTURE_VOL:%d\n", value);
633 sc_access[0].reg_addr = MICLICTRL1;
634 sc_access[1].reg_addr = MICLICTRL2;
635 sc_access[2].reg_addr = DMICCTRL1;
636 sc_access[2].value = value;
637 sc_access[0].value = sc_access[1].value = value;
638 sc_acces.reg_addr = MICLICTRL3;
639 sc_acces.value = value;
640 sc_acces.mask = (MASK0|MASK1|MASK2|MASK3|MASK5|MASK6|MASK7);
641 retval = sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
642 sc_access[0].mask = sc_access[1].mask =
643 sc_access[2].mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
651 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, reg_num);
654 static int fs_get_mute(int dev_id, u8 *value)
656 struct sc_reg_access sc_access[6] = {{0,},};
658 int retval = 0, temp_value = 0, mask = 0;
660 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
661 retval = fs_init_card();
667 case PMIC_SND_AMIC_MUTE:
668 case PMIC_SND_HP_MIC_MUTE:
669 sc_access[0].reg_addr = MICLICTRL1;
671 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
672 if (sc_access[0].value & mask)
677 case PMIC_SND_DMIC_MUTE:
678 sc_access[0].reg_addr = MICCTRL;
680 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
681 temp_value = (sc_access[0].value & mask);
688 case PMIC_SND_LEFT_HP_MUTE:
689 case PMIC_SND_LEFT_SPEAKER_MUTE:
690 sc_access[0].reg_addr = AUD16;
692 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
693 temp_value = sc_access[0].value & mask;
699 case PMIC_SND_RIGHT_HP_MUTE:
700 case PMIC_SND_RIGHT_SPEAKER_MUTE:
701 sc_access[0].reg_addr = AUD17;
703 retval = sst_sc_reg_access(sc_access, PMIC_READ, 1);
704 temp_value = sc_access[0].value & mask;
717 static int fs_get_vol(int dev_id, int *value)
719 struct sc_reg_access sc_access = {0,};
720 int retval = 0, mask = 0;
722 if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
723 retval = fs_init_card();
728 case PMIC_SND_CAPTURE_VOL:
729 pr_debug("sst: PMIC_SND_CAPTURE_VOL\n");
730 sc_access.reg_addr = MICLICTRL1;
731 mask = (MASK5|MASK4|MASK3|MASK2|MASK1|MASK0);
733 case PMIC_SND_LEFT_PB_VOL:
734 pr_debug("sst: PMIC_SND_LEFT_PB_VOL\n");
735 sc_access.reg_addr = AUD16;
736 mask = (MASK5|MASK4|MASK3|MASK2|MASK1|MASK0);
738 case PMIC_SND_RIGHT_PB_VOL:
739 pr_debug("sst: PMIC_SND_RT_PB_VOL\n");
740 sc_access.reg_addr = AUD17;
741 mask = (MASK5|MASK4|MASK3|MASK2|MASK1|MASK0);
747 retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
748 pr_debug("sst: value read = 0x%x\n", sc_access.value);
749 *value = (int) (sc_access.value & mask);
750 pr_debug("sst: value returned = 0x%x\n", *value);
754 struct snd_pmic_ops snd_pmic_ops_fs = {
755 .set_input_dev = fs_set_selected_input_dev,
756 .set_output_dev = fs_set_selected_output_dev,
757 .set_mute = fs_set_mute,
758 .get_mute = fs_get_mute,
759 .set_vol = fs_set_vol,
760 .get_vol = fs_get_vol,
761 .init_card = fs_init_card,
762 .set_pcm_audio_params = fs_set_pcm_audio_params,
763 .set_pcm_voice_params = fs_set_pcm_voice_params,
764 .set_voice_port = fs_set_voice_port,
765 .set_audio_port = fs_set_audio_port,
766 .power_up_pmic_pb = fs_power_up_pb,
767 .power_up_pmic_cp = fs_power_up_cp,
768 .power_down_pmic_pb = fs_power_down_pb,
769 .power_down_pmic_cp = fs_power_down_cp,
770 .power_down_pmic = fs_power_down,