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