// SPDX-License-Identifier: GPL-2.0-only
/*
 * Support for gpio amplifier
 *   Copyright 2026 CS GROUP France
 *   Author: Herve Codina <herve.codina@bootlin.com>
 *
 * Basic simple amplifier driver
 *   Copyright (c) 2017 BayLibre, SAS.
 *   Author: Jerome Brunet <jbrunet@baylibre.com>
 */

#include <linux/bitmap.h>
#include <linux/bits.h>
#include <linux/gpio/consumer.h>
#include <linux/math.h>
#include <linux/minmax.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regulator/consumer.h>
#include <linux/slab.h>
#include <sound/soc.h>
#include <linux/sort.h>
#include <sound/tlv.h>

struct simple_amp_single {
        struct gpio_desc *gpio;
        bool is_inverted;
        int kctrl_val;
        const char *control_name;
};

struct simple_amp_point {
        u32 gpio_val;
        int gain_db;
};

struct simple_amp_range {
        unsigned int nb_points;
        struct simple_amp_point min;
        struct simple_amp_point max;
};

struct simple_amp_ranges {
        unsigned int nb_ranges;
        struct simple_amp_range *tab_ranges;
};

struct simple_amp_labels {
        unsigned int nb_labels;
        const char **tab_labels;
};

enum simple_amp_mode {
        SIMPLE_AMP_MODE_NONE,
        SIMPLE_AMP_MODE_RANGES,
        SIMPLE_AMP_MODE_LABELS,
};

struct simple_amp_multi {
        struct gpio_descs *gpios;
        u32 kctrl_val;
        u32 kctrl_max;
        const char *control_name;
        unsigned int *tlv_array;
        enum simple_amp_mode mode;
        union {
                struct simple_amp_ranges ranges;
                struct simple_amp_labels labels;
        };
};

struct simple_amp_data {
        unsigned int supports;
#define SIMPLE_AUDIO_SUPPORT_PGA                BIT(0)
#define SIMPLE_AUDIO_SUPPORT_POWER_SUPPLIES     BIT(1)
#define SIMPLE_AUDIO_SUPPORT_MUTE               BIT(2)
#define SIMPLE_AUDIO_SUPPORT_BYPASS             BIT(3)

        const struct snd_soc_dapm_widget *dapm_widgets;
        unsigned int num_dapm_widgets;
        const struct snd_soc_dapm_route *dapm_routes;
        unsigned int num_dapm_routes;
};

struct simple_amp {
        const struct simple_amp_data *data;
        struct gpio_desc *gpiod_enable;
        struct simple_amp_single mute;
        struct simple_amp_single bypass;
        struct simple_amp_multi gain;
};

static int simple_amp_power_event(struct snd_soc_dapm_widget *w,
                                  struct snd_kcontrol *control, int event)
{
        struct snd_soc_component *c = snd_soc_dapm_to_component(w->dapm);
        struct simple_amp *simple_amp = snd_soc_component_get_drvdata(c);
        int val;

        switch (event) {
        case SND_SOC_DAPM_POST_PMU:
                val = 1;
                break;
        case SND_SOC_DAPM_PRE_PMD:
                val = 0;
                break;
        default:
                WARN(1, "Unexpected event");
                return -EINVAL;
        }

        gpiod_set_value_cansleep(simple_amp->gpiod_enable, val);

        return 0;
}

static const struct snd_soc_dapm_widget simple_amp_dapm_widgets[] = {
        SND_SOC_DAPM_INPUT("INL"),
        SND_SOC_DAPM_INPUT("INR"),
        SND_SOC_DAPM_OUT_DRV_E("DRV", SND_SOC_NOPM, 0, 0, NULL, 0, simple_amp_power_event,
                               (SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD)),
        SND_SOC_DAPM_OUTPUT("OUTL"),
        SND_SOC_DAPM_OUTPUT("OUTR"),
        SND_SOC_DAPM_REGULATOR_SUPPLY("VCC", 20, 0),
};

static const struct snd_soc_dapm_route simple_amp_dapm_routes[] = {
        { "DRV", NULL, "INL" },
        { "DRV", NULL, "INR" },
        { "OUTL", NULL, "VCC" },
        { "OUTR", NULL, "VCC" },
        { "OUTL", NULL, "DRV" },
        { "OUTR", NULL, "DRV" },
};

static const struct snd_soc_dapm_widget simple_amp_mono_pga_dapm_widgets[] = {
        SND_SOC_DAPM_INPUT("IN"),
        SND_SOC_DAPM_OUTPUT("OUT"),
        SND_SOC_DAPM_PGA_E("PGA", SND_SOC_NOPM, 0, 0, NULL, 0, simple_amp_power_event,
                           (SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD)),
        SND_SOC_DAPM_REGULATOR_SUPPLY("vdd", 0, 0),
};

static const struct snd_soc_dapm_route simple_amp_mono_pga_dapm_routes[] = {
        { "PGA", NULL, "IN" },
        { "PGA", NULL, "vdd" },
        { "OUT", NULL, "PGA" },
};

static const struct snd_soc_dapm_widget simple_amp_stereo_pga_dapm_widgets[] = {
        SND_SOC_DAPM_INPUT("INL"),
        SND_SOC_DAPM_INPUT("INR"),
        SND_SOC_DAPM_OUTPUT("OUTL"),
        SND_SOC_DAPM_OUTPUT("OUTR"),
        SND_SOC_DAPM_PGA_E("PGA", SND_SOC_NOPM, 0, 0, NULL, 0, simple_amp_power_event,
                           (SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD)),
        SND_SOC_DAPM_REGULATOR_SUPPLY("vdd", 0, 0),
};

static const struct snd_soc_dapm_route simple_amp_stereo_pga_dapm_routes[] = {
        { "PGA", NULL, "INL" },
        { "PGA", NULL, "INR" },
        { "PGA", NULL, "vdd" },
        { "OUTL", NULL, "PGA" },
        { "OUTR", NULL, "PGA" },
};

static int simple_amp_single_kctrl_write_gpio(struct simple_amp_single *single,
                                              int kctrl_val)
{
        int gpio_val;

        gpio_val = single->is_inverted ? !kctrl_val : kctrl_val;

        return gpiod_set_value_cansleep(single->gpio, gpio_val);
}

static int simple_amp_single_kctrl_info(struct snd_kcontrol *kcontrol,
                                        struct snd_ctl_elem_info *uinfo)
{
        uinfo->count = 1;
        uinfo->value.integer.min = 0;
        uinfo->value.integer.max = 1;
        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
        return 0;
}

static int simple_amp_single_kctrl_get(struct snd_kcontrol *kcontrol,
                                       struct snd_ctl_elem_value *ucontrol)
{
        struct simple_amp_single *single = (struct simple_amp_single *)kcontrol->private_value;

        ucontrol->value.integer.value[0] = single->kctrl_val;

        return 0;
}

static int simple_amp_single_kctrl_put(struct snd_kcontrol *kcontrol,
                                       struct snd_ctl_elem_value *ucontrol)
{
        struct simple_amp_single *single = (struct simple_amp_single *)kcontrol->private_value;
        int kctrl_val;
        int err;

        kctrl_val = ucontrol->value.integer.value[0] ? 1 : 0;

        if (kctrl_val == single->kctrl_val)
                return 0;

        err = simple_amp_single_kctrl_write_gpio(single, kctrl_val);
        if (err)
                return err;

        single->kctrl_val = kctrl_val;

        return 1; /* The value changed */
}

static int simple_amp_single_add_kcontrol(struct snd_soc_component *component,
                                          struct simple_amp_single *single)
{
        struct snd_kcontrol_new control = {
                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                .name = single->control_name,
                .info = simple_amp_single_kctrl_info,
                .get = simple_amp_single_kctrl_get,
                .put = simple_amp_single_kctrl_put,
                .private_value = (unsigned long)single,
        };
        int ret;

        /* Be consistent between single->kctrl_val value and the GPIO value */
        ret = simple_amp_single_kctrl_write_gpio(single, single->kctrl_val);
        if (ret)
                return ret;

        return snd_soc_add_component_controls(component, &control, 1);
}

static u32 simple_amp_multi_ranges_kctrl_to_gpio(u32 kctrl_val,
                                                 struct simple_amp_ranges *ranges)
{
        struct simple_amp_range *range;
        u32 index = kctrl_val;
        unsigned int i;

        for (i = 0; i < ranges->nb_ranges; i++) {
                range = &ranges->tab_ranges[i];

                if (index < range->nb_points)
                        return (range->max.gpio_val >= range->min.gpio_val) ?
                                range->min.gpio_val + index :
                                range->min.gpio_val - index;

                index -= range->nb_points;
        }

        /*
         * Given index out of possible ranges. This is shouldn't happen.
         * Signal the issue and return the maximum value
         */
        WARN(1, "kctrl_val %u out of ranges\n", kctrl_val);
        return ranges->tab_ranges[ranges->nb_ranges - 1].max.gpio_val;
}

static int simple_amp_multi_kctrl_write_gpios(struct simple_amp_multi *multi,
                                              u32 kctrl_val)
{
        DECLARE_BITMAP(bm, 32);
        u32 gpio_val;

        if (kctrl_val > multi->kctrl_max)
                return -EINVAL;

        if (multi->mode == SIMPLE_AMP_MODE_RANGES)
                gpio_val = simple_amp_multi_ranges_kctrl_to_gpio(kctrl_val,
                                                                 &multi->ranges);
        else
                gpio_val = kctrl_val;

        bitmap_from_arr32(bm, &gpio_val, multi->gpios->ndescs);

        return gpiod_multi_set_value_cansleep(multi->gpios, bm);
}

static int simple_amp_multi_kctrl_int_info(struct snd_kcontrol *kcontrol,
                                           struct snd_ctl_elem_info *uinfo)
{
        struct simple_amp_multi *multi = (struct simple_amp_multi *)kcontrol->private_value;

        uinfo->count = 1;
        uinfo->value.integer.min = 0;
        uinfo->value.integer.max = multi->kctrl_max;
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
        return 0;
}

static int simple_amp_multi_kctrl_int_get(struct snd_kcontrol *kcontrol,
                                          struct snd_ctl_elem_value *ucontrol)
{
        struct simple_amp_multi *multi = (struct simple_amp_multi *)kcontrol->private_value;

        ucontrol->value.integer.value[0] = multi->kctrl_val;
        return 0;
}

static int simple_amp_multi_kctrl_int_put(struct snd_kcontrol *kcontrol,
                                          struct snd_ctl_elem_value *ucontrol)
{
        struct simple_amp_multi *multi = (struct simple_amp_multi *)kcontrol->private_value;
        u32 kctrl_val;
        int ret;

        kctrl_val = ucontrol->value.integer.value[0];

        if (kctrl_val == multi->kctrl_val)
                return 0;

        ret = simple_amp_multi_kctrl_write_gpios(multi, kctrl_val);
        if (ret)
                return ret;

        multi->kctrl_val = kctrl_val;

        return 1; /* The value changed */
}

static int simple_amp_multi_kctrl_enum_info(struct snd_kcontrol *kcontrol,
                                            struct snd_ctl_elem_info *uinfo)
{
        struct simple_amp_multi *multi = (struct simple_amp_multi *)kcontrol->private_value;

        return snd_ctl_enum_info(uinfo, 1, multi->labels.nb_labels,
                                 multi->labels.tab_labels);
}

static int simple_amp_multi_kctrl_enum_get(struct snd_kcontrol *kcontrol,
                                           struct snd_ctl_elem_value *ucontrol)
{
        struct simple_amp_multi *multi = (struct simple_amp_multi *)kcontrol->private_value;

        ucontrol->value.enumerated.item[0] = multi->kctrl_val;
        return 0;
}

static int simple_amp_multi_kctrl_enum_put(struct snd_kcontrol *kcontrol,
                                           struct snd_ctl_elem_value *ucontrol)
{
        struct simple_amp_multi *multi = (struct simple_amp_multi *)kcontrol->private_value;
        u32 kctrl_val;
        int ret;

        kctrl_val = ucontrol->value.enumerated.item[0];

        if (kctrl_val == multi->kctrl_val)
                return 0;

        ret = simple_amp_multi_kctrl_write_gpios(multi, kctrl_val);
        if (ret)
                return ret;

        multi->kctrl_val = kctrl_val;

        return 1; /* The value changed */
}

static unsigned int *simple_amp_alloc_tlv_ranges(const struct simple_amp_ranges *ranges)
{
        unsigned int index;
        unsigned int *tlv;
        unsigned int *t;
        unsigned int i;

        tlv = kzalloc_objs(*tlv, 2 + ranges->nb_ranges * 6, GFP_KERNEL);
        if (!tlv)
                return NULL;

        t = tlv;

        /* Fill first TLV */
        *t++ = SNDRV_CTL_TLVT_DB_RANGE; /* Tag */
        *t++ = ranges->nb_ranges * 6 * sizeof(*tlv); /* Len */
        /* Ranges are sorted from lower to higher value */
        index = 0;
        for (i = 0; i < ranges->nb_ranges; i++) {
                /* Fill range item i */
                *t++ = index;  /* min */
                index += ranges->tab_ranges[i].nb_points;
                *t++ = index - 1;  /* max */
                *t++ = SNDRV_CTL_TLVT_DB_MINMAX; /* Tag */
                *t++ = 2 * sizeof(*tlv); /* Len */
                *t++ = ranges->tab_ranges[i].min.gain_db; /* min_dB */
                *t++ = ranges->tab_ranges[i].max.gain_db; /* max_dB */
        }

        return tlv;
}

static int simple_amp_multi_add_kcontrol(struct snd_soc_component *component,
                                         struct simple_amp_multi *multi)
{
        struct snd_kcontrol_new control = {
                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                .name = multi->control_name,
                .info = simple_amp_multi_kctrl_int_info,
                .get = simple_amp_multi_kctrl_int_get,
                .put = simple_amp_multi_kctrl_int_put,
                .private_value = (unsigned long)multi,
        };
        int ret;

        switch (multi->mode) {
        case SIMPLE_AMP_MODE_RANGES:
                multi->tlv_array = simple_amp_alloc_tlv_ranges(&multi->ranges);
                if (!multi->tlv_array)
                        return -ENOMEM;

                control.access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |
                                 SNDRV_CTL_ELEM_ACCESS_READWRITE;
                control.tlv.p = multi->tlv_array;
                break;

        case SIMPLE_AMP_MODE_LABELS:
                /* Use enumerated values */
                control.info = simple_amp_multi_kctrl_enum_info;
                control.get = simple_amp_multi_kctrl_enum_get;
                control.put = simple_amp_multi_kctrl_enum_put;
                break;

        case SIMPLE_AMP_MODE_NONE:
                /* Already set control configuration is enough */
                break;

        default:
                return -EINVAL;
        }

        /* Be consistent between multi->kctrl_val value and the GPIOs value */
        ret = simple_amp_multi_kctrl_write_gpios(multi, multi->kctrl_val);
        if (ret)
                goto err_free_tlv_array;

        ret = snd_soc_add_component_controls(component, &control, 1);
        if (ret)
                goto err_free_tlv_array;

        return 0;

err_free_tlv_array:
        kfree(multi->tlv_array);
        return ret;
}

static int simple_amp_add_basic_dapm(struct snd_soc_component *component)
{
        struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
        struct simple_amp *simple_amp = snd_soc_component_get_drvdata(component);
        struct device *dev = component->dev;
        int ret;

        /* Add basic dapm widgets and routes */
        ret = snd_soc_dapm_new_controls(dapm, simple_amp->data->dapm_widgets,
                                        simple_amp->data->num_dapm_widgets);
        if (ret) {
                dev_err(dev, "Failed to add basic dapm widgets (%d)\n", ret);
                return ret;
        }

        ret = snd_soc_dapm_add_routes(dapm, simple_amp->data->dapm_routes,
                                      simple_amp->data->num_dapm_routes);
        if (ret) {
                dev_err(dev, "Failed to add basic dapm routes (%d)\n", ret);
                return ret;
        }

        return 0;
}

struct simple_amp_supply {
        const char *prop_name;
        const struct snd_soc_dapm_widget dapm_widget;
        const struct snd_soc_dapm_route dapm_route;
};

static const struct simple_amp_supply simple_amp_supplies[] = {
        {
                .prop_name = "vddio-supply",
                .dapm_widget = SND_SOC_DAPM_REGULATOR_SUPPLY("vddio", 0, 0),
                .dapm_route = { "PGA", NULL, "vddio" },
        }, {
                .prop_name = "vdda1-supply",
                .dapm_widget = SND_SOC_DAPM_REGULATOR_SUPPLY("vdda1", 0, 0),
                .dapm_route = { "PGA", NULL, "vdda1" },
        }, {
                .prop_name = "vdda2-supply",
                .dapm_widget = SND_SOC_DAPM_REGULATOR_SUPPLY("vdda2", 0, 0),
                .dapm_route = { "PGA", NULL, "vdda2" },
        },
        { /* End of list */}
};

static int simple_amp_add_power_supplies(struct snd_soc_component *component)
{
        struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
        struct simple_amp *simple_amp = snd_soc_component_get_drvdata(component);
        const struct simple_amp_supply *supply;
        struct device *dev = component->dev;
        int ret;

        /*
         * Those additional power supplies are attached to the PGA.
         * If PGA is not supported, simply skipped them.
         */
        if (!(simple_amp->data->supports & SIMPLE_AUDIO_SUPPORT_PGA)) {
                dev_err(dev, "Extra power supplied need PGA\n");
                return -EINVAL;
        }

        supply = simple_amp_supplies;
        do {
                if (!of_property_present(dev->of_node, supply->prop_name))
                        continue;

                ret = snd_soc_dapm_new_controls(dapm, &supply->dapm_widget, 1);
                if (ret) {
                        dev_err(dev, "Failed to add control for '%s' (%d)\n",
                                supply->prop_name, ret);
                        return ret;
                }
                ret = snd_soc_dapm_add_routes(dapm, &supply->dapm_route, 1);
                if (ret) {
                        dev_err(dev, "Failed to add route for '%s' (%d)\n",
                                supply->prop_name, ret);
                        return ret;
                }
        } while ((++supply)->prop_name);

        return 0;
}

static int simple_amp_component_probe(struct snd_soc_component *component)
{
        struct simple_amp *simple_amp = snd_soc_component_get_drvdata(component);
        int ret;

        /* Add basic dapm widgets and routes */
        ret = simple_amp_add_basic_dapm(component);
        if (ret)
                return ret;

        /* Add additional power supplies */
        if (simple_amp->data->supports & SIMPLE_AUDIO_SUPPORT_POWER_SUPPLIES) {
                ret = simple_amp_add_power_supplies(component);
                if (ret)
                        return ret;
        }

        if (simple_amp->mute.gpio) {
                /*
                 * The name of the GPIO used is mute. According to this name, 1
                 * means muted and 0 means un-muted.
                 *
                 * An inversion is expected by ALSA. Indeed from ALSA point of
                 * view, 1 means 'on' (un-muted) and 0 means 'off' (muted).
                 */
                simple_amp->mute.is_inverted = true;
                simple_amp->mute.kctrl_val = 1; /* Un-muted */
                ret = simple_amp_single_add_kcontrol(component, &simple_amp->mute);
                if (ret)
                        return ret;
        }

        if (simple_amp->bypass.gpio) {
                ret = simple_amp_single_add_kcontrol(component, &simple_amp->bypass);
                if (ret)
                        return ret;
        }

        if (simple_amp->gain.gpios) {
                ret = simple_amp_multi_add_kcontrol(component, &simple_amp->gain);
                if (ret)
                        return ret;
        }

        return 0;
}

static void simple_amp_component_remove(struct snd_soc_component *component)
{
        struct simple_amp *simple_amp = snd_soc_component_get_drvdata(component);

        kfree(simple_amp->gain.tlv_array);
        simple_amp->gain.tlv_array = NULL;
}

static const struct snd_soc_component_driver simple_amp_component_driver = {
        .probe = simple_amp_component_probe,
        .remove = simple_amp_component_remove,
};

static int simple_amp_parse_single_gpio(struct device *dev,
                                        struct simple_amp_single *single,
                                        const char *gpio_property)
{
        /* Start with the inactive value */
        single->is_inverted = false;
        single->kctrl_val = 0;
        single->gpio = devm_gpiod_get_optional(dev, gpio_property, GPIOD_OUT_LOW);
        if (IS_ERR(single->gpio))
                return dev_err_probe(dev, PTR_ERR(single->gpio),
                                     "Failed to get '%s' gpio\n",
                                     gpio_property);
        return 0;
}

static int simple_amp_cmp_ranges(const void *a, const void *b)
{
        const struct simple_amp_range *a_range = a;
        const struct simple_amp_range *b_range = b;

        /* Ranges a and b don't overlap. This has been already checked */

        return a_range->min.gain_db - b_range->max.gain_db;
}

