soc-jack.c

Go to the documentation of this file.

/*
 * soc-jack.c  --  ALSA SoC jack handling
 *
 * Copyright 2008 Wolfson Microelectronics PLC.
 *
 * Author: Mark Brown <[email protected]>
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 */

#include <sound/jack.h>
#include <sound/soc.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/delay.h>
#include <linux/export.h>
#include <trace/events/asoc.h>

int snd_soc_jack_new(struct snd_soc_codec *codec, const char *id, int type,
             struct snd_soc_jack *jack)
{
    mutex_init(&jack->mutex);
    jack->codec = codec;
    INIT_LIST_HEAD(&jack->pins);
    INIT_LIST_HEAD(&jack->jack_zones);
    BLOCKING_INIT_NOTIFIER_HEAD(&jack->notifier);

    return snd_jack_new(codec->card->snd_card, id, type, &jack->jack);
}
EXPORT_SYMBOL_GPL(snd_soc_jack_new);

void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask)
{
    struct snd_soc_codec *codec;
    struct snd_soc_dapm_context *dapm;
    struct snd_soc_jack_pin *pin;
    int enable;
    int oldstatus;

    trace_snd_soc_jack_report(jack, mask, status);

    if (!jack)
        return;

    codec = jack->codec;
    dapm =  &codec->dapm;

    mutex_lock(&jack->mutex);

    oldstatus = jack->status;

    jack->status &= ~mask;
    jack->status |= status & mask;

    trace_snd_soc_jack_notify(jack, status);

    list_for_each_entry(pin, &jack->pins, list) {
        enable = pin->mask & jack->status;

        if (pin->invert)
            enable = !enable;

        if (enable)
            snd_soc_dapm_enable_pin(dapm, pin->pin);
        else
            snd_soc_dapm_disable_pin(dapm, pin->pin);
    }

    /* Report before the DAPM sync to help users updating micbias status */
    blocking_notifier_call_chain(&jack->notifier, jack->status, jack);

    snd_soc_dapm_sync(dapm);

    snd_jack_report(jack->jack, jack->status);

    mutex_unlock(&jack->mutex);
}
EXPORT_SYMBOL_GPL(snd_soc_jack_report);

int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count,
              struct snd_soc_jack_zone *zones)
{
    int i;

    for (i = 0; i < count; i++) {
        INIT_LIST_HEAD(&zones[i].list);
        list_add(&(zones[i].list), &jack->jack_zones);
    }
    return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_jack_add_zones);

int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage)
{
    struct snd_soc_jack_zone *zone;

    list_for_each_entry(zone, &jack->jack_zones, list) {
        if (micbias_voltage >= zone->min_mv &&
            micbias_voltage < zone->max_mv)
                return zone->jack_type;
    }
    return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_jack_get_type);

int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count,
              struct snd_soc_jack_pin *pins)
{
    int i;

    for (i = 0; i < count; i++) {
        if (!pins[i].pin) {
            printk(KERN_ERR "No name for pin %d\n", i);
            return -EINVAL;
        }
        if (!pins[i].mask) {
            printk(KERN_ERR "No mask for pin %d (%s)\n", i,
                   pins[i].pin);
            return -EINVAL;
        }

        INIT_LIST_HEAD(&pins[i].list);
        list_add(&(pins[i].list), &jack->pins);
    }

    snd_soc_dapm_new_widgets(&jack->codec->card->dapm);

    /* Update to reflect the last reported status; canned jack
     * implementations are likely to set their state before the
     * card has an opportunity to associate pins.
     */
    snd_soc_jack_report(jack, 0, 0);

    return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_jack_add_pins);

void snd_soc_jack_notifier_register(struct snd_soc_jack *jack,
                    struct notifier_block *nb)
{
    blocking_notifier_chain_register(&jack->notifier, nb);
}
EXPORT_SYMBOL_GPL(snd_soc_jack_notifier_register);

