#include <sound/core.h>
#include <asm/io.h>
#include <asm/irq.h>
-#ifdef CONFIG_PPC_HAS_FEATURE_CALLS
+#include <asm/machdep.h>
#include <asm/pmac_feature.h>
-#endif
#include "pmac.h"
#include "tumbler_volume.h"
+#undef DEBUG
+
+#ifdef DEBUG
+#define DBG(fmt...) printk(fmt)
+#else
+#define DBG(fmt...)
+#endif
+
/* i2c address for tumbler */
#define TAS_I2C_ADDR 0x34
VOL_IDX_LAST_MIX
};
-typedef struct pmac_gpio {
-#ifdef CONFIG_PPC_HAS_FEATURE_CALLS
+struct pmac_gpio {
unsigned int addr;
-#else
- void *addr;
-#endif
- int active_state;
-} pmac_gpio_t;
-
-typedef struct pmac_tumbler_t {
- pmac_keywest_t i2c;
- pmac_gpio_t audio_reset;
- pmac_gpio_t amp_mute;
- pmac_gpio_t hp_mute;
- pmac_gpio_t hp_detect;
+ u8 active_val;
+ u8 inactive_val;
+ u8 active_state;
+};
+
+struct pmac_tumbler {
+ struct pmac_keywest i2c;
+ struct pmac_gpio audio_reset;
+ struct pmac_gpio amp_mute;
+ struct pmac_gpio line_mute;
+ struct pmac_gpio line_detect;
+ struct pmac_gpio hp_mute;
+ struct pmac_gpio hp_detect;
int headphone_irq;
+ int lineout_irq;
+ unsigned int save_master_vol[2];
unsigned int master_vol[2];
+ unsigned int save_master_switch[2];
unsigned int master_switch[2];
unsigned int mono_vol[VOL_IDX_LAST_MONO];
unsigned int mix_vol[VOL_IDX_LAST_MIX][2]; /* stereo volumes for tas3004 */
int drc_range;
int drc_enable;
int capture_source;
-} pmac_tumbler_t;
+ int anded_reset;
+ int auto_mute_notify;
+ int reset_on_sleep;
+ u8 acs;
+};
/*
*/
-static int send_init_client(pmac_keywest_t *i2c, unsigned int *regs)
+static int send_init_client(struct pmac_keywest *i2c, unsigned int *regs)
{
while (*regs > 0) {
int err, count = 10;
do {
- err = snd_pmac_keywest_write_byte(i2c, regs[0], regs[1]);
+ err = i2c_smbus_write_byte_data(i2c->client,
+ regs[0], regs[1]);
if (err >= 0)
break;
+ DBG("(W) i2c error %d\n", err);
mdelay(10);
} while (count--);
if (err < 0)
}
-static int tumbler_init_client(pmac_keywest_t *i2c)
+static int tumbler_init_client(struct pmac_keywest *i2c)
{
static unsigned int regs[] = {
/* normal operation, SCLK=64fps, i2s output, i2s input, 16bit width */
TAS_REG_MCS, (1<<6)|(2<<4)|(2<<2)|0,
0, /* terminator */
};
+ DBG("(I) tumbler init client\n");
return send_init_client(i2c, regs);
}
-static int snapper_init_client(pmac_keywest_t *i2c)
+static int snapper_init_client(struct pmac_keywest *i2c)
{
static unsigned int regs[] = {
/* normal operation, SCLK=64fps, i2s output, 16bit width */
TAS_REG_ACS, 0,
0, /* terminator */
};
+ DBG("(I) snapper init client\n");
return send_init_client(i2c, regs);
}
/*
* gpio access
*/
-#ifdef CONFIG_PPC_HAS_FEATURE_CALLS
#define do_gpio_write(gp, val) \
pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
#define do_gpio_read(gp) \
pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
#define tumbler_gpio_free(gp) /* NOP */
-#else
-#define do_gpio_write(gp, val) writeb(val, (gp)->addr)
-#define do_gpio_read(gp) readb((gp)->addr)
-static inline void tumbler_gpio_free(pmac_gpio_t *gp)
+
+static void write_audio_gpio(struct pmac_gpio *gp, int active)
{
- if (gp->addr) {
- iounmap(gp->addr);
- gp->addr = 0;
- }
+ if (! gp->addr)
+ return;
+ active = active ? gp->active_val : gp->inactive_val;
+ do_gpio_write(gp, active);
+ DBG("(I) gpio %x write %d\n", gp->addr, active);
}
-#endif /* CONFIG_PPC_HAS_FEATURE_CALLS */
-static void write_audio_gpio(pmac_gpio_t *gp, int active)
+static int check_audio_gpio(struct pmac_gpio *gp)
{
+ int ret;
+
if (! gp->addr)
- return;
- active = active ? gp->active_state : !gp->active_state;
- do_gpio_write(gp, active ? 0x05 : 0x04);
+ return 0;
+
+ ret = do_gpio_read(gp);
+
+ return (ret & 0xd) == (gp->active_val & 0xd);
}
-static int read_audio_gpio(pmac_gpio_t *gp)
+static int read_audio_gpio(struct pmac_gpio *gp)
{
int ret;
if (! gp->addr)
/*
* update master volume
*/
-static int tumbler_set_master_volume(pmac_tumbler_t *mix)
+static int tumbler_set_master_volume(struct pmac_tumbler *mix)
{
unsigned char block[6];
unsigned int left_vol, right_vol;
block[4] = (right_vol >> 8) & 0xff;
block[5] = (right_vol >> 0) & 0xff;
- if (snd_pmac_keywest_write(&mix->i2c, TAS_REG_VOL, 6, block) < 0) {
- snd_printk("failed to set volume \n");
- return -EINVAL;
+ if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_VOL, 6,
+ block) < 0) {
+ snd_printk("failed to set volume \n");
+ return -EINVAL;
}
return 0;
}
/* output volume */
-static int tumbler_info_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
+static int tumbler_info_master_volume(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2;
return 0;
}
-static int tumbler_get_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_get_master_volume(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix = chip->mixer_data;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix = chip->mixer_data;
snd_assert(mix, return -ENODEV);
ucontrol->value.integer.value[0] = mix->master_vol[0];
ucontrol->value.integer.value[1] = mix->master_vol[1];
return 0;
}
-static int tumbler_put_master_volume(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_put_master_volume(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix = chip->mixer_data;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix = chip->mixer_data;
int change;
snd_assert(mix, return -ENODEV);
}
/* output switch */
-static int tumbler_get_master_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_get_master_switch(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix = chip->mixer_data;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix = chip->mixer_data;
snd_assert(mix, return -ENODEV);
ucontrol->value.integer.value[0] = mix->master_switch[0];
ucontrol->value.integer.value[1] = mix->master_switch[1];
return 0;
}
-static int tumbler_put_master_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_put_master_switch(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix = chip->mixer_data;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix = chip->mixer_data;
int change;
snd_assert(mix, return -ENODEV);
#define TAS3001_DRC_MAX 0x5f
-static int tumbler_set_drc(pmac_tumbler_t *mix)
+static int tumbler_set_drc(struct pmac_tumbler *mix)
{
unsigned char val[2];
val[1] = 0;
}
- if (snd_pmac_keywest_write(&mix->i2c, TAS_REG_DRC, 2, val) < 0) {
- snd_printk("failed to set DRC\n");
- return -EINVAL;
+ if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
+ 2, val) < 0) {
+ snd_printk("failed to set DRC\n");
+ return -EINVAL;
}
return 0;
}
#define TAS3004_DRC_MAX 0xef
-static int snapper_set_drc(pmac_tumbler_t *mix)
+static int snapper_set_drc(struct pmac_tumbler *mix)
{
unsigned char val[6];
val[4] = 0x60;
val[5] = 0xa0;
- if (snd_pmac_keywest_write(&mix->i2c, TAS_REG_DRC, 6, val) < 0) {
- snd_printk("failed to set DRC\n");
- return -EINVAL;
+ if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
+ 6, val) < 0) {
+ snd_printk("failed to set DRC\n");
+ return -EINVAL;
}
return 0;
}
-static int tumbler_info_drc_value(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
+static int tumbler_info_drc_value(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 1;
uinfo->value.integer.min = 0;
return 0;
}
-static int tumbler_get_drc_value(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_get_drc_value(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
if (! (mix = chip->mixer_data))
return -ENODEV;
ucontrol->value.integer.value[0] = mix->drc_range;
return 0;
}
-static int tumbler_put_drc_value(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_put_drc_value(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
int change;
if (! (mix = chip->mixer_data))
return change;
}
-static int tumbler_get_drc_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_get_drc_switch(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
if (! (mix = chip->mixer_data))
return -ENODEV;
ucontrol->value.integer.value[0] = mix->drc_enable;
return 0;
}
-static int tumbler_put_drc_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_put_drc_switch(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
int change;
if (! (mix = chip->mixer_data))
unsigned int *table;
};
-static int tumbler_set_mono_volume(pmac_tumbler_t *mix, struct tumbler_mono_vol *info)
+static int tumbler_set_mono_volume(struct pmac_tumbler *mix,
+ struct tumbler_mono_vol *info)
{
unsigned char block[4];
unsigned int vol;
vol = info->table[vol];
for (i = 0; i < info->bytes; i++)
block[i] = (vol >> ((info->bytes - i - 1) * 8)) & 0xff;
- if (snd_pmac_keywest_write(&mix->i2c, info->reg, info->bytes, block) < 0) {
- snd_printk("failed to set mono volume %d\n", info->index);
- return -EINVAL;
+ if (i2c_smbus_write_i2c_block_data(mix->i2c.client, info->reg,
+ info->bytes, block) < 0) {
+ snd_printk("failed to set mono volume %d\n", info->index);
+ return -EINVAL;
}
return 0;
}
-static int tumbler_info_mono(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
+static int tumbler_info_mono(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
{
struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
return 0;
}
-static int tumbler_get_mono(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_get_mono(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
if (! (mix = chip->mixer_data))
return -ENODEV;
ucontrol->value.integer.value[0] = mix->mono_vol[info->index];
return 0;
}
-static int tumbler_put_mono(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_put_mono(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
int change;
if (! (mix = chip->mixer_data))
* snapper mixer volumes
*/
-static int snapper_set_mix_vol1(pmac_tumbler_t *mix, int idx, int ch, int reg)
+static int snapper_set_mix_vol1(struct pmac_tumbler *mix, int idx, int ch, int reg)
{
int i, j, vol;
unsigned char block[9];
for (j = 0; j < 3; j++)
block[i * 3 + j] = (vol >> ((2 - j) * 8)) & 0xff;
}
- if (snd_pmac_keywest_write(&mix->i2c, reg, 9, block) < 0) {
- snd_printk("failed to set mono volume %d\n", reg);
- return -EINVAL;
+ if (i2c_smbus_write_i2c_block_data(mix->i2c.client, reg,
+ 9, block) < 0) {
+ snd_printk("failed to set mono volume %d\n", reg);
+ return -EINVAL;
}
return 0;
}
-static int snapper_set_mix_vol(pmac_tumbler_t *mix, int idx)
+static int snapper_set_mix_vol(struct pmac_tumbler *mix, int idx)
{
if (! mix->i2c.client)
return -ENODEV;
return 0;
}
-static int snapper_info_mix(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
+static int snapper_info_mix(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
{
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = 2;
return 0;
}
-static int snapper_get_mix(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int snapper_get_mix(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
int idx = (int)kcontrol->private_value;
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
if (! (mix = chip->mixer_data))
return -ENODEV;
ucontrol->value.integer.value[0] = mix->mix_vol[idx][0];
return 0;
}
-static int snapper_put_mix(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int snapper_put_mix(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
int idx = (int)kcontrol->private_value;
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
int change;
if (! (mix = chip->mixer_data))
/*
- * mute switches
+ * mute switches. FIXME: Turn that into software mute when both outputs are muted
+ * to avoid codec reset on ibook M7
*/
-enum { TUMBLER_MUTE_HP, TUMBLER_MUTE_AMP };
+enum { TUMBLER_MUTE_HP, TUMBLER_MUTE_AMP, TUMBLER_MUTE_LINE };
-static int tumbler_get_mute_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_get_mute_switch(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
- pmac_gpio_t *gp;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
+ struct pmac_gpio *gp;
if (! (mix = chip->mixer_data))
return -ENODEV;
- gp = (kcontrol->private_value == TUMBLER_MUTE_HP) ? &mix->hp_mute : &mix->amp_mute;
- ucontrol->value.integer.value[0] = ! read_audio_gpio(gp);
+ switch(kcontrol->private_value) {
+ case TUMBLER_MUTE_HP:
+ gp = &mix->hp_mute; break;
+ case TUMBLER_MUTE_AMP:
+ gp = &mix->amp_mute; break;
+ case TUMBLER_MUTE_LINE:
+ gp = &mix->line_mute; break;
+ default:
+ gp = NULL;
+ }
+ if (gp == NULL)
+ return -EINVAL;
+ ucontrol->value.integer.value[0] = !check_audio_gpio(gp);
return 0;
}
-static int tumbler_put_mute_switch(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int tumbler_put_mute_switch(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix;
- pmac_gpio_t *gp;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix;
+ struct pmac_gpio *gp;
int val;
#ifdef PMAC_SUPPORT_AUTOMUTE
if (chip->update_automute && chip->auto_mute)
#endif
if (! (mix = chip->mixer_data))
return -ENODEV;
- gp = (kcontrol->private_value == TUMBLER_MUTE_HP) ? &mix->hp_mute : &mix->amp_mute;
- val = ! read_audio_gpio(gp);
+ switch(kcontrol->private_value) {
+ case TUMBLER_MUTE_HP:
+ gp = &mix->hp_mute; break;
+ case TUMBLER_MUTE_AMP:
+ gp = &mix->amp_mute; break;
+ case TUMBLER_MUTE_LINE:
+ gp = &mix->line_mute; break;
+ default:
+ gp = NULL;
+ }
+ if (gp == NULL)
+ return -EINVAL;
+ val = ! check_audio_gpio(gp);
if (val != ucontrol->value.integer.value[0]) {
write_audio_gpio(gp, ! ucontrol->value.integer.value[0]);
return 1;
return 0;
}
-static int snapper_set_capture_source(pmac_tumbler_t *mix)
+static int snapper_set_capture_source(struct pmac_tumbler *mix)
{
if (! mix->i2c.client)
return -ENODEV;
- return snd_pmac_keywest_write_byte(&mix->i2c, TAS_REG_ACS,
- mix->capture_source ? 2 : 0);
+ if (mix->capture_source)
+ mix->acs = mix->acs |= 2;
+ else
+ mix->acs &= ~2;
+ return i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
}
-static int snapper_info_capture_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
+static int snapper_info_capture_source(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_info *uinfo)
{
static char *texts[2] = {
"Line", "Mic"
return 0;
}
-static int snapper_get_capture_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int snapper_get_capture_source(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix = chip->mixer_data;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix = chip->mixer_data;
snd_assert(mix, return -ENODEV);
ucontrol->value.integer.value[0] = mix->capture_source;
return 0;
}
-static int snapper_put_capture_source(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
+static int snapper_put_capture_source(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- pmac_t *chip = snd_kcontrol_chip(kcontrol);
- pmac_tumbler_t *mix = chip->mixer_data;
+ struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
+ struct pmac_tumbler *mix = chip->mixer_data;
int change;
snd_assert(mix, return -ENODEV);
/*
*/
-static snd_kcontrol_new_t tumbler_mixers[] __initdata = {
+static struct snd_kcontrol_new tumbler_mixers[] __initdata = {
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Master Playback Volume",
.info = tumbler_info_master_volume,
},
};
-static snd_kcontrol_new_t snapper_mixers[] __initdata = {
+static struct snd_kcontrol_new snapper_mixers[] __initdata = {
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Master Playback Volume",
.info = tumbler_info_master_volume,
},
};
-static snd_kcontrol_new_t tumbler_hp_sw __initdata = {
+static struct snd_kcontrol_new tumbler_hp_sw __initdata = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "Headphone Playback Switch",
.info = snd_pmac_boolean_mono_info,
.put = tumbler_put_mute_switch,
.private_value = TUMBLER_MUTE_HP,
};
-static snd_kcontrol_new_t tumbler_speaker_sw __initdata = {
+static struct snd_kcontrol_new tumbler_speaker_sw __initdata = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "PC Speaker Playback Switch",
.info = snd_pmac_boolean_mono_info,
.put = tumbler_put_mute_switch,
.private_value = TUMBLER_MUTE_AMP,
};
-static snd_kcontrol_new_t tumbler_drc_sw __initdata = {
+static struct snd_kcontrol_new tumbler_lineout_sw __initdata = {
+ .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+ .name = "Line Out Playback Switch",
+ .info = snd_pmac_boolean_mono_info,
+ .get = tumbler_get_mute_switch,
+ .put = tumbler_put_mute_switch,
+ .private_value = TUMBLER_MUTE_LINE,
+};
+static struct snd_kcontrol_new tumbler_drc_sw __initdata = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "DRC Switch",
.info = snd_pmac_boolean_mono_info,
/*
* auto-mute stuffs
*/
-static int tumbler_detect_headphone(pmac_t *chip)
+static int tumbler_detect_headphone(struct snd_pmac *chip)
{
- pmac_tumbler_t *mix = chip->mixer_data;
- return read_audio_gpio(&mix->hp_detect);
+ struct pmac_tumbler *mix = chip->mixer_data;
+ int detect = 0;
+
+ if (mix->hp_detect.addr)
+ detect |= read_audio_gpio(&mix->hp_detect);
+ return detect;
}
-static void check_mute(pmac_t *chip, pmac_gpio_t *gp, int val, int do_notify, snd_kcontrol_t *sw)
+static int tumbler_detect_lineout(struct snd_pmac *chip)
{
- //pmac_tumbler_t *mix = chip->mixer_data;
- if (val != read_audio_gpio(gp)) {
+ struct pmac_tumbler *mix = chip->mixer_data;
+ int detect = 0;
+
+ if (mix->line_detect.addr)
+ detect |= read_audio_gpio(&mix->line_detect);
+ return detect;
+}
+
+static void check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int val, int do_notify,
+ struct snd_kcontrol *sw)
+{
+ if (check_audio_gpio(gp) != val) {
write_audio_gpio(gp, val);
if (do_notify)
- snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &sw->id);
+ snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+ &sw->id);
}
}
static struct work_struct device_change;
-static void
-device_change_handler(void *self)
+static void device_change_handler(void *self)
{
- pmac_t *chip = (pmac_t*) self;
- pmac_tumbler_t *mix;
+ struct snd_pmac *chip = self;
+ struct pmac_tumbler *mix;
+ int headphone, lineout;
if (!chip)
return;
mix = chip->mixer_data;
+ snd_assert(mix, return);
- /* first set the DRC so the speaker do not explode -ReneR */
+ headphone = tumbler_detect_headphone(chip);
+ lineout = tumbler_detect_lineout(chip);
+
+ DBG("headphone: %d, lineout: %d\n", headphone, lineout);
+
+ if (headphone || lineout) {
+ /* unmute headphone/lineout & mute speaker */
+ if (headphone)
+ check_mute(chip, &mix->hp_mute, 0, mix->auto_mute_notify,
+ chip->master_sw_ctl);
+ if (lineout && mix->line_mute.addr != 0)
+ check_mute(chip, &mix->line_mute, 0, mix->auto_mute_notify,
+ chip->lineout_sw_ctl);
+ if (mix->anded_reset)
+ msleep(10);
+ check_mute(chip, &mix->amp_mute, 1, mix->auto_mute_notify,
+ chip->speaker_sw_ctl);
+ } else {
+ /* unmute speaker, mute others */
+ check_mute(chip, &mix->amp_mute, 0, mix->auto_mute_notify,
+ chip->speaker_sw_ctl);
+ if (mix->anded_reset)
+ msleep(10);
+ check_mute(chip, &mix->hp_mute, 1, mix->auto_mute_notify,
+ chip->master_sw_ctl);
+ if (mix->line_mute.addr != 0)
+ check_mute(chip, &mix->line_mute, 1, mix->auto_mute_notify,
+ chip->lineout_sw_ctl);
+ }
+ if (mix->auto_mute_notify)
+ snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+ &chip->hp_detect_ctl->id);
+
+#ifdef CONFIG_SND_POWERMAC_AUTO_DRC
+ mix->drc_enable = ! (headphone || lineout);
+ if (mix->auto_mute_notify)
+ snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+ &chip->drc_sw_ctl->id);
if (chip->model == PMAC_TUMBLER)
tumbler_set_drc(mix);
else
snapper_set_drc(mix);
+#endif
/* reset the master volume so the correct amplification is applied */
tumbler_set_master_volume(mix);
}
-static void tumbler_update_automute(pmac_t *chip, int do_notify)
+static void tumbler_update_automute(struct snd_pmac *chip, int do_notify)
{
if (chip->auto_mute) {
- pmac_tumbler_t *mix = chip->mixer_data;
+ struct pmac_tumbler *mix;
+ mix = chip->mixer_data;
snd_assert(mix, return);
- if (tumbler_detect_headphone(chip)) {
- /* mute speaker */
- check_mute(chip, &mix->amp_mute, 1, do_notify, chip->speaker_sw_ctl);
- check_mute(chip, &mix->hp_mute, 0, do_notify, chip->master_sw_ctl);
- mix->drc_enable = 0;
-
- } else {
- /* unmute speaker */
- check_mute(chip, &mix->amp_mute, 0, do_notify, chip->speaker_sw_ctl);
- check_mute(chip, &mix->hp_mute, 1, do_notify, chip->master_sw_ctl);
- mix->drc_enable = 1;
- }
- if (do_notify) {
- snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
- &chip->hp_detect_ctl->id);
- snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
- &chip->drc_sw_ctl->id);
- }
-
- /* finally we need to schedule an update of the mixer values
- (master and DRC are enough for now) -ReneR */
+ mix->auto_mute_notify = do_notify;
schedule_work(&device_change);
-
}
}
#endif /* PMAC_SUPPORT_AUTOMUTE */
/* interrupt - headphone plug changed */
static irqreturn_t headphone_intr(int irq, void *devid, struct pt_regs *regs)
{
- pmac_t *chip = devid;
+ struct snd_pmac *chip = devid;
if (chip->update_automute && chip->initialized) {
chip->update_automute(chip, 1);
return IRQ_HANDLED;
}
/* find an audio device and get its address */
-static unsigned long tumbler_find_device(const char *device, pmac_gpio_t *gp, int is_compatible)
+static long tumbler_find_device(const char *device, const char *platform,
+ struct pmac_gpio *gp, int is_compatible)
{
struct device_node *node;
- u32 *base;
+ u32 *base, addr;
if (is_compatible)
node = find_compatible_audio_device(device);
else
node = find_audio_device(device);
if (! node) {
+ DBG("(W) cannot find audio device %s !\n", device);
snd_printdd("cannot find device %s\n", device);
return -ENODEV;
}
base = (u32 *)get_property(node, "AAPL,address", NULL);
if (! base) {
- snd_printd("cannot find address for device %s\n", device);
- return -ENODEV;
- }
+ base = (u32 *)get_property(node, "reg", NULL);
+ if (!base) {
+ DBG("(E) cannot find address for device %s !\n", device);
+ snd_printd("cannot find address for device %s\n", device);
+ return -ENODEV;
+ }
+ addr = *base;
+ if (addr < 0x50)
+ addr += 0x50;
+ } else
+ addr = *base;
-#ifdef CONFIG_PPC_HAS_FEATURE_CALLS
- gp->addr = (*base) & 0x0000ffff;
-#else
- gp->addr = (void*)ioremap((unsigned long)(*base), 1);
-#endif
+ gp->addr = addr & 0x0000ffff;
+ /* Try to find the active state, default to 0 ! */
base = (u32 *)get_property(node, "audio-gpio-active-state", NULL);
- if (base)
+ if (base) {
gp->active_state = *base;
- else
- gp->active_state = 1;
+ gp->active_val = (*base) ? 0x5 : 0x4;
+ gp->inactive_val = (*base) ? 0x4 : 0x5;
+ } else {
+ u32 *prop = NULL;
+ gp->active_state = 0;
+ gp->active_val = 0x4;
+ gp->inactive_val = 0x5;
+ /* Here are some crude hacks to extract the GPIO polarity and
+ * open collector informations out of the do-platform script
+ * as we don't yet have an interpreter for these things
+ */
+ if (platform)
+ prop = (u32 *)get_property(node, platform, NULL);
+ if (prop) {
+ if (prop[3] == 0x9 && prop[4] == 0x9) {
+ gp->active_val = 0xd;
+ gp->inactive_val = 0xc;
+ }
+ if (prop[3] == 0x1 && prop[4] == 0x1) {
+ gp->active_val = 0x5;
+ gp->inactive_val = 0x4;
+ }
+ }
+ }
+ DBG("(I) GPIO device %s found, offset: %x, active state: %d !\n",
+ device, gp->addr, gp->active_state);
return (node->n_intrs > 0) ? node->intrs[0].line : 0;
}
/* reset audio */
-static void tumbler_reset_audio(pmac_t *chip)
+static void tumbler_reset_audio(struct snd_pmac *chip)
{
- pmac_tumbler_t *mix = chip->mixer_data;
-
- write_audio_gpio(&mix->audio_reset, 0);
- big_mdelay(200);
- write_audio_gpio(&mix->audio_reset, 1);
- big_mdelay(100);
- write_audio_gpio(&mix->audio_reset, 0);
- big_mdelay(100);
+ struct pmac_tumbler *mix = chip->mixer_data;
+
+ if (mix->anded_reset) {
+ DBG("(I) codec anded reset !\n");
+ write_audio_gpio(&mix->hp_mute, 0);
+ write_audio_gpio(&mix->amp_mute, 0);
+ msleep(200);
+ write_audio_gpio(&mix->hp_mute, 1);
+ write_audio_gpio(&mix->amp_mute, 1);
+ msleep(100);
+ write_audio_gpio(&mix->hp_mute, 0);
+ write_audio_gpio(&mix->amp_mute, 0);
+ msleep(100);
+ } else {
+ DBG("(I) codec normal reset !\n");
+
+ write_audio_gpio(&mix->audio_reset, 0);
+ msleep(200);
+ write_audio_gpio(&mix->audio_reset, 1);
+ msleep(100);
+ write_audio_gpio(&mix->audio_reset, 0);
+ msleep(100);
+ }
+}
+
+#ifdef CONFIG_PM
+/* suspend mixer */
+static void tumbler_suspend(struct snd_pmac *chip)
+{
+ struct pmac_tumbler *mix = chip->mixer_data;
+
+ if (mix->headphone_irq >= 0)
+ disable_irq(mix->headphone_irq);
+ if (mix->lineout_irq >= 0)
+ disable_irq(mix->lineout_irq);
+ mix->save_master_switch[0] = mix->master_switch[0];
+ mix->save_master_switch[1] = mix->master_switch[1];
+ mix->save_master_vol[0] = mix->master_vol[0];
+ mix->save_master_vol[1] = mix->master_vol[1];
+ mix->master_switch[0] = mix->master_switch[1] = 0;
+ tumbler_set_master_volume(mix);
+ if (!mix->anded_reset) {
+ write_audio_gpio(&mix->amp_mute, 1);
+ write_audio_gpio(&mix->hp_mute, 1);
+ }
+ if (chip->model == PMAC_SNAPPER) {
+ mix->acs |= 1;
+ i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
+ }
+ if (mix->anded_reset) {
+ write_audio_gpio(&mix->amp_mute, 1);
+ write_audio_gpio(&mix->hp_mute, 1);
+ } else
+ write_audio_gpio(&mix->audio_reset, 1);
}
-#ifdef CONFIG_PMAC_PBOOK
/* resume mixer */
-static void tumbler_resume(pmac_t *chip)
+static void tumbler_resume(struct snd_pmac *chip)
{
- pmac_tumbler_t *mix = chip->mixer_data;
+ struct pmac_tumbler *mix = chip->mixer_data;
snd_assert(mix, return);
+ mix->acs &= ~1;
+ mix->master_switch[0] = mix->save_master_switch[0];
+ mix->master_switch[1] = mix->save_master_switch[1];
+ mix->master_vol[0] = mix->save_master_vol[0];
+ mix->master_vol[1] = mix->save_master_vol[1];
tumbler_reset_audio(chip);
if (mix->i2c.client && mix->i2c.init_client) {
if (mix->i2c.init_client(&mix->i2c) < 0)
tumbler_set_master_volume(mix);
if (chip->update_automute)
chip->update_automute(chip, 0);
+ if (mix->headphone_irq >= 0) {
+ unsigned char val;
+
+ enable_irq(mix->headphone_irq);
+ /* activate headphone status interrupts */
+ val = do_gpio_read(&mix->hp_detect);
+ do_gpio_write(&mix->hp_detect, val | 0x80);
+ }
+ if (mix->lineout_irq >= 0)
+ enable_irq(mix->lineout_irq);
}
#endif
/* initialize tumbler */
-static int __init tumbler_init(pmac_t *chip)
+static int __init tumbler_init(struct snd_pmac *chip)
{
- int irq, err;
- pmac_tumbler_t *mix = chip->mixer_data;
+ int irq;
+ struct pmac_tumbler *mix = chip->mixer_data;
snd_assert(mix, return -EINVAL);
- tumbler_find_device("audio-hw-reset", &mix->audio_reset, 0);
- tumbler_find_device("amp-mute", &mix->amp_mute, 0);
- tumbler_find_device("headphone-mute", &mix->hp_mute, 0);
- irq = tumbler_find_device("headphone-detect", &mix->hp_detect, 0);
+ if (tumbler_find_device("audio-hw-reset",
+ "platform-do-hw-reset",
+ &mix->audio_reset, 0) < 0)
+ tumbler_find_device("hw-reset",
+ "platform-do-hw-reset",
+ &mix->audio_reset, 1);
+ if (tumbler_find_device("amp-mute",
+ "platform-do-amp-mute",
+ &mix->amp_mute, 0) < 0)
+ tumbler_find_device("amp-mute",
+ "platform-do-amp-mute",
+ &mix->amp_mute, 1);
+ if (tumbler_find_device("headphone-mute",
+ "platform-do-headphone-mute",
+ &mix->hp_mute, 0) < 0)
+ tumbler_find_device("headphone-mute",
+ "platform-do-headphone-mute",
+ &mix->hp_mute, 1);
+ if (tumbler_find_device("line-output-mute",
+ "platform-do-lineout-mute",
+ &mix->line_mute, 0) < 0)
+ tumbler_find_device("line-output-mute",
+ "platform-do-lineout-mute",
+ &mix->line_mute, 1);
+ irq = tumbler_find_device("headphone-detect",
+ NULL, &mix->hp_detect, 0);
if (irq < 0)
- irq = tumbler_find_device("keywest-gpio15", &mix->hp_detect, 1);
+ irq = tumbler_find_device("headphone-detect",
+ NULL, &mix->hp_detect, 1);
+ if (irq < 0)
+ irq = tumbler_find_device("keywest-gpio15",
+ NULL, &mix->hp_detect, 1);
+ mix->headphone_irq = irq;
+ irq = tumbler_find_device("line-output-detect",
+ NULL, &mix->line_detect, 0);
+ if (irq < 0)
+ irq = tumbler_find_device("line-output-detect",
+ NULL, &mix->line_detect, 1);
+ mix->lineout_irq = irq;
tumbler_reset_audio(chip);
-
- /* activate headphone status interrupts */
- if (irq >= 0) {
- unsigned char val;
- if ((err = request_irq(irq, headphone_intr, 0,
- "Tumbler Headphone Detection", chip)) < 0)
- return err;
- /* activate headphone status interrupts */
- val = do_gpio_read(&mix->hp_detect);
- do_gpio_write(&mix->hp_detect, val | 0x80);
- }
- mix->headphone_irq = irq;
return 0;
}
-static void tumbler_cleanup(pmac_t *chip)
+static void tumbler_cleanup(struct snd_pmac *chip)
{
- pmac_tumbler_t *mix = chip->mixer_data;
+ struct pmac_tumbler *mix = chip->mixer_data;
if (! mix)
return;
if (mix->headphone_irq >= 0)
free_irq(mix->headphone_irq, chip);
+ if (mix->lineout_irq >= 0)
+ free_irq(mix->lineout_irq, chip);
tumbler_gpio_free(&mix->audio_reset);
tumbler_gpio_free(&mix->amp_mute);
tumbler_gpio_free(&mix->hp_mute);
}
/* exported */
-int __init snd_pmac_tumbler_init(pmac_t *chip)
+int __init snd_pmac_tumbler_init(struct snd_pmac *chip)
{
int i, err;
- pmac_tumbler_t *mix;
+ struct pmac_tumbler *mix;
u32 *paddr;
- struct device_node *tas_node;
+ struct device_node *tas_node, *np;
char *chipname;
#ifdef CONFIG_KMOD
if (current->fs->root)
- request_module("i2c-keywest");
+ request_module("i2c-powermac");
#endif /* CONFIG_KMOD */
mix = kmalloc(sizeof(*mix), GFP_KERNEL);
chip->mixer_data = mix;
chip->mixer_free = tumbler_cleanup;
-
+ mix->anded_reset = 0;
+ mix->reset_on_sleep = 1;
+
+ for (np = chip->node->child; np; np = np->sibling) {
+ if (!strcmp(np->name, "sound")) {
+ if (get_property(np, "has-anded-reset", NULL))
+ mix->anded_reset = 1;
+ if (get_property(np, "layout-id", NULL))
+ mix->reset_on_sleep = 0;
+ break;
+ }
+ }
if ((err = tumbler_init(chip)) < 0)
return err;
/* set up TAS */
tas_node = find_devices("deq");
+ if (tas_node == NULL)
+ tas_node = find_devices("codec");
if (tas_node == NULL)
return -ENODEV;
paddr = (u32 *)get_property(tas_node, "i2c-address", NULL);
+ if (paddr == NULL)
+ paddr = (u32 *)get_property(tas_node, "reg", NULL);
if (paddr)
mix->i2c.addr = (*paddr) >> 1;
else
mix->i2c.addr = TAS_I2C_ADDR;
+ DBG("(I) TAS i2c address is: %x\n", mix->i2c.addr);
+
if (chip->model == PMAC_TUMBLER) {
mix->i2c.init_client = tumbler_init_client;
mix->i2c.name = "TAS3001c";
chip->speaker_sw_ctl = snd_ctl_new1(&tumbler_speaker_sw, chip);
if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
return err;
+ if (mix->line_mute.addr != 0) {
+ chip->lineout_sw_ctl = snd_ctl_new1(&tumbler_lineout_sw, chip);
+ if ((err = snd_ctl_add(chip->card, chip->lineout_sw_ctl)) < 0)
+ return err;
+ }
chip->drc_sw_ctl = snd_ctl_new1(&tumbler_drc_sw, chip);
if ((err = snd_ctl_add(chip->card, chip->drc_sw_ctl)) < 0)
return err;
+ /* set initial DRC range to 60% */
+ if (chip->model == PMAC_TUMBLER)
+ mix->drc_range = (TAS3001_DRC_MAX * 6) / 10;
+ else
+ mix->drc_range = (TAS3004_DRC_MAX * 6) / 10;
+ mix->drc_enable = 1; /* will be changed later if AUTO_DRC is set */
+ if (chip->model == PMAC_TUMBLER)
+ tumbler_set_drc(mix);
+ else
+ snapper_set_drc(mix);
-#ifdef CONFIG_PMAC_PBOOK
+#ifdef CONFIG_PM
+ chip->suspend = tumbler_suspend;
chip->resume = tumbler_resume;
#endif
INIT_WORK(&device_change, device_change_handler, (void *)chip);
#ifdef PMAC_SUPPORT_AUTOMUTE
- if (mix->headphone_irq >=0 && (err = snd_pmac_add_automute(chip)) < 0)
+ if ((mix->headphone_irq >=0 || mix->lineout_irq >= 0)
+ && (err = snd_pmac_add_automute(chip)) < 0)
return err;
chip->detect_headphone = tumbler_detect_headphone;
chip->update_automute = tumbler_update_automute;
tumbler_update_automute(chip, 0); /* update the status only */
+
+ /* activate headphone status interrupts */
+ if (mix->headphone_irq >= 0) {
+ unsigned char val;
+ if ((err = request_irq(mix->headphone_irq, headphone_intr, 0,
+ "Sound Headphone Detection", chip)) < 0)
+ return 0;
+ /* activate headphone status interrupts */
+ val = do_gpio_read(&mix->hp_detect);
+ do_gpio_write(&mix->hp_detect, val | 0x80);
+ }
+ if (mix->lineout_irq >= 0) {
+ unsigned char val;
+ if ((err = request_irq(mix->lineout_irq, headphone_intr, 0,
+ "Sound Lineout Detection", chip)) < 0)
+ return 0;
+ /* activate headphone status interrupts */
+ val = do_gpio_read(&mix->line_detect);
+ do_gpio_write(&mix->line_detect, val | 0x80);
+ }
#endif
return 0;