Merge branch 'hwmon-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6
[sfrench/cifs-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 <sound/driver.h>
24 #include <asm/io.h>
25 #include <asm/nvram.h>
26 #include <linux/init.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <sound/core.h>
30 #include "pmac.h"
31
32
33 #ifdef CONFIG_ADB_CUDA
34 #define PMAC_AMP_AVAIL
35 #endif
36
37 #ifdef PMAC_AMP_AVAIL
38 struct awacs_amp {
39         unsigned char amp_master;
40         unsigned char amp_vol[2][2];
41         unsigned char amp_tone[2];
42 };
43
44 #define CHECK_CUDA_AMP() (sys_ctrler == SYS_CTRLER_CUDA)
45
46 #endif /* PMAC_AMP_AVAIL */
47
48
49 static void snd_pmac_screamer_wait(struct snd_pmac *chip)
50 {
51         long timeout = 2000;
52         while (!(in_le32(&chip->awacs->codec_stat) & MASK_VALID)) {
53                 mdelay(1);
54                 if (! --timeout) {
55                         snd_printd("snd_pmac_screamer_wait timeout\n");
56                         break;
57                 }
58         }
59 }
60
61 /*
62  * write AWACS register
63  */
64 static void
65 snd_pmac_awacs_write(struct snd_pmac *chip, int val)
66 {
67         long timeout = 5000000;
68
69         if (chip->model == PMAC_SCREAMER)
70                 snd_pmac_screamer_wait(chip);
71         out_le32(&chip->awacs->codec_ctrl, val | (chip->subframe << 22));
72         while (in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) {
73                 if (! --timeout) {
74                         snd_printd("snd_pmac_awacs_write timeout\n");
75                         break;
76                 }
77         }
78 }
79
80 static void
81 snd_pmac_awacs_write_reg(struct snd_pmac *chip, int reg, int val)
82 {
83         snd_pmac_awacs_write(chip, val | (reg << 12));
84         chip->awacs_reg[reg] = val;
85 }
86
87 static void
88 snd_pmac_awacs_write_noreg(struct snd_pmac *chip, int reg, int val)
89 {
90         snd_pmac_awacs_write(chip, val | (reg << 12));
91 }
92
93 #ifdef CONFIG_PM
94 /* Recalibrate chip */
95 static void screamer_recalibrate(struct snd_pmac *chip)
96 {
97         if (chip->model != PMAC_SCREAMER)
98                 return;
99
100         /* Sorry for the horrible delays... I hope to get that improved
101          * by making the whole PM process asynchronous in a future version
102          */
103         snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
104         if (chip->manufacturer == 0x1)
105                 /* delay for broken crystal part */
106                 msleep(750);
107         snd_pmac_awacs_write_noreg(chip, 1,
108                                    chip->awacs_reg[1] | MASK_RECALIBRATE |
109                                    MASK_CMUTE | MASK_AMUTE);
110         snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
111         snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
112 }
113
114 #else
115 #define screamer_recalibrate(chip) /* NOP */
116 #endif
117
118
119 /*
120  * additional callback to set the pcm format
121  */
122 static void snd_pmac_awacs_set_format(struct snd_pmac *chip)
123 {
124         chip->awacs_reg[1] &= ~MASK_SAMPLERATE;
125         chip->awacs_reg[1] |= chip->rate_index << 3;
126         snd_pmac_awacs_write_reg(chip, 1, chip->awacs_reg[1]);
127 }
128
129
130 /*
131  * AWACS volume callbacks
132  */
133 /*
134  * volumes: 0-15 stereo
135  */
136 static int snd_pmac_awacs_info_volume(struct snd_kcontrol *kcontrol,
137                                       struct snd_ctl_elem_info *uinfo)
138 {
139         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
140         uinfo->count = 2;
141         uinfo->value.integer.min = 0;
142         uinfo->value.integer.max = 15;
143         return 0;
144 }
145  
146 static int snd_pmac_awacs_get_volume(struct snd_kcontrol *kcontrol,
147                                      struct snd_ctl_elem_value *ucontrol)
148 {
149         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
150         int reg = kcontrol->private_value & 0xff;
151         int lshift = (kcontrol->private_value >> 8) & 0xff;
152         int inverted = (kcontrol->private_value >> 16) & 1;
153         unsigned long flags;
154         int vol[2];
155
156         spin_lock_irqsave(&chip->reg_lock, flags);
157         vol[0] = (chip->awacs_reg[reg] >> lshift) & 0xf;
158         vol[1] = chip->awacs_reg[reg] & 0xf;
159         spin_unlock_irqrestore(&chip->reg_lock, flags);
160         if (inverted) {
161                 vol[0] = 0x0f - vol[0];
162                 vol[1] = 0x0f - vol[1];
163         }
164         ucontrol->value.integer.value[0] = vol[0];
165         ucontrol->value.integer.value[1] = vol[1];
166         return 0;
167 }
168
169 static int snd_pmac_awacs_put_volume(struct snd_kcontrol *kcontrol,
170                                      struct snd_ctl_elem_value *ucontrol)
171 {
172         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
173         int reg = kcontrol->private_value & 0xff;
174         int lshift = (kcontrol->private_value >> 8) & 0xff;
175         int inverted = (kcontrol->private_value >> 16) & 1;
176         int val, oldval;
177         unsigned long flags;
178         int vol[2];
179
180         vol[0] = ucontrol->value.integer.value[0];
181         vol[1] = ucontrol->value.integer.value[1];
182         if (inverted) {
183                 vol[0] = 0x0f - vol[0];
184                 vol[1] = 0x0f - vol[1];
185         }
186         vol[0] &= 0x0f;
187         vol[1] &= 0x0f;
188         spin_lock_irqsave(&chip->reg_lock, flags);
189         oldval = chip->awacs_reg[reg];
190         val = oldval & ~(0xf | (0xf << lshift));
191         val |= vol[0] << lshift;
192         val |= vol[1];
193         if (oldval != val)
194                 snd_pmac_awacs_write_reg(chip, reg, val);
195         spin_unlock_irqrestore(&chip->reg_lock, flags);
196         return oldval != reg;
197 }
198
199
200 #define AWACS_VOLUME(xname, xreg, xshift, xinverted) \
201 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
202   .info = snd_pmac_awacs_info_volume, \
203   .get = snd_pmac_awacs_get_volume, \
204   .put = snd_pmac_awacs_put_volume, \
205   .private_value = (xreg) | ((xshift) << 8) | ((xinverted) << 16) }
206
207 /*
208  * mute master/ogain for AWACS: mono
209  */
210 static int snd_pmac_awacs_get_switch(struct snd_kcontrol *kcontrol,
211                                      struct snd_ctl_elem_value *ucontrol)
212 {
213         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
214         int reg = kcontrol->private_value & 0xff;
215         int shift = (kcontrol->private_value >> 8) & 0xff;
216         int invert = (kcontrol->private_value >> 16) & 1;
217         int val;
218         unsigned long flags;
219
220         spin_lock_irqsave(&chip->reg_lock, flags);
221         val = (chip->awacs_reg[reg] >> shift) & 1;
222         spin_unlock_irqrestore(&chip->reg_lock, flags);
223         if (invert)
224                 val = 1 - val;
225         ucontrol->value.integer.value[0] = val;
226         return 0;
227 }
228
229 static int snd_pmac_awacs_put_switch(struct snd_kcontrol *kcontrol,
230                                      struct snd_ctl_elem_value *ucontrol)
231 {
232         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
233         int reg = kcontrol->private_value & 0xff;
234         int shift = (kcontrol->private_value >> 8) & 0xff;
235         int invert = (kcontrol->private_value >> 16) & 1;
236         int mask = 1 << shift;
237         int val, changed;
238         unsigned long flags;
239
240         spin_lock_irqsave(&chip->reg_lock, flags);
241         val = chip->awacs_reg[reg] & ~mask;
242         if (ucontrol->value.integer.value[0] != invert)
243                 val |= mask;
244         changed = chip->awacs_reg[reg] != val;
245         if (changed)
246                 snd_pmac_awacs_write_reg(chip, reg, val);
247         spin_unlock_irqrestore(&chip->reg_lock, flags);
248         return changed;
249 }
250
251 #define AWACS_SWITCH(xname, xreg, xshift, xinvert) \
252 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
253   .info = snd_pmac_boolean_mono_info, \
254   .get = snd_pmac_awacs_get_switch, \
255   .put = snd_pmac_awacs_put_switch, \
256   .private_value = (xreg) | ((xshift) << 8) | ((xinvert) << 16) }
257
258
259 #ifdef PMAC_AMP_AVAIL
260 /*
261  * controls for perch/whisper extension cards, e.g. G3 desktop
262  *
263  * TDA7433 connected via i2c address 0x45 (= 0x8a),
264  * accessed through cuda
265  */
266 static void awacs_set_cuda(int reg, int val)
267 {
268         struct adb_request req;
269         cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC, 0x8a, reg, val);
270         while (! req.complete)
271                 cuda_poll();
272 }
273
274 /*
275  * level = 0 - 14, 7 = 0 dB
276  */
277 static void awacs_amp_set_tone(struct awacs_amp *amp, int bass, int treble)
278 {
279         amp->amp_tone[0] = bass;
280         amp->amp_tone[1] = treble;
281         if (bass > 7)
282                 bass = (14 - bass) + 8;
283         if (treble > 7)
284                 treble = (14 - treble) + 8;
285         awacs_set_cuda(2, (bass << 4) | treble);
286 }
287
288 /*
289  * vol = 0 - 31 (attenuation), 32 = mute bit, stereo
290  */
291 static int awacs_amp_set_vol(struct awacs_amp *amp, int index, int lvol, int rvol,
292                              int do_check)
293 {
294         if (do_check && amp->amp_vol[index][0] == lvol &&
295             amp->amp_vol[index][1] == rvol)
296                 return 0;
297         awacs_set_cuda(3 + index, lvol);
298         awacs_set_cuda(5 + index, rvol);
299         amp->amp_vol[index][0] = lvol;
300         amp->amp_vol[index][1] = rvol;
301         return 1;
302 }
303
304 /*
305  * 0 = -79 dB, 79 = 0 dB, 99 = +20 dB
306  */
307 static void awacs_amp_set_master(struct awacs_amp *amp, int vol)
308 {
309         amp->amp_master = vol;
310         if (vol <= 79)
311                 vol = 32 + (79 - vol);
312         else
313                 vol = 32 - (vol - 79);
314         awacs_set_cuda(1, vol);
315 }
316
317 static void awacs_amp_free(struct snd_pmac *chip)
318 {
319         struct awacs_amp *amp = chip->mixer_data;
320         snd_assert(amp, return);
321         kfree(amp);
322         chip->mixer_data = NULL;
323         chip->mixer_free = NULL;
324 }
325
326
327 /*
328  * mixer controls
329  */
330 static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol,
331                                           struct snd_ctl_elem_info *uinfo)
332 {
333         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
334         uinfo->count = 2;
335         uinfo->value.integer.min = 0;
336         uinfo->value.integer.max = 31;
337         return 0;
338 }
339  
340 static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol,
341                                          struct snd_ctl_elem_value *ucontrol)
342 {
343         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
344         int index = kcontrol->private_value;
345         struct awacs_amp *amp = chip->mixer_data;
346         snd_assert(amp, return -EINVAL);
347         snd_assert(index >= 0 && index <= 1, return -EINVAL);
348         ucontrol->value.integer.value[0] = 31 - (amp->amp_vol[index][0] & 31);
349         ucontrol->value.integer.value[1] = 31 - (amp->amp_vol[index][1] & 31);
350         return 0;
351 }
352
353 static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol,
354                                          struct snd_ctl_elem_value *ucontrol)
355 {
356         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
357         int index = kcontrol->private_value;
358         int vol[2];
359         struct awacs_amp *amp = chip->mixer_data;
360         snd_assert(amp, return -EINVAL);
361         snd_assert(index >= 0 && index <= 1, return -EINVAL);
362
363         vol[0] = (31 - (ucontrol->value.integer.value[0] & 31)) | (amp->amp_vol[index][0] & 32);
364         vol[1] = (31 - (ucontrol->value.integer.value[1] & 31)) | (amp->amp_vol[index][1] & 32);
365         return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
366 }
367
368 static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol,
369                                          struct snd_ctl_elem_value *ucontrol)
370 {
371         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
372         int index = kcontrol->private_value;
373         struct awacs_amp *amp = chip->mixer_data;
374         snd_assert(amp, return -EINVAL);
375         snd_assert(index >= 0 && index <= 1, return -EINVAL);
376         ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32) ? 0 : 1;
377         ucontrol->value.integer.value[1] = (amp->amp_vol[index][1] & 32) ? 0 : 1;
378         return 0;
379 }
380
381 static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol,
382                                          struct snd_ctl_elem_value *ucontrol)
383 {
384         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
385         int index = kcontrol->private_value;
386         int vol[2];
387         struct awacs_amp *amp = chip->mixer_data;
388         snd_assert(amp, return -EINVAL);
389         snd_assert(index >= 0 && index <= 1, return -EINVAL);
390
391         vol[0] = (ucontrol->value.integer.value[0] ? 0 : 32) | (amp->amp_vol[index][0] & 31);
392         vol[1] = (ucontrol->value.integer.value[1] ? 0 : 32) | (amp->amp_vol[index][1] & 31);
393         return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
394 }
395
396 static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol,
397                                         struct snd_ctl_elem_info *uinfo)
398 {
399         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
400         uinfo->count = 1;
401         uinfo->value.integer.min = 0;
402         uinfo->value.integer.max = 14;
403         return 0;
404 }
405  
406 static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol,
407                                        struct snd_ctl_elem_value *ucontrol)
408 {
409         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
410         int index = kcontrol->private_value;
411         struct awacs_amp *amp = chip->mixer_data;
412         snd_assert(amp, return -EINVAL);
413         snd_assert(index >= 0 && index <= 1, return -EINVAL);
414         ucontrol->value.integer.value[0] = amp->amp_tone[index];
415         return 0;
416 }
417
418 static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol,
419                                        struct snd_ctl_elem_value *ucontrol)
420 {
421         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
422         int index = kcontrol->private_value;
423         struct awacs_amp *amp = chip->mixer_data;
424         snd_assert(amp, return -EINVAL);
425         snd_assert(index >= 0 && index <= 1, return -EINVAL);
426         if (ucontrol->value.integer.value[0] != amp->amp_tone[index]) {
427                 amp->amp_tone[index] = ucontrol->value.integer.value[0];
428                 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
429                 return 1;
430         }
431         return 0;
432 }
433
434 static int snd_pmac_awacs_info_master_amp(struct snd_kcontrol *kcontrol,
435                                           struct snd_ctl_elem_info *uinfo)
436 {
437         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
438         uinfo->count = 1;
439         uinfo->value.integer.min = 0;
440         uinfo->value.integer.max = 99;
441         return 0;
442 }
443  
444 static int snd_pmac_awacs_get_master_amp(struct snd_kcontrol *kcontrol,
445                                          struct snd_ctl_elem_value *ucontrol)
446 {
447         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
448         struct awacs_amp *amp = chip->mixer_data;
449         snd_assert(amp, return -EINVAL);
450         ucontrol->value.integer.value[0] = amp->amp_master;
451         return 0;
452 }
453
454 static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol,
455                                          struct snd_ctl_elem_value *ucontrol)
456 {
457         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
458         struct awacs_amp *amp = chip->mixer_data;
459         snd_assert(amp, return -EINVAL);
460         if (ucontrol->value.integer.value[0] != amp->amp_master) {
461                 amp->amp_master = ucontrol->value.integer.value[0];
462                 awacs_amp_set_master(amp, amp->amp_master);
463                 return 1;
464         }
465         return 0;
466 }
467
468 #define AMP_CH_SPK      0
469 #define AMP_CH_HD       1
470
471 static struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] __initdata = {
472         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
473           .name = "PC Speaker Playback Volume",
474           .info = snd_pmac_awacs_info_volume_amp,
475           .get = snd_pmac_awacs_get_volume_amp,
476           .put = snd_pmac_awacs_put_volume_amp,
477           .private_value = AMP_CH_SPK,
478         },
479         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
480           .name = "Headphone Playback Volume",
481           .info = snd_pmac_awacs_info_volume_amp,
482           .get = snd_pmac_awacs_get_volume_amp,
483           .put = snd_pmac_awacs_put_volume_amp,
484           .private_value = AMP_CH_HD,
485         },
486         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
487           .name = "Tone Control - Bass",
488           .info = snd_pmac_awacs_info_tone_amp,
489           .get = snd_pmac_awacs_get_tone_amp,
490           .put = snd_pmac_awacs_put_tone_amp,
491           .private_value = 0,
492         },
493         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
494           .name = "Tone Control - Treble",
495           .info = snd_pmac_awacs_info_tone_amp,
496           .get = snd_pmac_awacs_get_tone_amp,
497           .put = snd_pmac_awacs_put_tone_amp,
498           .private_value = 1,
499         },
500         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
501           .name = "Amp Master Playback Volume",
502           .info = snd_pmac_awacs_info_master_amp,
503           .get = snd_pmac_awacs_get_master_amp,
504           .put = snd_pmac_awacs_put_master_amp,
505         },
506 };
507
508 static struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw __initdata = {
509         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
510         .name = "Headphone Playback Switch",
511         .info = snd_pmac_boolean_stereo_info,
512         .get = snd_pmac_awacs_get_switch_amp,
513         .put = snd_pmac_awacs_put_switch_amp,
514         .private_value = AMP_CH_HD,
515 };
516
517 static struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw __initdata = {
518         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
519         .name = "PC Speaker 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_SPK,
524 };
525
526 #endif /* PMAC_AMP_AVAIL */
527
528
529 /*
530  * mic boost for screamer
531  */
532 static int snd_pmac_screamer_mic_boost_info(struct snd_kcontrol *kcontrol,
533                                             struct snd_ctl_elem_info *uinfo)
534 {
535         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
536         uinfo->count = 1;
537         uinfo->value.integer.min = 0;
538         uinfo->value.integer.max = 2;
539         return 0;
540 }
541
542 static int snd_pmac_screamer_mic_boost_get(struct snd_kcontrol *kcontrol,
543                                            struct snd_ctl_elem_value *ucontrol)
544 {
545         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
546         int val;
547         unsigned long flags;
548
549         spin_lock_irqsave(&chip->reg_lock, flags);
550         if (chip->awacs_reg[6] & MASK_MIC_BOOST)
551                 val = 2;
552         else if (chip->awacs_reg[0] & MASK_GAINLINE)
553                 val = 1;
554         else
555                 val = 0;
556         spin_unlock_irqrestore(&chip->reg_lock, flags);
557         ucontrol->value.integer.value[0] = val;
558         return 0;
559 }
560
561 static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol,
562                                            struct snd_ctl_elem_value *ucontrol)
563 {
564         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
565         int changed = 0;
566         int val0, val6;
567         unsigned long flags;
568
569         spin_lock_irqsave(&chip->reg_lock, flags);
570         val0 = chip->awacs_reg[0] & ~MASK_GAINLINE;
571         val6 = chip->awacs_reg[6] & ~MASK_MIC_BOOST;
572         if (ucontrol->value.integer.value[0] > 0) {
573                 val0 |= MASK_GAINLINE;
574                 if (ucontrol->value.integer.value[0] > 1)
575                         val6 |= MASK_MIC_BOOST;
576         }
577         if (val0 != chip->awacs_reg[0]) {
578                 snd_pmac_awacs_write_reg(chip, 0, val0);
579                 changed = 1;
580         }
581         if (val6 != chip->awacs_reg[6]) {
582                 snd_pmac_awacs_write_reg(chip, 6, val6);
583                 changed = 1;
584         }
585         spin_unlock_irqrestore(&chip->reg_lock, flags);
586         return changed;
587 }
588
589 /*
590  * lists of mixer elements
591  */
592 static struct snd_kcontrol_new snd_pmac_awacs_mixers[] __initdata = {
593         AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
594         AWACS_SWITCH("Master Capture Switch", 1, SHIFT_LOOPTHRU, 0),
595         AWACS_VOLUME("Capture Volume", 0, 4, 0),
596         AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
597 };
598
599 /* FIXME: is this correct order?
600  * screamer (powerbook G3 pismo) seems to have different bits...
601  */
602 static struct snd_kcontrol_new snd_pmac_awacs_mixers2[] __initdata = {
603         AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0),
604         AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0),
605 };
606
607 static struct snd_kcontrol_new snd_pmac_screamer_mixers2[] __initdata = {
608         AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
609         AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
610 };
611
612 static struct snd_kcontrol_new snd_pmac_awacs_master_sw __initdata =
613 AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
614
615 static struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] __initdata = {
616         AWACS_SWITCH("Mic Boost", 0, SHIFT_GAINLINE, 0),
617 };
618
619 static struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] __initdata = {
620         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
621           .name = "Mic Boost",
622           .info = snd_pmac_screamer_mic_boost_info,
623           .get = snd_pmac_screamer_mic_boost_get,
624           .put = snd_pmac_screamer_mic_boost_put,
625         },
626 };
627
628 static struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] __initdata = {
629         AWACS_VOLUME("PC Speaker Playback Volume", 4, 6, 1),
630 };
631 static struct snd_kcontrol_new snd_pmac_awacs_speaker_sw __initdata =
632 AWACS_SWITCH("PC Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
633
634
635 /*
636  * add new mixer elements to the card
637  */
638 static int build_mixers(struct snd_pmac *chip, int nums, struct snd_kcontrol_new *mixers)
639 {
640         int i, err;
641
642         for (i = 0; i < nums; i++) {
643                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip))) < 0)
644                         return err;
645         }
646         return 0;
647 }
648
649
650 /*
651  * restore all registers
652  */
653 static void awacs_restore_all_regs(struct snd_pmac *chip)
654 {
655         snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
656         snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
657         snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
658         snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
659         if (chip->model == PMAC_SCREAMER) {
660                 snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
661                 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
662                 snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
663         }
664 }
665
666 #ifdef CONFIG_PM
667 static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
668 {
669         snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
670                                              | MASK_AMUTE | MASK_CMUTE));
671 }
672
673 static void snd_pmac_awacs_resume(struct snd_pmac *chip)
674 {
675         if (machine_is_compatible("PowerBook3,1")
676             || machine_is_compatible("PowerBook3,2")) {
677                 msleep(100);
678                 snd_pmac_awacs_write_reg(chip, 1,
679                         chip->awacs_reg[1] & ~MASK_PAROUT);
680                 msleep(300);
681         }
682
683         awacs_restore_all_regs(chip);
684         if (chip->model == PMAC_SCREAMER) {
685                 /* reset power bits in reg 6 */
686                 mdelay(5);
687                 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
688         }
689         screamer_recalibrate(chip);
690 #ifdef PMAC_AMP_AVAIL
691         if (chip->mixer_data) {
692                 struct awacs_amp *amp = chip->mixer_data;
693                 awacs_amp_set_vol(amp, 0, amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
694                 awacs_amp_set_vol(amp, 1, amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
695                 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
696                 awacs_amp_set_master(amp, amp->amp_master);
697         }
698 #endif
699 }
700 #endif /* CONFIG_PM */
701
702 #ifdef PMAC_SUPPORT_AUTOMUTE
703 /*
704  * auto-mute stuffs
705  */
706 static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip)
707 {
708         return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
709 }
710
711 #ifdef PMAC_AMP_AVAIL
712 static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute)
713 {
714         int vol[2];
715         vol[0] = amp->amp_vol[index][0] & 31;
716         vol[1] = amp->amp_vol[index][1] & 31;
717         if (mute) {
718                 vol[0] |= 32;
719                 vol[1] |= 32;
720         }
721         return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
722 }
723 #endif
724
725 static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify)
726 {
727         if (chip->auto_mute) {
728 #ifdef PMAC_AMP_AVAIL
729                 if (chip->mixer_data) {
730                         struct awacs_amp *amp = chip->mixer_data;
731                         int changed;
732                         if (snd_pmac_awacs_detect_headphone(chip)) {
733                                 changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
734                                 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
735                         } else {
736                                 changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
737                                 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
738                         }
739                         if (do_notify && ! changed)
740                                 return;
741                 } else
742 #endif
743                 {
744                         int reg = chip->awacs_reg[1] | (MASK_HDMUTE|MASK_SPKMUTE);
745                         if (snd_pmac_awacs_detect_headphone(chip))
746                                 reg &= ~MASK_HDMUTE;
747                         else
748                                 reg &= ~MASK_SPKMUTE;
749                         if (do_notify && reg == chip->awacs_reg[1])
750                                 return;
751                         snd_pmac_awacs_write_reg(chip, 1, reg);
752                 }
753                 if (do_notify) {
754                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
755                                        &chip->master_sw_ctl->id);
756                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
757                                        &chip->speaker_sw_ctl->id);
758                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
759                                        &chip->hp_detect_ctl->id);
760                 }
761         }
762 }
763 #endif /* PMAC_SUPPORT_AUTOMUTE */
764
765
766 /*
767  * initialize chip
768  */
769 int __init
770 snd_pmac_awacs_init(struct snd_pmac *chip)
771 {
772         int err, vol;
773
774         /* looks like MASK_GAINLINE triggers something, so we set here
775          * as start-up
776          */
777         chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
778         chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
779         /* FIXME: Only machines with external SRS module need MASK_PAROUT */
780         if (chip->has_iic || chip->device_id == 0x5 ||
781             /*chip->_device_id == 0x8 || */
782             chip->device_id == 0xb)
783                 chip->awacs_reg[1] |= MASK_PAROUT;
784         /* get default volume from nvram */
785         // vol = (~nvram_read_byte(0x1308) & 7) << 1;
786         // vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
787         vol = 0x0f; /* no, on alsa, muted as default */
788         vol = vol + (vol << 6);
789         chip->awacs_reg[2] = vol;
790         chip->awacs_reg[4] = vol;
791         if (chip->model == PMAC_SCREAMER) {
792                 chip->awacs_reg[5] = vol; /* FIXME: screamer has loopthru vol control */
793                 chip->awacs_reg[6] = MASK_MIC_BOOST; /* FIXME: maybe should be vol << 3 for PCMCIA speaker */
794                 chip->awacs_reg[7] = 0;
795         }
796
797         awacs_restore_all_regs(chip);
798         chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
799         screamer_recalibrate(chip);
800
801         chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
802 #ifdef PMAC_AMP_AVAIL
803         if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
804                 struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
805                 if (! amp)
806                         return -ENOMEM;
807                 chip->mixer_data = amp;
808                 chip->mixer_free = awacs_amp_free;
809                 awacs_amp_set_vol(amp, 0, 63, 63, 0); /* mute and zero vol */
810                 awacs_amp_set_vol(amp, 1, 63, 63, 0);
811                 awacs_amp_set_tone(amp, 7, 7); /* 0 dB */
812                 awacs_amp_set_master(amp, 79); /* 0 dB */
813         }
814 #endif /* PMAC_AMP_AVAIL */
815
816         if (chip->hp_stat_mask == 0) {
817                 /* set headphone-jack detection bit */
818                 switch (chip->model) {
819                 case PMAC_AWACS:
820                         chip->hp_stat_mask = 0x04;
821                         break;
822                 case PMAC_SCREAMER:
823                         switch (chip->device_id) {
824                         case 0x08:
825                                 /* 1 = side jack, 2 = front jack */
826                                 chip->hp_stat_mask = 0x03;
827                                 break;
828                         case 0x00:
829                         case 0x05:
830                                 chip->hp_stat_mask = 0x04;
831                                 break;
832                         default:
833                                 chip->hp_stat_mask = 0x08;
834                                 break;
835                         }
836                         break;
837                 default:
838                         snd_BUG();
839                         break;
840                 }
841         }
842
843         /*
844          * build mixers
845          */
846         strcpy(chip->card->mixername, "PowerMac AWACS");
847
848         if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
849                                 snd_pmac_awacs_mixers)) < 0)
850                 return err;
851         if (chip->model == PMAC_SCREAMER)
852                 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
853                                    snd_pmac_screamer_mixers2);
854         else
855                 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
856                                    snd_pmac_awacs_mixers2);
857         if (err < 0)
858                 return err;
859         chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_master_sw, chip);
860         if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
861                 return err;
862 #ifdef PMAC_AMP_AVAIL
863         if (chip->mixer_data) {
864                 /* use amplifier.  the signal is connected from route A
865                  * to the amp.  the amp has its headphone and speaker
866                  * volumes and mute switches, so we use them instead of
867                  * screamer registers.
868                  * in this case, it seems the route C is not used.
869                  */
870                 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
871                                         snd_pmac_awacs_amp_vol)) < 0)
872                         return err;
873                 /* overwrite */
874                 chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw, chip);
875                 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
876                         return err;
877                 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw, chip);
878                 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
879                         return err;
880         } else
881 #endif /* PMAC_AMP_AVAIL */
882         {
883                 /* route A = headphone, route C = speaker */
884                 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_speaker_vol),
885                                         snd_pmac_awacs_speaker_vol)) < 0)
886                         return err;
887                 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_speaker_sw, chip);
888                 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
889                         return err;
890         }
891
892         if (chip->model == PMAC_SCREAMER) {
893                 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mic_boost),
894                                         snd_pmac_screamer_mic_boost)) < 0)
895                         return err;
896         } else {
897                 if ((err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
898                                         snd_pmac_awacs_mic_boost)) < 0)
899                         return err;
900         }
901
902         /*
903          * set lowlevel callbacks
904          */
905         chip->set_format = snd_pmac_awacs_set_format;
906 #ifdef CONFIG_PM
907         chip->suspend = snd_pmac_awacs_suspend;
908         chip->resume = snd_pmac_awacs_resume;
909 #endif
910 #ifdef PMAC_SUPPORT_AUTOMUTE
911         if ((err = snd_pmac_add_automute(chip)) < 0)
912                 return err;
913         chip->detect_headphone = snd_pmac_awacs_detect_headphone;
914         chip->update_automute = snd_pmac_awacs_update_automute;
915         snd_pmac_awacs_update_automute(chip, 0); /* update the status only */
916 #endif
917         if (chip->model == PMAC_SCREAMER) {
918                 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
919                 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
920         }
921
922         return 0;
923 }