2 * PMac Tumbler/Snapper lowlevel functions
4 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
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.
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.
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
20 * Rene Rebe <rene.rebe@gmx.net>:
21 * * update from shadow registers on wakeup and headphone plug
22 * * automatically toggle DRC on headphone plug
27 #include <linux/init.h>
28 #include <linux/delay.h>
29 #include <linux/i2c.h>
30 #include <linux/kmod.h>
31 #include <linux/slab.h>
32 #include <linux/interrupt.h>
33 #include <linux/string.h>
34 #include <sound/core.h>
37 #include <asm/machdep.h>
38 #include <asm/pmac_feature.h>
40 #include "tumbler_volume.h"
45 #define DBG(fmt...) printk(KERN_DEBUG fmt)
50 #define IS_G4DA (machine_is_compatible("PowerMac3,4"))
52 /* i2c address for tumbler */
53 #define TAS_I2C_ADDR 0x34
56 #define TAS_REG_MCS 0x01 /* main control */
57 #define TAS_REG_DRC 0x02
58 #define TAS_REG_VOL 0x04
59 #define TAS_REG_TREBLE 0x05
60 #define TAS_REG_BASS 0x06
61 #define TAS_REG_INPUT1 0x07
62 #define TAS_REG_INPUT2 0x08
65 #define TAS_REG_PCM TAS_REG_INPUT1
68 #define TAS_REG_LMIX TAS_REG_INPUT1
69 #define TAS_REG_RMIX TAS_REG_INPUT2
70 #define TAS_REG_MCS2 0x43 /* main control 2 */
71 #define TAS_REG_ACS 0x40 /* analog control */
73 /* mono volumes for tas3001c/tas3004 */
75 VOL_IDX_PCM_MONO, /* tas3001c only */
76 VOL_IDX_BASS, VOL_IDX_TREBLE,
80 /* stereo volumes for tas3004 */
82 VOL_IDX_PCM, VOL_IDX_PCM2, VOL_IDX_ADC,
94 struct pmac_keywest i2c;
95 struct pmac_gpio audio_reset;
96 struct pmac_gpio amp_mute;
97 struct pmac_gpio line_mute;
98 struct pmac_gpio line_detect;
99 struct pmac_gpio hp_mute;
100 struct pmac_gpio hp_detect;
103 unsigned int save_master_vol[2];
104 unsigned int master_vol[2];
105 unsigned int save_master_switch[2];
106 unsigned int master_switch[2];
107 unsigned int mono_vol[VOL_IDX_LAST_MONO];
108 unsigned int mix_vol[VOL_IDX_LAST_MIX][2]; /* stereo volumes for tas3004 */
113 int auto_mute_notify;
122 static int send_init_client(struct pmac_keywest *i2c, unsigned int *regs)
127 err = i2c_smbus_write_byte_data(i2c->client,
131 DBG("(W) i2c error %d\n", err);
142 static int tumbler_init_client(struct pmac_keywest *i2c)
144 static unsigned int regs[] = {
145 /* normal operation, SCLK=64fps, i2s output, i2s input, 16bit width */
146 TAS_REG_MCS, (1<<6)|(2<<4)|(2<<2)|0,
149 DBG("(I) tumbler init client\n");
150 return send_init_client(i2c, regs);
153 static int snapper_init_client(struct pmac_keywest *i2c)
155 static unsigned int regs[] = {
156 /* normal operation, SCLK=64fps, i2s output, 16bit width */
157 TAS_REG_MCS, (1<<6)|(2<<4)|0,
158 /* normal operation, all-pass mode */
159 TAS_REG_MCS2, (1<<1),
160 /* normal output, no deemphasis, A input, power-up, line-in */
164 DBG("(I) snapper init client\n");
165 return send_init_client(i2c, regs);
171 #define do_gpio_write(gp, val) \
172 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
173 #define do_gpio_read(gp) \
174 pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
175 #define tumbler_gpio_free(gp) /* NOP */
177 static void write_audio_gpio(struct pmac_gpio *gp, int active)
181 active = active ? gp->active_val : gp->inactive_val;
182 do_gpio_write(gp, active);
183 DBG("(I) gpio %x write %d\n", gp->addr, active);
186 static int check_audio_gpio(struct pmac_gpio *gp)
193 ret = do_gpio_read(gp);
195 return (ret & 0x1) == (gp->active_val & 0x1);
198 static int read_audio_gpio(struct pmac_gpio *gp)
203 ret = do_gpio_read(gp);
204 ret = (ret & 0x02) !=0;
205 return ret == gp->active_state;
209 * update master volume
211 static int tumbler_set_master_volume(struct pmac_tumbler *mix)
213 unsigned char block[6];
214 unsigned int left_vol, right_vol;
216 if (! mix->i2c.client)
219 if (! mix->master_switch[0])
222 left_vol = mix->master_vol[0];
223 if (left_vol >= ARRAY_SIZE(master_volume_table))
224 left_vol = ARRAY_SIZE(master_volume_table) - 1;
225 left_vol = master_volume_table[left_vol];
227 if (! mix->master_switch[1])
230 right_vol = mix->master_vol[1];
231 if (right_vol >= ARRAY_SIZE(master_volume_table))
232 right_vol = ARRAY_SIZE(master_volume_table) - 1;
233 right_vol = master_volume_table[right_vol];
236 block[0] = (left_vol >> 16) & 0xff;
237 block[1] = (left_vol >> 8) & 0xff;
238 block[2] = (left_vol >> 0) & 0xff;
240 block[3] = (right_vol >> 16) & 0xff;
241 block[4] = (right_vol >> 8) & 0xff;
242 block[5] = (right_vol >> 0) & 0xff;
244 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_VOL, 6,
246 snd_printk(KERN_ERR "failed to set volume \n");
254 static int tumbler_info_master_volume(struct snd_kcontrol *kcontrol,
255 struct snd_ctl_elem_info *uinfo)
257 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
259 uinfo->value.integer.min = 0;
260 uinfo->value.integer.max = ARRAY_SIZE(master_volume_table) - 1;
264 static int tumbler_get_master_volume(struct snd_kcontrol *kcontrol,
265 struct snd_ctl_elem_value *ucontrol)
267 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
268 struct pmac_tumbler *mix = chip->mixer_data;
270 ucontrol->value.integer.value[0] = mix->master_vol[0];
271 ucontrol->value.integer.value[1] = mix->master_vol[1];
275 static int tumbler_put_master_volume(struct snd_kcontrol *kcontrol,
276 struct snd_ctl_elem_value *ucontrol)
278 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
279 struct pmac_tumbler *mix = chip->mixer_data;
283 vol[0] = ucontrol->value.integer.value[0];
284 vol[1] = ucontrol->value.integer.value[1];
285 if (vol[0] >= ARRAY_SIZE(master_volume_table) ||
286 vol[1] >= ARRAY_SIZE(master_volume_table))
288 change = mix->master_vol[0] != vol[0] ||
289 mix->master_vol[1] != vol[1];
291 mix->master_vol[0] = vol[0];
292 mix->master_vol[1] = vol[1];
293 tumbler_set_master_volume(mix);
299 static int tumbler_get_master_switch(struct snd_kcontrol *kcontrol,
300 struct snd_ctl_elem_value *ucontrol)
302 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
303 struct pmac_tumbler *mix = chip->mixer_data;
305 ucontrol->value.integer.value[0] = mix->master_switch[0];
306 ucontrol->value.integer.value[1] = mix->master_switch[1];
310 static int tumbler_put_master_switch(struct snd_kcontrol *kcontrol,
311 struct snd_ctl_elem_value *ucontrol)
313 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
314 struct pmac_tumbler *mix = chip->mixer_data;
317 change = mix->master_switch[0] != ucontrol->value.integer.value[0] ||
318 mix->master_switch[1] != ucontrol->value.integer.value[1];
320 mix->master_switch[0] = !!ucontrol->value.integer.value[0];
321 mix->master_switch[1] = !!ucontrol->value.integer.value[1];
322 tumbler_set_master_volume(mix);
329 * TAS3001c dynamic range compression
332 #define TAS3001_DRC_MAX 0x5f
334 static int tumbler_set_drc(struct pmac_tumbler *mix)
336 unsigned char val[2];
338 if (! mix->i2c.client)
341 if (mix->drc_enable) {
342 val[0] = 0xc1; /* enable, 3:1 compression */
343 if (mix->drc_range > TAS3001_DRC_MAX)
345 else if (mix->drc_range < 0)
348 val[1] = mix->drc_range + 0x91;
354 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
356 snd_printk(KERN_ERR "failed to set DRC\n");
366 #define TAS3004_DRC_MAX 0xef
368 static int snapper_set_drc(struct pmac_tumbler *mix)
370 unsigned char val[6];
372 if (! mix->i2c.client)
376 val[0] = 0x50; /* 3:1 above threshold */
378 val[0] = 0x51; /* disabled */
379 val[1] = 0x02; /* 1:1 below threshold */
380 if (mix->drc_range > 0xef)
382 else if (mix->drc_range < 0)
385 val[2] = mix->drc_range;
390 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
392 snd_printk(KERN_ERR "failed to set DRC\n");
398 static int tumbler_info_drc_value(struct snd_kcontrol *kcontrol,
399 struct snd_ctl_elem_info *uinfo)
401 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
402 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
404 uinfo->value.integer.min = 0;
405 uinfo->value.integer.max =
406 chip->model == PMAC_TUMBLER ? TAS3001_DRC_MAX : TAS3004_DRC_MAX;
410 static int tumbler_get_drc_value(struct snd_kcontrol *kcontrol,
411 struct snd_ctl_elem_value *ucontrol)
413 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
414 struct pmac_tumbler *mix;
415 if (! (mix = chip->mixer_data))
417 ucontrol->value.integer.value[0] = mix->drc_range;
421 static int tumbler_put_drc_value(struct snd_kcontrol *kcontrol,
422 struct snd_ctl_elem_value *ucontrol)
424 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
425 struct pmac_tumbler *mix;
429 if (! (mix = chip->mixer_data))
431 val = ucontrol->value.integer.value[0];
432 if (chip->model == PMAC_TUMBLER) {
433 if (val > TAS3001_DRC_MAX)
436 if (val > TAS3004_DRC_MAX)
439 change = mix->drc_range != val;
441 mix->drc_range = val;
442 if (chip->model == PMAC_TUMBLER)
443 tumbler_set_drc(mix);
445 snapper_set_drc(mix);
450 static int tumbler_get_drc_switch(struct snd_kcontrol *kcontrol,
451 struct snd_ctl_elem_value *ucontrol)
453 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
454 struct pmac_tumbler *mix;
455 if (! (mix = chip->mixer_data))
457 ucontrol->value.integer.value[0] = mix->drc_enable;
461 static int tumbler_put_drc_switch(struct snd_kcontrol *kcontrol,
462 struct snd_ctl_elem_value *ucontrol)
464 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
465 struct pmac_tumbler *mix;
468 if (! (mix = chip->mixer_data))
470 change = mix->drc_enable != ucontrol->value.integer.value[0];
472 mix->drc_enable = !!ucontrol->value.integer.value[0];
473 if (chip->model == PMAC_TUMBLER)
474 tumbler_set_drc(mix);
476 snapper_set_drc(mix);
486 struct tumbler_mono_vol {
494 static int tumbler_set_mono_volume(struct pmac_tumbler *mix,
495 struct tumbler_mono_vol *info)
497 unsigned char block[4];
501 if (! mix->i2c.client)
504 vol = mix->mono_vol[info->index];
505 if (vol >= info->max)
507 vol = info->table[vol];
508 for (i = 0; i < info->bytes; i++)
509 block[i] = (vol >> ((info->bytes - i - 1) * 8)) & 0xff;
510 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, info->reg,
511 info->bytes, block) < 0) {
512 snd_printk(KERN_ERR "failed to set mono volume %d\n",
519 static int tumbler_info_mono(struct snd_kcontrol *kcontrol,
520 struct snd_ctl_elem_info *uinfo)
522 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
524 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
526 uinfo->value.integer.min = 0;
527 uinfo->value.integer.max = info->max - 1;
531 static int tumbler_get_mono(struct snd_kcontrol *kcontrol,
532 struct snd_ctl_elem_value *ucontrol)
534 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
535 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
536 struct pmac_tumbler *mix;
537 if (! (mix = chip->mixer_data))
539 ucontrol->value.integer.value[0] = mix->mono_vol[info->index];
543 static int tumbler_put_mono(struct snd_kcontrol *kcontrol,
544 struct snd_ctl_elem_value *ucontrol)
546 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
547 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
548 struct pmac_tumbler *mix;
552 if (! (mix = chip->mixer_data))
554 vol = ucontrol->value.integer.value[0];
555 if (vol >= info->max)
557 change = mix->mono_vol[info->index] != vol;
559 mix->mono_vol[info->index] = vol;
560 tumbler_set_mono_volume(mix, info);
565 /* TAS3001c mono volumes */
566 static struct tumbler_mono_vol tumbler_pcm_vol_info = {
567 .index = VOL_IDX_PCM_MONO,
570 .max = ARRAY_SIZE(mixer_volume_table),
571 .table = mixer_volume_table,
574 static struct tumbler_mono_vol tumbler_bass_vol_info = {
575 .index = VOL_IDX_BASS,
578 .max = ARRAY_SIZE(bass_volume_table),
579 .table = bass_volume_table,
582 static struct tumbler_mono_vol tumbler_treble_vol_info = {
583 .index = VOL_IDX_TREBLE,
584 .reg = TAS_REG_TREBLE,
586 .max = ARRAY_SIZE(treble_volume_table),
587 .table = treble_volume_table,
590 /* TAS3004 mono volumes */
591 static struct tumbler_mono_vol snapper_bass_vol_info = {
592 .index = VOL_IDX_BASS,
595 .max = ARRAY_SIZE(snapper_bass_volume_table),
596 .table = snapper_bass_volume_table,
599 static struct tumbler_mono_vol snapper_treble_vol_info = {
600 .index = VOL_IDX_TREBLE,
601 .reg = TAS_REG_TREBLE,
603 .max = ARRAY_SIZE(snapper_treble_volume_table),
604 .table = snapper_treble_volume_table,
608 #define DEFINE_MONO(xname,type) { \
609 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
611 .info = tumbler_info_mono, \
612 .get = tumbler_get_mono, \
613 .put = tumbler_put_mono, \
614 .private_value = (unsigned long)(&tumbler_##type##_vol_info), \
617 #define DEFINE_SNAPPER_MONO(xname,type) { \
618 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
620 .info = tumbler_info_mono, \
621 .get = tumbler_get_mono, \
622 .put = tumbler_put_mono, \
623 .private_value = (unsigned long)(&snapper_##type##_vol_info), \
628 * snapper mixer volumes
631 static int snapper_set_mix_vol1(struct pmac_tumbler *mix, int idx, int ch, int reg)
634 unsigned char block[9];
636 vol = mix->mix_vol[idx][ch];
637 if (vol >= ARRAY_SIZE(mixer_volume_table)) {
638 vol = ARRAY_SIZE(mixer_volume_table) - 1;
639 mix->mix_vol[idx][ch] = vol;
642 for (i = 0; i < 3; i++) {
643 vol = mix->mix_vol[i][ch];
644 vol = mixer_volume_table[vol];
645 for (j = 0; j < 3; j++)
646 block[i * 3 + j] = (vol >> ((2 - j) * 8)) & 0xff;
648 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, reg,
650 snd_printk(KERN_ERR "failed to set mono volume %d\n", reg);
656 static int snapper_set_mix_vol(struct pmac_tumbler *mix, int idx)
658 if (! mix->i2c.client)
660 if (snapper_set_mix_vol1(mix, idx, 0, TAS_REG_LMIX) < 0 ||
661 snapper_set_mix_vol1(mix, idx, 1, TAS_REG_RMIX) < 0)
666 static int snapper_info_mix(struct snd_kcontrol *kcontrol,
667 struct snd_ctl_elem_info *uinfo)
669 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
671 uinfo->value.integer.min = 0;
672 uinfo->value.integer.max = ARRAY_SIZE(mixer_volume_table) - 1;
676 static int snapper_get_mix(struct snd_kcontrol *kcontrol,
677 struct snd_ctl_elem_value *ucontrol)
679 int idx = (int)kcontrol->private_value;
680 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
681 struct pmac_tumbler *mix;
682 if (! (mix = chip->mixer_data))
684 ucontrol->value.integer.value[0] = mix->mix_vol[idx][0];
685 ucontrol->value.integer.value[1] = mix->mix_vol[idx][1];
689 static int snapper_put_mix(struct snd_kcontrol *kcontrol,
690 struct snd_ctl_elem_value *ucontrol)
692 int idx = (int)kcontrol->private_value;
693 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
694 struct pmac_tumbler *mix;
698 if (! (mix = chip->mixer_data))
700 vol[0] = ucontrol->value.integer.value[0];
701 vol[1] = ucontrol->value.integer.value[1];
702 if (vol[0] >= ARRAY_SIZE(mixer_volume_table) ||
703 vol[1] >= ARRAY_SIZE(mixer_volume_table))
705 change = mix->mix_vol[idx][0] != vol[0] ||
706 mix->mix_vol[idx][1] != vol[1];
708 mix->mix_vol[idx][0] = vol[0];
709 mix->mix_vol[idx][1] = vol[1];
710 snapper_set_mix_vol(mix, idx);
717 * mute switches. FIXME: Turn that into software mute when both outputs are muted
718 * to avoid codec reset on ibook M7
721 enum { TUMBLER_MUTE_HP, TUMBLER_MUTE_AMP, TUMBLER_MUTE_LINE };
723 static int tumbler_get_mute_switch(struct snd_kcontrol *kcontrol,
724 struct snd_ctl_elem_value *ucontrol)
726 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
727 struct pmac_tumbler *mix;
728 struct pmac_gpio *gp;
729 if (! (mix = chip->mixer_data))
731 switch(kcontrol->private_value) {
732 case TUMBLER_MUTE_HP:
733 gp = &mix->hp_mute; break;
734 case TUMBLER_MUTE_AMP:
735 gp = &mix->amp_mute; break;
736 case TUMBLER_MUTE_LINE:
737 gp = &mix->line_mute; break;
743 ucontrol->value.integer.value[0] = !check_audio_gpio(gp);
747 static int tumbler_put_mute_switch(struct snd_kcontrol *kcontrol,
748 struct snd_ctl_elem_value *ucontrol)
750 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
751 struct pmac_tumbler *mix;
752 struct pmac_gpio *gp;
754 #ifdef PMAC_SUPPORT_AUTOMUTE
755 if (chip->update_automute && chip->auto_mute)
756 return 0; /* don't touch in the auto-mute mode */
758 if (! (mix = chip->mixer_data))
760 switch(kcontrol->private_value) {
761 case TUMBLER_MUTE_HP:
762 gp = &mix->hp_mute; break;
763 case TUMBLER_MUTE_AMP:
764 gp = &mix->amp_mute; break;
765 case TUMBLER_MUTE_LINE:
766 gp = &mix->line_mute; break;
772 val = ! check_audio_gpio(gp);
773 if (val != ucontrol->value.integer.value[0]) {
774 write_audio_gpio(gp, ! ucontrol->value.integer.value[0]);
780 static int snapper_set_capture_source(struct pmac_tumbler *mix)
782 if (! mix->i2c.client)
784 if (mix->capture_source)
785 mix->acs = mix->acs |= 2;
788 return i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
791 static int snapper_info_capture_source(struct snd_kcontrol *kcontrol,
792 struct snd_ctl_elem_info *uinfo)
794 static char *texts[2] = {
797 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
799 uinfo->value.enumerated.items = 2;
800 if (uinfo->value.enumerated.item > 1)
801 uinfo->value.enumerated.item = 1;
802 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
806 static int snapper_get_capture_source(struct snd_kcontrol *kcontrol,
807 struct snd_ctl_elem_value *ucontrol)
809 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
810 struct pmac_tumbler *mix = chip->mixer_data;
812 ucontrol->value.enumerated.item[0] = mix->capture_source;
816 static int snapper_put_capture_source(struct snd_kcontrol *kcontrol,
817 struct snd_ctl_elem_value *ucontrol)
819 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
820 struct pmac_tumbler *mix = chip->mixer_data;
823 change = ucontrol->value.enumerated.item[0] != mix->capture_source;
825 mix->capture_source = !!ucontrol->value.enumerated.item[0];
826 snapper_set_capture_source(mix);
831 #define DEFINE_SNAPPER_MIX(xname,idx,ofs) { \
832 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
834 .info = snapper_info_mix, \
835 .get = snapper_get_mix, \
836 .put = snapper_put_mix, \
838 .private_value = ofs, \
844 static struct snd_kcontrol_new tumbler_mixers[] __devinitdata = {
845 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
846 .name = "Master Playback Volume",
847 .info = tumbler_info_master_volume,
848 .get = tumbler_get_master_volume,
849 .put = tumbler_put_master_volume
851 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
852 .name = "Master Playback Switch",
853 .info = snd_pmac_boolean_stereo_info,
854 .get = tumbler_get_master_switch,
855 .put = tumbler_put_master_switch
857 DEFINE_MONO("Tone Control - Bass", bass),
858 DEFINE_MONO("Tone Control - Treble", treble),
859 DEFINE_MONO("PCM Playback Volume", pcm),
860 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
862 .info = tumbler_info_drc_value,
863 .get = tumbler_get_drc_value,
864 .put = tumbler_put_drc_value
868 static struct snd_kcontrol_new snapper_mixers[] __devinitdata = {
869 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
870 .name = "Master Playback Volume",
871 .info = tumbler_info_master_volume,
872 .get = tumbler_get_master_volume,
873 .put = tumbler_put_master_volume
875 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
876 .name = "Master Playback Switch",
877 .info = snd_pmac_boolean_stereo_info,
878 .get = tumbler_get_master_switch,
879 .put = tumbler_put_master_switch
881 DEFINE_SNAPPER_MIX("PCM Playback Volume", 0, VOL_IDX_PCM),
882 /* Alternative PCM is assigned to Mic analog loopback on iBook G4 */
883 DEFINE_SNAPPER_MIX("Mic Playback Volume", 0, VOL_IDX_PCM2),
884 DEFINE_SNAPPER_MIX("Monitor Mix Volume", 0, VOL_IDX_ADC),
885 DEFINE_SNAPPER_MONO("Tone Control - Bass", bass),
886 DEFINE_SNAPPER_MONO("Tone Control - Treble", treble),
887 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
889 .info = tumbler_info_drc_value,
890 .get = tumbler_get_drc_value,
891 .put = tumbler_put_drc_value
893 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
894 .name = "Input Source", /* FIXME: "Capture Source" doesn't work properly */
895 .info = snapper_info_capture_source,
896 .get = snapper_get_capture_source,
897 .put = snapper_put_capture_source
901 static struct snd_kcontrol_new tumbler_hp_sw __devinitdata = {
902 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
903 .name = "Headphone Playback Switch",
904 .info = snd_pmac_boolean_mono_info,
905 .get = tumbler_get_mute_switch,
906 .put = tumbler_put_mute_switch,
907 .private_value = TUMBLER_MUTE_HP,
909 static struct snd_kcontrol_new tumbler_speaker_sw __devinitdata = {
910 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
911 .name = "Speaker Playback Switch",
912 .info = snd_pmac_boolean_mono_info,
913 .get = tumbler_get_mute_switch,
914 .put = tumbler_put_mute_switch,
915 .private_value = TUMBLER_MUTE_AMP,
917 static struct snd_kcontrol_new tumbler_lineout_sw __devinitdata = {
918 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
919 .name = "Line Out Playback Switch",
920 .info = snd_pmac_boolean_mono_info,
921 .get = tumbler_get_mute_switch,
922 .put = tumbler_put_mute_switch,
923 .private_value = TUMBLER_MUTE_LINE,
925 static struct snd_kcontrol_new tumbler_drc_sw __devinitdata = {
926 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
927 .name = "DRC Switch",
928 .info = snd_pmac_boolean_mono_info,
929 .get = tumbler_get_drc_switch,
930 .put = tumbler_put_drc_switch
934 #ifdef PMAC_SUPPORT_AUTOMUTE
938 static int tumbler_detect_headphone(struct snd_pmac *chip)
940 struct pmac_tumbler *mix = chip->mixer_data;
943 if (mix->hp_detect.addr)
944 detect |= read_audio_gpio(&mix->hp_detect);
948 static int tumbler_detect_lineout(struct snd_pmac *chip)
950 struct pmac_tumbler *mix = chip->mixer_data;
953 if (mix->line_detect.addr)
954 detect |= read_audio_gpio(&mix->line_detect);
958 static void check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int val, int do_notify,
959 struct snd_kcontrol *sw)
961 if (check_audio_gpio(gp) != val) {
962 write_audio_gpio(gp, val);
964 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
969 static struct work_struct device_change;
970 static struct snd_pmac *device_change_chip;
972 static void device_change_handler(struct work_struct *work)
974 struct snd_pmac *chip = device_change_chip;
975 struct pmac_tumbler *mix;
976 int headphone, lineout;
981 mix = chip->mixer_data;
982 if (snd_BUG_ON(!mix))
985 headphone = tumbler_detect_headphone(chip);
986 lineout = tumbler_detect_lineout(chip);
988 DBG("headphone: %d, lineout: %d\n", headphone, lineout);
990 if (headphone || lineout) {
991 /* unmute headphone/lineout & mute speaker */
993 check_mute(chip, &mix->hp_mute, 0, mix->auto_mute_notify,
994 chip->master_sw_ctl);
995 if (lineout && mix->line_mute.addr != 0)
996 check_mute(chip, &mix->line_mute, 0, mix->auto_mute_notify,
997 chip->lineout_sw_ctl);
998 if (mix->anded_reset)
1000 check_mute(chip, &mix->amp_mute, 1, mix->auto_mute_notify,
1001 chip->speaker_sw_ctl);
1003 /* unmute speaker, mute others */
1004 check_mute(chip, &mix->amp_mute, 0, mix->auto_mute_notify,
1005 chip->speaker_sw_ctl);
1006 if (mix->anded_reset)
1008 check_mute(chip, &mix->hp_mute, 1, mix->auto_mute_notify,
1009 chip->master_sw_ctl);
1010 if (mix->line_mute.addr != 0)
1011 check_mute(chip, &mix->line_mute, 1, mix->auto_mute_notify,
1012 chip->lineout_sw_ctl);
1014 if (mix->auto_mute_notify)
1015 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1016 &chip->hp_detect_ctl->id);
1018 #ifdef CONFIG_SND_POWERMAC_AUTO_DRC
1019 mix->drc_enable = ! (headphone || lineout);
1020 if (mix->auto_mute_notify)
1021 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1022 &chip->drc_sw_ctl->id);
1023 if (chip->model == PMAC_TUMBLER)
1024 tumbler_set_drc(mix);
1026 snapper_set_drc(mix);
1029 /* reset the master volume so the correct amplification is applied */
1030 tumbler_set_master_volume(mix);
1033 static void tumbler_update_automute(struct snd_pmac *chip, int do_notify)
1035 if (chip->auto_mute) {
1036 struct pmac_tumbler *mix;
1037 mix = chip->mixer_data;
1038 if (snd_BUG_ON(!mix))
1040 mix->auto_mute_notify = do_notify;
1041 schedule_work(&device_change);
1044 #endif /* PMAC_SUPPORT_AUTOMUTE */
1047 /* interrupt - headphone plug changed */
1048 static irqreturn_t headphone_intr(int irq, void *devid)
1050 struct snd_pmac *chip = devid;
1051 if (chip->update_automute && chip->initialized) {
1052 chip->update_automute(chip, 1);
1058 /* look for audio-gpio device */
1059 static struct device_node *find_audio_device(const char *name)
1061 struct device_node *gpiop;
1062 struct device_node *np;
1064 gpiop = of_find_node_by_name(NULL, "gpio");
1068 for (np = of_get_next_child(gpiop, NULL); np;
1069 np = of_get_next_child(gpiop, np)) {
1070 const char *property = of_get_property(np, "audio-gpio", NULL);
1071 if (property && strcmp(property, name) == 0)
1078 /* look for audio-gpio device */
1079 static struct device_node *find_compatible_audio_device(const char *name)
1081 struct device_node *gpiop;
1082 struct device_node *np;
1084 gpiop = of_find_node_by_name(NULL, "gpio");
1088 for (np = of_get_next_child(gpiop, NULL); np;
1089 np = of_get_next_child(gpiop, np)) {
1090 if (of_device_is_compatible(np, name))
1097 /* find an audio device and get its address */
1098 static long tumbler_find_device(const char *device, const char *platform,
1099 struct pmac_gpio *gp, int is_compatible)
1101 struct device_node *node;
1107 node = find_compatible_audio_device(device);
1109 node = find_audio_device(device);
1111 DBG("(W) cannot find audio device %s !\n", device);
1112 snd_printdd("cannot find device %s\n", device);
1116 base = of_get_property(node, "AAPL,address", NULL);
1118 base = of_get_property(node, "reg", NULL);
1120 DBG("(E) cannot find address for device %s !\n", device);
1121 snd_printd("cannot find address for device %s\n", device);
1131 gp->addr = addr & 0x0000ffff;
1132 /* Try to find the active state, default to 0 ! */
1133 base = of_get_property(node, "audio-gpio-active-state", NULL);
1135 gp->active_state = *base;
1136 gp->active_val = (*base) ? 0x5 : 0x4;
1137 gp->inactive_val = (*base) ? 0x4 : 0x5;
1139 const u32 *prop = NULL;
1140 gp->active_state = IS_G4DA
1141 && !strncmp(device, "keywest-gpio1", 13);
1142 gp->active_val = 0x4;
1143 gp->inactive_val = 0x5;
1144 /* Here are some crude hacks to extract the GPIO polarity and
1145 * open collector informations out of the do-platform script
1146 * as we don't yet have an interpreter for these things
1149 prop = of_get_property(node, platform, NULL);
1151 if (prop[3] == 0x9 && prop[4] == 0x9) {
1152 gp->active_val = 0xd;
1153 gp->inactive_val = 0xc;
1155 if (prop[3] == 0x1 && prop[4] == 0x1) {
1156 gp->active_val = 0x5;
1157 gp->inactive_val = 0x4;
1162 DBG("(I) GPIO device %s found, offset: %x, active state: %d !\n",
1163 device, gp->addr, gp->active_state);
1165 ret = irq_of_parse_and_map(node, 0);
1171 static void tumbler_reset_audio(struct snd_pmac *chip)
1173 struct pmac_tumbler *mix = chip->mixer_data;
1175 if (mix->anded_reset) {
1176 DBG("(I) codec anded reset !\n");
1177 write_audio_gpio(&mix->hp_mute, 0);
1178 write_audio_gpio(&mix->amp_mute, 0);
1180 write_audio_gpio(&mix->hp_mute, 1);
1181 write_audio_gpio(&mix->amp_mute, 1);
1183 write_audio_gpio(&mix->hp_mute, 0);
1184 write_audio_gpio(&mix->amp_mute, 0);
1187 DBG("(I) codec normal reset !\n");
1189 write_audio_gpio(&mix->audio_reset, 0);
1191 write_audio_gpio(&mix->audio_reset, 1);
1193 write_audio_gpio(&mix->audio_reset, 0);
1200 static void tumbler_suspend(struct snd_pmac *chip)
1202 struct pmac_tumbler *mix = chip->mixer_data;
1204 if (mix->headphone_irq >= 0)
1205 disable_irq(mix->headphone_irq);
1206 if (mix->lineout_irq >= 0)
1207 disable_irq(mix->lineout_irq);
1208 mix->save_master_switch[0] = mix->master_switch[0];
1209 mix->save_master_switch[1] = mix->master_switch[1];
1210 mix->save_master_vol[0] = mix->master_vol[0];
1211 mix->save_master_vol[1] = mix->master_vol[1];
1212 mix->master_switch[0] = mix->master_switch[1] = 0;
1213 tumbler_set_master_volume(mix);
1214 if (!mix->anded_reset) {
1215 write_audio_gpio(&mix->amp_mute, 1);
1216 write_audio_gpio(&mix->hp_mute, 1);
1218 if (chip->model == PMAC_SNAPPER) {
1220 i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
1222 if (mix->anded_reset) {
1223 write_audio_gpio(&mix->amp_mute, 1);
1224 write_audio_gpio(&mix->hp_mute, 1);
1226 write_audio_gpio(&mix->audio_reset, 1);
1230 static void tumbler_resume(struct snd_pmac *chip)
1232 struct pmac_tumbler *mix = chip->mixer_data;
1235 mix->master_switch[0] = mix->save_master_switch[0];
1236 mix->master_switch[1] = mix->save_master_switch[1];
1237 mix->master_vol[0] = mix->save_master_vol[0];
1238 mix->master_vol[1] = mix->save_master_vol[1];
1239 tumbler_reset_audio(chip);
1240 if (mix->i2c.client && mix->i2c.init_client) {
1241 if (mix->i2c.init_client(&mix->i2c) < 0)
1242 printk(KERN_ERR "tumbler_init_client error\n");
1244 printk(KERN_ERR "tumbler: i2c is not initialized\n");
1245 if (chip->model == PMAC_TUMBLER) {
1246 tumbler_set_mono_volume(mix, &tumbler_pcm_vol_info);
1247 tumbler_set_mono_volume(mix, &tumbler_bass_vol_info);
1248 tumbler_set_mono_volume(mix, &tumbler_treble_vol_info);
1249 tumbler_set_drc(mix);
1251 snapper_set_mix_vol(mix, VOL_IDX_PCM);
1252 snapper_set_mix_vol(mix, VOL_IDX_PCM2);
1253 snapper_set_mix_vol(mix, VOL_IDX_ADC);
1254 tumbler_set_mono_volume(mix, &snapper_bass_vol_info);
1255 tumbler_set_mono_volume(mix, &snapper_treble_vol_info);
1256 snapper_set_drc(mix);
1257 snapper_set_capture_source(mix);
1259 tumbler_set_master_volume(mix);
1260 if (chip->update_automute)
1261 chip->update_automute(chip, 0);
1262 if (mix->headphone_irq >= 0) {
1265 enable_irq(mix->headphone_irq);
1266 /* activate headphone status interrupts */
1267 val = do_gpio_read(&mix->hp_detect);
1268 do_gpio_write(&mix->hp_detect, val | 0x80);
1270 if (mix->lineout_irq >= 0)
1271 enable_irq(mix->lineout_irq);
1275 /* initialize tumbler */
1276 static int __devinit tumbler_init(struct snd_pmac *chip)
1279 struct pmac_tumbler *mix = chip->mixer_data;
1281 if (tumbler_find_device("audio-hw-reset",
1282 "platform-do-hw-reset",
1283 &mix->audio_reset, 0) < 0)
1284 tumbler_find_device("hw-reset",
1285 "platform-do-hw-reset",
1286 &mix->audio_reset, 1);
1287 if (tumbler_find_device("amp-mute",
1288 "platform-do-amp-mute",
1289 &mix->amp_mute, 0) < 0)
1290 tumbler_find_device("amp-mute",
1291 "platform-do-amp-mute",
1293 if (tumbler_find_device("headphone-mute",
1294 "platform-do-headphone-mute",
1295 &mix->hp_mute, 0) < 0)
1296 tumbler_find_device("headphone-mute",
1297 "platform-do-headphone-mute",
1299 if (tumbler_find_device("line-output-mute",
1300 "platform-do-lineout-mute",
1301 &mix->line_mute, 0) < 0)
1302 tumbler_find_device("line-output-mute",
1303 "platform-do-lineout-mute",
1304 &mix->line_mute, 1);
1305 irq = tumbler_find_device("headphone-detect",
1306 NULL, &mix->hp_detect, 0);
1308 irq = tumbler_find_device("headphone-detect",
1309 NULL, &mix->hp_detect, 1);
1311 irq = tumbler_find_device("keywest-gpio15",
1312 NULL, &mix->hp_detect, 1);
1313 mix->headphone_irq = irq;
1314 irq = tumbler_find_device("line-output-detect",
1315 NULL, &mix->line_detect, 0);
1317 irq = tumbler_find_device("line-output-detect",
1318 NULL, &mix->line_detect, 1);
1319 if (IS_G4DA && irq <= NO_IRQ)
1320 irq = tumbler_find_device("keywest-gpio16",
1321 NULL, &mix->line_detect, 1);
1322 mix->lineout_irq = irq;
1324 tumbler_reset_audio(chip);
1329 static void tumbler_cleanup(struct snd_pmac *chip)
1331 struct pmac_tumbler *mix = chip->mixer_data;
1335 if (mix->headphone_irq >= 0)
1336 free_irq(mix->headphone_irq, chip);
1337 if (mix->lineout_irq >= 0)
1338 free_irq(mix->lineout_irq, chip);
1339 tumbler_gpio_free(&mix->audio_reset);
1340 tumbler_gpio_free(&mix->amp_mute);
1341 tumbler_gpio_free(&mix->hp_mute);
1342 tumbler_gpio_free(&mix->hp_detect);
1343 snd_pmac_keywest_cleanup(&mix->i2c);
1345 chip->mixer_data = NULL;
1349 int __devinit snd_pmac_tumbler_init(struct snd_pmac *chip)
1352 struct pmac_tumbler *mix;
1354 struct device_node *tas_node, *np;
1357 request_module("i2c-powermac");
1359 mix = kzalloc(sizeof(*mix), GFP_KERNEL);
1362 mix->headphone_irq = -1;
1364 chip->mixer_data = mix;
1365 chip->mixer_free = tumbler_cleanup;
1366 mix->anded_reset = 0;
1367 mix->reset_on_sleep = 1;
1369 for (np = chip->node->child; np; np = np->sibling) {
1370 if (!strcmp(np->name, "sound")) {
1371 if (of_get_property(np, "has-anded-reset", NULL))
1372 mix->anded_reset = 1;
1373 if (of_get_property(np, "layout-id", NULL))
1374 mix->reset_on_sleep = 0;
1378 if ((err = tumbler_init(chip)) < 0)
1382 tas_node = of_find_node_by_name(NULL, "deq");
1383 if (tas_node == NULL)
1384 tas_node = of_find_node_by_name(NULL, "codec");
1385 if (tas_node == NULL)
1388 paddr = of_get_property(tas_node, "i2c-address", NULL);
1390 paddr = of_get_property(tas_node, "reg", NULL);
1392 mix->i2c.addr = (*paddr) >> 1;
1394 mix->i2c.addr = TAS_I2C_ADDR;
1395 of_node_put(tas_node);
1397 DBG("(I) TAS i2c address is: %x\n", mix->i2c.addr);
1399 if (chip->model == PMAC_TUMBLER) {
1400 mix->i2c.init_client = tumbler_init_client;
1401 mix->i2c.name = "TAS3001c";
1402 chipname = "Tumbler";
1404 mix->i2c.init_client = snapper_init_client;
1405 mix->i2c.name = "TAS3004";
1406 chipname = "Snapper";
1409 if ((err = snd_pmac_keywest_init(&mix->i2c)) < 0)
1415 sprintf(chip->card->mixername, "PowerMac %s", chipname);
1417 if (chip->model == PMAC_TUMBLER) {
1418 for (i = 0; i < ARRAY_SIZE(tumbler_mixers); i++) {
1419 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&tumbler_mixers[i], chip))) < 0)
1423 for (i = 0; i < ARRAY_SIZE(snapper_mixers); i++) {
1424 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snapper_mixers[i], chip))) < 0)
1428 chip->master_sw_ctl = snd_ctl_new1(&tumbler_hp_sw, chip);
1429 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
1431 chip->speaker_sw_ctl = snd_ctl_new1(&tumbler_speaker_sw, chip);
1432 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
1434 if (mix->line_mute.addr != 0) {
1435 chip->lineout_sw_ctl = snd_ctl_new1(&tumbler_lineout_sw, chip);
1436 if ((err = snd_ctl_add(chip->card, chip->lineout_sw_ctl)) < 0)
1439 chip->drc_sw_ctl = snd_ctl_new1(&tumbler_drc_sw, chip);
1440 if ((err = snd_ctl_add(chip->card, chip->drc_sw_ctl)) < 0)
1443 /* set initial DRC range to 60% */
1444 if (chip->model == PMAC_TUMBLER)
1445 mix->drc_range = (TAS3001_DRC_MAX * 6) / 10;
1447 mix->drc_range = (TAS3004_DRC_MAX * 6) / 10;
1448 mix->drc_enable = 1; /* will be changed later if AUTO_DRC is set */
1449 if (chip->model == PMAC_TUMBLER)
1450 tumbler_set_drc(mix);
1452 snapper_set_drc(mix);
1455 chip->suspend = tumbler_suspend;
1456 chip->resume = tumbler_resume;
1459 INIT_WORK(&device_change, device_change_handler);
1460 device_change_chip = chip;
1462 #ifdef PMAC_SUPPORT_AUTOMUTE
1463 if ((mix->headphone_irq >=0 || mix->lineout_irq >= 0)
1464 && (err = snd_pmac_add_automute(chip)) < 0)
1466 chip->detect_headphone = tumbler_detect_headphone;
1467 chip->update_automute = tumbler_update_automute;
1468 tumbler_update_automute(chip, 0); /* update the status only */
1470 /* activate headphone status interrupts */
1471 if (mix->headphone_irq >= 0) {
1473 if ((err = request_irq(mix->headphone_irq, headphone_intr, 0,
1474 "Sound Headphone Detection", chip)) < 0)
1476 /* activate headphone status interrupts */
1477 val = do_gpio_read(&mix->hp_detect);
1478 do_gpio_write(&mix->hp_detect, val | 0x80);
1480 if (mix->lineout_irq >= 0) {
1482 if ((err = request_irq(mix->lineout_irq, headphone_intr, 0,
1483 "Sound Lineout Detection", chip)) < 0)
1485 /* activate headphone status interrupts */
1486 val = do_gpio_read(&mix->line_detect);
1487 do_gpio_write(&mix->line_detect, val | 0x80);