?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / sound / ppc / awacs.c
bloba2be13804f9c12a9afabba5a4d628361dc357ee6
1 /*
2 * PMac AWACS lowlevel functions
3 *
4 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
5 * code based on dmasound.c.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22
23 #include <asm/io.h>
24 #include <asm/nvram.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/slab.h>
28 #include <sound/core.h>
29 #include "pmac.h"
30
31
32 #ifdef CONFIG_ADB_CUDA
33 #define PMAC_AMP_AVAIL
34 #endif
35
36 #ifdef PMAC_AMP_AVAIL
37 struct awacs_amp {
38 unsigned char amp_master;
39 unsigned char amp_vol[2][2];
40 unsigned char amp_tone[2];
41 };
42
43 #define CHECK_CUDA_AMP() (sys_ctrler == SYS_CTRLER_CUDA)
44
45 #endif /* PMAC_AMP_AVAIL */
46
47
48 static void snd_pmac_screamer_wait(struct snd_pmac *chip)
49 {
50 long timeout = 2000;
51 while (!(in_le32(&chip->awacs->codec_stat) & MASK_VALID)) {
52 mdelay(1);
53 if (! --timeout) {
54 snd_printd("snd_pmac_screamer_wait timeout\n");
55 break;
56 }
57 }
58 }
59
60 /*
61 * write AWACS register
62 */
63 static void
64 snd_pmac_awacs_write(struct snd_pmac *chip, int val)
65 {
66 long timeout = 5000000;
67
68 if (chip->model == PMAC_SCREAMER)
69 snd_pmac_screamer_wait(chip);
70 out_le32(&chip->awacs->codec_ctrl, val | (chip->subframe << 22));
71 while (in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) {
72 if (! --timeout) {
73 snd_printd("snd_pmac_awacs_write timeout\n");
74 break;
75 }
76 }
77 }
78
79 static void
80 snd_pmac_awacs_write_reg(struct snd_pmac *chip, int reg, int val)
81 {
82 snd_pmac_awacs_write(chip, val | (reg << 12));
83 chip->awacs_reg[reg] = val;
84 }
85
86 static void
87 snd_pmac_awacs_write_noreg(struct snd_pmac *chip, int reg, int val)
88 {
89 snd_pmac_awacs_write(chip, val | (reg << 12));
90 }
91
92 #ifdef CONFIG_PM
93 /* Recalibrate chip */
94 static void screamer_recalibrate(struct snd_pmac *chip)
95 {
96 if (chip->model != PMAC_SCREAMER)
97 return;
98
99 /* Sorry for the horrible delays... I hope to get that improved
100 * by making the whole PM process asynchronous in a future version
101 */
102 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
103 if (chip->manufacturer == 0x1)
104 /* delay for broken crystal part */
105 msleep(750);
106 snd_pmac_awacs_write_noreg(chip, 1,
107 chip->awacs_reg[1] | MASK_RECALIBRATE |
108 MASK_CMUTE | MASK_AMUTE);
109 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
110 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
111 }
112
113 #else
114 #define screamer_recalibrate(chip) /* NOP */
115 #endif
116
117
118 /*
119 * additional callback to set the pcm format
120 */
121 static void snd_pmac_awacs_set_format(struct snd_pmac *chip)
122 {
123 chip->awacs_reg[1] &= ~MASK_SAMPLERATE;
124 chip->awacs_reg[1] |= chip->rate_index << 3;
125 snd_pmac_awacs_write_reg(chip, 1, chip->awacs_reg[1]);
126 }
127
128
129 /*
130 * AWACS volume callbacks
131 */
132 /*
133 * volumes: 0-15 stereo
134 */
135 static int snd_pmac_awacs_info_volume(struct snd_kcontrol *kcontrol,
136 struct snd_ctl_elem_info *uinfo)
137 {
138 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
139 uinfo->count = 2;
140 uinfo->value.integer.min = 0;
141 uinfo->value.integer.max = 15;
142 return 0;
143 }
144
145 static int snd_pmac_awacs_get_volume(struct snd_kcontrol *kcontrol,
146 struct snd_ctl_elem_value *ucontrol)
147 {
148 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
149 int reg = kcontrol->private_value & 0xff;
150 int lshift = (kcontrol->private_value >> 8) & 0xff;
151 int inverted = (kcontrol->private_value >> 16) & 1;
152 unsigned long flags;
153 int vol[2];
154
155 spin_lock_irqsave(&chip->reg_lock, flags);
156 vol[0] = (chip->awacs_reg[reg] >> lshift) & 0xf;
157 vol[1] = chip->awacs_reg[reg] & 0xf;
158 spin_unlock_irqrestore(&chip->reg_lock, flags);
159 if (inverted) {
160 vol[0] = 0x0f - vol[0];
161 vol[1] = 0x0f - vol[1];
162 }
163 ucontrol->value.integer.value[0] = vol[0];
164 ucontrol->value.integer.value[1] = vol[1];
165 return 0;
166 }
167
168 static int snd_pmac_awacs_put_volume(struct snd_kcontrol *kcontrol,
169 struct snd_ctl_elem_value *ucontrol)
170 {
171 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
172 int reg = kcontrol->private_value & 0xff;
173 int lshift = (kcontrol->private_value >> 8) & 0xff;
174 int inverted = (kcontrol->private_value >> 16) & 1;
175 int val, oldval;
176 unsigned long flags;
177 unsigned int vol[2];
178
179 vol[0] = ucontrol->value.integer.value[0];
180 vol[1] = ucontrol->value.integer.value[1];
181 if (vol[0] > 0x0f || vol[1] > 0x0f)
182 return -EINVAL;
183 if (inverted) {
184 vol[0] = 0x0f - vol[0];
185 vol[1] = 0x0f - vol[1];
186 }
187 vol[0] &= 0x0f;
188 vol[1] &= 0x0f;
189 spin_lock_irqsave(&chip->reg_lock, flags);
190 oldval = chip->awacs_reg[reg];
191 val = oldval & ~(0xf | (0xf << lshift));
192 val |= vol[0] << lshift;
193 val |= vol[1];
194 if (oldval != val)
195 snd_pmac_awacs_write_reg(chip, reg, val);
196 spin_unlock_irqrestore(&chip->reg_lock, flags);
197 return oldval != reg;
198 }
199
200
201 #define AWACS_VOLUME(xname, xreg, xshift, xinverted) \
202 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
203 .info = snd_pmac_awacs_info_volume, \
204 .get = snd_pmac_awacs_get_volume, \
205 .put = snd_pmac_awacs_put_volume, \
206 .private_value = (xreg) | ((xshift) << 8) | ((xinverted) << 16) }
207
208 /*
209 * mute master/ogain for AWACS: mono
210 */
211 static int snd_pmac_awacs_get_switch(struct snd_kcontrol *kcontrol,
212 struct snd_ctl_elem_value *ucontrol)
213 {
214 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
215 int reg = kcontrol->private_value & 0xff;
216 int shift = (kcontrol->private_value >> 8) & 0xff;
217 int invert = (kcontrol->private_value >> 16) & 1;
218 int val;
219 unsigned long flags;
220
221 spin_lock_irqsave(&chip->reg_lock, flags);
222 val = (chip->awacs_reg[reg] >> shift) & 1;
223 spin_unlock_irqrestore(&chip->reg_lock, flags);
224 if (invert)
225 val = 1 - val;
226 ucontrol->value.integer.value[0] = val;
227 return 0;
228 }
229
230 static int snd_pmac_awacs_put_switch(struct snd_kcontrol *kcontrol,
231 struct snd_ctl_elem_value *ucontrol)
232 {
233 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
234 int reg = kcontrol->private_value & 0xff;
235 int shift = (kcontrol->private_value >> 8) & 0xff;
236 int invert = (kcontrol->private_value >> 16) & 1;
237 int mask = 1 << shift;
238 int val, changed;
239 unsigned long flags;
240
241 spin_lock_irqsave(&chip->reg_lock, flags);
242 val = chip->awacs_reg[reg] & ~mask;
243 if (ucontrol->value.integer.value[0] != invert)
244 val |= mask;
245 changed = chip->awacs_reg[reg] != val;
246 if (changed)
247 snd_pmac_awacs_write_reg(chip, reg, val);
248 spin_unlock_irqrestore(&chip->reg_lock, flags);
249 return changed;
250 }
251
252 #define AWACS_SWITCH(xname, xreg, xshift, xinvert) \
253 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
254 .info = snd_pmac_boolean_mono_info, \
255 .get = snd_pmac_awacs_get_switch, \
256 .put = snd_pmac_awacs_put_switch, \
257 .private_value = (xreg) | ((xshift) << 8) | ((xinvert) << 16) }
258
259
260 #ifdef PMAC_AMP_AVAIL
261 /*
262 * controls for perch/whisper extension cards, e.g. G3 desktop
263 *
264 * TDA7433 connected via i2c address 0x45 (= 0x8a),
265 * accessed through cuda
266 */
267 static void awacs_set_cuda(int reg, int val)
268 {
269 struct adb_request req;
270 cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC, 0x8a,
271 reg, val);
272 while (! req.complete)
273 cuda_poll();
274 }
275
276 /*
277 * level = 0 - 14, 7 = 0 dB
278 */
279 static void awacs_amp_set_tone(struct awacs_amp *amp, int bass, int treble)
280 {
281 amp->amp_tone[0] = bass;
282 amp->amp_tone[1] = treble;
283 if (bass > 7)
284 bass = (14 - bass) + 8;
285 if (treble > 7)
286 treble = (14 - treble) + 8;
287 awacs_set_cuda(2, (bass << 4) | treble);
288 }
289
290 /*
291 * vol = 0 - 31 (attenuation), 32 = mute bit, stereo
292 */
293 static int awacs_amp_set_vol(struct awacs_amp *amp, int index,
294 int lvol, int rvol, int do_check)
295 {
296 if (do_check && amp->amp_vol[index][0] == lvol &&
297 amp->amp_vol[index][1] == rvol)
298 return 0;
299 awacs_set_cuda(3 + index, lvol);
300 awacs_set_cuda(5 + index, rvol);
301 amp->amp_vol[index][0] = lvol;
302 amp->amp_vol[index][1] = rvol;
303 return 1;
304 }
305
306 /*
307 * 0 = -79 dB, 79 = 0 dB, 99 = +20 dB
308 */
309 static void awacs_amp_set_master(struct awacs_amp *amp, int vol)
310 {
311 amp->amp_master = vol;
312 if (vol <= 79)
313 vol = 32 + (79 - vol);
314 else
315 vol = 32 - (vol - 79);
316 awacs_set_cuda(1, vol);
317 }
318
319 static void awacs_amp_free(struct snd_pmac *chip)
320 {
321 struct awacs_amp *amp = chip->mixer_data;
322 if (!amp)
323 return;
324 kfree(amp);
325 chip->mixer_data = NULL;
326 chip->mixer_free = NULL;
327 }
328
329
330 /*
331 * mixer controls
332 */
333 static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol,
334 struct snd_ctl_elem_info *uinfo)
335 {
336 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
337 uinfo->count = 2;
338 uinfo->value.integer.min = 0;
339 uinfo->value.integer.max = 31;
340 return 0;
341 }
342
343 static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol,
344 struct snd_ctl_elem_value *ucontrol)
345 {
346 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
347 int index = kcontrol->private_value;
348 struct awacs_amp *amp = chip->mixer_data;
349
350 ucontrol->value.integer.value[0] = 31 - (amp->amp_vol[index][0] & 31);
351 ucontrol->value.integer.value[1] = 31 - (amp->amp_vol[index][1] & 31);
352 return 0;
353 }
354
355 static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol,
356 struct snd_ctl_elem_value *ucontrol)
357 {
358 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
359 int index = kcontrol->private_value;
360 int vol[2];
361 struct awacs_amp *amp = chip->mixer_data;
362
363 vol[0] = (31 - (ucontrol->value.integer.value[0] & 31))
364 | (amp->amp_vol[index][0] & 32);
365 vol[1] = (31 - (ucontrol->value.integer.value[1] & 31))
366 | (amp->amp_vol[index][1] & 32);
367 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
368 }
369
370 static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol,
371 struct snd_ctl_elem_value *ucontrol)
372 {
373 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
374 int index = kcontrol->private_value;
375 struct awacs_amp *amp = chip->mixer_data;
376
377 ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32)
378 ? 0 : 1;
379 ucontrol->value.integer.value[1] = (amp->amp_vol[index][1] & 32)
380 ? 0 : 1;
381 return 0;
382 }
383
384 static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol,
385 struct snd_ctl_elem_value *ucontrol)
386 {
387 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
388 int index = kcontrol->private_value;
389 int vol[2];
390 struct awacs_amp *amp = chip->mixer_data;
391
392 vol[0] = (ucontrol->value.integer.value[0] ? 0 : 32)
393 | (amp->amp_vol[index][0] & 31);
394 vol[1] = (ucontrol->value.integer.value[1] ? 0 : 32)
395 | (amp->amp_vol[index][1] & 31);
396 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
397 }
398
399 static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol,
400 struct snd_ctl_elem_info *uinfo)
401 {
402 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
403 uinfo->count = 1;
404 uinfo->value.integer.min = 0;
405 uinfo->value.integer.max = 14;
406 return 0;
407 }
408
409 static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol,
410 struct snd_ctl_elem_value *ucontrol)
411 {
412 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
413 int index = kcontrol->private_value;
414 struct awacs_amp *amp = chip->mixer_data;
415
416 ucontrol->value.integer.value[0] = amp->amp_tone[index];
417 return 0;
418 }
419
420 static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol,
421 struct snd_ctl_elem_value *ucontrol)
422 {
423 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
424 int index = kcontrol->private_value;
425 struct awacs_amp *amp = chip->mixer_data;
426 unsigned int val;
427
428 val = ucontrol->value.integer.value[0];
429 if (val > 14)
430 return -EINVAL;
431 if (val != amp->amp_tone[index]) {
432 amp->amp_tone[index] = val;
433 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
434 return 1;
435 }
436 return 0;
437 }
438
439 static int snd_pmac_awacs_info_master_amp(struct snd_kcontrol *kcontrol,
440 struct snd_ctl_elem_info *uinfo)
441 {
442 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
443 uinfo->count = 1;
444 uinfo->value.integer.min = 0;
445 uinfo->value.integer.max = 99;
446 return 0;
447 }
448
449 static int snd_pmac_awacs_get_master_amp(struct snd_kcontrol *kcontrol,
450 struct snd_ctl_elem_value *ucontrol)
451 {
452 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
453 struct awacs_amp *amp = chip->mixer_data;
454
455 ucontrol->value.integer.value[0] = amp->amp_master;
456 return 0;
457 }
458
459 static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol,
460 struct snd_ctl_elem_value *ucontrol)
461 {
462 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
463 struct awacs_amp *amp = chip->mixer_data;
464 unsigned int val;
465
466 val = ucontrol->value.integer.value[0];
467 if (val > 99)
468 return -EINVAL;
469 if (val != amp->amp_master) {
470 amp->amp_master = val;
471 awacs_amp_set_master(amp, amp->amp_master);
472 return 1;
473 }
474 return 0;
475 }
476
477 #define AMP_CH_SPK 0
478 #define AMP_CH_HD 1
479
480 static struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] __devinitdata = {
481 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
482 .name = "Speaker Playback Volume",
483 .info = snd_pmac_awacs_info_volume_amp,
484 .get = snd_pmac_awacs_get_volume_amp,
485 .put = snd_pmac_awacs_put_volume_amp,
486 .private_value = AMP_CH_SPK,
487 },
488 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
489 .name = "Headphone Playback Volume",
490 .info = snd_pmac_awacs_info_volume_amp,
491 .get = snd_pmac_awacs_get_volume_amp,
492 .put = snd_pmac_awacs_put_volume_amp,
493 .private_value = AMP_CH_HD,
494 },
495 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
496 .name = "Tone Control - Bass",
497 .info = snd_pmac_awacs_info_tone_amp,
498 .get = snd_pmac_awacs_get_tone_amp,
499 .put = snd_pmac_awacs_put_tone_amp,
500 .private_value = 0,
501 },
502 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
503 .name = "Tone Control - Treble",
504 .info = snd_pmac_awacs_info_tone_amp,
505 .get = snd_pmac_awacs_get_tone_amp,
506 .put = snd_pmac_awacs_put_tone_amp,
507 .private_value = 1,
508 },
509 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
510 .name = "Amp Master Playback Volume",
511 .info = snd_pmac_awacs_info_master_amp,
512 .get = snd_pmac_awacs_get_master_amp,
513 .put = snd_pmac_awacs_put_master_amp,
514 },
515 };
516
517 static struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw __devinitdata = {
518 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
519 .name = "Headphone Playback Switch",
520 .info = snd_pmac_boolean_stereo_info,
521 .get = snd_pmac_awacs_get_switch_amp,
522 .put = snd_pmac_awacs_put_switch_amp,
523 .private_value = AMP_CH_HD,
524 };
525
526 static struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw __devinitdata = {
527 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
528 .name = "Speaker Playback Switch",
529 .info = snd_pmac_boolean_stereo_info,
530 .get = snd_pmac_awacs_get_switch_amp,
531 .put = snd_pmac_awacs_put_switch_amp,
532 .private_value = AMP_CH_SPK,
533 };
534
535 #endif /* PMAC_AMP_AVAIL */
536
537
538 /*
539 * mic boost for screamer
540 */
541 static int snd_pmac_screamer_mic_boost_info(struct snd_kcontrol *kcontrol,
542 struct snd_ctl_elem_info *uinfo)
543 {
544 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
545 uinfo->count = 1;
546 uinfo->value.integer.min = 0;
547 uinfo->value.integer.max = 3;
548 return 0;
549 }
550
551 static int snd_pmac_screamer_mic_boost_get(struct snd_kcontrol *kcontrol,
552 struct snd_ctl_elem_value *ucontrol)
553 {
554 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
555 int val = 0;
556 unsigned long flags;
557
558 spin_lock_irqsave(&chip->reg_lock, flags);
559 if (chip->awacs_reg[6] & MASK_MIC_BOOST)
560 val |= 2;
561 if (chip->awacs_reg[0] & MASK_GAINLINE)
562 val |= 1;
563 spin_unlock_irqrestore(&chip->reg_lock, flags);
564 ucontrol->value.integer.value[0] = val;
565 return 0;
566 }
567
568 static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol,
569 struct snd_ctl_elem_value *ucontrol)
570 {
571 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
572 int changed = 0;
573 int val0, val6;
574 unsigned long flags;
575
576 spin_lock_irqsave(&chip->reg_lock, flags);
577 val0 = chip->awacs_reg[0] & ~MASK_GAINLINE;
578 val6 = chip->awacs_reg[6] & ~MASK_MIC_BOOST;
579 if (ucontrol->value.integer.value[0] & 1)
580 val0 |= MASK_GAINLINE;
581 if (ucontrol->value.integer.value[0] & 2)
582 val6 |= MASK_MIC_BOOST;
583 if (val0 != chip->awacs_reg[0]) {
584 snd_pmac_awacs_write_reg(chip, 0, val0);
585 changed = 1;
586 }
587 if (val6 != chip->awacs_reg[6]) {
588 snd_pmac_awacs_write_reg(chip, 6, val6);
589 changed = 1;
590 }
591 spin_unlock_irqrestore(&chip->reg_lock, flags);
592 return changed;
593 }
594
595 /*
596 * lists of mixer elements
597 */
598 static struct snd_kcontrol_new snd_pmac_awacs_mixers[] __devinitdata = {
599 AWACS_SWITCH("Master Capture Switch", 1, SHIFT_LOOPTHRU, 0),
600 AWACS_VOLUME("Master Capture Volume", 0, 4, 0),
601 /* AWACS_SWITCH("Unknown Playback Switch", 6, SHIFT_PAROUT0, 0), */
602 };
603
604 static struct snd_kcontrol_new snd_pmac_screamer_mixers_beige[] __devinitdata = {
605 AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
606 AWACS_VOLUME("Play-through Playback Volume", 5, 6, 1),
607 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
608 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_LINE, 0),
609 };
610
611 static struct snd_kcontrol_new snd_pmac_screamer_mixers_lo[] __devinitdata = {
612 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
613 };
614
615 static struct snd_kcontrol_new snd_pmac_screamer_mixers_imac[] __devinitdata = {
616 AWACS_VOLUME("Play-through Playback Volume", 5, 6, 1),
617 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
618 };
619
620 static struct snd_kcontrol_new snd_pmac_screamer_mixers_g4agp[] __devinitdata = {
621 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
622 AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
623 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
624 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
625 };
626
627 static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac7500[] __devinitdata = {
628 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
629 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
630 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
631 };
632
633 static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac5500[] __devinitdata = {
634 AWACS_VOLUME("Headphone Playback Volume", 2, 6, 1),
635 };
636
637 static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac[] __devinitdata = {
638 AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
639 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
640 };
641
642 static struct snd_kcontrol_new snd_pmac_awacs_mixers2[] __devinitdata = {
643 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0),
644 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0),
645 };
646
647 static struct snd_kcontrol_new snd_pmac_screamer_mixers2[] __devinitdata = {
648 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
649 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
650 };
651
652 static struct snd_kcontrol_new snd_pmac_awacs_mixers2_pmac5500[] __devinitdata = {
653 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
654 };
655
656 static struct snd_kcontrol_new snd_pmac_awacs_master_sw __devinitdata =
657 AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
658
659 static struct snd_kcontrol_new snd_pmac_awacs_master_sw_imac __devinitdata =
660 AWACS_SWITCH("Line out Playback Switch", 1, SHIFT_HDMUTE, 1);
661
662 static struct snd_kcontrol_new snd_pmac_awacs_master_sw_pmac5500 __devinitdata =
663 AWACS_SWITCH("Headphone Playback Switch", 1, SHIFT_HDMUTE, 1);
664
665 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __devinitdata = {
666 AWACS_SWITCH("Mic Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
667 };
668
669 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __devinitdata = {
670 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
671 .name = "Mic Boost Capture Volume",
672 .info = snd_pmac_screamer_mic_boost_info,
673 .get = snd_pmac_screamer_mic_boost_get,
674 .put = snd_pmac_screamer_mic_boost_put,
675 },
676 };
677
678 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost_pmac7500[] __devinitdata =
679 {
680 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
681 };
682
683 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_beige[] __devinitdata =
684 {
685 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
686 AWACS_SWITCH("CD Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
687 };
688
689 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_imac[] __devinitdata =
690 {
691 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
692 AWACS_SWITCH("Mic Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
693 };
694
695 static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __devinitdata = {
696 AWACS_VOLUME("Speaker Playback Volume", 4, 6, 1),
697 };
698
699 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __devinitdata =
700 AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
701
702 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac1 __devinitdata =
703 AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_PAROUT1, 1);
704
705 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac2 __devinitdata =
706 AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
707
708
709 /*
710 * add new mixer elements to the card
711 */
712 static int build_mixers(struct snd_pmac *chip, int nums,
713 struct snd_kcontrol_new *mixers)
714 {
715 int i, err;
716
717 for (i = 0; i < nums; i++) {
718 err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip));
719 if (err < 0)
720 return err;
721 }
722 return 0;
723 }
724
725
726 /*
727 * restore all registers
728 */
729 static void awacs_restore_all_regs(struct snd_pmac *chip)
730 {
731 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
732 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
733 snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
734 snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
735 if (chip->model == PMAC_SCREAMER) {
736 snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
737 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
738 snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
739 }
740 }
741
742 #ifdef CONFIG_PM
743 static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
744 {
745 snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
746 | MASK_AMUTE | MASK_CMUTE));
747 }
748
749 static void snd_pmac_awacs_resume(struct snd_pmac *chip)
750 {
751 if (of_machine_is_compatible("PowerBook3,1")
752 || of_machine_is_compatible("PowerBook3,2")) {
753 msleep(100);
754 snd_pmac_awacs_write_reg(chip, 1,
755 chip->awacs_reg[1] & ~MASK_PAROUT);
756 msleep(300);
757 }
758
759 awacs_restore_all_regs(chip);
760 if (chip->model == PMAC_SCREAMER) {
761 /* reset power bits in reg 6 */
762 mdelay(5);
763 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
764 }
765 screamer_recalibrate(chip);
766 #ifdef PMAC_AMP_AVAIL
767 if (chip->mixer_data) {
768 struct awacs_amp *amp = chip->mixer_data;
769 awacs_amp_set_vol(amp, 0,
770 amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
771 awacs_amp_set_vol(amp, 1,
772 amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
773 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
774 awacs_amp_set_master(amp, amp->amp_master);
775 }
776 #endif
777 }
778 #endif /* CONFIG_PM */
779
780 #define IS_PM7500 (of_machine_is_compatible("AAPL,7500") \
781 || of_machine_is_compatible("AAPL,8500") \
782 || of_machine_is_compatible("AAPL,9500"))
783 #define IS_PM5500 (of_machine_is_compatible("AAPL,e411"))
784 #define IS_BEIGE (of_machine_is_compatible("AAPL,Gossamer"))
785 #define IS_IMAC1 (of_machine_is_compatible("PowerMac2,1"))
786 #define IS_IMAC2 (of_machine_is_compatible("PowerMac2,2") \
787 || of_machine_is_compatible("PowerMac4,1"))
788 #define IS_G4AGP (of_machine_is_compatible("PowerMac3,1"))
789 #define IS_LOMBARD (of_machine_is_compatible("PowerBook1,1"))
790
791 static int imac1, imac2;
792
793 #ifdef PMAC_SUPPORT_AUTOMUTE
794 /*
795 * auto-mute stuffs
796 */
797 static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip)
798 {
799 return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
800 }
801
802 #ifdef PMAC_AMP_AVAIL
803 static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute)
804 {
805 int vol[2];
806 vol[0] = amp->amp_vol[index][0] & 31;
807 vol[1] = amp->amp_vol[index][1] & 31;
808 if (mute) {
809 vol[0] |= 32;
810 vol[1] |= 32;
811 }
812 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
813 }
814 #endif
815
816 static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify)
817 {
818 if (chip->auto_mute) {
819 #ifdef PMAC_AMP_AVAIL
820 if (chip->mixer_data) {
821 struct awacs_amp *amp = chip->mixer_data;
822 int changed;
823 if (snd_pmac_awacs_detect_headphone(chip)) {
824 changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
825 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
826 } else {
827 changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
828 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
829 }
830 if (do_notify && ! changed)
831 return;
832 } else
833 #endif
834 {
835 int reg = chip->awacs_reg[1]
836 | (MASK_HDMUTE | MASK_SPKMUTE);
837 if (imac1) {
838 reg &= ~MASK_SPKMUTE;
839 reg |= MASK_PAROUT1;
840 } else if (imac2) {
841 reg &= ~MASK_SPKMUTE;
842 reg &= ~MASK_PAROUT1;
843 }
844 if (snd_pmac_awacs_detect_headphone(chip))
845 reg &= ~MASK_HDMUTE;
846 else if (imac1)
847 reg &= ~MASK_PAROUT1;
848 else if (imac2)
849 reg |= MASK_PAROUT1;
850 else
851 reg &= ~MASK_SPKMUTE;
852 if (do_notify && reg == chip->awacs_reg[1])
853 return;
854 snd_pmac_awacs_write_reg(chip, 1, reg);
855 }
856 if (do_notify) {
857 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
858 &chip->master_sw_ctl->id);
859 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
860 &chip->speaker_sw_ctl->id);
861 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
862 &chip->hp_detect_ctl->id);
863 }
864 }
865 }
866 #endif /* PMAC_SUPPORT_AUTOMUTE */
867
868
869 /*
870 * initialize chip
871 */
872 int __devinit
873 snd_pmac_awacs_init(struct snd_pmac *chip)
874 {
875 int pm7500 = IS_PM7500;
876 int pm5500 = IS_PM5500;
877 int beige = IS_BEIGE;
878 int g4agp = IS_G4AGP;
879 int lombard = IS_LOMBARD;
880 int imac;
881 int err, vol;
882 struct snd_kcontrol *vmaster_sw, *vmaster_vol;
883 struct snd_kcontrol *master_vol, *speaker_vol;
884
885 imac1 = IS_IMAC1;
886 imac2 = IS_IMAC2;
887 imac = imac1 || imac2;
888 /* looks like MASK_GAINLINE triggers something, so we set here
889 * as start-up
890 */
891 chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
892 chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
893 if (chip->has_iic || chip->device_id == 0x5 ||
894 /* chip->_device_id == 0x8 || */
895 chip->device_id == 0xb)
896 chip->awacs_reg[1] |= MASK_PAROUT;
897 /* get default volume from nvram */
898 // vol = (~nvram_read_byte(0x1308) & 7) << 1;
899 // vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
900 vol = 0x0f; /* no, on alsa, muted as default */
901 vol = vol + (vol << 6);
902 chip->awacs_reg[2] = vol;
903 chip->awacs_reg[4] = vol;
904 if (chip->model == PMAC_SCREAMER) {
905 chip->awacs_reg[5] = vol;
906 chip->awacs_reg[6] = MASK_MIC_BOOST;
907 chip->awacs_reg[7] = 0;
908 }
909
910 awacs_restore_all_regs(chip);
911 chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
912 screamer_recalibrate(chip);
913
914 chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
915 #ifdef PMAC_AMP_AVAIL
916 if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
917 struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
918 if (! amp)
919 return -ENOMEM;
920 chip->mixer_data = amp;
921 chip->mixer_free = awacs_amp_free;
922 /* mute and zero vol */
923 awacs_amp_set_vol(amp, 0, 63, 63, 0);
924 awacs_amp_set_vol(amp, 1, 63, 63, 0);
925 awacs_amp_set_tone(amp, 7, 7); /* 0 dB */
926 awacs_amp_set_master(amp, 79); /* 0 dB */
927 }
928 #endif /* PMAC_AMP_AVAIL */
929
930 if (chip->hp_stat_mask == 0) {
931 /* set headphone-jack detection bit */
932 switch (chip->model) {
933 case PMAC_AWACS:
934 chip->hp_stat_mask = pm7500 || pm5500 ? MASK_HDPCONN
935 : MASK_LOCONN;
936 break;
937 case PMAC_SCREAMER:
938 switch (chip->device_id) {
939 case 0x08:
940 case 0x0B:
941 chip->hp_stat_mask = imac
942 ? MASK_LOCONN_IMAC |
943 MASK_HDPLCONN_IMAC |
944 MASK_HDPRCONN_IMAC
945 : MASK_HDPCONN;
946 break;
947 case 0x00:
948 case 0x05:
949 chip->hp_stat_mask = MASK_LOCONN;
950 break;
951 default:
952 chip->hp_stat_mask = MASK_HDPCONN;
953 break;
954 }
955 break;
956 default:
957 snd_BUG();
958 break;
959 }
960 }
961
962 /*
963 * build mixers
964 */
965 strcpy(chip->card->mixername, "PowerMac AWACS");
966
967 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
968 snd_pmac_awacs_mixers);
969 if (err < 0)
970 return err;
971 if (beige || g4agp)
972 ;
973 else if (chip->model == PMAC_SCREAMER || pm5500)
974 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
975 snd_pmac_screamer_mixers2);
976 else if (!pm7500)
977 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
978 snd_pmac_awacs_mixers2);
979 if (err < 0)
980 return err;
981 if (pm5500) {
982 err = build_mixers(chip,
983 ARRAY_SIZE(snd_pmac_awacs_mixers2_pmac5500),
984 snd_pmac_awacs_mixers2_pmac5500);
985 if (err < 0)
986 return err;
987 }
988 if (pm7500)
989 err = build_mixers(chip,
990 ARRAY_SIZE(snd_pmac_awacs_mixers_pmac7500),
991 snd_pmac_awacs_mixers_pmac7500);
992 else if (pm5500)
993 err = snd_ctl_add(chip->card,
994 (master_vol = snd_ctl_new1(snd_pmac_awacs_mixers_pmac5500,
995 chip)));
996 else if (beige)
997 err = build_mixers(chip,
998 ARRAY_SIZE(snd_pmac_screamer_mixers_beige),
999 snd_pmac_screamer_mixers_beige);
1000 else if (imac || lombard) {
1001 err = snd_ctl_add(chip->card,
1002 (master_vol = snd_ctl_new1(snd_pmac_screamer_mixers_lo,
1003 chip)));
1004 if (err < 0)
1005 return err;
1006 err = build_mixers(chip,
1007 ARRAY_SIZE(snd_pmac_screamer_mixers_imac),
1008 snd_pmac_screamer_mixers_imac);
1009 } else if (g4agp)
1010 err = build_mixers(chip,
1011 ARRAY_SIZE(snd_pmac_screamer_mixers_g4agp),
1012 snd_pmac_screamer_mixers_g4agp);
1013 else
1014 err = build_mixers(chip,
1015 ARRAY_SIZE(snd_pmac_awacs_mixers_pmac),
1016 snd_pmac_awacs_mixers_pmac);
1017 if (err < 0)
1018 return err;
1019 chip->master_sw_ctl = snd_ctl_new1((pm7500 || imac || g4agp || lombard)
1020 ? &snd_pmac_awacs_master_sw_imac
1021 : pm5500
1022 ? &snd_pmac_awacs_master_sw_pmac5500
1023 : &snd_pmac_awacs_master_sw, chip);
1024 err = snd_ctl_add(chip->card, chip->master_sw_ctl);
1025 if (err < 0)
1026 return err;
1027 #ifdef PMAC_AMP_AVAIL
1028 if (chip->mixer_data) {
1029 /* use amplifier. the signal is connected from route A
1030 * to the amp. the amp has its headphone and speaker
1031 * volumes and mute switches, so we use them instead of
1032 * screamer registers.
1033 * in this case, it seems the route C is not used.
1034 */
1035 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
1036 snd_pmac_awacs_amp_vol);
1037 if (err < 0)
1038 return err;
1039 /* overwrite */
1040 chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw,
1041 chip);
1042 err = snd_ctl_add(chip->card, chip->master_sw_ctl);
1043 if (err < 0)
1044 return err;
1045 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw,
1046 chip);
1047 err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1048 if (err < 0)
1049 return err;
1050 } else
1051 #endif /* PMAC_AMP_AVAIL */
1052 {
1053 /* route A = headphone, route C = speaker */
1054 err = snd_ctl_add(chip->card,
1055 (speaker_vol = snd_ctl_new1(snd_pmac_awacs_speaker_vol,
1056 chip)));
1057 if (err < 0)
1058 return err;
1059 chip->speaker_sw_ctl = snd_ctl_new1(imac1
1060 ? &snd_pmac_awacs_speaker_sw_imac1
1061 : imac2
1062 ? &snd_pmac_awacs_speaker_sw_imac2
1063 : &snd_pmac_awacs_speaker_sw, chip);
1064 err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1065 if (err < 0)
1066 return err;
1067 }
1068
1069 if (pm5500 || imac || lombard) {
1070 vmaster_sw = snd_ctl_make_virtual_master(
1071 "Master Playback Switch", (unsigned int *) NULL);
1072 err = snd_ctl_add_slave_uncached(vmaster_sw,
1073 chip->master_sw_ctl);
1074 if (err < 0)
1075 return err;
1076 err = snd_ctl_add_slave_uncached(vmaster_sw,
1077 chip->speaker_sw_ctl);
1078 if (err < 0)
1079 return err;
1080 err = snd_ctl_add(chip->card, vmaster_sw);
1081 if (err < 0)
1082 return err;
1083 vmaster_vol = snd_ctl_make_virtual_master(
1084 "Master Playback Volume", (unsigned int *) NULL);
1085 err = snd_ctl_add_slave(vmaster_vol, master_vol);
1086 if (err < 0)
1087 return err;
1088 err = snd_ctl_add_slave(vmaster_vol, speaker_vol);
1089 if (err < 0)
1090 return err;
1091 err = snd_ctl_add(chip->card, vmaster_vol);
1092 if (err < 0)
1093 return err;
1094 }
1095
1096 if (beige || g4agp)
1097 err = build_mixers(chip,
1098 ARRAY_SIZE(snd_pmac_screamer_mic_boost_beige),
1099 snd_pmac_screamer_mic_boost_beige);
1100 else if (imac)
1101 err = build_mixers(chip,
1102 ARRAY_SIZE(snd_pmac_screamer_mic_boost_imac),
1103 snd_pmac_screamer_mic_boost_imac);
1104 else if (chip->model == PMAC_SCREAMER)
1105 err = build_mixers(chip,
1106 ARRAY_SIZE(snd_pmac_screamer_mic_boost),
1107 snd_pmac_screamer_mic_boost);
1108 else if (pm7500)
1109 err = build_mixers(chip,
1110 ARRAY_SIZE(snd_pmac_awacs_mic_boost_pmac7500),
1111 snd_pmac_awacs_mic_boost_pmac7500);
1112 else
1113 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
1114 snd_pmac_awacs_mic_boost);
1115 if (err < 0)
1116 return err;
1117
1118 /*
1119 * set lowlevel callbacks
1120 */
1121 chip->set_format = snd_pmac_awacs_set_format;
1122 #ifdef CONFIG_PM
1123 chip->suspend = snd_pmac_awacs_suspend;
1124 chip->resume = snd_pmac_awacs_resume;
1125 #endif
1126 #ifdef PMAC_SUPPORT_AUTOMUTE
1127 err = snd_pmac_add_automute(chip);
1128 if (err < 0)
1129 return err;
1130 chip->detect_headphone = snd_pmac_awacs_detect_headphone;
1131 chip->update_automute = snd_pmac_awacs_update_automute;
1132 snd_pmac_awacs_update_automute(chip, 0); /* update the status only */
1133 #endif
1134 if (chip->model == PMAC_SCREAMER) {
1135 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
1136 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
1137 }
1138
1139 return 0;
1140 }
Tomato firmware and modifications.