aboutsummaryrefslogtreecommitdiffstats
path: root/sound/ppc/tumbler.c
diff options
context:
space:
mode:
Diffstat (limited to 'sound/ppc/tumbler.c')
-rw-r--r--sound/ppc/tumbler.c1175
1 files changed, 1175 insertions, 0 deletions
diff --git a/sound/ppc/tumbler.c b/sound/ppc/tumbler.c
new file mode 100644
index 000000000000..7d10385f0a76
--- /dev/null
+++ b/sound/ppc/tumbler.c
@@ -0,0 +1,1175 @@
1/*
2 * PMac Tumbler/Snapper lowlevel functions
3 *
4 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * Rene Rebe <rene.rebe@gmx.net>:
21 * * update from shadow registers on wakeup and headphone plug
22 * * automatically toggle DRC on headphone plug
23 *
24 */
25
26
27#include <sound/driver.h>
28#include <linux/init.h>
29#include <linux/delay.h>
30#include <linux/i2c.h>
31#include <linux/i2c-dev.h>
32#include <linux/kmod.h>
33#include <linux/slab.h>
34#include <linux/interrupt.h>
35#include <sound/core.h>
36#include <asm/io.h>
37#include <asm/irq.h>
38#ifdef CONFIG_PPC_HAS_FEATURE_CALLS
39#include <asm/pmac_feature.h>
40#endif
41#include "pmac.h"
42#include "tumbler_volume.h"
43
44/* i2c address for tumbler */
45#define TAS_I2C_ADDR 0x34
46
47/* registers */
48#define TAS_REG_MCS 0x01 /* main control */
49#define TAS_REG_DRC 0x02
50#define TAS_REG_VOL 0x04
51#define TAS_REG_TREBLE 0x05
52#define TAS_REG_BASS 0x06
53#define TAS_REG_INPUT1 0x07
54#define TAS_REG_INPUT2 0x08
55
56/* tas3001c */
57#define TAS_REG_PCM TAS_REG_INPUT1
58
59/* tas3004 */
60#define TAS_REG_LMIX TAS_REG_INPUT1
61#define TAS_REG_RMIX TAS_REG_INPUT2
62#define TAS_REG_MCS2 0x43 /* main control 2 */
63#define TAS_REG_ACS 0x40 /* analog control */
64
65/* mono volumes for tas3001c/tas3004 */
66enum {
67 VOL_IDX_PCM_MONO, /* tas3001c only */
68 VOL_IDX_BASS, VOL_IDX_TREBLE,
69 VOL_IDX_LAST_MONO
70};
71
72/* stereo volumes for tas3004 */
73enum {
74 VOL_IDX_PCM, VOL_IDX_PCM2, VOL_IDX_ADC,
75 VOL_IDX_LAST_MIX
76};
77
78typedef struct pmac_gpio {
79#ifdef CONFIG_PPC_HAS_FEATURE_CALLS
80 unsigned int addr;
81#else
82 void __iomem *addr;
83#endif
84 int active_state;
85} pmac_gpio_t;
86
87typedef struct pmac_tumbler_t {
88 pmac_keywest_t i2c;
89 pmac_gpio_t audio_reset;
90 pmac_gpio_t amp_mute;
91 pmac_gpio_t hp_mute;
92 pmac_gpio_t hp_detect;
93 int headphone_irq;
94 unsigned int master_vol[2];
95 unsigned int master_switch[2];
96 unsigned int mono_vol[VOL_IDX_LAST_MONO];
97 unsigned int mix_vol[VOL_IDX_LAST_MIX][2]; /* stereo volumes for tas3004 */
98 int drc_range;
99 int drc_enable;
100 int capture_source;
101} pmac_tumbler_t;
102
103
104/*
105 */
106
107static int send_init_client(pmac_keywest_t *i2c, unsigned int *regs)
108{
109 while (*regs > 0) {
110 int err, count = 10;
111 do {
112 err = i2c_smbus_write_byte_data(i2c->client,
113 regs[0], regs[1]);
114 if (err >= 0)
115 break;
116 mdelay(10);
117 } while (count--);
118 if (err < 0)
119 return -ENXIO;
120 regs += 2;
121 }
122 return 0;
123}
124
125
126static int tumbler_init_client(pmac_keywest_t *i2c)
127{
128 static unsigned int regs[] = {
129 /* normal operation, SCLK=64fps, i2s output, i2s input, 16bit width */
130 TAS_REG_MCS, (1<<6)|(2<<4)|(2<<2)|0,
131 0, /* terminator */
132 };
133 return send_init_client(i2c, regs);
134}
135
136static int snapper_init_client(pmac_keywest_t *i2c)
137{
138 static unsigned int regs[] = {
139 /* normal operation, SCLK=64fps, i2s output, 16bit width */
140 TAS_REG_MCS, (1<<6)|(2<<4)|0,
141 /* normal operation, all-pass mode */
142 TAS_REG_MCS2, (1<<1),
143 /* normal output, no deemphasis, A input, power-up, line-in */
144 TAS_REG_ACS, 0,
145 0, /* terminator */
146 };
147 return send_init_client(i2c, regs);
148}
149
150/*
151 * gpio access
152 */
153#ifdef CONFIG_PPC_HAS_FEATURE_CALLS
154#define do_gpio_write(gp, val) \
155 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
156#define do_gpio_read(gp) \
157 pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
158#define tumbler_gpio_free(gp) /* NOP */
159#else
160#define do_gpio_write(gp, val) writeb(val, (gp)->addr)
161#define do_gpio_read(gp) readb((gp)->addr)
162static inline void tumbler_gpio_free(pmac_gpio_t *gp)
163{
164 if (gp->addr) {
165 iounmap(gp->addr);
166 gp->addr = NULL;
167 }
168}
169#endif /* CONFIG_PPC_HAS_FEATURE_CALLS */
170
171static void write_audio_gpio(pmac_gpio_t *gp, int active)
172{
173 if (! gp->addr)
174 return;
175 active = active ? gp->active_state : !gp->active_state;
176 do_gpio_write(gp, active ? 0x05 : 0x04);
177}
178
179static int read_audio_gpio(pmac_gpio_t *gp)
180{
181 int ret;
182 if (! gp->addr)
183 return 0;
184 ret = ((do_gpio_read(gp) & 0x02) !=0);
185 return ret == gp->active_state;
186}
187
188/*
189 * update master volume
190 */
191static int tumbler_set_master_volume(pmac_tumbler_t *mix)
192{
193 unsigned char block[6];
194 unsigned int left_vol, right_vol;
195
196 if (! mix->i2c.client)
197 return -ENODEV;
198
199 if (! mix->master_switch[0])
200 left_vol = 0;
201 else {
202 left_vol = mix->master_vol[0];
203 if (left_vol >= ARRAY_SIZE(master_volume_table))
204 left_vol = ARRAY_SIZE(master_volume_table) - 1;
205 left_vol = master_volume_table[left_vol];
206 }
207 if (! mix->master_switch[1])
208 right_vol = 0;
209 else {
210 right_vol = mix->master_vol[1];
211 if (right_vol >= ARRAY_SIZE(master_volume_table))
212 right_vol = ARRAY_SIZE(master_volume_table) - 1;
213 right_vol = master_volume_table[right_vol];
214 }
215
216 block[0] = (left_vol >> 16) & 0xff;
217 block[1] = (left_vol >> 8) & 0xff;
218 block[2] = (left_vol >> 0) & 0xff;
219
220 block[3] = (right_vol >> 16) & 0xff;
221 block[4] = (right_vol >> 8) & 0xff;
222 block[5] = (right_vol >> 0) & 0xff;
223
224 if (i2c_smbus_write_block_data(mix->i2c.client, TAS_REG_VOL,
225 6, block) < 0) {
226 snd_printk("failed to set volume \n");
227 return -EINVAL;
228 }
229 return 0;
230}
231
232
233/* output volume */
234static int tumbler_info_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
235{
236 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
237 uinfo->count = 2;
238 uinfo->value.integer.min = 0;
239 uinfo->value.integer.max = ARRAY_SIZE(master_volume_table) - 1;
240 return 0;
241}
242
243static int tumbler_get_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
244{
245 pmac_t *chip = snd_kcontrol_chip(kcontrol);
246 pmac_tumbler_t *mix = chip->mixer_data;
247 snd_assert(mix, return -ENODEV);
248 ucontrol->value.integer.value[0] = mix->master_vol[0];
249 ucontrol->value.integer.value[1] = mix->master_vol[1];
250 return 0;
251}
252
253static int tumbler_put_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
254{
255 pmac_t *chip = snd_kcontrol_chip(kcontrol);
256 pmac_tumbler_t *mix = chip->mixer_data;
257 int change;
258
259 snd_assert(mix, return -ENODEV);
260 change = mix->master_vol[0] != ucontrol->value.integer.value[0] ||
261 mix->master_vol[1] != ucontrol->value.integer.value[1];
262 if (change) {
263 mix->master_vol[0] = ucontrol->value.integer.value[0];
264 mix->master_vol[1] = ucontrol->value.integer.value[1];
265 tumbler_set_master_volume(mix);
266 }
267 return change;
268}
269
270/* output switch */
271static int tumbler_get_master_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
272{
273 pmac_t *chip = snd_kcontrol_chip(kcontrol);
274 pmac_tumbler_t *mix = chip->mixer_data;
275 snd_assert(mix, return -ENODEV);
276 ucontrol->value.integer.value[0] = mix->master_switch[0];
277 ucontrol->value.integer.value[1] = mix->master_switch[1];
278 return 0;
279}
280
281static int tumbler_put_master_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
282{
283 pmac_t *chip = snd_kcontrol_chip(kcontrol);
284 pmac_tumbler_t *mix = chip->mixer_data;
285 int change;
286
287 snd_assert(mix, return -ENODEV);
288 change = mix->master_switch[0] != ucontrol->value.integer.value[0] ||
289 mix->master_switch[1] != ucontrol->value.integer.value[1];
290 if (change) {
291 mix->master_switch[0] = !!ucontrol->value.integer.value[0];
292 mix->master_switch[1] = !!ucontrol->value.integer.value[1];
293 tumbler_set_master_volume(mix);
294 }
295 return change;
296}
297
298
299/*
300 * TAS3001c dynamic range compression
301 */
302
303#define TAS3001_DRC_MAX 0x5f
304
305static int tumbler_set_drc(pmac_tumbler_t *mix)
306{
307 unsigned char val[2];
308
309 if (! mix->i2c.client)
310 return -ENODEV;
311
312 if (mix->drc_enable) {
313 val[0] = 0xc1; /* enable, 3:1 compression */
314 if (mix->drc_range > TAS3001_DRC_MAX)
315 val[1] = 0xf0;
316 else if (mix->drc_range < 0)
317 val[1] = 0x91;
318 else
319 val[1] = mix->drc_range + 0x91;
320 } else {
321 val[0] = 0;
322 val[1] = 0;
323 }
324
325 if (i2c_smbus_write_block_data(mix->i2c.client, TAS_REG_DRC,
326 2, val) < 0) {
327 snd_printk("failed to set DRC\n");
328 return -EINVAL;
329 }
330 return 0;
331}
332
333/*
334 * TAS3004
335 */
336
337#define TAS3004_DRC_MAX 0xef
338
339static int snapper_set_drc(pmac_tumbler_t *mix)
340{
341 unsigned char val[6];
342
343 if (! mix->i2c.client)
344 return -ENODEV;
345
346 if (mix->drc_enable)
347 val[0] = 0x50; /* 3:1 above threshold */
348 else
349 val[0] = 0x51; /* disabled */
350 val[1] = 0x02; /* 1:1 below threshold */
351 if (mix->drc_range > 0xef)
352 val[2] = 0xef;
353 else if (mix->drc_range < 0)
354 val[2] = 0x00;
355 else
356 val[2] = mix->drc_range;
357 val[3] = 0xb0;
358 val[4] = 0x60;
359 val[5] = 0xa0;
360
361 if (i2c_smbus_write_block_data(mix->i2c.client, TAS_REG_DRC,
362 6, val) < 0) {
363 snd_printk("failed to set DRC\n");
364 return -EINVAL;
365 }
366 return 0;
367}
368
369static int tumbler_info_drc_value(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
370{
371 pmac_t *chip = snd_kcontrol_chip(kcontrol);
372 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
373 uinfo->count = 1;
374 uinfo->value.integer.min = 0;
375 uinfo->value.integer.max =
376 chip->model == PMAC_TUMBLER ? TAS3001_DRC_MAX : TAS3004_DRC_MAX;
377 return 0;
378}
379
380static int tumbler_get_drc_value(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
381{
382 pmac_t *chip = snd_kcontrol_chip(kcontrol);
383 pmac_tumbler_t *mix;
384 if (! (mix = chip->mixer_data))
385 return -ENODEV;
386 ucontrol->value.integer.value[0] = mix->drc_range;
387 return 0;
388}
389
390static int tumbler_put_drc_value(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
391{
392 pmac_t *chip = snd_kcontrol_chip(kcontrol);
393 pmac_tumbler_t *mix;
394 int change;
395
396 if (! (mix = chip->mixer_data))
397 return -ENODEV;
398 change = mix->drc_range != ucontrol->value.integer.value[0];
399 if (change) {
400 mix->drc_range = ucontrol->value.integer.value[0];
401 if (chip->model == PMAC_TUMBLER)
402 tumbler_set_drc(mix);
403 else
404 snapper_set_drc(mix);
405 }
406 return change;
407}
408
409static int tumbler_get_drc_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
410{
411 pmac_t *chip = snd_kcontrol_chip(kcontrol);
412 pmac_tumbler_t *mix;
413 if (! (mix = chip->mixer_data))
414 return -ENODEV;
415 ucontrol->value.integer.value[0] = mix->drc_enable;
416 return 0;
417}
418
419static int tumbler_put_drc_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
420{
421 pmac_t *chip = snd_kcontrol_chip(kcontrol);
422 pmac_tumbler_t *mix;
423 int change;
424
425 if (! (mix = chip->mixer_data))
426 return -ENODEV;
427 change = mix->drc_enable != ucontrol->value.integer.value[0];
428 if (change) {
429 mix->drc_enable = !!ucontrol->value.integer.value[0];
430 if (chip->model == PMAC_TUMBLER)
431 tumbler_set_drc(mix);
432 else
433 snapper_set_drc(mix);
434 }
435 return change;
436}
437
438
439/*
440 * mono volumes
441 */
442
443struct tumbler_mono_vol {
444 int index;
445 int reg;
446 int bytes;
447 unsigned int max;
448 unsigned int *table;
449};
450
451static int tumbler_set_mono_volume(pmac_tumbler_t *mix, struct tumbler_mono_vol *info)
452{
453 unsigned char block[4];
454 unsigned int vol;
455 int i;
456
457 if (! mix->i2c.client)
458 return -ENODEV;
459
460 vol = mix->mono_vol[info->index];
461 if (vol >= info->max)
462 vol = info->max - 1;
463 vol = info->table[vol];
464 for (i = 0; i < info->bytes; i++)
465 block[i] = (vol >> ((info->bytes - i - 1) * 8)) & 0xff;
466 if (i2c_smbus_write_block_data(mix->i2c.client, info->reg,
467 info->bytes, block) < 0) {
468 snd_printk("failed to set mono volume %d\n", info->index);
469 return -EINVAL;
470 }
471 return 0;
472}
473
474static int tumbler_info_mono(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
475{
476 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
477
478 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
479 uinfo->count = 1;
480 uinfo->value.integer.min = 0;
481 uinfo->value.integer.max = info->max - 1;
482 return 0;
483}
484
485static int tumbler_get_mono(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
486{
487 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
488 pmac_t *chip = snd_kcontrol_chip(kcontrol);
489 pmac_tumbler_t *mix;
490 if (! (mix = chip->mixer_data))
491 return -ENODEV;
492 ucontrol->value.integer.value[0] = mix->mono_vol[info->index];
493 return 0;
494}
495
496static int tumbler_put_mono(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
497{
498 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
499 pmac_t *chip = snd_kcontrol_chip(kcontrol);
500 pmac_tumbler_t *mix;
501 int change;
502
503 if (! (mix = chip->mixer_data))
504 return -ENODEV;
505 change = mix->mono_vol[info->index] != ucontrol->value.integer.value[0];
506 if (change) {
507 mix->mono_vol[info->index] = ucontrol->value.integer.value[0];
508 tumbler_set_mono_volume(mix, info);
509 }
510 return change;
511}
512
513/* TAS3001c mono volumes */
514static struct tumbler_mono_vol tumbler_pcm_vol_info = {
515 .index = VOL_IDX_PCM_MONO,
516 .reg = TAS_REG_PCM,
517 .bytes = 3,
518 .max = ARRAY_SIZE(mixer_volume_table),
519 .table = mixer_volume_table,
520};
521
522static struct tumbler_mono_vol tumbler_bass_vol_info = {
523 .index = VOL_IDX_BASS,
524 .reg = TAS_REG_BASS,
525 .bytes = 1,
526 .max = ARRAY_SIZE(bass_volume_table),
527 .table = bass_volume_table,
528};
529
530static struct tumbler_mono_vol tumbler_treble_vol_info = {
531 .index = VOL_IDX_TREBLE,
532 .reg = TAS_REG_TREBLE,
533 .bytes = 1,
534 .max = ARRAY_SIZE(treble_volume_table),
535 .table = treble_volume_table,
536};
537
538/* TAS3004 mono volumes */
539static struct tumbler_mono_vol snapper_bass_vol_info = {
540 .index = VOL_IDX_BASS,
541 .reg = TAS_REG_BASS,
542 .bytes = 1,
543 .max = ARRAY_SIZE(snapper_bass_volume_table),
544 .table = snapper_bass_volume_table,
545};
546
547static struct tumbler_mono_vol snapper_treble_vol_info = {
548 .index = VOL_IDX_TREBLE,
549 .reg = TAS_REG_TREBLE,
550 .bytes = 1,
551 .max = ARRAY_SIZE(snapper_treble_volume_table),
552 .table = snapper_treble_volume_table,
553};
554
555
556#define DEFINE_MONO(xname,type) { \
557 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
558 .name = xname, \
559 .info = tumbler_info_mono, \
560 .get = tumbler_get_mono, \
561 .put = tumbler_put_mono, \
562 .private_value = (unsigned long)(&tumbler_##type##_vol_info), \
563}
564
565#define DEFINE_SNAPPER_MONO(xname,type) { \
566 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
567 .name = xname, \
568 .info = tumbler_info_mono, \
569 .get = tumbler_get_mono, \
570 .put = tumbler_put_mono, \
571 .private_value = (unsigned long)(&snapper_##type##_vol_info), \
572}
573
574
575/*
576 * snapper mixer volumes
577 */
578
579static int snapper_set_mix_vol1(pmac_tumbler_t *mix, int idx, int ch, int reg)
580{
581 int i, j, vol;
582 unsigned char block[9];
583
584 vol = mix->mix_vol[idx][ch];
585 if (vol >= ARRAY_SIZE(mixer_volume_table)) {
586 vol = ARRAY_SIZE(mixer_volume_table) - 1;
587 mix->mix_vol[idx][ch] = vol;
588 }
589
590 for (i = 0; i < 3; i++) {
591 vol = mix->mix_vol[i][ch];
592 vol = mixer_volume_table[vol];
593 for (j = 0; j < 3; j++)
594 block[i * 3 + j] = (vol >> ((2 - j) * 8)) & 0xff;
595 }
596 if (i2c_smbus_write_block_data(mix->i2c.client, reg, 9, block) < 0) {
597 snd_printk("failed to set mono volume %d\n", reg);
598 return -EINVAL;
599 }
600 return 0;
601}
602
603static int snapper_set_mix_vol(pmac_tumbler_t *mix, int idx)
604{
605 if (! mix->i2c.client)
606 return -ENODEV;
607 if (snapper_set_mix_vol1(mix, idx, 0, TAS_REG_LMIX) < 0 ||
608 snapper_set_mix_vol1(mix, idx, 1, TAS_REG_RMIX) < 0)
609 return -EINVAL;
610 return 0;
611}
612
613static int snapper_info_mix(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
614{
615 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
616 uinfo->count = 2;
617 uinfo->value.integer.min = 0;
618 uinfo->value.integer.max = ARRAY_SIZE(mixer_volume_table) - 1;
619 return 0;
620}
621
622static int snapper_get_mix(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
623{
624 int idx = (int)kcontrol->private_value;
625 pmac_t *chip = snd_kcontrol_chip(kcontrol);
626 pmac_tumbler_t *mix;
627 if (! (mix = chip->mixer_data))
628 return -ENODEV;
629 ucontrol->value.integer.value[0] = mix->mix_vol[idx][0];
630 ucontrol->value.integer.value[1] = mix->mix_vol[idx][1];
631 return 0;
632}
633
634static int snapper_put_mix(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
635{
636 int idx = (int)kcontrol->private_value;
637 pmac_t *chip = snd_kcontrol_chip(kcontrol);
638 pmac_tumbler_t *mix;
639 int change;
640
641 if (! (mix = chip->mixer_data))
642 return -ENODEV;
643 change = mix->mix_vol[idx][0] != ucontrol->value.integer.value[0] ||
644 mix->mix_vol[idx][1] != ucontrol->value.integer.value[1];
645 if (change) {
646 mix->mix_vol[idx][0] = ucontrol->value.integer.value[0];
647 mix->mix_vol[idx][1] = ucontrol->value.integer.value[1];
648 snapper_set_mix_vol(mix, idx);
649 }
650 return change;
651}
652
653
654/*
655 * mute switches
656 */
657
658enum { TUMBLER_MUTE_HP, TUMBLER_MUTE_AMP };
659
660static int tumbler_get_mute_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
661{
662 pmac_t *chip = snd_kcontrol_chip(kcontrol);
663 pmac_tumbler_t *mix;
664 pmac_gpio_t *gp;
665 if (! (mix = chip->mixer_data))
666 return -ENODEV;
667 gp = (kcontrol->private_value == TUMBLER_MUTE_HP) ? &mix->hp_mute : &mix->amp_mute;
668 ucontrol->value.integer.value[0] = ! read_audio_gpio(gp);
669 return 0;
670}
671
672static int tumbler_put_mute_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
673{
674 pmac_t *chip = snd_kcontrol_chip(kcontrol);
675 pmac_tumbler_t *mix;
676 pmac_gpio_t *gp;
677 int val;
678#ifdef PMAC_SUPPORT_AUTOMUTE
679 if (chip->update_automute && chip->auto_mute)
680 return 0; /* don't touch in the auto-mute mode */
681#endif
682 if (! (mix = chip->mixer_data))
683 return -ENODEV;
684 gp = (kcontrol->private_value == TUMBLER_MUTE_HP) ? &mix->hp_mute : &mix->amp_mute;
685 val = ! read_audio_gpio(gp);
686 if (val != ucontrol->value.integer.value[0]) {
687 write_audio_gpio(gp, ! ucontrol->value.integer.value[0]);
688 return 1;
689 }
690 return 0;
691}
692
693static int snapper_set_capture_source(pmac_tumbler_t *mix)
694{
695 if (! mix->i2c.client)
696 return -ENODEV;
697 return i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS,
698 mix->capture_source ? 2 : 0);
699}
700
701static int snapper_info_capture_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
702{
703 static char *texts[2] = {
704 "Line", "Mic"
705 };
706 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
707 uinfo->count = 1;
708 uinfo->value.enumerated.items = 2;
709 if (uinfo->value.enumerated.item > 1)
710 uinfo->value.enumerated.item = 1;
711 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
712 return 0;
713}
714
715static int snapper_get_capture_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
716{
717 pmac_t *chip = snd_kcontrol_chip(kcontrol);
718 pmac_tumbler_t *mix = chip->mixer_data;
719
720 snd_assert(mix, return -ENODEV);
721 ucontrol->value.integer.value[0] = mix->capture_source;
722 return 0;
723}
724
725static int snapper_put_capture_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
726{
727 pmac_t *chip = snd_kcontrol_chip(kcontrol);
728 pmac_tumbler_t *mix = chip->mixer_data;
729 int change;
730
731 snd_assert(mix, return -ENODEV);
732 change = ucontrol->value.integer.value[0] != mix->capture_source;
733 if (change) {
734 mix->capture_source = !!ucontrol->value.integer.value[0];
735 snapper_set_capture_source(mix);
736 }
737 return change;
738}
739
740#define DEFINE_SNAPPER_MIX(xname,idx,ofs) { \
741 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
742 .name = xname, \
743 .info = snapper_info_mix, \
744 .get = snapper_get_mix, \
745 .put = snapper_put_mix, \
746 .index = idx,\
747 .private_value = ofs, \
748}
749
750
751/*
752 */
753static snd_kcontrol_new_t tumbler_mixers[] __initdata = {
754 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
755 .name = "Master Playback Volume",
756 .info = tumbler_info_master_volume,
757 .get = tumbler_get_master_volume,
758 .put = tumbler_put_master_volume
759 },
760 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
761 .name = "Master Playback Switch",
762 .info = snd_pmac_boolean_stereo_info,
763 .get = tumbler_get_master_switch,
764 .put = tumbler_put_master_switch
765 },
766 DEFINE_MONO("Tone Control - Bass", bass),
767 DEFINE_MONO("Tone Control - Treble", treble),
768 DEFINE_MONO("PCM Playback Volume", pcm),
769 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
770 .name = "DRC Range",
771 .info = tumbler_info_drc_value,
772 .get = tumbler_get_drc_value,
773 .put = tumbler_put_drc_value
774 },
775};
776
777static snd_kcontrol_new_t snapper_mixers[] __initdata = {
778 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
779 .name = "Master Playback Volume",
780 .info = tumbler_info_master_volume,
781 .get = tumbler_get_master_volume,
782 .put = tumbler_put_master_volume
783 },
784 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
785 .name = "Master Playback Switch",
786 .info = snd_pmac_boolean_stereo_info,
787 .get = tumbler_get_master_switch,
788 .put = tumbler_put_master_switch
789 },
790 DEFINE_SNAPPER_MIX("PCM Playback Volume", 0, VOL_IDX_PCM),
791 DEFINE_SNAPPER_MIX("PCM Playback Volume", 1, VOL_IDX_PCM2),
792 DEFINE_SNAPPER_MIX("Monitor Mix Volume", 0, VOL_IDX_ADC),
793 DEFINE_SNAPPER_MONO("Tone Control - Bass", bass),
794 DEFINE_SNAPPER_MONO("Tone Control - Treble", treble),
795 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
796 .name = "DRC Range",
797 .info = tumbler_info_drc_value,
798 .get = tumbler_get_drc_value,
799 .put = tumbler_put_drc_value
800 },
801 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
802 .name = "Input Source", /* FIXME: "Capture Source" doesn't work properly */
803 .info = snapper_info_capture_source,
804 .get = snapper_get_capture_source,
805 .put = snapper_put_capture_source
806 },
807};
808
809static snd_kcontrol_new_t tumbler_hp_sw __initdata = {
810 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
811 .name = "Headphone Playback Switch",
812 .info = snd_pmac_boolean_mono_info,
813 .get = tumbler_get_mute_switch,
814 .put = tumbler_put_mute_switch,
815 .private_value = TUMBLER_MUTE_HP,
816};
817static snd_kcontrol_new_t tumbler_speaker_sw __initdata = {
818 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
819 .name = "PC Speaker Playback Switch",
820 .info = snd_pmac_boolean_mono_info,
821 .get = tumbler_get_mute_switch,
822 .put = tumbler_put_mute_switch,
823 .private_value = TUMBLER_MUTE_AMP,
824};
825static snd_kcontrol_new_t tumbler_drc_sw __initdata = {
826 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
827 .name = "DRC Switch",
828 .info = snd_pmac_boolean_mono_info,
829 .get = tumbler_get_drc_switch,
830 .put = tumbler_put_drc_switch
831};
832
833
834#ifdef PMAC_SUPPORT_AUTOMUTE
835/*
836 * auto-mute stuffs
837 */
838static int tumbler_detect_headphone(pmac_t *chip)
839{
840 pmac_tumbler_t *mix = chip->mixer_data;
841 return read_audio_gpio(&mix->hp_detect);
842}
843
844static void check_mute(pmac_t *chip, pmac_gpio_t *gp, int val, int do_notify, snd_kcontrol_t *sw)
845{
846 //pmac_tumbler_t *mix = chip->mixer_data;
847 if (val != read_audio_gpio(gp)) {
848 write_audio_gpio(gp, val);
849 if (do_notify)
850 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &sw->id);
851 }
852}
853
854static struct work_struct device_change;
855
856static void
857device_change_handler(void *self)
858{
859 pmac_t *chip = (pmac_t*) self;
860 pmac_tumbler_t *mix;
861
862 if (!chip)
863 return;
864
865 mix = chip->mixer_data;
866
867 /* first set the DRC so the speaker do not explode -ReneR */
868 if (chip->model == PMAC_TUMBLER)
869 tumbler_set_drc(mix);
870 else
871 snapper_set_drc(mix);
872
873 /* reset the master volume so the correct amplification is applied */
874 tumbler_set_master_volume(mix);
875}
876
877static void tumbler_update_automute(pmac_t *chip, int do_notify)
878{
879 if (chip->auto_mute) {
880 pmac_tumbler_t *mix = chip->mixer_data;
881 snd_assert(mix, return);
882 if (tumbler_detect_headphone(chip)) {
883 /* mute speaker */
884 check_mute(chip, &mix->amp_mute, 1, do_notify, chip->speaker_sw_ctl);
885 check_mute(chip, &mix->hp_mute, 0, do_notify, chip->master_sw_ctl);
886 mix->drc_enable = 0;
887
888 } else {
889 /* unmute speaker */
890 check_mute(chip, &mix->amp_mute, 0, do_notify, chip->speaker_sw_ctl);
891 check_mute(chip, &mix->hp_mute, 1, do_notify, chip->master_sw_ctl);
892 mix->drc_enable = 1;
893 }
894 if (do_notify) {
895 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
896 &chip->hp_detect_ctl->id);
897 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
898 &chip->drc_sw_ctl->id);
899 }
900
901 /* finally we need to schedule an update of the mixer values
902 (master and DRC are enough for now) -ReneR */
903 schedule_work(&device_change);
904
905 }
906}
907#endif /* PMAC_SUPPORT_AUTOMUTE */
908
909
910/* interrupt - headphone plug changed */
911static irqreturn_t headphone_intr(int irq, void *devid, struct pt_regs *regs)
912{
913 pmac_t *chip = devid;
914 if (chip->update_automute && chip->initialized) {
915 chip->update_automute(chip, 1);
916 return IRQ_HANDLED;
917 }
918 return IRQ_NONE;
919}
920
921/* look for audio-gpio device */
922static struct device_node *find_audio_device(const char *name)
923{
924 struct device_node *np;
925
926 if (! (np = find_devices("gpio")))
927 return NULL;
928
929 for (np = np->child; np; np = np->sibling) {
930 char *property = get_property(np, "audio-gpio", NULL);
931 if (property && strcmp(property, name) == 0)
932 return np;
933 }
934 return NULL;
935}
936
937/* look for audio-gpio device */
938static struct device_node *find_compatible_audio_device(const char *name)
939{
940 struct device_node *np;
941
942 if (! (np = find_devices("gpio")))
943 return NULL;
944
945 for (np = np->child; np; np = np->sibling) {
946 if (device_is_compatible(np, name))
947 return np;
948 }
949 return NULL;
950}
951
952/* find an audio device and get its address */
953static unsigned long tumbler_find_device(const char *device, pmac_gpio_t *gp, int is_compatible)
954{
955 struct device_node *node;
956 u32 *base;
957
958 if (is_compatible)
959 node = find_compatible_audio_device(device);
960 else
961 node = find_audio_device(device);
962 if (! node) {
963 snd_printdd("cannot find device %s\n", device);
964 return -ENODEV;
965 }
966
967 base = (u32 *)get_property(node, "AAPL,address", NULL);
968 if (! base) {
969 snd_printd("cannot find address for device %s\n", device);
970 return -ENODEV;
971 }
972
973#ifdef CONFIG_PPC_HAS_FEATURE_CALLS
974 gp->addr = (*base) & 0x0000ffff;
975#else
976 gp->addr = ioremap((unsigned long)(*base), 1);
977#endif
978 base = (u32 *)get_property(node, "audio-gpio-active-state", NULL);
979 if (base)
980 gp->active_state = *base;
981 else
982 gp->active_state = 1;
983
984
985 return (node->n_intrs > 0) ? node->intrs[0].line : 0;
986}
987
988/* reset audio */
989static void tumbler_reset_audio(pmac_t *chip)
990{
991 pmac_tumbler_t *mix = chip->mixer_data;
992
993 write_audio_gpio(&mix->audio_reset, 0);
994 big_mdelay(200);
995 write_audio_gpio(&mix->audio_reset, 1);
996 big_mdelay(100);
997 write_audio_gpio(&mix->audio_reset, 0);
998 big_mdelay(100);
999}
1000
1001#ifdef CONFIG_PMAC_PBOOK
1002/* resume mixer */
1003static void tumbler_resume(pmac_t *chip)
1004{
1005 pmac_tumbler_t *mix = chip->mixer_data;
1006
1007 snd_assert(mix, return);
1008
1009 tumbler_reset_audio(chip);
1010 if (mix->i2c.client && mix->i2c.init_client) {
1011 if (mix->i2c.init_client(&mix->i2c) < 0)
1012 printk(KERN_ERR "tumbler_init_client error\n");
1013 } else
1014 printk(KERN_ERR "tumbler: i2c is not initialized\n");
1015 if (chip->model == PMAC_TUMBLER) {
1016 tumbler_set_mono_volume(mix, &tumbler_pcm_vol_info);
1017 tumbler_set_mono_volume(mix, &tumbler_bass_vol_info);
1018 tumbler_set_mono_volume(mix, &tumbler_treble_vol_info);
1019 tumbler_set_drc(mix);
1020 } else {
1021 snapper_set_mix_vol(mix, VOL_IDX_PCM);
1022 snapper_set_mix_vol(mix, VOL_IDX_PCM2);
1023 snapper_set_mix_vol(mix, VOL_IDX_ADC);
1024 tumbler_set_mono_volume(mix, &snapper_bass_vol_info);
1025 tumbler_set_mono_volume(mix, &snapper_treble_vol_info);
1026 snapper_set_drc(mix);
1027 snapper_set_capture_source(mix);
1028 }
1029 tumbler_set_master_volume(mix);
1030 if (chip->update_automute)
1031 chip->update_automute(chip, 0);
1032}
1033#endif
1034
1035/* initialize tumbler */
1036static int __init tumbler_init(pmac_t *chip)
1037{
1038 int irq, err;
1039 pmac_tumbler_t *mix = chip->mixer_data;
1040 snd_assert(mix, return -EINVAL);
1041
1042 tumbler_find_device("audio-hw-reset", &mix->audio_reset, 0);
1043 tumbler_find_device("amp-mute", &mix->amp_mute, 0);
1044 tumbler_find_device("headphone-mute", &mix->hp_mute, 0);
1045 irq = tumbler_find_device("headphone-detect", &mix->hp_detect, 0);
1046 if (irq < 0)
1047 irq = tumbler_find_device("keywest-gpio15", &mix->hp_detect, 1);
1048
1049 tumbler_reset_audio(chip);
1050
1051 /* activate headphone status interrupts */
1052 if (irq >= 0) {
1053 unsigned char val;
1054 if ((err = request_irq(irq, headphone_intr, 0,
1055 "Tumbler Headphone Detection", chip)) < 0)
1056 return err;
1057 /* activate headphone status interrupts */
1058 val = do_gpio_read(&mix->hp_detect);
1059 do_gpio_write(&mix->hp_detect, val | 0x80);
1060 }
1061 mix->headphone_irq = irq;
1062
1063 return 0;
1064}
1065
1066static void tumbler_cleanup(pmac_t *chip)
1067{
1068 pmac_tumbler_t *mix = chip->mixer_data;
1069 if (! mix)
1070 return;
1071
1072 if (mix->headphone_irq >= 0)
1073 free_irq(mix->headphone_irq, chip);
1074 tumbler_gpio_free(&mix->audio_reset);
1075 tumbler_gpio_free(&mix->amp_mute);
1076 tumbler_gpio_free(&mix->hp_mute);
1077 tumbler_gpio_free(&mix->hp_detect);
1078 snd_pmac_keywest_cleanup(&mix->i2c);
1079 kfree(mix);
1080 chip->mixer_data = NULL;
1081}
1082
1083/* exported */
1084int __init snd_pmac_tumbler_init(pmac_t *chip)
1085{
1086 int i, err;
1087 pmac_tumbler_t *mix;
1088 u32 *paddr;
1089 struct device_node *tas_node;
1090 char *chipname;
1091
1092#ifdef CONFIG_KMOD
1093 if (current->fs->root)
1094 request_module("i2c-keywest");
1095#endif /* CONFIG_KMOD */
1096
1097 mix = kmalloc(sizeof(*mix), GFP_KERNEL);
1098 if (! mix)
1099 return -ENOMEM;
1100 memset(mix, 0, sizeof(*mix));
1101 mix->headphone_irq = -1;
1102
1103 chip->mixer_data = mix;
1104 chip->mixer_free = tumbler_cleanup;
1105
1106 if ((err = tumbler_init(chip)) < 0)
1107 return err;
1108
1109 /* set up TAS */
1110 tas_node = find_devices("deq");
1111 if (tas_node == NULL)
1112 return -ENODEV;
1113
1114 paddr = (u32 *)get_property(tas_node, "i2c-address", NULL);
1115 if (paddr)
1116 mix->i2c.addr = (*paddr) >> 1;
1117 else
1118 mix->i2c.addr = TAS_I2C_ADDR;
1119
1120 if (chip->model == PMAC_TUMBLER) {
1121 mix->i2c.init_client = tumbler_init_client;
1122 mix->i2c.name = "TAS3001c";
1123 chipname = "Tumbler";
1124 } else {
1125 mix->i2c.init_client = snapper_init_client;
1126 mix->i2c.name = "TAS3004";
1127 chipname = "Snapper";
1128 }
1129
1130 if ((err = snd_pmac_keywest_init(&mix->i2c)) < 0)
1131 return err;
1132
1133 /*
1134 * build mixers
1135 */
1136 sprintf(chip->card->mixername, "PowerMac %s", chipname);
1137
1138 if (chip->model == PMAC_TUMBLER) {
1139 for (i = 0; i < ARRAY_SIZE(tumbler_mixers); i++) {
1140 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&tumbler_mixers[i], chip))) < 0)
1141 return err;
1142 }
1143 } else {
1144 for (i = 0; i < ARRAY_SIZE(snapper_mixers); i++) {
1145 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snapper_mixers[i], chip))) < 0)
1146 return err;
1147 }
1148 }
1149 chip->master_sw_ctl = snd_ctl_new1(&tumbler_hp_sw, chip);
1150 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
1151 return err;
1152 chip->speaker_sw_ctl = snd_ctl_new1(&tumbler_speaker_sw, chip);
1153 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
1154 return err;
1155 chip->drc_sw_ctl = snd_ctl_new1(&tumbler_drc_sw, chip);
1156 if ((err = snd_ctl_add(chip->card, chip->drc_sw_ctl)) < 0)
1157 return err;
1158
1159
1160#ifdef CONFIG_PMAC_PBOOK
1161 chip->resume = tumbler_resume;
1162#endif
1163
1164 INIT_WORK(&device_change, device_change_handler, (void *)chip);
1165
1166#ifdef PMAC_SUPPORT_AUTOMUTE
1167 if (mix->headphone_irq >=0 && (err = snd_pmac_add_automute(chip)) < 0)
1168 return err;
1169 chip->detect_headphone = tumbler_detect_headphone;
1170 chip->update_automute = tumbler_update_automute;
1171 tumbler_update_automute(chip, 0); /* update the status only */
1172#endif
1173
1174 return 0;
1175}