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,