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