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