Merge branch 'hwmon-for-linus' of git://jdelvare.pck.nerim.net/jdelvare-2.6
[sfrench/cifs-2.6.git] / sound / ppc / burgundy.c
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 <sound/driver.h>
23 #include <asm/io.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/delay.h>
27 #include <sound/core.h>
28 #include "pmac.h"
29 #include "burgundy.h"
30
31
32 /* Waits for busy flag to clear */
33 static inline void
34 snd_pmac_burgundy_busy_wait(struct snd_pmac *chip)
35 {
36         int timeout = 50;
37         while ((in_le32(&chip->awacs->codec_ctrl) & MASK_NEWECMD) && timeout--)
38                 udelay(1);
39         if (! timeout)
40                 printk(KERN_DEBUG "burgundy_busy_wait: timeout\n");
41 }
42
43 static inline void
44 snd_pmac_burgundy_extend_wait(struct snd_pmac *chip)
45 {
46         int timeout;
47         timeout = 50;
48         while (!(in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--)
49                 udelay(1);
50         if (! timeout)
51                 printk(KERN_DEBUG "burgundy_extend_wait: timeout #1\n");
52         timeout = 50;
53         while ((in_le32(&chip->awacs->codec_stat) & MASK_EXTEND) && timeout--)
54                 udelay(1);
55         if (! timeout)
56                 printk(KERN_DEBUG "burgundy_extend_wait: timeout #2\n");
57 }
58
59 static void
60 snd_pmac_burgundy_wcw(struct snd_pmac *chip, unsigned addr, unsigned val)
61 {
62         out_le32(&chip->awacs->codec_ctrl, addr + 0x200c00 + (val & 0xff));
63         snd_pmac_burgundy_busy_wait(chip);
64         out_le32(&chip->awacs->codec_ctrl, addr + 0x200d00 +((val>>8) & 0xff));
65         snd_pmac_burgundy_busy_wait(chip);
66         out_le32(&chip->awacs->codec_ctrl, addr + 0x200e00 +((val>>16) & 0xff));
67         snd_pmac_burgundy_busy_wait(chip);
68         out_le32(&chip->awacs->codec_ctrl, addr + 0x200f00 +((val>>24) & 0xff));
69         snd_pmac_burgundy_busy_wait(chip);
70 }
71
72 static unsigned
73 snd_pmac_burgundy_rcw(struct snd_pmac *chip, unsigned addr)
74 {
75         unsigned val = 0;
76         unsigned long flags;
77
78         spin_lock_irqsave(&chip->reg_lock, flags);
79
80         out_le32(&chip->awacs->codec_ctrl, addr + 0x100000);
81         snd_pmac_burgundy_busy_wait(chip);
82         snd_pmac_burgundy_extend_wait(chip);
83         val += (in_le32(&chip->awacs->codec_stat) >> 4) & 0xff;
84
85         out_le32(&chip->awacs->codec_ctrl, addr + 0x100100);
86         snd_pmac_burgundy_busy_wait(chip);
87         snd_pmac_burgundy_extend_wait(chip);
88         val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<8;
89
90         out_le32(&chip->awacs->codec_ctrl, addr + 0x100200);
91         snd_pmac_burgundy_busy_wait(chip);
92         snd_pmac_burgundy_extend_wait(chip);
93         val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<16;
94
95         out_le32(&chip->awacs->codec_ctrl, addr + 0x100300);
96         snd_pmac_burgundy_busy_wait(chip);
97         snd_pmac_burgundy_extend_wait(chip);
98         val += ((in_le32(&chip->awacs->codec_stat)>>4) & 0xff) <<24;
99
100         spin_unlock_irqrestore(&chip->reg_lock, flags);
101
102         return val;
103 }
104
105 static void
106 snd_pmac_burgundy_wcb(struct snd_pmac *chip, unsigned int addr, unsigned int val)
107 {
108         out_le32(&chip->awacs->codec_ctrl, addr + 0x300000 + (val & 0xff));
109         snd_pmac_burgundy_busy_wait(chip);
110 }
111
112 static unsigned
113 snd_pmac_burgundy_rcb(struct snd_pmac *chip, unsigned int addr)
114 {
115         unsigned val = 0;
116         unsigned long flags;
117
118         spin_lock_irqsave(&chip->reg_lock, flags);
119
120         out_le32(&chip->awacs->codec_ctrl, addr + 0x100000);
121         snd_pmac_burgundy_busy_wait(chip);
122         snd_pmac_burgundy_extend_wait(chip);
123         val += (in_le32(&chip->awacs->codec_stat) >> 4) & 0xff;
124
125         spin_unlock_irqrestore(&chip->reg_lock, flags);
126
127         return val;
128 }
129
130 /*
131  * Burgundy volume: 0 - 100, stereo
132  */
133 static void
134 snd_pmac_burgundy_write_volume(struct snd_pmac *chip, unsigned int address,
135                                long *volume, int shift)
136 {
137         int hardvolume, lvolume, rvolume;
138
139         lvolume = volume[0] ? volume[0] + BURGUNDY_VOLUME_OFFSET : 0;
140         rvolume = volume[1] ? volume[1] + BURGUNDY_VOLUME_OFFSET : 0;
141
142         hardvolume = lvolume + (rvolume << shift);
143         if (shift == 8)
144                 hardvolume |= hardvolume << 16;
145
146         snd_pmac_burgundy_wcw(chip, address, hardvolume);
147 }
148
149 static void
150 snd_pmac_burgundy_read_volume(struct snd_pmac *chip, unsigned int address,
151                               long *volume, int shift)
152 {
153         int wvolume;
154
155         wvolume = snd_pmac_burgundy_rcw(chip, address);
156
157         volume[0] = wvolume & 0xff;
158         if (volume[0] >= BURGUNDY_VOLUME_OFFSET)
159                 volume[0] -= BURGUNDY_VOLUME_OFFSET;
160         else
161                 volume[0] = 0;
162         volume[1] = (wvolume >> shift) & 0xff;
163         if (volume[1] >= BURGUNDY_VOLUME_OFFSET)
164                 volume[1] -= BURGUNDY_VOLUME_OFFSET;
165         else
166                 volume[1] = 0;
167 }
168
169
170 /*
171  */
172
173 #define BASE2ADDR(base) ((base) << 12)
174 #define ADDR2BASE(addr) ((addr) >> 12)
175
176 static int snd_pmac_burgundy_info_volume(struct snd_kcontrol *kcontrol,
177                                          struct snd_ctl_elem_info *uinfo)
178 {
179         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
180         uinfo->count = 2;
181         uinfo->value.integer.min = 0;
182         uinfo->value.integer.max = 100;
183         return 0;
184 }
185
186 static int snd_pmac_burgundy_get_volume(struct snd_kcontrol *kcontrol,
187                                         struct snd_ctl_elem_value *ucontrol)
188 {
189         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
190         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
191         int shift = (kcontrol->private_value >> 8) & 0xff;
192         snd_pmac_burgundy_read_volume(chip, addr, ucontrol->value.integer.value,
193                                       shift);
194         return 0;
195 }
196
197 static int snd_pmac_burgundy_put_volume(struct snd_kcontrol *kcontrol,
198                                         struct snd_ctl_elem_value *ucontrol)
199 {
200         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
201         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
202         int shift = (kcontrol->private_value >> 8) & 0xff;
203         long nvoices[2];
204
205         snd_pmac_burgundy_write_volume(chip, addr, ucontrol->value.integer.value,
206                                        shift);
207         snd_pmac_burgundy_read_volume(chip, addr, nvoices, shift);
208         return (nvoices[0] != ucontrol->value.integer.value[0] ||
209                 nvoices[1] != ucontrol->value.integer.value[1]);
210 }
211
212 #define BURGUNDY_VOLUME(xname, xindex, addr, shift) \
213 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
214   .info = snd_pmac_burgundy_info_volume,\
215   .get = snd_pmac_burgundy_get_volume,\
216   .put = snd_pmac_burgundy_put_volume,\
217   .private_value = ((ADDR2BASE(addr) & 0xff) | ((shift) << 8)) }
218
219 /* lineout/speaker */
220
221 static int snd_pmac_burgundy_info_switch_out(struct snd_kcontrol *kcontrol,
222                                              struct snd_ctl_elem_info *uinfo)
223 {
224         int stereo = (kcontrol->private_value >> 24) & 1;
225         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
226         uinfo->count = stereo + 1;
227         uinfo->value.integer.min = 0;
228         uinfo->value.integer.max = 1;
229         return 0;
230 }
231
232 static int snd_pmac_burgundy_get_switch_out(struct snd_kcontrol *kcontrol,
233                                             struct snd_ctl_elem_value *ucontrol)
234 {
235         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
236         int lmask = kcontrol->private_value & 0xff;
237         int rmask = (kcontrol->private_value >> 8) & 0xff;
238         int stereo = (kcontrol->private_value >> 24) & 1;
239         int val = snd_pmac_burgundy_rcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES);
240         ucontrol->value.integer.value[0] = (val & lmask) ? 1 : 0;
241         if (stereo)
242                 ucontrol->value.integer.value[1] = (val & rmask) ? 1 : 0;
243         return 0;
244 }
245
246 static int snd_pmac_burgundy_put_switch_out(struct snd_kcontrol *kcontrol,
247                                             struct snd_ctl_elem_value *ucontrol)
248 {
249         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
250         int lmask = kcontrol->private_value & 0xff;
251         int rmask = (kcontrol->private_value >> 8) & 0xff;
252         int stereo = (kcontrol->private_value >> 24) & 1;
253         int val, oval;
254         oval = snd_pmac_burgundy_rcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES);
255         val = oval & ~(lmask | rmask);
256         if (ucontrol->value.integer.value[0])
257                 val |= lmask;
258         if (stereo && ucontrol->value.integer.value[1])
259                 val |= rmask;
260         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES, val);
261         return val != oval;
262 }
263
264 #define BURGUNDY_OUTPUT_SWITCH(xname, xindex, lmask, rmask, stereo) \
265 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
266   .info = snd_pmac_burgundy_info_switch_out,\
267   .get = snd_pmac_burgundy_get_switch_out,\
268   .put = snd_pmac_burgundy_put_switch_out,\
269   .private_value = ((lmask) | ((rmask) << 8) | ((stereo) << 24)) }
270
271 /* line/speaker output volume */
272 static int snd_pmac_burgundy_info_volume_out(struct snd_kcontrol *kcontrol,
273                                              struct snd_ctl_elem_info *uinfo)
274 {
275         int stereo = (kcontrol->private_value >> 24) & 1;
276         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
277         uinfo->count = stereo + 1;
278         uinfo->value.integer.min = 0;
279         uinfo->value.integer.max = 15;
280         return 0;
281 }
282
283 static int snd_pmac_burgundy_get_volume_out(struct snd_kcontrol *kcontrol,
284                                             struct snd_ctl_elem_value *ucontrol)
285 {
286         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
287         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
288         int stereo = (kcontrol->private_value >> 24) & 1;
289         int oval;
290
291         oval = ~snd_pmac_burgundy_rcb(chip, addr) & 0xff;
292         ucontrol->value.integer.value[0] = oval & 0xf;
293         if (stereo)
294                 ucontrol->value.integer.value[1] = (oval >> 4) & 0xf;
295         return 0;
296 }
297
298 static int snd_pmac_burgundy_put_volume_out(struct snd_kcontrol *kcontrol,
299                                             struct snd_ctl_elem_value *ucontrol)
300 {
301         struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
302         unsigned int addr = BASE2ADDR(kcontrol->private_value & 0xff);
303         int stereo = (kcontrol->private_value >> 24) & 1;
304         int oval, val;
305
306         oval = ~snd_pmac_burgundy_rcb(chip, addr) & 0xff;
307         val = ucontrol->value.integer.value[0];
308         if (stereo)
309                 val |= ucontrol->value.integer.value[1] << 4;
310         else
311                 val |= ucontrol->value.integer.value[0] << 4;
312         val = ~val & 0xff;
313         snd_pmac_burgundy_wcb(chip, addr, val);
314         return val != oval;
315 }
316
317 #define BURGUNDY_OUTPUT_VOLUME(xname, xindex, addr, stereo) \
318 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
319   .info = snd_pmac_burgundy_info_volume_out,\
320   .get = snd_pmac_burgundy_get_volume_out,\
321   .put = snd_pmac_burgundy_put_volume_out,\
322   .private_value = (ADDR2BASE(addr) | ((stereo) << 24)) }
323
324 static struct snd_kcontrol_new snd_pmac_burgundy_mixers[] __initdata = {
325         BURGUNDY_VOLUME("Master Playback Volume", 0, MASK_ADDR_BURGUNDY_MASTER_VOLUME, 8),
326         BURGUNDY_VOLUME("Line Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLLINE, 16),
327         BURGUNDY_VOLUME("CD Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLCD, 16),
328         BURGUNDY_VOLUME("Mic Playback Volume", 0, MASK_ADDR_BURGUNDY_VOLMIC, 16),
329         BURGUNDY_OUTPUT_VOLUME("PC Speaker Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENHP, 0),
330         /*BURGUNDY_OUTPUT_VOLUME("PCM Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENLINEOUT, 1),*/
331         BURGUNDY_OUTPUT_VOLUME("Headphone Playback Volume", 0, MASK_ADDR_BURGUNDY_ATTENSPEAKER, 1),
332 };      
333 static struct snd_kcontrol_new snd_pmac_burgundy_master_sw __initdata = 
334 BURGUNDY_OUTPUT_SWITCH("Headphone Playback Switch", 0, BURGUNDY_OUTPUT_LEFT, BURGUNDY_OUTPUT_RIGHT, 1);
335 static struct snd_kcontrol_new snd_pmac_burgundy_speaker_sw __initdata = 
336 BURGUNDY_OUTPUT_SWITCH("PC Speaker Playback Switch", 0, BURGUNDY_OUTPUT_INTERN, 0, 0);
337
338
339 #ifdef PMAC_SUPPORT_AUTOMUTE
340 /*
341  * auto-mute stuffs
342  */
343 static int snd_pmac_burgundy_detect_headphone(struct snd_pmac *chip)
344 {
345         return (in_le32(&chip->awacs->codec_stat) & chip->hp_stat_mask) ? 1 : 0;
346 }
347
348 static void snd_pmac_burgundy_update_automute(struct snd_pmac *chip, int do_notify)
349 {
350         if (chip->auto_mute) {
351                 int reg, oreg;
352                 reg = oreg = snd_pmac_burgundy_rcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES);
353                 reg &= ~(BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT | BURGUNDY_OUTPUT_INTERN);
354                 if (snd_pmac_burgundy_detect_headphone(chip))
355                         reg |= BURGUNDY_OUTPUT_LEFT | BURGUNDY_OUTPUT_RIGHT;
356                 else
357                         reg |= BURGUNDY_OUTPUT_INTERN;
358                 if (do_notify && reg == oreg)
359                         return;
360                 snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES, reg);
361                 if (do_notify) {
362                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
363                                        &chip->master_sw_ctl->id);
364                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
365                                        &chip->speaker_sw_ctl->id);
366                         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
367                                        &chip->hp_detect_ctl->id);
368                 }
369         }
370 }
371 #endif /* PMAC_SUPPORT_AUTOMUTE */
372
373
374 /*
375  * initialize burgundy
376  */
377 int __init snd_pmac_burgundy_init(struct snd_pmac *chip)
378 {
379         int i, err;
380
381         /* Checks to see the chip is alive and kicking */
382         if ((in_le32(&chip->awacs->codec_ctrl) & MASK_ERRCODE) == 0xf0000) {
383                 printk(KERN_WARNING "pmac burgundy: disabled by MacOS :-(\n");
384                 return 1;
385         }
386
387         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_OUTPUTENABLES,
388                            DEF_BURGUNDY_OUTPUTENABLES);
389         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_MORE_OUTPUTENABLES,
390                            DEF_BURGUNDY_MORE_OUTPUTENABLES);
391         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_OUTPUTSELECTS,
392                            DEF_BURGUNDY_OUTPUTSELECTS);
393
394         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL21,
395                            DEF_BURGUNDY_INPSEL21);
396         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_INPSEL3,
397                            DEF_BURGUNDY_INPSEL3);
398         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINCD,
399                            DEF_BURGUNDY_GAINCD);
400         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINLINE,
401                            DEF_BURGUNDY_GAINLINE);
402         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMIC,
403                            DEF_BURGUNDY_GAINMIC);
404         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_GAINMODEM,
405                            DEF_BURGUNDY_GAINMODEM);
406
407         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENSPEAKER,
408                            DEF_BURGUNDY_ATTENSPEAKER);
409         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENLINEOUT,
410                            DEF_BURGUNDY_ATTENLINEOUT);
411         snd_pmac_burgundy_wcb(chip, MASK_ADDR_BURGUNDY_ATTENHP,
412                            DEF_BURGUNDY_ATTENHP);
413
414         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_MASTER_VOLUME,
415                            DEF_BURGUNDY_MASTER_VOLUME);
416         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLCD,
417                            DEF_BURGUNDY_VOLCD);
418         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLLINE,
419                            DEF_BURGUNDY_VOLLINE);
420         snd_pmac_burgundy_wcw(chip, MASK_ADDR_BURGUNDY_VOLMIC,
421                            DEF_BURGUNDY_VOLMIC);
422
423         if (chip->hp_stat_mask == 0)
424                 /* set headphone-jack detection bit */
425                 chip->hp_stat_mask = 0x04;
426
427         /*
428          * build burgundy mixers
429          */
430         strcpy(chip->card->mixername, "PowerMac Burgundy");
431
432         for (i = 0; i < ARRAY_SIZE(snd_pmac_burgundy_mixers); i++) {
433                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_pmac_burgundy_mixers[i], chip))) < 0)
434                         return err;
435         }
436         chip->master_sw_ctl = snd_ctl_new1(&snd_pmac_burgundy_master_sw, chip);
437         if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
438                 return err;
439         chip->speaker_sw_ctl = snd_ctl_new1(&snd_pmac_burgundy_speaker_sw, chip);
440         if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
441                 return err;
442 #ifdef PMAC_SUPPORT_AUTOMUTE
443         if ((err = snd_pmac_add_automute(chip)) < 0)
444                 return err;
445
446         chip->detect_headphone = snd_pmac_burgundy_detect_headphone;
447         chip->update_automute = snd_pmac_burgundy_update_automute;
448         snd_pmac_burgundy_update_automute(chip, 0); /* update the status only */
449 #endif
450
451         return 0;
452 }