drivers/gpio/gpio-arizona.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * gpiolib support for Wolfson Arizona class devices
   4  *
   5  * Copyright 2012 Wolfson Microelectronics PLC.
   6  *
   7  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/slab.h>
  12 #include <linux/module.h>
  13 #include <linux/gpio/driver.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/pm_runtime.h>
  16 #include <linux/seq_file.h>
  17
  18 #include <linux/mfd/arizona/core.h>
  19 #include <linux/mfd/arizona/pdata.h>
  20 #include <linux/mfd/arizona/registers.h>
  21
  22 struct arizona_gpio {
  23         struct arizona *arizona;
  24         struct gpio_chip gpio_chip;
  25 };
  26
  27 static int arizona_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
  28 {
  29         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
  30         struct arizona *arizona = arizona_gpio->arizona;
  31         bool persistent = gpiochip_line_is_persistent(chip, offset);
  32         bool change;
  33         int ret;
  34
  35         ret = regmap_update_bits_check(arizona->regmap,
  36                                        ARIZONA_GPIO1_CTRL + offset,
  37                                        ARIZONA_GPN_DIR, ARIZONA_GPN_DIR,
  38                                        &change);
  39         if (ret < 0)
  40                 return ret;
  41
  42         if (change && persistent) {
  43                 pm_runtime_mark_last_busy(chip->parent);
  44                 pm_runtime_put_autosuspend(chip->parent);
  45         }
  46
  47         return 0;
  48 }
  49
  50 static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset)
  51 {
  52         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
  53         struct arizona *arizona = arizona_gpio->arizona;
  54         unsigned int reg, val;
  55         int ret;
  56
  57         reg = ARIZONA_GPIO1_CTRL + offset;
  58         ret = regmap_read(arizona->regmap, reg, &val);
  59         if (ret < 0)
  60                 return ret;
  61
  62         /* Resume to read actual registers for input pins */
  63         if (val & ARIZONA_GPN_DIR) {
  64                 ret = pm_runtime_get_sync(chip->parent);
  65                 if (ret < 0) {
  66                         dev_err(chip->parent, "Failed to resume: %d\n", ret);
  67                         pm_runtime_put_autosuspend(chip->parent);
  68                         return ret;
  69                 }
  70
  71                 /* Register is cached, drop it to ensure a physical read */
  72                 ret = regcache_drop_region(arizona->regmap, reg, reg);
  73                 if (ret < 0) {
  74                         dev_err(chip->parent, "Failed to drop cache: %d\n",
  75                                 ret);
  76                         pm_runtime_put_autosuspend(chip->parent);
  77                         return ret;
  78                 }
  79
  80                 ret = regmap_read(arizona->regmap, reg, &val);
  81                 if (ret < 0) {
  82                         pm_runtime_put_autosuspend(chip->parent);
  83                         return ret;
  84                 }
  85
  86                 pm_runtime_mark_last_busy(chip->parent);
  87                 pm_runtime_put_autosuspend(chip->parent);
  88         }
  89
  90         if (val & ARIZONA_GPN_LVL)
  91                 return 1;
  92         else
  93                 return 0;
  94 }
  95
  96 static int arizona_gpio_direction_out(struct gpio_chip *chip,
  97                                      unsigned offset, int value)
  98 {
  99         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
 100         struct arizona *arizona = arizona_gpio->arizona;
 101         bool persistent = gpiochip_line_is_persistent(chip, offset);
 102         unsigned int val;
 103         int ret;
 104
 105         ret = regmap_read(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, &val);
 106         if (ret < 0)
 107                 return ret;
 108
 109         if ((val & ARIZONA_GPN_DIR) && persistent) {
 110                 ret = pm_runtime_get_sync(chip->parent);
 111                 if (ret < 0) {
 112                         dev_err(chip->parent, "Failed to resume: %d\n", ret);
 113                         pm_runtime_put(chip->parent);
 114                         return ret;
 115                 }
 116         }
 117
 118         if (value)
 119                 value = ARIZONA_GPN_LVL;
 120
 121         return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
 122                                   ARIZONA_GPN_DIR | ARIZONA_GPN_LVL, value);
 123 }
 124
 125 static void arizona_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 126 {
 127         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
 128         struct arizona *arizona = arizona_gpio->arizona;
 129
 130         if (value)
 131                 value = ARIZONA_GPN_LVL;
 132
 133         regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
 134                            ARIZONA_GPN_LVL, value);
 135 }
 136
 137 static const struct gpio_chip template_chip = {
 138         .label                  = "arizona",
 139         .owner                  = THIS_MODULE,
 140         .direction_input        = arizona_gpio_direction_in,
 141         .get                    = arizona_gpio_get,
 142         .direction_output       = arizona_gpio_direction_out,
 143         .set                    = arizona_gpio_set,
 144         .can_sleep              = true,
 145 };
 146
 147 static int arizona_gpio_probe(struct platform_device *pdev)
 148 {
 149         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
 150         struct arizona_pdata *pdata = &arizona->pdata;
 151         struct arizona_gpio *arizona_gpio;
 152         int ret;
 153
 154         device_set_node(&pdev->dev, dev_fwnode(pdev->dev.parent));
 155
 156         arizona_gpio = devm_kzalloc(&pdev->dev, sizeof(*arizona_gpio),
 157                                     GFP_KERNEL);
 158         if (!arizona_gpio)
 159                 return -ENOMEM;
 160
 161         arizona_gpio->arizona = arizona;
 162         arizona_gpio->gpio_chip = template_chip;
 163         arizona_gpio->gpio_chip.parent = &pdev->dev;
 164
 165         switch (arizona->type) {
 166         case WM5102:
 167         case WM5110:
 168         case WM8280:
 169         case WM8997:
 170         case WM8998:
 171         case WM1814:
 172                 arizona_gpio->gpio_chip.ngpio = 5;
 173                 break;
 174         case WM1831:
 175         case CS47L24:
 176                 arizona_gpio->gpio_chip.ngpio = 2;
 177                 break;
 178         default:
 179                 dev_err(&pdev->dev, "Unknown chip variant %d\n",
 180                         arizona->type);
 181                 return -EINVAL;
 182         }
 183
 184         if (pdata->gpio_base)
 185                 arizona_gpio->gpio_chip.base = pdata->gpio_base;
 186         else
 187                 arizona_gpio->gpio_chip.base = -1;
 188
 189         pm_runtime_enable(&pdev->dev);
 190
 191         ret = devm_gpiochip_add_data(&pdev->dev, &arizona_gpio->gpio_chip,
 192                                      arizona_gpio);
 193         if (ret < 0) {
 194                 pm_runtime_disable(&pdev->dev);
 195                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
 196                         ret);
 197                 return ret;
 198         }
 199
 200         return 0;
 201 }
 202
 203 static struct platform_driver arizona_gpio_driver = {
 204         .driver.name    = "arizona-gpio",
 205         .probe          = arizona_gpio_probe,
 206 };
 207
 208 module_platform_driver(arizona_gpio_driver);
 209
 210 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 211 MODULE_DESCRIPTION("GPIO interface for Arizona devices");
 212 MODULE_LICENSE("GPL");
 213 MODULE_ALIAS("platform:arizona-gpio");