drivers/gpio/gpio-regmap.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * regmap based generic GPIO driver
   4  *
   5  * Copyright 2020 Michael Walle <michael@walle.cc>
   6  */
   7
   8 #include <linux/bits.h>
   9 #include <linux/device.h>
  10 #include <linux/err.h>
  11 #include <linux/io.h>
  12 #include <linux/module.h>
  13 #include <linux/regmap.h>
  14 #include <linux/slab.h>
  15 #include <linux/types.h>
  16
  17 #include <linux/gpio/driver.h>
  18 #include <linux/gpio/regmap.h>
  19
  20 struct gpio_regmap {
  21         struct device *parent;
  22         struct regmap *regmap;
  23         struct gpio_chip gpio_chip;
  24
  25         int reg_stride;
  26         int ngpio_per_reg;
  27         unsigned int reg_dat_base;
  28         unsigned int reg_set_base;
  29         unsigned int reg_clr_base;
  30         unsigned int reg_dir_in_base;
  31         unsigned int reg_dir_out_base;
  32
  33         int (*reg_mask_xlate)(struct gpio_regmap *gpio, unsigned int base,
  34                               unsigned int offset, unsigned int *reg,
  35                               unsigned int *mask);
  36
  37         void *driver_data;
  38 };
  39
  40 static unsigned int gpio_regmap_addr(unsigned int addr)
  41 {
  42         if (addr == GPIO_REGMAP_ADDR_ZERO)
  43                 return 0;
  44
  45         return addr;
  46 }
  47
  48 static int gpio_regmap_simple_xlate(struct gpio_regmap *gpio,
  49                                     unsigned int base, unsigned int offset,
  50                                     unsigned int *reg, unsigned int *mask)
  51 {
  52         unsigned int line = offset % gpio->ngpio_per_reg;
  53         unsigned int stride = offset / gpio->ngpio_per_reg;
  54
  55         *reg = base + stride * gpio->reg_stride;
  56         *mask = BIT(line);
  57
  58         return 0;
  59 }
  60
  61 static int gpio_regmap_get(struct gpio_chip *chip, unsigned int offset)
  62 {
  63         struct gpio_regmap *gpio = gpiochip_get_data(chip);
  64         unsigned int base, val, reg, mask;
  65         int ret;
  66
  67         /* we might not have an output register if we are input only */
  68         if (gpio->reg_dat_base)
  69                 base = gpio_regmap_addr(gpio->reg_dat_base);
  70         else
  71                 base = gpio_regmap_addr(gpio->reg_set_base);
  72
  73         ret = gpio->reg_mask_xlate(gpio, base, offset, &reg, &mask);
  74         if (ret)
  75                 return ret;
  76
  77         ret = regmap_read(gpio->regmap, reg, &val);
  78         if (ret)
  79                 return ret;
  80
  81         return !!(val & mask);
  82 }
  83
  84 static void gpio_regmap_set(struct gpio_chip *chip, unsigned int offset,
  85                             int val)
  86 {
  87         struct gpio_regmap *gpio = gpiochip_get_data(chip);
  88         unsigned int base = gpio_regmap_addr(gpio->reg_set_base);
  89         unsigned int reg, mask;
  90
  91         gpio->reg_mask_xlate(gpio, base, offset, &reg, &mask);
  92         if (val)
  93                 regmap_update_bits(gpio->regmap, reg, mask, mask);
  94         else
  95                 regmap_update_bits(gpio->regmap, reg, mask, 0);
  96 }
  97
  98 static void gpio_regmap_set_with_clear(struct gpio_chip *chip,
  99                                        unsigned int offset, int val)
 100 {
 101         struct gpio_regmap *gpio = gpiochip_get_data(chip);
 102         unsigned int base, reg, mask;
 103
 104         if (val)
 105                 base = gpio_regmap_addr(gpio->reg_set_base);
 106         else
 107                 base = gpio_regmap_addr(gpio->reg_clr_base);
 108
 109         gpio->reg_mask_xlate(gpio, base, offset, &reg, &mask);
 110         regmap_write(gpio->regmap, reg, mask);
 111 }
 112
 113 static int gpio_regmap_get_direction(struct gpio_chip *chip,
 114                                      unsigned int offset)
 115 {
 116         struct gpio_regmap *gpio = gpiochip_get_data(chip);
 117         unsigned int base, val, reg, mask;
 118         int invert, ret;
 119
 120         if (gpio->reg_dat_base && !gpio->reg_set_base)
 121                 return GPIO_LINE_DIRECTION_IN;
 122         if (gpio->reg_set_base && !gpio->reg_dat_base)
 123                 return GPIO_LINE_DIRECTION_OUT;
 124
 125         if (gpio->reg_dir_out_base) {
 126                 base = gpio_regmap_addr(gpio->reg_dir_out_base);
 127                 invert = 0;
 128         } else if (gpio->reg_dir_in_base) {
 129                 base = gpio_regmap_addr(gpio->reg_dir_in_base);
 130                 invert = 1;
 131         } else {
 132                 return -ENOTSUPP;
 133         }
 134
 135         ret = gpio->reg_mask_xlate(gpio, base, offset, &reg, &mask);
 136         if (ret)
 137                 return ret;
 138
 139         ret = regmap_read(gpio->regmap, reg, &val);
 140         if (ret)
 141                 return ret;
 142
 143         if (!!(val & mask) ^ invert)
 144                 return GPIO_LINE_DIRECTION_OUT;
 145         else
 146                 return GPIO_LINE_DIRECTION_IN;
 147 }
 148
 149 static int gpio_regmap_set_direction(struct gpio_chip *chip,
 150                                      unsigned int offset, bool output)
 151 {
 152         struct gpio_regmap *gpio = gpiochip_get_data(chip);
 153         unsigned int base, val, reg, mask;
 154         int invert, ret;
 155
 156         if (gpio->reg_dir_out_base) {
 157                 base = gpio_regmap_addr(gpio->reg_dir_out_base);
 158                 invert = 0;
 159         } else if (gpio->reg_dir_in_base) {
 160                 base = gpio_regmap_addr(gpio->reg_dir_in_base);
 161                 invert = 1;
 162         } else {
 163                 return -ENOTSUPP;
 164         }
 165
 166         ret = gpio->reg_mask_xlate(gpio, base, offset, &reg, &mask);
 167         if (ret)
 168                 return ret;
 169
 170         if (invert)
 171                 val = output ? 0 : mask;
 172         else
 173                 val = output ? mask : 0;
 174
 175         return regmap_update_bits(gpio->regmap, reg, mask, val);
 176 }
 177
 178 static int gpio_regmap_direction_input(struct gpio_chip *chip,
 179                                        unsigned int offset)
 180 {
 181         return gpio_regmap_set_direction(chip, offset, false);
 182 }
 183
 184 static int gpio_regmap_direction_output(struct gpio_chip *chip,
 185                                         unsigned int offset, int value)
 186 {
 187         gpio_regmap_set(chip, offset, value);
 188
 189         return gpio_regmap_set_direction(chip, offset, true);
 190 }
 191
 192 void *gpio_regmap_get_drvdata(struct gpio_regmap *gpio)
 193 {
 194         return gpio->driver_data;
 195 }
 196 EXPORT_SYMBOL_GPL(gpio_regmap_get_drvdata);
 197
 198 /**
 199  * gpio_regmap_register() - Register a generic regmap GPIO controller
 200  * @config: configuration for gpio_regmap
 201  *
 202  * Return: A pointer to the registered gpio_regmap or ERR_PTR error value.
 203  */
 204 struct gpio_regmap *gpio_regmap_register(const struct gpio_regmap_config *config)
 205 {
 206         struct gpio_regmap *gpio;
 207         struct gpio_chip *chip;
 208         int ret;
 209
 210         if (!config->parent)
 211                 return ERR_PTR(-EINVAL);
 212
 213         if (!config->ngpio)
 214                 return ERR_PTR(-EINVAL);
 215
 216         /* we need at least one */
 217         if (!config->reg_dat_base && !config->reg_set_base)
 218                 return ERR_PTR(-EINVAL);
 219
 220         /* if we have a direction register we need both input and output */
 221         if ((config->reg_dir_out_base || config->reg_dir_in_base) &&
 222             (!config->reg_dat_base || !config->reg_set_base))
 223                 return ERR_PTR(-EINVAL);
 224
 225         /* we don't support having both registers simultaneously for now */
 226         if (config->reg_dir_out_base && config->reg_dir_in_base)
 227                 return ERR_PTR(-EINVAL);
 228
 229         gpio = kzalloc(sizeof(*gpio), GFP_KERNEL);
 230         if (!gpio)
 231                 return ERR_PTR(-ENOMEM);
 232
 233         gpio->parent = config->parent;
 234         gpio->driver_data = config->drvdata;
 235         gpio->regmap = config->regmap;
 236         gpio->ngpio_per_reg = config->ngpio_per_reg;
 237         gpio->reg_stride = config->reg_stride;
 238         gpio->reg_mask_xlate = config->reg_mask_xlate;
 239         gpio->reg_dat_base = config->reg_dat_base;
 240         gpio->reg_set_base = config->reg_set_base;
 241         gpio->reg_clr_base = config->reg_clr_base;
 242         gpio->reg_dir_in_base = config->reg_dir_in_base;
 243         gpio->reg_dir_out_base = config->reg_dir_out_base;
 244
 245         /* if not set, assume there is only one register */
 246         if (!gpio->ngpio_per_reg)
 247                 gpio->ngpio_per_reg = config->ngpio;
 248
 249         /* if not set, assume they are consecutive */
 250         if (!gpio->reg_stride)
 251                 gpio->reg_stride = 1;
 252
 253         if (!gpio->reg_mask_xlate)
 254                 gpio->reg_mask_xlate = gpio_regmap_simple_xlate;
 255
 256         chip = &gpio->gpio_chip;
 257         chip->parent = config->parent;
 258         chip->fwnode = config->fwnode;
 259         chip->base = -1;
 260         chip->ngpio = config->ngpio;
 261         chip->names = config->names;
 262         chip->label = config->label ?: dev_name(config->parent);
 263         chip->can_sleep = regmap_might_sleep(config->regmap);
 264
 265         chip->get = gpio_regmap_get;
 266         if (gpio->reg_set_base && gpio->reg_clr_base)
 267                 chip->set = gpio_regmap_set_with_clear;
 268         else if (gpio->reg_set_base)
 269                 chip->set = gpio_regmap_set;
 270
 271         chip->get_direction = gpio_regmap_get_direction;
 272         if (gpio->reg_dir_in_base || gpio->reg_dir_out_base) {
 273                 chip->direction_input = gpio_regmap_direction_input;
 274                 chip->direction_output = gpio_regmap_direction_output;
 275         }
 276
 277         ret = gpiochip_add_data(chip, gpio);
 278         if (ret < 0)
 279                 goto err_free_gpio;
 280
 281         if (config->irq_domain) {
 282                 ret = gpiochip_irqchip_add_domain(chip, config->irq_domain);
 283                 if (ret)
 284                         goto err_remove_gpiochip;
 285         }
 286
 287         return gpio;
 288
 289 err_remove_gpiochip:
 290         gpiochip_remove(chip);
 291 err_free_gpio:
 292         kfree(gpio);
 293         return ERR_PTR(ret);
 294 }
 295 EXPORT_SYMBOL_GPL(gpio_regmap_register);
 296
 297 /**
 298  * gpio_regmap_unregister() - Unregister a generic regmap GPIO controller
 299  * @gpio: gpio_regmap device to unregister
 300  */
 301 void gpio_regmap_unregister(struct gpio_regmap *gpio)
 302 {
 303         gpiochip_remove(&gpio->gpio_chip);
 304         kfree(gpio);
 305 }
 306 EXPORT_SYMBOL_GPL(gpio_regmap_unregister);
 307
 308 static void devm_gpio_regmap_unregister(void *res)
 309 {
 310         gpio_regmap_unregister(res);
 311 }
 312
 313 /**
 314  * devm_gpio_regmap_register() - resource managed gpio_regmap_register()
 315  * @dev: device that is registering this GPIO device
 316  * @config: configuration for gpio_regmap
 317  *
 318  * Managed gpio_regmap_register(). For generic regmap GPIO device registered by
 319  * this function, gpio_regmap_unregister() is automatically called on driver
 320  * detach. See gpio_regmap_register() for more information.
 321  *
 322  * Return: A pointer to the registered gpio_regmap or ERR_PTR error value.
 323  */
 324 struct gpio_regmap *devm_gpio_regmap_register(struct device *dev,
 325                                               const struct gpio_regmap_config *config)
 326 {
 327         struct gpio_regmap *gpio;
 328         int ret;
 329
 330         gpio = gpio_regmap_register(config);
 331
 332         if (IS_ERR(gpio))
 333                 return gpio;
 334
 335         ret = devm_add_action_or_reset(dev, devm_gpio_regmap_unregister, gpio);
 336         if (ret)
 337                 return ERR_PTR(ret);
 338
 339         return gpio;
 340 }
 341 EXPORT_SYMBOL_GPL(devm_gpio_regmap_register);
 342
 343 MODULE_AUTHOR("Michael Walle <michael@walle.cc>");
 344 MODULE_DESCRIPTION("GPIO generic regmap driver core");
 345 MODULE_LICENSE("GPL");