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