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