1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
37struct 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
46
47
48static 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
62
63static void
64snd_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
79static void
80snd_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
86static void
87snd_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
94static void screamer_recalibrate(struct snd_pmac *chip)
95{
96 if (chip->model != PMAC_SCREAMER)
97 return;
98
99
100
101
102 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
103 if (chip->manufacturer == 0x1)
104
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)
115#endif
116
117
118
119
120
121static 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
131
132
133
134
135static 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
145static 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
168static 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
210
211static 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
230static 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
263
264
265
266
267static 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
278
279static 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
292
293static 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
308
309static 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
319static void awacs_amp_free(struct snd_pmac *chip)
320{
321 struct awacs_amp *amp = chip->mixer_data;
322 snd_assert(amp, return);
323 kfree(amp);
324 chip->mixer_data = NULL;
325 chip->mixer_free = NULL;
326}
327
328
329
330
331
332static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol,
333 struct snd_ctl_elem_info *uinfo)
334{
335 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
336 uinfo->count = 2;
337 uinfo->value.integer.min = 0;
338 uinfo->value.integer.max = 31;
339 return 0;
340}
341
342static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol,
343 struct snd_ctl_elem_value *ucontrol)
344{
345 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
346 int index = kcontrol->private_value;
347 struct awacs_amp *amp = chip->mixer_data;
348 snd_assert(amp, return -EINVAL);
349 snd_assert(index >= 0 && index <= 1, return -EINVAL);
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
355static 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 snd_assert(amp, return -EINVAL);
363 snd_assert(index >= 0 && index <= 1, return -EINVAL);
364
365 vol[0] = (31 - (ucontrol->value.integer.value[0] & 31))
366 | (amp->amp_vol[index][0] & 32);
367 vol[1] = (31 - (ucontrol->value.integer.value[1] & 31))
368 | (amp->amp_vol[index][1] & 32);
369 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
370}
371
372static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol,
373 struct snd_ctl_elem_value *ucontrol)
374{
375 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
376 int index = kcontrol->private_value;
377 struct awacs_amp *amp = chip->mixer_data;
378 snd_assert(amp, return -EINVAL);
379 snd_assert(index >= 0 && index <= 1, return -EINVAL);
380 ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32)
381 ? 0 : 1;
382 ucontrol->value.integer.value[1] = (amp->amp_vol[index][1] & 32)
383 ? 0 : 1;
384 return 0;
385}
386
387static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol,
388 struct snd_ctl_elem_value *ucontrol)
389{
390 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
391 int index = kcontrol->private_value;
392 int vol[2];
393 struct awacs_amp *amp = chip->mixer_data;
394 snd_assert(amp, return -EINVAL);
395 snd_assert(index >= 0 && index <= 1, return -EINVAL);
396
397 vol[0] = (ucontrol->value.integer.value[0] ? 0 : 32)
398 | (amp->amp_vol[index][0] & 31);
399 vol[1] = (ucontrol->value.integer.value[1] ? 0 : 32)
400 | (amp->amp_vol[index][1] & 31);
401 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
402}
403
404static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol,
405 struct snd_ctl_elem_info *uinfo)
406{
407 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
408 uinfo->count = 1;
409 uinfo->value.integer.min = 0;
410 uinfo->value.integer.max = 14;
411 return 0;
412}
413
414static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol,
415 struct snd_ctl_elem_value *ucontrol)
416{
417 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
418 int index = kcontrol->private_value;
419 struct awacs_amp *amp = chip->mixer_data;
420 snd_assert(amp, return -EINVAL);
421 snd_assert(index >= 0 && index <= 1, return -EINVAL);
422 ucontrol->value.integer.value[0] = amp->amp_tone[index];
423 return 0;
424}
425
426static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol,
427 struct snd_ctl_elem_value *ucontrol)
428{
429 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
430 int index = kcontrol->private_value;
431 struct awacs_amp *amp = chip->mixer_data;
432 unsigned int val;
433 snd_assert(amp, return -EINVAL);
434 snd_assert(index >= 0 && index <= 1, return -EINVAL);
435 val = ucontrol->value.integer.value[0];
436 if (val > 14)
437 return -EINVAL;
438 if (val != amp->amp_tone[index]) {
439 amp->amp_tone[index] = val;
440 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
441 return 1;
442 }
443 return 0;
444}
445
446static int snd_pmac_awacs_info_master_amp(struct snd_kcontrol *kcontrol,
447 struct snd_ctl_elem_info *uinfo)
448{
449 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
450 uinfo->count = 1;
451 uinfo->value.integer.min = 0;
452 uinfo->value.integer.max = 99;
453 return 0;
454}
455
456static int snd_pmac_awacs_get_master_amp(struct snd_kcontrol *kcontrol,
457 struct snd_ctl_elem_value *ucontrol)
458{
459 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
460 struct awacs_amp *amp = chip->mixer_data;
461 snd_assert(amp, return -EINVAL);
462 ucontrol->value.integer.value[0] = amp->amp_master;
463 return 0;
464}
465
466static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol,
467 struct snd_ctl_elem_value *ucontrol)
468{
469 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
470 struct awacs_amp *amp = chip->mixer_data;
471 unsigned int val;
472 snd_assert(amp, return -EINVAL);
473 val = ucontrol->value.integer.value[0];
474 if (val > 99)
475 return -EINVAL;
476 if (val != amp->amp_master) {
477 amp->amp_master = val;
478 awacs_amp_set_master(amp, amp->amp_master);
479 return 1;
480 }
481 return 0;
482}
483
484#define AMP_CH_SPK 0
485#define AMP_CH_HD 1
486
487static struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] __initdata = {
488 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
489 .name = "PC Speaker 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_SPK,
494 },
495 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
496 .name = "Headphone Playback Volume",
497 .info = snd_pmac_awacs_info_volume_amp,
498 .get = snd_pmac_awacs_get_volume_amp,
499 .put = snd_pmac_awacs_put_volume_amp,
500 .private_value = AMP_CH_HD,
501 },
502 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
503 .name = "Tone Control - Bass",
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 = 0,
508 },
509 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
510 .name = "Tone Control - Treble",
511 .info = snd_pmac_awacs_info_tone_amp,
512 .get = snd_pmac_awacs_get_tone_amp,
513 .put = snd_pmac_awacs_put_tone_amp,
514 .private_value = 1,
515 },
516 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
517 .name = "Amp Master Playback Volume",
518 .info = snd_pmac_awacs_info_master_amp,
519 .get = snd_pmac_awacs_get_master_amp,
520 .put = snd_pmac_awacs_put_master_amp,
521 },
522};
523
524static struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw __initdata = {
525 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
526 .name = "Headphone Playback Switch",
527 .info = snd_pmac_boolean_stereo_info,
528 .get = snd_pmac_awacs_get_switch_amp,
529 .put = snd_pmac_awacs_put_switch_amp,
530 .private_value = AMP_CH_HD,
531};
532
533static struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw __initdata = {
534 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
535 .name = "PC Speaker Playback Switch",
536 .info = snd_pmac_boolean_stereo_info,
537 .get = snd_pmac_awacs_get_switch_amp,
538 .put = snd_pmac_awacs_put_switch_amp,
539 .private_value = AMP_CH_SPK,
540};
541
542#endif
543
544
545
546
547
548static int snd_pmac_screamer_mic_boost_info(struct snd_kcontrol *kcontrol,
549 struct snd_ctl_elem_info *uinfo)
550{
551 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
552 uinfo->count = 1;
553 uinfo->value.integer.min = 0;
554 uinfo->value.integer.max = 3;
555 return 0;
556}
557
558static int snd_pmac_screamer_mic_boost_get(struct snd_kcontrol *kcontrol,
559 struct snd_ctl_elem_value *ucontrol)
560{
561 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
562 int val = 0;
563 unsigned long flags;
564
565 spin_lock_irqsave(&chip->reg_lock, flags);
566 if (chip->awacs_reg[6] & MASK_MIC_BOOST)
567 val |= 2;
568 if (chip->awacs_reg[0] & MASK_GAINLINE)
569 val |= 1;
570 spin_unlock_irqrestore(&chip->reg_lock, flags);
571 ucontrol->value.integer.value[0] = val;
572 return 0;
573}
574
575static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol,
576 struct snd_ctl_elem_value *ucontrol)
577{
578 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
579 int changed = 0;
580 int val0, val6;
581 unsigned long flags;
582
583 spin_lock_irqsave(&chip->reg_lock, flags);
584 val0 = chip->awacs_reg[0] & ~MASK_GAINLINE;
585 val6 = chip->awacs_reg[6] & ~MASK_MIC_BOOST;
586 if (ucontrol->value.integer.value[0] & 1)
587 val0 |= MASK_GAINLINE;
588 if (ucontrol->value.integer.value[0] & 2)
589 val6 |= MASK_MIC_BOOST;
590 if (val0 != chip->awacs_reg[0]) {
591 snd_pmac_awacs_write_reg(chip, 0, val0);
592 changed = 1;
593 }
594 if (val6 != chip->awacs_reg[6]) {
595 snd_pmac_awacs_write_reg(chip, 6, val6);
596 changed = 1;
597 }
598 spin_unlock_irqrestore(&chip->reg_lock, flags);
599 return changed;
600}
601
602
603
604
605static struct snd_kcontrol_new snd_pmac_awacs_mixers[] __initdata = {
606 AWACS_SWITCH("Master Capture Switch", 1, SHIFT_LOOPTHRU, 0),
607 AWACS_VOLUME("Master Capture Volume", 0, 4, 0),
608
609};
610
611static struct snd_kcontrol_new snd_pmac_screamer_mixers_beige[] __initdata = {
612 AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
613 AWACS_VOLUME("Play-through Playback Volume", 5, 6, 1),
614 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
615 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_LINE, 0),
616};
617
618static struct snd_kcontrol_new snd_pmac_screamer_mixers_imac[] __initdata = {
619 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
620 AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
621 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
622};
623
624static struct snd_kcontrol_new snd_pmac_screamer_mixers_g4agp[] __initdata = {
625 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
626 AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
627 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
628 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
629};
630
631static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac7500[] __initdata = {
632 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
633 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
634 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
635};
636
637static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac[] __initdata = {
638 AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
639 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
640};
641
642
643
644
645static struct snd_kcontrol_new snd_pmac_awacs_mixers2[] __initdata = {
646 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0),
647 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0),
648};
649
650static struct snd_kcontrol_new snd_pmac_screamer_mixers2[] __initdata = {
651 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
652 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
653};
654
655static struct snd_kcontrol_new snd_pmac_awacs_master_sw __initdata =
656AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
657
658static struct snd_kcontrol_new snd_pmac_awacs_master_sw_imac __initdata =
659AWACS_SWITCH("Line out Playback Switch", 1, SHIFT_HDMUTE, 1);
660
661static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __initdata = {
662 AWACS_SWITCH("Mic Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
663};
664
665static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __initdata = {
666 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
667 .name = "Mic Boost Capture Volume",
668 .info = snd_pmac_screamer_mic_boost_info,
669 .get = snd_pmac_screamer_mic_boost_get,
670 .put = snd_pmac_screamer_mic_boost_put,
671 },
672};
673
674static struct snd_kcontrol_new snd_pmac_awacs_mic_boost_pmac7500[] __initdata =
675{
676 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
677};
678
679static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_beige[] __initdata =
680{
681 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
682 AWACS_SWITCH("CD Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
683};
684
685static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_imac[] __initdata =
686{
687 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
688 AWACS_SWITCH("Mic Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
689};
690
691static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __initdata = {
692 AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1),
693};
694
695static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __initdata =
696AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
697
698static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac1 __initdata =
699AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 1);
700
701static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac2 __initdata =
702AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
703
704
705
706
707
708static int build_mixers(struct snd_pmac *chip, int nums,
709 struct snd_kcontrol_new *mixers)
710{
711 int i, err;
712
713 for (i = 0; i < nums; i++) {
714 err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip));
715 if (err < 0)
716 return err;
717 }
718 return 0;
719}
720
721
722
723
724
725static void awacs_restore_all_regs(struct snd_pmac *chip)
726{
727 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
728 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
729 snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
730 snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
731 if (chip->model == PMAC_SCREAMER) {
732 snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
733 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
734 snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
735 }
736}
737
738#ifdef CONFIG_PM
739static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
740{
741 snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
742 | MASK_AMUTE | MASK_CMUTE));
743}
744
745static void snd_pmac_awacs_resume(struct snd_pmac *chip)
746{
747 if (machine_is_compatible("PowerBook3,1")
748 || machine_is_compatible("PowerBook3,2")) {
749 msleep(100);
750 snd_pmac_awacs_write_reg(chip, 1,
751 chip->awacs_reg[1] & ~MASK_PAROUT);
752 msleep(300);
753 }
754
755 awacs_restore_all_regs(chip);
756 if (chip->model == PMAC_SCREAMER) {
757
758 mdelay(5);
759 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
760 }
761 screamer_recalibrate(chip);
762#ifdef PMAC_AMP_AVAIL
763 if (chip->mixer_data) {
764 struct awacs_amp *amp = chip->mixer_data;
765 awacs_amp_set_vol(amp, 0,
766 amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
767 awacs_amp_set_vol(amp, 1,
768 amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
769 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
770 awacs_amp_set_master(amp, amp->amp_master);
771 }
772#endif
773}
774#endif
775
776#define IS_PM7500 (machine_is_compatible("AAPL,7500"))
777#define IS_BEIGE (machine_is_compatible("AAPL,Gossamer"))
778#define IS_IMAC1 (machine_is_compatible("PowerMac2,1"))
779#define IS_IMAC2 (machine_is_compatible("PowerMac2,2") \
780 || machine_is_compatible("PowerMac4,1"))
781#define IS_G4AGP (machine_is_compatible("PowerMac3,1"))
782
783static int imac1, imac2;
784
785#ifdef PMAC_SUPPORT_AUTOMUTE
786
787
788
789static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip)
790{
791 return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
792}
793
794#ifdef PMAC_AMP_AVAIL
795static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute)
796{
797 int vol[2];
798 vol[0] = amp->amp_vol[index][0] & 31;
799 vol[1] = amp->amp_vol[index][1] & 31;
800 if (mute) {
801 vol[0] |= 32;
802 vol[1] |= 32;
803 }
804 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
805}
806#endif
807
808static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify)
809{
810 if (chip->auto_mute) {
811#ifdef PMAC_AMP_AVAIL
812 if (chip->mixer_data) {
813 struct awacs_amp *amp = chip->mixer_data;
814 int changed;
815 if (snd_pmac_awacs_detect_headphone(chip)) {
816 changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
817 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
818 } else {
819 changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
820 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
821 }
822 if (do_notify && ! changed)
823 return;
824 } else
825#endif
826 {
827 int reg = chip->awacs_reg[1]
828 | (MASK_HDMUTE | MASK_SPKMUTE);
829 if (imac1) {
830 reg &= ~MASK_SPKMUTE;
831 reg |= MASK_PAROUT1;
832 } else if (imac2) {
833 reg &= ~MASK_SPKMUTE;
834 reg &= ~MASK_PAROUT1;
835 }
836 if (snd_pmac_awacs_detect_headphone(chip))
837 reg &= ~MASK_HDMUTE;
838 else if (imac1)
839 reg &= ~MASK_PAROUT1;
840 else if (imac2)
841 reg |= MASK_PAROUT1;
842 else
843 reg &= ~MASK_SPKMUTE;
844 if (do_notify && reg == chip->awacs_reg[1])
845 return;
846 snd_pmac_awacs_write_reg(chip, 1, reg);
847 }
848 if (do_notify) {
849 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
850 &chip->master_sw_ctl->id);
851 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
852 &chip->speaker_sw_ctl->id);
853 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
854 &chip->hp_detect_ctl->id);
855 }
856 }
857}
858#endif
859
860
861
862
863
864int __init
865snd_pmac_awacs_init(struct snd_pmac *chip)
866{
867 int pm7500 = IS_PM7500;
868 int beige = IS_BEIGE;
869 int g4agp = IS_G4AGP;
870 int imac;
871 int err, vol;
872
873 imac1 = IS_IMAC1;
874 imac2 = IS_IMAC2;
875 imac = imac1 || imac2;
876
877
878
879 chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
880 chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
881
882 if (chip->has_iic || chip->device_id == 0x5 ||
883
884 chip->device_id == 0xb)
885 chip->awacs_reg[1] |= MASK_PAROUT;
886
887
888
889 vol = 0x0f;
890 vol = vol + (vol << 6);
891 chip->awacs_reg[2] = vol;
892 chip->awacs_reg[4] = vol;
893 if (chip->model == PMAC_SCREAMER) {
894
895 chip->awacs_reg[5] = vol;
896
897 chip->awacs_reg[6] = MASK_MIC_BOOST;
898 chip->awacs_reg[7] = 0;
899 }
900
901 awacs_restore_all_regs(chip);
902 chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
903 screamer_recalibrate(chip);
904
905 chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
906#ifdef PMAC_AMP_AVAIL
907 if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
908 struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
909 if (! amp)
910 return -ENOMEM;
911 chip->mixer_data = amp;
912 chip->mixer_free = awacs_amp_free;
913
914 awacs_amp_set_vol(amp, 0, 63, 63, 0);
915 awacs_amp_set_vol(amp, 1, 63, 63, 0);
916 awacs_amp_set_tone(amp, 7, 7);
917 awacs_amp_set_master(amp, 79);
918 }
919#endif
920
921 if (chip->hp_stat_mask == 0) {
922
923 switch (chip->model) {
924 case PMAC_AWACS:
925 chip->hp_stat_mask = pm7500 ? MASK_HDPCONN
926 : MASK_LOCONN;
927 break;
928 case PMAC_SCREAMER:
929 switch (chip->device_id) {
930 case 0x08:
931 case 0x0B:
932 chip->hp_stat_mask = imac
933 ? MASK_LOCONN_IMAC |
934 MASK_HDPLCONN_IMAC |
935 MASK_HDPRCONN_IMAC
936 : MASK_HDPCONN;
937 break;
938 case 0x00:
939 case 0x05:
940 chip->hp_stat_mask = MASK_LOCONN;
941 break;
942 default:
943 chip->hp_stat_mask = MASK_HDPCONN;
944 break;
945 }
946 break;
947 default:
948 snd_BUG();
949 break;
950 }
951 }
952
953
954
955
956 strcpy(chip->card->mixername, "PowerMac AWACS");
957
958 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
959 snd_pmac_awacs_mixers);
960 if (err < 0)
961 return err;
962 if (beige || g4agp)
963 ;
964 else if (chip->model == PMAC_SCREAMER)
965 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
966 snd_pmac_screamer_mixers2);
967 else if (!pm7500)
968 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
969 snd_pmac_awacs_mixers2);
970 if (err < 0)
971 return err;
972 if (pm7500)
973 err = build_mixers(chip,
974 ARRAY_SIZE(snd_pmac_awacs_mixers_pmac7500),
975 snd_pmac_awacs_mixers_pmac7500);
976 else if (beige)
977 err = build_mixers(chip,
978 ARRAY_SIZE(snd_pmac_screamer_mixers_beige),
979 snd_pmac_screamer_mixers_beige);
980 else if (imac)
981 err = build_mixers(chip,
982 ARRAY_SIZE(snd_pmac_screamer_mixers_imac),
983 snd_pmac_screamer_mixers_imac);
984 else if (g4agp)
985 err = build_mixers(chip,
986 ARRAY_SIZE(snd_pmac_screamer_mixers_g4agp),
987 snd_pmac_screamer_mixers_g4agp);
988 else
989 err = build_mixers(chip,
990 ARRAY_SIZE(snd_pmac_awacs_mixers_pmac),
991 snd_pmac_awacs_mixers_pmac);
992 if (err < 0)
993 return err;
994 chip->master_sw_ctl = snd_ctl_new1((pm7500 || imac || g4agp)
995 ? &snd_pmac_awacs_master_sw_imac
996 : &snd_pmac_awacs_master_sw, chip);
997 err = snd_ctl_add(chip->card, chip->master_sw_ctl);
998 if (err < 0)
999 return err;
1000#ifdef PMAC_AMP_AVAIL
1001 if (chip->mixer_data) {
1002
1003
1004
1005
1006
1007
1008 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
1009 snd_pmac_awacs_amp_vol);
1010 if (err < 0)
1011 return err;
1012
1013 chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw,
1014 chip);
1015 err = snd_ctl_add(chip->card, chip->master_sw_ctl);
1016 if (err < 0)
1017 return err;
1018 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw,
1019 chip);
1020 err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1021 if (err < 0)
1022 return err;
1023 } else
1024#endif
1025 {
1026
1027 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_speaker_vol),
1028 snd_pmac_awacs_speaker_vol);
1029 if (err < 0)
1030 return err;
1031 chip->speaker_sw_ctl = snd_ctl_new1(imac1
1032 ? &snd_pmac_awacs_speaker_sw_imac1
1033 : imac2
1034 ? &snd_pmac_awacs_speaker_sw_imac2
1035 : &snd_pmac_awacs_speaker_sw, chip);
1036 err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1037 if (err < 0)
1038 return err;
1039 }
1040
1041 if (beige || g4agp)
1042 err = build_mixers(chip,
1043 ARRAY_SIZE(snd_pmac_screamer_mic_boost_beige),
1044 snd_pmac_screamer_mic_boost_beige);
1045 else if (imac)
1046 err = build_mixers(chip,
1047 ARRAY_SIZE(snd_pmac_screamer_mic_boost_imac),
1048 snd_pmac_screamer_mic_boost_imac);
1049 else if (chip->model == PMAC_SCREAMER)
1050 err = build_mixers(chip,
1051 ARRAY_SIZE(snd_pmac_screamer_mic_boost),
1052 snd_pmac_screamer_mic_boost);
1053 else if (pm7500)
1054 err = build_mixers(chip,
1055 ARRAY_SIZE(snd_pmac_awacs_mic_boost_pmac7500),
1056 snd_pmac_awacs_mic_boost_pmac7500);
1057 else
1058 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
1059 snd_pmac_awacs_mic_boost);
1060 if (err < 0)
1061 return err;
1062
1063
1064
1065
1066 chip->set_format = snd_pmac_awacs_set_format;
1067#ifdef CONFIG_PM
1068 chip->suspend = snd_pmac_awacs_suspend;
1069 chip->resume = snd_pmac_awacs_resume;
1070#endif
1071#ifdef PMAC_SUPPORT_AUTOMUTE
1072 err = snd_pmac_add_automute(chip);
1073 if (err < 0)
1074 return err;
1075 chip->detect_headphone = snd_pmac_awacs_detect_headphone;
1076 chip->update_automute = snd_pmac_awacs_update_automute;
1077 snd_pmac_awacs_update_automute(chip, 0);
1078#endif
1079 if (chip->model == PMAC_SCREAMER) {
1080 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
1081 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
1082 }
1083
1084 return 0;
1085}
1086
