#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
};
typedef struct pmac_gpio {
-#ifdef CONFIG_PPC_HAS_FEATURE_CALLS
unsigned int addr;
-#else
- void __iomem *addr;
-#endif
- int active_state;
+ u8 active_val;
+ u8 inactive_val;
+ u8 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 line_mute;
+ pmac_gpio_t line_detect;
pmac_gpio_t hp_mute;
pmac_gpio_t 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;
+ int anded_reset;
+ int auto_mute_notify;
+ int reset_on_sleep;
+ u8 acs;
} pmac_tumbler_t;
regs[0], regs[1]);
if (err >= 0)
break;
+ DBG("(W) i2c error %d\n", err);
mdelay(10);
} while (count--);
if (err < 0)
TAS_REG_MCS, (1<<6)|(2<<4)|(2<<2)|0,
0, /* terminator */
};
+ DBG("(I) tumbler init client\n");
return send_init_client(i2c, regs);
}
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)
-{
- if (gp->addr) {
- iounmap(gp->addr);
- gp->addr = NULL;
- }
-}
-#endif /* CONFIG_PPC_HAS_FEATURE_CALLS */
static void write_audio_gpio(pmac_gpio_t *gp, int active)
{
if (! gp->addr)
return;
- active = active ? gp->active_state : !gp->active_state;
- do_gpio_write(gp, active ? 0x05 : 0x04);
+ active = active ? gp->active_val : gp->inactive_val;
+ do_gpio_write(gp, active);
+ DBG("(I) gpio %x write %d\n", gp->addr, active);
+}
+
+static int check_audio_gpio(pmac_gpio_t *gp)
+{
+ int ret;
+
+ if (! gp->addr)
+ return 0;
+
+ ret = do_gpio_read(gp);
+
+ return (ret & 0xd) == (gp->active_val & 0xd);
}
static int read_audio_gpio(pmac_gpio_t *gp)
/*
- * 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)
{
pmac_gpio_t *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;
}
#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;
{
if (! mix->i2c.client)
return -ENODEV;
- return i2c_smbus_write_byte_data(mix->i2c.client, 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)
.put = tumbler_put_mute_switch,
.private_value = TUMBLER_MUTE_AMP,
};
+static snd_kcontrol_new_t 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 snd_kcontrol_new_t tumbler_drc_sw __initdata = {
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
.name = "DRC Switch",
static int tumbler_detect_headphone(pmac_t *chip)
{
pmac_tumbler_t *mix = chip->mixer_data;
- return read_audio_gpio(&mix->hp_detect);
+ int detect = 0;
+
+ if (mix->hp_detect.addr)
+ detect |= read_audio_gpio(&mix->hp_detect);
+ return detect;
+}
+
+static int tumbler_detect_lineout(pmac_t *chip)
+{
+ pmac_tumbler_t *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(pmac_t *chip, pmac_gpio_t *gp, int val, int do_notify, snd_kcontrol_t *sw)
{
- //pmac_tumbler_t *mix = chip->mixer_data;
- if (val != read_audio_gpio(gp)) {
+ 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;
+ int headphone, lineout;
if (!chip)
return;
mix = chip->mixer_data;
+ snd_assert(mix, return);
+
+ 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)
+ big_mdelay(10);
+ check_mute(chip, &mix->amp_mute, 1, mix->auto_mute_notify,
+ chip->speaker_sw_ctl);
+ mix->drc_enable = 0;
+ } else {
+ /* unmute speaker, mute others */
+ check_mute(chip, &mix->amp_mute, 0, mix->auto_mute_notify,
+ chip->speaker_sw_ctl);
+ if (mix->anded_reset)
+ big_mdelay(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);
+ mix->drc_enable = 1;
+ }
+ if (mix->auto_mute_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);
+ }
/* first set the DRC so the speaker do not explode -ReneR */
if (chip->model == PMAC_TUMBLER)
static void tumbler_update_automute(pmac_t *chip, int do_notify)
{
if (chip->auto_mute) {
- pmac_tumbler_t *mix = chip->mixer_data;
+ pmac_tumbler_t *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 */
}
/* 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, pmac_gpio_t *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 = 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;
}
{
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);
+ if (mix->anded_reset) {
+ DBG("(I) codec anded reset !\n");
+ write_audio_gpio(&mix->hp_mute, 0);
+ write_audio_gpio(&mix->amp_mute, 0);
+ big_mdelay(200);
+ write_audio_gpio(&mix->hp_mute, 1);
+ write_audio_gpio(&mix->amp_mute, 1);
+ big_mdelay(100);
+ write_audio_gpio(&mix->hp_mute, 0);
+ write_audio_gpio(&mix->amp_mute, 0);
+ big_mdelay(100);
+ } else {
+ DBG("(I) codec normal reset !\n");
+
+ 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);
+ }
}
#ifdef CONFIG_PMAC_PBOOK
+/* suspend mixer */
+static void tumbler_suspend(pmac_t *chip)
+{
+ pmac_tumbler_t *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);
+}
+
/* resume mixer */
static void tumbler_resume(pmac_t *chip)
{
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)
+ enable_irq(mix->headphone_irq);
+ if (mix->lineout_irq >= 0)
+ enable_irq(mix->lineout_irq);
}
#endif
/* initialize tumbler */
static int __init tumbler_init(pmac_t *chip)
{
- int irq, err;
+ int irq;
pmac_tumbler_t *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("headphone-detect",
+ NULL, &mix->hp_detect, 1);
if (irq < 0)
- irq = tumbler_find_device("keywest-gpio15", &mix->hp_detect, 1);
+ 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;
}
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);
int i, err;
pmac_tumbler_t *mix;
u32 *paddr;
- struct device_node *tas_node;
+ struct device_node *tas_node, *np;
char *chipname;
#ifdef CONFIG_KMOD
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;
-
#ifdef CONFIG_PMAC_PBOOK
+ 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;
git://git.onelab.eu / linux-2.6.git / blobdiff