xref: /openbmc/linux/sound/ppc/awacs.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
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 <sound/driver.h>
24 #include <asm/io.h>
25 #include <asm/nvram.h>
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <sound/core.h>
30 #include "pmac.h"
31 
32 
33 #ifdef CONFIG_ADB_CUDA
34 #define PMAC_AMP_AVAIL
35 #endif
36 
37 #ifdef PMAC_AMP_AVAIL
38 typedef struct awacs_amp {
39 	unsigned char amp_master;
40 	unsigned char amp_vol[2][2];
41 	unsigned char amp_tone[2];
42 } awacs_amp_t;
43 
44 #define CHECK_CUDA_AMP() (sys_ctrler == SYS_CTRLER_CUDA)
45 
46 #endif /* PMAC_AMP_AVAIL */
47 
48 
49 static void snd_pmac_screamer_wait(pmac_t *chip)
50 {
51 	long timeout = 2000;
52 	while (!(in_le32(&chip->awacs->codec_stat) & MASK_VALID)) {
53 		mdelay(1);
54 		if (! --timeout) {
55 			snd_printd("snd_pmac_screamer_wait timeout\n");
56 			break;
57 		}
58 	}
59 }
60 
61 /*
62  * write AWACS register
63  */
64 static void
65 snd_pmac_awacs_write(pmac_t *chip, int val)
66 {
67 	long timeout = 5000000;
68 
69 	if (chip->model == PMAC_SCREAMER)
70 		snd_pmac_screamer_wait(chip);
71 	out_le32(&chip->awacs->codec_ctrl, val | (chip->subframe << 22));
72 	while (in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) {
73 		if (! --timeout) {
74 			snd_printd("snd_pmac_awacs_write timeout\n");
75 			break;
76 		}
77 	}
78 }
79 
80 static void
81 snd_pmac_awacs_write_reg(pmac_t *chip, int reg, int val)
82 {
83 	snd_pmac_awacs_write(chip, val | (reg << 12));
84 	chip->awacs_reg[reg] = val;
85 }
86 
87 static void
88 snd_pmac_awacs_write_noreg(pmac_t *chip, int reg, int val)
89 {
90 	snd_pmac_awacs_write(chip, val | (reg << 12));
91 }
92 
93 #ifdef CONFIG_PM
94 /* Recalibrate chip */
95 static void screamer_recalibrate(pmac_t *chip)
96 {
97 	if (chip->model != PMAC_SCREAMER)
98 		return;
99 
100 	/* Sorry for the horrible delays... I hope to get that improved
101 	 * by making the whole PM process asynchronous in a future version
102 	 */
103 	snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
104 	if (chip->manufacturer == 0x1)
105 		/* delay for broken crystal part */
106 		msleep(750);
107 	snd_pmac_awacs_write_noreg(chip, 1,
108 				   chip->awacs_reg[1] | MASK_RECALIBRATE | 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(pmac_t *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(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
136 {
137 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
138 	uinfo->count = 2;
139 	uinfo->value.integer.min = 0;
140 	uinfo->value.integer.max = 15;
141 	return 0;
142 }
143 
144 static int snd_pmac_awacs_get_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
145 {
146 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
147 	int reg = kcontrol->private_value & 0xff;
148 	int lshift = (kcontrol->private_value >> 8) & 0xff;
149 	int inverted = (kcontrol->private_value >> 16) & 1;
150 	unsigned long flags;
151 	int vol[2];
152 
153 	spin_lock_irqsave(&chip->reg_lock, flags);
154 	vol[0] = (chip->awacs_reg[reg] >> lshift) & 0xf;
155 	vol[1] = chip->awacs_reg[reg] & 0xf;
156 	spin_unlock_irqrestore(&chip->reg_lock, flags);
157 	if (inverted) {
158 		vol[0] = 0x0f - vol[0];
159 		vol[1] = 0x0f - vol[1];
160 	}
161 	ucontrol->value.integer.value[0] = vol[0];
162 	ucontrol->value.integer.value[1] = vol[1];
163 	return 0;
164 }
165 
166 static int snd_pmac_awacs_put_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
167 {
168 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
169 	int reg = kcontrol->private_value & 0xff;
170 	int lshift = (kcontrol->private_value >> 8) & 0xff;
171 	int inverted = (kcontrol->private_value >> 16) & 1;
172 	int val, oldval;
173 	unsigned long flags;
174 	int vol[2];
175 
176 	vol[0] = ucontrol->value.integer.value[0];
177 	vol[1] = ucontrol->value.integer.value[1];
178 	if (inverted) {
179 		vol[0] = 0x0f - vol[0];
180 		vol[1] = 0x0f - vol[1];
181 	}
182 	vol[0] &= 0x0f;
183 	vol[1] &= 0x0f;
184 	spin_lock_irqsave(&chip->reg_lock, flags);
185 	oldval = chip->awacs_reg[reg];
186 	val = oldval & ~(0xf | (0xf << lshift));
187 	val |= vol[0] << lshift;
188 	val |= vol[1];
189 	if (oldval != val)
190 		snd_pmac_awacs_write_reg(chip, reg, val);
191 	spin_unlock_irqrestore(&chip->reg_lock, flags);
192 	return oldval != reg;
193 }
194 
195 
196 #define AWACS_VOLUME(xname, xreg, xshift, xinverted) \
197 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
198   .info = snd_pmac_awacs_info_volume, \
199   .get = snd_pmac_awacs_get_volume, \
200   .put = snd_pmac_awacs_put_volume, \
201   .private_value = (xreg) | ((xshift) << 8) | ((xinverted) << 16) }
202 
203 /*
204  * mute master/ogain for AWACS: mono
205  */
206 static int snd_pmac_awacs_get_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
207 {
208 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
209 	int reg = kcontrol->private_value & 0xff;
210 	int shift = (kcontrol->private_value >> 8) & 0xff;
211 	int invert = (kcontrol->private_value >> 16) & 1;
212 	int val;
213 	unsigned long flags;
214 
215 	spin_lock_irqsave(&chip->reg_lock, flags);
216 	val = (chip->awacs_reg[reg] >> shift) & 1;
217 	spin_unlock_irqrestore(&chip->reg_lock, flags);
218 	if (invert)
219 		val = 1 - val;
220 	ucontrol->value.integer.value[0] = val;
221 	return 0;
222 }
223 
224 static int snd_pmac_awacs_put_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
225 {
226 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
227 	int reg = kcontrol->private_value & 0xff;
228 	int shift = (kcontrol->private_value >> 8) & 0xff;
229 	int invert = (kcontrol->private_value >> 16) & 1;
230 	int mask = 1 << shift;
231 	int val, changed;
232 	unsigned long flags;
233 
234 	spin_lock_irqsave(&chip->reg_lock, flags);
235 	val = chip->awacs_reg[reg] & ~mask;
236 	if (ucontrol->value.integer.value[0] != invert)
237 		val |= mask;
238 	changed = chip->awacs_reg[reg] != val;
239 	if (changed)
240 		snd_pmac_awacs_write_reg(chip, reg, val);
241 	spin_unlock_irqrestore(&chip->reg_lock, flags);
242 	return changed;
243 }
244 
245 #define AWACS_SWITCH(xname, xreg, xshift, xinvert) \
246 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
247   .info = snd_pmac_boolean_mono_info, \
248   .get = snd_pmac_awacs_get_switch, \
249   .put = snd_pmac_awacs_put_switch, \
250   .private_value = (xreg) | ((xshift) << 8) | ((xinvert) << 16) }
251 
252 
253 #ifdef PMAC_AMP_AVAIL
254 /*
255  * controls for perch/whisper extension cards, e.g. G3 desktop
256  *
257  * TDA7433 connected via i2c address 0x45 (= 0x8a),
258  * accessed through cuda
259  */
260 static void awacs_set_cuda(int reg, int val)
261 {
262 	struct adb_request req;
263 	cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC, 0x8a, reg, val);
264 	while (! req.complete)
265 		cuda_poll();
266 }
267 
268 /*
269  * level = 0 - 14, 7 = 0 dB
270  */
271 static void awacs_amp_set_tone(awacs_amp_t *amp, int bass, int treble)
272 {
273 	amp->amp_tone[0] = bass;
274 	amp->amp_tone[1] = treble;
275 	if (bass > 7)
276 		bass = (14 - bass) + 8;
277 	if (treble > 7)
278 		treble = (14 - treble) + 8;
279 	awacs_set_cuda(2, (bass << 4) | treble);
280 }
281 
282 /*
283  * vol = 0 - 31 (attenuation), 32 = mute bit, stereo
284  */
285 static int awacs_amp_set_vol(awacs_amp_t *amp, int index, int lvol, int rvol, int do_check)
286 {
287 	if (do_check && amp->amp_vol[index][0] == lvol &&
288 	    amp->amp_vol[index][1] == rvol)
289 		return 0;
290 	awacs_set_cuda(3 + index, lvol);
291 	awacs_set_cuda(5 + index, rvol);
292 	amp->amp_vol[index][0] = lvol;
293 	amp->amp_vol[index][1] = rvol;
294 	return 1;
295 }
296 
297 /*
298  * 0 = -79 dB, 79 = 0 dB, 99 = +20 dB
299  */
300 static void awacs_amp_set_master(awacs_amp_t *amp, int vol)
301 {
302 	amp->amp_master = vol;
303 	if (vol <= 79)
304 		vol = 32 + (79 - vol);
305 	else
306 		vol = 32 - (vol - 79);
307 	awacs_set_cuda(1, vol);
308 }
309 
310 static void awacs_amp_free(pmac_t *chip)
311 {
312 	awacs_amp_t *amp = chip->mixer_data;
313 	snd_assert(amp, return);
314 	kfree(amp);
315 	chip->mixer_data = NULL;
316 	chip->mixer_free = NULL;
317 }
318 
319 
320 /*
321  * mixer controls
322  */
323 static int snd_pmac_awacs_info_volume_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
324 {
325 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
326 	uinfo->count = 2;
327 	uinfo->value.integer.min = 0;
328 	uinfo->value.integer.max = 31;
329 	return 0;
330 }
331 
332 static int snd_pmac_awacs_get_volume_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
333 {
334 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
335 	int index = kcontrol->private_value;
336 	awacs_amp_t *amp = chip->mixer_data;
337 	snd_assert(amp, return -EINVAL);
338 	snd_assert(index >= 0 && index <= 1, return -EINVAL);
339 	ucontrol->value.integer.value[0] = 31 - (amp->amp_vol[index][0] & 31);
340 	ucontrol->value.integer.value[1] = 31 - (amp->amp_vol[index][1] & 31);
341 	return 0;
342 }
343 
344 static int snd_pmac_awacs_put_volume_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
345 {
346 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
347 	int index = kcontrol->private_value;
348 	int vol[2];
349 	awacs_amp_t *amp = chip->mixer_data;
350 	snd_assert(amp, return -EINVAL);
351 	snd_assert(index >= 0 && index <= 1, return -EINVAL);
352 
353 	vol[0] = (31 - (ucontrol->value.integer.value[0] & 31)) | (amp->amp_vol[index][0] & 32);
354 	vol[1] = (31 - (ucontrol->value.integer.value[1] & 31)) | (amp->amp_vol[index][1] & 32);
355 	return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
356 }
357 
358 static int snd_pmac_awacs_get_switch_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
359 {
360 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
361 	int index = kcontrol->private_value;
362 	awacs_amp_t *amp = chip->mixer_data;
363 	snd_assert(amp, return -EINVAL);
364 	snd_assert(index >= 0 && index <= 1, return -EINVAL);
365 	ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32) ? 0 : 1;
366 	ucontrol->value.integer.value[1] = (amp->amp_vol[index][1] & 32) ? 0 : 1;
367 	return 0;
368 }
369 
370 static int snd_pmac_awacs_put_switch_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
371 {
372 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
373 	int index = kcontrol->private_value;
374 	int vol[2];
375 	awacs_amp_t *amp = chip->mixer_data;
376 	snd_assert(amp, return -EINVAL);
377 	snd_assert(index >= 0 && index <= 1, return -EINVAL);
378 
379 	vol[0] = (ucontrol->value.integer.value[0] ? 0 : 32) | (amp->amp_vol[index][0] & 31);
380 	vol[1] = (ucontrol->value.integer.value[1] ? 0 : 32) | (amp->amp_vol[index][1] & 31);
381 	return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
382 }
383 
384 static int snd_pmac_awacs_info_tone_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
385 {
386 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
387 	uinfo->count = 1;
388 	uinfo->value.integer.min = 0;
389 	uinfo->value.integer.max = 14;
390 	return 0;
391 }
392 
393 static int snd_pmac_awacs_get_tone_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
394 {
395 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
396 	int index = kcontrol->private_value;
397 	awacs_amp_t *amp = chip->mixer_data;
398 	snd_assert(amp, return -EINVAL);
399 	snd_assert(index >= 0 && index <= 1, return -EINVAL);
400 	ucontrol->value.integer.value[0] = amp->amp_tone[index];
401 	return 0;
402 }
403 
404 static int snd_pmac_awacs_put_tone_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
405 {
406 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
407 	int index = kcontrol->private_value;
408 	awacs_amp_t *amp = chip->mixer_data;
409 	snd_assert(amp, return -EINVAL);
410 	snd_assert(index >= 0 && index <= 1, return -EINVAL);
411 	if (ucontrol->value.integer.value[0] != amp->amp_tone[index]) {
412 		amp->amp_tone[index] = ucontrol->value.integer.value[0];
413 		awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
414 		return 1;
415 	}
416 	return 0;
417 }
418 
419 static int snd_pmac_awacs_info_master_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
420 {
421 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
422 	uinfo->count = 1;
423 	uinfo->value.integer.min = 0;
424 	uinfo->value.integer.max = 99;
425 	return 0;
426 }
427 
428 static int snd_pmac_awacs_get_master_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
429 {
430 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
431 	awacs_amp_t *amp = chip->mixer_data;
432 	snd_assert(amp, return -EINVAL);
433 	ucontrol->value.integer.value[0] = amp->amp_master;
434 	return 0;
435 }
436 
437 static int snd_pmac_awacs_put_master_amp(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
438 {
439 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
440 	awacs_amp_t *amp = chip->mixer_data;
441 	snd_assert(amp, return -EINVAL);
442 	if (ucontrol->value.integer.value[0] != amp->amp_master) {
443 		amp->amp_master = ucontrol->value.integer.value[0];
444 		awacs_amp_set_master(amp, amp->amp_master);
445 		return 1;
446 	}
447 	return 0;
448 }
449 
450 #define AMP_CH_SPK	0
451 #define AMP_CH_HD	1
452 
453 static snd_kcontrol_new_t snd_pmac_awacs_amp_vol[] __initdata = {
454 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
455 	  .name = "PC Speaker Playback Volume",
456 	  .info = snd_pmac_awacs_info_volume_amp,
457 	  .get = snd_pmac_awacs_get_volume_amp,
458 	  .put = snd_pmac_awacs_put_volume_amp,
459 	  .private_value = AMP_CH_SPK,
460 	},
461 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
462 	  .name = "Headphone Playback Volume",
463 	  .info = snd_pmac_awacs_info_volume_amp,
464 	  .get = snd_pmac_awacs_get_volume_amp,
465 	  .put = snd_pmac_awacs_put_volume_amp,
466 	  .private_value = AMP_CH_HD,
467 	},
468 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
469 	  .name = "Tone Control - Bass",
470 	  .info = snd_pmac_awacs_info_tone_amp,
471 	  .get = snd_pmac_awacs_get_tone_amp,
472 	  .put = snd_pmac_awacs_put_tone_amp,
473 	  .private_value = 0,
474 	},
475 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
476 	  .name = "Tone Control - Treble",
477 	  .info = snd_pmac_awacs_info_tone_amp,
478 	  .get = snd_pmac_awacs_get_tone_amp,
479 	  .put = snd_pmac_awacs_put_tone_amp,
480 	  .private_value = 1,
481 	},
482 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
483 	  .name = "Amp Master Playback Volume",
484 	  .info = snd_pmac_awacs_info_master_amp,
485 	  .get = snd_pmac_awacs_get_master_amp,
486 	  .put = snd_pmac_awacs_put_master_amp,
487 	},
488 };
489 
490 static snd_kcontrol_new_t snd_pmac_awacs_amp_hp_sw __initdata = {
491 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
492 	.name = "Headphone Playback Switch",
493 	.info = snd_pmac_boolean_stereo_info,
494 	.get = snd_pmac_awacs_get_switch_amp,
495 	.put = snd_pmac_awacs_put_switch_amp,
496 	.private_value = AMP_CH_HD,
497 };
498 
499 static snd_kcontrol_new_t snd_pmac_awacs_amp_spk_sw __initdata = {
500 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
501 	.name = "PC Speaker Playback Switch",
502 	.info = snd_pmac_boolean_stereo_info,
503 	.get = snd_pmac_awacs_get_switch_amp,
504 	.put = snd_pmac_awacs_put_switch_amp,
505 	.private_value = AMP_CH_SPK,
506 };
507 
508 #endif /* PMAC_AMP_AVAIL */
509 
510 
511 /*
512  * mic boost for screamer
513  */
514 static int snd_pmac_screamer_mic_boost_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
515 {
516 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
517 	uinfo->count = 1;
518 	uinfo->value.integer.min = 0;
519 	uinfo->value.integer.max = 2;
520 	return 0;
521 }
522 
523 static int snd_pmac_screamer_mic_boost_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
524 {
525 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
526 	int val;
527 	unsigned long flags;
528 
529 	spin_lock_irqsave(&chip->reg_lock, flags);
530 	if (chip->awacs_reg[6] & MASK_MIC_BOOST)
531 		val = 2;
532 	else if (chip->awacs_reg[0] & MASK_GAINLINE)
533 		val = 1;
534 	else
535 		val = 0;
536 	spin_unlock_irqrestore(&chip->reg_lock, flags);
537 	ucontrol->value.integer.value[0] = val;
538 	return 0;
539 }
540 
541 static int snd_pmac_screamer_mic_boost_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
542 {
543 	pmac_t *chip = snd_kcontrol_chip(kcontrol);
544 	int changed = 0;
545 	int val0, val6;
546 	unsigned long flags;
547 
548 	spin_lock_irqsave(&chip->reg_lock, flags);
549 	val0 = chip->awacs_reg[0] & ~MASK_GAINLINE;
550 	val6 = chip->awacs_reg[6] & ~MASK_MIC_BOOST;
551 	if (ucontrol->value.integer.value[0] > 0) {
552 		val0 |= MASK_GAINLINE;
553 		if (ucontrol->value.integer.value[0] > 1)
554 			val6 |= MASK_MIC_BOOST;
555 	}
556 	if (val0 != chip->awacs_reg[0]) {
557 		snd_pmac_awacs_write_reg(chip, 0, val0);
558 		changed = 1;
559 	}
560 	if (val6 != chip->awacs_reg[6]) {
561 		snd_pmac_awacs_write_reg(chip, 6, val6);
562 		changed = 1;
563 	}
564 	spin_unlock_irqrestore(&chip->reg_lock, flags);
565 	return changed;
566 }
567 
568 /*
569  * lists of mixer elements
570  */
571 static snd_kcontrol_new_t snd_pmac_awacs_mixers[] __initdata = {
572 	AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
573 	AWACS_SWITCH("Master Capture Switch", 1, SHIFT_LOOPTHRU, 0),
574 	AWACS_VOLUME("Capture Volume", 0, 4, 0),
575 	AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
576 };
577 
578 /* FIXME: is this correct order?
579  * screamer (powerbook G3 pismo) seems to have different bits...
580  */
581 static snd_kcontrol_new_t snd_pmac_awacs_mixers2[] __initdata = {
582 	AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0),
583 	AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0),
584 };
585 
586 static snd_kcontrol_new_t snd_pmac_screamer_mixers2[] __initdata = {
587 	AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
588 	AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
589 };
590 
591 static snd_kcontrol_new_t snd_pmac_awacs_master_sw __initdata =
592 AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
593 
594 static snd_kcontrol_new_t snd_pmac_awacs_mic_boost[] __initdata = {
595 	AWACS_SWITCH("Mic Boost", 0, SHIFT_GAINLINE, 0),
596 };
597 
598 static snd_kcontrol_new_t snd_pmac_screamer_mic_boost[] __initdata = {
599 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
600 	  .name = "Mic Boost",
601 	  .info = snd_pmac_screamer_mic_boost_info,
602 	  .get = snd_pmac_screamer_mic_boost_get,
603 	  .put = snd_pmac_screamer_mic_boost_put,
604 	},
605 };
606 
607 static snd_kcontrol_new_t snd_pmac_awacs_speaker_vol[] __initdata = {
608 	AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1),
609 };
610 static snd_kcontrol_new_t snd_pmac_awacs_speaker_sw __initdata =
611 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
612 
613 
614 /*
615  * add new mixer elements to the card
616  */
617 static int build_mixers(pmac_t *chip, int nums, snd_kcontrol_new_t *mixers)
618 {
619 	int i, err;
620 
621 	for (i = 0; i < nums; i++) {
622 		if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip))) < 0)
623 			return err;
624 	}
625 	return 0;
626 }
627 
628 
629 /*
630  * restore all registers
631  */
632 static void awacs_restore_all_regs(pmac_t *chip)
633 {
634 	snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
635 	snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
636 	snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
637 	snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
638 	if (chip->model == PMAC_SCREAMER) {
639 		snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
640 		snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
641 		snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
642 	}
643 }
644 
645 #ifdef CONFIG_PM
646 static void snd_pmac_awacs_suspend(pmac_t *chip)
647 {
648 	snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
649 					     | MASK_AMUTE | MASK_CMUTE));
650 }
651 
652 static void snd_pmac_awacs_resume(pmac_t *chip)
653 {
654 	if (machine_is_compatible("PowerBook3,1")
655 	    || machine_is_compatible("PowerBook3,2")) {
656 		msleep(100);
657 		snd_pmac_awacs_write_reg(chip, 1,
658 			chip->awacs_reg[1] & ~MASK_PAROUT);
659 		msleep(300);
660 	}
661 
662 	awacs_restore_all_regs(chip);
663 	if (chip->model == PMAC_SCREAMER) {
664 		/* reset power bits in reg 6 */
665 		mdelay(5);
666 		snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
667 	}
668 	screamer_recalibrate(chip);
669 #ifdef PMAC_AMP_AVAIL
670 	if (chip->mixer_data) {
671 		awacs_amp_t *amp = chip->mixer_data;
672 		awacs_amp_set_vol(amp, 0, amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
673 		awacs_amp_set_vol(amp, 1, amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
674 		awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
675 		awacs_amp_set_master(amp, amp->amp_master);
676 	}
677 #endif
678 }
679 #endif /* CONFIG_PM */
680 
681 #ifdef PMAC_SUPPORT_AUTOMUTE
682 /*
683  * auto-mute stuffs
684  */
685 static int snd_pmac_awacs_detect_headphone(pmac_t *chip)
686 {
687 	return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
688 }
689 
690 #ifdef PMAC_AMP_AVAIL
691 static int toggle_amp_mute(awacs_amp_t *amp, int index, int mute)
692 {
693 	int vol[2];
694 	vol[0] = amp->amp_vol[index][0] & 31;
695 	vol[1] = amp->amp_vol[index][1] & 31;
696 	if (mute) {
697 		vol[0] |= 32;
698 		vol[1] |= 32;
699 	}
700 	return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
701 }
702 #endif
703 
704 static void snd_pmac_awacs_update_automute(pmac_t *chip, int do_notify)
705 {
706 	if (chip->auto_mute) {
707 #ifdef PMAC_AMP_AVAIL
708 		if (chip->mixer_data) {
709 			awacs_amp_t *amp = chip->mixer_data;
710 			int changed;
711 			if (snd_pmac_awacs_detect_headphone(chip)) {
712 				changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
713 				changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
714 			} else {
715 				changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
716 				changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
717 			}
718 			if (do_notify && ! changed)
719 				return;
720 		} else
721 #endif
722 		{
723 			int reg = chip->awacs_reg[1] | (MASK_HDMUTE|MASK_SPKMUTE);
724 			if (snd_pmac_awacs_detect_headphone(chip))
725 				reg &= ~MASK_HDMUTE;
726 			else
727 				reg &= ~MASK_SPKMUTE;
728 			if (do_notify && reg == chip->awacs_reg[1])
729 				return;
730 			snd_pmac_awacs_write_reg(chip, 1, reg);
731 		}
732 		if (do_notify) {
733 			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
734 				       &chip->master_sw_ctl->id);
735 			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
736 				       &chip->speaker_sw_ctl->id);
737 			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
738 				       &chip->hp_detect_ctl->id);
739 		}
740 	}
741 }
742 #endif /* PMAC_SUPPORT_AUTOMUTE */
743 
744 
745 /*
746  * initialize chip
747  */
748 int __init
749 snd_pmac_awacs_init(pmac_t *chip)
750 {
751 	int err, vol;
752 
753 	/* looks like MASK_GAINLINE triggers something, so we set here
754 	 * as start-up
755 	 */
756 	chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
757 	chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
758 	/* FIXME: Only machines with external SRS module need MASK_PAROUT */
759 	if (chip->has_iic || chip->device_id == 0x5 ||
760 	    /*chip->_device_id == 0x8 || */
761 	    chip->device_id == 0xb)
762 		chip->awacs_reg[1] |= MASK_PAROUT;
763 	/* get default volume from nvram */
764 	// vol = (~nvram_read_byte(0x1308) & 7) << 1;
765 	// vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
766 	vol = 0x0f; /* no, on alsa, muted as default */
767 	vol = vol + (vol << 6);
768 	chip->awacs_reg[2] = vol;
769 	chip->awacs_reg[4] = vol;
770 	if (chip->model == PMAC_SCREAMER) {
771 		chip->awacs_reg[5] = vol; /* FIXME: screamer has loopthru vol control */
772 		chip->awacs_reg[6] = MASK_MIC_BOOST; /* FIXME: maybe should be vol << 3 for PCMCIA speaker */
773 		chip->awacs_reg[7] = 0;
774 	}
775 
776 	awacs_restore_all_regs(chip);
777 	chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
778 	screamer_recalibrate(chip);
779 
780 	chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
781 #ifdef PMAC_AMP_AVAIL
782 	if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
783 		awacs_amp_t *amp = kmalloc(sizeof(*amp), GFP_KERNEL);
784 		if (! amp)
785 			return -ENOMEM;
786 		chip->mixer_data = amp;
787 		memset(amp, 0, sizeof(*amp));
788 		chip->mixer_free = awacs_amp_free;
789 		awacs_amp_set_vol(amp, 0, 63, 63, 0); /* mute and zero vol */
790 		awacs_amp_set_vol(amp, 1, 63, 63, 0);
791 		awacs_amp_set_tone(amp, 7, 7); /* 0 dB */
792 		awacs_amp_set_master(amp, 79); /* 0 dB */
793 	}
794 #endif /* PMAC_AMP_AVAIL */
795 
796 	if (chip->hp_stat_mask == 0) {
797 		/* set headphone-jack detection bit */
798 		switch (chip->model) {
799 		case PMAC_AWACS:
800 			chip->hp_stat_mask = 0x04;
801 			break;
802 		case PMAC_SCREAMER:
803 			switch (chip->device_id) {
804 			case 0x08:
805 				/* 1 = side jack, 2 = front jack */
806 				chip->hp_stat_mask = 0x03;
807 				break;
808 			case 0x00:
809 			case 0x05:
810 				chip->hp_stat_mask = 0x04;
811 				break;
812 			default:
813 				chip->hp_stat_mask = 0x08;
814 				break;
815 			}
816 			break;
817 		default:
818 			snd_BUG();
819 			break;
820 		}
821 	}
822 
823 	/*
824 	 * build mixers
825 	 */
826 	strcpy(chip->card->mixername, "PowerMac AWACS");
827 
828 	if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
829 				snd_pmac_awacs_mixers)) < 0)
830 		return err;
831 	if (chip->model == PMAC_SCREAMER)
832 		err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
833 				   snd_pmac_screamer_mixers2);
834 	else
835 		err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
836 				   snd_pmac_awacs_mixers2);
837 	if (err < 0)
838 		return err;
839 	chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_master_sw, chip);
840 	if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
841 		return err;
842 #ifdef PMAC_AMP_AVAIL
843 	if (chip->mixer_data) {
844 		/* use amplifier.  the signal is connected from route A
845 		 * to the amp.  the amp has its headphone and speaker
846 		 * volumes and mute switches, so we use them instead of
847 		 * screamer registers.
848 		 * in this case, it seems the route C is not used.
849 		 */
850 		if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
851 					snd_pmac_awacs_amp_vol)) < 0)
852 			return err;
853 		/* overwrite */
854 		chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw, chip);
855 		if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
856 			return err;
857 		chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw, chip);
858 		if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
859 			return err;
860 	} else
861 #endif /* PMAC_AMP_AVAIL */
862 	{
863 		/* route A = headphone, route C = speaker */
864 		if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_speaker_vol),
865 					snd_pmac_awacs_speaker_vol)) < 0)
866 			return err;
867 		chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_speaker_sw, chip);
868 		if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
869 			return err;
870 	}
871 
872 	if (chip->model == PMAC_SCREAMER) {
873 		if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mic_boost),
874 					snd_pmac_screamer_mic_boost)) < 0)
875 			return err;
876 	} else {
877 		if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
878 					snd_pmac_awacs_mic_boost)) < 0)
879 			return err;
880 	}
881 
882 	/*
883 	 * set lowlevel callbacks
884 	 */
885 	chip->set_format = snd_pmac_awacs_set_format;
886 #ifdef CONFIG_PM
887 	chip->suspend = snd_pmac_awacs_suspend;
888 	chip->resume = snd_pmac_awacs_resume;
889 #endif
890 #ifdef PMAC_SUPPORT_AUTOMUTE
891 	if ((err = snd_pmac_add_automute(chip)) < 0)
892 		return err;
893 	chip->detect_headphone = snd_pmac_awacs_detect_headphone;
894 	chip->update_automute = snd_pmac_awacs_update_automute;
895 	snd_pmac_awacs_update_automute(chip, 0); /* update the status only */
896 #endif
897 	if (chip->model == PMAC_SCREAMER) {
898 		snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
899 		snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
900 	}
901 
902 	return 0;
903 }
904