~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/ppc/burgundy.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp