projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'fuse-update-6.6' of git://git.kernel.org/pub/scm/linux/kernel/git/mszeredi...
[linux-block.git] / sound / ppc / awacs.c
CommitLineData
1a59d1b8 1// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4
LT		 2/*
3 * PMac AWACS lowlevel functions
4 *
5 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
6 * code based on dmasound.c.
1da177e4
LT		 7 */
8
9
6cbbfe1c 10#include <linux/io.h>
1da177e4
LT		 11#include <asm/nvram.h>
12#include <linux/init.h>
13#include <linux/delay.h>
7e9f2839 14#include <linux/of.h>
1da177e4
LT		 15#include <linux/slab.h>
16#include <sound/core.h>
17#include "pmac.h"
18
19
20#ifdef CONFIG_ADB_CUDA
21#define PMAC_AMP_AVAIL
22#endif
23
24#ifdef PMAC_AMP_AVAIL
65b29f50 25struct awacs_amp {
1da177e4
LT		 26 unsigned char amp_master;
27 unsigned char amp_vol[2][2];
28 unsigned char amp_tone[2];
65b29f50 29};
1da177e4
LT		 30
31#define CHECK_CUDA_AMP() (sys_ctrler == SYS_CTRLER_CUDA)
32
33#endif /* PMAC_AMP_AVAIL */
34
35
65b29f50 36static void snd_pmac_screamer_wait(struct snd_pmac *chip)
1da177e4
LT		 37{
38 long timeout = 2000;
39 while (!(in_le32(&chip->awacs->codec_stat) & MASK_VALID)) {
40 mdelay(1);
41 if (! --timeout) {
42 snd_printd("snd_pmac_screamer_wait timeout\n");
43 break;
44 }
45 }
46}
47
48/*
49 * write AWACS register
50 */
51static void
65b29f50 52snd_pmac_awacs_write(struct snd_pmac *chip, int val)
1da177e4
LT		 53{
54 long timeout = 5000000;
55
56 if (chip->model == PMAC_SCREAMER)
57 snd_pmac_screamer_wait(chip);
58 out_le32(&chip->awacs->codec_ctrl, val | (chip->subframe << 22));
59 while (in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) {
60 if (! --timeout) {
61 snd_printd("snd_pmac_awacs_write timeout\n");
62 break;
63 }
64 }
65}
66
67static void
65b29f50 68snd_pmac_awacs_write_reg(struct snd_pmac *chip, int reg, int val)
1da177e4
LT		 69{
70 snd_pmac_awacs_write(chip, val | (reg << 12));
71 chip->awacs_reg[reg] = val;
72}
73
74static void
65b29f50 75snd_pmac_awacs_write_noreg(struct snd_pmac *chip, int reg, int val)
1da177e4
LT		 76{
77 snd_pmac_awacs_write(chip, val | (reg << 12));
78}
79
8c870933 80#ifdef CONFIG_PM
1da177e4 81/* Recalibrate chip */
65b29f50 82static void screamer_recalibrate(struct snd_pmac *chip)
1da177e4
LT		 83{
84 if (chip->model != PMAC_SCREAMER)
85 return;
86
87 /* Sorry for the horrible delays... I hope to get that improved
88 * by making the whole PM process asynchronous in a future version
89 */
90 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
91 if (chip->manufacturer == 0x1)
92 /* delay for broken crystal part */
989a0b24 93 msleep(750);
1da177e4 94 snd_pmac_awacs_write_noreg(chip, 1,
65b29f50
TI		 95 chip->awacs_reg[1] | MASK_RECALIBRATE |
96 MASK_CMUTE | MASK_AMUTE);
1da177e4
LT		 97 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
98 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
99}
100
101#else
102#define screamer_recalibrate(chip) /* NOP */
103#endif
104
105
106/*
107 * additional callback to set the pcm format
108 */
65b29f50 109static void snd_pmac_awacs_set_format(struct snd_pmac *chip)
1da177e4
LT		 110{
111 chip->awacs_reg[1] &= ~MASK_SAMPLERATE;
112 chip->awacs_reg[1] |= chip->rate_index << 3;
113 snd_pmac_awacs_write_reg(chip, 1, chip->awacs_reg[1]);
114}
115
116
117/*
118 * AWACS volume callbacks
119 */
120/*
121 * volumes: 0-15 stereo
122 */
65b29f50
TI		 123static int snd_pmac_awacs_info_volume(struct snd_kcontrol *kcontrol,
124 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 125{
126 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
127 uinfo->count = 2;
128 uinfo->value.integer.min = 0;
129 uinfo->value.integer.max = 15;
130 return 0;
131}
7ae44cfa 132
65b29f50
TI		 133static int snd_pmac_awacs_get_volume(struct snd_kcontrol *kcontrol,
134 struct snd_ctl_elem_value *ucontrol)
1da177e4 135{
65b29f50 136 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 137 int reg = kcontrol->private_value & 0xff;
138 int lshift = (kcontrol->private_value >> 8) & 0xff;
139 int inverted = (kcontrol->private_value >> 16) & 1;
140 unsigned long flags;
141 int vol[2];
142
143 spin_lock_irqsave(&chip->reg_lock, flags);
144 vol[0] = (chip->awacs_reg[reg] >> lshift) & 0xf;
145 vol[1] = chip->awacs_reg[reg] & 0xf;
146 spin_unlock_irqrestore(&chip->reg_lock, flags);
147 if (inverted) {
148 vol[0] = 0x0f - vol[0];
149 vol[1] = 0x0f - vol[1];
150 }
151 ucontrol->value.integer.value[0] = vol[0];
152 ucontrol->value.integer.value[1] = vol[1];
153 return 0;
154}
155
65b29f50
TI		 156static int snd_pmac_awacs_put_volume(struct snd_kcontrol *kcontrol,
157 struct snd_ctl_elem_value *ucontrol)
1da177e4 158{
65b29f50 159 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 160 int reg = kcontrol->private_value & 0xff;
161 int lshift = (kcontrol->private_value >> 8) & 0xff;
162 int inverted = (kcontrol->private_value >> 16) & 1;
163 int val, oldval;
164 unsigned long flags;
d4079ac4 165 unsigned int vol[2];
1da177e4
LT		 166
167 vol[0] = ucontrol->value.integer.value[0];
168 vol[1] = ucontrol->value.integer.value[1];
d4079ac4
TI		 169 if (vol[0] > 0x0f || vol[1] > 0x0f)
170 return -EINVAL;
1da177e4
LT		 171 if (inverted) {
172 vol[0] = 0x0f - vol[0];
173 vol[1] = 0x0f - vol[1];
174 }
175 vol[0] &= 0x0f;
176 vol[1] &= 0x0f;
177 spin_lock_irqsave(&chip->reg_lock, flags);
178 oldval = chip->awacs_reg[reg];
179 val = oldval & ~(0xf | (0xf << lshift));
180 val |= vol[0] << lshift;
181 val |= vol[1];
182 if (oldval != val)
183 snd_pmac_awacs_write_reg(chip, reg, val);
184 spin_unlock_irqrestore(&chip->reg_lock, flags);
185 return oldval != reg;
186}
187
188
189#define AWACS_VOLUME(xname, xreg, xshift, xinverted) \
190{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
191 .info = snd_pmac_awacs_info_volume, \
192 .get = snd_pmac_awacs_get_volume, \
193 .put = snd_pmac_awacs_put_volume, \
194 .private_value = (xreg) | ((xshift) << 8) | ((xinverted) << 16) }
195
196/*
197 * mute master/ogain for AWACS: mono
198 */
65b29f50
TI		 199static int snd_pmac_awacs_get_switch(struct snd_kcontrol *kcontrol,
200 struct snd_ctl_elem_value *ucontrol)
1da177e4 201{
65b29f50 202 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 203 int reg = kcontrol->private_value & 0xff;
204 int shift = (kcontrol->private_value >> 8) & 0xff;
205 int invert = (kcontrol->private_value >> 16) & 1;
206 int val;
207 unsigned long flags;
208
209 spin_lock_irqsave(&chip->reg_lock, flags);
210 val = (chip->awacs_reg[reg] >> shift) & 1;
211 spin_unlock_irqrestore(&chip->reg_lock, flags);
212 if (invert)
213 val = 1 - val;
214 ucontrol->value.integer.value[0] = val;
215 return 0;
216}
217
65b29f50
TI		 218static int snd_pmac_awacs_put_switch(struct snd_kcontrol *kcontrol,
219 struct snd_ctl_elem_value *ucontrol)
1da177e4 220{
65b29f50 221 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 222 int reg = kcontrol->private_value & 0xff;
223 int shift = (kcontrol->private_value >> 8) & 0xff;
224 int invert = (kcontrol->private_value >> 16) & 1;
225 int mask = 1 << shift;
226 int val, changed;
227 unsigned long flags;
228
229 spin_lock_irqsave(&chip->reg_lock, flags);
230 val = chip->awacs_reg[reg] & ~mask;
231 if (ucontrol->value.integer.value[0] != invert)
232 val |= mask;
233 changed = chip->awacs_reg[reg] != val;
234 if (changed)
235 snd_pmac_awacs_write_reg(chip, reg, val);
236 spin_unlock_irqrestore(&chip->reg_lock, flags);
237 return changed;
238}
239
240#define AWACS_SWITCH(xname, xreg, xshift, xinvert) \
241{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0, \
242 .info = snd_pmac_boolean_mono_info, \
243 .get = snd_pmac_awacs_get_switch, \
244 .put = snd_pmac_awacs_put_switch, \
245 .private_value = (xreg) | ((xshift) << 8) | ((xinvert) << 16) }
246
247
248#ifdef PMAC_AMP_AVAIL
249/*
250 * controls for perch/whisper extension cards, e.g. G3 desktop
251 *
252 * TDA7433 connected via i2c address 0x45 (= 0x8a),
253 * accessed through cuda
254 */
255static void awacs_set_cuda(int reg, int val)
256{
257 struct adb_request req;
7ae44cfa
RS		 258 cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_GET_SET_IIC, 0x8a,
259 reg, val);
1da177e4
LT		 260 while (! req.complete)
261 cuda_poll();
262}
263
264/*
265 * level = 0 - 14, 7 = 0 dB
266 */
65b29f50 267static void awacs_amp_set_tone(struct awacs_amp *amp, int bass, int treble)
1da177e4
LT		 268{
269 amp->amp_tone[0] = bass;
270 amp->amp_tone[1] = treble;
271 if (bass > 7)
272 bass = (14 - bass) + 8;
273 if (treble > 7)
274 treble = (14 - treble) + 8;
275 awacs_set_cuda(2, (bass << 4) | treble);
276}
277
278/*
279 * vol = 0 - 31 (attenuation), 32 = mute bit, stereo
280 */
7ae44cfa
RS		 281static int awacs_amp_set_vol(struct awacs_amp *amp, int index,
282 int lvol, int rvol, int do_check)
1da177e4
LT		 283{
284 if (do_check && amp->amp_vol[index][0] == lvol &&
7ae44cfa 285 amp->amp_vol[index][1] == rvol)
1da177e4
LT		 286 return 0;
287 awacs_set_cuda(3 + index, lvol);
288 awacs_set_cuda(5 + index, rvol);
289 amp->amp_vol[index][0] = lvol;
290 amp->amp_vol[index][1] = rvol;
291 return 1;
292}
293
294/*
295 * 0 = -79 dB, 79 = 0 dB, 99 = +20 dB
296 */
65b29f50 297static void awacs_amp_set_master(struct awacs_amp *amp, int vol)
1da177e4
LT		 298{
299 amp->amp_master = vol;
300 if (vol <= 79)
301 vol = 32 + (79 - vol);
302 else
303 vol = 32 - (vol - 79);
304 awacs_set_cuda(1, vol);
305}
306
65b29f50 307static void awacs_amp_free(struct snd_pmac *chip)
1da177e4 308{
65b29f50 309 struct awacs_amp *amp = chip->mixer_data;
5e246b85
TI		 310 if (!amp)
311 return;
1da177e4
LT		 312 kfree(amp);
313 chip->mixer_data = NULL;
314 chip->mixer_free = NULL;
315}
316
317
318/*
319 * mixer controls
320 */
65b29f50
TI		 321static int snd_pmac_awacs_info_volume_amp(struct snd_kcontrol *kcontrol,
322 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 323{
324 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
325 uinfo->count = 2;
326 uinfo->value.integer.min = 0;
327 uinfo->value.integer.max = 31;
328 return 0;
329}
7ae44cfa 330
65b29f50
TI		 331static int snd_pmac_awacs_get_volume_amp(struct snd_kcontrol *kcontrol,
332 struct snd_ctl_elem_value *ucontrol)
1da177e4 333{
65b29f50 334 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4 335 int index = kcontrol->private_value;
65b29f50 336 struct awacs_amp *amp = chip->mixer_data;
5e246b85 337
1da177e4
LT		 338 ucontrol->value.integer.value[0] = 31 - (amp->amp_vol[index][0] & 31);
339 ucontrol->value.integer.value[1] = 31 - (amp->amp_vol[index][1] & 31);
340 return 0;
341}
342
65b29f50
TI		 343static int snd_pmac_awacs_put_volume_amp(struct snd_kcontrol *kcontrol,
344 struct snd_ctl_elem_value *ucontrol)
1da177e4 345{
65b29f50 346 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 347 int index = kcontrol->private_value;
348 int vol[2];
65b29f50 349 struct awacs_amp *amp = chip->mixer_data;
1da177e4 350
7ae44cfa
RS		 351 vol[0] = (31 - (ucontrol->value.integer.value[0] & 31))
352 | (amp->amp_vol[index][0] & 32);
353 vol[1] = (31 - (ucontrol->value.integer.value[1] & 31))
354 | (amp->amp_vol[index][1] & 32);
1da177e4
LT		 355 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
356}
357
65b29f50
TI		 358static int snd_pmac_awacs_get_switch_amp(struct snd_kcontrol *kcontrol,
359 struct snd_ctl_elem_value *ucontrol)
1da177e4 360{
65b29f50 361 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4 362 int index = kcontrol->private_value;
65b29f50 363 struct awacs_amp *amp = chip->mixer_data;
5e246b85 364
7ae44cfa
RS		 365 ucontrol->value.integer.value[0] = (amp->amp_vol[index][0] & 32)
366 ? 0 : 1;
367 ucontrol->value.integer.value[1] = (amp->amp_vol[index][1] & 32)
368 ? 0 : 1;
1da177e4
LT		 369 return 0;
370}
371
65b29f50
TI		 372static int snd_pmac_awacs_put_switch_amp(struct snd_kcontrol *kcontrol,
373 struct snd_ctl_elem_value *ucontrol)
1da177e4 374{
65b29f50 375 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 376 int index = kcontrol->private_value;
377 int vol[2];
65b29f50 378 struct awacs_amp *amp = chip->mixer_data;
1da177e4 379
7ae44cfa
RS		 380 vol[0] = (ucontrol->value.integer.value[0] ? 0 : 32)
381 | (amp->amp_vol[index][0] & 31);
382 vol[1] = (ucontrol->value.integer.value[1] ? 0 : 32)
383 | (amp->amp_vol[index][1] & 31);
1da177e4
LT		 384 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
385}
386
65b29f50
TI		 387static int snd_pmac_awacs_info_tone_amp(struct snd_kcontrol *kcontrol,
388 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 389{
390 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
391 uinfo->count = 1;
392 uinfo->value.integer.min = 0;
393 uinfo->value.integer.max = 14;
394 return 0;
395}
7ae44cfa 396
65b29f50
TI		 397static int snd_pmac_awacs_get_tone_amp(struct snd_kcontrol *kcontrol,
398 struct snd_ctl_elem_value *ucontrol)
1da177e4 399{
65b29f50 400 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4 401 int index = kcontrol->private_value;
65b29f50 402 struct awacs_amp *amp = chip->mixer_data;
5e246b85 403
1da177e4
LT		 404 ucontrol->value.integer.value[0] = amp->amp_tone[index];
405 return 0;
406}
407
65b29f50
TI		 408static int snd_pmac_awacs_put_tone_amp(struct snd_kcontrol *kcontrol,
409 struct snd_ctl_elem_value *ucontrol)
1da177e4 410{
65b29f50 411 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4 412 int index = kcontrol->private_value;
65b29f50 413 struct awacs_amp *amp = chip->mixer_data;
d4079ac4 414 unsigned int val;
5e246b85 415
d4079ac4
TI		 416 val = ucontrol->value.integer.value[0];
417 if (val > 14)
418 return -EINVAL;
419 if (val != amp->amp_tone[index]) {
420 amp->amp_tone[index] = val;
1da177e4
LT		 421 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
422 return 1;
423 }
424 return 0;
425}
426
65b29f50
TI		 427static int snd_pmac_awacs_info_master_amp(struct snd_kcontrol *kcontrol,
428 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 429{
430 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
431 uinfo->count = 1;
432 uinfo->value.integer.min = 0;
433 uinfo->value.integer.max = 99;
434 return 0;
435}
7ae44cfa 436
65b29f50
TI		 437static int snd_pmac_awacs_get_master_amp(struct snd_kcontrol *kcontrol,
438 struct snd_ctl_elem_value *ucontrol)
1da177e4 439{
65b29f50
TI		 440 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
441 struct awacs_amp *amp = chip->mixer_data;
5e246b85 442
1da177e4
LT		 443 ucontrol->value.integer.value[0] = amp->amp_master;
444 return 0;
445}
446
65b29f50
TI		 447static int snd_pmac_awacs_put_master_amp(struct snd_kcontrol *kcontrol,
448 struct snd_ctl_elem_value *ucontrol)
1da177e4 449{
65b29f50
TI		 450 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
451 struct awacs_amp *amp = chip->mixer_data;
d4079ac4 452 unsigned int val;
5e246b85 453
d4079ac4
TI		 454 val = ucontrol->value.integer.value[0];
455 if (val > 99)
456 return -EINVAL;
457 if (val != amp->amp_master) {
458 amp->amp_master = val;
1da177e4
LT		 459 awacs_amp_set_master(amp, amp->amp_master);
460 return 1;
461 }
462 return 0;
463}
464
465#define AMP_CH_SPK 0
466#define AMP_CH_HD 1
467
c031b0cc 468static const struct snd_kcontrol_new snd_pmac_awacs_amp_vol[] = {
1da177e4 469 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
ad1cd745 470 .name = "Speaker Playback Volume",
1da177e4
LT		 471 .info = snd_pmac_awacs_info_volume_amp,
472 .get = snd_pmac_awacs_get_volume_amp,
473 .put = snd_pmac_awacs_put_volume_amp,
474 .private_value = AMP_CH_SPK,
475 },
476 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
477 .name = "Headphone Playback Volume",
478 .info = snd_pmac_awacs_info_volume_amp,
479 .get = snd_pmac_awacs_get_volume_amp,
480 .put = snd_pmac_awacs_put_volume_amp,
481 .private_value = AMP_CH_HD,
482 },
483 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
484 .name = "Tone Control - Bass",
485 .info = snd_pmac_awacs_info_tone_amp,
486 .get = snd_pmac_awacs_get_tone_amp,
487 .put = snd_pmac_awacs_put_tone_amp,
488 .private_value = 0,
489 },
490 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
491 .name = "Tone Control - Treble",
492 .info = snd_pmac_awacs_info_tone_amp,
493 .get = snd_pmac_awacs_get_tone_amp,
494 .put = snd_pmac_awacs_put_tone_amp,
495 .private_value = 1,
496 },
497 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
498 .name = "Amp Master Playback Volume",
499 .info = snd_pmac_awacs_info_master_amp,
500 .get = snd_pmac_awacs_get_master_amp,
501 .put = snd_pmac_awacs_put_master_amp,
502 },
503};
504
905e46ac 505static const struct snd_kcontrol_new snd_pmac_awacs_amp_hp_sw = {
1da177e4
LT		 506 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
507 .name = "Headphone Playback Switch",
508 .info = snd_pmac_boolean_stereo_info,
509 .get = snd_pmac_awacs_get_switch_amp,
510 .put = snd_pmac_awacs_put_switch_amp,
511 .private_value = AMP_CH_HD,
512};
513
905e46ac 514static const struct snd_kcontrol_new snd_pmac_awacs_amp_spk_sw = {
1da177e4 515 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
ad1cd745 516 .name = "Speaker Playback Switch",
1da177e4
LT		 517 .info = snd_pmac_boolean_stereo_info,
518 .get = snd_pmac_awacs_get_switch_amp,
519 .put = snd_pmac_awacs_put_switch_amp,
520 .private_value = AMP_CH_SPK,
521};
522
523#endif /* PMAC_AMP_AVAIL */
524
525
526/*
527 * mic boost for screamer
528 */
65b29f50
TI		 529static int snd_pmac_screamer_mic_boost_info(struct snd_kcontrol *kcontrol,
530 struct snd_ctl_elem_info *uinfo)
1da177e4
LT		 531{
532 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
533 uinfo->count = 1;
534 uinfo->value.integer.min = 0;
a8c2a6bf 535 uinfo->value.integer.max = 3;
1da177e4
LT		 536 return 0;
537}
538
65b29f50
TI		 539static int snd_pmac_screamer_mic_boost_get(struct snd_kcontrol *kcontrol,
540 struct snd_ctl_elem_value *ucontrol)
1da177e4 541{
65b29f50 542 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
a8c2a6bf 543 int val = 0;
1da177e4
LT		 544 unsigned long flags;
545
546 spin_lock_irqsave(&chip->reg_lock, flags);
547 if (chip->awacs_reg[6] & MASK_MIC_BOOST)
a8c2a6bf
RS		 548 val |= 2;
549 if (chip->awacs_reg[0] & MASK_GAINLINE)
550 val |= 1;
1da177e4
LT		 551 spin_unlock_irqrestore(&chip->reg_lock, flags);
552 ucontrol->value.integer.value[0] = val;
553 return 0;
554}
555
65b29f50
TI		 556static int snd_pmac_screamer_mic_boost_put(struct snd_kcontrol *kcontrol,
557 struct snd_ctl_elem_value *ucontrol)
1da177e4 558{
65b29f50 559 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
1da177e4
LT		 560 int changed = 0;
561 int val0, val6;
562 unsigned long flags;
563
564 spin_lock_irqsave(&chip->reg_lock, flags);
565 val0 = chip->awacs_reg[0] & ~MASK_GAINLINE;
566 val6 = chip->awacs_reg[6] & ~MASK_MIC_BOOST;
a8c2a6bf 567 if (ucontrol->value.integer.value[0] & 1)
1da177e4 568 val0 |= MASK_GAINLINE;
a8c2a6bf
RS		 569 if (ucontrol->value.integer.value[0] & 2)
570 val6 |= MASK_MIC_BOOST;
1da177e4
LT		 571 if (val0 != chip->awacs_reg[0]) {
572 snd_pmac_awacs_write_reg(chip, 0, val0);
573 changed = 1;
574 }
575 if (val6 != chip->awacs_reg[6]) {
576 snd_pmac_awacs_write_reg(chip, 6, val6);
577 changed = 1;
578 }
579 spin_unlock_irqrestore(&chip->reg_lock, flags);
580 return changed;
581}
582
583/*
584 * lists of mixer elements
585 */
c031b0cc 586static const struct snd_kcontrol_new snd_pmac_awacs_mixers[] = {
1da177e4 587 AWACS_SWITCH("Master Capture Switch", 1, SHIFT_LOOPTHRU, 0),
a8c2a6bf
RS		 588 AWACS_VOLUME("Master Capture Volume", 0, 4, 0),
589/* AWACS_SWITCH("Unknown Playback Switch", 6, SHIFT_PAROUT0, 0), */
590};
591
c031b0cc 592static const struct snd_kcontrol_new snd_pmac_screamer_mixers_beige[] = {
a8c2a6bf
RS		 593 AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
594 AWACS_VOLUME("Play-through Playback Volume", 5, 6, 1),
595 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
596 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_LINE, 0),
597};
598
c031b0cc 599static const struct snd_kcontrol_new snd_pmac_screamer_mixers_lo[] = {
a8c2a6bf 600 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
dca7c741
RS		 601};
602
c031b0cc 603static const struct snd_kcontrol_new snd_pmac_screamer_mixers_imac[] = {
dca7c741 604 AWACS_VOLUME("Play-through Playback Volume", 5, 6, 1),
a8c2a6bf
RS		 605 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
606};
607
c031b0cc 608static const struct snd_kcontrol_new snd_pmac_screamer_mixers_g4agp[] = {
4dbf95ba
RS		 609 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
610 AWACS_VOLUME("Master Playback Volume", 5, 6, 1),
611 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
612 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
613};
614
c031b0cc 615static const struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac7500[] = {
a8c2a6bf
RS		 616 AWACS_VOLUME("Line out Playback Volume", 2, 6, 1),
617 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
618 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
619};
620
c031b0cc 621static const struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac5500[] = {
dca7c741
RS		 622 AWACS_VOLUME("Headphone Playback Volume", 2, 6, 1),
623};
624
c031b0cc 625static const struct snd_kcontrol_new snd_pmac_awacs_mixers_pmac[] = {
a8c2a6bf 626 AWACS_VOLUME("Master Playback Volume", 2, 6, 1),
1da177e4
LT		 627 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
628};
629
630/* FIXME: is this correct order?
631 * screamer (powerbook G3 pismo) seems to have different bits...
632 */
c031b0cc 633static const struct snd_kcontrol_new snd_pmac_awacs_mixers2[] = {
1da177e4
LT		 634 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_LINE, 0),
635 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_MIC, 0),
636};
637
c031b0cc 638static const struct snd_kcontrol_new snd_pmac_screamer_mixers2[] = {
1da177e4
LT		 639 AWACS_SWITCH("Line Capture Switch", 0, SHIFT_MUX_MIC, 0),
640 AWACS_SWITCH("Mic Capture Switch", 0, SHIFT_MUX_LINE, 0),
641};
642
c031b0cc 643static const struct snd_kcontrol_new snd_pmac_awacs_mixers2_pmac5500[] = {
dca7c741
RS		 644 AWACS_SWITCH("CD Capture Switch", 0, SHIFT_MUX_CD, 0),
645};
646
c031b0cc 647static const struct snd_kcontrol_new snd_pmac_awacs_master_sw =
1da177e4
LT		 648AWACS_SWITCH("Master Playback Switch", 1, SHIFT_HDMUTE, 1);
649
c031b0cc 650static const struct snd_kcontrol_new snd_pmac_awacs_master_sw_imac =
a8c2a6bf
RS		 651AWACS_SWITCH("Line out Playback Switch", 1, SHIFT_HDMUTE, 1);
652
c031b0cc 653static const struct snd_kcontrol_new snd_pmac_awacs_master_sw_pmac5500 =
dca7c741
RS		 654AWACS_SWITCH("Headphone Playback Switch", 1, SHIFT_HDMUTE, 1);
655
c031b0cc 656static const struct snd_kcontrol_new snd_pmac_awacs_mic_boost[] = {
a8c2a6bf 657 AWACS_SWITCH("Mic Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
1da177e4
LT		 658};
659
c031b0cc 660static const struct snd_kcontrol_new snd_pmac_screamer_mic_boost[] = {
1da177e4 661 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
a8c2a6bf 662 .name = "Mic Boost Capture Volume",
1da177e4
LT		 663 .info = snd_pmac_screamer_mic_boost_info,
664 .get = snd_pmac_screamer_mic_boost_get,
665 .put = snd_pmac_screamer_mic_boost_put,
666 },
667};
668
c031b0cc 669static const struct snd_kcontrol_new snd_pmac_awacs_mic_boost_pmac7500[] =
a8c2a6bf
RS		 670{
671 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
672};
673
c031b0cc 674static const struct snd_kcontrol_new snd_pmac_screamer_mic_boost_beige[] =
a8c2a6bf
RS		 675{
676 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
677 AWACS_SWITCH("CD Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
678};
679
c031b0cc 680static const struct snd_kcontrol_new snd_pmac_screamer_mic_boost_imac[] =
a8c2a6bf
RS		 681{
682 AWACS_SWITCH("Line Boost Capture Switch", 0, SHIFT_GAINLINE, 0),
683 AWACS_SWITCH("Mic Boost Capture Switch", 6, SHIFT_MIC_BOOST, 0),
684};
685
c031b0cc 686static const struct snd_kcontrol_new snd_pmac_awacs_speaker_vol[] = {
ad1cd745 687 AWACS_VOLUME("Speaker Playback Volume", 4, 6, 1),
1da177e4 688};
a8c2a6bf 689
c031b0cc 690static const struct snd_kcontrol_new snd_pmac_awacs_speaker_sw =
ad1cd745 691AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_SPKMUTE, 1);
1da177e4 692
c031b0cc 693static const struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac1 =
ad1cd745 694AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_PAROUT1, 1);
030b655b 695
c031b0cc 696static const struct snd_kcontrol_new snd_pmac_awacs_speaker_sw_imac2 =
ad1cd745 697AWACS_SWITCH("Speaker Playback Switch", 1, SHIFT_PAROUT1, 0);
a8c2a6bf 698
1da177e4
LT		 699
700/*
701 * add new mixer elements to the card
702 */
7ae44cfa 703static int build_mixers(struct snd_pmac *chip, int nums,
c031b0cc 704 const struct snd_kcontrol_new *mixers)
1da177e4
LT		 705{
706 int i, err;
707
708 for (i = 0; i < nums; i++) {
7ae44cfa
RS		 709 err = snd_ctl_add(chip->card, snd_ctl_new1(&mixers[i], chip));
710 if (err < 0)
1da177e4
LT		 711 return err;
712 }
713 return 0;
714}
715
716
717/*
718 * restore all registers
719 */
65b29f50 720static void awacs_restore_all_regs(struct snd_pmac *chip)
1da177e4
LT		 721{
722 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
723 snd_pmac_awacs_write_noreg(chip, 1, chip->awacs_reg[1]);
724 snd_pmac_awacs_write_noreg(chip, 2, chip->awacs_reg[2]);
725 snd_pmac_awacs_write_noreg(chip, 4, chip->awacs_reg[4]);
726 if (chip->model == PMAC_SCREAMER) {
727 snd_pmac_awacs_write_noreg(chip, 5, chip->awacs_reg[5]);
728 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
729 snd_pmac_awacs_write_noreg(chip, 7, chip->awacs_reg[7]);
730 }
731}
732
8c870933 733#ifdef CONFIG_PM
65b29f50 734static void snd_pmac_awacs_suspend(struct snd_pmac *chip)
1da177e4
LT		 735{
736 snd_pmac_awacs_write_noreg(chip, 1, (chip->awacs_reg[1]
737 | MASK_AMUTE | MASK_CMUTE));
738}
739
65b29f50 740static void snd_pmac_awacs_resume(struct snd_pmac *chip)
1da177e4 741{
71a157e8
GL		 742 if (of_machine_is_compatible("PowerBook3,1")
743 || of_machine_is_compatible("PowerBook3,2")) {
989a0b24 744 msleep(100);
1da177e4
LT		 745 snd_pmac_awacs_write_reg(chip, 1,
746 chip->awacs_reg[1] & ~MASK_PAROUT);
989a0b24 747 msleep(300);
1da177e4
LT		 748 }
749
750 awacs_restore_all_regs(chip);
751 if (chip->model == PMAC_SCREAMER) {
752 /* reset power bits in reg 6 */
753 mdelay(5);
754 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
755 }
756 screamer_recalibrate(chip);
757#ifdef PMAC_AMP_AVAIL
758 if (chip->mixer_data) {
65b29f50 759 struct awacs_amp *amp = chip->mixer_data;
7ae44cfa
RS		 760 awacs_amp_set_vol(amp, 0,
761 amp->amp_vol[0][0], amp->amp_vol[0][1], 0);
762 awacs_amp_set_vol(amp, 1,
763 amp->amp_vol[1][0], amp->amp_vol[1][1], 0);
1da177e4
LT		 764 awacs_amp_set_tone(amp, amp->amp_tone[0], amp->amp_tone[1]);
765 awacs_amp_set_master(amp, amp->amp_master);
766 }
767#endif
768}
8c870933 769#endif /* CONFIG_PM */
1da177e4 770
71a157e8
GL		 771#define IS_PM7500 (of_machine_is_compatible("AAPL,7500") \
772 || of_machine_is_compatible("AAPL,8500") \
773 || of_machine_is_compatible("AAPL,9500"))
774#define IS_PM5500 (of_machine_is_compatible("AAPL,e411"))
775#define IS_BEIGE (of_machine_is_compatible("AAPL,Gossamer"))
776#define IS_IMAC1 (of_machine_is_compatible("PowerMac2,1"))
777#define IS_IMAC2 (of_machine_is_compatible("PowerMac2,2") \
778 || of_machine_is_compatible("PowerMac4,1"))
779#define IS_G4AGP (of_machine_is_compatible("PowerMac3,1"))
780#define IS_LOMBARD (of_machine_is_compatible("PowerBook1,1"))
a8c2a6bf 781
030b655b 782static int imac1, imac2;
a8c2a6bf 783
1da177e4
LT		 784#ifdef PMAC_SUPPORT_AUTOMUTE
785/*
786 * auto-mute stuffs
787 */
65b29f50 788static int snd_pmac_awacs_detect_headphone(struct snd_pmac *chip)
1da177e4
LT		 789{
790 return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
791}
792
793#ifdef PMAC_AMP_AVAIL
65b29f50 794static int toggle_amp_mute(struct awacs_amp *amp, int index, int mute)
1da177e4
LT		 795{
796 int vol[2];
797 vol[0] = amp->amp_vol[index][0] & 31;
798 vol[1] = amp->amp_vol[index][1] & 31;
799 if (mute) {
800 vol[0] |= 32;
801 vol[1] |= 32;
802 }
803 return awacs_amp_set_vol(amp, index, vol[0], vol[1], 1);
804}
805#endif
806
65b29f50 807static void snd_pmac_awacs_update_automute(struct snd_pmac *chip, int do_notify)
1da177e4
LT		 808{
809 if (chip->auto_mute) {
810#ifdef PMAC_AMP_AVAIL
811 if (chip->mixer_data) {
65b29f50 812 struct awacs_amp *amp = chip->mixer_data;
1da177e4
LT		 813 int changed;
814 if (snd_pmac_awacs_detect_headphone(chip)) {
815 changed = toggle_amp_mute(amp, AMP_CH_HD, 0);
816 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 1);
817 } else {
818 changed = toggle_amp_mute(amp, AMP_CH_HD, 1);
819 changed |= toggle_amp_mute(amp, AMP_CH_SPK, 0);
820 }
821 if (do_notify && ! changed)
822 return;
823 } else
824#endif
825 {
a8c2a6bf
RS		 826 int reg = chip->awacs_reg[1]
827 | (MASK_HDMUTE | MASK_SPKMUTE);
030b655b
RS		 828 if (imac1) {
829 reg &= ~MASK_SPKMUTE;
830 reg |= MASK_PAROUT1;
831 } else if (imac2) {
a8c2a6bf
RS		 832 reg &= ~MASK_SPKMUTE;
833 reg &= ~MASK_PAROUT1;
834 }
1da177e4
LT		 835 if (snd_pmac_awacs_detect_headphone(chip))
836 reg &= ~MASK_HDMUTE;
030b655b
RS		 837 else if (imac1)
838 reg &= ~MASK_PAROUT1;
839 else if (imac2)
a8c2a6bf 840 reg |= MASK_PAROUT1;
1da177e4
LT		 841 else
842 reg &= ~MASK_SPKMUTE;
843 if (do_notify && reg == chip->awacs_reg[1])
844 return;
845 snd_pmac_awacs_write_reg(chip, 1, reg);
846 }
847 if (do_notify) {
848 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
849 &chip->master_sw_ctl->id);
850 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
851 &chip->speaker_sw_ctl->id);
852 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
853 &chip->hp_detect_ctl->id);
854 }
855 }
856}
857#endif /* PMAC_SUPPORT_AUTOMUTE */
858
859
860/*
861 * initialize chip
862 */
15afafc2 863int
65b29f50 864snd_pmac_awacs_init(struct snd_pmac *chip)
1da177e4 865{
a8c2a6bf 866 int pm7500 = IS_PM7500;
b0a8a8fd 867 int pm5500 = IS_PM5500;
a8c2a6bf 868 int beige = IS_BEIGE;
4dbf95ba 869 int g4agp = IS_G4AGP;
573934bc 870 int lombard = IS_LOMBARD;
030b655b 871 int imac;
1da177e4 872 int err, vol;
dca7c741
RS		 873 struct snd_kcontrol *vmaster_sw, *vmaster_vol;
874 struct snd_kcontrol *master_vol, *speaker_vol;
1da177e4 875
030b655b
RS		 876 imac1 = IS_IMAC1;
877 imac2 = IS_IMAC2;
878 imac = imac1 || imac2;
1da177e4
LT		 879 /* looks like MASK_GAINLINE triggers something, so we set here
880 * as start-up
881 */
882 chip->awacs_reg[0] = MASK_MUX_CD | 0xff | MASK_GAINLINE;
883 chip->awacs_reg[1] = MASK_CMUTE | MASK_AMUTE;
884 /* FIXME: Only machines with external SRS module need MASK_PAROUT */
885 if (chip->has_iic || chip->device_id == 0x5 ||
7ae44cfa 886 /* chip->_device_id == 0x8 || */
1da177e4
LT		 887 chip->device_id == 0xb)
888 chip->awacs_reg[1] |= MASK_PAROUT;
889 /* get default volume from nvram */
890 // vol = (~nvram_read_byte(0x1308) & 7) << 1;
891 // vol = ((pmac_xpram_read( 8 ) & 7 ) << 1 );
892 vol = 0x0f; /* no, on alsa, muted as default */
893 vol = vol + (vol << 6);
894 chip->awacs_reg[2] = vol;
895 chip->awacs_reg[4] = vol;
896 if (chip->model == PMAC_SCREAMER) {
7ae44cfa
RS		 897 /* FIXME: screamer has loopthru vol control */
898 chip->awacs_reg[5] = vol;
899 /* FIXME: maybe should be vol << 3 for PCMCIA speaker */
900 chip->awacs_reg[6] = MASK_MIC_BOOST;
1da177e4
LT		 901 chip->awacs_reg[7] = 0;
902 }
903
904 awacs_restore_all_regs(chip);
905 chip->manufacturer = (in_le32(&chip->awacs->codec_stat) >> 8) & 0xf;
906 screamer_recalibrate(chip);
907
908 chip->revision = (in_le32(&chip->awacs->codec_stat) >> 12) & 0xf;
909#ifdef PMAC_AMP_AVAIL
910 if (chip->revision == 3 && chip->has_iic && CHECK_CUDA_AMP()) {
59feddb2 911 struct awacs_amp *amp = kzalloc(sizeof(*amp), GFP_KERNEL);
1da177e4
LT		 912 if (! amp)
913 return -ENOMEM;
914 chip->mixer_data = amp;
1da177e4 915 chip->mixer_free = awacs_amp_free;
7ae44cfa
RS		 916 /* mute and zero vol */
917 awacs_amp_set_vol(amp, 0, 63, 63, 0);
1da177e4
LT		 918 awacs_amp_set_vol(amp, 1, 63, 63, 0);
919 awacs_amp_set_tone(amp, 7, 7); /* 0 dB */
920 awacs_amp_set_master(amp, 79); /* 0 dB */
921 }
922#endif /* PMAC_AMP_AVAIL */
923
924 if (chip->hp_stat_mask == 0) {
925 /* set headphone-jack detection bit */
926 switch (chip->model) {
927 case PMAC_AWACS:
b0a8a8fd 928 chip->hp_stat_mask = pm7500 || pm5500 ? MASK_HDPCONN
a8c2a6bf 929 : MASK_LOCONN;
1da177e4
LT		 930 break;
931 case PMAC_SCREAMER:
932 switch (chip->device_id) {
933 case 0x08:
a8c2a6bf
RS		 934 case 0x0B:
935 chip->hp_stat_mask = imac
936 ? MASK_LOCONN_IMAC |
937 MASK_HDPLCONN_IMAC |
938 MASK_HDPRCONN_IMAC
939 : MASK_HDPCONN;
1da177e4
LT		 940 break;
941 case 0x00:
942 case 0x05:
a8c2a6bf 943 chip->hp_stat_mask = MASK_LOCONN;
1da177e4
LT		 944 break;
945 default:
a8c2a6bf 946 chip->hp_stat_mask = MASK_HDPCONN;
1da177e4
LT		 947 break;
948 }
949 break;
950 default:
951 snd_BUG();
952 break;
953 }
954 }
955
956 /*
957 * build mixers
958 */
959 strcpy(chip->card->mixername, "PowerMac AWACS");
960
7ae44cfa
RS		 961 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers),
962 snd_pmac_awacs_mixers);
963 if (err < 0)
1da177e4 964 return err;
4dbf95ba 965 if (beige || g4agp)
a8c2a6bf 966 ;
b0a8a8fd 967 else if (chip->model == PMAC_SCREAMER || pm5500)
1da177e4
LT		 968 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_screamer_mixers2),
969 snd_pmac_screamer_mixers2);
a8c2a6bf 970 else if (!pm7500)
1da177e4
LT		 971 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mixers2),
972 snd_pmac_awacs_mixers2);
973 if (err < 0)
974 return err;
dca7c741
RS		 975 if (pm5500) {
976 err = build_mixers(chip,
977 ARRAY_SIZE(snd_pmac_awacs_mixers2_pmac5500),
978 snd_pmac_awacs_mixers2_pmac5500);
979 if (err < 0)
980 return err;
981 }
b268c34e 982 master_vol = NULL;
a8c2a6bf
RS		 983 if (pm7500)
984 err = build_mixers(chip,
985 ARRAY_SIZE(snd_pmac_awacs_mixers_pmac7500),
986 snd_pmac_awacs_mixers_pmac7500);
dca7c741
RS		 987 else if (pm5500)
988 err = snd_ctl_add(chip->card,
989 (master_vol = snd_ctl_new1(snd_pmac_awacs_mixers_pmac5500,
990 chip)));
a8c2a6bf
RS		 991 else if (beige)
992 err = build_mixers(chip,
993 ARRAY_SIZE(snd_pmac_screamer_mixers_beige),
994 snd_pmac_screamer_mixers_beige);
dca7c741
RS		 995 else if (imac || lombard) {
996 err = snd_ctl_add(chip->card,
997 (master_vol = snd_ctl_new1(snd_pmac_screamer_mixers_lo,
998 chip)));
999 if (err < 0)
1000 return err;
a8c2a6bf
RS		 1001 err = build_mixers(chip,
1002 ARRAY_SIZE(snd_pmac_screamer_mixers_imac),
1003 snd_pmac_screamer_mixers_imac);
dca7c741 1004 } else if (g4agp)
4dbf95ba
RS		 1005 err = build_mixers(chip,
1006 ARRAY_SIZE(snd_pmac_screamer_mixers_g4agp),
1007 snd_pmac_screamer_mixers_g4agp);
a8c2a6bf
RS		 1008 else
1009 err = build_mixers(chip,
1010 ARRAY_SIZE(snd_pmac_awacs_mixers_pmac),
1011 snd_pmac_awacs_mixers_pmac);
1012 if (err < 0)
1013 return err;
573934bc 1014 chip->master_sw_ctl = snd_ctl_new1((pm7500 || imac || g4agp || lombard)
a8c2a6bf 1015 ? &snd_pmac_awacs_master_sw_imac
dca7c741
RS		 1016 : pm5500
1017 ? &snd_pmac_awacs_master_sw_pmac5500
a8c2a6bf 1018 : &snd_pmac_awacs_master_sw, chip);
7ae44cfa
RS		 1019 err = snd_ctl_add(chip->card, chip->master_sw_ctl);
1020 if (err < 0)
1da177e4
LT		 1021 return err;
1022#ifdef PMAC_AMP_AVAIL
1023 if (chip->mixer_data) {
1024 /* use amplifier. the signal is connected from route A
1025 * to the amp. the amp has its headphone and speaker
1026 * volumes and mute switches, so we use them instead of
1027 * screamer registers.
1028 * in this case, it seems the route C is not used.
1029 */
7ae44cfa
RS		 1030 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_amp_vol),
1031 snd_pmac_awacs_amp_vol);
1032 if (err < 0)
1da177e4
LT		 1033 return err;
1034 /* overwrite */
7ae44cfa
RS		 1035 chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_hp_sw,
1036 chip);
1037 err = snd_ctl_add(chip->card, chip->master_sw_ctl);
1038 if (err < 0)
1da177e4 1039 return err;
7ae44cfa
RS		 1040 chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_awacs_amp_spk_sw,
1041 chip);
1042 err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1043 if (err < 0)
1da177e4
LT		 1044 return err;
1045 } else
1046#endif /* PMAC_AMP_AVAIL */
1047 {
1048 /* route A = headphone, route C = speaker */
dca7c741
RS		 1049 err = snd_ctl_add(chip->card,
1050 (speaker_vol = snd_ctl_new1(snd_pmac_awacs_speaker_vol,
1051 chip)));
7ae44cfa 1052 if (err < 0)
1da177e4 1053 return err;
030b655b
RS		 1054 chip->speaker_sw_ctl = snd_ctl_new1(imac1
1055 ? &snd_pmac_awacs_speaker_sw_imac1
1056 : imac2
1057 ? &snd_pmac_awacs_speaker_sw_imac2
a8c2a6bf 1058 : &snd_pmac_awacs_speaker_sw, chip);
7ae44cfa
RS		 1059 err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
1060 if (err < 0)
1da177e4
LT		 1061 return err;
1062 }
1063
dca7c741
RS		 1064 if (pm5500 || imac || lombard) {
1065 vmaster_sw = snd_ctl_make_virtual_master(
1066 "Master Playback Switch", (unsigned int *) NULL);
9ab0cb30
TI		 1067 err = snd_ctl_add_follower_uncached(vmaster_sw,
1068 chip->master_sw_ctl);
dca7c741
RS		 1069 if (err < 0)
1070 return err;
9ab0cb30
TI		 1071 err = snd_ctl_add_follower_uncached(vmaster_sw,
1072 chip->speaker_sw_ctl);
dca7c741
RS		 1073 if (err < 0)
1074 return err;
1075 err = snd_ctl_add(chip->card, vmaster_sw);
1076 if (err < 0)
1077 return err;
1078 vmaster_vol = snd_ctl_make_virtual_master(
1079 "Master Playback Volume", (unsigned int *) NULL);
9ab0cb30 1080 err = snd_ctl_add_follower(vmaster_vol, master_vol);
dca7c741
RS		 1081 if (err < 0)
1082 return err;
9ab0cb30 1083 err = snd_ctl_add_follower(vmaster_vol, speaker_vol);
dca7c741
RS		 1084 if (err < 0)
1085 return err;
1086 err = snd_ctl_add(chip->card, vmaster_vol);
1087 if (err < 0)
1088 return err;
1089 }
1090
4dbf95ba 1091 if (beige || g4agp)
a8c2a6bf
RS		 1092 err = build_mixers(chip,
1093 ARRAY_SIZE(snd_pmac_screamer_mic_boost_beige),
1094 snd_pmac_screamer_mic_boost_beige);
1095 else if (imac)
1096 err = build_mixers(chip,
1097 ARRAY_SIZE(snd_pmac_screamer_mic_boost_imac),
1098 snd_pmac_screamer_mic_boost_imac);
1099 else if (chip->model == PMAC_SCREAMER)
1100 err = build_mixers(chip,
1101 ARRAY_SIZE(snd_pmac_screamer_mic_boost),
1102 snd_pmac_screamer_mic_boost);
1103 else if (pm7500)
1104 err = build_mixers(chip,
1105 ARRAY_SIZE(snd_pmac_awacs_mic_boost_pmac7500),
1106 snd_pmac_awacs_mic_boost_pmac7500);
1107 else
1108 err = build_mixers(chip, ARRAY_SIZE(snd_pmac_awacs_mic_boost),
1109 snd_pmac_awacs_mic_boost);
1110 if (err < 0)
1111 return err;
1da177e4
LT		 1112
1113 /*
1114 * set lowlevel callbacks
1115 */
1116 chip->set_format = snd_pmac_awacs_set_format;
8c870933 1117#ifdef CONFIG_PM
1da177e4
LT		 1118 chip->suspend = snd_pmac_awacs_suspend;
1119 chip->resume = snd_pmac_awacs_resume;
1120#endif
1121#ifdef PMAC_SUPPORT_AUTOMUTE
7ae44cfa
RS		 1122 err = snd_pmac_add_automute(chip);
1123 if (err < 0)
1da177e4
LT		 1124 return err;
1125 chip->detect_headphone = snd_pmac_awacs_detect_headphone;
1126 chip->update_automute = snd_pmac_awacs_update_automute;
1127 snd_pmac_awacs_update_automute(chip, 0); /* update the status only */
1128#endif
1129 if (chip->model == PMAC_SCREAMER) {
1130 snd_pmac_awacs_write_noreg(chip, 6, chip->awacs_reg[6]);
1131 snd_pmac_awacs_write_noreg(chip, 0, chip->awacs_reg[0]);
1132 }
1133
1134 return 0;
1135}
Linux 6.x block layer and io_uring tree(s)