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