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

source code of linux/drivers/gpio/gpio-virtuser.c