?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sst: report correct jack event
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / intel_sst / intelmid_v2_control.c
blob46ab55eb8097bfb5abb3fbab2b336371a6e27b31
1 /*
2 * intelmid_v2_control.c - Intel Sound card driver for MID
3 *
4 * Copyright (C) 2008-10 Intel Corp
5 * Authors: Vinod Koul <vinod.koul@intel.com>
6 * Harsha Priya <priya.harsha@intel.com>
7 * KP Jeeja <jeeja.kp@intel.com>
8 * Dharageswari R <dharageswari.r@intel.com>
9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10 *
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.
14 *
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.
19 *
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.
23 *
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 *
26 * This file contains the control operations of vendor 3
27 */
28
29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
30
31 #include <linux/gpio.h>
32 #include <linux/pci.h>
33 #include <linux/delay.h>
34 #include <linux/file.h>
35 #include <sound/control.h>
36 #include "intel_sst.h"
37 #include "intelmid_snd_control.h"
38 #include "intelmid.h"
39
40 enum reg_v3 {
41 VAUDIOCNT = 0x51,
42 VOICEPORT1 = 0x100,
43 VOICEPORT2 = 0x101,
44 AUDIOPORT1 = 0x102,
45 AUDIOPORT2 = 0x103,
46 ADCSAMPLERATE = 0x104,
47 DMICCTRL1 = 0x105,
48 DMICCTRL2 = 0x106,
49 MICCTRL = 0x107,
50 MICSELVOL = 0x108,
51 LILSEL = 0x109,
52 LIRSEL = 0x10a,
53 VOICEVOL = 0x10b,
54 AUDIOLVOL = 0x10c,
55 AUDIORVOL = 0x10d,
56 LMUTE = 0x10e,
57 RMUTE = 0x10f,
58 POWERCTRL1 = 0x110,
59 POWERCTRL2 = 0x111,
60 DRVPOWERCTRL = 0x112,
61 VREFPLL = 0x113,
62 PCMBUFCTRL = 0x114,
63 SOFTMUTE = 0x115,
64 DTMFPATH = 0x116,
65 DTMFVOL = 0x117,
66 DTMFFREQ = 0x118,
67 DTMFHFREQ = 0x119,
68 DTMFLFREQ = 0x11a,
69 DTMFCTRL = 0x11b,
70 DTMFASON = 0x11c,
71 DTMFASOFF = 0x11d,
72 DTMFASINUM = 0x11e,
73 CLASSDVOL = 0x11f,
74 VOICEDACAVOL = 0x120,
75 AUDDACAVOL = 0x121,
76 LOMUTEVOL = 0x122,
77 HPLVOL = 0x123,
78 HPRVOL = 0x124,
79 MONOVOL = 0x125,
80 LINEOUTMIXVOL = 0x126,
81 EPMIXVOL = 0x127,
82 LINEOUTLSEL = 0x128,
83 LINEOUTRSEL = 0x129,
84 EPMIXOUTSEL = 0x12a,
85 HPLMIXSEL = 0x12b,
86 HPRMIXSEL = 0x12c,
87 LOANTIPOP = 0x12d,
88 AUXDBNC = 0x12f,
89 };
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
97 /****
98 * nc_init_card - initialize the sound card
99 *
100 * This initializes the audio paths to know values in case of this sound card
101 */
102 static int nc_init_card(void)
103 {
104 struct sc_reg_access sc_access[] = {
105 {VAUDIOCNT, 0x25, 0},
106 {VOICEPORT1, 0x00, 0},
107 {VOICEPORT2, 0x00, 0},
108 {AUDIOPORT1, 0x98, 0},
109 {AUDIOPORT2, 0x09, 0},
110 {AUDIOLVOL, 0x00, 0},
111 {AUDIORVOL, 0x00, 0},
112 {LMUTE, 0x03, 0},
113 {RMUTE, 0x03, 0},
114 {POWERCTRL1, 0x00, 0},
115 {POWERCTRL2, 0x00, 0},
116 {DRVPOWERCTRL, 0x00, 0},
117 {VREFPLL, 0x10, 0},
118 {HPLMIXSEL, 0xee, 0},
119 {HPRMIXSEL, 0xf6, 0},
120 {PCMBUFCTRL, 0x0, 0},
121 {VOICEVOL, 0x0e, 0},
122 {HPLVOL, 0x06, 0},
123 {HPRVOL, 0x06, 0},
124 {MICCTRL, 0x51, 0x00},
125 {ADCSAMPLERATE, 0x8B, 0x00},
126 {MICSELVOL, 0x5B, 0x00},
127 {LILSEL, 0x06, 0},
128 {LIRSEL, 0x46, 0},
129 {LOANTIPOP, 0x00, 0},
130 {DMICCTRL1, 0x40, 0},
131 {AUXDBNC, 0xff, 0},
132 };
133 snd_pmic_ops_nc.card_status = SND_CARD_INIT_DONE;
134 snd_pmic_ops_nc.master_mute = UNMUTE;
135 snd_pmic_ops_nc.mute_status = UNMUTE;
136 sst_sc_reg_access(sc_access, PMIC_WRITE, 27);
137 mutex_init(&snd_pmic_ops_nc.lock);
138 pr_debug("init complete!!\n");
139 return 0;
140 }
141
142 static int nc_enable_audiodac(int value)
143 {
144 struct sc_reg_access sc_access[3];
145 int mute_val = 0;
146
147 if (snd_pmic_ops_nc.mute_status == MUTE)
148 return 0;
149
150 if (((snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE) ||
151 (snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)) &&
152 (value == UNMUTE))
153 return 0;
154 if (value == UNMUTE) {
155 /* unmute the system, set the 7th bit to zero */
156 mute_val = 0x00;
157 } else {
158 /* MUTE:Set the seventh bit */
159 mute_val = 0x04;
160
161 }
162 sc_access[0].reg_addr = LMUTE;
163 sc_access[1].reg_addr = RMUTE;
164 sc_access[0].mask = sc_access[1].mask = MASK2;
165 sc_access[0].value = sc_access[1].value = mute_val;
166
167 if (snd_pmic_ops_nc.num_channel == 1)
168 sc_access[1].value = 0x04;
169 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
170
171 }
172
173 static int nc_power_up_pb(unsigned int port)
174 {
175 struct sc_reg_access sc_access[7];
176 int retval = 0;
177
178 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
179 retval = nc_init_card();
180 if (retval)
181 return retval;
182 if (port == 0xFF)
183 return 0;
184 mutex_lock(&snd_pmic_ops_nc.lock);
185 nc_enable_audiodac(MUTE);
186 msleep(30);
187
188 pr_debug("powering up pb....\n");
189
190 sc_access[0].reg_addr = VAUDIOCNT;
191 sc_access[0].value = 0x27;
192 sc_access[0].mask = 0x27;
193 sc_access[1].reg_addr = VREFPLL;
194 if (port == 0) {
195 sc_access[1].value = 0x3A;
196 sc_access[1].mask = 0x3A;
197 } else if (port == 1) {
198 sc_access[1].value = 0x35;
199 sc_access[1].mask = 0x35;
200 }
201 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
202
203
204
205 sc_access[0].reg_addr = POWERCTRL1;
206 if (port == 0) {
207 sc_access[0].value = 0x40;
208 sc_access[0].mask = 0x40;
209 } else if (port == 1) {
210 sc_access[0].value = 0x01;
211 sc_access[0].mask = 0x01;
212 }
213 sc_access[1].reg_addr = POWERCTRL2;
214 sc_access[1].value = 0x0C;
215 sc_access[1].mask = 0x0C;
216
217 sc_access[2].reg_addr = DRVPOWERCTRL;
218 sc_access[2].value = 0x86;
219 sc_access[2].mask = 0x86;
220
221 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
222
223 msleep(30);
224
225 snd_pmic_ops_nc.pb_on = 1;
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;
240 }
241
242 static int nc_power_up_cp(unsigned int port)
243 {
244 struct sc_reg_access sc_access[5];
245 int retval = 0;
246
247
248 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
249 retval = nc_init_card();
250 if (retval)
251 return retval;
252
253
254 pr_debug("powering up cp....\n");
255
256 if (port == 0xFF)
257 return 0;
258 sc_access[0].reg_addr = VAUDIOCNT;
259 sc_access[0].value = 0x27;
260 sc_access[0].mask = 0x27;
261 sc_access[1].reg_addr = VREFPLL;
262 if (port == 0) {
263 sc_access[1].value = 0x3E;
264 sc_access[1].mask = 0x3E;
265 } else if (port == 1) {
266 sc_access[1].value = 0x35;
267 sc_access[1].mask = 0x35;
268 }
269
270 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
271
272
273 sc_access[0].reg_addr = POWERCTRL1;
274 if (port == 0) {
275 sc_access[0].value = 0xB4;
276 sc_access[0].mask = 0xB4;
277 } else if (port == 1) {
278 sc_access[0].value = 0xBF;
279 sc_access[0].mask = 0xBF;
280 }
281 sc_access[1].reg_addr = POWERCTRL2;
282 if (port == 0) {
283 sc_access[1].value = 0x0C;
284 sc_access[1].mask = 0x0C;
285 } else if (port == 1) {
286 sc_access[1].value = 0x02;
287 sc_access[1].mask = 0x02;
288 }
289
290 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
291
292 }
293
294 static int nc_power_down(void)
295 {
296 int retval = 0;
297 struct sc_reg_access sc_access[5];
298
299 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
300 retval = nc_init_card();
301 if (retval)
302 return retval;
303 nc_enable_audiodac(MUTE);
304
305
306 pr_debug("powering dn nc_power_down ....\n");
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
312 msleep(30);
313
314 sc_access[0].reg_addr = DRVPOWERCTRL;
315 sc_access[0].value = 0x00;
316 sc_access[0].mask = 0x00;
317
318 sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
319
320 sc_access[0].reg_addr = POWERCTRL1;
321 sc_access[0].value = 0x00;
322 sc_access[0].mask = 0x00;
323
324 sc_access[1].reg_addr = POWERCTRL2;
325 sc_access[1].value = 0x00;
326 sc_access[1].mask = 0x00;
327
328
329
330 sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
331
332 msleep(30);
333 sc_access[0].reg_addr = VREFPLL;
334 sc_access[0].value = 0x10;
335 sc_access[0].mask = 0x10;
336
337 sc_access[1].reg_addr = VAUDIOCNT;
338 sc_access[1].value = 0x25;
339 sc_access[1].mask = 0x25;
340
341
342 retval = sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
343
344 msleep(30);
345 return nc_enable_audiodac(UNMUTE);
346 }
347
348 static int nc_power_down_pb(unsigned int device)
349 {
350
351 int retval = 0;
352 struct sc_reg_access sc_access[5];
353
354 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
355 retval = nc_init_card();
356 if (retval)
357 return retval;
358
359 pr_debug("powering dn pb....\n");
360 mutex_lock(&snd_pmic_ops_nc.lock);
361 nc_enable_audiodac(MUTE);
362
363
364 msleep(30);
365
366
367 sc_access[0].reg_addr = DRVPOWERCTRL;
368 sc_access[0].value = 0x00;
369 sc_access[0].mask = 0x00;
370
371 sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
372
373 msleep(30);
374
375 sc_access[0].reg_addr = POWERCTRL1;
376 sc_access[0].value = 0x00;
377 sc_access[0].mask = 0x41;
378
379 sc_access[1].reg_addr = POWERCTRL2;
380 sc_access[1].value = 0x00;
381 sc_access[1].mask = 0x0C;
382
383 sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
384
385 msleep(30);
386
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;
392 }
393
394 static int nc_power_down_cp(unsigned int device)
395 {
396 struct sc_reg_access sc_access[] = {
397 {POWERCTRL1, 0x00, 0xBE},
398 {POWERCTRL2, 0x00, 0x02},
399 };
400 int retval = 0;
401
402 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
403 retval = nc_init_card();
404 if (retval)
405 return retval;
406
407 pr_debug("powering dn cp....\n");
408 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
409 }
410
411 static int nc_set_pcm_voice_params(void)
412 {
413 struct sc_reg_access sc_access[] = {
414 {0x100, 0xD5, 0},
415 {0x101, 0x08, 0},
416 {0x104, 0x03, 0},
417 {0x107, 0x10, 0},
418 {0x10B, 0x0E, 0},
419 {0x10E, 0x03, 0},
420 {0x10F, 0x03, 0},
421 {0x114, 0x13, 0},
422 {0x115, 0x00, 0},
423 {0x128, 0xFE, 0},
424 {0x129, 0xFE, 0},
425 {0x12A, 0xFE, 0},
426 {0x12B, 0xDE, 0},
427 {0x12C, 0xDE, 0},
428 };
429 int retval = 0;
430
431 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
432 retval = nc_init_card();
433 if (retval)
434 return retval;
435
436 sst_sc_reg_access(sc_access, PMIC_WRITE, 14);
437 pr_debug("Voice parameters set successfully!!\n");
438 return 0;
439 }
440
441
442 static int nc_set_pcm_audio_params(int sfreq, int word_size, int num_channel)
443 {
444 int config2 = 0;
445 struct sc_reg_access sc_access;
446 int retval = 0;
447
448 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
449 retval = nc_init_card();
450 if (retval)
451 return retval;
452
453 switch (sfreq) {
454 case 8000:
455 config2 = 0x00;
456 break;
457 case 11025:
458 config2 = 0x01;
459 break;
460 case 12000:
461 config2 = 0x02;
462 break;
463 case 16000:
464 config2 = 0x03;
465 break;
466 case 22050:
467 config2 = 0x04;
468 break;
469 case 24000:
470 config2 = 0x05;
471 break;
472 case 32000:
473 config2 = 0x07;
474 break;
475 case 44100:
476 config2 = 0x08;
477 break;
478 case 48000:
479 config2 = 0x09;
480 break;
481 }
482
483 snd_pmic_ops_nc.num_channel = num_channel;
484 if (snd_pmic_ops_nc.num_channel == 1) {
485
486 sc_access.value = 0x07;
487 sc_access.reg_addr = RMUTE;
488 pr_debug("RIGHT_HP_MUTE value%d\n", sc_access.value);
489 sc_access.mask = MASK2;
490 sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
491 } else {
492 sc_access.value = 0x00;
493 sc_access.reg_addr = RMUTE;
494 pr_debug("RIGHT_HP_MUTE value %d\n", sc_access.value);
495 sc_access.mask = MASK2;
496 sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
497
498
499 }
500
501 pr_debug("word_size = %d\n", word_size);
502
503 if (word_size == 24) {
504 sc_access.reg_addr = AUDIOPORT2;
505 sc_access.value = config2 | 0x10;
506 sc_access.mask = 0x1F;
507 } else {
508 sc_access.value = config2;
509 sc_access.mask = 0x1F;
510 sc_access.reg_addr = AUDIOPORT2;
511 }
512 sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
513
514 pr_debug("word_size = %d\n", word_size);
515 sc_access.reg_addr = AUDIOPORT1;
516 sc_access.mask = MASK5|MASK4|MASK1|MASK0;
517 if (word_size == 16)
518 sc_access.value = 0x98;
519 else if (word_size == 24)
520 sc_access.value = 0xAB;
521
522 return sst_sc_reg_access(&sc_access, PMIC_READ_MODIFY, 1);
523
524
525
526 }
527
528 static int nc_set_selected_output_dev(u8 value)
529 {
530 struct sc_reg_access sc_access_HP[] = {
531 {LMUTE, 0x02, 0x06},
532 {RMUTE, 0x02, 0x06},
533 {DRVPOWERCTRL, 0x06, 0x06},
534 };
535 struct sc_reg_access sc_access_IS[] = {
536 {LMUTE, 0x04, 0x06},
537 {RMUTE, 0x04, 0x06},
538 {DRVPOWERCTRL, 0x00, 0x06},
539 };
540 int retval = 0;
541
542 snd_pmic_ops_nc.output_dev_id = value;
543 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
544 retval = nc_init_card();
545 if (retval)
546 return retval;
547 pr_debug("nc set selected output:%d\n", value);
548 mutex_lock(&snd_pmic_ops_nc.lock);
549 switch (value) {
550 case STEREO_HEADPHONE:
551 if (snd_pmic_ops_nc.pb_on)
552 sst_sc_reg_access(sc_access_HP+2, PMIC_WRITE, 1);
553 retval = sst_sc_reg_access(sc_access_HP, PMIC_WRITE, 2);
554 nc_set_amp_power(0);
555 break;
556 case MONO_EARPIECE:
557 case INTERNAL_SPKR:
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);
561 break;
562 default:
563 pr_err("rcvd illegal request: %d\n", value);
564 mutex_unlock(&snd_pmic_ops_nc.lock);
565 return -EINVAL;
566 }
567 mutex_unlock(&snd_pmic_ops_nc.lock);
568 return retval;
569 }
570
571 static int nc_audio_init(void)
572 {
573 struct sc_reg_access sc_acces, sc_access[] = {
574 {0x100, 0x00, 0},
575 {0x101, 0x00, 0},
576 {0x104, 0x8B, 0},
577 {0x107, 0x11, 0},
578 {0x10B, 0x0E, 0},
579 {0x114, 0x00, 0},
580 {0x115, 0x00, 0},
581 {0x128, 0x00, 0},
582 {0x129, 0x00, 0},
583 {0x12A, 0x00, 0},
584 {0x12B, 0xee, 0},
585 {0x12C, 0xf6, 0},
586 };
587
588 sst_sc_reg_access(sc_access, PMIC_WRITE, 12);
589 pr_debug("Audio Init successfully!!\n");
590
591 /*set output device */
592 nc_set_selected_output_dev(snd_pmic_ops_nc.output_dev_id);
593
594 if (snd_pmic_ops_nc.num_channel == 1) {
595 sc_acces.value = 0x07;
596 sc_acces.reg_addr = RMUTE;
597 pr_debug("RIGHT_HP_MUTE value%d\n", sc_acces.value);
598 sc_acces.mask = MASK2;
599 sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
600 } else {
601 sc_acces.value = 0x00;
602 sc_acces.reg_addr = RMUTE;
603 pr_debug("RIGHT_HP_MUTE value%d\n", sc_acces.value);
604 sc_acces.mask = MASK2;
605 sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
606 }
607
608 return 0;
609 }
610
611 static int nc_set_audio_port(int status)
612 {
613 struct sc_reg_access sc_access[2] = {{0,},};
614 int retval = 0;
615
616 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
617 retval = nc_init_card();
618 if (retval)
619 return retval;
620
621 if (status == DEACTIVATE) {
622 /* Deactivate audio port-tristate and power */
623 sc_access[0].value = 0x00;
624 sc_access[0].mask = MASK4|MASK5;
625 sc_access[0].reg_addr = AUDIOPORT1;
626 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
627 } else if (status == ACTIVATE) {
628 /* activate audio port */
629 nc_audio_init();
630 sc_access[0].value = 0x10;
631 sc_access[0].mask = MASK4|MASK5 ;
632 sc_access[0].reg_addr = AUDIOPORT1;
633 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
634 } else
635 return -EINVAL;
636
637 }
638
639 static int nc_set_voice_port(int status)
640 {
641 struct sc_reg_access sc_access[2] = {{0,},};
642 int retval = 0;
643
644 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
645 retval = nc_init_card();
646 if (retval)
647 return retval;
648
649 if (status == DEACTIVATE) {
650 /* Activate Voice port */
651 sc_access[0].value = 0x00;
652 sc_access[0].mask = MASK4;
653 sc_access[0].reg_addr = VOICEPORT1;
654 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
655 } else if (status == ACTIVATE) {
656 /* Deactivate voice port */
657 nc_set_pcm_voice_params();
658 sc_access[0].value = 0x10;
659 sc_access[0].mask = MASK4;
660 sc_access[0].reg_addr = VOICEPORT1;
661 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
662 } else
663 return -EINVAL;
664 }
665
666 static int nc_set_mute(int dev_id, u8 value)
667 {
668 struct sc_reg_access sc_access[3];
669 u8 mute_val, cap_mute;
670 int retval = 0;
671
672 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
673 retval = nc_init_card();
674 if (retval)
675 return retval;
676
677 pr_debug("set device id::%d, value %d\n", dev_id, value);
678
679 switch (dev_id) {
680 case PMIC_SND_MUTE_ALL:
681 pr_debug("PMIC_SND_MUTE_ALL value %d\n", value);
682 snd_pmic_ops_nc.mute_status = value;
683 snd_pmic_ops_nc.master_mute = value;
684 if (value == UNMUTE) {
685 /* unmute the system, set the 7th bit to zero */
686 mute_val = cap_mute = 0x00;
687 } else {
688 /* MUTE:Set the seventh bit */
689 mute_val = 0x80;
690 cap_mute = 0x40;
691 }
692 sc_access[0].reg_addr = AUDIOLVOL;
693 sc_access[1].reg_addr = AUDIORVOL;
694 sc_access[0].mask = sc_access[1].mask = MASK7;
695 sc_access[0].value = sc_access[1].value = mute_val;
696 if (snd_pmic_ops_nc.num_channel == 1)
697 sc_access[1].value = 0x80;
698 if (!sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2)) {
699 sc_access[0].reg_addr = 0x109;
700 sc_access[1].reg_addr = 0x10a;
701 sc_access[2].reg_addr = 0x105;
702 sc_access[0].mask = sc_access[1].mask =
703 sc_access[2].mask = MASK6;
704 sc_access[0].value = sc_access[1].value =
705 sc_access[2].value = cap_mute;
706
707 if ((snd_pmic_ops_nc.input_dev_id == AMIC) ||
708 (snd_pmic_ops_nc.input_dev_id == DMIC))
709 sc_access[1].value = 0x40;
710 if (snd_pmic_ops_nc.input_dev_id == HS_MIC)
711 sc_access[0].value = 0x40;
712 retval = sst_sc_reg_access(sc_access,
713 PMIC_READ_MODIFY, 3);
714 }
715 break;
716 case PMIC_SND_HP_MIC_MUTE:
717 pr_debug("PMIC_SND_HPMIC_MUTE value %d\n", value);
718 if (value == UNMUTE) {
719 /* unmute the system, set the 6th bit to one */
720 sc_access[0].value = 0x00;
721 } else {
722 /* mute the system, reset the 6th bit to zero */
723 sc_access[0].value = 0x40;
724 }
725 sc_access[0].reg_addr = LIRSEL;
726 sc_access[0].mask = MASK6;
727 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
728 break;
729 case PMIC_SND_AMIC_MUTE:
730 pr_debug("PMIC_SND_AMIC_MUTE value %d\n", value);
731 if (value == UNMUTE) {
732 /* unmute the system, set the 6th bit to one */
733 sc_access[0].value = 0x00;
734 } else {
735 /* mute the system, reset the 6th bit to zero */
736 sc_access[0].value = 0x40;
737 }
738 sc_access[0].reg_addr = LILSEL;
739 sc_access[0].mask = MASK6;
740 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
741 break;
742
743 case PMIC_SND_DMIC_MUTE:
744 pr_debug("INPUT_MUTE_DMIC value%d\n", value);
745 if (value == UNMUTE) {
746 /* unmute the system, set the 6th bit to one */
747 sc_access[1].value = 0x00;
748 sc_access[0].value = 0x00;
749 } else {
750 /* mute the system, reset the 6th bit to zero */
751 sc_access[1].value = 0x40;
752 sc_access[0].value = 0x40;
753 }
754 sc_access[0].reg_addr = DMICCTRL1;
755 sc_access[0].mask = MASK6;
756 sc_access[1].reg_addr = LILSEL;
757 sc_access[1].mask = MASK6;
758 retval = sst_sc_reg_access(sc_access,
759 PMIC_READ_MODIFY, 2);
760 break;
761
762 case PMIC_SND_LEFT_HP_MUTE:
763 case PMIC_SND_RIGHT_HP_MUTE:
764 snd_pmic_ops_nc.mute_status = value;
765 if (value == UNMUTE)
766 sc_access[0].value = 0x0;
767 else
768 sc_access[0].value = 0x04;
769
770 if (dev_id == PMIC_SND_LEFT_HP_MUTE) {
771 sc_access[0].reg_addr = LMUTE;
772 pr_debug("LEFT_HP_MUTE value %d\n",
773 sc_access[0].value);
774 } else {
775 if (snd_pmic_ops_nc.num_channel == 1)
776 sc_access[0].value = 0x04;
777 sc_access[0].reg_addr = RMUTE;
778 pr_debug("RIGHT_HP_MUTE value %d\n",
779 sc_access[0].value);
780 }
781 sc_access[0].mask = MASK2;
782 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
783 break;
784 case PMIC_SND_LEFT_SPEAKER_MUTE:
785 case PMIC_SND_RIGHT_SPEAKER_MUTE:
786 if (value == UNMUTE)
787 sc_access[0].value = 0x00;
788 else
789 sc_access[0].value = 0x03;
790 sc_access[0].reg_addr = LMUTE;
791 pr_debug("SPEAKER_MUTE %d\n", sc_access[0].value);
792 sc_access[0].mask = MASK1;
793 retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
794 break;
795 default:
796 return -EINVAL;
797 }
798 return retval ;
799
800 }
801
802 static int nc_set_vol(int dev_id, int value)
803 {
804 struct sc_reg_access sc_access[3];
805 int retval = 0, entries = 0;
806
807 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
808 retval = nc_init_card();
809 if (retval)
810 return retval;
811
812 pr_debug("set volume:%d\n", dev_id);
813 switch (dev_id) {
814 case PMIC_SND_CAPTURE_VOL:
815 pr_debug("PMIC_SND_CAPTURE_VOL:value::%d\n", value);
816 sc_access[0].value = sc_access[1].value =
817 sc_access[2].value = -value;
818 sc_access[0].mask = sc_access[1].mask = sc_access[2].mask =
819 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
820 sc_access[0].reg_addr = 0x10a;
821 sc_access[1].reg_addr = 0x109;
822 sc_access[2].reg_addr = 0x105;
823 entries = 3;
824 break;
825
826 case PMIC_SND_LEFT_PB_VOL:
827 pr_debug("PMIC_SND_LEFT_HP_VOL %d\n", value);
828 sc_access[0].value = -value;
829 sc_access[0].reg_addr = HPLVOL;
830 sc_access[0].mask = (MASK0|MASK1|MASK2|MASK3|MASK4);
831 entries = 1;
832 break;
833
834 case PMIC_SND_RIGHT_PB_VOL:
835 pr_debug("PMIC_SND_RIGHT_HP_VOL value %d\n", value);
836 if (snd_pmic_ops_nc.num_channel == 1) {
837 sc_access[0].value = 0x04;
838 sc_access[0].reg_addr = RMUTE;
839 sc_access[0].mask = MASK2;
840 } else {
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;
861 sc_access[0].mask =
862 (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
863 entries = 1;
864 break;
865
866 default:
867 return -EINVAL;
868
869 }
870 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, entries);
871 }
872
873 static int nc_set_selected_input_dev(u8 value)
874 {
875 struct sc_reg_access sc_access[6];
876 u8 num_val;
877 int retval = 0;
878
879 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
880 retval = nc_init_card();
881 if (retval)
882 return retval;
883 snd_pmic_ops_nc.input_dev_id = value;
884
885 pr_debug("nc set selected input:%d\n", value);
886
887 switch (value) {
888 case AMIC:
889 pr_debug("Selecting AMIC\n");
890 sc_access[0].reg_addr = 0x107;
891 sc_access[0].value = 0x40;
892 sc_access[0].mask = MASK6|MASK3|MASK1|MASK0;
893 sc_access[1].reg_addr = 0x10a;
894 sc_access[1].value = 0x40;
895 sc_access[1].mask = MASK6;
896 sc_access[2].reg_addr = 0x109;
897 sc_access[2].value = 0x00;
898 sc_access[2].mask = MASK6;
899 sc_access[3].reg_addr = 0x105;
900 sc_access[3].value = 0x40;
901 sc_access[3].mask = MASK6;
902 num_val = 4;
903 break;
904
905 case HS_MIC:
906 pr_debug("Selecting HS_MIC\n");
907 sc_access[0].reg_addr = MICCTRL;
908 sc_access[0].mask = MASK6|MASK3|MASK1|MASK0;
909 sc_access[0].value = 0x00;
910 sc_access[1].reg_addr = 0x109;
911 sc_access[1].mask = MASK6;
912 sc_access[1].value = 0x40;
913 sc_access[2].reg_addr = 0x10a;
914 sc_access[2].mask = MASK6;
915 sc_access[2].value = 0x00;
916 sc_access[3].reg_addr = 0x105;
917 sc_access[3].value = 0x40;
918 sc_access[3].mask = MASK6;
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;
923 break;
924
925 case DMIC:
926 pr_debug("DMIC\n");
927 sc_access[0].reg_addr = MICCTRL;
928 sc_access[0].mask = MASK6|MASK3|MASK1|MASK0;
929 sc_access[0].value = 0x0B;
930 sc_access[1].reg_addr = 0x105;
931 sc_access[1].value = 0x80;
932 sc_access[1].mask = MASK7|MASK6;
933 sc_access[2].reg_addr = 0x10a;
934 sc_access[2].value = 0x40;
935 sc_access[2].mask = MASK6;
936 sc_access[3].reg_addr = LILSEL;
937 sc_access[3].mask = MASK6;
938 sc_access[3].value = 0x00;
939 sc_access[4].reg_addr = ADCSAMPLERATE;
940 sc_access[4].mask = MASK7|MASK6|MASK5|MASK4|MASK3;
941 sc_access[4].value = 0x33;
942 num_val = 5;
943 break;
944 default:
945 return -EINVAL;
946 }
947 return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, num_val);
948 }
949
950 static int nc_get_mute(int dev_id, u8 *value)
951 {
952 int retval = 0, mask = 0;
953 struct sc_reg_access sc_access = {0,};
954
955 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
956 retval = nc_init_card();
957 if (retval)
958 return retval;
959
960 pr_debug("get mute::%d\n", dev_id);
961
962 switch (dev_id) {
963 case PMIC_SND_AMIC_MUTE:
964 pr_debug("PMIC_SND_INPUT_MUTE_MIC1\n");
965 sc_access.reg_addr = LILSEL;
966 mask = MASK6;
967 break;
968 case PMIC_SND_HP_MIC_MUTE:
969 pr_debug("PMIC_SND_INPUT_MUTE_MIC2\n");
970 sc_access.reg_addr = LIRSEL;
971 mask = MASK6;
972 break;
973 case PMIC_SND_LEFT_HP_MUTE:
974 case PMIC_SND_RIGHT_HP_MUTE:
975 mask = MASK2;
976 pr_debug("PMIC_SN_LEFT/RIGHT_HP_MUTE\n");
977 if (dev_id == PMIC_SND_RIGHT_HP_MUTE)
978 sc_access.reg_addr = RMUTE;
979 else
980 sc_access.reg_addr = LMUTE;
981 break;
982
983 case PMIC_SND_LEFT_SPEAKER_MUTE:
984 pr_debug("PMIC_MONO_EARPIECE_MUTE\n");
985 sc_access.reg_addr = RMUTE;
986 mask = MASK1;
987 break;
988 case PMIC_SND_DMIC_MUTE:
989 pr_debug("PMIC_SND_INPUT_MUTE_DMIC\n");
990 sc_access.reg_addr = 0x105;
991 mask = MASK6;
992 break;
993 default:
994 return -EINVAL;
995
996 }
997 retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
998 pr_debug("reg value = %d\n", sc_access.value);
999 if (retval)
1000 return retval;
1001 *value = (sc_access.value) & mask;
1002 pr_debug("masked value = %d\n", *value);
1003 if (*value)
1004 *value = 0;
1005 else
1006 *value = 1;
1007 pr_debug("value returned = 0x%x\n", *value);
1008 return retval;
1009 }
1010
1011 static int nc_get_vol(int dev_id, int *value)
1012 {
1013 int retval = 0, mask = 0;
1014 struct sc_reg_access sc_access = {0,};
1015
1016 if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
1017 retval = nc_init_card();
1018 if (retval)
1019 return retval;
1020
1021 switch (dev_id) {
1022 case PMIC_SND_CAPTURE_VOL:
1023 pr_debug("PMIC_SND_INPUT_CAPTURE_VOL\n");
1024 sc_access.reg_addr = LILSEL;
1025 mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
1026 break;
1027
1028 case PMIC_SND_LEFT_MASTER_VOL:
1029 pr_debug("GET_VOLUME_PMIC_LEFT_MASTER_VOL\n");
1030 sc_access.reg_addr = AUDIOLVOL;
1031 mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5|MASK6);
1032 break;
1033
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:
1041 pr_debug("GET_VOLUME_PMIC_RIGHT_HP_VOL\n");
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);
1050 break;
1051
1052 default:
1053 return -EINVAL;
1054
1055 }
1056 retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
1057 pr_debug("value read = 0x%x\n", sc_access.value);
1058 *value = -((sc_access.value) & mask);
1059 pr_debug("get vol value returned = %d\n", *value);
1060 return retval;
1061 }
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) ? 3 : 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
1135 struct snd_pmic_ops snd_pmic_ops_nc = {
1136 .input_dev_id = DMIC,
1137 .output_dev_id = INTERNAL_SPKR,
1138 .set_input_dev = nc_set_selected_input_dev,
1139 .set_output_dev = nc_set_selected_output_dev,
1140 .set_mute = nc_set_mute,
1141 .get_mute = nc_get_mute,
1142 .set_vol = nc_set_vol,
1143 .get_vol = nc_get_vol,
1144 .init_card = nc_init_card,
1145 .set_pcm_audio_params = nc_set_pcm_audio_params,
1146 .set_pcm_voice_params = nc_set_pcm_voice_params,
1147 .set_voice_port = nc_set_voice_port,
1148 .set_audio_port = nc_set_audio_port,
1149 .power_up_pmic_pb = nc_power_up_pb,
1150 .power_up_pmic_cp = nc_power_up_cp,
1151 .power_down_pmic_pb = nc_power_down_pb,
1152 .power_down_pmic_cp = nc_power_down_cp,
1153 .power_down_pmic = nc_power_down,
1154 .pmic_irq_cb = nc_pmic_irq_cb,
1155 .pmic_jack_enable = nc_jack_enable,
1156 };
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree