LXR linux/drivers/mfd/arizona-spi.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * arizona-spi.c  --  Arizona SPI bus interface
   4 *
   5 * Copyright 2012 Wolfson Microelectronics plc
   6 *
   7 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   8 */
   9
  10#include <linux/acpi.h>
  11#include <linux/err.h>
  12#include <linux/gpio/consumer.h>
  13#include <linux/gpio/machine.h>
  14#include <linux/module.h>
  15#include <linux/pm_runtime.h>
  16#include <linux/regmap.h>
  17#include <linux/regulator/consumer.h>
  18#include <linux/slab.h>
  19#include <linux/spi/spi.h>
  20#include <linux/of.h>
  21#include <uapi/linux/input-event-codes.h>
  22
  23#include <linux/mfd/arizona/core.h>
  24
  25#include "arizona.h"
  26
  27#ifdef CONFIG_ACPI
  28static const struct acpi_gpio_params reset_gpios = { 1, 0, false };
  29static const struct acpi_gpio_params ldoena_gpios = { 2, 0, false };
  30
  31static const struct acpi_gpio_mapping arizona_acpi_gpios[] = {
  32        { "reset-gpios", &reset_gpios, 1, },
  33        { "wlf,ldoena-gpios", &ldoena_gpios, 1 },
  34        { }
  35};
  36
  37/*
  38 * The ACPI resources for the device only describe external GPIO-s. They do
  39 * not provide mappings for the GPIO-s coming from the Arizona codec itself.
  40 */
  41static const struct gpiod_lookup arizona_soc_gpios[] = {
  42        { "arizona", 2, "wlf,spkvdd-ena", 0, GPIO_ACTIVE_HIGH },
  43        { "arizona", 4, "wlf,micd-pol", 0, GPIO_ACTIVE_LOW },
  44};
  45
  46/*
  47 * The AOSP 3.5 mm Headset: Accessory Specification gives the following values:
  48 * Function A Play/Pause:           0 ohm
  49 * Function D Voice assistant:    135 ohm
  50 * Function B Volume Up           240 ohm
  51 * Function C Volume Down         470 ohm
  52 * Minimum Mic DC resistance     1000 ohm
  53 * Minimum Ear speaker impedance   16 ohm
  54 * Note the first max value below must be less then the min. speaker impedance,
  55 * to allow CTIA/OMTP detection to work. The other max values are the closest
  56 * value from extcon-arizona.c:arizona_micd_levels halfway 2 button resistances.
  57 */
  58static const struct arizona_micd_range arizona_micd_aosp_ranges[] = {
  59        { .max =  11, .key = KEY_PLAYPAUSE },
  60        { .max = 186, .key = KEY_VOICECOMMAND },
  61        { .max = 348, .key = KEY_VOLUMEUP },
  62        { .max = 752, .key = KEY_VOLUMEDOWN },
  63};
  64
  65static void arizona_spi_acpi_remove_lookup(void *lookup)
  66{
  67        gpiod_remove_lookup_table(lookup);
  68}
  69
  70static int arizona_spi_acpi_probe(struct arizona *arizona)
  71{
  72        struct gpiod_lookup_table *lookup;
  73        acpi_status status;
  74        int ret;
  75
  76        /* Add mappings for the 2 ACPI declared GPIOs used for reset and ldo-ena */
  77        devm_acpi_dev_add_driver_gpios(arizona->dev, arizona_acpi_gpios);
  78
  79        /* Add lookups for the SoCs own GPIOs used for micdet-polarity and spkVDD-enable */
  80        lookup = devm_kzalloc(arizona->dev,
  81                              struct_size(lookup, table, ARRAY_SIZE(arizona_soc_gpios) + 1),
  82                              GFP_KERNEL);
  83        if (!lookup)
  84                return -ENOMEM;
  85
  86        lookup->dev_id = dev_name(arizona->dev);
  87        memcpy(lookup->table, arizona_soc_gpios, sizeof(arizona_soc_gpios));
  88
  89        gpiod_add_lookup_table(lookup);
  90        ret = devm_add_action_or_reset(arizona->dev, arizona_spi_acpi_remove_lookup, lookup);
  91        if (ret)
  92                return ret;
  93
  94        /* Enable 32KHz clock from SoC to codec for jack-detect */
  95        status = acpi_evaluate_object(ACPI_HANDLE(arizona->dev), "CLKE", NULL, NULL);
  96        if (ACPI_FAILURE(status))
  97                dev_warn(arizona->dev, "Failed to enable 32KHz clk ACPI error %d\n", status);
  98
  99        /*
 100         * Some DSDTs wrongly declare the IRQ trigger-type as IRQF_TRIGGER_FALLING
 101         * The IRQ line will stay low when a new IRQ event happens between reading
 102         * the IRQ status flags and acknowledging them. When the IRQ line stays
 103         * low like this the IRQ will never trigger again when its type is set
 104         * to IRQF_TRIGGER_FALLING. Correct the IRQ trigger-type to fix this.
 105         *
 106         * Note theoretically it is possible that some boards are not capable
 107         * of handling active low level interrupts. In that case setting the
 108         * flag to IRQF_TRIGGER_FALLING would not be a bug (and we would need
 109         * to work around this) but so far all known usages of IRQF_TRIGGER_FALLING
 110         * are a bug in the board's DSDT.
 111         */
 112        arizona->pdata.irq_flags = IRQF_TRIGGER_LOW;
 113
 114        /* Wait 200 ms after jack insertion */
 115        arizona->pdata.micd_detect_debounce = 200;
 116
 117        /* Use standard AOSP values for headset-button mappings */
 118        arizona->pdata.micd_ranges = arizona_micd_aosp_ranges;
 119        arizona->pdata.num_micd_ranges = ARRAY_SIZE(arizona_micd_aosp_ranges);
 120
 121        return 0;
 122}
 123
 124static const struct acpi_device_id arizona_acpi_match[] = {
 125        {
 126                .id = "WM510204",
 127                .driver_data = WM5102,
 128        },
 129        {
 130                .id = "WM510205",
 131                .driver_data = WM5102,
 132        },
 133        { }
 134};
 135MODULE_DEVICE_TABLE(acpi, arizona_acpi_match);
 136#else
 137static int arizona_spi_acpi_probe(struct arizona *arizona)
 138{
 139        return -ENODEV;
 140}
 141#endif
 142
 143static int arizona_spi_probe(struct spi_device *spi)
 144{
 145        const struct spi_device_id *id = spi_get_device_id(spi);
 146        const void *match_data;
 147        struct arizona *arizona;
 148        const struct regmap_config *regmap_config = NULL;
 149        unsigned long type = 0;
 150        int ret;
 151
 152        match_data = device_get_match_data(&spi->dev);
 153        if (match_data)
 154                type = (unsigned long)match_data;
 155        else if (id)
 156                type = id->driver_data;
 157
 158        switch (type) {
 159        case WM5102:
 160                if (IS_ENABLED(CONFIG_MFD_WM5102))
 161                        regmap_config = &wm5102_spi_regmap;
 162                break;
 163        case WM5110:
 164        case WM8280:
 165                if (IS_ENABLED(CONFIG_MFD_WM5110))
 166                        regmap_config = &wm5110_spi_regmap;
 167                break;
 168        case WM1831:
 169        case CS47L24:
 170                if (IS_ENABLED(CONFIG_MFD_CS47L24))
 171                        regmap_config = &cs47l24_spi_regmap;
 172                break;
 173        default:
 174                dev_err(&spi->dev, "Unknown device type %ld\n", type);
 175                return -EINVAL;
 176        }
 177
 178        if (!regmap_config) {
 179                dev_err(&spi->dev,
 180                        "No kernel support for device type %ld\n", type);
 181                return -EINVAL;
 182        }
 183
 184        arizona = devm_kzalloc(&spi->dev, sizeof(*arizona), GFP_KERNEL);
 185        if (arizona == NULL)
 186                return -ENOMEM;
 187
 188        arizona->regmap = devm_regmap_init_spi(spi, regmap_config);
 189        if (IS_ERR(arizona->regmap)) {
 190                ret = PTR_ERR(arizona->regmap);
 191                dev_err(&spi->dev, "Failed to allocate register map: %d\n",
 192                        ret);
 193                return ret;
 194        }
 195
 196        arizona->type = type;
 197        arizona->dev = &spi->dev;
 198        arizona->irq = spi->irq;
 199
 200        if (has_acpi_companion(&spi->dev)) {
 201                ret = arizona_spi_acpi_probe(arizona);
 202                if (ret)
 203                        return ret;
 204        }
 205
 206        return arizona_dev_init(arizona);
 207}
 208
 209static int arizona_spi_remove(struct spi_device *spi)
 210{
 211        struct arizona *arizona = spi_get_drvdata(spi);
 212
 213        arizona_dev_exit(arizona);
 214
 215        return 0;
 216}
 217
 218static const struct spi_device_id arizona_spi_ids[] = {
 219        { "wm5102", WM5102 },
 220        { "wm5110", WM5110 },
 221        { "wm8280", WM8280 },
 222        { "wm1831", WM1831 },
 223        { "cs47l24", CS47L24 },
 224        { },
 225};
 226MODULE_DEVICE_TABLE(spi, arizona_spi_ids);
 227
 228static struct spi_driver arizona_spi_driver = {
 229        .driver = {
 230                .name   = "arizona",
 231                .pm     = &arizona_pm_ops,
 232                .of_match_table = of_match_ptr(arizona_of_match),
 233                .acpi_match_table = ACPI_PTR(arizona_acpi_match),
 234        },
 235        .probe          = arizona_spi_probe,
 236        .remove         = arizona_spi_remove,
 237        .id_table       = arizona_spi_ids,
 238};
 239
 240module_spi_driver(arizona_spi_driver);
 241
 242MODULE_SOFTDEP("pre: arizona_ldo1");
 243MODULE_DESCRIPTION("Arizona SPI bus interface");
 244MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 245MODULE_LICENSE("GPL");
 246