← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/staging/intel_sst/intelmid_v2_control.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/intel_sst/intelmid_v2_control.c
28
28
 
29
29
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30
30
 
 
31
#include <linux/gpio.h>
31
32
#include <linux/pci.h>
 
33
#include <linux/delay.h>
32
34
#include <linux/file.h>
 
35
#include <sound/control.h>
33
36
#include "intel_sst.h"
34
37
#include "intelmid_snd_control.h"
 
38
#include "intelmid.h"
35
39
 
36
40
enum reg_v3 {
37
41
        VAUDIOCNT = 0x51,
81
85
        HPLMIXSEL = 0x12b,
82
86
        HPRMIXSEL = 0x12c,
83
87
        LOANTIPOP = 0x12d,
 
88
        AUXDBNC = 0x12f,
84
89
};
85
90
 
 
91
static void nc_set_amp_power(int power)
 
92
{
 
93
        if (snd_pmic_ops_nc.gpio_amp)
 
94
                gpio_set_value(snd_pmic_ops_nc.gpio_amp, power);
 
95
}
 
96
 
86
97
/****
87
 
 * nc_init_card - initilize the sound card
 
98
 * nc_init_card - initialize the sound card
88
99
 *
89
 
 * This initilizes the audio paths to know values in case of this sound card
 
100
 * This initializes the audio paths to know values in case of this sound card
90
101
 */
91
102
static int nc_init_card(void)
92
103
{
110
121
                {VOICEVOL, 0x0e, 0},
111
122
                {HPLVOL, 0x06, 0},
112
123
                {HPRVOL, 0x06, 0},
113
 
                {MICCTRL, 0x41, 0x00},
 
124
                {MICCTRL, 0x51, 0x00},
114
125
                {ADCSAMPLERATE, 0x8B, 0x00},
115
126
                {MICSELVOL, 0x5B, 0x00},
116
127
                {LILSEL, 0x06, 0},
117
128
                {LIRSEL, 0x46, 0},
118
129
                {LOANTIPOP, 0x00, 0},
119
130
                {DMICCTRL1, 0x40, 0},
 
131
                {AUXDBNC, 0xff, 0},
120
132
        };
121
133
        snd_pmic_ops_nc.card_status = SND_CARD_INIT_DONE;
122
134
        snd_pmic_ops_nc.master_mute = UNMUTE;
123
135
        snd_pmic_ops_nc.mute_status = UNMUTE;
124
 
        sst_sc_reg_access(sc_access, PMIC_WRITE, 26);
 
136
        sst_sc_reg_access(sc_access, PMIC_WRITE, 27);
 
137
        mutex_init(&snd_pmic_ops_nc.lock);
125
138
        pr_debug("init complete!!\n");
126
139
        return 0;
127
140
}
168
181
                return retval;
169
182
        if (port == 0xFF)
170
183
                return 0;
 
184
        mutex_lock(&snd_pmic_ops_nc.lock);
171
185
        nc_enable_audiodac(MUTE);
172
186
        msleep(30);
173
187
 
208
222
 
209
223
        msleep(30);
210
224
 
211
 
        return nc_enable_audiodac(UNMUTE);
 
225
        snd_pmic_ops_nc.pb_on = 1;
212
226
 
 
227
        /*
 
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
 
233
         */
 
234
        if (snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE ||
 
235
            snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)
 
236
                nc_set_amp_power(1);
 
237
        nc_enable_audiodac(UNMUTE);
 
238
        mutex_unlock(&snd_pmic_ops_nc.lock);
 
239
        return 0;
213
240
}
214
241
 
215
242
static int nc_power_up_cp(unsigned int port)
269
296
        int retval = 0;
270
297
        struct sc_reg_access sc_access[5];
271
298
 
272
 
 
273
299
        if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
274
300
                retval = nc_init_card();
275
301
        if (retval)
279
305
 
280
306
        pr_debug("powering dn nc_power_down ....\n");
281
307
 
 
308
        if (snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE ||
 
309
            snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)
 
310
                nc_set_amp_power(0);
 
311
 
282
312
        msleep(30);
283
313
 
284
314
        sc_access[0].reg_addr = DRVPOWERCTRL;