static int simple_amp_check_new_range(const struct simple_amp_range *new_range,
                                      const struct simple_amp_range *tab_ranges,
                                      unsigned int nb_ranges)
{
        unsigned int i;

        for (i = 0; i < nb_ranges; i++) {
                /* Check for range overlaps */
                if (new_range->min.gain_db >= tab_ranges[i].min.gain_db &&
                    new_range->min.gain_db <= tab_ranges[i].max.gain_db)
                        return -EINVAL;

                if (new_range->max.gain_db >= tab_ranges[i].min.gain_db &&
                    new_range->max.gain_db <= tab_ranges[i].max.gain_db)
                        return -EINVAL;

                if (new_range->min.gain_db <= tab_ranges[i].min.gain_db &&
                    new_range->max.gain_db >= tab_ranges[i].max.gain_db)
                        return -EINVAL;
        }
        return 0;
}

static int simple_amp_parse_ranges(struct device *dev,
                                   struct simple_amp_multi *multi,
                                   const char *ranges_property)
{
        struct simple_amp_ranges *ranges = &multi->ranges;
        struct simple_amp_range *range;
        struct device_node *np = dev->of_node;
        struct simple_amp_point first_point;
        unsigned int max_gpio_val;
        unsigned int i;
        int ret;
        u32 u;
        s32 s;

        max_gpio_val = (1 << multi->gpios->ndescs) - 1;

        ret = of_property_count_u32_elems(np, ranges_property);
        if (ret < 0)
                return ret;

        /* The ranges array cannot be empty */
        if (ret == 0)
                return -EINVAL;
        /*
         * One range item is composed of 2 points and each point is composed of
         * 2 values.
         */
        if (ret % 4)
                return -EINVAL;

        ranges->nb_ranges = ret / 4;

        /* The worst case is one range per possible gpio value */
        if (ranges->nb_ranges > max_gpio_val + 1)
                return -EINVAL;

        ranges->tab_ranges = devm_kcalloc(dev, ranges->nb_ranges,
                                          sizeof(*ranges->tab_ranges),
                                          GFP_KERNEL);
        if (!ranges->tab_ranges)
                return -ENOMEM;

        multi->kctrl_max = 0;
        for (i = 0; i < ranges->nb_ranges; i++) {
                range = &ranges->tab_ranges[i];

                /* First gpios value */
                ret = of_property_read_u32_index(np, ranges_property, i * 4, &u);
                if (ret)
                        return ret;
                if (u > max_gpio_val)
                        return -EINVAL;

                range->min.gpio_val = u;

                /* First Gain value */
                ret = of_property_read_s32_index(np, ranges_property, i * 4 + 1, &s);
                if (ret)
                        return ret;

                range->min.gain_db = s;

                /* Second gpios value */
                ret = of_property_read_u32_index(np, ranges_property, i * 4 + 2, &u);
                if (ret)
                        return ret;
                if (u > max_gpio_val)
                        return -EINVAL;

                range->max.gpio_val = u;

                /* Second Gain value */
                ret = of_property_read_s32_index(np, ranges_property, i * 4 + 3, &s);
                if (ret)
                        return ret;

                range->max.gain_db = s;

                /* Save the first point for later usage */
                if (i == 0)
                        first_point = range->min;

                /* Fix min and max if needed */
                if (range->min.gain_db > range->max.gain_db)
                        swap(range->min, range->max);

                ret = simple_amp_check_new_range(range, ranges->tab_ranges, i);
                if (ret)
                        return ret;

                range->nb_points = abs_diff(range->min.gpio_val,
                                            range->max.gpio_val) + 1;

                multi->kctrl_max += range->nb_points;
        }

        multi->kctrl_max -= 1;

        /* Sort the tab_range array by gain_db value */
        sort(ranges->tab_ranges, ranges->nb_ranges, sizeof(*ranges->tab_ranges),
             simple_amp_cmp_ranges, NULL);

        /*
         * multi->kctrl_val is the index in tab_ranges.
         *
         * Choose to have the initial amplification value set to the first point
         * available in the first range available in the tab_ranges array before
         * sorting.
         *
         * This first point has been identified before sorting. Search for it in
         * the sorted array in order to set the multi->kctrl_val initial value.
         */
        multi->kctrl_val = 0;
        for (i = 0; i < ranges->nb_ranges; i++) {
                range = &ranges->tab_ranges[i];

                if (range->min.gpio_val == first_point.gpio_val &&
                    range->min.gain_db == first_point.gain_db)
                        break;

                multi->kctrl_val += range->nb_points;

                if (range->max.gpio_val == first_point.gpio_val &&
                    range->max.gain_db == first_point.gain_db) {
                        multi->kctrl_val--;
                        break;
                }
        }

        return 0;
}

static int simple_amp_parse_labels(struct device *dev,
                                   struct simple_amp_multi *multi,
                                   const char *labels_property)
{
        struct simple_amp_labels *labels = &multi->labels;
        struct device_node *np = dev->of_node;
        int ret;

        ret = of_property_count_strings(np, labels_property);
        if (ret < 0)
                return ret;

        /* The labels array cannot be empty */
        if (ret == 0)
                return -EINVAL;

        labels->nb_labels = ret;
        if (labels->nb_labels > (1 << multi->gpios->ndescs))
                return -EINVAL;

        labels->tab_labels = devm_kcalloc(dev, labels->nb_labels,
                                          sizeof(*labels->tab_labels),
                                          GFP_KERNEL);
        if (!labels->tab_labels)
                return -ENOMEM;

        multi->kctrl_max = labels->nb_labels - 1;
        multi->kctrl_val = 0;

        return of_property_read_string_array(np, labels_property, labels->tab_labels,
                                             labels->nb_labels);
}

static int simple_amp_parse_multi_gpio(struct device *dev,
                                       struct simple_amp_multi *multi,
                                       const char *gpios_property,
                                       const char *ranges_property,
                                       const char *labels_property)
{
        struct device_node *np = dev->of_node;
        int ret;

        /* Start with the value 0 (GPIO inactive). Can be changed later */
        multi->kctrl_val = 0;
        multi->gpios = devm_gpiod_get_array_optional(dev, gpios_property, GPIOD_OUT_LOW);
        if (IS_ERR(multi->gpios))
                return dev_err_probe(dev, PTR_ERR(multi->gpios),
                                     "Failed to get '%s' gpios\n",
                                     gpios_property);
        if (!multi->gpios)
                return 0;

        if (multi->gpios->ndescs > 16)
                return dev_err_probe(dev, -EINVAL,
                                     "Number of '%s' gpios limited to 16\n",
                                     gpios_property);

        /* Set default value for the kctrl_max. Can be changed later */
        multi->kctrl_max = (1 << multi->gpios->ndescs) - 1;

        multi->mode = SIMPLE_AMP_MODE_NONE;
        if (of_property_present(np, ranges_property)) {
                ret = simple_amp_parse_ranges(dev, multi, ranges_property);
                if (ret < 0)
                        return dev_err_probe(dev, ret, "Failed to parse '%s'\n",
                                             ranges_property);
                multi->mode = SIMPLE_AMP_MODE_RANGES;
        } else if (of_property_present(np, labels_property)) {
                ret = simple_amp_parse_labels(dev, multi, labels_property);
                if (ret < 0)
                        return dev_err_probe(dev, ret, "Failed to parse '%s'\n",
                                             labels_property);

                multi->mode = SIMPLE_AMP_MODE_LABELS;
        }

        return 0;
}

