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