void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack,
                      struct notifier_block *nb)
{
    blocking_notifier_chain_unregister(&jack->notifier, nb);
}
EXPORT_SYMBOL_GPL(snd_soc_jack_notifier_unregister);

#ifdef CONFIG_GPIOLIB
/* gpio detect */
static void snd_soc_jack_gpio_detect(struct snd_soc_jack_gpio *gpio)
{
    struct snd_soc_jack *jack = gpio->jack;
    int enable;
    int report;

    enable = gpio_get_value_cansleep(gpio->gpio);
    if (gpio->invert)
        enable = !enable;

    if (enable)
        report = gpio->report;
    else
        report = 0;

    if (gpio->jack_status_check)
        report = gpio->jack_status_check();

    snd_soc_jack_report(jack, report, gpio->report);
}

/* irq handler for gpio pin */
static irqreturn_t gpio_handler(int irq, void *data)
{
    struct snd_soc_jack_gpio *gpio = data;
    struct device *dev = gpio->jack->codec->card->dev;

    trace_snd_soc_jack_irq(gpio->name);

    if (device_may_wakeup(dev))
        pm_wakeup_event(dev, gpio->debounce_time + 50);

    schedule_delayed_work(&gpio->work,
                  msecs_to_jiffies(gpio->debounce_time));

    return IRQ_HANDLED;
}

/* gpio work */
static void gpio_work(struct work_struct *work)
{
    struct snd_soc_jack_gpio *gpio;

    gpio = container_of(work, struct snd_soc_jack_gpio, work.work);
    snd_soc_jack_gpio_detect(gpio);
}

int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count,
            struct snd_soc_jack_gpio *gpios)
{
    int i, ret;

    for (i = 0; i < count; i++) {
        if (!gpio_is_valid(gpios[i].gpio)) {
            printk(KERN_ERR "Invalid gpio %d\n",
                gpios[i].gpio);
            ret = -EINVAL;
            goto undo;
        }
        if (!gpios[i].name) {
            printk(KERN_ERR "No name for gpio %d\n",
                gpios[i].gpio);
            ret = -EINVAL;
            goto undo;
        }

        ret = gpio_request(gpios[i].gpio, gpios[i].name);
        if (ret)
            goto undo;

        ret = gpio_direction_input(gpios[i].gpio);
        if (ret)
            goto err;

        INIT_DELAYED_WORK(&gpios[i].work, gpio_work);
        gpios[i].jack = jack;

        ret = request_any_context_irq(gpio_to_irq(gpios[i].gpio),
                          gpio_handler,
                          IRQF_TRIGGER_RISING |
                          IRQF_TRIGGER_FALLING,
                          gpios[i].name,
                          &gpios[i]);
        if (ret < 0)
            goto err;

        if (gpios[i].wake) {
            ret = irq_set_irq_wake(gpio_to_irq(gpios[i].gpio), 1);
            if (ret != 0)
                printk(KERN_ERR
                  "Failed to mark GPIO %d as wake source: %d\n",
                    gpios[i].gpio, ret);
        }

        /* Expose GPIO value over sysfs for diagnostic purposes */
        gpio_export(gpios[i].gpio, false);

        /* Update initial jack status */
        snd_soc_jack_gpio_detect(&gpios[i]);
    }

    return 0;

err:
    gpio_free(gpios[i].gpio);
undo:
    snd_soc_jack_free_gpios(jack, i, gpios);

    return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_jack_add_gpios);

void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count,
            struct snd_soc_jack_gpio *gpios)
{
    int i;

    for (i = 0; i < count; i++) {
        gpio_unexport(gpios[i].gpio);
        free_irq(gpio_to_irq(gpios[i].gpio), &gpios[i]);
        cancel_delayed_work_sync(&gpios[i].work);
        gpio_free(gpios[i].gpio);
        gpios[i].jack = NULL;
    }
}
EXPORT_SYMBOL_GPL(snd_soc_jack_free_gpios);
#endif  /* CONFIG_GPIOLIB */