106c48225bbadd2978a10b325fe80badcc7f086d
[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         snd_assert(amp, return);
323         kfree(amp);
324         chip->mixer_data = NULL;
325         chip->mixer_free = NULL;
326 }
327
328
329 /*
330  * mixer controls
331  */
332 static 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
342 static 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
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         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
372 static 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
387 static 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
404 static 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
414 static 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
426 static 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
446 static 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
456 static 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
466 static 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
487 static 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
524 static 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
533 static 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 /* PMAC_AMP_AVAIL */
543
544
545 /*
546  * mic boost for screamer
547  */
548 static 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
558 static 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
575 static 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  * lists of mixer elements
604  */
605 static 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 /*      AWACS_SWITCH("Unknown Playback Switch", 6, SHIFT_PAROUT0, 0), */
609 };
610
611 static 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
618 static 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
624 static 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
631 static 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
637 static 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 /* FIXME: is this correct order?
643  * screamer (powerbook G3 pismo) seems to have different bits...
644  */
645 static 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
650 static 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
655 static struct snd_kcontrol_new snd_pmac_awacs_master_sw __initdata =
656 AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
657
658 static struct snd_kcontrol_new snd_pmac_awacs_master_sw_imac __initdata =
659 AWACS_SWITCH("Line out Playback Switch", 1, SHIFT_HDMUTE, 1);
660
661 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __initdata = {
662         AWACS_SWITCH("Mic Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
663 };
664
665 static 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
674 static 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
679 static 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
685 static 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
691 static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __initdata = {
692         AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1),
693 };
694
695 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __initdata =
696 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
697
698 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac1 __initdata =
699 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 1);
700
701 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac2 __initdata =
702 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
703
704
705 /*
706  * add new mixer elements to the card
707  */
708 static 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  * restore all registers
724  */
725 static 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
739 static 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
745 static 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                 /* reset power bits in reg 6 */
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 /* CONFIG_PM */
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
783 static int imac1, imac2;
784
785 #ifdef PMAC_SUPPORT_AUTOMUTE
786 /*
787  * auto-mute stuffs
788  */
789 static 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
795 static 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
808 static 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 /* PMAC_SUPPORT_AUTOMUTE */
859
860
861 /*
862  * initialize chip
863  */
864 int __init
865 snd_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         /* looks like MASK_GAINLINE triggers something, so we set here
877          * as start-up
878          */
879         chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
880         chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
881         /* FIXME: Only machines with external SRS module need MASK_PAROUT */
882         if (chip->has_iic || chip->device_id == 0x5 ||
883             /* chip->_device_id == 0x8 || */
884             chip->device_id == 0xb)
885                 chip->awacs_reg[1] |= MASK_PAROUT;
886         /* get default volume from nvram */
887         // vol = (~nvram_read_byte(0x1308) & 7) << 1;
888         // vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
889         vol = 0x0f; /* no, on alsa, muted as default */
890         vol = vol + (vol << 6);
891         chip->awacs_reg[2] = vol;
892         chip->awacs_reg[4] = vol;
893         if (chip->model == PMAC_SCREAMER) {
894                 /* FIXME: screamer has loopthru vol control */
895                 chip->awacs_reg[5] = vol;
896                 /* FIXME: maybe should be vol << 3 for PCMCIA speaker */
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                 /* mute and zero vol */
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); /* 0 dB */
917                 awacs_amp_set_master(amp, 79); /* 0 dB */
918         }
919 #endif /* PMAC_AMP_AVAIL */
920
921         if (chip->hp_stat_mask == 0) {
922                 /* set headphone-jack detection bit */
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          * build mixers
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                 /* use amplifier.  the signal is connected from route A
1003                  * to the amp.  the amp has its headphone and speaker
1004                  * volumes and mute switches, so we use them instead of
1005                  * screamer registers.
1006                  * in this case, it seems the route C is not used.
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                 /* overwrite */
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 /* PMAC_AMP_AVAIL */
1025         {
1026                 /* route A = headphone, route C = speaker */
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          * set lowlevel callbacks
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); /* update the status only */
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 }