static int simple_amp_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct simple_amp *simple_amp;
        int ret;

        simple_amp = devm_kzalloc(dev, sizeof(*simple_amp), GFP_KERNEL);
        if (!simple_amp)
                return -ENOMEM;
        platform_set_drvdata(pdev, simple_amp);

        simple_amp->data = of_device_get_match_data(dev);
        if (!simple_amp->data)
                return -EINVAL;

        simple_amp->gpiod_enable = devm_gpiod_get_optional(dev, "enable",
                                                           GPIOD_OUT_LOW);
        if (IS_ERR(simple_amp->gpiod_enable))
                return dev_err_probe(dev, PTR_ERR(simple_amp->gpiod_enable),
                                     "Failed to get 'enable' gpio");

        if (simple_amp->data->supports & SIMPLE_AUDIO_SUPPORT_MUTE) {
                ret = simple_amp_parse_single_gpio(dev, &simple_amp->mute, "mute");
                if (ret)
                        return ret;
        }

        if (simple_amp->data->supports & SIMPLE_AUDIO_SUPPORT_BYPASS) {
                ret = simple_amp_parse_single_gpio(dev, &simple_amp->bypass, "bypass");
                if (ret)
                        return ret;
        }

        if (simple_amp->data->supports & SIMPLE_AUDIO_SUPPORT_PGA) {
                ret = simple_amp_parse_multi_gpio(dev, &simple_amp->gain, "gain",
                                                  "gain-ranges", "gain-labels");
                if (ret)
                        return ret;
        }

        /* Set controls name */
        simple_amp->gain.control_name = "Volume";
        simple_amp->mute.control_name = "Switch";
        simple_amp->bypass.control_name = "Bypass Switch";

        if (simple_amp->gain.mode == SIMPLE_AMP_MODE_LABELS) {
                /*
                 * The gain widget control will use enumerated values.
                 *
                 * Having just "Voltage" and "Switch" widget names with
                 * enumerated values and boolean value can confuse ALSA in terms
                 * of possible values (strings).
                 *
                 * Make things clear and avoid the just "Switch" name in that
                 * case.
                 */
                simple_amp->mute.control_name = "Out Switch";
        }

        return devm_snd_soc_register_component(dev,
                                               &simple_amp_component_driver,
                                               NULL, 0);
}

static const struct simple_amp_data simple_audio_amplifier_data = {
        .dapm_widgets           = simple_amp_dapm_widgets,
        .num_dapm_widgets       = ARRAY_SIZE(simple_amp_dapm_widgets),
        .dapm_routes            = simple_amp_dapm_routes,
        .num_dapm_routes        = ARRAY_SIZE(simple_amp_dapm_routes),
};

static const struct simple_amp_data simple_audio_mono_pga_data = {
        .supports               = SIMPLE_AUDIO_SUPPORT_PGA |
                                  SIMPLE_AUDIO_SUPPORT_POWER_SUPPLIES |
                                  SIMPLE_AUDIO_SUPPORT_MUTE |
                                  SIMPLE_AUDIO_SUPPORT_BYPASS,
        .dapm_widgets           = simple_amp_mono_pga_dapm_widgets,
        .num_dapm_widgets       = ARRAY_SIZE(simple_amp_mono_pga_dapm_widgets),
        .dapm_routes            = simple_amp_mono_pga_dapm_routes,
        .num_dapm_routes        = ARRAY_SIZE(simple_amp_mono_pga_dapm_routes),
};

static const struct simple_amp_data simple_audio_stereo_pga_data = {
        .supports               = SIMPLE_AUDIO_SUPPORT_PGA |
                                  SIMPLE_AUDIO_SUPPORT_POWER_SUPPLIES |
                                  SIMPLE_AUDIO_SUPPORT_MUTE |
                                  SIMPLE_AUDIO_SUPPORT_BYPASS,
        .dapm_widgets           = simple_amp_stereo_pga_dapm_widgets,
        .num_dapm_widgets       = ARRAY_SIZE(simple_amp_stereo_pga_dapm_widgets),
        .dapm_routes            = simple_amp_stereo_pga_dapm_routes,
        .num_dapm_routes        = ARRAY_SIZE(simple_amp_stereo_pga_dapm_routes),
};

static const struct of_device_id simple_amp_ids[] = {
        { .compatible = "dioo,dio2125",           .data = &simple_audio_amplifier_data},
        { .compatible = "simple-audio-amplifier", .data = &simple_audio_amplifier_data},
        { .compatible = "gpio-audio-amp-mono",    .data = &simple_audio_mono_pga_data},
        { .compatible = "gpio-audio-amp-stereo",  .data = &simple_audio_stereo_pga_data},
        { }
};
MODULE_DEVICE_TABLE(of, simple_amp_ids);

static struct platform_driver simple_amp_driver = {
        .driver = {
                .name = "simple-amplifier",
                .of_match_table = simple_amp_ids,
        },
        .probe = simple_amp_probe,
};

module_platform_driver(simple_amp_driver);

MODULE_DESCRIPTION("ASoC Simple Audio Amplifier driver");
MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
MODULE_AUTHOR("Herve Codina <herve.codina@bootlin.com>");
MODULE_LICENSE("GPL");