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
gpio_regmap_addr(unsigned int addr)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
gpio_regmap_simple_xlate(struct gpio_regmap * gpio,unsigned int base,unsigned int offset,unsigned int * reg,unsigned int * mask)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
gpio_regmap_get(struct gpio_chip * chip,unsigned int offset)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, ®, &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
gpio_regmap_set(struct gpio_chip * chip,unsigned int offset,int val)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, ®, &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
gpio_regmap_set_with_clear(struct gpio_chip * chip,unsigned int offset,int val)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, ®, &mask);
110 regmap_write(gpio->regmap, reg, mask);
111 }
112
gpio_regmap_get_direction(struct gpio_chip * chip,unsigned int offset)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, ®, &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
gpio_regmap_set_direction(struct gpio_chip * chip,unsigned int offset,bool output)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, ®, &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
gpio_regmap_direction_input(struct gpio_chip * chip,unsigned int offset)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
gpio_regmap_direction_output(struct gpio_chip * chip,unsigned int offset,int value)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
gpio_regmap_get_drvdata(struct gpio_regmap * gpio)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 */
gpio_regmap_register(const struct gpio_regmap_config * config)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 */
gpio_regmap_unregister(struct gpio_regmap * gpio)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
devm_gpio_regmap_unregister(void * res)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 */
devm_gpio_regmap_register(struct device * dev,const struct gpio_regmap_config * config)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");
346