xref: /linux/drivers/gpio/gpio-virtuser.c (revision fcb117e0758d1462128a50c5788555e03b48833b)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Configurable virtual GPIO consumer module.
4  *
5  * Copyright (C) 2023-2024 Bartosz Golaszewski <bartosz.golaszewski@linaro.org>
6  */
7 
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 
10 #include <linux/array_size.h>
11 #include <linux/atomic.h>
12 #include <linux/bitmap.h>
13 #include <linux/cleanup.h>
14 #include <linux/configfs.h>
15 #include <linux/debugfs.h>
16 #include <linux/device.h>
17 #include <linux/err.h>
18 #include <linux/gpio/consumer.h>
19 #include <linux/gpio/machine.h>
20 #include <linux/idr.h>
21 #include <linux/interrupt.h>
22 #include <linux/irq_work.h>
23 #include <linux/limits.h>
24 #include <linux/list.h>
25 #include <linux/lockdep.h>
26 #include <linux/mod_devicetable.h>
27 #include <linux/module.h>
28 #include <linux/mutex.h>
29 #include <linux/notifier.h>
30 #include <linux/of.h>
31 #include <linux/overflow.h>
32 #include <linux/platform_device.h>
33 #include <linux/printk.h>
34 #include <linux/property.h>
35 #include <linux/slab.h>
36 #include <linux/string_helpers.h>
37 #include <linux/types.h>
38 
39 #include "dev-sync-probe.h"
40 
41 #define GPIO_VIRTUSER_NAME_BUF_LEN 32
42 
43 static DEFINE_IDA(gpio_virtuser_ida);
44 static struct dentry *gpio_virtuser_dbg_root;
45 
46 struct gpio_virtuser_attr_data {
47 	union {
48 		struct gpio_desc *desc;
49 		struct gpio_descs *descs;
50 	};
51 	struct dentry *dbgfs_dir;
52 };
53 
54 struct gpio_virtuser_line_array_data {
55 	struct gpio_virtuser_attr_data ad;
56 };
57 
58 struct gpio_virtuser_line_data {
59 	struct gpio_virtuser_attr_data ad;
60 	char consumer[GPIO_VIRTUSER_NAME_BUF_LEN];
61 	struct mutex consumer_lock;
62 	unsigned int debounce;
63 	atomic_t irq;
64 	atomic_t irq_count;
65 };
66 
67 struct gpio_virtuser_dbgfs_attr_descr {
68 	const char *name;
69 	const struct file_operations *fops;
70 };
71 
72 struct gpio_virtuser_irq_work_context {
73 	struct irq_work work;
74 	struct completion work_completion;
75 	union {
76 		struct {
77 			struct gpio_desc *desc;
78 			int dir;
79 			int val;
80 			int ret;
81 		};
82 		struct {
83 			struct gpio_descs *descs;
84 			unsigned long *values;
85 		};
86 	};
87 };
88 
89 static struct gpio_virtuser_irq_work_context *
to_gpio_virtuser_irq_work_context(struct irq_work * work)90 to_gpio_virtuser_irq_work_context(struct irq_work *work)
91 {
92 	return container_of(work, struct gpio_virtuser_irq_work_context, work);
93 }
94 
95 static void
gpio_virtuser_init_irq_work_context(struct gpio_virtuser_irq_work_context * ctx)96 gpio_virtuser_init_irq_work_context(struct gpio_virtuser_irq_work_context *ctx)
97 {
98 	memset(ctx, 0, sizeof(*ctx));
99 	init_completion(&ctx->work_completion);
100 }
101 
102 static void
gpio_virtuser_irq_work_queue_sync(struct gpio_virtuser_irq_work_context * ctx)103 gpio_virtuser_irq_work_queue_sync(struct gpio_virtuser_irq_work_context *ctx)
104 {
105 	irq_work_queue(&ctx->work);
106 	wait_for_completion(&ctx->work_completion);
107 }
108 
gpio_virtuser_dbgfs_emit_value_array(char * buf,unsigned long * values,size_t num_values)109 static void gpio_virtuser_dbgfs_emit_value_array(char *buf,
110 						 unsigned long *values,
111 						 size_t num_values)
112 {
113 	size_t i;
114 
115 	for (i = 0; i < num_values; i++)
116 		buf[i] = test_bit(i, values) ? '1' : '0';
117 
118 	buf[i++] = '\n';
119 }
120 
gpio_virtuser_get_value_array_atomic(struct irq_work * work)121 static void gpio_virtuser_get_value_array_atomic(struct irq_work *work)
122 {
123 	struct gpio_virtuser_irq_work_context *ctx =
124 				to_gpio_virtuser_irq_work_context(work);
125 	struct gpio_descs *descs = ctx->descs;
126 
127 	ctx->ret = gpiod_get_array_value(descs->ndescs, descs->desc,
128 					 descs->info, ctx->values);
129 	complete(&ctx->work_completion);
130 }
131 
gpio_virtuser_get_array_value(struct gpio_descs * descs,unsigned long * values,bool atomic)132 static int gpio_virtuser_get_array_value(struct gpio_descs *descs,
133 					 unsigned long *values, bool atomic)
134 {
135 	struct gpio_virtuser_irq_work_context ctx;
136 
137 	if (!atomic)
138 		return gpiod_get_array_value_cansleep(descs->ndescs,
139 						      descs->desc,
140 						      descs->info, values);
141 
142 	gpio_virtuser_init_irq_work_context(&ctx);
143 	ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_get_value_array_atomic);
144 	ctx.descs = descs;
145 	ctx.values = values;
146 
147 	gpio_virtuser_irq_work_queue_sync(&ctx);
148 
149 	return ctx.ret;
150 }
151 
gpio_virtuser_value_array_do_read(struct file * file,char __user * user_buf,size_t size,loff_t * ppos,bool atomic)152 static ssize_t gpio_virtuser_value_array_do_read(struct file *file,
153 						 char __user *user_buf,
154 						 size_t size, loff_t *ppos,
155 						 bool atomic)
156 {
157 	struct gpio_virtuser_line_data *data = file->private_data;
158 	struct gpio_descs *descs = data->ad.descs;
159 	size_t bufsize;
160 	int ret;
161 
162 	unsigned long *values __free(bitmap) = bitmap_zalloc(descs->ndescs,
163 							     GFP_KERNEL);
164 	if (!values)
165 		return -ENOMEM;
166 
167 	ret = gpio_virtuser_get_array_value(descs, values, atomic);
168 	if (ret)
169 		return ret;
170 
171 	bufsize = descs->ndescs + 2;
172 
173 	char *buf __free(kfree) = kzalloc(bufsize, GFP_KERNEL);
174 	if (!buf)
175 		return -ENOMEM;
176 
177 	gpio_virtuser_dbgfs_emit_value_array(buf, values, descs->ndescs);
178 
179 	return simple_read_from_buffer(user_buf, size, ppos, buf,
180 				       descs->ndescs + 1);
181 }
182 
gpio_virtuser_dbgfs_parse_value_array(const char * buf,size_t len,unsigned long * values)183 static int gpio_virtuser_dbgfs_parse_value_array(const char *buf,
184 						 size_t len,
185 						 unsigned long *values)
186 {
187 	size_t i;
188 
189 	for (i = 0; i < len; i++) {
190 		if (buf[i] == '0')
191 			clear_bit(i, values);
192 		else if (buf[i] == '1')
193 			set_bit(i, values);
194 		else
195 			return -EINVAL;
196 	}
197 
198 	return 0;
199 }
200 
gpio_virtuser_set_value_array_atomic(struct irq_work * work)201 static void gpio_virtuser_set_value_array_atomic(struct irq_work *work)
202 {
203 	struct gpio_virtuser_irq_work_context *ctx =
204 				to_gpio_virtuser_irq_work_context(work);
205 	struct gpio_descs *descs = ctx->descs;
206 
207 	ctx->ret = gpiod_set_array_value(descs->ndescs, descs->desc,
208 					 descs->info, ctx->values);
209 	complete(&ctx->work_completion);
210 }
211 
gpio_virtuser_set_array_value(struct gpio_descs * descs,unsigned long * values,bool atomic)212 static int gpio_virtuser_set_array_value(struct gpio_descs *descs,
213 					 unsigned long *values, bool atomic)
214 {
215 	struct gpio_virtuser_irq_work_context ctx;
216 
217 	if (!atomic)
218 		return gpiod_multi_set_value_cansleep(descs, values);
219 
220 	gpio_virtuser_init_irq_work_context(&ctx);
221 	ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_set_value_array_atomic);
222 	ctx.descs = descs;
223 	ctx.values = values;
224 
225 	gpio_virtuser_irq_work_queue_sync(&ctx);
226 
227 	return ctx.ret;
228 }
229 
gpio_virtuser_value_array_do_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos,bool atomic)230 static ssize_t gpio_virtuser_value_array_do_write(struct file *file,
231 						  const char __user *user_buf,
232 						  size_t count, loff_t *ppos,
233 						  bool atomic)
234 {
235 	struct gpio_virtuser_line_data *data = file->private_data;
236 	struct gpio_descs *descs = data->ad.descs;
237 	int ret;
238 
239 	if (count - 1 != descs->ndescs)
240 		return -EINVAL;
241 
242 	char *buf __free(kfree) = kzalloc(count, GFP_KERNEL);
243 	if (!buf)
244 		return -ENOMEM;
245 
246 	ret = simple_write_to_buffer(buf, count, ppos, user_buf, count);
247 	if (ret < 0)
248 		return ret;
249 
250 	unsigned long *values __free(bitmap) = bitmap_zalloc(descs->ndescs,
251 							     GFP_KERNEL);
252 	if (!values)
253 		return -ENOMEM;
254 
255 	ret = gpio_virtuser_dbgfs_parse_value_array(buf, count - 1, values);
256 	if (ret)
257 		return ret;
258 
259 	ret = gpio_virtuser_set_array_value(descs, values, atomic);
260 	if (ret)
261 		return ret;
262 
263 	return count;
264 }
265 
gpio_virtuser_value_array_read(struct file * file,char __user * user_buf,size_t count,loff_t * ppos)266 static ssize_t gpio_virtuser_value_array_read(struct file *file,
267 					      char __user *user_buf,
268 					      size_t count, loff_t *ppos)
269 {
270 	return gpio_virtuser_value_array_do_read(file, user_buf, count, ppos,
271 						 false);
272 }
273 
gpio_virtuser_value_array_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)274 static ssize_t gpio_virtuser_value_array_write(struct file *file,
275 					       const char __user *user_buf,
276 					       size_t count, loff_t *ppos)
277 {
278 	return gpio_virtuser_value_array_do_write(file, user_buf, count, ppos,
279 						  false);
280 }
281 
282 static const struct file_operations gpio_virtuser_value_array_fops = {
283 	.read = gpio_virtuser_value_array_read,
284 	.write = gpio_virtuser_value_array_write,
285 	.open = simple_open,
286 	.owner = THIS_MODULE,
287 	.llseek = default_llseek,
288 };
289 
290 static ssize_t
gpio_virtuser_value_array_atomic_read(struct file * file,char __user * user_buf,size_t count,loff_t * ppos)291 gpio_virtuser_value_array_atomic_read(struct file *file, char __user *user_buf,
292 				      size_t count, loff_t *ppos)
293 {
294 	return gpio_virtuser_value_array_do_read(file, user_buf, count, ppos,
295 						 true);
296 }
297 
298 static ssize_t
gpio_virtuser_value_array_atomic_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)299 gpio_virtuser_value_array_atomic_write(struct file *file,
300 				       const char __user *user_buf,
301 				       size_t count, loff_t *ppos)
302 {
303 	return gpio_virtuser_value_array_do_write(file, user_buf, count, ppos,
304 						  true);
305 }
306 
307 static const struct file_operations gpio_virtuser_value_array_atomic_fops = {
308 	.read = gpio_virtuser_value_array_atomic_read,
309 	.write = gpio_virtuser_value_array_atomic_write,
310 	.open = simple_open,
311 	.owner = THIS_MODULE,
312 	.llseek = default_llseek,
313 };
314 
gpio_virtuser_do_get_direction_atomic(struct irq_work * work)315 static void gpio_virtuser_do_get_direction_atomic(struct irq_work *work)
316 {
317 	struct gpio_virtuser_irq_work_context *ctx =
318 				to_gpio_virtuser_irq_work_context(work);
319 
320 	ctx->ret = gpiod_get_direction(ctx->desc);
321 	complete(&ctx->work_completion);
322 }
323 
gpio_virtuser_get_direction_atomic(struct gpio_desc * desc)324 static int gpio_virtuser_get_direction_atomic(struct gpio_desc *desc)
325 {
326 	struct gpio_virtuser_irq_work_context ctx;
327 
328 	gpio_virtuser_init_irq_work_context(&ctx);
329 	ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_do_get_direction_atomic);
330 	ctx.desc = desc;
331 
332 	gpio_virtuser_irq_work_queue_sync(&ctx);
333 
334 	return ctx.ret;
335 }
336 
gpio_virtuser_direction_do_read(struct file * file,char __user * user_buf,size_t size,loff_t * ppos,bool atomic)337 static ssize_t gpio_virtuser_direction_do_read(struct file *file,
338 					       char __user *user_buf,
339 					       size_t size, loff_t *ppos,
340 					       bool atomic)
341 {
342 	struct gpio_virtuser_line_data *data = file->private_data;
343 	struct gpio_desc *desc = data->ad.desc;
344 	char buf[32];
345 	int dir;
346 
347 	if (!atomic)
348 		dir = gpiod_get_direction(desc);
349 	else
350 		dir = gpio_virtuser_get_direction_atomic(desc);
351 	if (dir < 0)
352 		return dir;
353 
354 	snprintf(buf, sizeof(buf), "%s\n", dir ? "input" : "output");
355 
356 	return simple_read_from_buffer(user_buf, size, ppos, buf, strlen(buf));
357 }
358 
gpio_virtuser_set_direction(struct gpio_desc * desc,int dir,int val)359 static int gpio_virtuser_set_direction(struct gpio_desc *desc, int dir, int val)
360 {
361 	if (dir)
362 		return gpiod_direction_input(desc);
363 
364 	return gpiod_direction_output(desc, val);
365 }
366 
gpio_virtuser_do_set_direction_atomic(struct irq_work * work)367 static void gpio_virtuser_do_set_direction_atomic(struct irq_work *work)
368 {
369 	struct gpio_virtuser_irq_work_context *ctx =
370 				to_gpio_virtuser_irq_work_context(work);
371 
372 	ctx->ret = gpio_virtuser_set_direction(ctx->desc, ctx->dir, ctx->val);
373 	complete(&ctx->work_completion);
374 }
375 
gpio_virtuser_set_direction_atomic(struct gpio_desc * desc,int dir,int val)376 static int gpio_virtuser_set_direction_atomic(struct gpio_desc *desc,
377 					      int dir, int val)
378 {
379 	struct gpio_virtuser_irq_work_context ctx;
380 
381 	gpio_virtuser_init_irq_work_context(&ctx);
382 	ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_do_set_direction_atomic);
383 	ctx.desc = desc;
384 	ctx.dir = dir;
385 	ctx.val = val;
386 
387 	gpio_virtuser_irq_work_queue_sync(&ctx);
388 
389 	return ctx.ret;
390 }
391 
gpio_virtuser_direction_do_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos,bool atomic)392 static ssize_t gpio_virtuser_direction_do_write(struct file *file,
393 						const char __user *user_buf,
394 						size_t count, loff_t *ppos,
395 						bool atomic)
396 {
397 	struct gpio_virtuser_line_data *data = file->private_data;
398 	struct gpio_desc *desc = data->ad.desc;
399 	char buf[32], *trimmed;
400 	int ret, dir, val = 0;
401 
402 	if (count >= sizeof(buf))
403 		return -EINVAL;
404 
405 	ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count);
406 	if (ret < 0)
407 		return ret;
408 
409 	buf[ret] = '\0';
410 
411 	trimmed = strim(buf);
412 
413 	if (strcmp(trimmed, "input") == 0) {
414 		dir = 1;
415 	} else if (strcmp(trimmed, "output-high") == 0) {
416 		dir = 0;
417 		val = 1;
418 	} else if (strcmp(trimmed, "output-low") == 0) {
419 		dir = val = 0;
420 	} else {
421 		return -EINVAL;
422 	}
423 
424 	if (!atomic)
425 		ret = gpio_virtuser_set_direction(desc, dir, val);
426 	else
427 		ret = gpio_virtuser_set_direction_atomic(desc, dir, val);
428 	if (ret)
429 		return ret;
430 
431 	return count;
432 }
433 
gpio_virtuser_direction_read(struct file * file,char __user * user_buf,size_t size,loff_t * ppos)434 static ssize_t gpio_virtuser_direction_read(struct file *file,
435 					    char __user *user_buf,
436 					    size_t size, loff_t *ppos)
437 {
438 	return gpio_virtuser_direction_do_read(file, user_buf, size, ppos,
439 					       false);
440 }
441 
gpio_virtuser_direction_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)442 static ssize_t gpio_virtuser_direction_write(struct file *file,
443 					     const char __user *user_buf,
444 					     size_t count, loff_t *ppos)
445 {
446 	return gpio_virtuser_direction_do_write(file, user_buf, count, ppos,
447 						false);
448 }
449 
450 static const struct file_operations gpio_virtuser_direction_fops = {
451 	.read = gpio_virtuser_direction_read,
452 	.write = gpio_virtuser_direction_write,
453 	.open = simple_open,
454 	.owner = THIS_MODULE,
455 	.llseek = default_llseek,
456 };
457 
gpio_virtuser_direction_atomic_read(struct file * file,char __user * user_buf,size_t size,loff_t * ppos)458 static ssize_t gpio_virtuser_direction_atomic_read(struct file *file,
459 						   char __user *user_buf,
460 						   size_t size, loff_t *ppos)
461 {
462 	return gpio_virtuser_direction_do_read(file, user_buf, size, ppos,
463 					       true);
464 }
465 
gpio_virtuser_direction_atomic_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)466 static ssize_t gpio_virtuser_direction_atomic_write(struct file *file,
467 						    const char __user *user_buf,
468 						    size_t count, loff_t *ppos)
469 {
470 	return gpio_virtuser_direction_do_write(file, user_buf, count, ppos,
471 						true);
472 }
473 
474 static const struct file_operations gpio_virtuser_direction_atomic_fops = {
475 	.read = gpio_virtuser_direction_atomic_read,
476 	.write = gpio_virtuser_direction_atomic_write,
477 	.open = simple_open,
478 	.owner = THIS_MODULE,
479 	.llseek = default_llseek,
480 };
481 
gpio_virtuser_value_get(void * data,u64 * val)482 static int gpio_virtuser_value_get(void *data, u64 *val)
483 {
484 	struct gpio_virtuser_line_data *ld = data;
485 	int ret;
486 
487 	ret = gpiod_get_value_cansleep(ld->ad.desc);
488 	if (ret < 0)
489 		return ret;
490 
491 	*val = ret;
492 
493 	return 0;
494 }
495 
gpio_virtuser_value_set(void * data,u64 val)496 static int gpio_virtuser_value_set(void *data, u64 val)
497 {
498 	struct gpio_virtuser_line_data *ld = data;
499 
500 	if (val > 1)
501 		return -EINVAL;
502 
503 	gpiod_set_value_cansleep(ld->ad.desc, (int)val);
504 
505 	return 0;
506 }
507 
508 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_value_fops,
509 			 gpio_virtuser_value_get,
510 			 gpio_virtuser_value_set,
511 			 "%llu\n");
512 
gpio_virtuser_get_value_atomic(struct irq_work * work)513 static void gpio_virtuser_get_value_atomic(struct irq_work *work)
514 {
515 	struct gpio_virtuser_irq_work_context *ctx =
516 				to_gpio_virtuser_irq_work_context(work);
517 
518 	ctx->val = gpiod_get_value(ctx->desc);
519 	complete(&ctx->work_completion);
520 }
521 
gpio_virtuser_value_atomic_get(void * data,u64 * val)522 static int gpio_virtuser_value_atomic_get(void *data, u64 *val)
523 {
524 	struct gpio_virtuser_line_data *ld = data;
525 	struct gpio_virtuser_irq_work_context ctx;
526 
527 	gpio_virtuser_init_irq_work_context(&ctx);
528 	ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_get_value_atomic);
529 	ctx.desc = ld->ad.desc;
530 
531 	gpio_virtuser_irq_work_queue_sync(&ctx);
532 
533 	if (ctx.val < 0)
534 		return ctx.val;
535 
536 	*val = ctx.val;
537 
538 	return 0;
539 }
540 
gpio_virtuser_set_value_atomic(struct irq_work * work)541 static void gpio_virtuser_set_value_atomic(struct irq_work *work)
542 {
543 	struct gpio_virtuser_irq_work_context *ctx =
544 			to_gpio_virtuser_irq_work_context(work);
545 
546 	gpiod_set_value(ctx->desc, ctx->val);
547 	complete(&ctx->work_completion);
548 }
549 
gpio_virtuser_value_atomic_set(void * data,u64 val)550 static int gpio_virtuser_value_atomic_set(void *data, u64 val)
551 {
552 	struct gpio_virtuser_line_data *ld = data;
553 	struct gpio_virtuser_irq_work_context ctx;
554 
555 	if (val > 1)
556 		return -EINVAL;
557 
558 	gpio_virtuser_init_irq_work_context(&ctx);
559 	ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_set_value_atomic);
560 	ctx.desc = ld->ad.desc;
561 	ctx.val = (int)val;
562 
563 	gpio_virtuser_irq_work_queue_sync(&ctx);
564 
565 	return 0;
566 }
567 
568 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_value_atomic_fops,
569 			 gpio_virtuser_value_atomic_get,
570 			 gpio_virtuser_value_atomic_set,
571 			 "%llu\n");
572 
gpio_virtuser_debounce_get(void * data,u64 * val)573 static int gpio_virtuser_debounce_get(void *data, u64 *val)
574 {
575 	struct gpio_virtuser_line_data *ld = data;
576 
577 	*val = READ_ONCE(ld->debounce);
578 
579 	return 0;
580 }
581 
gpio_virtuser_debounce_set(void * data,u64 val)582 static int gpio_virtuser_debounce_set(void *data, u64 val)
583 {
584 	struct gpio_virtuser_line_data *ld = data;
585 	int ret;
586 
587 	if (val > UINT_MAX)
588 		return -E2BIG;
589 
590 	ret = gpiod_set_debounce(ld->ad.desc, (unsigned int)val);
591 	if (ret)
592 		/* Don't propagate errno unknown to user-space. */
593 		return ret == -ENOTSUPP ? -EOPNOTSUPP : ret;
594 
595 	WRITE_ONCE(ld->debounce, (unsigned int)val);
596 
597 	return 0;
598 }
599 
600 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_debounce_fops,
601 			 gpio_virtuser_debounce_get,
602 			 gpio_virtuser_debounce_set,
603 			 "%llu\n");
604 
gpio_virtuser_consumer_read(struct file * file,char __user * user_buf,size_t size,loff_t * ppos)605 static ssize_t gpio_virtuser_consumer_read(struct file *file,
606 					   char __user *user_buf,
607 					   size_t size, loff_t *ppos)
608 {
609 	struct gpio_virtuser_line_data *data = file->private_data;
610 	char buf[GPIO_VIRTUSER_NAME_BUF_LEN + 1];
611 	ssize_t ret;
612 
613 	memset(buf, 0x0, sizeof(buf));
614 
615 	scoped_guard(mutex, &data->consumer_lock)
616 		ret = snprintf(buf, sizeof(buf), "%s\n", data->consumer);
617 
618 	return simple_read_from_buffer(user_buf, size, ppos, buf, ret);
619 }
620 
gpio_virtuser_consumer_write(struct file * file,const char __user * user_buf,size_t count,loff_t * ppos)621 static ssize_t gpio_virtuser_consumer_write(struct file *file,
622 					    const char __user *user_buf,
623 					    size_t count, loff_t *ppos)
624 {
625 	struct gpio_virtuser_line_data *data = file->private_data;
626 	char buf[GPIO_VIRTUSER_NAME_BUF_LEN + 2];
627 	int ret;
628 
629 	if (count >= sizeof(buf))
630 		return -EINVAL;
631 
632 	ret = simple_write_to_buffer(buf, GPIO_VIRTUSER_NAME_BUF_LEN, ppos,
633 				     user_buf, count);
634 	if (ret < 0)
635 		return ret;
636 
637 	buf[ret] = '\0';
638 
639 	ret = gpiod_set_consumer_name(data->ad.desc, buf);
640 	if (ret)
641 		return ret;
642 
643 	scoped_guard(mutex, &data->consumer_lock)
644 		strscpy(data->consumer, buf, sizeof(data->consumer));
645 
646 	return count;
647 }
648 
649 static const struct file_operations gpio_virtuser_consumer_fops = {
650 	.read = gpio_virtuser_consumer_read,
651 	.write = gpio_virtuser_consumer_write,
652 	.open = simple_open,
653 	.owner = THIS_MODULE,
654 	.llseek = default_llseek,
655 };
656 
gpio_virtuser_interrupts_get(void * data,u64 * val)657 static int gpio_virtuser_interrupts_get(void *data, u64 *val)
658 {
659 	struct gpio_virtuser_line_data *ld = data;
660 
661 	*val = atomic_read(&ld->irq_count);
662 
663 	return 0;
664 }
665 
gpio_virtuser_irq_handler(int irq,void * data)666 static irqreturn_t gpio_virtuser_irq_handler(int irq, void *data)
667 {
668 	struct gpio_virtuser_line_data *ld = data;
669 
670 	atomic_inc(&ld->irq_count);
671 
672 	return IRQ_HANDLED;
673 }
674 
gpio_virtuser_interrupts_set(void * data,u64 val)675 static int gpio_virtuser_interrupts_set(void *data, u64 val)
676 {
677 	struct gpio_virtuser_line_data *ld = data;
678 	int irq, ret;
679 
680 	if (val > 1)
681 		return -EINVAL;
682 
683 	if (val) {
684 		irq = gpiod_to_irq(ld->ad.desc);
685 		if (irq < 0)
686 			return irq;
687 
688 		ret = request_threaded_irq(irq, NULL,
689 					   gpio_virtuser_irq_handler,
690 					   IRQF_TRIGGER_RISING |
691 					   IRQF_TRIGGER_FALLING |
692 					   IRQF_ONESHOT,
693 					   ld->consumer, data);
694 		if (ret)
695 			return ret;
696 
697 		atomic_set(&ld->irq, irq);
698 	} else {
699 		irq = atomic_xchg(&ld->irq, 0);
700 		free_irq(irq, ld);
701 	}
702 
703 	return 0;
704 }
705 
706 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_interrupts_fops,
707 			 gpio_virtuser_interrupts_get,
708 			 gpio_virtuser_interrupts_set,
709 			 "%llu\n");
710 
711 static const struct gpio_virtuser_dbgfs_attr_descr
712 gpio_virtuser_line_array_dbgfs_attrs[] = {
713 	{
714 		.name = "values",
715 		.fops = &gpio_virtuser_value_array_fops,
716 	},
717 	{
718 		.name = "values_atomic",
719 		.fops = &gpio_virtuser_value_array_atomic_fops,
720 	},
721 };
722 
723 static const struct gpio_virtuser_dbgfs_attr_descr
724 gpio_virtuser_line_dbgfs_attrs[] = {
725 	{
726 		.name = "direction",
727 		.fops = &gpio_virtuser_direction_fops,
728 	},
729 	{
730 		.name = "direction_atomic",
731 		.fops = &gpio_virtuser_direction_atomic_fops,
732 	},
733 	{
734 		.name = "value",
735 		.fops = &gpio_virtuser_value_fops,
736 	},
737 	{
738 		.name = "value_atomic",
739 		.fops = &gpio_virtuser_value_atomic_fops,
740 	},
741 	{
742 		.name = "debounce",
743 		.fops = &gpio_virtuser_debounce_fops,
744 	},
745 	{
746 		.name = "consumer",
747 		.fops = &gpio_virtuser_consumer_fops,
748 	},
749 	{
750 		.name = "interrupts",
751 		.fops = &gpio_virtuser_interrupts_fops,
752 	},
753 };
754 
gpio_virtuser_create_debugfs_attrs(const struct gpio_virtuser_dbgfs_attr_descr * attr,size_t num_attrs,struct dentry * parent,void * data)755 static int gpio_virtuser_create_debugfs_attrs(
756 			const struct gpio_virtuser_dbgfs_attr_descr *attr,
757 			size_t num_attrs, struct dentry *parent, void *data)
758 {
759 	struct dentry *ret;
760 	size_t i;
761 
762 	for (i = 0; i < num_attrs; i++, attr++) {
763 		ret = debugfs_create_file(attr->name, 0644, parent, data,
764 					  attr->fops);
765 		if (IS_ERR(ret))
766 			return PTR_ERR(ret);
767 	}
768 
769 	return 0;
770 }
771 
gpio_virtuser_dbgfs_init_line_array_attrs(struct device * dev,struct gpio_descs * descs,const char * id,struct dentry * dbgfs_entry)772 static int gpio_virtuser_dbgfs_init_line_array_attrs(struct device *dev,
773 						     struct gpio_descs *descs,
774 						     const char *id,
775 						     struct dentry *dbgfs_entry)
776 {
777 	struct gpio_virtuser_line_array_data *data;
778 	char *name;
779 
780 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
781 	if (!data)
782 		return -ENOMEM;
783 
784 	data->ad.descs = descs;
785 
786 	name = devm_kasprintf(dev, GFP_KERNEL, "gpiod:%s", id);
787 	if (!name)
788 		return -ENOMEM;
789 
790 	data->ad.dbgfs_dir = debugfs_create_dir(name, dbgfs_entry);
791 	if (IS_ERR(data->ad.dbgfs_dir))
792 		return PTR_ERR(data->ad.dbgfs_dir);
793 
794 	return gpio_virtuser_create_debugfs_attrs(
795 			gpio_virtuser_line_array_dbgfs_attrs,
796 			ARRAY_SIZE(gpio_virtuser_line_array_dbgfs_attrs),
797 			data->ad.dbgfs_dir, data);
798 }
799 
gpio_virtuser_dbgfs_init_line_attrs(struct device * dev,struct gpio_desc * desc,const char * id,unsigned int index,struct dentry * dbgfs_entry)800 static int gpio_virtuser_dbgfs_init_line_attrs(struct device *dev,
801 					       struct gpio_desc *desc,
802 					       const char *id,
803 					       unsigned int index,
804 					       struct dentry *dbgfs_entry)
805 {
806 	struct gpio_virtuser_line_data *data;
807 	char *name;
808 	int ret;
809 
810 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
811 	if (!data)
812 		return -ENOMEM;
813 
814 	data->ad.desc = desc;
815 	strscpy(data->consumer, id);
816 	atomic_set(&data->irq, 0);
817 	atomic_set(&data->irq_count, 0);
818 
819 	name = devm_kasprintf(dev, GFP_KERNEL, "gpiod:%s:%u", id, index);
820 	if (!name)
821 		return -ENOMEM;
822 
823 	ret = devm_mutex_init(dev, &data->consumer_lock);
824 	if (ret)
825 		return ret;
826 
827 	data->ad.dbgfs_dir = debugfs_create_dir(name, dbgfs_entry);
828 	if (IS_ERR(data->ad.dbgfs_dir))
829 		return PTR_ERR(data->ad.dbgfs_dir);
830 
831 	return gpio_virtuser_create_debugfs_attrs(
832 				gpio_virtuser_line_dbgfs_attrs,
833 				ARRAY_SIZE(gpio_virtuser_line_dbgfs_attrs),
834 				data->ad.dbgfs_dir, data);
835 }
836 
gpio_virtuser_debugfs_remove(void * data)837 static void gpio_virtuser_debugfs_remove(void *data)
838 {
839 	struct dentry *dbgfs_entry = data;
840 
841 	debugfs_remove_recursive(dbgfs_entry);
842 }
843 
gpio_virtuser_prop_is_gpio(struct property * prop)844 static int gpio_virtuser_prop_is_gpio(struct property *prop)
845 {
846 	char *dash = strrchr(prop->name, '-');
847 
848 	return dash && strcmp(dash, "-gpios") == 0;
849 }
850 
851 /*
852  * If this is an OF-based system, then we iterate over properties and consider
853  * all whose names end in "-gpios". For configfs we expect an additional string
854  * array property - "gpio-virtuser,ids" - containing the list of all GPIO IDs
855  * to request.
856  */
gpio_virtuser_count_ids(struct device * dev)857 static int gpio_virtuser_count_ids(struct device *dev)
858 {
859 	struct device_node *of_node = dev_of_node(dev);
860 	struct property *prop;
861 	int ret = 0;
862 
863 	if (!of_node)
864 		return device_property_string_array_count(dev,
865 							  "gpio-virtuser,ids");
866 
867 	for_each_property_of_node(of_node, prop) {
868 		if (gpio_virtuser_prop_is_gpio(prop))
869 			++ret;
870 	}
871 
872 	return ret;
873 }
874 
gpio_virtuser_get_ids(struct device * dev,const char ** ids,int num_ids)875 static int gpio_virtuser_get_ids(struct device *dev, const char **ids,
876 				 int num_ids)
877 {
878 	struct device_node *of_node = dev_of_node(dev);
879 	struct property *prop;
880 	size_t pos = 0, diff;
881 	char *dash, *tmp;
882 
883 	if (!of_node)
884 		return device_property_read_string_array(dev,
885 							 "gpio-virtuser,ids",
886 							 ids, num_ids);
887 
888 	for_each_property_of_node(of_node, prop) {
889 		if (!gpio_virtuser_prop_is_gpio(prop))
890 			continue;
891 
892 		dash = strrchr(prop->name, '-');
893 		diff = dash - prop->name;
894 
895 		tmp = devm_kmemdup(dev, prop->name, diff + 1,
896 				   GFP_KERNEL);
897 		if (!tmp)
898 			return -ENOMEM;
899 
900 		tmp[diff] = '\0';
901 		ids[pos++] = tmp;
902 	}
903 
904 	return 0;
905 }
906 
gpio_virtuser_probe(struct platform_device * pdev)907 static int gpio_virtuser_probe(struct platform_device *pdev)
908 {
909 	struct device *dev = &pdev->dev;
910 	struct dentry *dbgfs_entry;
911 	struct gpio_descs *descs;
912 	int ret, num_ids = 0, i;
913 	const char **ids;
914 	unsigned int j;
915 
916 	num_ids = gpio_virtuser_count_ids(dev);
917 	if (num_ids < 0)
918 		return dev_err_probe(dev, num_ids,
919 				     "Failed to get the number of GPIOs to request\n");
920 
921 	if (num_ids == 0)
922 		return dev_err_probe(dev, -EINVAL, "No GPIO IDs specified\n");
923 
924 	ids = devm_kcalloc(dev, num_ids, sizeof(*ids), GFP_KERNEL);
925 	if (!ids)
926 		return -ENOMEM;
927 
928 	ret = gpio_virtuser_get_ids(dev, ids, num_ids);
929 	if (ret < 0)
930 		return dev_err_probe(dev, ret,
931 				     "Failed to get the IDs of GPIOs to request\n");
932 
933 	dbgfs_entry = debugfs_create_dir(dev_name(dev), gpio_virtuser_dbg_root);
934 	ret = devm_add_action_or_reset(dev, gpio_virtuser_debugfs_remove,
935 				       dbgfs_entry);
936 	if (ret)
937 		return ret;
938 
939 	for (i = 0; i < num_ids; i++) {
940 		descs = devm_gpiod_get_array(dev, ids[i], GPIOD_ASIS);
941 		if (IS_ERR(descs))
942 			return dev_err_probe(dev, PTR_ERR(descs),
943 					     "Failed to request the '%s' GPIOs\n",
944 					     ids[i]);
945 
946 		ret = gpio_virtuser_dbgfs_init_line_array_attrs(dev, descs,
947 								ids[i],
948 								dbgfs_entry);
949 		if (ret)
950 			return dev_err_probe(dev, ret,
951 					     "Failed to setup the debugfs array interface for the '%s' GPIOs\n",
952 					     ids[i]);
953 
954 		for (j = 0; j < descs->ndescs; j++) {
955 			ret = gpio_virtuser_dbgfs_init_line_attrs(dev,
956 							descs->desc[j], ids[i],
957 							j, dbgfs_entry);
958 			if (ret)
959 				return dev_err_probe(dev, ret,
960 						     "Failed to setup the debugfs line interface for the '%s' GPIOs\n",
961 						     ids[i]);
962 		}
963 	}
964 
965 	return 0;
966 }
967 
968 static const struct of_device_id gpio_virtuser_of_match[] = {
969 	{ .compatible = "gpio-virtuser" },
970 	{ }
971 };
972 MODULE_DEVICE_TABLE(of, gpio_virtuser_of_match);
973 
974 static struct platform_driver gpio_virtuser_driver = {
975 	.driver = {
976 		.name = "gpio-virtuser",
977 		.of_match_table = gpio_virtuser_of_match,
978 	},
979 	.probe = gpio_virtuser_probe,
980 };
981 
982 struct gpio_virtuser_device {
983 	struct dev_sync_probe_data probe_data;
984 	struct config_group group;
985 
986 	int id;
987 	struct mutex lock;
988 
989 	struct gpiod_lookup_table *lookup_table;
990 
991 	struct list_head lookup_list;
992 };
993 
994 static struct gpio_virtuser_device *
to_gpio_virtuser_device(struct config_item * item)995 to_gpio_virtuser_device(struct config_item *item)
996 {
997 	struct config_group *group = to_config_group(item);
998 
999 	return container_of(group, struct gpio_virtuser_device, group);
1000 }
1001 
1002 static bool
gpio_virtuser_device_is_live(struct gpio_virtuser_device * dev)1003 gpio_virtuser_device_is_live(struct gpio_virtuser_device *dev)
1004 {
1005 	lockdep_assert_held(&dev->lock);
1006 
1007 	return !!dev->probe_data.pdev;
1008 }
1009 
1010 struct gpio_virtuser_lookup {
1011 	struct config_group group;
1012 
1013 	struct gpio_virtuser_device *parent;
1014 	struct list_head siblings;
1015 
1016 	char *con_id;
1017 
1018 	struct list_head entry_list;
1019 };
1020 
1021 static struct gpio_virtuser_lookup *
to_gpio_virtuser_lookup(struct config_item * item)1022 to_gpio_virtuser_lookup(struct config_item *item)
1023 {
1024 	struct config_group *group = to_config_group(item);
1025 
1026 	return container_of(group, struct gpio_virtuser_lookup, group);
1027 }
1028 
1029 struct gpio_virtuser_lookup_entry {
1030 	struct config_group group;
1031 
1032 	struct gpio_virtuser_lookup *parent;
1033 	struct list_head siblings;
1034 
1035 	char *key;
1036 	/* Can be negative to indicate lookup by name. */
1037 	int offset;
1038 	enum gpio_lookup_flags flags;
1039 };
1040 
1041 static struct gpio_virtuser_lookup_entry *
to_gpio_virtuser_lookup_entry(struct config_item * item)1042 to_gpio_virtuser_lookup_entry(struct config_item *item)
1043 {
1044 	struct config_group *group = to_config_group(item);
1045 
1046 	return container_of(group, struct gpio_virtuser_lookup_entry, group);
1047 }
1048 
1049 static ssize_t
gpio_virtuser_lookup_entry_config_key_show(struct config_item * item,char * page)1050 gpio_virtuser_lookup_entry_config_key_show(struct config_item *item, char *page)
1051 {
1052 	struct gpio_virtuser_lookup_entry *entry =
1053 					to_gpio_virtuser_lookup_entry(item);
1054 	struct gpio_virtuser_device *dev = entry->parent->parent;
1055 
1056 	guard(mutex)(&dev->lock);
1057 
1058 	return sprintf(page, "%s\n", entry->key ?: "");
1059 }
1060 
1061 static ssize_t
gpio_virtuser_lookup_entry_config_key_store(struct config_item * item,const char * page,size_t count)1062 gpio_virtuser_lookup_entry_config_key_store(struct config_item *item,
1063 					    const char *page, size_t count)
1064 {
1065 	struct gpio_virtuser_lookup_entry *entry =
1066 					to_gpio_virtuser_lookup_entry(item);
1067 	struct gpio_virtuser_device *dev = entry->parent->parent;
1068 
1069 	char *key __free(kfree) = kstrndup(skip_spaces(page), count,
1070 					   GFP_KERNEL);
1071 	if (!key)
1072 		return -ENOMEM;
1073 
1074 	strim(key);
1075 
1076 	guard(mutex)(&dev->lock);
1077 
1078 	if (gpio_virtuser_device_is_live(dev))
1079 		return -EBUSY;
1080 
1081 	kfree(entry->key);
1082 	entry->key = no_free_ptr(key);
1083 
1084 	return count;
1085 }
1086 
1087 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, key);
1088 
1089 static ssize_t
gpio_virtuser_lookup_entry_config_offset_show(struct config_item * item,char * page)1090 gpio_virtuser_lookup_entry_config_offset_show(struct config_item *item,
1091 					      char *page)
1092 {
1093 	struct gpio_virtuser_lookup_entry *entry =
1094 					to_gpio_virtuser_lookup_entry(item);
1095 	struct gpio_virtuser_device *dev = entry->parent->parent;
1096 	unsigned int offset;
1097 
1098 	scoped_guard(mutex, &dev->lock)
1099 		offset = entry->offset;
1100 
1101 	return sprintf(page, "%d\n", offset);
1102 }
1103 
1104 static ssize_t
gpio_virtuser_lookup_entry_config_offset_store(struct config_item * item,const char * page,size_t count)1105 gpio_virtuser_lookup_entry_config_offset_store(struct config_item *item,
1106 					       const char *page, size_t count)
1107 {
1108 	struct gpio_virtuser_lookup_entry *entry =
1109 					to_gpio_virtuser_lookup_entry(item);
1110 	struct gpio_virtuser_device *dev = entry->parent->parent;
1111 	int offset, ret;
1112 
1113 	ret = kstrtoint(page, 0, &offset);
1114 	if (ret)
1115 		return ret;
1116 
1117 	/*
1118 	 * Negative number here means: 'key' represents a line name to lookup.
1119 	 * Non-negative means: 'key' represents the label of the chip with
1120 	 * the 'offset' value representing the line within that chip.
1121 	 *
1122 	 * GPIOLIB uses the U16_MAX value to indicate lookup by line name so
1123 	 * the greatest offset we can accept is (U16_MAX - 1).
1124 	 */
1125 	if (offset > (U16_MAX - 1))
1126 		return -EINVAL;
1127 
1128 	guard(mutex)(&dev->lock);
1129 
1130 	if (gpio_virtuser_device_is_live(dev))
1131 		return -EBUSY;
1132 
1133 	entry->offset = offset;
1134 
1135 	return count;
1136 }
1137 
1138 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, offset);
1139 
1140 static enum gpio_lookup_flags
gpio_virtuser_lookup_get_flags(struct config_item * item)1141 gpio_virtuser_lookup_get_flags(struct config_item *item)
1142 {
1143 	struct gpio_virtuser_lookup_entry *entry =
1144 					to_gpio_virtuser_lookup_entry(item);
1145 	struct gpio_virtuser_device *dev = entry->parent->parent;
1146 
1147 	guard(mutex)(&dev->lock);
1148 
1149 	return entry->flags;
1150 }
1151 
1152 static ssize_t
gpio_virtuser_lookup_entry_config_drive_show(struct config_item * item,char * page)1153 gpio_virtuser_lookup_entry_config_drive_show(struct config_item *item, char *page)
1154 {
1155 	enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item);
1156 	const char *repr;
1157 
1158 	if (flags & GPIO_OPEN_DRAIN)
1159 		repr = "open-drain";
1160 	else if (flags & GPIO_OPEN_SOURCE)
1161 		repr = "open-source";
1162 	else
1163 		repr = "push-pull";
1164 
1165 	return sprintf(page, "%s\n", repr);
1166 }
1167 
1168 static ssize_t
gpio_virtuser_lookup_entry_config_drive_store(struct config_item * item,const char * page,size_t count)1169 gpio_virtuser_lookup_entry_config_drive_store(struct config_item *item,
1170 					      const char *page, size_t count)
1171 {
1172 	struct gpio_virtuser_lookup_entry *entry =
1173 					to_gpio_virtuser_lookup_entry(item);
1174 	struct gpio_virtuser_device *dev = entry->parent->parent;
1175 
1176 	guard(mutex)(&dev->lock);
1177 
1178 	if (gpio_virtuser_device_is_live(dev))
1179 		return -EBUSY;
1180 
1181 	if (sysfs_streq(page, "push-pull")) {
1182 		entry->flags &= ~(GPIO_OPEN_DRAIN | GPIO_OPEN_SOURCE);
1183 	} else if (sysfs_streq(page, "open-drain")) {
1184 		entry->flags &= ~GPIO_OPEN_SOURCE;
1185 		entry->flags |= GPIO_OPEN_DRAIN;
1186 	} else if (sysfs_streq(page, "open-source")) {
1187 		entry->flags &= ~GPIO_OPEN_DRAIN;
1188 		entry->flags |= GPIO_OPEN_SOURCE;
1189 	} else {
1190 		count = -EINVAL;
1191 	}
1192 
1193 	return count;
1194 }
1195 
1196 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, drive);
1197 
1198 static ssize_t
gpio_virtuser_lookup_entry_config_pull_show(struct config_item * item,char * page)1199 gpio_virtuser_lookup_entry_config_pull_show(struct config_item *item, char *page)
1200 {
1201 	enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item);
1202 	const char *repr;
1203 
1204 	if (flags & GPIO_PULL_UP)
1205 		repr = "pull-up";
1206 	else if (flags & GPIO_PULL_DOWN)
1207 		repr = "pull-down";
1208 	else if (flags & GPIO_PULL_DISABLE)
1209 		repr = "pull-disabled";
1210 	else
1211 		repr = "as-is";
1212 
1213 	return sprintf(page, "%s\n", repr);
1214 }
1215 
1216 static ssize_t
gpio_virtuser_lookup_entry_config_pull_store(struct config_item * item,const char * page,size_t count)1217 gpio_virtuser_lookup_entry_config_pull_store(struct config_item *item,
1218 					     const char *page, size_t count)
1219 {
1220 	struct gpio_virtuser_lookup_entry *entry =
1221 					to_gpio_virtuser_lookup_entry(item);
1222 	struct gpio_virtuser_device *dev = entry->parent->parent;
1223 
1224 	guard(mutex)(&dev->lock);
1225 
1226 	if (gpio_virtuser_device_is_live(dev))
1227 		return -EBUSY;
1228 
1229 	if (sysfs_streq(page, "pull-up")) {
1230 		entry->flags &= ~(GPIO_PULL_DOWN | GPIO_PULL_DISABLE);
1231 		entry->flags |= GPIO_PULL_UP;
1232 	} else if (sysfs_streq(page, "pull-down")) {
1233 		entry->flags &= ~(GPIO_PULL_UP | GPIO_PULL_DISABLE);
1234 		entry->flags |= GPIO_PULL_DOWN;
1235 	} else if (sysfs_streq(page, "pull-disabled")) {
1236 		entry->flags &= ~(GPIO_PULL_UP | GPIO_PULL_DOWN);
1237 		entry->flags |= GPIO_PULL_DISABLE;
1238 	} else if (sysfs_streq(page, "as-is")) {
1239 		entry->flags &= ~(GPIO_PULL_UP | GPIO_PULL_DOWN |
1240 				  GPIO_PULL_DISABLE);
1241 	} else {
1242 		count = -EINVAL;
1243 	}
1244 
1245 	return count;
1246 }
1247 
1248 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, pull);
1249 
1250 static ssize_t
gpio_virtuser_lookup_entry_config_active_low_show(struct config_item * item,char * page)1251 gpio_virtuser_lookup_entry_config_active_low_show(struct config_item *item,
1252 						  char *page)
1253 {
1254 	enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item);
1255 
1256 	return sprintf(page, "%c\n", flags & GPIO_ACTIVE_LOW ? '1' : '0');
1257 }
1258 
1259 static ssize_t
gpio_virtuser_lookup_entry_config_active_low_store(struct config_item * item,const char * page,size_t count)1260 gpio_virtuser_lookup_entry_config_active_low_store(struct config_item *item,
1261 						   const char *page,
1262 						   size_t count)
1263 {
1264 	struct gpio_virtuser_lookup_entry *entry =
1265 					to_gpio_virtuser_lookup_entry(item);
1266 	struct gpio_virtuser_device *dev = entry->parent->parent;
1267 	bool active_low;
1268 	int ret;
1269 
1270 	ret = kstrtobool(page, &active_low);
1271 	if (ret)
1272 		return ret;
1273 
1274 	guard(mutex)(&dev->lock);
1275 
1276 	if (gpio_virtuser_device_is_live(dev))
1277 		return -EBUSY;
1278 
1279 	if (active_low)
1280 		entry->flags |= GPIO_ACTIVE_LOW;
1281 	else
1282 		entry->flags &= ~GPIO_ACTIVE_LOW;
1283 
1284 	return count;
1285 }
1286 
1287 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, active_low);
1288 
1289 static ssize_t
gpio_virtuser_lookup_entry_config_transitory_show(struct config_item * item,char * page)1290 gpio_virtuser_lookup_entry_config_transitory_show(struct config_item *item,
1291 						  char *page)
1292 {
1293 	enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item);
1294 
1295 	return sprintf(page, "%c\n", flags & GPIO_TRANSITORY ? '1' : '0');
1296 }
1297 
1298 static ssize_t
gpio_virtuser_lookup_entry_config_transitory_store(struct config_item * item,const char * page,size_t count)1299 gpio_virtuser_lookup_entry_config_transitory_store(struct config_item *item,
1300 						   const char *page,
1301 						   size_t count)
1302 {
1303 	struct gpio_virtuser_lookup_entry *entry =
1304 					to_gpio_virtuser_lookup_entry(item);
1305 	struct gpio_virtuser_device *dev = entry->parent->parent;
1306 	bool transitory;
1307 	int ret;
1308 
1309 	ret = kstrtobool(page, &transitory);
1310 	if (ret)
1311 		return ret;
1312 
1313 	guard(mutex)(&dev->lock);
1314 
1315 	if (gpio_virtuser_device_is_live(dev))
1316 		return -EBUSY;
1317 
1318 	if (transitory)
1319 		entry->flags |= GPIO_TRANSITORY;
1320 	else
1321 		entry->flags &= ~GPIO_TRANSITORY;
1322 
1323 	return count;
1324 }
1325 
1326 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, transitory);
1327 
1328 static struct configfs_attribute *gpio_virtuser_lookup_entry_config_attrs[] = {
1329 	&gpio_virtuser_lookup_entry_config_attr_key,
1330 	&gpio_virtuser_lookup_entry_config_attr_offset,
1331 	&gpio_virtuser_lookup_entry_config_attr_drive,
1332 	&gpio_virtuser_lookup_entry_config_attr_pull,
1333 	&gpio_virtuser_lookup_entry_config_attr_active_low,
1334 	&gpio_virtuser_lookup_entry_config_attr_transitory,
1335 	NULL
1336 };
1337 
1338 static ssize_t
gpio_virtuser_device_config_dev_name_show(struct config_item * item,char * page)1339 gpio_virtuser_device_config_dev_name_show(struct config_item *item,
1340 					  char *page)
1341 {
1342 	struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item);
1343 	struct platform_device *pdev;
1344 
1345 	guard(mutex)(&dev->lock);
1346 
1347 	pdev = dev->probe_data.pdev;
1348 	if (pdev)
1349 		return sprintf(page, "%s\n", dev_name(&pdev->dev));
1350 
1351 	return sprintf(page, "gpio-sim.%d\n", dev->id);
1352 }
1353 
1354 CONFIGFS_ATTR_RO(gpio_virtuser_device_config_, dev_name);
1355 
gpio_virtuser_device_config_live_show(struct config_item * item,char * page)1356 static ssize_t gpio_virtuser_device_config_live_show(struct config_item *item,
1357 						     char *page)
1358 {
1359 	struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item);
1360 	bool live;
1361 
1362 	scoped_guard(mutex, &dev->lock)
1363 		live = gpio_virtuser_device_is_live(dev);
1364 
1365 	return sprintf(page, "%c\n", live ? '1' : '0');
1366 }
1367 
1368 static size_t
gpio_virtuser_get_lookup_count(struct gpio_virtuser_device * dev)1369 gpio_virtuser_get_lookup_count(struct gpio_virtuser_device *dev)
1370 {
1371 	struct gpio_virtuser_lookup *lookup;
1372 	size_t count = 0;
1373 
1374 	lockdep_assert_held(&dev->lock);
1375 
1376 	list_for_each_entry(lookup, &dev->lookup_list, siblings)
1377 		count += list_count_nodes(&lookup->entry_list);
1378 
1379 	return count;
1380 }
1381 
1382 static int
gpio_virtuser_make_lookup_table(struct gpio_virtuser_device * dev)1383 gpio_virtuser_make_lookup_table(struct gpio_virtuser_device *dev)
1384 {
1385 	size_t num_entries = gpio_virtuser_get_lookup_count(dev);
1386 	struct gpio_virtuser_lookup_entry *entry;
1387 	struct gpio_virtuser_lookup *lookup;
1388 	unsigned int i = 0, idx;
1389 
1390 	lockdep_assert_held(&dev->lock);
1391 
1392 	struct gpiod_lookup_table *table __free(kfree) =
1393 		kzalloc(struct_size(table, table, num_entries + 1), GFP_KERNEL);
1394 	if (!table)
1395 		return -ENOMEM;
1396 
1397 	table->dev_id = kasprintf(GFP_KERNEL, "gpio-virtuser.%d", dev->id);
1398 	if (!table->dev_id)
1399 		return -ENOMEM;
1400 
1401 	list_for_each_entry(lookup, &dev->lookup_list, siblings) {
1402 		idx = 0;
1403 		list_for_each_entry(entry, &lookup->entry_list, siblings) {
1404 			table->table[i++] =
1405 				GPIO_LOOKUP_IDX(entry->key,
1406 						entry->offset < 0 ? U16_MAX : entry->offset,
1407 						lookup->con_id, idx++, entry->flags);
1408 		}
1409 	}
1410 
1411 	gpiod_add_lookup_table(table);
1412 	dev->lookup_table = no_free_ptr(table);
1413 
1414 	return 0;
1415 }
1416 
1417 static void
gpio_virtuser_remove_lookup_table(struct gpio_virtuser_device * dev)1418 gpio_virtuser_remove_lookup_table(struct gpio_virtuser_device *dev)
1419 {
1420 	gpiod_remove_lookup_table(dev->lookup_table);
1421 	kfree(dev->lookup_table->dev_id);
1422 	kfree(dev->lookup_table);
1423 	dev->lookup_table = NULL;
1424 }
1425 
1426 static struct fwnode_handle *
gpio_virtuser_make_device_swnode(struct gpio_virtuser_device * dev)1427 gpio_virtuser_make_device_swnode(struct gpio_virtuser_device *dev)
1428 {
1429 	struct property_entry properties[2];
1430 	struct gpio_virtuser_lookup *lookup;
1431 	unsigned int i = 0;
1432 	size_t num_ids;
1433 
1434 	memset(properties, 0, sizeof(properties));
1435 
1436 	num_ids = list_count_nodes(&dev->lookup_list);
1437 	char **ids __free(kfree) = kcalloc(num_ids + 1, sizeof(*ids),
1438 					   GFP_KERNEL);
1439 	if (!ids)
1440 		return ERR_PTR(-ENOMEM);
1441 
1442 	list_for_each_entry(lookup, &dev->lookup_list, siblings)
1443 		ids[i++] = lookup->con_id;
1444 
1445 	properties[0] = PROPERTY_ENTRY_STRING_ARRAY_LEN("gpio-virtuser,ids",
1446 							ids, num_ids);
1447 
1448 	return fwnode_create_software_node(properties, NULL);
1449 }
1450 
1451 static int
gpio_virtuser_device_activate(struct gpio_virtuser_device * dev)1452 gpio_virtuser_device_activate(struct gpio_virtuser_device *dev)
1453 {
1454 	struct platform_device_info pdevinfo;
1455 	struct fwnode_handle *swnode;
1456 	int ret;
1457 
1458 	lockdep_assert_held(&dev->lock);
1459 
1460 	if (list_empty(&dev->lookup_list))
1461 		return -ENODATA;
1462 
1463 	swnode = gpio_virtuser_make_device_swnode(dev);
1464 	if (IS_ERR(swnode))
1465 		return PTR_ERR(swnode);
1466 
1467 	memset(&pdevinfo, 0, sizeof(pdevinfo));
1468 	pdevinfo.name = "gpio-virtuser";
1469 	pdevinfo.id = dev->id;
1470 	pdevinfo.fwnode = swnode;
1471 
1472 	ret = gpio_virtuser_make_lookup_table(dev);
1473 	if (ret)
1474 		goto err_remove_swnode;
1475 
1476 	ret = dev_sync_probe_register(&dev->probe_data, &pdevinfo);
1477 	if (ret)
1478 		goto err_remove_lookup_table;
1479 
1480 	return 0;
1481 
1482 err_remove_lookup_table:
1483 	gpio_virtuser_remove_lookup_table(dev);
1484 err_remove_swnode:
1485 	fwnode_remove_software_node(swnode);
1486 
1487 	return ret;
1488 }
1489 
1490 static void
gpio_virtuser_device_deactivate(struct gpio_virtuser_device * dev)1491 gpio_virtuser_device_deactivate(struct gpio_virtuser_device *dev)
1492 {
1493 	struct fwnode_handle *swnode;
1494 
1495 	lockdep_assert_held(&dev->lock);
1496 
1497 	swnode = dev_fwnode(&dev->probe_data.pdev->dev);
1498 	dev_sync_probe_unregister(&dev->probe_data);
1499 	gpio_virtuser_remove_lookup_table(dev);
1500 	fwnode_remove_software_node(swnode);
1501 }
1502 
1503 static void
gpio_virtuser_device_lockup_configfs(struct gpio_virtuser_device * dev,bool lock)1504 gpio_virtuser_device_lockup_configfs(struct gpio_virtuser_device *dev, bool lock)
1505 {
1506 	struct configfs_subsystem *subsys = dev->group.cg_subsys;
1507 	struct gpio_virtuser_lookup_entry *entry;
1508 	struct gpio_virtuser_lookup *lookup;
1509 
1510 	/*
1511 	 * The device only needs to depend on leaf lookup entries. This is
1512 	 * sufficient to lock up all the configfs entries that the
1513 	 * instantiated, alive device depends on.
1514 	 */
1515 	list_for_each_entry(lookup, &dev->lookup_list, siblings) {
1516 		list_for_each_entry(entry, &lookup->entry_list, siblings) {
1517 			if (lock)
1518 				WARN_ON(configfs_depend_item_unlocked(
1519 						subsys, &entry->group.cg_item));
1520 			else
1521 				configfs_undepend_item_unlocked(
1522 						&entry->group.cg_item);
1523 		}
1524 	}
1525 }
1526 
1527 static ssize_t
gpio_virtuser_device_config_live_store(struct config_item * item,const char * page,size_t count)1528 gpio_virtuser_device_config_live_store(struct config_item *item,
1529 				       const char *page, size_t count)
1530 {
1531 	struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item);
1532 	int ret = 0;
1533 	bool live;
1534 
1535 	ret = kstrtobool(page, &live);
1536 	if (ret)
1537 		return ret;
1538 
1539 	if (live)
1540 		gpio_virtuser_device_lockup_configfs(dev, true);
1541 
1542 	scoped_guard(mutex, &dev->lock) {
1543 		if (live == gpio_virtuser_device_is_live(dev))
1544 			ret = -EPERM;
1545 		else if (live)
1546 			ret = gpio_virtuser_device_activate(dev);
1547 		else
1548 			gpio_virtuser_device_deactivate(dev);
1549 	}
1550 
1551 	/*
1552 	 * Undepend is required only if device disablement (live == 0)
1553 	 * succeeds or if device enablement (live == 1) fails.
1554 	 */
1555 	if (live == !!ret)
1556 		gpio_virtuser_device_lockup_configfs(dev, false);
1557 
1558 	return ret ?: count;
1559 }
1560 
1561 CONFIGFS_ATTR(gpio_virtuser_device_config_, live);
1562 
1563 static struct configfs_attribute *gpio_virtuser_device_config_attrs[] = {
1564 	&gpio_virtuser_device_config_attr_dev_name,
1565 	&gpio_virtuser_device_config_attr_live,
1566 	NULL
1567 };
1568 
1569 static void
gpio_virtuser_lookup_entry_config_group_release(struct config_item * item)1570 gpio_virtuser_lookup_entry_config_group_release(struct config_item *item)
1571 {
1572 	struct gpio_virtuser_lookup_entry *entry =
1573 					to_gpio_virtuser_lookup_entry(item);
1574 	struct gpio_virtuser_device *dev = entry->parent->parent;
1575 
1576 	guard(mutex)(&dev->lock);
1577 
1578 	list_del(&entry->siblings);
1579 
1580 	kfree(entry->key);
1581 	kfree(entry);
1582 }
1583 
1584 static struct
1585 configfs_item_operations gpio_virtuser_lookup_entry_config_item_ops = {
1586 	.release	= gpio_virtuser_lookup_entry_config_group_release,
1587 };
1588 
1589 static const struct
1590 config_item_type gpio_virtuser_lookup_entry_config_group_type = {
1591 	.ct_item_ops	= &gpio_virtuser_lookup_entry_config_item_ops,
1592 	.ct_attrs	= gpio_virtuser_lookup_entry_config_attrs,
1593 	.ct_owner	= THIS_MODULE,
1594 };
1595 
1596 static struct config_group *
gpio_virtuser_make_lookup_entry_group(struct config_group * group,const char * name)1597 gpio_virtuser_make_lookup_entry_group(struct config_group *group,
1598 				      const char *name)
1599 {
1600 	struct gpio_virtuser_lookup *lookup =
1601 				to_gpio_virtuser_lookup(&group->cg_item);
1602 	struct gpio_virtuser_device *dev = lookup->parent;
1603 
1604 	guard(mutex)(&dev->lock);
1605 
1606 	if (gpio_virtuser_device_is_live(dev))
1607 		return ERR_PTR(-EBUSY);
1608 
1609 	struct gpio_virtuser_lookup_entry *entry __free(kfree) =
1610 				kzalloc(sizeof(*entry), GFP_KERNEL);
1611 	if (!entry)
1612 		return ERR_PTR(-ENOMEM);
1613 
1614 	config_group_init_type_name(&entry->group, name,
1615 			&gpio_virtuser_lookup_entry_config_group_type);
1616 	entry->flags = GPIO_LOOKUP_FLAGS_DEFAULT;
1617 	entry->parent = lookup;
1618 	list_add_tail(&entry->siblings, &lookup->entry_list);
1619 
1620 	return &no_free_ptr(entry)->group;
1621 }
1622 
gpio_virtuser_lookup_config_group_release(struct config_item * item)1623 static void gpio_virtuser_lookup_config_group_release(struct config_item *item)
1624 {
1625 	struct gpio_virtuser_lookup *lookup = to_gpio_virtuser_lookup(item);
1626 	struct gpio_virtuser_device *dev = lookup->parent;
1627 
1628 	guard(mutex)(&dev->lock);
1629 
1630 	list_del(&lookup->siblings);
1631 
1632 	kfree(lookup->con_id);
1633 	kfree(lookup);
1634 }
1635 
1636 static struct configfs_item_operations gpio_virtuser_lookup_config_item_ops = {
1637 	.release	= gpio_virtuser_lookup_config_group_release,
1638 };
1639 
1640 static struct
1641 configfs_group_operations gpio_virtuser_lookup_config_group_ops = {
1642 	.make_group     = gpio_virtuser_make_lookup_entry_group,
1643 };
1644 
1645 static const struct config_item_type gpio_virtuser_lookup_config_group_type = {
1646 	.ct_group_ops	= &gpio_virtuser_lookup_config_group_ops,
1647 	.ct_item_ops	= &gpio_virtuser_lookup_config_item_ops,
1648 	.ct_owner	= THIS_MODULE,
1649 };
1650 
1651 static struct config_group *
gpio_virtuser_make_lookup_group(struct config_group * group,const char * name)1652 gpio_virtuser_make_lookup_group(struct config_group *group, const char *name)
1653 {
1654 	struct gpio_virtuser_device *dev =
1655 				to_gpio_virtuser_device(&group->cg_item);
1656 
1657 	if (strlen(name) > (GPIO_VIRTUSER_NAME_BUF_LEN - 1))
1658 		return ERR_PTR(-E2BIG);
1659 
1660 	guard(mutex)(&dev->lock);
1661 
1662 	if (gpio_virtuser_device_is_live(dev))
1663 		return ERR_PTR(-EBUSY);
1664 
1665 	struct gpio_virtuser_lookup *lookup __free(kfree) =
1666 				kzalloc(sizeof(*lookup), GFP_KERNEL);
1667 	if (!lookup)
1668 		return ERR_PTR(-ENOMEM);
1669 
1670 	lookup->con_id = kstrdup(name, GFP_KERNEL);
1671 	if (!lookup->con_id)
1672 		return ERR_PTR(-ENOMEM);
1673 
1674 	config_group_init_type_name(&lookup->group, name,
1675 				    &gpio_virtuser_lookup_config_group_type);
1676 	INIT_LIST_HEAD(&lookup->entry_list);
1677 	lookup->parent = dev;
1678 	list_add_tail(&lookup->siblings, &dev->lookup_list);
1679 
1680 	return &no_free_ptr(lookup)->group;
1681 }
1682 
gpio_virtuser_device_config_group_release(struct config_item * item)1683 static void gpio_virtuser_device_config_group_release(struct config_item *item)
1684 {
1685 	struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item);
1686 
1687 	guard(mutex)(&dev->lock);
1688 
1689 	if (gpio_virtuser_device_is_live(dev))
1690 		gpio_virtuser_device_deactivate(dev);
1691 
1692 	mutex_destroy(&dev->lock);
1693 	ida_free(&gpio_virtuser_ida, dev->id);
1694 	kfree(dev);
1695 }
1696 
1697 static struct configfs_item_operations gpio_virtuser_device_config_item_ops = {
1698 	.release	= gpio_virtuser_device_config_group_release,
1699 };
1700 
1701 static struct configfs_group_operations gpio_virtuser_device_config_group_ops = {
1702 	.make_group	= gpio_virtuser_make_lookup_group,
1703 };
1704 
1705 static const struct config_item_type gpio_virtuser_device_config_group_type = {
1706 	.ct_group_ops	= &gpio_virtuser_device_config_group_ops,
1707 	.ct_item_ops	= &gpio_virtuser_device_config_item_ops,
1708 	.ct_attrs	= gpio_virtuser_device_config_attrs,
1709 	.ct_owner	= THIS_MODULE,
1710 };
1711 
1712 static struct config_group *
gpio_virtuser_config_make_device_group(struct config_group * group,const char * name)1713 gpio_virtuser_config_make_device_group(struct config_group *group,
1714 				       const char *name)
1715 {
1716 	struct gpio_virtuser_device *dev __free(kfree) = kzalloc(sizeof(*dev),
1717 								 GFP_KERNEL);
1718 	if (!dev)
1719 		return ERR_PTR(-ENOMEM);
1720 
1721 	dev->id = ida_alloc(&gpio_virtuser_ida, GFP_KERNEL);
1722 	if (dev->id < 0)
1723 		return ERR_PTR(dev->id);
1724 
1725 	config_group_init_type_name(&dev->group, name,
1726 				    &gpio_virtuser_device_config_group_type);
1727 	mutex_init(&dev->lock);
1728 	INIT_LIST_HEAD(&dev->lookup_list);
1729 	dev_sync_probe_init(&dev->probe_data);
1730 
1731 	return &no_free_ptr(dev)->group;
1732 }
1733 
1734 static struct configfs_group_operations gpio_virtuser_config_group_ops = {
1735 	.make_group	= gpio_virtuser_config_make_device_group,
1736 };
1737 
1738 static const struct config_item_type gpio_virtuser_config_type = {
1739 	.ct_group_ops	= &gpio_virtuser_config_group_ops,
1740 	.ct_owner	= THIS_MODULE,
1741 };
1742 
1743 static struct configfs_subsystem gpio_virtuser_config_subsys = {
1744 	.su_group = {
1745 		.cg_item = {
1746 			.ci_namebuf	= "gpio-virtuser",
1747 			.ci_type	= &gpio_virtuser_config_type,
1748 		},
1749 	},
1750 };
1751 
gpio_virtuser_init(void)1752 static int __init gpio_virtuser_init(void)
1753 {
1754 	int ret;
1755 
1756 	ret = platform_driver_register(&gpio_virtuser_driver);
1757 	if (ret) {
1758 		pr_err("Failed to register the platform driver: %d\n", ret);
1759 		return ret;
1760 	}
1761 
1762 	config_group_init(&gpio_virtuser_config_subsys.su_group);
1763 	mutex_init(&gpio_virtuser_config_subsys.su_mutex);
1764 	ret = configfs_register_subsystem(&gpio_virtuser_config_subsys);
1765 	if (ret) {
1766 		pr_err("Failed to register the '%s' configfs subsystem: %d\n",
1767 		       gpio_virtuser_config_subsys.su_group.cg_item.ci_namebuf,
1768 		       ret);
1769 		goto err_plat_drv_unreg;
1770 	}
1771 
1772 	gpio_virtuser_dbg_root = debugfs_create_dir("gpio-virtuser", NULL);
1773 	if (IS_ERR(gpio_virtuser_dbg_root)) {
1774 		ret = PTR_ERR(gpio_virtuser_dbg_root);
1775 		pr_err("Failed to create the debugfs tree: %d\n", ret);
1776 		goto err_configfs_unreg;
1777 	}
1778 
1779 	return 0;
1780 
1781 err_configfs_unreg:
1782 	configfs_unregister_subsystem(&gpio_virtuser_config_subsys);
1783 err_plat_drv_unreg:
1784 	mutex_destroy(&gpio_virtuser_config_subsys.su_mutex);
1785 	platform_driver_unregister(&gpio_virtuser_driver);
1786 
1787 	return ret;
1788 }
1789 module_init(gpio_virtuser_init);
1790 
gpio_virtuser_exit(void)1791 static void __exit gpio_virtuser_exit(void)
1792 {
1793 	configfs_unregister_subsystem(&gpio_virtuser_config_subsys);
1794 	mutex_destroy(&gpio_virtuser_config_subsys.su_mutex);
1795 	platform_driver_unregister(&gpio_virtuser_driver);
1796 	debugfs_remove_recursive(gpio_virtuser_dbg_root);
1797 }
1798 module_exit(gpio_virtuser_exit);
1799 
1800 MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@linaro.org>");
1801 MODULE_DESCRIPTION("Virtual GPIO consumer module");
1802 MODULE_LICENSE("GPL");
1803