315
345
        return nc_enable_audiodac(UNMUTE);
316
346
}
317
347
 
318
 
static int nc_power_down_pb(void)
 
348
static int nc_power_down_pb(unsigned int device)
319
349
{
320
350
 
321
351
        int retval = 0;
327
357
                return retval;
328
358
 
329
359
        pr_debug("powering dn pb....\n");
330
 
 
 
360
        mutex_lock(&snd_pmic_ops_nc.lock);
331
361
        nc_enable_audiodac(MUTE);
332
362
 
333
363
 
354
384
 
355
385
        msleep(30);
356
386
 
357
 
        return nc_enable_audiodac(UNMUTE);
358
 
 
359
 
 
 
387
        snd_pmic_ops_nc.pb_on = 0;
 
388
 
 
389
        nc_enable_audiodac(UNMUTE);
 
390
        mutex_unlock(&snd_pmic_ops_nc.lock);
 
391
        return 0;
360
392
}
361
393
 
362
 
static int nc_power_down_cp(void)
 
394
static int nc_power_down_cp(unsigned int device)
363
395
{
364
396
        struct sc_reg_access sc_access[] = {
365
397
                {POWERCTRL1, 0x00, 0xBE},
497
529
{
498
530
        struct sc_reg_access sc_access_HP[] = {
499
531
                {LMUTE, 0x02, 0x06},
500
 
                {RMUTE, 0x02, 0x06}
 
532
                {RMUTE, 0x02, 0x06},
 
533
                {DRVPOWERCTRL, 0x06, 0x06},
501
534
        };
502
535
        struct sc_reg_access sc_access_IS[] = {
503
536
                {LMUTE, 0x04, 0x06},
504
 
                {RMUTE, 0x04, 0x06}
 
537
                {RMUTE, 0x04, 0x06},
 
538
                {DRVPOWERCTRL, 0x00, 0x06},
505
539
        };
506
540
        int retval = 0;
507
541
 
511
545
        if (retval)
512
546
                return retval;
513
547
        pr_debug("nc set selected output:%d\n", value);
 
548
        mutex_lock(&snd_pmic_ops_nc.lock);
514
549
        switch (value) {
515
550
        case STEREO_HEADPHONE:
 
551
                if (snd_pmic_ops_nc.pb_on)
 
552
                        sst_sc_reg_access(sc_access_HP+2, PMIC_WRITE, 1);
516
553
                retval = sst_sc_reg_access(sc_access_HP, PMIC_WRITE, 2);
 
554
                nc_set_amp_power(0);
517
555
                break;
 
556
        case MONO_EARPIECE:
518
557
        case INTERNAL_SPKR:
519
 
                retval = sst_sc_reg_access(sc_access_IS, PMIC_WRITE, 2);
 
558
                retval = sst_sc_reg_access(sc_access_IS, PMIC_WRITE, 3);
 
559
                if (snd_pmic_ops_nc.pb_on)
 
560
                        nc_set_amp_power(1);
520
561
                break;
521
562
        default:
522
563
                pr_err("rcvd illegal request: %d\n", value);
 
564
                mutex_unlock(&snd_pmic_ops_nc.lock);
523
565
                return -EINVAL;
524
566
        }
 
567
        mutex_unlock(&snd_pmic_ops_nc.lock);
525
568
        return retval;
526
569
}
527
570
 
783
826
        case PMIC_SND_LEFT_PB_VOL:
784
827
                pr_debug("PMIC_SND_LEFT_HP_VOL %d\n", value);
785
828
                sc_access[0].value = -value;
786
 
                sc_access[0].reg_addr  = AUDIOLVOL;
787
 
                sc_access[0].mask =
788
 
                        (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
 
829
                sc_access[0].reg_addr  = HPLVOL;
 
830
                sc_access[0].mask = (MASK0|MASK1|MASK2|MASK3|MASK4);
789
831
                entries = 1;
790
832
                break;
791
833
 
793
835
                pr_debug("PMIC_SND_RIGHT_HP_VOL value %d\n", value);
794
836
                if (snd_pmic_ops_nc.num_channel == 1) {
795
837
                        sc_access[0].value = 0x04;
796
 
                    sc_access[0].reg_addr = RMUTE;
 
838
                        sc_access[0].reg_addr = RMUTE;
797
839
                        sc_access[0].mask = MASK2;
798
840
                } else {
799
 
                sc_access[0].value = -value;
800
 
                sc_access[0].reg_addr  = AUDIORVOL;
 
841
                        sc_access[0].value = -value;
 
842
                        sc_access[0].reg_addr  = HPRVOL;
 
843
                        sc_access[0].mask = (MASK0|MASK1|MASK2|MASK3|MASK4);
 
844
                }
 
845
                entries = 1;
 
846
                break;
 
847
 
 
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;
 
852
                sc_access[0].mask =
 
853
                        (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
 
854
                entries = 1;
 
855
                break;
 
856
 
 
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;
801
861
                sc_access[0].mask =
802
862
                                (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
803
863
                entries = 1;
804
 
                }
805
864
                break;
806
865
 
807
866
        default:
830
889
                pr_debug("Selecting AMIC\n");
831
890
                sc_access[0].reg_addr = 0x107;
832
891
                sc_access[0].value = 0x40;
833
 
                sc_access[0].mask =  MASK6|MASK4|MASK3|MASK1|MASK0;
 
892
                sc_access[0].mask =  MASK6|MASK3|MASK1|MASK0;
834
893
                sc_access[1].reg_addr = 0x10a;
835
894
                sc_access[1].value = 0x40;
836
895
                sc_access[1].mask = MASK6;
845
904
 
846
905
        case HS_MIC:
847
906
                pr_debug("Selecting HS_MIC\n");
848
 
                sc_access[0].reg_addr = 0x107;
849
 
                sc_access[0].mask =  MASK6|MASK4|MASK3|MASK1|MASK0;
850
 
                sc_access[0].value = 0x10;
 
907
                sc_access[0].reg_addr = MICCTRL;
 
908
                sc_access[0].mask =  MASK6|MASK3|MASK1|MASK0;
 
909
                sc_access[0].value = 0x00;
851
910
                sc_access[1].reg_addr = 0x109;
852
911
                sc_access[1].mask = MASK6;
853
912
                sc_access[1].value = 0x40;
857
916
                sc_access[3].reg_addr = 0x105;
858
917
                sc_access[3].value = 0x40;
859
918
                sc_access[3].mask = MASK6;
860
 
                num_val = 4;
 
919
                sc_access[4].reg_addr = ADCSAMPLERATE;
 
920
                sc_access[4].mask = MASK7|MASK6|MASK5|MASK4|MASK3;
 
921
                sc_access[4].value = 0xc8;
 
922
                num_val = 5;
861
923
                break;
862
924
 
863
925
        case DMIC:
864
926
                pr_debug("DMIC\n");
865
 
                sc_access[0].reg_addr = 0x107;
866
 
                sc_access[0].mask = MASK6|MASK4|MASK3|MASK1|MASK0;
 
927
                sc_access[0].reg_addr = MICCTRL;
 
928
                sc_access[0].mask = MASK6|MASK3|MASK1|MASK0;
867
929
                sc_access[0].value = 0x0B;
868
930
                sc_access[1].reg_addr = 0x105;
869
931
                sc_access[1].value = 0x80;
871
933
                sc_access[2].reg_addr = 0x10a;
872
934
                sc_access[2].value = 0x40;
873
935
                sc_access[2].mask = MASK6;
874
 
                sc_access[3].reg_addr = 0x109;
 
936
                sc_access[3].reg_addr = LILSEL;
875
937
                sc_access[3].mask = MASK6;
876
938
                sc_access[3].value = 0x00;
877
 
                sc_access[4].reg_addr = 0x104;
878
 
                sc_access[4].value = 0x3C;
879
 
                sc_access[4].mask = 0xff;
 
939
                sc_access[4].reg_addr = ADCSAMPLERATE;
 
940
                sc_access[4].mask =  MASK7|MASK6|MASK5|MASK4|MASK3;
 
941
                sc_access[4].value = 0x33;
880
942
                num_val = 5;
881
943
                break;
882
944
        default:
963
1025
                mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
964
1026
                break;
965
1027
 
966
 
        case PMIC_SND_RIGHT_PB_VOL:
967
 
                pr_debug("GET_VOLUME_PMIC_LEFT_HP_VOL\n");
 
1028
        case PMIC_SND_LEFT_MASTER_VOL:
 
1029
                pr_debug("GET_VOLUME_PMIC_LEFT_MASTER_VOL\n");
968
1030
                sc_access.reg_addr = AUDIOLVOL;
969
1031
                mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
970
1032
                break;
971
1033
 
972
 
        case PMIC_SND_LEFT_PB_VOL:
 
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);
 
1038
                break;
 
1039
 
 
1040
        case PMIC_SND_RIGHT_PB_VOL:
973
1041
                pr_debug("GET_VOLUME_PMIC_RIGHT_HP_VOL\n");
974
 
                sc_access.reg_addr = AUDIORVOL;
975
 
                mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
 
1042
                sc_access.reg_addr = HPRVOL;
 
1043
                mask = (MASK0|MASK1|MASK2|MASK3|MASK4);
 
1044
                break;
 
1045
 
 
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);
976
1050
                break;
977
1051
 
978
1052
        default:
986
1060
        return retval;
987
1061
}
988
1062
 
 
1063
static void hp_automute(enum snd_jack_types type, int present)
 
1064
{
 
1065
        u8 in = DMIC;
 
1066
        u8 out = INTERNAL_SPKR;
 
1067
        if (present) {
 
1068
                if (type == SND_JACK_HEADSET)
 
1069
                        in = HS_MIC;
 
1070
                out = STEREO_HEADPHONE;
 
1071
        }
 
1072
        nc_set_selected_input_dev(in);
 
1073
        nc_set_selected_output_dev(out);
 
1074
}
 
1075
 
 
1076
static void nc_pmic_irq_cb(void *cb_data, u8 intsts)
 
1077
{
 
1078
        u8 value = 0;
 
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,};
 
1083
 
 
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);
 
