ALSA: powermac - Replace the rest of __init*
[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[] __devinitdata = {
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 __devinitdata = {
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 __devinitdata = {
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[] __devinitdata = {
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[] __devinitdata = {
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_lo[] __devinitdata = {
612         AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
613 };
614
615 static struct snd_kcontrol_new snd_pmac_screamer_mixers_imac[] __devinitdata = {
616         AWACS_VOLUME("Play-through Playback Volume", 5, 6, 1),
617         AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
618 };
619
620 static struct snd_kcontrol_new snd_pmac_screamer_mixers_g4agp[] __devinitdata = {
621         AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
622         AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
623         AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
624         AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
625 };
626
627 static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac7500[] __devinitdata = {
628         AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
629         AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
630         AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
631 };
632
633 static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac5500[] __devinitdata = {
634         AWACS_VOLUME("Headphone Playback Volume", 2, 6, 1),
635 };
636
637 static struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac[] __devinitdata = {
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[] __devinitdata = {
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[] __devinitdata = {
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_mixers2_pmac5500[] __devinitdata = {
656         AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
657 };
658
659 static struct snd_kcontrol_new snd_pmac_awacs_master_sw __devinitdata =
660 AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
661
662 static struct snd_kcontrol_new snd_pmac_awacs_master_sw_imac __devinitdata =
663 AWACS_SWITCH("Line out Playback Switch", 1, SHIFT_HDMUTE, 1);
664
665 static struct snd_kcontrol_new snd_pmac_awacs_master_sw_pmac5500 __devinitdata =
666 AWACS_SWITCH("Headphone Playback Switch", 1, SHIFT_HDMUTE, 1);
667
668 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __devinitdata = {
669         AWACS_SWITCH("Mic Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
670 };
671
672 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __devinitdata = {
673         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
674           .name = "Mic Boost Capture Volume",
675           .info = snd_pmac_screamer_mic_boost_info,
676           .get = snd_pmac_screamer_mic_boost_get,
677           .put = snd_pmac_screamer_mic_boost_put,
678         },
679 };
680
681 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost_pmac7500[] __devinitdata =
682 {
683         AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
684 };
685
686 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_beige[] __devinitdata =
687 {
688         AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
689         AWACS_SWITCH("CD Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
690 };
691
692 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost_imac[] __devinitdata =
693 {
694         AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
695         AWACS_SWITCH("Mic Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
696 };
697
698 static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __devinitdata = {
699         AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1),
700 };
701
702 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __devinitdata =
703 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
704
705 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac1 __devinitdata =
706 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 1);
707
708 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac2 __devinitdata =
709 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
710
711
712 /*
713  * add new mixer elements to the card
714  */
715 static int build_mixers(struct snd_pmac *chip, int nums,
716                         struct snd_kcontrol_new *mixers)
717 {
718         int i, err;
719
720         for (i = 0; i < nums; i++) {
721                 err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip));
722                 if (err < 0)
723                         return err;
724         }
725         return 0;
726 }
727
728
729 /*
730  * restore all registers
731  */
732 static void awacs_restore_all_regs(struct snd_pmac *chip)
733 {
734         snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
735         snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
736         snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
737         snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
738         if (chip->model == PMAC_SCREAMER) {
739                 snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
740                 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
741                 snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
742         }
743 }
744
745 #ifdef CONFIG_PM
746 static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
747 {
748         snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
749                                              | MASK_AMUTE | MASK_CMUTE));
750 }
751
752 static void snd_pmac_awacs_resume(struct snd_pmac *chip)
753 {
754         if (machine_is_compatible("PowerBook3,1")
755             || machine_is_compatible("PowerBook3,2")) {
756                 msleep(100);
757                 snd_pmac_awacs_write_reg(chip, 1,
758                         chip->awacs_reg[1] & ~MASK_PAROUT);
759                 msleep(300);
760         }
761
762         awacs_restore_all_regs(chip);
763         if (chip->model == PMAC_SCREAMER) {
764                 /* reset power bits in reg 6 */
765                 mdelay(5);
766                 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
767         }
768         screamer_recalibrate(chip);
769 #ifdef PMAC_AMP_AVAIL
770         if (chip->mixer_data) {
771                 struct awacs_amp *amp = chip->mixer_data;
772                 awacs_amp_set_vol(amp, 0,
773                                   amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
774                 awacs_amp_set_vol(amp, 1,
775                                   amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
776                 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
777                 awacs_amp_set_master(amp, amp->amp_master);
778         }
779 #endif
780 }
781 #endif /* CONFIG_PM */
782
783 #define IS_PM7500 (machine_is_compatible("AAPL,7500") \
784                 || machine_is_compatible("AAPL,8500") \
785                 || machine_is_compatible("AAPL,9500"))
786 #define IS_PM5500 (machine_is_compatible("AAPL,e411"))
787 #define IS_BEIGE (machine_is_compatible("AAPL,Gossamer"))
788 #define IS_IMAC1 (machine_is_compatible("PowerMac2,1"))
789 #define IS_IMAC2 (machine_is_compatible("PowerMac2,2") \
790                 || machine_is_compatible("PowerMac4,1"))
791 #define IS_G4AGP (machine_is_compatible("PowerMac3,1"))
792 #define IS_LOMBARD (machine_is_compatible("PowerBook1,1"))
793
794 static int imac1, imac2;
795
796 #ifdef PMAC_SUPPORT_AUTOMUTE
797 /*
798  * auto-mute stuffs
799  */
800 static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip)
801 {
802         return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
803 }
804
805 #ifdef PMAC_AMP_AVAIL
806 static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute)
807 {
808         int vol[2];
809         vol[0] = amp->amp_vol[index][0] & 31;
810         vol[1] = amp->amp_vol[index][1] & 31;
811         if (mute) {
812                 vol[0] |= 32;
813                 vol[1] |= 32;
814         }
815         return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
816 }
817 #endif
818
819 static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify)
820 {
821         if (chip->auto_mute) {
822 #ifdef PMAC_AMP_AVAIL
823                 if (chip->mixer_data) {
824                         struct awacs_amp *amp = chip->mixer_data;
825                         int changed;
826                         if (snd_pmac_awacs_detect_headphone(chip)) {
827                                 changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
828                                 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
829                         } else {
830                                 changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
831                                 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
832                         }
833                         if (do_notify && ! changed)
834                                 return;
835                 } else
836 #endif
837                 {
838                         int reg = chip->awacs_reg[1]
839                                 | (MASK_HDMUTE | MASK_SPKMUTE);
840                         if (imac1) {
841                                 reg &= ~MASK_SPKMUTE;
842                                 reg |= MASK_PAROUT1;
843                         } else if (imac2) {
844                                 reg &= ~MASK_SPKMUTE;
845                                 reg &= ~MASK_PAROUT1;
846                         }
847                         if (snd_pmac_awacs_detect_headphone(chip))
848                                 reg &= ~MASK_HDMUTE;
849                         else if (imac1)
850                                 reg &= ~MASK_PAROUT1;
851                         else if (imac2)
852                                 reg |= MASK_PAROUT1;
853                         else
854                                 reg &= ~MASK_SPKMUTE;
855                         if (do_notify && reg == chip->awacs_reg[1])
856                                 return;
857                         snd_pmac_awacs_write_reg(chip, 1, reg);
858                 }
859                 if (do_notify) {
860                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
861                                        &chip->master_sw_ctl->id);
862                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
863                                        &chip->speaker_sw_ctl->id);
864                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
865                                        &chip->hp_detect_ctl->id);
866                 }
867         }
868 }
869 #endif /* PMAC_SUPPORT_AUTOMUTE */
870
871
872 /*
873  * initialize chip
874  */
875 int __devinit
876 snd_pmac_awacs_init(struct snd_pmac *chip)
877 {
878         int pm7500 = IS_PM7500;
879         int pm5500 = IS_PM5500;
880         int beige = IS_BEIGE;
881         int g4agp = IS_G4AGP;
882         int lombard = IS_LOMBARD;
883         int imac;
884         int err, vol;
885         struct snd_kcontrol *vmaster_sw, *vmaster_vol;
886         struct snd_kcontrol *master_vol, *speaker_vol;
887
888         imac1 = IS_IMAC1;
889         imac2 = IS_IMAC2;
890         imac = imac1 || imac2;
891         /* looks like MASK_GAINLINE triggers something, so we set here
892          * as start-up
893          */
894         chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
895         chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
896         /* FIXME: Only machines with external SRS module need MASK_PAROUT */
897         if (chip->has_iic || chip->device_id == 0x5 ||
898             /* chip->_device_id == 0x8 || */
899             chip->device_id == 0xb)
900                 chip->awacs_reg[1] |= MASK_PAROUT;
901         /* get default volume from nvram */
902         // vol = (~nvram_read_byte(0x1308) & 7) << 1;
903         // vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
904         vol = 0x0f; /* no, on alsa, muted as default */
905         vol = vol + (vol << 6);
906         chip->awacs_reg[2] = vol;
907         chip->awacs_reg[4] = vol;
908         if (chip->model == PMAC_SCREAMER) {
909                 /* FIXME: screamer has loopthru vol control */
910                 chip->awacs_reg[5] = vol;
911                 /* FIXME: maybe should be vol << 3 for PCMCIA speaker */
912                 chip->awacs_reg[6] = MASK_MIC_BOOST;
913                 chip->awacs_reg[7] = 0;
914         }
915
916         awacs_restore_all_regs(chip);
917         chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
918         screamer_recalibrate(chip);
919
920         chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
921 #ifdef PMAC_AMP_AVAIL
922         if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
923                 struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
924                 if (! amp)
925                         return -ENOMEM;
926                 chip->mixer_data = amp;
927                 chip->mixer_free = awacs_amp_free;
928                 /* mute and zero vol */
929                 awacs_amp_set_vol(amp, 0, 63, 63, 0);
930                 awacs_amp_set_vol(amp, 1, 63, 63, 0);
931                 awacs_amp_set_tone(amp, 7, 7); /* 0 dB */
932                 awacs_amp_set_master(amp, 79); /* 0 dB */
933         }
934 #endif /* PMAC_AMP_AVAIL */
935
936         if (chip->hp_stat_mask == 0) {
937                 /* set headphone-jack detection bit */
938                 switch (chip->model) {
939                 case PMAC_AWACS:
940                         chip->hp_stat_mask = pm7500 || pm5500 ? MASK_HDPCONN
941                                 : MASK_LOCONN;
942                         break;
943                 case PMAC_SCREAMER:
944                         switch (chip->device_id) {
945                         case 0x08:
946                         case 0x0B:
947                                 chip->hp_stat_mask = imac
948                                         ? MASK_LOCONN_IMAC |
949                                         MASK_HDPLCONN_IMAC |
950                                         MASK_HDPRCONN_IMAC
951                                         : MASK_HDPCONN;
952                                 break;
953                         case 0x00:
954                         case 0x05:
955                                 chip->hp_stat_mask = MASK_LOCONN;
956                                 break;
957                         default:
958                                 chip->hp_stat_mask = MASK_HDPCONN;
959                                 break;
960                         }
961                         break;
962                 default:
963                         snd_BUG();
964                         break;
965                 }
966         }
967
968         /*
969          * build mixers
970          */
971         strcpy(chip->card->mixername, "PowerMac AWACS");
972
973         err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
974                                 snd_pmac_awacs_mixers);
975         if (err < 0)
976                 return err;
977         if (beige || g4agp)
978                 ;
979         else if (chip->model == PMAC_SCREAMER || pm5500)
980                 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
981                                    snd_pmac_screamer_mixers2);
982         else if (!pm7500)
983                 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
984                                    snd_pmac_awacs_mixers2);
985         if (err < 0)
986                 return err;
987         if (pm5500) {
988                 err = build_mixers(chip,
989                                    ARRAY_SIZE(snd_pmac_awacs_mixers2_pmac5500),
990                                    snd_pmac_awacs_mixers2_pmac5500);
991                 if (err < 0)
992                         return err;
993         }
994         if (pm7500)
995                 err = build_mixers(chip,
996                                    ARRAY_SIZE(snd_pmac_awacs_mixers_pmac7500),
997                                    snd_pmac_awacs_mixers_pmac7500);
998         else if (pm5500)
999                 err = snd_ctl_add(chip->card,
1000                     (master_vol = snd_ctl_new1(snd_pmac_awacs_mixers_pmac5500,
1001                                                 chip)));
1002         else if (beige)
1003                 err = build_mixers(chip,
1004                                    ARRAY_SIZE(snd_pmac_screamer_mixers_beige),
1005                                    snd_pmac_screamer_mixers_beige);
1006         else if (imac || lombard) {
1007                 err = snd_ctl_add(chip->card,
1008                     (master_vol = snd_ctl_new1(snd_pmac_screamer_mixers_lo,
1009                                                 chip)));
1010                 if (err < 0)
1011                         return err;
1012                 err = build_mixers(chip,
1013                                    ARRAY_SIZE(snd_pmac_screamer_mixers_imac),
1014                                    snd_pmac_screamer_mixers_imac);
1015         } else if (g4agp)
1016                 err = build_mixers(chip,
1017                                    ARRAY_SIZE(snd_pmac_screamer_mixers_g4agp),
1018                                    snd_pmac_screamer_mixers_g4agp);
1019         else
1020                 err = build_mixers(chip,
1021                                    ARRAY_SIZE(snd_pmac_awacs_mixers_pmac),
1022                                    snd_pmac_awacs_mixers_pmac);
1023         if (err < 0)
1024                 return err;
1025         chip->master_sw_ctl = snd_ctl_new1((pm7500 || imac || g4agp || lombard)
1026                         ? &snd_pmac_awacs_master_sw_imac
1027                         : pm5500
1028                         ? &snd_pmac_awacs_master_sw_pmac5500
1029                         : &snd_pmac_awacs_master_sw, chip);
1030         err = snd_ctl_add(chip->card, chip->master_sw_ctl);
1031         if (err < 0)
1032                 return err;
1033 #ifdef PMAC_AMP_AVAIL
1034         if (chip->mixer_data) {
1035                 /* use amplifier.  the signal is connected from route A
1036                  * to the amp.  the amp has its headphone and speaker
1037                  * volumes and mute switches, so we use them instead of
1038                  * screamer registers.
1039                  * in this case, it seems the route C is not used.
1040                  */
1041                 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
1042                                         snd_pmac_awacs_amp_vol);
1043                 if (err < 0)
1044                         return err;
1045                 /* overwrite */
1046                 chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw,
1047                                                         chip);
1048                 err = snd_ctl_add(chip->card, chip->master_sw_ctl);
1049                 if (err < 0)
1050                         return err;
1051                 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw,
1052                                                         chip);
1053                 err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1054                 if (err < 0)
1055                         return err;
1056         } else
1057 #endif /* PMAC_AMP_AVAIL */
1058         {
1059                 /* route A = headphone, route C = speaker */
1060                 err = snd_ctl_add(chip->card,
1061                     (speaker_vol = snd_ctl_new1(snd_pmac_awacs_speaker_vol,
1062                                                 chip)));
1063                 if (err < 0)
1064                         return err;
1065                 chip->speaker_sw_ctl = snd_ctl_new1(imac1
1066                                 ? &snd_pmac_awacs_speaker_sw_imac1
1067                                 : imac2
1068                                 ? &snd_pmac_awacs_speaker_sw_imac2
1069                                 : &snd_pmac_awacs_speaker_sw, chip);
1070                 err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1071                 if (err < 0)
1072                         return err;
1073         }
1074
1075         if (pm5500 || imac || lombard) {
1076                 vmaster_sw = snd_ctl_make_virtual_master(
1077                         "Master Playback Switch", (unsigned int *) NULL);
1078                 err = snd_ctl_add_slave_uncached(vmaster_sw,
1079                                                  chip->master_sw_ctl);
1080                 if (err < 0)
1081                         return err;
1082                 err = snd_ctl_add_slave_uncached(vmaster_sw,
1083                                                   chip->speaker_sw_ctl);
1084                 if (err < 0)
1085                         return err;
1086                 err = snd_ctl_add(chip->card, vmaster_sw);
1087                 if (err < 0)
1088                         return err;
1089                 vmaster_vol = snd_ctl_make_virtual_master(
1090                         "Master Playback Volume", (unsigned int *) NULL);
1091                 err = snd_ctl_add_slave(vmaster_vol, master_vol);
1092                 if (err < 0)
1093                         return err;
1094                 err = snd_ctl_add_slave(vmaster_vol, speaker_vol);
1095                 if (err < 0)
1096                         return err;
1097                 err = snd_ctl_add(chip->card, vmaster_vol);
1098                 if (err < 0)
1099                         return err;
1100         }
1101
1102         if (beige || g4agp)
1103                 err = build_mixers(chip,
1104                                 ARRAY_SIZE(snd_pmac_screamer_mic_boost_beige),
1105                                 snd_pmac_screamer_mic_boost_beige);
1106         else if (imac)
1107                 err = build_mixers(chip,
1108                                 ARRAY_SIZE(snd_pmac_screamer_mic_boost_imac),
1109                                 snd_pmac_screamer_mic_boost_imac);
1110         else if (chip->model == PMAC_SCREAMER)
1111                 err = build_mixers(chip,
1112                                 ARRAY_SIZE(snd_pmac_screamer_mic_boost),
1113                                 snd_pmac_screamer_mic_boost);
1114         else if (pm7500)
1115                 err = build_mixers(chip,
1116                                 ARRAY_SIZE(snd_pmac_awacs_mic_boost_pmac7500),
1117                                 snd_pmac_awacs_mic_boost_pmac7500);
1118         else
1119                 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
1120                                 snd_pmac_awacs_mic_boost);
1121         if (err < 0)
1122                 return err;
1123
1124         /*
1125          * set lowlevel callbacks
1126          */
1127         chip->set_format = snd_pmac_awacs_set_format;
1128 #ifdef CONFIG_PM
1129         chip->suspend = snd_pmac_awacs_suspend;
1130         chip->resume = snd_pmac_awacs_resume;
1131 #endif
1132 #ifdef PMAC_SUPPORT_AUTOMUTE
1133         err = snd_pmac_add_automute(chip);
1134         if (err < 0)
1135                 return err;
1136         chip->detect_headphone = snd_pmac_awacs_detect_headphone;
1137         chip->update_automute = snd_pmac_awacs_update_automute;
1138         snd_pmac_awacs_update_automute(chip, 0); /* update the status only */
1139 #endif
1140         if (chip->model == PMAC_SCREAMER) {
1141                 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
1142                 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
1143         }
1144
1145         return 0;
1146 }