1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) 2025 Linaro Ltd.
4 */
5
6#include <linux/auxiliary_bus.h>
7#include <linux/cleanup.h>
8#include <linux/device.h>
9#include <linux/err.h>
10#include <linux/gpio/consumer.h>
11#include <linux/gpio/driver.h>
12#include <linux/mod_devicetable.h>
13#include <linux/module.h>
14#include <linux/string_choices.h>
15#include <linux/types.h>
16
17#include "gpiolib-shared.h"
18
19struct gpio_shared_proxy_data {
20 struct gpio_chip gc;
21 struct gpio_shared_desc *shared_desc;
22 struct device *dev;
23 bool voted_high;
24};
25
26static int
27gpio_shared_proxy_set_unlocked(struct gpio_shared_proxy_data *proxy,
28 int (*set_func)(struct gpio_desc *desc, int value),
29 int value)
30{
31 struct gpio_shared_desc *shared_desc = proxy->shared_desc;
32 struct gpio_desc *desc = shared_desc->desc;
33 int ret = 0;
34
35 gpio_shared_lockdep_assert(shared_desc);
36
37 if (value) {
38 /* User wants to set value to high. */
39 if (proxy->voted_high)
40 /* Already voted for high, nothing to do. */
41 goto out;
42
43 /* Haven't voted for high yet. */
44 if (!shared_desc->highcnt) {
45 /*
46 * Current value is low, need to actually set value
47 * to high.
48 */
49 ret = set_func(desc, 1);
50 if (ret)
51 goto out;
52 }
53
54 shared_desc->highcnt++;
55 proxy->voted_high = true;
56
57 goto out;
58 }
59
60 /* Desired value is low. */
61 if (!proxy->voted_high)
62 /* We didn't vote for high, nothing to do. */
63 goto out;
64
65 /* We previously voted for high. */
66 if (shared_desc->highcnt == 1) {
67 /* This is the last remaining vote for high, set value to low. */
68 ret = set_func(desc, 0);
69 if (ret)
70 goto out;
71 }
72
73 shared_desc->highcnt--;
74 proxy->voted_high = false;
75
76out:
77 if (shared_desc->highcnt)
78 dev_dbg(proxy->dev,
79 "Voted for value '%s', effective value is 'high', number of votes for 'high': %u\n",
80 str_high_low(value), shared_desc->highcnt);
81 else
82 dev_dbg(proxy->dev, "Voted for value 'low', effective value is 'low'\n");
83
84 return ret;
85}
86
87static int gpio_shared_proxy_request(struct gpio_chip *gc, unsigned int offset)
88{
89 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
90 struct gpio_shared_desc *shared_desc = proxy->shared_desc;
91
92 guard(gpio_shared_desc_lock)(l: shared_desc);
93
94 proxy->shared_desc->usecnt++;
95
96 dev_dbg(proxy->dev, "Shared GPIO requested, number of users: %u\n",
97 proxy->shared_desc->usecnt);
98
99 return 0;
100}
101
102static void gpio_shared_proxy_free(struct gpio_chip *gc, unsigned int offset)
103{
104 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
105 struct gpio_shared_desc *shared_desc = proxy->shared_desc;
106
107 guard(gpio_shared_desc_lock)(l: shared_desc);
108
109 proxy->shared_desc->usecnt--;
110
111 dev_dbg(proxy->dev, "Shared GPIO freed, number of users: %u\n",
112 proxy->shared_desc->usecnt);
113}
114
115static int gpio_shared_proxy_set_config(struct gpio_chip *gc,
116 unsigned int offset, unsigned long cfg)
117{
118 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
119 struct gpio_shared_desc *shared_desc = proxy->shared_desc;
120 struct gpio_desc *desc = shared_desc->desc;
121 int ret;
122
123 guard(gpio_shared_desc_lock)(l: shared_desc);
124
125 if (shared_desc->usecnt > 1) {
126 if (shared_desc->cfg != cfg) {
127 dev_dbg(proxy->dev,
128 "Shared GPIO's configuration already set, accepting changes but users may conflict!!\n");
129 } else {
130 dev_dbg(proxy->dev, "Equal config requested, nothing to do\n");
131 return 0;
132 }
133 }
134
135 ret = gpiod_set_config(desc, config: cfg);
136 if (ret && ret != -ENOTSUPP)
137 return ret;
138
139 shared_desc->cfg = cfg;
140 return 0;
141}
142
143static int gpio_shared_proxy_direction_input(struct gpio_chip *gc,
144 unsigned int offset)
145{
146 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
147 struct gpio_shared_desc *shared_desc = proxy->shared_desc;
148 struct gpio_desc *desc = shared_desc->desc;
149 int dir;
150
151 guard(gpio_shared_desc_lock)(l: shared_desc);
152
153 if (shared_desc->usecnt == 1) {
154 dev_dbg(proxy->dev,
155 "Only one user of this shared GPIO, allowing to set direction to input\n");
156
157 return gpiod_direction_input(desc);
158 }
159
160 dir = gpiod_get_direction(desc);
161 if (dir < 0)
162 return dir;
163
164 if (dir == GPIO_LINE_DIRECTION_OUT) {
165 dev_dbg(proxy->dev,
166 "Shared GPIO's direction already set to output, refusing to change\n");
167 return -EPERM;
168 }
169
170 return 0;
171}
172
173static int gpio_shared_proxy_direction_output(struct gpio_chip *gc,
174 unsigned int offset, int value)
175{
176 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
177 struct gpio_shared_desc *shared_desc = proxy->shared_desc;
178 struct gpio_desc *desc = shared_desc->desc;
179 int ret, dir;
180
181 guard(gpio_shared_desc_lock)(l: shared_desc);
182
183 if (shared_desc->usecnt == 1) {
184 dev_dbg(proxy->dev,
185 "Only one user of this shared GPIO, allowing to set direction to output with value '%s'\n",
186 str_high_low(value));
187
188 ret = gpiod_direction_output(desc, value);
189 if (ret)
190 return ret;
191
192 if (value) {
193 proxy->voted_high = true;
194 shared_desc->highcnt = 1;
195 } else {
196 proxy->voted_high = false;
197 shared_desc->highcnt = 0;
198 }
199
200 return 0;
201 }
202
203 dir = gpiod_get_direction(desc);
204 if (dir < 0)
205 return dir;
206
207 if (dir == GPIO_LINE_DIRECTION_IN) {
208 dev_dbg(proxy->dev,
209 "Shared GPIO's direction already set to input, refusing to change\n");
210 return -EPERM;
211 }
212
213 return gpio_shared_proxy_set_unlocked(proxy, set_func: gpiod_direction_output, value);
214}
215
216static int gpio_shared_proxy_get(struct gpio_chip *gc, unsigned int offset)
217{
218 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
219
220 return gpiod_get_value(desc: proxy->shared_desc->desc);
221}
222
223static int gpio_shared_proxy_get_cansleep(struct gpio_chip *gc,
224 unsigned int offset)
225{
226 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
227
228 return gpiod_get_value_cansleep(desc: proxy->shared_desc->desc);
229}
230
231static int gpio_shared_proxy_do_set(struct gpio_shared_proxy_data *proxy,
232 int (*set_func)(struct gpio_desc *desc, int value),
233 int value)
234{
235 guard(gpio_shared_desc_lock)(l: proxy->shared_desc);
236
237 return gpio_shared_proxy_set_unlocked(proxy, set_func, value);
238}
239
240static int gpio_shared_proxy_set(struct gpio_chip *gc, unsigned int offset,
241 int value)
242{
243 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
244
245 return gpio_shared_proxy_do_set(proxy, set_func: gpiod_set_value, value);
246}
247
248static int gpio_shared_proxy_set_cansleep(struct gpio_chip *gc,
249 unsigned int offset, int value)
250{
251 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
252
253 return gpio_shared_proxy_do_set(proxy, set_func: gpiod_set_value_cansleep, value);
254}
255
256static int gpio_shared_proxy_get_direction(struct gpio_chip *gc,
257 unsigned int offset)
258{
259 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
260
261 return gpiod_get_direction(desc: proxy->shared_desc->desc);
262}
263
264static int gpio_shared_proxy_to_irq(struct gpio_chip *gc, unsigned int offset)
265{
266 struct gpio_shared_proxy_data *proxy = gpiochip_get_data(gc);
267
268 return gpiod_to_irq(desc: proxy->shared_desc->desc);
269}
270
271static int gpio_shared_proxy_probe(struct auxiliary_device *adev,
272 const struct auxiliary_device_id *id)
273{
274 struct gpio_shared_proxy_data *proxy;
275 struct gpio_shared_desc *shared_desc;
276 struct device *dev = &adev->dev;
277 struct gpio_chip *gc;
278
279 shared_desc = devm_gpiod_shared_get(dev);
280 if (IS_ERR(ptr: shared_desc))
281 return PTR_ERR(ptr: shared_desc);
282
283 proxy = devm_kzalloc(dev, size: sizeof(*proxy), GFP_KERNEL);
284 if (!proxy)
285 return -ENOMEM;
286
287 proxy->shared_desc = shared_desc;
288 proxy->dev = dev;
289
290 gc = &proxy->gc;
291 gc->base = -1;
292 gc->ngpio = 1;
293 gc->label = dev_name(dev);
294 gc->parent = dev;
295 gc->owner = THIS_MODULE;
296 gc->can_sleep = shared_desc->can_sleep;
297
298 gc->request = gpio_shared_proxy_request;
299 gc->free = gpio_shared_proxy_free;
300 gc->set_config = gpio_shared_proxy_set_config;
301 gc->direction_input = gpio_shared_proxy_direction_input;
302 gc->direction_output = gpio_shared_proxy_direction_output;
303 if (gc->can_sleep) {
304 gc->set = gpio_shared_proxy_set_cansleep;
305 gc->get = gpio_shared_proxy_get_cansleep;
306 } else {
307 gc->set = gpio_shared_proxy_set;
308 gc->get = gpio_shared_proxy_get;
309 }
310 gc->get_direction = gpio_shared_proxy_get_direction;
311 gc->to_irq = gpio_shared_proxy_to_irq;
312
313 return devm_gpiochip_add_data(dev, &proxy->gc, proxy);
314}
315
316static const struct auxiliary_device_id gpio_shared_proxy_id_table[] = {
317 { .name = "gpiolib_shared.proxy" },
318 {},
319};
320MODULE_DEVICE_TABLE(auxiliary, gpio_shared_proxy_id_table);
321
322static struct auxiliary_driver gpio_shared_proxy_driver = {
323 .driver = {
324 .name = "gpio-shared-proxy",
325 .suppress_bind_attrs = true,
326 },
327 .probe = gpio_shared_proxy_probe,
328 .id_table = gpio_shared_proxy_id_table,
329};
330module_auxiliary_driver(gpio_shared_proxy_driver);
331
332MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@linaro.org>");
333MODULE_DESCRIPTION("Shared GPIO mux driver.");
334MODULE_LICENSE("GPL");
335

source code of linux/drivers/gpio/gpio-shared-proxy.c