1088
 
 
1089
        mjack = &intelmaddata->jack[0];
 
1090
        if (intsts & 0x1) {
 
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);
 
1097
        }
 
1098
 
 
1099
        if (intsts & 0x2) {
 
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);
 
1106
        }
 
1107
 
 
1108
        if (intsts & 0x4) {
 
1109
                pr_debug("MAD short push detected\n");
 
1110
                /* send short push */
 
1111
                present = 1;
 
1112
                jack_event_flag = 1;
 
1113
                buttonpressflag = 1;
 
1114
                mjack->jack.type = MID_JACK_HS_SHORT_PRESS;
 
1115
        }
 
1116
 
 
1117
        if (intsts & 0x8) {
 
1118
                pr_debug(":MAD long push detected\n");
 
1119
                /* send long push */
 
1120
                present = 1;
 
1121
                jack_event_flag = 1;
 
1122
                buttonpressflag = 1;
 
1123
                mjack->jack.type = MID_JACK_HS_LONG_PRESS;
 
1124
        }
 
1125
 
 
1126
        if (jack_event_flag)
 
1127
                sst_mad_send_jack_report(&mjack->jack,
 
1128
                                        buttonpressflag, present);
 
1129
}
 
1130
static int nc_jack_enable(void)
 
1131
{
 
1132
        return 0;
 
1133
}
 
1134
 
989
1135
struct snd_pmic_ops snd_pmic_ops_nc = {
 
1136
        .input_dev_id   =       DMIC,
 
1137
        .output_dev_id  =       INTERNAL_SPKR,
990
1138
        .set_input_dev  =       nc_set_selected_input_dev,
991
1139
        .set_output_dev =       nc_set_selected_output_dev,
992
1140
        .set_mute       =       nc_set_mute,
1002
1150
        .power_up_pmic_cp =     nc_power_up_cp,
1003
1151
        .power_down_pmic_pb =   nc_power_down_pb,
1004
1152
        .power_down_pmic_cp =   nc_power_down_cp,
1005
 
        .power_down_pmic =      nc_power_down,
 
1153
        .power_down_pmic        =       nc_power_down,
 
1154
        .pmic_irq_cb    =       nc_pmic_irq_cb,
 
1155
        .pmic_jack_enable =     nc_jack_enable,
1006
1156
};