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 <[email protected]>
   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                         return ret;
  68                 }
  69
  70                 /* Register is cached, drop it to ensure a physical read */
  71                 ret = regcache_drop_region(arizona->regmap, reg, reg);
  72                 if (ret < 0) {
  73                         dev_err(chip->parent, "Failed to drop cache: %d\n",
  74                                 ret);
  75                         return ret;
  76                 }
  77
  78                 ret = regmap_read(arizona->regmap, reg, &val);
  79                 if (ret < 0)
  80                         return ret;
  81
  82                 pm_runtime_mark_last_busy(chip->parent);
  83                 pm_runtime_put_autosuspend(chip->parent);
  84         }
  85
  86         if (val & ARIZONA_GPN_LVL)
  87                 return 1;
  88         else
  89                 return 0;
  90 }
  91
  92 static int arizona_gpio_direction_out(struct gpio_chip *chip,
  93                                      unsigned offset, int value)
  94 {
  95         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
  96         struct arizona *arizona = arizona_gpio->arizona;
  97         bool persistent = gpiochip_line_is_persistent(chip, offset);
  98         unsigned int val;
  99         int ret;
 100
 101         ret = regmap_read(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, &val);
 102         if (ret < 0)
 103                 return ret;
 104
 105         if ((val & ARIZONA_GPN_DIR) && persistent) {
 106                 ret = pm_runtime_get_sync(chip->parent);
 107                 if (ret < 0) {
 108                         dev_err(chip->parent, "Failed to resume: %d\n", ret);
 109                         return ret;
 110                 }
 111         }
 112
 113         if (value)
 114                 value = ARIZONA_GPN_LVL;
 115
 116         return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
 117                                   ARIZONA_GPN_DIR | ARIZONA_GPN_LVL, value);
 118 }
 119
 120 static void arizona_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 121 {
 122         struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
 123         struct arizona *arizona = arizona_gpio->arizona;
 124
 125         if (value)
 126                 value = ARIZONA_GPN_LVL;
 127
 128         regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
 129                            ARIZONA_GPN_LVL, value);
 130 }
 131
 132 static const struct gpio_chip template_chip = {
 133         .label                  = "arizona",
 134         .owner                  = THIS_MODULE,
 135         .direction_input        = arizona_gpio_direction_in,
 136         .get                    = arizona_gpio_get,
 137         .direction_output       = arizona_gpio_direction_out,
 138         .set                    = arizona_gpio_set,
 139         .can_sleep              = true,
 140 };
 141
 142 static int arizona_gpio_probe(struct platform_device *pdev)
 143 {
 144         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
 145         struct arizona_pdata *pdata = dev_get_platdata(arizona->dev);
 146         struct arizona_gpio *arizona_gpio;
 147         int ret;
 148
 149         arizona_gpio = devm_kzalloc(&pdev->dev, sizeof(*arizona_gpio),
 150                                     GFP_KERNEL);
 151         if (!arizona_gpio)
 152                 return -ENOMEM;
 153
 154         arizona_gpio->arizona = arizona;
 155         arizona_gpio->gpio_chip = template_chip;
 156         arizona_gpio->gpio_chip.parent = &pdev->dev;
 157 #ifdef CONFIG_OF_GPIO
 158         arizona_gpio->gpio_chip.of_node = arizona->dev->of_node;
 159 #endif
 160
 161         switch (arizona->type) {
 162         case WM5102:
 163         case WM5110:
 164         case WM8280:
 165         case WM8997:
 166         case WM8998:
 167         case WM1814:
 168                 arizona_gpio->gpio_chip.ngpio = 5;
 169                 break;
 170         case WM1831:
 171         case CS47L24:
 172                 arizona_gpio->gpio_chip.ngpio = 2;
 173                 break;
 174         default:
 175                 dev_err(&pdev->dev, "Unknown chip variant %d\n",
 176                         arizona->type);
 177                 return -EINVAL;
 178         }
 179
 180         if (pdata && pdata->gpio_base)
 181                 arizona_gpio->gpio_chip.base = pdata->gpio_base;
 182         else
 183                 arizona_gpio->gpio_chip.base = -1;
 184
 185         pm_runtime_enable(&pdev->dev);
 186
 187         ret = devm_gpiochip_add_data(&pdev->dev, &arizona_gpio->gpio_chip,
 188                                      arizona_gpio);
 189         if (ret < 0) {
 190                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
 191                         ret);
 192                 return ret;
 193         }
 194
 195         return 0;
 196 }
 197
 198 static struct platform_driver arizona_gpio_driver = {
 199         .driver.name    = "arizona-gpio",
 200         .probe          = arizona_gpio_probe,
 201 };
 202
 203 module_platform_driver(arizona_gpio_driver);
 204
 205 MODULE_AUTHOR("Mark Brown <[email protected]>");
 206 MODULE_DESCRIPTION("GPIO interface for Arizona devices");
 207 MODULE_LICENSE("GPL");
 208 MODULE_ALIAS("platform:arizona-gpio");