2 * PMac AWACS lowlevel functions
4 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
5 * code based on dmasound.c.
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.
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.
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
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>
32 #ifdef CONFIG_ADB_CUDA
33 #define PMAC_AMP_AVAIL
38 unsigned char amp_master;
39 unsigned char amp_vol[2][2];
40 unsigned char amp_tone[2];
43 #define CHECK_CUDA_AMP() (sys_ctrler == SYS_CTRLER_CUDA)
45 #endif /* PMAC_AMP_AVAIL */
48 static void snd_pmac_screamer_wait(struct snd_pmac *chip)
51 while (!(in_le32(&chip->awacs->codec_stat) & MASK_VALID)) {
54 snd_printd("snd_pmac_screamer_wait timeout\n");
61 * write AWACS register
64 snd_pmac_awacs_write(struct snd_pmac *chip, int val)
66 long timeout = 5000000;
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) {
73 snd_printd("snd_pmac_awacs_write timeout\n");
80 snd_pmac_awacs_write_reg(struct snd_pmac *chip, int reg, int val)
82 snd_pmac_awacs_write(chip, val | (reg << 12));
83 chip->awacs_reg[reg] = val;
87 snd_pmac_awacs_write_noreg(struct snd_pmac *chip, int reg, int val)
89 snd_pmac_awacs_write(chip, val | (reg << 12));
93 /* Recalibrate chip */
94 static void screamer_recalibrate(struct snd_pmac *chip)
96 if (chip->model != PMAC_SCREAMER)
99 /* Sorry for the horrible delays... I hope to get that improved
100 * by making the whole PM process asynchronous in a future version
102 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
103 if (chip->manufacturer == 0x1)
104 /* delay for broken crystal part */
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]);
114 #define screamer_recalibrate(chip) /* NOP */
119 * additional callback to set the pcm format
121 static void snd_pmac_awacs_set_format(struct snd_pmac *chip)
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]);
130 * AWACS volume callbacks
133 * volumes: 0-15 stereo
135 static int snd_pmac_awacs_info_volume(struct snd_kcontrol *kcontrol,
136 struct snd_ctl_elem_info *uinfo)
138 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
140 uinfo->value.integer.min = 0;
141 uinfo->value.integer.max = 15;
145 static int snd_pmac_awacs_get_volume(struct snd_kcontrol *kcontrol,
146 struct snd_ctl_elem_value *ucontrol)
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;
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);
160 vol[0] = 0x0f - vol[0];
161 vol[1] = 0x0f - vol[1];
163 ucontrol->value.integer.value[0] = vol[0];
164 ucontrol->value.integer.value[1] = vol[1];
168 static int snd_pmac_awacs_put_volume(struct snd_kcontrol *kcontrol,
169 struct snd_ctl_elem_value *ucontrol)
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;
179 vol[0] = ucontrol->value.integer.value[0];
180 vol[1] = ucontrol->value.integer.value[1];
181 if (vol[0] > 0x0f || vol[1] > 0x0f)
184 vol[0] = 0x0f - vol[0];
185 vol[1] = 0x0f - vol[1];
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;
195 snd_pmac_awacs_write_reg(chip, reg, val);
196 spin_unlock_irqrestore(&chip->reg_lock, flags);
197 return oldval != reg;
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) }
209 * mute master/ogain for AWACS: mono
211 static int snd_pmac_awacs_get_switch(struct snd_kcontrol *kcontrol,
212 struct snd_ctl_elem_value *ucontrol)
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;
221 spin_lock_irqsave(&chip->reg_lock, flags);
222 val = (chip->awacs_reg[reg] >> shift) & 1;
223 spin_unlock_irqrestore(&chip->reg_lock, flags);
226 ucontrol->value.integer.value[0] = val;
230 static int snd_pmac_awacs_put_switch(struct snd_kcontrol *kcontrol,
231 struct snd_ctl_elem_value *ucontrol)
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;
241 spin_lock_irqsave(&chip->reg_lock, flags);
242 val = chip->awacs_reg[reg] & ~mask;
243 if (ucontrol->value.integer.value[0] != invert)
245 changed = chip->awacs_reg[reg] != val;
247 snd_pmac_awacs_write_reg(chip, reg, val);
248 spin_unlock_irqrestore(&chip->reg_lock, flags);
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) }
260 #ifdef PMAC_AMP_AVAIL
262 * controls for perch/whisper extension cards, e.g. G3 desktop
264 * TDA7433 connected via i2c address 0x45 (= 0x8a),
265 * accessed through cuda
267 static void awacs_set_cuda(int reg, int val)
269 struct adb_request req;
270 cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC, 0x8a, reg, val);
271 while (! req.complete)
276 * level = 0 - 14, 7 = 0 dB
278 static void awacs_amp_set_tone(struct awacs_amp *amp, int bass, int treble)
280 amp->amp_tone[0] = bass;
281 amp->amp_tone[1] = treble;
283 bass = (14 - bass) + 8;
285 treble = (14 - treble) + 8;
286 awacs_set_cuda(2, (bass << 4) | treble);
290 * vol = 0 - 31 (attenuation), 32 = mute bit, stereo
292 static int awacs_amp_set_vol(struct awacs_amp *amp, int index, int lvol, int rvol,
295 if (do_check && amp->amp_vol[index][0] == lvol &&
296 amp->amp_vol[index][1] == rvol)
298 awacs_set_cuda(3 + index, lvol);
299 awacs_set_cuda(5 + index, rvol);
300 amp->amp_vol[index][0] = lvol;
301 amp->amp_vol[index][1] = rvol;
306 * 0 = -79 dB, 79 = 0 dB, 99 = +20 dB
308 static void awacs_amp_set_master(struct awacs_amp *amp, int vol)
310 amp->amp_master = vol;
312 vol = 32 + (79 - vol);
314 vol = 32 - (vol - 79);
315 awacs_set_cuda(1, vol);
318 static void awacs_amp_free(struct snd_pmac *chip)
320 struct awacs_amp *amp = chip->mixer_data;
321 snd_assert(amp, return);
323 chip->mixer_data = NULL;
324 chip->mixer_free = NULL;
331 static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol,
332 struct snd_ctl_elem_info *uinfo)
334 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
336 uinfo->value.integer.min = 0;
337 uinfo->value.integer.max = 31;
341 static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol,
342 struct snd_ctl_elem_value *ucontrol)
344 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
345 int index = kcontrol->private_value;
346 struct awacs_amp *amp = chip->mixer_data;
347 snd_assert(amp, return -EINVAL);
348 snd_assert(index >= 0 && index <= 1, return -EINVAL);
349 ucontrol->value.integer.value[0] = 31 - (amp->amp_vol[index][0] & 31);
350 ucontrol->value.integer.value[1] = 31 - (amp->amp_vol[index][1] & 31);
354 static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol,
355 struct snd_ctl_elem_value *ucontrol)
357 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
358 int index = kcontrol->private_value;
360 struct awacs_amp *amp = chip->mixer_data;
361 snd_assert(amp, return -EINVAL);
362 snd_assert(index >= 0 && index <= 1, return -EINVAL);
364 vol[0] = (31 - (ucontrol->value.integer.value[0] & 31)) | (amp->amp_vol[index][0] & 32);
365 vol[1] = (31 - (ucontrol->value.integer.value[1] & 31)) | (amp->amp_vol[index][1] & 32);
366 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
369 static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol,
370 struct snd_ctl_elem_value *ucontrol)
372 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
373 int index = kcontrol->private_value;
374 struct awacs_amp *amp = chip->mixer_data;
375 snd_assert(amp, return -EINVAL);
376 snd_assert(index >= 0 && index <= 1, return -EINVAL);
377 ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32) ? 0 : 1;
378 ucontrol->value.integer.value[1] = (amp->amp_vol[index][1] & 32) ? 0 : 1;
382 static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol,
383 struct snd_ctl_elem_value *ucontrol)
385 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
386 int index = kcontrol->private_value;
388 struct awacs_amp *amp = chip->mixer_data;
389 snd_assert(amp, return -EINVAL);
390 snd_assert(index >= 0 && index <= 1, return -EINVAL);
392 vol[0] = (ucontrol->value.integer.value[0] ? 0 : 32) | (amp->amp_vol[index][0] & 31);
393 vol[1] = (ucontrol->value.integer.value[1] ? 0 : 32) | (amp->amp_vol[index][1] & 31);
394 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
397 static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol,
398 struct snd_ctl_elem_info *uinfo)
400 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
402 uinfo->value.integer.min = 0;
403 uinfo->value.integer.max = 14;
407 static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol,
408 struct snd_ctl_elem_value *ucontrol)
410 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
411 int index = kcontrol->private_value;
412 struct awacs_amp *amp = chip->mixer_data;
413 snd_assert(amp, return -EINVAL);
414 snd_assert(index >= 0 && index <= 1, return -EINVAL);
415 ucontrol->value.integer.value[0] = amp->amp_tone[index];
419 static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol,
420 struct snd_ctl_elem_value *ucontrol)
422 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
423 int index = kcontrol->private_value;
424 struct awacs_amp *amp = chip->mixer_data;
426 snd_assert(amp, return -EINVAL);
427 snd_assert(index >= 0 && index <= 1, return -EINVAL);
428 val = ucontrol->value.integer.value[0];
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]);
439 static int snd_pmac_awacs_info_master_amp(struct snd_kcontrol *kcontrol,
440 struct snd_ctl_elem_info *uinfo)
442 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
444 uinfo->value.integer.min = 0;
445 uinfo->value.integer.max = 99;
449 static int snd_pmac_awacs_get_master_amp(struct snd_kcontrol *kcontrol,
450 struct snd_ctl_elem_value *ucontrol)
452 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
453 struct awacs_amp *amp = chip->mixer_data;
454 snd_assert(amp, return -EINVAL);
455 ucontrol->value.integer.value[0] = amp->amp_master;
459 static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol,
460 struct snd_ctl_elem_value *ucontrol)
462 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
463 struct awacs_amp *amp = chip->mixer_data;
465 snd_assert(amp, return -EINVAL);
466 val = ucontrol->value.integer.value[0];
469 if (val != amp->amp_master) {
470 amp->amp_master = val;
471 awacs_amp_set_master(amp, amp->amp_master);
480 static struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] __initdata = {
481 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
482 .name = "PC 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,
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,
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,
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,
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,
517 static struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw __initdata = {
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,
526 static struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw __initdata = {
527 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
528 .name = "PC 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,
535 #endif /* PMAC_AMP_AVAIL */
539 * mic boost for screamer
541 static int snd_pmac_screamer_mic_boost_info(struct snd_kcontrol *kcontrol,
542 struct snd_ctl_elem_info *uinfo)
544 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
546 uinfo->value.integer.min = 0;
547 uinfo->value.integer.max = 3;
551 static int snd_pmac_screamer_mic_boost_get(struct snd_kcontrol *kcontrol,
552 struct snd_ctl_elem_value *ucontrol)
554 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
558 spin_lock_irqsave(&chip->reg_lock, flags);
559 if (chip->awacs_reg[6] & MASK_MIC_BOOST)
561 if (chip->awacs_reg[0] & MASK_GAINLINE)
563 spin_unlock_irqrestore(&chip->reg_lock, flags);
564 ucontrol->value.integer.value[0] = val;
568 static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol,
569 struct snd_ctl_elem_value *ucontrol)
571 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
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);
587 if (val6 != chip->awacs_reg[6]) {
588 snd_pmac_awacs_write_reg(chip, 6, val6);
591 spin_unlock_irqrestore(&chip->reg_lock, flags);
596 * lists of mixer elements
598 static struct snd_kcontrol_new snd_pmac_awacs_mixers[] __initdata = {
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), */
604 static struct snd_kcontrol_new snd_pmac_screamer_mixers_beige[] __initdata = {
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),
611 static struct snd_kcontrol_new snd_pmac_screamer_mixers_imac[] __initdata = {
612 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
613 AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
614 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
617 static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac7500[] __initdata = {
618 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
619 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
620 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
623 static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac[] __initdata = {
624 AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
625 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
628 /* FIXME: is this correct order?
629 * screamer (powerbook G3 pismo) seems to have different bits...
631 static struct snd_kcontrol_new snd_pmac_awacs_mixers2[] __initdata = {
632 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0),
633 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0),
636 static struct snd_kcontrol_new snd_pmac_screamer_mixers2[] __initdata = {
637 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
638 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
641 static struct snd_kcontrol_new snd_pmac_awacs_master_sw __initdata =
642 AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
644 static struct snd_kcontrol_new snd_pmac_awacs_master_sw_imac __initdata =
645 AWACS_SWITCH("Line out Playback Switch", 1, SHIFT_HDMUTE, 1);
647 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __initdata = {
648 AWACS_SWITCH("Mic Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
651 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __initdata = {
652 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
653 .name = "Mic Boost Capture Volume",
654 .info = snd_pmac_screamer_mic_boost_info,
655 .get = snd_pmac_screamer_mic_boost_get,
656 .put = snd_pmac_screamer_mic_boost_put,
660 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost_pmac7500[] __initdata =
662 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
665 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_beige[] __initdata =
667 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
668 AWACS_SWITCH("CD Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
671 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_imac[] __initdata =
673 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
674 AWACS_SWITCH("Mic Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
677 static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __initdata = {
678 AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1),
681 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __initdata =
682 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
684 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac __initdata =
685 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
689 * add new mixer elements to the card
691 static int build_mixers(struct snd_pmac *chip, int nums, struct snd_kcontrol_new *mixers)
695 for (i = 0; i < nums; i++) {
696 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip))) < 0)
704 * restore all registers
706 static void awacs_restore_all_regs(struct snd_pmac *chip)
708 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
709 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
710 snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
711 snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
712 if (chip->model == PMAC_SCREAMER) {
713 snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
714 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
715 snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
720 static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
722 snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
723 | MASK_AMUTE | MASK_CMUTE));
726 static void snd_pmac_awacs_resume(struct snd_pmac *chip)
728 if (machine_is_compatible("PowerBook3,1")
729 || machine_is_compatible("PowerBook3,2")) {
731 snd_pmac_awacs_write_reg(chip, 1,
732 chip->awacs_reg[1] & ~MASK_PAROUT);
736 awacs_restore_all_regs(chip);
737 if (chip->model == PMAC_SCREAMER) {
738 /* reset power bits in reg 6 */
740 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
742 screamer_recalibrate(chip);
743 #ifdef PMAC_AMP_AVAIL
744 if (chip->mixer_data) {
745 struct awacs_amp *amp = chip->mixer_data;
746 awacs_amp_set_vol(amp, 0, amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
747 awacs_amp_set_vol(amp, 1, amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
748 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
749 awacs_amp_set_master(amp, amp->amp_master);
753 #endif /* CONFIG_PM */
755 #define IS_PM7500 (machine_is_compatible("AAPL,7500"))
756 #define IS_BEIGE (machine_is_compatible("AAPL,Gossamer"))
757 #define IS_IMAC (machine_is_compatible("PowerMac2,1") \
758 || machine_is_compatible("PowerMac2,2") \
759 || machine_is_compatible("PowerMac4,1"))
763 #ifdef PMAC_SUPPORT_AUTOMUTE
767 static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip)
769 return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
772 #ifdef PMAC_AMP_AVAIL
773 static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute)
776 vol[0] = amp->amp_vol[index][0] & 31;
777 vol[1] = amp->amp_vol[index][1] & 31;
782 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
786 static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify)
788 if (chip->auto_mute) {
789 #ifdef PMAC_AMP_AVAIL
790 if (chip->mixer_data) {
791 struct awacs_amp *amp = chip->mixer_data;
793 if (snd_pmac_awacs_detect_headphone(chip)) {
794 changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
795 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
797 changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
798 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
800 if (do_notify && ! changed)
805 int reg = chip->awacs_reg[1]
806 | (MASK_HDMUTE | MASK_SPKMUTE);
808 reg &= ~MASK_SPKMUTE;
809 reg &= ~MASK_PAROUT1;
811 if (snd_pmac_awacs_detect_headphone(chip))
816 reg &= ~MASK_SPKMUTE;
817 if (do_notify && reg == chip->awacs_reg[1])
819 snd_pmac_awacs_write_reg(chip, 1, reg);
822 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
823 &chip->master_sw_ctl->id);
824 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
825 &chip->speaker_sw_ctl->id);
826 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
827 &chip->hp_detect_ctl->id);
831 #endif /* PMAC_SUPPORT_AUTOMUTE */
838 snd_pmac_awacs_init(struct snd_pmac *chip)
840 int pm7500 = IS_PM7500;
841 int beige = IS_BEIGE;
845 /* looks like MASK_GAINLINE triggers something, so we set here
848 chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
849 chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
850 /* FIXME: Only machines with external SRS module need MASK_PAROUT */
851 if (chip->has_iic || chip->device_id == 0x5 ||
852 /*chip->_device_id == 0x8 || */
853 chip->device_id == 0xb)
854 chip->awacs_reg[1] |= MASK_PAROUT;
855 /* get default volume from nvram */
856 // vol = (~nvram_read_byte(0x1308) & 7) << 1;
857 // vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
858 vol = 0x0f; /* no, on alsa, muted as default */
859 vol = vol + (vol << 6);
860 chip->awacs_reg[2] = vol;
861 chip->awacs_reg[4] = vol;
862 if (chip->model == PMAC_SCREAMER) {
863 chip->awacs_reg[5] = vol; /* FIXME: screamer has loopthru vol control */
864 chip->awacs_reg[6] = MASK_MIC_BOOST; /* FIXME: maybe should be vol << 3 for PCMCIA speaker */
865 chip->awacs_reg[7] = 0;
868 awacs_restore_all_regs(chip);
869 chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
870 screamer_recalibrate(chip);
872 chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
873 #ifdef PMAC_AMP_AVAIL
874 if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
875 struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
878 chip->mixer_data = amp;
879 chip->mixer_free = awacs_amp_free;
880 awacs_amp_set_vol(amp, 0, 63, 63, 0); /* mute and zero vol */
881 awacs_amp_set_vol(amp, 1, 63, 63, 0);
882 awacs_amp_set_tone(amp, 7, 7); /* 0 dB */
883 awacs_amp_set_master(amp, 79); /* 0 dB */
885 #endif /* PMAC_AMP_AVAIL */
887 if (chip->hp_stat_mask == 0) {
888 /* set headphone-jack detection bit */
889 switch (chip->model) {
891 chip->hp_stat_mask = pm7500 ? MASK_HDPCONN
895 switch (chip->device_id) {
898 chip->hp_stat_mask = imac
906 chip->hp_stat_mask = MASK_LOCONN;
909 chip->hp_stat_mask = MASK_HDPCONN;
922 strcpy(chip->card->mixername, "PowerMac AWACS");
924 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
925 snd_pmac_awacs_mixers)) < 0)
929 else if (chip->model == PMAC_SCREAMER)
930 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
931 snd_pmac_screamer_mixers2);
933 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
934 snd_pmac_awacs_mixers2);
938 err = build_mixers(chip,
939 ARRAY_SIZE(snd_pmac_awacs_mixers_pmac7500),
940 snd_pmac_awacs_mixers_pmac7500);
942 err = build_mixers(chip,
943 ARRAY_SIZE(snd_pmac_screamer_mixers_beige),
944 snd_pmac_screamer_mixers_beige);
946 err = build_mixers(chip,
947 ARRAY_SIZE(snd_pmac_screamer_mixers_imac),
948 snd_pmac_screamer_mixers_imac);
950 err = build_mixers(chip,
951 ARRAY_SIZE(snd_pmac_awacs_mixers_pmac),
952 snd_pmac_awacs_mixers_pmac);
955 chip->master_sw_ctl = snd_ctl_new1((pm7500 || imac)
956 ? &snd_pmac_awacs_master_sw_imac
957 : &snd_pmac_awacs_master_sw, chip);
958 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
960 #ifdef PMAC_AMP_AVAIL
961 if (chip->mixer_data) {
962 /* use amplifier. the signal is connected from route A
963 * to the amp. the amp has its headphone and speaker
964 * volumes and mute switches, so we use them instead of
965 * screamer registers.
966 * in this case, it seems the route C is not used.
968 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
969 snd_pmac_awacs_amp_vol)) < 0)
972 chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw, chip);
973 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
975 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw, chip);
976 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
979 #endif /* PMAC_AMP_AVAIL */
981 /* route A = headphone, route C = speaker */
982 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_speaker_vol),
983 snd_pmac_awacs_speaker_vol)) < 0)
985 chip->speaker_sw_ctl = snd_ctl_new1(imac
986 ? &snd_pmac_awacs_speaker_sw_imac
987 : &snd_pmac_awacs_speaker_sw, chip);
988 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
993 err = build_mixers(chip,
994 ARRAY_SIZE(snd_pmac_screamer_mic_boost_beige),
995 snd_pmac_screamer_mic_boost_beige);
997 err = build_mixers(chip,
998 ARRAY_SIZE(snd_pmac_screamer_mic_boost_imac),
999 snd_pmac_screamer_mic_boost_imac);
1000 else if (chip->model == PMAC_SCREAMER)
1001 err = build_mixers(chip,
1002 ARRAY_SIZE(snd_pmac_screamer_mic_boost),
1003 snd_pmac_screamer_mic_boost);
1005 err = build_mixers(chip,
1006 ARRAY_SIZE(snd_pmac_awacs_mic_boost_pmac7500),
1007 snd_pmac_awacs_mic_boost_pmac7500);
1009 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
1010 snd_pmac_awacs_mic_boost);
1015 * set lowlevel callbacks
1017 chip->set_format = snd_pmac_awacs_set_format;
1019 chip->suspend = snd_pmac_awacs_suspend;
1020 chip->resume = snd_pmac_awacs_resume;
1022 #ifdef PMAC_SUPPORT_AUTOMUTE
1023 if ((err = snd_pmac_add_automute(chip)) < 0)
1025 chip->detect_headphone = snd_pmac_awacs_detect_headphone;
1026 chip->update_automute = snd_pmac_awacs_update_automute;
1027 snd_pmac_awacs_update_automute(chip, 0); /* update the status only */
1029 if (chip->model == PMAC_SCREAMER) {
1030 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
1031 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);