xref: /linux/sound/ppc/burgundy.c (revision a1c613ae4c322ddd58d5a8539dbfba2a0380a8c0)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * PMac Burgundy lowlevel functions
4  *
5  * Copyright (c) by Takashi Iwai <tiwai@suse.de>
6  * code based on dmasound.c.
7  */
8 
9 #include <linux/io.h>
10 #include <linux/init.h>
11 #include <linux/delay.h>
12 #include <linux/of.h>
13 #include <sound/core.h>
14 #include "pmac.h"
15 #include "burgundy.h"
16 
17 
18 /* Waits for busy flag to clear */
19 static inline void
snd_pmac_burgundy_busy_wait(struct snd_pmac * chip)20 snd_pmac_burgundy_busy_wait(struct snd_pmac *chip)
21 {
22 	int timeout = 50;
23 	while ((in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) && timeout--)
24 		udelay(1);
25 	if (timeout < 0)
26 		printk(KERN_DEBUG "burgundy_busy_wait: timeout\n");
27 }
28 
29 static inline void
snd_pmac_burgundy_extend_wait(struct snd_pmac * chip)30 snd_pmac_burgundy_extend_wait(struct snd_pmac *chip)
31 {
32 	int timeout;
33 	timeout = 50;
34 	while (!(in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--)
35 		udelay(1);
36 	if (timeout < 0)
37 		printk(KERN_DEBUG "burgundy_extend_wait: timeout #1\n");
38 	timeout = 50;
39 	while ((in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--)
40 		udelay(1);
41 	if (timeout < 0)
42 		printk(KERN_DEBUG "burgundy_extend_wait: timeout #2\n");
43 }
44 
45 static void
snd_pmac_burgundy_wcw(struct snd_pmac * chip,unsigned addr,unsigned val)46 snd_pmac_burgundy_wcw(struct snd_pmac *chip, unsigned addr, unsigned val)
47 {
48 	out_le32(&chip->awacs->codec_ctrl, addr + 0x200c00 + (val & 0xff));
49 	snd_pmac_burgundy_busy_wait(chip);
50 	out_le32(&chip->awacs->codec_ctrl, addr + 0x200d00 +((val>>8) & 0xff));
51 	snd_pmac_burgundy_busy_wait(chip);
52 	out_le32(&chip->awacs->codec_ctrl, addr + 0x200e00 +((val>>16) & 0xff));
53 	snd_pmac_burgundy_busy_wait(chip);
54 	out_le32(&chip->awacs->codec_ctrl, addr + 0x200f00 +((val>>24) & 0xff));
55 	snd_pmac_burgundy_busy_wait(chip);
56 }
57 
58 static unsigned
snd_pmac_burgundy_rcw(struct snd_pmac * chip,unsigned addr)59 snd_pmac_burgundy_rcw(struct snd_pmac *chip, unsigned addr)
60 {
61 	unsigned val = 0;
62 	unsigned long flags;
63 
64 	spin_lock_irqsave(&chip->reg_lock, flags);
65 
66 	out_le32(&chip->awacs->codec_ctrl, addr + 0x100000);
67 	snd_pmac_burgundy_busy_wait(chip);
68 	snd_pmac_burgundy_extend_wait(chip);
69 	val += (in_le32(&chip->awacs->codec_stat) >> 4) & 0xff;
70 
71 	out_le32(&chip->awacs->codec_ctrl, addr + 0x100100);
72 	snd_pmac_burgundy_busy_wait(chip);
73 	snd_pmac_burgundy_extend_wait(chip);
74 	val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<8;
75 
76 	out_le32(&chip->awacs->codec_ctrl, addr + 0x100200);
77 	snd_pmac_burgundy_busy_wait(chip);
78 	snd_pmac_burgundy_extend_wait(chip);
79 	val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<16;
80 
81 	out_le32(&chip->awacs->codec_ctrl, addr + 0x100300);
82 	snd_pmac_burgundy_busy_wait(chip);
83 	snd_pmac_burgundy_extend_wait(chip);
84 	val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<24;
85 
86 	spin_unlock_irqrestore(&chip->reg_lock, flags);
87 
88 	return val;
89 }
90 
91 static void
snd_pmac_burgundy_wcb(struct snd_pmac * chip,unsigned int addr,unsigned int val)92 snd_pmac_burgundy_wcb(struct snd_pmac *chip, unsigned int addr,
93 		      unsigned int val)
94 {
95 	out_le32(&chip->awacs->codec_ctrl, addr + 0x300000 + (val & 0xff));
96 	snd_pmac_burgundy_busy_wait(chip);
97 }
98 
99 static unsigned
snd_pmac_burgundy_rcb(struct snd_pmac * chip,unsigned int addr)100 snd_pmac_burgundy_rcb(struct snd_pmac *chip, unsigned int addr)
101 {
102 	unsigned val = 0;
103 	unsigned long flags;
104 
105 	spin_lock_irqsave(&chip->reg_lock, flags);
106 
107 	out_le32(&chip->awacs->codec_ctrl, addr + 0x100000);
108 	snd_pmac_burgundy_busy_wait(chip);
109 	snd_pmac_burgundy_extend_wait(chip);
110 	val += (in_le32(&chip->awacs->codec_stat) >> 4) & 0xff;
111 
112 	spin_unlock_irqrestore(&chip->reg_lock, flags);
113 
114 	return val;
115 }
116 
117 #define BASE2ADDR(base)	((base) << 12)
118 #define ADDR2BASE(addr)	((addr) >> 12)
119 
120 /*
121  * Burgundy volume: 0 - 100, stereo, word reg
122  */
123 static void
snd_pmac_burgundy_write_volume(struct snd_pmac * chip,unsigned int address,long * volume,int shift)124 snd_pmac_burgundy_write_volume(struct snd_pmac *chip, unsigned int address,
125 			       long *volume, int shift)
126 {
127 	int hardvolume, lvolume, rvolume;
128 
129 	if (volume[0] < 0 || volume[0] > 100 ||
130 	    volume[1] < 0 || volume[1] > 100)
131 		return; /* -EINVAL */
132 	lvolume = volume[0] ? volume[0] + BURGUNDY_VOLUME_OFFSET : 0;
133 	rvolume = volume[1] ? volume[1] + BURGUNDY_VOLUME_OFFSET : 0;
134 
135 	hardvolume = lvolume + (rvolume << shift);
136 	if (shift == 8)
137 		hardvolume |= hardvolume << 16;
138 
139 	snd_pmac_burgundy_wcw(chip, address, hardvolume);
140 }
141 
142 static void
snd_pmac_burgundy_read_volume(struct snd_pmac * chip,unsigned int address,long * volume,int shift)143 snd_pmac_burgundy_read_volume(struct snd_pmac *chip, unsigned int address,
144 			      long *volume, int shift)
145 {
146 	int wvolume;
147 
148 	wvolume = snd_pmac_burgundy_rcw(chip, address);
149 
150 	volume[0] = wvolume & 0xff;
151 	if (volume[0] >= BURGUNDY_VOLUME_OFFSET)
152 		volume[0] -= BURGUNDY_VOLUME_OFFSET;
153 	else
154 		volume[0] = 0;
155 	volume[1] = (wvolume >> shift) & 0xff;
156 	if (volume[1] >= BURGUNDY_VOLUME_OFFSET)
157 		volume[1] -= BURGUNDY_VOLUME_OFFSET;
158 	else
159 		volume[1] = 0;
160 }
161 
snd_pmac_burgundy_info_volume(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)162 static int snd_pmac_burgundy_info_volume(struct snd_kcontrol *kcontrol,
163 					 struct snd_ctl_elem_info *uinfo)
164 {
165 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
166 	uinfo->count = 2;
167 	uinfo->value.integer.min = 0;
168 	uinfo->value.integer.max = 100;
169 	return 0;
170 }
171 
snd_pmac_burgundy_get_volume(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)172 static int snd_pmac_burgundy_get_volume(struct snd_kcontrol *kcontrol,
173 					struct snd_ctl_elem_value *ucontrol)
174 {
175 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
176 	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
177 	int shift = (kcontrol->private_value >> 8) & 0xff;
178 	snd_pmac_burgundy_read_volume(chip, addr,
179 				      ucontrol->value.integer.value, shift);
180 	return 0;
181 }
182 
snd_pmac_burgundy_put_volume(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)183 static int snd_pmac_burgundy_put_volume(struct snd_kcontrol *kcontrol,
184 					struct snd_ctl_elem_value *ucontrol)
185 {
186 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
187 	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
188 	int shift = (kcontrol->private_value >> 8) & 0xff;
189 	long nvoices[2];
190 
191 	snd_pmac_burgundy_write_volume(chip, addr,
192 				       ucontrol->value.integer.value, shift);
193 	snd_pmac_burgundy_read_volume(chip, addr, nvoices, shift);
194 	return (nvoices[0] != ucontrol->value.integer.value[0] ||
195 		nvoices[1] != ucontrol->value.integer.value[1]);
196 }
197 
198 #define BURGUNDY_VOLUME_W(xname, xindex, addr, shift) \
199 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
200   .info = snd_pmac_burgundy_info_volume,\
201   .get = snd_pmac_burgundy_get_volume,\
202   .put = snd_pmac_burgundy_put_volume,\
203   .private_value = ((ADDR2BASE(addr) & 0xff) | ((shift) << 8)) }
204 
205 /*
206  * Burgundy volume: 0 - 100, stereo, 2-byte reg
207  */
208 static void
snd_pmac_burgundy_write_volume_2b(struct snd_pmac * chip,unsigned int address,long * volume,int off)209 snd_pmac_burgundy_write_volume_2b(struct snd_pmac *chip, unsigned int address,
210 				  long *volume, int off)
211 {
212 	int lvolume, rvolume;
213 
214 	off |= off << 2;
215 	lvolume = volume[0] ? volume[0] + BURGUNDY_VOLUME_OFFSET : 0;
216 	rvolume = volume[1] ? volume[1] + BURGUNDY_VOLUME_OFFSET : 0;
217 
218 	snd_pmac_burgundy_wcb(chip, address + off, lvolume);
219 	snd_pmac_burgundy_wcb(chip, address + off + 0x500, rvolume);
220 }
221 
222 static void
snd_pmac_burgundy_read_volume_2b(struct snd_pmac * chip,unsigned int address,long * volume,int off)223 snd_pmac_burgundy_read_volume_2b(struct snd_pmac *chip, unsigned int address,
224 				 long *volume, int off)
225 {
226 	volume[0] = snd_pmac_burgundy_rcb(chip, address + off);
227 	if (volume[0] >= BURGUNDY_VOLUME_OFFSET)
228 		volume[0] -= BURGUNDY_VOLUME_OFFSET;
229 	else
230 		volume[0] = 0;
231 	volume[1] = snd_pmac_burgundy_rcb(chip, address + off + 0x100);
232 	if (volume[1] >= BURGUNDY_VOLUME_OFFSET)
233 		volume[1] -= BURGUNDY_VOLUME_OFFSET;
234 	else
235 		volume[1] = 0;
236 }
237 
snd_pmac_burgundy_info_volume_2b(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)238 static int snd_pmac_burgundy_info_volume_2b(struct snd_kcontrol *kcontrol,
239 					    struct snd_ctl_elem_info *uinfo)
240 {
241 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
242 	uinfo->count = 2;
243 	uinfo->value.integer.min = 0;
244 	uinfo->value.integer.max = 100;
245 	return 0;
246 }
247 
snd_pmac_burgundy_get_volume_2b(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)248 static int snd_pmac_burgundy_get_volume_2b(struct snd_kcontrol *kcontrol,
249 					   struct snd_ctl_elem_value *ucontrol)
250 {
251 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
252 	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
253 	int off = kcontrol->private_value & 0x300;
254 	snd_pmac_burgundy_read_volume_2b(chip, addr,
255 			ucontrol->value.integer.value, off);
256 	return 0;
257 }
258 
snd_pmac_burgundy_put_volume_2b(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)259 static int snd_pmac_burgundy_put_volume_2b(struct snd_kcontrol *kcontrol,
260 					   struct snd_ctl_elem_value *ucontrol)
261 {
262 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
263 	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
264 	int off = kcontrol->private_value & 0x300;
265 	long nvoices[2];
266 
267 	snd_pmac_burgundy_write_volume_2b(chip, addr,
268 			ucontrol->value.integer.value, off);
269 	snd_pmac_burgundy_read_volume_2b(chip, addr, nvoices, off);
270 	return (nvoices[0] != ucontrol->value.integer.value[0] ||
271 		nvoices[1] != ucontrol->value.integer.value[1]);
272 }
273 
274 #define BURGUNDY_VOLUME_2B(xname, xindex, addr, off) \
275 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
276   .info = snd_pmac_burgundy_info_volume_2b,\
277   .get = snd_pmac_burgundy_get_volume_2b,\
278   .put = snd_pmac_burgundy_put_volume_2b,\
279   .private_value = ((ADDR2BASE(addr) & 0xff) | ((off) << 8)) }
280 
281 /*
282  * Burgundy gain/attenuation: 0 - 15, mono/stereo, byte reg
283  */
snd_pmac_burgundy_info_gain(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)284 static int snd_pmac_burgundy_info_gain(struct snd_kcontrol *kcontrol,
285 				       struct snd_ctl_elem_info *uinfo)
286 {
287 	int stereo = (kcontrol->private_value >> 24) & 1;
288 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
289 	uinfo->count = stereo + 1;
290 	uinfo->value.integer.min = 0;
291 	uinfo->value.integer.max = 15;
292 	return 0;
293 }
294 
snd_pmac_burgundy_get_gain(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)295 static int snd_pmac_burgundy_get_gain(struct snd_kcontrol *kcontrol,
296 				      struct snd_ctl_elem_value *ucontrol)
297 {
298 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
299 	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
300 	int stereo = (kcontrol->private_value >> 24) & 1;
301 	int atten = (kcontrol->private_value >> 25) & 1;
302 	int oval;
303 
304 	oval = snd_pmac_burgundy_rcb(chip, addr);
305 	if (atten)
306 		oval = ~oval & 0xff;
307 	ucontrol->value.integer.value[0] = oval & 0xf;
308 	if (stereo)
309 		ucontrol->value.integer.value[1] = (oval >> 4) & 0xf;
310 	return 0;
311 }
312 
snd_pmac_burgundy_put_gain(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)313 static int snd_pmac_burgundy_put_gain(struct snd_kcontrol *kcontrol,
314 				      struct snd_ctl_elem_value *ucontrol)
315 {
316 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
317 	unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
318 	int stereo = (kcontrol->private_value >> 24) & 1;
319 	int atten = (kcontrol->private_value >> 25) & 1;
320 	int oval, val;
321 
322 	oval = snd_pmac_burgundy_rcb(chip, addr);
323 	if (atten)
324 		oval = ~oval & 0xff;
325 	val = ucontrol->value.integer.value[0];
326 	if (stereo)
327 		val |= ucontrol->value.integer.value[1] << 4;
328 	else
329 		val |= ucontrol->value.integer.value[0] << 4;
330 	if (atten)
331 		val = ~val & 0xff;
332 	snd_pmac_burgundy_wcb(chip, addr, val);
333 	return val != oval;
334 }
335 
336 #define BURGUNDY_VOLUME_B(xname, xindex, addr, stereo, atten) \
337 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
338   .info = snd_pmac_burgundy_info_gain,\
339   .get = snd_pmac_burgundy_get_gain,\
340   .put = snd_pmac_burgundy_put_gain,\
341   .private_value = (ADDR2BASE(addr) | ((stereo) << 24) | ((atten) << 25)) }
342 
343 /*
344  * Burgundy switch: 0/1, mono/stereo, word reg
345  */
snd_pmac_burgundy_info_switch_w(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)346 static int snd_pmac_burgundy_info_switch_w(struct snd_kcontrol *kcontrol,
347 					   struct snd_ctl_elem_info *uinfo)
348 {
349 	int stereo = (kcontrol->private_value >> 24) & 1;
350 	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
351 	uinfo->count = stereo + 1;
352 	uinfo->value.integer.min = 0;
353 	uinfo->value.integer.max = 1;
354 	return 0;
355 }
356 
snd_pmac_burgundy_get_switch_w(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)357 static int snd_pmac_burgundy_get_switch_w(struct snd_kcontrol *kcontrol,
358 					  struct snd_ctl_elem_value *ucontrol)
359 {
360 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
361 	unsigned int addr = BASE2ADDR((kcontrol->private_value >> 16) & 0xff);
362 	int lmask = 1 << (kcontrol->private_value & 0xff);
363 	int rmask = 1 << ((kcontrol->private_value >> 8) & 0xff);
364 	int stereo = (kcontrol->private_value >> 24) & 1;
365 	int val = snd_pmac_burgundy_rcw(chip, addr);
366 	ucontrol->value.integer.value[0] = (val & lmask) ? 1 : 0;
367 	if (stereo)
368 		ucontrol->value.integer.value[1] = (val & rmask) ? 1 : 0;
369 	return 0;
370 }
371 
snd_pmac_burgundy_put_switch_w(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)372 static int snd_pmac_burgundy_put_switch_w(struct snd_kcontrol *kcontrol,
373 					  struct snd_ctl_elem_value *ucontrol)
374 {
375 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
376 	unsigned int addr = BASE2ADDR((kcontrol->private_value >> 16) & 0xff);
377 	int lmask = 1 << (kcontrol->private_value & 0xff);
378 	int rmask = 1 << ((kcontrol->private_value >> 8) & 0xff);
379 	int stereo = (kcontrol->private_value >> 24) & 1;
380 	int val, oval;
381 	oval = snd_pmac_burgundy_rcw(chip, addr);
382 	val = oval & ~(lmask | (stereo ? rmask : 0));
383 	if (ucontrol->value.integer.value[0])
384 		val |= lmask;
385 	if (stereo && ucontrol->value.integer.value[1])
386 		val |= rmask;
387 	snd_pmac_burgundy_wcw(chip, addr, val);
388 	return val != oval;
389 }
390 
391 #define BURGUNDY_SWITCH_W(xname, xindex, addr, lbit, rbit, stereo) \
392 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
393   .info = snd_pmac_burgundy_info_switch_w,\
394   .get = snd_pmac_burgundy_get_switch_w,\
395   .put = snd_pmac_burgundy_put_switch_w,\
396   .private_value = ((lbit) | ((rbit) << 8)\
397 		| (ADDR2BASE(addr) << 16) | ((stereo) << 24)) }
398 
399 /*
400  * Burgundy switch: 0/1, mono/stereo, byte reg, bit mask
401  */
snd_pmac_burgundy_info_switch_b(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)402 static int snd_pmac_burgundy_info_switch_b(struct snd_kcontrol *kcontrol,
403 					   struct snd_ctl_elem_info *uinfo)
404 {
405 	int stereo = (kcontrol->private_value >> 24) & 1;
406 	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
407 	uinfo->count = stereo + 1;
408 	uinfo->value.integer.min = 0;
409 	uinfo->value.integer.max = 1;
410 	return 0;
411 }
412 
snd_pmac_burgundy_get_switch_b(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)413 static int snd_pmac_burgundy_get_switch_b(struct snd_kcontrol *kcontrol,
414 					  struct snd_ctl_elem_value *ucontrol)
415 {
416 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
417 	unsigned int addr = BASE2ADDR((kcontrol->private_value >> 16) & 0xff);
418 	int lmask = kcontrol->private_value & 0xff;
419 	int rmask = (kcontrol->private_value >> 8) & 0xff;
420 	int stereo = (kcontrol->private_value >> 24) & 1;
421 	int val = snd_pmac_burgundy_rcb(chip, addr);
422 	ucontrol->value.integer.value[0] = (val & lmask) ? 1 : 0;
423 	if (stereo)
424 		ucontrol->value.integer.value[1] = (val & rmask) ? 1 : 0;
425 	return 0;
426 }
427 
snd_pmac_burgundy_put_switch_b(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)428 static int snd_pmac_burgundy_put_switch_b(struct snd_kcontrol *kcontrol,
429 					  struct snd_ctl_elem_value *ucontrol)
430 {
431 	struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
432 	unsigned int addr = BASE2ADDR((kcontrol->private_value >> 16) & 0xff);
433 	int lmask = kcontrol->private_value & 0xff;
434 	int rmask = (kcontrol->private_value >> 8) & 0xff;
435 	int stereo = (kcontrol->private_value >> 24) & 1;
436 	int val, oval;
437 	oval = snd_pmac_burgundy_rcb(chip, addr);
438 	val = oval & ~(lmask | rmask);
439 	if (ucontrol->value.integer.value[0])
440 		val |= lmask;
441 	if (stereo && ucontrol->value.integer.value[1])
442 		val |= rmask;
443 	snd_pmac_burgundy_wcb(chip, addr, val);
444 	return val != oval;
445 }
446 
447 #define BURGUNDY_SWITCH_B(xname, xindex, addr, lmask, rmask, stereo) \
448 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
449   .info = snd_pmac_burgundy_info_switch_b,\
450   .get = snd_pmac_burgundy_get_switch_b,\
451   .put = snd_pmac_burgundy_put_switch_b,\
452   .private_value = ((lmask) | ((rmask) << 8)\
453 		| (ADDR2BASE(addr) << 16) | ((stereo) << 24)) }
454 
455 /*
456  * Burgundy mixers
457  */
458 static const struct snd_kcontrol_new snd_pmac_burgundy_mixers[] = {
459 	BURGUNDY_VOLUME_W("Master Playback Volume", 0,
460 			MASK_ADDR_BURGUNDY_MASTER_VOLUME, 8),
461 	BURGUNDY_VOLUME_W("CD Capture Volume", 0,
462 			MASK_ADDR_BURGUNDY_VOLCD, 16),
463 	BURGUNDY_VOLUME_2B("Input Capture Volume", 0,
464 			MASK_ADDR_BURGUNDY_VOLMIX01, 2),
465 	BURGUNDY_VOLUME_2B("Mixer Playback Volume", 0,
466 			MASK_ADDR_BURGUNDY_VOLMIX23, 0),
467 	BURGUNDY_VOLUME_B("CD Gain Capture Volume", 0,
468 			MASK_ADDR_BURGUNDY_GAINCD, 1, 0),
469 	BURGUNDY_SWITCH_W("Master Capture Switch", 0,
470 			MASK_ADDR_BURGUNDY_OUTPUTENABLES, 24, 0, 0),
471 	BURGUNDY_SWITCH_W("CD Capture Switch", 0,
472 			MASK_ADDR_BURGUNDY_CAPTURESELECTS, 0, 16, 1),
473 	BURGUNDY_SWITCH_W("CD Playback Switch", 0,
474 			MASK_ADDR_BURGUNDY_OUTPUTSELECTS, 0, 16, 1),
475 /*	BURGUNDY_SWITCH_W("Loop Capture Switch", 0,
476  *		MASK_ADDR_BURGUNDY_CAPTURESELECTS, 8, 24, 1),
477  *	BURGUNDY_SWITCH_B("Mixer out Capture Switch", 0,
478  *		MASK_ADDR_BURGUNDY_HOSTIFAD, 0x02, 0, 0),
479  *	BURGUNDY_SWITCH_B("Mixer Capture Switch", 0,
480  *		MASK_ADDR_BURGUNDY_HOSTIFAD, 0x01, 0, 0),
481  *	BURGUNDY_SWITCH_B("PCM out Capture Switch", 0,
482  *		MASK_ADDR_BURGUNDY_HOSTIFEH, 0x02, 0, 0),
483  */	BURGUNDY_SWITCH_B("PCM Capture Switch", 0,
484 			MASK_ADDR_BURGUNDY_HOSTIFEH, 0x01, 0, 0)
485 };
486 static const struct snd_kcontrol_new snd_pmac_burgundy_mixers_imac[] = {
487 	BURGUNDY_VOLUME_W("Line in Capture Volume", 0,
488 			MASK_ADDR_BURGUNDY_VOLLINE, 16),
489 	BURGUNDY_VOLUME_W("Mic Capture Volume", 0,
490 			MASK_ADDR_BURGUNDY_VOLMIC, 16),
491 	BURGUNDY_VOLUME_B("Line in Gain Capture Volume", 0,
492 			MASK_ADDR_BURGUNDY_GAINLINE, 1, 0),
493 	BURGUNDY_VOLUME_B("Mic Gain Capture Volume", 0,
494 			MASK_ADDR_BURGUNDY_GAINMIC, 1, 0),
495 	BURGUNDY_VOLUME_B("Speaker Playback Volume", 0,
496 			MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1, 1),
497 	BURGUNDY_VOLUME_B("Line out Playback Volume", 0,
498 			MASK_ADDR_BURGUNDY_ATTENLINEOUT, 1, 1),
499 	BURGUNDY_VOLUME_B("Headphone Playback Volume", 0,
500 			MASK_ADDR_BURGUNDY_ATTENHP, 1, 1),
501 	BURGUNDY_SWITCH_W("Line in Capture Switch", 0,
502 			MASK_ADDR_BURGUNDY_CAPTURESELECTS, 1, 17, 1),
503 	BURGUNDY_SWITCH_W("Mic Capture Switch", 0,
504 			MASK_ADDR_BURGUNDY_CAPTURESELECTS, 2, 18, 1),
505 	BURGUNDY_SWITCH_W("Line in Playback Switch", 0,
506 			MASK_ADDR_BURGUNDY_OUTPUTSELECTS, 1, 17, 1),
507 	BURGUNDY_SWITCH_W("Mic Playback Switch", 0,
508 			MASK_ADDR_BURGUNDY_OUTPUTSELECTS, 2, 18, 1),
509 	BURGUNDY_SWITCH_B("Mic Boost Capture Switch", 0,
510 			MASK_ADDR_BURGUNDY_INPBOOST, 0x40, 0x80, 1)
511 };
512 static const struct snd_kcontrol_new snd_pmac_burgundy_mixers_pmac[] = {
513 	BURGUNDY_VOLUME_W("Line in Capture Volume", 0,
514 			MASK_ADDR_BURGUNDY_VOLMIC, 16),
515 	BURGUNDY_VOLUME_B("Line in Gain Capture Volume", 0,
516 			MASK_ADDR_BURGUNDY_GAINMIC, 1, 0),
517 	BURGUNDY_VOLUME_B("Speaker Playback Volume", 0,
518 			MASK_ADDR_BURGUNDY_ATTENMONO, 0, 1),
519 	BURGUNDY_VOLUME_B("Line out Playback Volume", 0,
520 			MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1, 1),
521 	BURGUNDY_SWITCH_W("Line in Capture Switch", 0,
522 			MASK_ADDR_BURGUNDY_CAPTURESELECTS, 2, 18, 1),
523 	BURGUNDY_SWITCH_W("Line in Playback Switch", 0,
524 			MASK_ADDR_BURGUNDY_OUTPUTSELECTS, 2, 18, 1),
525 /*	BURGUNDY_SWITCH_B("Line in Boost Capture Switch", 0,
526  *		MASK_ADDR_BURGUNDY_INPBOOST, 0x40, 0x80, 1) */
527 };
528 static const struct snd_kcontrol_new snd_pmac_burgundy_master_sw_imac =
529 BURGUNDY_SWITCH_B("Master Playback Switch", 0,
530 	MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
531 	BURGUNDY_OUTPUT_LEFT | BURGUNDY_LINEOUT_LEFT | BURGUNDY_HP_LEFT,
532 	BURGUNDY_OUTPUT_RIGHT | BURGUNDY_LINEOUT_RIGHT | BURGUNDY_HP_RIGHT, 1);
533 static const struct snd_kcontrol_new snd_pmac_burgundy_master_sw_pmac =
534 BURGUNDY_SWITCH_B("Master Playback Switch", 0,
535 	MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
536 	BURGUNDY_OUTPUT_INTERN
537 	| BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
538 static const struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw_imac =
539 BURGUNDY_SWITCH_B("Speaker Playback Switch", 0,
540 	MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
541 	BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
542 static const struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw_pmac =
543 BURGUNDY_SWITCH_B("Speaker Playback Switch", 0,
544 	MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
545 	BURGUNDY_OUTPUT_INTERN, 0, 0);
546 static const struct snd_kcontrol_new snd_pmac_burgundy_line_sw_imac =
547 BURGUNDY_SWITCH_B("Line out Playback Switch", 0,
548 	MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
549 	BURGUNDY_LINEOUT_LEFT, BURGUNDY_LINEOUT_RIGHT, 1);
550 static const struct snd_kcontrol_new snd_pmac_burgundy_line_sw_pmac =
551 BURGUNDY_SWITCH_B("Line out Playback Switch", 0,
552 	MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
553 	BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
554 static const struct snd_kcontrol_new snd_pmac_burgundy_hp_sw_imac =
555 BURGUNDY_SWITCH_B("Headphone Playback Switch", 0,
556 	MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
557 	BURGUNDY_HP_LEFT, BURGUNDY_HP_RIGHT, 1);
558 
559 
560 #ifdef PMAC_SUPPORT_AUTOMUTE
561 /*
562  * auto-mute stuffs
563  */
snd_pmac_burgundy_detect_headphone(struct snd_pmac * chip)564 static int snd_pmac_burgundy_detect_headphone(struct snd_pmac *chip)
565 {
566 	return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
567 }
568 
snd_pmac_burgundy_update_automute(struct snd_pmac * chip,int do_notify)569 static void snd_pmac_burgundy_update_automute(struct snd_pmac *chip, int do_notify)
570 {
571 	if (chip->auto_mute) {
572 		int imac = of_machine_is_compatible("iMac");
573 		int reg, oreg;
574 		reg = oreg = snd_pmac_burgundy_rcb(chip,
575 				MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES);
576 		reg &= imac ? ~(BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT
577 				| BURGUNDY_HP_LEFT | BURGUNDY_HP_RIGHT)
578 			: ~(BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT
579 				| BURGUNDY_OUTPUT_INTERN);
580 		if (snd_pmac_burgundy_detect_headphone(chip))
581 			reg |= imac ? (BURGUNDY_HP_LEFT | BURGUNDY_HP_RIGHT)
582 				: (BURGUNDY_OUTPUT_LEFT
583 					| BURGUNDY_OUTPUT_RIGHT);
584 		else
585 			reg |= imac ? (BURGUNDY_OUTPUT_LEFT
586 					| BURGUNDY_OUTPUT_RIGHT)
587 				: (BURGUNDY_OUTPUT_INTERN);
588 		if (do_notify && reg == oreg)
589 			return;
590 		snd_pmac_burgundy_wcb(chip,
591 				MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES, reg);
592 		if (do_notify) {
593 			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
594 				       &chip->master_sw_ctl->id);
595 			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
596 				       &chip->speaker_sw_ctl->id);
597 			snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
598 				       &chip->hp_detect_ctl->id);
599 		}
600 	}
601 }
602 #endif /* PMAC_SUPPORT_AUTOMUTE */
603 
604 
605 /*
606  * initialize burgundy
607  */
snd_pmac_burgundy_init(struct snd_pmac * chip)608 int snd_pmac_burgundy_init(struct snd_pmac *chip)
609 {
610 	int imac = of_machine_is_compatible("iMac");
611 	int i, err;
612 
613 	/* Checks to see the chip is alive and kicking */
614 	if ((in_le32(&chip->awacs->codec_ctrl) & MASK_ERRCODE) == 0xf0000) {
615 		printk(KERN_WARNING "pmac burgundy: disabled by MacOS :-(\n");
616 		return 1;
617 	}
618 
619 	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_OUTPUTENABLES,
620 			   DEF_BURGUNDY_OUTPUTENABLES);
621 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
622 			   DEF_BURGUNDY_MORE_OUTPUTENABLES);
623 	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_OUTPUTSELECTS,
624 			   DEF_BURGUNDY_OUTPUTSELECTS);
625 
626 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL21,
627 			   DEF_BURGUNDY_INPSEL21);
628 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL3,
629 			   imac ? DEF_BURGUNDY_INPSEL3_IMAC
630 			   : DEF_BURGUNDY_INPSEL3_PMAC);
631 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINCD,
632 			   DEF_BURGUNDY_GAINCD);
633 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINLINE,
634 			   DEF_BURGUNDY_GAINLINE);
635 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMIC,
636 			   DEF_BURGUNDY_GAINMIC);
637 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMODEM,
638 			   DEF_BURGUNDY_GAINMODEM);
639 
640 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENSPEAKER,
641 			   DEF_BURGUNDY_ATTENSPEAKER);
642 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENLINEOUT,
643 			   DEF_BURGUNDY_ATTENLINEOUT);
644 	snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENHP,
645 			   DEF_BURGUNDY_ATTENHP);
646 
647 	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_MASTER_VOLUME,
648 			   DEF_BURGUNDY_MASTER_VOLUME);
649 	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLCD,
650 			   DEF_BURGUNDY_VOLCD);
651 	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLLINE,
652 			   DEF_BURGUNDY_VOLLINE);
653 	snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLMIC,
654 			   DEF_BURGUNDY_VOLMIC);
655 
656 	if (chip->hp_stat_mask == 0) {
657 		/* set headphone-jack detection bit */
658 		if (imac)
659 			chip->hp_stat_mask = BURGUNDY_HPDETECT_IMAC_UPPER
660 				| BURGUNDY_HPDETECT_IMAC_LOWER
661 				| BURGUNDY_HPDETECT_IMAC_SIDE;
662 		else
663 			chip->hp_stat_mask = BURGUNDY_HPDETECT_PMAC_BACK;
664 	}
665 	/*
666 	 * build burgundy mixers
667 	 */
668 	strcpy(chip->card->mixername, "PowerMac Burgundy");
669 
670 	for (i = 0; i < ARRAY_SIZE(snd_pmac_burgundy_mixers); i++) {
671 		err = snd_ctl_add(chip->card,
672 		    snd_ctl_new1(&snd_pmac_burgundy_mixers[i], chip));
673 		if (err < 0)
674 			return err;
675 	}
676 	for (i = 0; i < (imac ? ARRAY_SIZE(snd_pmac_burgundy_mixers_imac)
677 			: ARRAY_SIZE(snd_pmac_burgundy_mixers_pmac)); i++) {
678 		err = snd_ctl_add(chip->card,
679 		    snd_ctl_new1(imac ? &snd_pmac_burgundy_mixers_imac[i]
680 		    : &snd_pmac_burgundy_mixers_pmac[i], chip));
681 		if (err < 0)
682 			return err;
683 	}
684 	chip->master_sw_ctl = snd_ctl_new1(imac
685 			? &snd_pmac_burgundy_master_sw_imac
686 			: &snd_pmac_burgundy_master_sw_pmac, chip);
687 	err = snd_ctl_add(chip->card, chip->master_sw_ctl);
688 	if (err < 0)
689 		return err;
690 	chip->master_sw_ctl = snd_ctl_new1(imac
691 			? &snd_pmac_burgundy_line_sw_imac
692 			: &snd_pmac_burgundy_line_sw_pmac, chip);
693 	err = snd_ctl_add(chip->card, chip->master_sw_ctl);
694 	if (err < 0)
695 		return err;
696 	if (imac) {
697 		chip->master_sw_ctl = snd_ctl_new1(
698 				&snd_pmac_burgundy_hp_sw_imac, chip);
699 		err = snd_ctl_add(chip->card, chip->master_sw_ctl);
700 		if (err < 0)
701 			return err;
702 	}
703 	chip->speaker_sw_ctl = snd_ctl_new1(imac
704 			? &snd_pmac_burgundy_speaker_sw_imac
705 			: &snd_pmac_burgundy_speaker_sw_pmac, chip);
706 	err = snd_ctl_add(chip->card, chip->speaker_sw_ctl);
707 	if (err < 0)
708 		return err;
709 #ifdef PMAC_SUPPORT_AUTOMUTE
710 	err = snd_pmac_add_automute(chip);
711 	if (err < 0)
712 		return err;
713 
714 	chip->detect_headphone = snd_pmac_burgundy_detect_headphone;
715 	chip->update_automute = snd_pmac_burgundy_update_automute;
716 	snd_pmac_burgundy_update_automute(chip, 0); /* update the status only */
717 #endif
718 
719 	return 0;
720 }
721