54
60
/*TI vibra w/a settings*/
62
65
/* pcm port setting */
66
69
/* Set vol HSLRVOLCTRL, IHFVOL */
71
74
/* HSEPRXCTRL Enable the headset left and right FIR filters */
75
78
/* amic configuration */
78
81
/* unmask ocaudio/accdet interrupts */
79
82
{0x1d, 0x00, 0x00},
80
83
{0x1e, 0x00, 0x00},
82
85
snd_msic_ops.card_status = SND_CARD_INIT_DONE;
83
sst_sc_reg_access(sc_access, PMIC_WRITE, 30);
86
sst_sc_reg_access(sc_access, PMIC_WRITE, 28);
84
87
snd_msic_ops.pb_on = 0;
88
snd_msic_ops.pbhs_on = 0;
85
89
snd_msic_ops.cap_on = 0;
86
90
snd_msic_ops.input_dev_id = DMIC; /*def dev*/
87
91
snd_msic_ops.output_dev_id = STEREO_HEADPHONE;
92
snd_msic_ops.jack_interrupt_status = false;
88
93
pr_debug("msic init complete!!\n");
96
static int msic_line_out_restore(u8 value)
98
struct sc_reg_access hs_drv_en[] = {
101
struct sc_reg_access ep_drv_en[] = {
104
struct sc_reg_access ihf_drv_en[] = {
107
struct sc_reg_access vib1_drv_en[] = {
110
struct sc_reg_access vib2_drv_en[] = {
113
struct sc_reg_access pmode_enable[] = {
118
pr_debug("msic_lineout_restore_lineout_dev:%d\n", value);
122
pr_debug("Selecting Lineout-HEADSET-restore\n");
123
if (snd_msic_ops.output_dev_id == STEREO_HEADPHONE)
124
retval = sst_sc_reg_access(hs_drv_en,
125
PMIC_READ_MODIFY, 1);
127
retval = sst_sc_reg_access(ep_drv_en,
128
PMIC_READ_MODIFY, 1);
131
pr_debug("Selecting Lineout-IHF-restore\n");
132
retval = sst_sc_reg_access(ihf_drv_en, PMIC_READ_MODIFY, 1);
135
retval = sst_sc_reg_access(pmode_enable, PMIC_READ_MODIFY, 1);
138
pr_debug("Selecting Lineout-Vibra1-restore\n");
139
retval = sst_sc_reg_access(vib1_drv_en, PMIC_READ_MODIFY, 1);
142
pr_debug("Selecting Lineout-VIBRA2-restore\n");
143
retval = sst_sc_reg_access(vib2_drv_en, PMIC_READ_MODIFY, 1);
146
pr_debug("Selecting Lineout-NONE-restore\n");
153
static int msic_get_lineout_prvstate(void)
155
struct sc_reg_access hs_ihf_drv[2] = {
159
struct sc_reg_access vib1drv[2] = {
163
struct sc_reg_access vib2drv[2] = {
167
int retval = 0, drv_en, dac_en, dev_id, mask;
168
for (dev_id = 0; dev_id < snd_msic_ops.line_out_names_cnt; dev_id++) {
171
pr_debug("msic_get_lineout_prvs_state: HEADSET\n");
172
sst_sc_reg_access(hs_ihf_drv, PMIC_READ, 2);
174
mask = (MASK0|MASK1);
175
dac_en = (hs_ihf_drv[0].value) & mask;
177
mask = ((MASK0|MASK1)|MASK6);
178
drv_en = (hs_ihf_drv[1].value) & mask;
180
if (dac_en && (!drv_en)) {
181
snd_msic_ops.prev_lineout_dev_id = HEADSET;
186
pr_debug("msic_get_lineout_prvstate: IHF\n");
187
sst_sc_reg_access(hs_ihf_drv, PMIC_READ, 2);
189
mask = (MASK2 | MASK3);
190
dac_en = (hs_ihf_drv[0].value) & mask;
192
mask = (MASK2 | MASK3);
193
drv_en = (hs_ihf_drv[1].value) & mask;
195
if (dac_en && (!drv_en)) {
196
snd_msic_ops.prev_lineout_dev_id = IHF;
201
pr_debug("msic_get_lineout_prvstate: vibra1\n");
202
sst_sc_reg_access(vib1drv, PMIC_READ, 2);
205
dac_en = (vib1drv[0].value) & mask;
208
drv_en = (vib1drv[1].value) & mask;
210
if (dac_en && (!drv_en)) {
211
snd_msic_ops.prev_lineout_dev_id = VIBRA1;
216
pr_debug("msic_get_lineout_prvstate: vibra2\n");
217
sst_sc_reg_access(vib2drv, PMIC_READ, 2);
220
dac_en = (vib2drv[0].value) & mask;
223
drv_en = ((vib2drv[1].value) & mask);
225
if (dac_en && (!drv_en)) {
226
snd_msic_ops.prev_lineout_dev_id = VIBRA2;
231
pr_debug("msic_get_lineout_prvstate: NONE\n");
232
snd_msic_ops.prev_lineout_dev_id = NONE;
235
pr_debug("Invalid device id\n");
236
snd_msic_ops.prev_lineout_dev_id = NONE;
242
static int msic_set_selected_lineout_dev(u8 value)
244
struct sc_reg_access lout_hs[] = {
248
struct sc_reg_access lout_ihf[] = {
252
struct sc_reg_access lout_vibra1[] = {
257
struct sc_reg_access lout_vibra2[] = {
262
struct sc_reg_access lout_def[] = {
265
struct sc_reg_access pmode_disable[] = {
268
struct sc_reg_access pmode_enable[] = {
273
pr_debug("msic_set_selected_lineout_dev:%d\n", value);
274
msic_get_lineout_prvstate();
275
msic_line_out_restore(snd_msic_ops.prev_lineout_dev_id);
276
snd_msic_ops.lineout_dev_id = value;
280
pr_debug("Selecting Lineout-HEADSET\n");
281
if (snd_msic_ops.pb_on)
282
retval = sst_sc_reg_access(lout_hs,
283
PMIC_READ_MODIFY, 2);
286
retval = sst_sc_reg_access(pmode_disable,
287
PMIC_READ_MODIFY, 1);
290
pr_debug("Selecting Lineout-IHF\n");
291
if (snd_msic_ops.pb_on)
292
retval = sst_sc_reg_access(lout_ihf,
293
PMIC_READ_MODIFY, 2);
296
retval = sst_sc_reg_access(pmode_enable,
297
PMIC_READ_MODIFY, 1);
300
pr_debug("Selecting Lineout-Vibra1\n");
301
if (snd_msic_ops.pb_on)
302
retval = sst_sc_reg_access(lout_vibra1,
303
PMIC_READ_MODIFY, 2);
306
retval = sst_sc_reg_access(pmode_disable,
307
PMIC_READ_MODIFY, 1);
310
pr_debug("Selecting Lineout-VIBRA2\n");
311
if (snd_msic_ops.pb_on)
312
retval = sst_sc_reg_access(lout_vibra2,
313
PMIC_READ_MODIFY, 2);
316
retval = sst_sc_reg_access(pmode_disable,
317
PMIC_READ_MODIFY, 1);
320
pr_debug("Selecting Lineout-NONE\n");
321
retval = sst_sc_reg_access(lout_def,
325
retval = sst_sc_reg_access(pmode_disable,
326
PMIC_READ_MODIFY, 1);
92
335
static int msic_power_up_pb(unsigned int device)
94
struct sc_reg_access sc_access1[] = {
337
struct sc_reg_access vaud[] = {
95
338
/* turn on the audio power supplies */
341
struct sc_reg_access pll[] = {
345
struct sc_reg_access vhs[] = {
100
349
{0x0DD, 0x3F, 0},
104
struct sc_reg_access sc_access2[] = {
351
struct sc_reg_access hsdac[] = {
105
353
/* disable driver */
106
354
{0x25D, 0x0, 0x43},
107
355
/* DAC CONFIG ; both HP, LP on */
108
356
{0x257, 0x03, 0x03},
110
struct sc_reg_access sc_access3[] = {
358
struct sc_reg_access hs_filter[] = {
111
359
/* HSEPRXCTRL Enable the headset left and right FIR filters */
112
360
{0x250, 0x30, 0},
114
362
{0x256, 0x11, 0},
116
struct sc_reg_access sc_access4[] = {
364
struct sc_reg_access hs_enable[] = {
117
365
/* enable driver */
118
366
{0x25D, 0x3, 0x3},
119
368
/* unmute the headset */
120
369
{ 0x259, 0x80, 0x80},
121
370
{ 0x25A, 0x80, 0x80},
123
struct sc_reg_access sc_access_vihf[] = {
372
struct sc_reg_access vihf[] = {
127
struct sc_reg_access sc_access22[] = {
376
struct sc_reg_access ihf_filter[] = {
128
377
/* disable driver */
129
378
{0x25D, 0x00, 0x0C},
130
379
/*Filer DAC enable*/
131
380
{0x251, 0x03, 0x03},
132
381
{0x257, 0x0C, 0x0C},
134
struct sc_reg_access sc_access32[] = {
383
struct sc_reg_access ihf_en[] = {
136
385
{0x25D, 0x0C, 0x0c},
138
struct sc_reg_access sc_access42[] = {
387
struct sc_reg_access ihf_unmute[] = {
139
388
/*unmute headset*/
140
389
{0x25B, 0x80, 0x80},
141
390
{0x25C, 0x80, 0x80},
143
struct sc_reg_access sc_access23[] = {
392
struct sc_reg_access epdac[] = {
144
393
/* disable driver */
145
394
{0x25D, 0x0, 0x43},
146
395
/* DAC CONFIG ; both HP, LP on */
147
396
{0x257, 0x03, 0x03},
149
struct sc_reg_access sc_access43[] = {
398
struct sc_reg_access ep_enable[] = {
150
399
/* enable driver */
151
400
{0x25D, 0x40, 0x40},
152
401
/* unmute the headset */
153
402
{ 0x259, 0x80, 0x80},
154
403
{ 0x25A, 0x80, 0x80},
156
struct sc_reg_access sc_access_vib[] = {
405
struct sc_reg_access vib1_en[] = {
157
406
/* enable driver, ADC */
158
407
{0x25D, 0x10, 0x10},
161
struct sc_reg_access sc_access_hap[] = {
410
struct sc_reg_access vib2_en[] = {
162
411
/* enable driver, ADC */
163
412
{0x25D, 0x20, 0x20},
166
struct sc_reg_access sc_access_pcm2[] = {
415
struct sc_reg_access pcm2_en[] = {
167
416
/* enable pcm 2 */
168
417
{0x27C, 0x1, 0x1},
178
427
pr_debug("powering up pb.... Device %d\n", device);
179
sst_sc_reg_access(sc_access1, PMIC_WRITE, 4);
428
sst_sc_reg_access(vaud, PMIC_WRITE, 1);
430
sst_sc_reg_access(pll, PMIC_WRITE, 1);
180
432
switch (device) {
181
433
case SND_SST_DEVICE_HEADSET:
434
snd_msic_ops.pb_on = 1;
435
snd_msic_ops.pbhs_on = 1;
182
436
if (snd_msic_ops.output_dev_id == STEREO_HEADPHONE) {
183
sst_sc_reg_access(sc_access2, PMIC_READ_MODIFY, 2);
184
sst_sc_reg_access(sc_access3, PMIC_WRITE, 2);
185
sst_sc_reg_access(sc_access4, PMIC_READ_MODIFY, 3);
437
sst_sc_reg_access(vhs, PMIC_WRITE, 2);
438
sst_sc_reg_access(hsdac, PMIC_READ_MODIFY, 3);
439
sst_sc_reg_access(hs_filter, PMIC_WRITE, 2);
440
sst_sc_reg_access(hs_enable, PMIC_READ_MODIFY, 4);
187
sst_sc_reg_access(sc_access23, PMIC_READ_MODIFY, 2);
188
sst_sc_reg_access(sc_access3, PMIC_WRITE, 2);
189
sst_sc_reg_access(sc_access43, PMIC_READ_MODIFY, 3);
442
sst_sc_reg_access(epdac, PMIC_READ_MODIFY, 2);
443
sst_sc_reg_access(hs_filter, PMIC_WRITE, 2);
444
sst_sc_reg_access(ep_enable, PMIC_READ_MODIFY, 3);
191
snd_msic_ops.pb_on = 1;
446
if (snd_msic_ops.lineout_dev_id == HEADSET)
447
msic_set_selected_lineout_dev(HEADSET);
194
449
case SND_SST_DEVICE_IHF:
195
sst_sc_reg_access(sc_access_vihf, PMIC_WRITE, 1);
196
sst_sc_reg_access(sc_access22, PMIC_READ_MODIFY, 3);
197
sst_sc_reg_access(sc_access32, PMIC_READ_MODIFY, 1);
198
sst_sc_reg_access(sc_access42, PMIC_READ_MODIFY, 2);
450
snd_msic_ops.pb_on = 1;
451
sst_sc_reg_access(vihf, PMIC_WRITE, 1);
452
sst_sc_reg_access(ihf_filter, PMIC_READ_MODIFY, 3);
453
sst_sc_reg_access(ihf_en, PMIC_READ_MODIFY, 1);
454
sst_sc_reg_access(ihf_unmute, PMIC_READ_MODIFY, 2);
455
if (snd_msic_ops.lineout_dev_id == IHF)
456
msic_set_selected_lineout_dev(IHF);
201
459
case SND_SST_DEVICE_VIBRA:
202
sst_sc_reg_access(sc_access_vib, PMIC_READ_MODIFY, 2);
460
snd_msic_ops.pb_on = 1;
461
sst_sc_reg_access(vib1_en, PMIC_READ_MODIFY, 2);
462
if (snd_msic_ops.lineout_dev_id == VIBRA1)
463
msic_set_selected_lineout_dev(VIBRA1);
205
466
case SND_SST_DEVICE_HAPTIC:
206
sst_sc_reg_access(sc_access_hap, PMIC_READ_MODIFY, 2);
467
snd_msic_ops.pb_on = 1;
468
sst_sc_reg_access(vib2_en, PMIC_READ_MODIFY, 2);
469
if (snd_msic_ops.lineout_dev_id == VIBRA2)
470
msic_set_selected_lineout_dev(VIBRA2);
210
474
pr_warn("Wrong Device %d, selected %d\n",
211
475
device, snd_msic_ops.output_dev_id);
213
return sst_sc_reg_access(sc_access_pcm2, PMIC_READ_MODIFY, 1);
477
return sst_sc_reg_access(pcm2_en, PMIC_READ_MODIFY, 1);
216
480
static int msic_power_up_cp(unsigned int device)
218
struct sc_reg_access sc_access[] = {
482
struct sc_reg_access vaud[] = {
219
483
/* turn on the audio power supplies */
486
struct sc_reg_access pll[] = {
225
487
/* turn on PLL */
228
/* Turn on DMIC supply */
490
struct sc_reg_access dmic_bias[] = {
491
/* Turn on AMIC supply */
494
struct sc_reg_access dmic[] = {
233
495
/* mic demux enable */
238
struct sc_reg_access sc_access_amic[] = {
239
/* turn on the audio power supplies */
500
struct sc_reg_access amic_bias[] = {
501
/* Turn on AMIC supply */
504
struct sc_reg_access amic[] = {
253
/* Turn on AMIC supply */
257
struct sc_reg_access sc_access2[] = {
512
struct sc_reg_access pcm2[] = {
258
513
/* enable pcm 2 */
259
514
{0x27C, 0x1, 0x1},
261
struct sc_reg_access sc_access3[] = {
516
struct sc_reg_access tx_on[] = {
262
517
/*wait for mic to stabalize before turning on audio channels*/
263
518
{0x24F, 0x3C, 0x0},
273
528
pr_debug("powering up cp....%d\n", snd_msic_ops.input_dev_id);
274
sst_sc_reg_access(sc_access2, PMIC_READ_MODIFY, 1);
529
sst_sc_reg_access(vaud, PMIC_WRITE, 1);
530
msleep(500);/*FIXME need optimzed value here*/
531
sst_sc_reg_access(pll, PMIC_WRITE, 1);
275
533
snd_msic_ops.cap_on = 1;
276
if (snd_msic_ops.input_dev_id == AMIC)
277
sst_sc_reg_access(sc_access_amic, PMIC_WRITE, 9);
279
sst_sc_reg_access(sc_access, PMIC_WRITE, 9);
280
return sst_sc_reg_access(sc_access3, PMIC_WRITE, 1);
534
if (snd_msic_ops.input_dev_id == AMIC) {
535
sst_sc_reg_access(amic_bias, PMIC_READ_MODIFY, 1);
537
sst_sc_reg_access(amic, PMIC_READ_MODIFY, 3);
539
sst_sc_reg_access(dmic_bias, PMIC_READ_MODIFY, 1);
541
sst_sc_reg_access(dmic, PMIC_READ_MODIFY, 2);
544
sst_sc_reg_access(tx_on, PMIC_WRITE, 1);
545
return sst_sc_reg_access(pcm2, PMIC_READ_MODIFY, 1);
284
548
static int msic_power_down(void)
550
struct sc_reg_access power_dn[] = {
558
struct sc_reg_access pll[] = {
562
struct sc_reg_access vaud[] = {
288
567
pr_debug("powering dn msic\n");
568
snd_msic_ops.pbhs_on = 0;
289
569
snd_msic_ops.pb_on = 0;
290
570
snd_msic_ops.cap_on = 0;
294
static int msic_power_down_pb(void)
298
pr_debug("powering dn pb....\n");
299
snd_msic_ops.pb_on = 0;
303
static int msic_power_down_cp(void)
571
sst_sc_reg_access(power_dn, PMIC_WRITE, 3);
573
sst_sc_reg_access(pll, PMIC_WRITE, 1);
575
sst_sc_reg_access(vaud, PMIC_WRITE, 1);
579
static int msic_power_down_pb(unsigned int device)
581
struct sc_reg_access drv_enable[] = {
584
struct sc_reg_access hs_mute[] = {
589
struct sc_reg_access hs_off[] = {
594
struct sc_reg_access ihf_mute[] = {
598
struct sc_reg_access ihf_off[] = {
602
struct sc_reg_access vib1_off[] = {
605
struct sc_reg_access vib2_off[] = {
608
struct sc_reg_access lout_off[] = {
611
struct sc_reg_access pmode_disable[] = {
617
pr_debug("powering dn pb for device %d\n", device);
619
case SND_SST_DEVICE_HEADSET:
620
snd_msic_ops.pbhs_on = 0;
621
sst_sc_reg_access(hs_mute, PMIC_READ_MODIFY, 3);
622
drv_enable[0].mask = 0x43;
623
sst_sc_reg_access(drv_enable, PMIC_READ_MODIFY, 1);
624
sst_sc_reg_access(hs_off, PMIC_READ_MODIFY, 3);
625
if (snd_msic_ops.lineout_dev_id == HEADSET)
626
sst_sc_reg_access(lout_off, PMIC_WRITE, 1);
629
case SND_SST_DEVICE_IHF:
630
sst_sc_reg_access(ihf_mute, PMIC_READ_MODIFY, 2);
631
drv_enable[0].mask = 0x0C;
632
sst_sc_reg_access(drv_enable, PMIC_READ_MODIFY, 1);
633
sst_sc_reg_access(ihf_off, PMIC_READ_MODIFY, 2);
634
if (snd_msic_ops.lineout_dev_id == IHF) {
635
sst_sc_reg_access(lout_off, PMIC_WRITE, 1);
636
sst_sc_reg_access(pmode_disable, PMIC_READ_MODIFY, 1);
640
case SND_SST_DEVICE_VIBRA:
641
sst_sc_reg_access(vib1_off, PMIC_READ_MODIFY, 1);
642
drv_enable[0].mask = 0x10;
643
sst_sc_reg_access(drv_enable, PMIC_READ_MODIFY, 1);
644
if (snd_msic_ops.lineout_dev_id == VIBRA1)
645
sst_sc_reg_access(lout_off, PMIC_WRITE, 1);
648
case SND_SST_DEVICE_HAPTIC:
649
sst_sc_reg_access(vib2_off, PMIC_READ_MODIFY, 1);
650
drv_enable[0].mask = 0x20;
651
sst_sc_reg_access(drv_enable, PMIC_READ_MODIFY, 1);
652
if (snd_msic_ops.lineout_dev_id == VIBRA2)
653
sst_sc_reg_access(lout_off, PMIC_WRITE, 1);
659
static int msic_power_down_cp(unsigned int device)
661
struct sc_reg_access dmic[] = {
666
struct sc_reg_access amic[] = {
672
struct sc_reg_access tx_off[] = {
307
676
pr_debug("powering dn cp....\n");
308
677
snd_msic_ops.cap_on = 0;
678
sst_sc_reg_access(tx_off, PMIC_READ_MODIFY, 1);
679
if (snd_msic_ops.input_dev_id == DMIC)
680
sst_sc_reg_access(dmic, PMIC_READ_MODIFY, 3);
682
sst_sc_reg_access(amic, PMIC_READ_MODIFY, 4);
312
686
static int msic_set_selected_output_dev(u8 value)
729
static int msic_set_hw_dmic_route(u8 hw_ch_index)
731
struct sc_reg_access sc_access_router;
732
int retval = -EINVAL;
734
switch (hw_ch_index) {
736
sc_access_router.reg_addr = AUDIOMUX12;
737
sc_access_router.value = snd_msic_ops.hw_dmic_map[0];
738
sc_access_router.mask = (MASK2 | MASK1 | MASK0);
739
pr_debug("hw_ch0. value = 0x%x\n",
740
sc_access_router.value);
741
retval = sst_sc_reg_access(&sc_access_router,
742
PMIC_READ_MODIFY, 1);
746
sc_access_router.reg_addr = AUDIOMUX12;
747
sc_access_router.value = (snd_msic_ops.hw_dmic_map[1]) << 4;
748
sc_access_router.mask = (MASK6 | MASK5 | MASK4);
749
pr_debug("### hw_ch1. value = 0x%x\n",
750
sc_access_router.value);
751
retval = sst_sc_reg_access(&sc_access_router,
752
PMIC_READ_MODIFY, 1);
756
sc_access_router.reg_addr = AUDIOMUX34;
757
sc_access_router.value = snd_msic_ops.hw_dmic_map[2];
758
sc_access_router.mask = (MASK2 | MASK1 | MASK0);
759
pr_debug("hw_ch2. value = 0x%x\n",
760
sc_access_router.value);
761
retval = sst_sc_reg_access(&sc_access_router,
762
PMIC_READ_MODIFY, 1);
766
sc_access_router.reg_addr = AUDIOMUX34;
767
sc_access_router.value = (snd_msic_ops.hw_dmic_map[3]) << 4;
768
sc_access_router.mask = (MASK6 | MASK5 | MASK4);
769
pr_debug("hw_ch3. value = 0x%x\n",
770
sc_access_router.value);
771
retval = sst_sc_reg_access(&sc_access_router,
772
PMIC_READ_MODIFY, 1);
355
780
static int msic_set_pcm_voice_params(void)
820
static int msic_set_headset_state(int state)
822
struct sc_reg_access hs_enable[] = {
828
sst_sc_reg_access(hs_enable, PMIC_READ_MODIFY, 1);
830
hs_enable[0].value = 0;
831
sst_sc_reg_access(hs_enable, PMIC_READ_MODIFY, 1);
836
static int msic_enable_mic_bias(void)
838
struct sc_reg_access jack_interrupt_reg[] = {
842
struct sc_reg_access jack_bias_reg[] = {
846
sst_sc_reg_access(jack_interrupt_reg, PMIC_WRITE, 1);
847
sst_sc_reg_access(jack_bias_reg, PMIC_READ_MODIFY, 1);
851
static int msic_disable_mic_bias(void)
853
if (snd_msic_ops.jack_interrupt_status == true)
855
if (!(snd_msic_ops.pb_on || snd_msic_ops.cap_on))
860
static int msic_disable_jack_btn(void)
862
struct sc_reg_access btn_disable[] = {
866
if (!(snd_msic_ops.pb_on || snd_msic_ops.cap_on))
868
snd_msic_ops.jack_interrupt_status = false;
869
return sst_sc_reg_access(btn_disable, PMIC_READ_MODIFY, 1);
872
static int msic_enable_jack_btn(void)
874
struct sc_reg_access btn_enable[] = {
878
return sst_sc_reg_access(btn_enable, PMIC_WRITE, 2);
880
static int msic_convert_adc_to_mvolt(unsigned int mic_bias)
882
return (ADC_ONE_LSB_MULTIPLIER * mic_bias) / 1000;
884
int msic_get_headset_state(int mic_bias)
886
struct sc_reg_access msic_hs_toggle[] = {
889
if (mic_bias >= 0 && mic_bias < 400) {
891
pr_debug("Detected Headphone!!!\n");
892
sst_sc_reg_access(msic_hs_toggle, PMIC_READ_MODIFY, 1);
894
} else if (mic_bias > 400 && mic_bias < 650) {
896
pr_debug("Detected American headset\n");
897
msic_hs_toggle[0].value = 0x01;
898
sst_sc_reg_access(msic_hs_toggle, PMIC_READ_MODIFY, 1);
900
} else if (mic_bias >= 650 && mic_bias < 2000) {
902
pr_debug("Detected Headset!!!\n");
903
sst_sc_reg_access(msic_hs_toggle, PMIC_READ_MODIFY, 1);
904
/*power on jack and btn*/
905
snd_msic_ops.jack_interrupt_status = true;
906
msic_enable_jack_btn();
907
msic_enable_mic_bias();
908
return SND_JACK_HEADSET;
911
pr_debug("Detected Open Cable!!!\n");
913
return SND_JACK_HEADPHONE;
916
static int msic_get_mic_bias(void *arg)
918
struct snd_intelmad *intelmad_drv = (struct snd_intelmad *)arg;
919
u16 adc_adr = intelmad_drv->adc_address;
922
struct sc_reg_access adc_ctrl3[2] = {
926
struct sc_reg_access audio_adc_reg1 = {0,};
927
struct sc_reg_access audio_adc_reg2 = {0,};
929
msic_enable_mic_bias();
930
/* Enable the msic for conversion before reading */
931
ret = sst_sc_reg_access(adc_ctrl3, PMIC_WRITE, 1);
934
adc_ctrl3[0].value = 0x04;
935
/* Re-toggle the RRDATARD bit */
936
ret = sst_sc_reg_access(adc_ctrl3, PMIC_WRITE, 1);
940
audio_adc_reg1.reg_addr = adc_adr;
941
/* Read the higher bits of data */
943
ret = sst_sc_reg_access(&audio_adc_reg1, PMIC_READ, 1);
946
pr_debug("adc read value %x", audio_adc_reg1.value);
948
/* Shift bits to accomodate the lower two data bits */
949
adc_val = (audio_adc_reg1.value << 2);
951
audio_adc_reg2. reg_addr = adc_adr;
952
ret = sst_sc_reg_access(&audio_adc_reg2, PMIC_READ, 1);
955
pr_debug("adc read value %x", audio_adc_reg2.value);
957
/* Adding lower two bits to the higher bits */
958
audio_adc_reg2.value &= 03;
959
adc_val += audio_adc_reg2.value;
961
pr_debug("ADC value 0x%x", adc_val);
962
msic_disable_mic_bias();
966
static void msic_pmic_irq_cb(void *cb_data, u8 intsts)
968
struct mad_jack *mjack = NULL;
969
unsigned int present = 0, jack_event_flag = 0, buttonpressflag = 0;
970
struct snd_intelmad *intelmaddata = cb_data;
973
pr_debug("value returned = 0x%x\n", intsts);
975
if (snd_msic_ops.card_status == SND_CARD_UN_INIT) {
976
retval = msic_init_card();
981
mjack = &intelmaddata->jack[0];
983
pr_debug("MAD short_push detected\n");
984
present = SND_JACK_BTN_0;
985
jack_event_flag = buttonpressflag = 1;
986
mjack->jack.type = SND_JACK_BTN_0;
987
mjack->jack.key[0] = BTN_0 ;
991
pr_debug(":MAD long_push detected\n");
992
jack_event_flag = buttonpressflag = 1;
993
mjack->jack.type = present = SND_JACK_BTN_1;
994
mjack->jack.key[1] = BTN_1;
998
unsigned int mic_bias;
1000
buttonpressflag = 0;
1001
mic_bias = msic_get_mic_bias(intelmaddata);
1002
pr_debug("mic_bias = %d\n", mic_bias);
1003
mic_bias = msic_convert_adc_to_mvolt(mic_bias);
1004
pr_debug("mic_bias after conversion = %d mV\n", mic_bias);
1005
mjack->jack_dev_state = msic_get_headset_state(mic_bias);
1006
mjack->jack.type = present = mjack->jack_dev_state;
1010
mjack->jack.type = mjack->jack_dev_state;
1012
jack_event_flag = 1;
1013
buttonpressflag = 0;
1014
msic_disable_jack_btn();
1015
msic_disable_mic_bias();
1017
if (jack_event_flag)
1018
sst_mad_send_jack_report(&mjack->jack,
1019
buttonpressflag, present);
395
1024
struct snd_pmic_ops snd_msic_ops = {
396
1025
.set_input_dev = msic_set_selected_input_dev,
397
1026
.set_output_dev = msic_set_selected_output_dev,
1027
.set_lineout_dev = msic_set_selected_lineout_dev,
1028
.set_hw_dmic_route = msic_set_hw_dmic_route,
398
1029
.set_mute = msic_set_mute,
399
1030
.get_mute = msic_get_mute,
400
1031
.set_vol = msic_set_vol,