xref: /openbmc/linux/sound/ppc/awacs.c (revision a1e58bbd)
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, reg, val);
271 	while (! req.complete)
272 		cuda_poll();
273 }
274 
275 /*
276  * level = 0 - 14, 7 = 0 dB
277  */
278 static void awacs_amp_set_tone(struct awacs_amp *amp, int bass, int treble)
279 {
280 	amp->amp_tone[0] = bass;
281 	amp->amp_tone[1] = treble;
282 	if (bass > 7)
283 		bass = (14 - bass) + 8;
284 	if (treble > 7)
285 		treble = (14 - treble) + 8;
286 	awacs_set_cuda(2, (bass << 4) | treble);
287 }
288 
289 /*
290  * vol = 0 - 31 (attenuation), 32 = mute bit, stereo
291  */
292 static int awacs_amp_set_vol(struct awacs_amp *amp, int index, int lvol, int rvol,
293 			     int do_check)
294 {
295 	if (do_check && amp->amp_vol[index][0] == lvol &&
296 	    amp->amp_vol[index][1] == rvol)
297 		return 0;
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;
302 	return 1;
303 }
304 
305 /*
306  * 0 = -79 dB, 79 = 0 dB, 99 = +20 dB
307  */
308 static void awacs_amp_set_master(struct awacs_amp *amp, int vol)
309 {
310 	amp->amp_master = vol;
311 	if (vol <= 79)
312 		vol = 32 + (79 - vol);
313 	else
314 		vol = 32 - (vol - 79);
315 	awacs_set_cuda(1, vol);
316 }
317 
318 static void awacs_amp_free(struct snd_pmac *chip)
319 {
320 	struct awacs_amp *amp = chip->mixer_data;
321 	snd_assert(amp, return);
322 	kfree(amp);
323 	chip->mixer_data = NULL;
324 	chip->mixer_free = NULL;
325 }
326 
327 
328 /*
329  * mixer controls
330  */
331 static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol,
332 					  struct snd_ctl_elem_info *uinfo)
333 {
334 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
335 	uinfo->count = 2;
336 	uinfo->value.integer.min = 0;
337 	uinfo->value.integer.max = 31;
338 	return 0;
339 }
340 
341 static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol,
342 					 struct snd_ctl_elem_value *ucontrol)
343 {
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);
351 	return 0;
352 }
353 
354 static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol,
355 					 struct snd_ctl_elem_value *ucontrol)
356 {
357 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
358 	int index = kcontrol->private_value;
359 	int vol[2];
360 	struct awacs_amp *amp = chip->mixer_data;
361 	snd_assert(amp, return -EINVAL);
362 	snd_assert(index >= 0 && index <= 1, return -EINVAL);
363 
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);
367 }
368 
369 static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol,
370 					 struct snd_ctl_elem_value *ucontrol)
371 {
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;
379 	return 0;
380 }
381 
382 static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol,
383 					 struct snd_ctl_elem_value *ucontrol)
384 {
385 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
386 	int index = kcontrol->private_value;
387 	int vol[2];
388 	struct awacs_amp *amp = chip->mixer_data;
389 	snd_assert(amp, return -EINVAL);
390 	snd_assert(index >= 0 && index <= 1, return -EINVAL);
391 
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);
395 }
396 
397 static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol,
398 					struct snd_ctl_elem_info *uinfo)
399 {
400 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
401 	uinfo->count = 1;
402 	uinfo->value.integer.min = 0;
403 	uinfo->value.integer.max = 14;
404 	return 0;
405 }
406 
407 static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol,
408 				       struct snd_ctl_elem_value *ucontrol)
409 {
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];
416 	return 0;
417 }
418 
419 static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol,
420 				       struct snd_ctl_elem_value *ucontrol)
421 {
422 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
423 	int index = kcontrol->private_value;
424 	struct awacs_amp *amp = chip->mixer_data;
425 	unsigned int val;
426 	snd_assert(amp, return -EINVAL);
427 	snd_assert(index >= 0 && index <= 1, return -EINVAL);
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 	snd_assert(amp, return -EINVAL);
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 	snd_assert(amp, return -EINVAL);
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[] __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,
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 __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,
524 };
525 
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,
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 = 2;
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;
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 	else if (chip->awacs_reg[0] & MASK_GAINLINE)
562 		val = 1;
563 	else
564 		val = 0;
565 	spin_unlock_irqrestore(&chip->reg_lock, flags);
566 	ucontrol->value.integer.value[0] = val;
567 	return 0;
568 }
569 
570 static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol,
571 					   struct snd_ctl_elem_value *ucontrol)
572 {
573 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
574 	int changed = 0;
575 	int val0, val6;
576 	unsigned long flags;
577 
578 	spin_lock_irqsave(&chip->reg_lock, flags);
579 	val0 = chip->awacs_reg[0] & ~MASK_GAINLINE;
580 	val6 = chip->awacs_reg[6] & ~MASK_MIC_BOOST;
581 	if (ucontrol->value.integer.value[0] > 0) {
582 		val0 |= MASK_GAINLINE;
583 		if (ucontrol->value.integer.value[0] > 1)
584 			val6 |= MASK_MIC_BOOST;
585 	}
586 	if (val0 != chip->awacs_reg[0]) {
587 		snd_pmac_awacs_write_reg(chip, 0, val0);
588 		changed = 1;
589 	}
590 	if (val6 != chip->awacs_reg[6]) {
591 		snd_pmac_awacs_write_reg(chip, 6, val6);
592 		changed = 1;
593 	}
594 	spin_unlock_irqrestore(&chip->reg_lock, flags);
595 	return changed;
596 }
597 
598 /*
599  * lists of mixer elements
600  */
601 static struct snd_kcontrol_new snd_pmac_awacs_mixers[] __initdata = {
602 	AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
603 	AWACS_SWITCH("Master Capture Switch", 1, SHIFT_LOOPTHRU, 0),
604 	AWACS_VOLUME("Capture Volume", 0, 4, 0),
605 	AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
606 };
607 
608 /* FIXME: is this correct order?
609  * screamer (powerbook G3 pismo) seems to have different bits...
610  */
611 static struct snd_kcontrol_new snd_pmac_awacs_mixers2[] __initdata = {
612 	AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0),
613 	AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0),
614 };
615 
616 static struct snd_kcontrol_new snd_pmac_screamer_mixers2[] __initdata = {
617 	AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
618 	AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
619 };
620 
621 static struct snd_kcontrol_new snd_pmac_awacs_master_sw __initdata =
622 AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
623 
624 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __initdata = {
625 	AWACS_SWITCH("Mic Boost", 0, SHIFT_GAINLINE, 0),
626 };
627 
628 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __initdata = {
629 	{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
630 	  .name = "Mic Boost",
631 	  .info = snd_pmac_screamer_mic_boost_info,
632 	  .get = snd_pmac_screamer_mic_boost_get,
633 	  .put = snd_pmac_screamer_mic_boost_put,
634 	},
635 };
636 
637 static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __initdata = {
638 	AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1),
639 };
640 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __initdata =
641 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
642 
643 
644 /*
645  * add new mixer elements to the card
646  */
647 static int build_mixers(struct snd_pmac *chip, int nums, struct snd_kcontrol_new *mixers)
648 {
649 	int i, err;
650 
651 	for (i = 0; i < nums; i++) {
652 		if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip))) < 0)
653 			return err;
654 	}
655 	return 0;
656 }
657 
658 
659 /*
660  * restore all registers
661  */
662 static void awacs_restore_all_regs(struct snd_pmac *chip)
663 {
664 	snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
665 	snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
666 	snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
667 	snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
668 	if (chip->model == PMAC_SCREAMER) {
669 		snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
670 		snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
671 		snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
672 	}
673 }
674 
675 #ifdef CONFIG_PM
676 static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
677 {
678 	snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
679 					     | MASK_AMUTE | MASK_CMUTE));
680 }
681 
682 static void snd_pmac_awacs_resume(struct snd_pmac *chip)
683 {
684 	if (machine_is_compatible("PowerBook3,1")
685 	    || machine_is_compatible("PowerBook3,2")) {
686 		msleep(100);
687 		snd_pmac_awacs_write_reg(chip, 1,
688 			chip->awacs_reg[1] & ~MASK_PAROUT);
689 		msleep(300);
690 	}
691 
692 	awacs_restore_all_regs(chip);
693 	if (chip->model == PMAC_SCREAMER) {
694 		/* reset power bits in reg 6 */
695 		mdelay(5);
696 		snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
697 	}
698 	screamer_recalibrate(chip);
699 #ifdef PMAC_AMP_AVAIL
700 	if (chip->mixer_data) {
701 		struct awacs_amp *amp = chip->mixer_data;
702 		awacs_amp_set_vol(amp, 0, amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
703 		awacs_amp_set_vol(amp, 1, amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
704 		awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
705 		awacs_amp_set_master(amp, amp->amp_master);
706 	}
707 #endif
708 }
709 #endif /* CONFIG_PM */
710 
711 #ifdef PMAC_SUPPORT_AUTOMUTE
712 /*
713  * auto-mute stuffs
714  */
715 static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip)
716 {
717 	return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
718 }
719 
720 #ifdef PMAC_AMP_AVAIL
721 static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute)
722 {
723 	int vol[2];
724 	vol[0] = amp->amp_vol[index][0] & 31;
725 	vol[1] = amp->amp_vol[index][1] & 31;
726 	if (mute) {
727 		vol[0] |= 32;
728 		vol[1] |= 32;
729 	}
730 	return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
731 }
732 #endif
733 
734 static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify)
735 {
736 	if (chip->auto_mute) {
737 #ifdef PMAC_AMP_AVAIL
738 		if (chip->mixer_data) {
739 			struct awacs_amp *amp = chip->mixer_data;
740 			int changed;
741 			if (snd_pmac_awacs_detect_headphone(chip)) {
742 				changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
743 				changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
744 			} else {
745 				changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
746 				changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
747 			}
748 			if (do_notify && ! changed)
749 				return;
750 		} else
751 #endif
752 		{
753 			int reg = chip->awacs_reg[1] | (MASK_HDMUTE|MASK_SPKMUTE);
754 			if (snd_pmac_awacs_detect_headphone(chip))
755 				reg &= ~MASK_HDMUTE;
756 			else
757 				reg &= ~MASK_SPKMUTE;
758 			if (do_notify && reg == chip->awacs_reg[1])
759 				return;
760 			snd_pmac_awacs_write_reg(chip, 1, reg);
761 		}
762 		if (do_notify) {
763 			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
764 				       &chip->master_sw_ctl->id);
765 			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
766 				       &chip->speaker_sw_ctl->id);
767 			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
768 				       &chip->hp_detect_ctl->id);
769 		}
770 	}
771 }
772 #endif /* PMAC_SUPPORT_AUTOMUTE */
773 
774 
775 /*
776  * initialize chip
777  */
778 int __init
779 snd_pmac_awacs_init(struct snd_pmac *chip)
780 {
781 	int err, vol;
782 
783 	/* looks like MASK_GAINLINE triggers something, so we set here
784 	 * as start-up
785 	 */
786 	chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
787 	chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
788 	/* FIXME: Only machines with external SRS module need MASK_PAROUT */
789 	if (chip->has_iic || chip->device_id == 0x5 ||
790 	    /*chip->_device_id == 0x8 || */
791 	    chip->device_id == 0xb)
792 		chip->awacs_reg[1] |= MASK_PAROUT;
793 	/* get default volume from nvram */
794 	// vol = (~nvram_read_byte(0x1308) & 7) << 1;
795 	// vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
796 	vol = 0x0f; /* no, on alsa, muted as default */
797 	vol = vol + (vol << 6);
798 	chip->awacs_reg[2] = vol;
799 	chip->awacs_reg[4] = vol;
800 	if (chip->model == PMAC_SCREAMER) {
801 		chip->awacs_reg[5] = vol; /* FIXME: screamer has loopthru vol control */
802 		chip->awacs_reg[6] = MASK_MIC_BOOST; /* FIXME: maybe should be vol << 3 for PCMCIA speaker */
803 		chip->awacs_reg[7] = 0;
804 	}
805 
806 	awacs_restore_all_regs(chip);
807 	chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
808 	screamer_recalibrate(chip);
809 
810 	chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
811 #ifdef PMAC_AMP_AVAIL
812 	if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
813 		struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
814 		if (! amp)
815 			return -ENOMEM;
816 		chip->mixer_data = amp;
817 		chip->mixer_free = awacs_amp_free;
818 		awacs_amp_set_vol(amp, 0, 63, 63, 0); /* mute and zero vol */
819 		awacs_amp_set_vol(amp, 1, 63, 63, 0);
820 		awacs_amp_set_tone(amp, 7, 7); /* 0 dB */
821 		awacs_amp_set_master(amp, 79); /* 0 dB */
822 	}
823 #endif /* PMAC_AMP_AVAIL */
824 
825 	if (chip->hp_stat_mask == 0) {
826 		/* set headphone-jack detection bit */
827 		switch (chip->model) {
828 		case PMAC_AWACS:
829 			chip->hp_stat_mask = 0x04;
830 			break;
831 		case PMAC_SCREAMER:
832 			switch (chip->device_id) {
833 			case 0x08:
834 				/* 1 = side jack, 2 = front jack */
835 				chip->hp_stat_mask = 0x03;
836 				break;
837 			case 0x00:
838 			case 0x05:
839 				chip->hp_stat_mask = 0x04;
840 				break;
841 			default:
842 				chip->hp_stat_mask = 0x08;
843 				break;
844 			}
845 			break;
846 		default:
847 			snd_BUG();
848 			break;
849 		}
850 	}
851 
852 	/*
853 	 * build mixers
854 	 */
855 	strcpy(chip->card->mixername, "PowerMac AWACS");
856 
857 	if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
858 				snd_pmac_awacs_mixers)) < 0)
859 		return err;
860 	if (chip->model == PMAC_SCREAMER)
861 		err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
862 				   snd_pmac_screamer_mixers2);
863 	else
864 		err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
865 				   snd_pmac_awacs_mixers2);
866 	if (err < 0)
867 		return err;
868 	chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_master_sw, chip);
869 	if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
870 		return err;
871 #ifdef PMAC_AMP_AVAIL
872 	if (chip->mixer_data) {
873 		/* use amplifier.  the signal is connected from route A
874 		 * to the amp.  the amp has its headphone and speaker
875 		 * volumes and mute switches, so we use them instead of
876 		 * screamer registers.
877 		 * in this case, it seems the route C is not used.
878 		 */
879 		if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
880 					snd_pmac_awacs_amp_vol)) < 0)
881 			return err;
882 		/* overwrite */
883 		chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw, chip);
884 		if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
885 			return err;
886 		chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw, chip);
887 		if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
888 			return err;
889 	} else
890 #endif /* PMAC_AMP_AVAIL */
891 	{
892 		/* route A = headphone, route C = speaker */
893 		if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_speaker_vol),
894 					snd_pmac_awacs_speaker_vol)) < 0)
895 			return err;
896 		chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_speaker_sw, chip);
897 		if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
898 			return err;
899 	}
900 
901 	if (chip->model == PMAC_SCREAMER) {
902 		if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mic_boost),
903 					snd_pmac_screamer_mic_boost)) < 0)
904 			return err;
905 	} else {
906 		if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
907 					snd_pmac_awacs_mic_boost)) < 0)
908 			return err;
909 	}
910 
911 	/*
912 	 * set lowlevel callbacks
913 	 */
914 	chip->set_format = snd_pmac_awacs_set_format;
915 #ifdef CONFIG_PM
916 	chip->suspend = snd_pmac_awacs_suspend;
917 	chip->resume = snd_pmac_awacs_resume;
918 #endif
919 #ifdef PMAC_SUPPORT_AUTOMUTE
920 	if ((err = snd_pmac_add_automute(chip)) < 0)
921 		return err;
922 	chip->detect_headphone = snd_pmac_awacs_detect_headphone;
923 	chip->update_automute = snd_pmac_awacs_update_automute;
924 	snd_pmac_awacs_update_automute(chip, 0); /* update the status only */
925 #endif
926 	if (chip->model == PMAC_SCREAMER) {
927 		snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
928 		snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
929 	}
930 
931 	return 0;
932 }
933