Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * GPIO testing driver based on configfs.
4 *
5 * Copyright (C) 2021 Bartosz Golaszewski <brgl@bgdev.pl>
6 */
7
8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10#include <linux/array_size.h>
11#include <linux/bitmap.h>
12#include <linux/cleanup.h>
13#include <linux/configfs.h>
14#include <linux/device.h>
15#include <linux/err.h>
16#include <linux/gpio/consumer.h>
17#include <linux/gpio/driver.h>
18#include <linux/gpio/machine.h>
19#include <linux/idr.h>
20#include <linux/interrupt.h>
21#include <linux/irq.h>
22#include <linux/irq_sim.h>
23#include <linux/list.h>
24#include <linux/lockdep.h>
25#include <linux/minmax.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/platform_device.h>
31#include <linux/property.h>
32#include <linux/seq_file.h>
33#include <linux/slab.h>
34#include <linux/string.h>
35#include <linux/string_helpers.h>
36#include <linux/sysfs.h>
37#include <linux/types.h>
38
39#define GPIO_SIM_NGPIO_MAX 1024
40#define GPIO_SIM_PROP_MAX 5 /* Max 4 properties + sentinel. */
41#define GPIO_SIM_HOG_PROP_MAX 5
42#define GPIO_SIM_NUM_ATTRS 3 /* value, pull and sentinel */
43
44static DEFINE_IDA(gpio_sim_ida);
45
46struct gpio_sim_chip {
47 struct gpio_chip gc;
48 struct device *dev;
49 unsigned long *request_map;
50 unsigned long *direction_map;
51 unsigned long *value_map;
52 unsigned long *pull_map;
53 struct irq_domain *irq_sim;
54 struct mutex lock;
55 const struct attribute_group **attr_groups;
56};
57
58struct gpio_sim_attribute {
59 struct device_attribute dev_attr;
60 unsigned int offset;
61};
62
63static struct gpio_sim_attribute *
64to_gpio_sim_attr(struct device_attribute *dev_attr)
65{
66 return container_of(dev_attr, struct gpio_sim_attribute, dev_attr);
67}
68
69static int gpio_sim_apply_pull(struct gpio_sim_chip *chip,
70 unsigned int offset, int value)
71{
72 int irq, irq_type, ret;
73
74 guard(mutex)(&chip->lock);
75
76 if (test_bit(offset, chip->request_map) &&
77 test_bit(offset, chip->direction_map)) {
78 if (value == !!test_bit(offset, chip->value_map))
79 goto set_pull;
80
81 /*
82 * This is fine - it just means, nobody is listening
83 * for interrupts on this line, otherwise
84 * irq_create_mapping() would have been called from
85 * the to_irq() callback.
86 */
87 irq = irq_find_mapping(chip->irq_sim, offset);
88 if (!irq)
89 goto set_value;
90
91 irq_type = irq_get_trigger_type(irq);
92
93 if ((value && (irq_type & IRQ_TYPE_EDGE_RISING)) ||
94 (!value && (irq_type & IRQ_TYPE_EDGE_FALLING))) {
95 ret = irq_set_irqchip_state(irq, IRQCHIP_STATE_PENDING,
96 true);
97 if (ret)
98 goto set_pull;
99 }
100 }
101
102set_value:
103 /* Change the value unless we're actively driving the line. */
104 if (!test_bit(offset, chip->request_map) ||
105 test_bit(offset, chip->direction_map))
106 __assign_bit(offset, chip->value_map, value);
107
108set_pull:
109 __assign_bit(offset, chip->pull_map, value);
110 return 0;
111}
112
113static int gpio_sim_get(struct gpio_chip *gc, unsigned int offset)
114{
115 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
116
117 guard(mutex)(&chip->lock);
118
119 return !!test_bit(offset, chip->value_map);
120}
121
122static int gpio_sim_set(struct gpio_chip *gc, unsigned int offset, int value)
123{
124 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
125
126 scoped_guard(mutex, &chip->lock)
127 __assign_bit(offset, chip->value_map, value);
128
129 return 0;
130}
131
132static int gpio_sim_get_multiple(struct gpio_chip *gc,
133 unsigned long *mask, unsigned long *bits)
134{
135 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
136
137 scoped_guard(mutex, &chip->lock)
138 bitmap_replace(bits, bits, chip->value_map, mask, gc->ngpio);
139
140 return 0;
141}
142
143static int gpio_sim_set_multiple(struct gpio_chip *gc,
144 unsigned long *mask, unsigned long *bits)
145{
146 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
147
148 scoped_guard(mutex, &chip->lock)
149 bitmap_replace(chip->value_map, chip->value_map, bits, mask,
150 gc->ngpio);
151
152 return 0;
153}
154
155static int gpio_sim_direction_output(struct gpio_chip *gc,
156 unsigned int offset, int value)
157{
158 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
159
160 scoped_guard(mutex, &chip->lock) {
161 __clear_bit(offset, chip->direction_map);
162 __assign_bit(offset, chip->value_map, value);
163 }
164
165 return 0;
166}
167
168static int gpio_sim_direction_input(struct gpio_chip *gc, unsigned int offset)
169{
170 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
171
172 scoped_guard(mutex, &chip->lock)
173 __set_bit(offset, chip->direction_map);
174
175 return 0;
176}
177
178static int gpio_sim_get_direction(struct gpio_chip *gc, unsigned int offset)
179{
180 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
181 int direction;
182
183 scoped_guard(mutex, &chip->lock)
184 direction = !!test_bit(offset, chip->direction_map);
185
186 return direction ? GPIO_LINE_DIRECTION_IN : GPIO_LINE_DIRECTION_OUT;
187}
188
189static int gpio_sim_set_config(struct gpio_chip *gc, unsigned int offset,
190 unsigned long config)
191{
192 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
193
194 switch (pinconf_to_config_param(config)) {
195 case PIN_CONFIG_BIAS_PULL_UP:
196 return gpio_sim_apply_pull(chip, offset, 1);
197 case PIN_CONFIG_BIAS_PULL_DOWN:
198 return gpio_sim_apply_pull(chip, offset, 0);
199 default:
200 break;
201 }
202
203 return -ENOTSUPP;
204}
205
206static int gpio_sim_to_irq(struct gpio_chip *gc, unsigned int offset)
207{
208 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
209
210 return irq_create_mapping(chip->irq_sim, offset);
211}
212
213static int gpio_sim_request(struct gpio_chip *gc, unsigned int offset)
214{
215 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
216
217 scoped_guard(mutex, &chip->lock)
218 __set_bit(offset, chip->request_map);
219
220 return 0;
221}
222
223static void gpio_sim_free(struct gpio_chip *gc, unsigned int offset)
224{
225 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
226
227 scoped_guard(mutex, &chip->lock) {
228 __assign_bit(offset, chip->value_map,
229 !!test_bit(offset, chip->pull_map));
230 __clear_bit(offset, chip->request_map);
231 }
232}
233
234static int gpio_sim_irq_requested(struct irq_domain *domain,
235 irq_hw_number_t hwirq, void *data)
236{
237 struct gpio_sim_chip *chip = data;
238
239 return gpiochip_lock_as_irq(&chip->gc, hwirq);
240}
241
242static void gpio_sim_irq_released(struct irq_domain *domain,
243 irq_hw_number_t hwirq, void *data)
244{
245 struct gpio_sim_chip *chip = data;
246
247 gpiochip_unlock_as_irq(&chip->gc, hwirq);
248}
249
250static const struct irq_sim_ops gpio_sim_irq_sim_ops = {
251 .irq_sim_irq_requested = gpio_sim_irq_requested,
252 .irq_sim_irq_released = gpio_sim_irq_released,
253};
254
255static void gpio_sim_dbg_show(struct seq_file *seq, struct gpio_chip *gc)
256{
257 struct gpio_sim_chip *chip = gpiochip_get_data(gc);
258 const char *label;
259 int i;
260
261 guard(mutex)(&chip->lock);
262
263 for_each_hwgpio(gc, i, label)
264 seq_printf(seq, " gpio-%-3d (%s) %s,%s\n", i,
265 label ?: "<unused>",
266 test_bit(i, chip->direction_map) ? "input" :
267 test_bit(i, chip->value_map) ? "output-high" :
268 "output-low",
269 test_bit(i, chip->pull_map) ? "pull-up" :
270 "pull-down");
271}
272
273static ssize_t gpio_sim_sysfs_val_show(struct device *dev,
274 struct device_attribute *attr, char *buf)
275{
276 struct gpio_sim_attribute *line_attr = to_gpio_sim_attr(attr);
277 struct gpio_sim_chip *chip = dev_get_drvdata(dev);
278 int val;
279
280 scoped_guard(mutex, &chip->lock)
281 val = !!test_bit(line_attr->offset, chip->value_map);
282
283 return sysfs_emit(buf, "%d\n", val);
284}
285
286static ssize_t gpio_sim_sysfs_val_store(struct device *dev,
287 struct device_attribute *attr,
288 const char *buf, size_t count)
289{
290 /*
291 * Not assigning this function will result in write() returning -EIO
292 * which is confusing. Return -EPERM explicitly.
293 */
294 return -EPERM;
295}
296
297static const char *const gpio_sim_sysfs_pull_strings[] = {
298 [0] = "pull-down",
299 [1] = "pull-up",
300};
301
302static ssize_t gpio_sim_sysfs_pull_show(struct device *dev,
303 struct device_attribute *attr,
304 char *buf)
305{
306 struct gpio_sim_attribute *line_attr = to_gpio_sim_attr(attr);
307 struct gpio_sim_chip *chip = dev_get_drvdata(dev);
308 int pull;
309
310 scoped_guard(mutex, &chip->lock)
311 pull = !!test_bit(line_attr->offset, chip->pull_map);
312
313 return sysfs_emit(buf, "%s\n", gpio_sim_sysfs_pull_strings[pull]);
314}
315
316static ssize_t gpio_sim_sysfs_pull_store(struct device *dev,
317 struct device_attribute *attr,
318 const char *buf, size_t len)
319{
320 struct gpio_sim_attribute *line_attr = to_gpio_sim_attr(attr);
321 struct gpio_sim_chip *chip = dev_get_drvdata(dev);
322 int ret, pull;
323
324 pull = sysfs_match_string(gpio_sim_sysfs_pull_strings, buf);
325 if (pull < 0)
326 return pull;
327
328 ret = gpio_sim_apply_pull(chip, line_attr->offset, pull);
329 if (ret)
330 return ret;
331
332 return len;
333}
334
335static void gpio_sim_put_device(void *data)
336{
337 struct device *dev = data;
338
339 put_device(dev);
340}
341
342static void gpio_sim_dispose_mappings(void *data)
343{
344 struct gpio_sim_chip *chip = data;
345 unsigned int i;
346
347 for (i = 0; i < chip->gc.ngpio; i++)
348 irq_dispose_mapping(irq_find_mapping(chip->irq_sim, i));
349}
350
351static void gpio_sim_sysfs_remove(void *data)
352{
353 struct gpio_sim_chip *chip = data;
354
355 sysfs_remove_groups(&chip->dev->kobj, chip->attr_groups);
356}
357
358static int gpio_sim_setup_sysfs(struct gpio_sim_chip *chip)
359{
360 struct device_attribute *val_dev_attr, *pull_dev_attr;
361 struct gpio_sim_attribute *val_attr, *pull_attr;
362 unsigned int num_lines = chip->gc.ngpio;
363 struct device *dev = chip->gc.parent;
364 struct attribute_group *attr_group;
365 struct attribute **attrs;
366 int i, ret;
367
368 chip->attr_groups = devm_kcalloc(dev, sizeof(*chip->attr_groups),
369 num_lines + 1, GFP_KERNEL);
370 if (!chip->attr_groups)
371 return -ENOMEM;
372
373 for (i = 0; i < num_lines; i++) {
374 attr_group = devm_kzalloc(dev, sizeof(*attr_group), GFP_KERNEL);
375 attrs = devm_kcalloc(dev, GPIO_SIM_NUM_ATTRS, sizeof(*attrs),
376 GFP_KERNEL);
377 val_attr = devm_kzalloc(dev, sizeof(*val_attr), GFP_KERNEL);
378 pull_attr = devm_kzalloc(dev, sizeof(*pull_attr), GFP_KERNEL);
379 if (!attr_group || !attrs || !val_attr || !pull_attr)
380 return -ENOMEM;
381
382 attr_group->name = devm_kasprintf(dev, GFP_KERNEL,
383 "sim_gpio%u", i);
384 if (!attr_group->name)
385 return -ENOMEM;
386
387 val_attr->offset = pull_attr->offset = i;
388
389 val_dev_attr = &val_attr->dev_attr;
390 pull_dev_attr = &pull_attr->dev_attr;
391
392 sysfs_attr_init(&val_dev_attr->attr);
393 sysfs_attr_init(&pull_dev_attr->attr);
394
395 val_dev_attr->attr.name = "value";
396 pull_dev_attr->attr.name = "pull";
397
398 val_dev_attr->attr.mode = pull_dev_attr->attr.mode = 0644;
399
400 val_dev_attr->show = gpio_sim_sysfs_val_show;
401 val_dev_attr->store = gpio_sim_sysfs_val_store;
402 pull_dev_attr->show = gpio_sim_sysfs_pull_show;
403 pull_dev_attr->store = gpio_sim_sysfs_pull_store;
404
405 attrs[0] = &val_dev_attr->attr;
406 attrs[1] = &pull_dev_attr->attr;
407
408 attr_group->attrs = attrs;
409 chip->attr_groups[i] = attr_group;
410 }
411
412 ret = sysfs_create_groups(&chip->dev->kobj, chip->attr_groups);
413 if (ret)
414 return ret;
415
416 return devm_add_action_or_reset(dev, gpio_sim_sysfs_remove, chip);
417}
418
419static int gpio_sim_add_bank(struct fwnode_handle *swnode, struct device *dev)
420{
421 struct gpio_sim_chip *chip;
422 struct gpio_chip *gc;
423 const char *label;
424 u32 num_lines;
425 int ret;
426
427 ret = fwnode_property_read_u32(swnode, "ngpios", &num_lines);
428 if (ret)
429 return ret;
430
431 if (num_lines > GPIO_SIM_NGPIO_MAX)
432 return -ERANGE;
433
434 ret = fwnode_property_read_string(swnode, "gpio-sim,label", &label);
435 if (ret) {
436 label = devm_kasprintf(dev, GFP_KERNEL, "%s:%pfwP",
437 dev_name(dev), swnode);
438 if (!label)
439 return -ENOMEM;
440 }
441
442 chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
443 if (!chip)
444 return -ENOMEM;
445
446 chip->request_map = devm_bitmap_zalloc(dev, num_lines, GFP_KERNEL);
447 if (!chip->request_map)
448 return -ENOMEM;
449
450 chip->direction_map = devm_bitmap_alloc(dev, num_lines, GFP_KERNEL);
451 if (!chip->direction_map)
452 return -ENOMEM;
453
454 /* Default to input mode. */
455 bitmap_fill(chip->direction_map, num_lines);
456
457 chip->value_map = devm_bitmap_zalloc(dev, num_lines, GFP_KERNEL);
458 if (!chip->value_map)
459 return -ENOMEM;
460
461 chip->pull_map = devm_bitmap_zalloc(dev, num_lines, GFP_KERNEL);
462 if (!chip->pull_map)
463 return -ENOMEM;
464
465 chip->irq_sim = devm_irq_domain_create_sim_full(dev, swnode, num_lines,
466 &gpio_sim_irq_sim_ops,
467 chip);
468 if (IS_ERR(chip->irq_sim))
469 return PTR_ERR(chip->irq_sim);
470
471 ret = devm_add_action_or_reset(dev, gpio_sim_dispose_mappings, chip);
472 if (ret)
473 return ret;
474
475 ret = devm_mutex_init(dev, &chip->lock);
476 if (ret)
477 return ret;
478
479 gc = &chip->gc;
480 gc->base = -1;
481 gc->ngpio = num_lines;
482 gc->label = label;
483 gc->owner = THIS_MODULE;
484 gc->parent = dev;
485 gc->fwnode = swnode;
486 gc->get = gpio_sim_get;
487 gc->set = gpio_sim_set;
488 gc->get_multiple = gpio_sim_get_multiple;
489 gc->set_multiple = gpio_sim_set_multiple;
490 gc->direction_output = gpio_sim_direction_output;
491 gc->direction_input = gpio_sim_direction_input;
492 gc->get_direction = gpio_sim_get_direction;
493 gc->set_config = gpio_sim_set_config;
494 gc->to_irq = gpio_sim_to_irq;
495 gc->request = gpio_sim_request;
496 gc->free = gpio_sim_free;
497 gc->dbg_show = PTR_IF(IS_ENABLED(CONFIG_DEBUG_FS), gpio_sim_dbg_show);
498 gc->can_sleep = true;
499
500 ret = devm_gpiochip_add_data(dev, gc, chip);
501 if (ret)
502 return ret;
503
504 chip->dev = device_find_child(dev, swnode, device_match_fwnode);
505 if (!chip->dev)
506 return -ENODEV;
507
508 ret = devm_add_action_or_reset(dev, gpio_sim_put_device, chip->dev);
509 if (ret)
510 return ret;
511
512 /* Used by sysfs callbacks. */
513 dev_set_drvdata(chip->dev, chip);
514
515 return gpio_sim_setup_sysfs(chip);
516}
517
518static int gpio_sim_probe(struct platform_device *pdev)
519{
520 struct device *dev = &pdev->dev;
521 int ret;
522
523 device_for_each_child_node_scoped(dev, swnode) {
524 ret = gpio_sim_add_bank(swnode, dev);
525 if (ret)
526 return ret;
527 }
528
529 return 0;
530}
531
532static const struct of_device_id gpio_sim_of_match[] = {
533 { .compatible = "gpio-simulator" },
534 { }
535};
536MODULE_DEVICE_TABLE(of, gpio_sim_of_match);
537
538static struct platform_driver gpio_sim_driver = {
539 .driver = {
540 .name = "gpio-sim",
541 .of_match_table = gpio_sim_of_match,
542 },
543 .probe = gpio_sim_probe,
544};
545
546struct gpio_sim_device {
547 struct platform_device *pdev;
548 struct config_group group;
549
550 int id;
551
552 /*
553 * Each configfs filesystem operation is protected with the subsystem
554 * mutex. Each separate attribute is protected with the buffer mutex.
555 * This structure however can be modified by callbacks of different
556 * attributes so we need another lock.
557 *
558 * We use this lock for protecting all data structures owned by this
559 * object too.
560 */
561 struct mutex lock;
562
563 struct list_head bank_list;
564};
565
566static struct gpio_sim_device *to_gpio_sim_device(struct config_item *item)
567{
568 struct config_group *group = to_config_group(item);
569
570 return container_of(group, struct gpio_sim_device, group);
571}
572
573struct gpio_sim_bank {
574 struct config_group group;
575
576 /*
577 * We could have used the ci_parent field of the config_item but
578 * configfs is stupid and calls the item's release callback after
579 * already having cleared the parent pointer even though the parent
580 * is guaranteed to survive the child...
581 *
582 * So we need to store the pointer to the parent struct here. We can
583 * dereference it anywhere we need with no checks and no locking as
584 * it's guaranteed to survive the children and protected by configfs
585 * locks.
586 *
587 * Same for other structures.
588 */
589 struct gpio_sim_device *parent;
590 struct list_head siblings;
591
592 char *label;
593 unsigned int num_lines;
594
595 struct list_head line_list;
596
597 struct fwnode_handle *swnode;
598};
599
600static struct gpio_sim_bank *to_gpio_sim_bank(struct config_item *item)
601{
602 struct config_group *group = to_config_group(item);
603
604 return container_of(group, struct gpio_sim_bank, group);
605}
606
607static bool gpio_sim_bank_has_label(struct gpio_sim_bank *bank)
608{
609 return bank->label && *bank->label;
610}
611
612static struct gpio_sim_device *
613gpio_sim_bank_get_device(struct gpio_sim_bank *bank)
614{
615 return bank->parent;
616}
617
618struct gpio_sim_hog;
619
620struct gpio_sim_line {
621 struct config_group group;
622
623 struct gpio_sim_bank *parent;
624 struct list_head siblings;
625
626 unsigned int offset;
627 char *name;
628 bool valid;
629
630 /* There can only be one hog per line. */
631 struct gpio_sim_hog *hog;
632};
633
634static struct gpio_sim_line *to_gpio_sim_line(struct config_item *item)
635{
636 struct config_group *group = to_config_group(item);
637
638 return container_of(group, struct gpio_sim_line, group);
639}
640
641static struct gpio_sim_device *
642gpio_sim_line_get_device(struct gpio_sim_line *line)
643{
644 struct gpio_sim_bank *bank = line->parent;
645
646 return gpio_sim_bank_get_device(bank);
647}
648
649struct gpio_sim_hog {
650 struct config_item item;
651 struct gpio_sim_line *parent;
652
653 char *name;
654 int dir;
655 bool active_low;
656};
657
658static struct gpio_sim_hog *to_gpio_sim_hog(struct config_item *item)
659{
660 return container_of(item, struct gpio_sim_hog, item);
661}
662
663static struct gpio_sim_device *gpio_sim_hog_get_device(struct gpio_sim_hog *hog)
664{
665 struct gpio_sim_line *line = hog->parent;
666
667 return gpio_sim_line_get_device(line);
668}
669
670static bool gpio_sim_device_is_live(struct gpio_sim_device *dev)
671{
672 lockdep_assert_held(&dev->lock);
673
674 return !!dev->pdev;
675}
676
677static char *gpio_sim_strdup_trimmed(const char *str, size_t count)
678{
679 char *trimmed;
680
681 trimmed = kstrndup(skip_spaces(str), count, GFP_KERNEL);
682 if (!trimmed)
683 return NULL;
684
685 return strim(trimmed);
686}
687
688static ssize_t gpio_sim_device_config_dev_name_show(struct config_item *item,
689 char *page)
690{
691 struct gpio_sim_device *dev = to_gpio_sim_device(item);
692 struct platform_device *pdev;
693
694 guard(mutex)(&dev->lock);
695
696 pdev = dev->pdev;
697 if (pdev)
698 return sprintf(page, "%s\n", dev_name(&pdev->dev));
699
700 return sprintf(page, "gpio-sim.%d\n", dev->id);
701}
702
703CONFIGFS_ATTR_RO(gpio_sim_device_config_, dev_name);
704
705static ssize_t
706gpio_sim_device_config_live_show(struct config_item *item, char *page)
707{
708 struct gpio_sim_device *dev = to_gpio_sim_device(item);
709 bool live;
710
711 scoped_guard(mutex, &dev->lock)
712 live = gpio_sim_device_is_live(dev);
713
714 return sprintf(page, "%c\n", live ? '1' : '0');
715}
716
717static unsigned int gpio_sim_get_line_names_size(struct gpio_sim_bank *bank)
718{
719 struct gpio_sim_line *line;
720 unsigned int size = 0;
721
722 list_for_each_entry(line, &bank->line_list, siblings) {
723 if (!line->name || (line->offset >= bank->num_lines))
724 continue;
725
726 size = max(size, line->offset + 1);
727 }
728
729 return size;
730}
731
732static void
733gpio_sim_set_line_names(struct gpio_sim_bank *bank, char **line_names)
734{
735 struct gpio_sim_line *line;
736
737 list_for_each_entry(line, &bank->line_list, siblings) {
738 if (!line->name || (line->offset >= bank->num_lines))
739 continue;
740
741 line_names[line->offset] = line->name;
742 }
743}
744
745static unsigned int gpio_sim_get_reserved_ranges_size(struct gpio_sim_bank *bank)
746{
747 struct gpio_sim_line *line;
748 unsigned int size = 0;
749
750 list_for_each_entry(line, &bank->line_list, siblings) {
751 if (line->valid)
752 continue;
753
754 size += 2;
755 }
756
757 return size;
758}
759
760static void gpio_sim_set_reserved_ranges(struct gpio_sim_bank *bank,
761 u32 *ranges)
762{
763 struct gpio_sim_line *line;
764 int i = 0;
765
766 list_for_each_entry(line, &bank->line_list, siblings) {
767 if (line->valid)
768 continue;
769
770 ranges[i++] = line->offset;
771 ranges[i++] = 1;
772 }
773}
774
775static struct fwnode_handle *
776gpio_sim_make_bank_swnode(struct gpio_sim_bank *bank,
777 struct fwnode_handle *parent)
778{
779 unsigned int prop_idx = 0, line_names_size, ranges_size;
780 struct property_entry properties[GPIO_SIM_PROP_MAX];
781 char **line_names __free(kfree) = NULL;
782 u32 *ranges __free(kfree) = NULL;
783
784 memset(properties, 0, sizeof(properties));
785
786 properties[prop_idx++] = PROPERTY_ENTRY_U32("ngpios", bank->num_lines);
787
788 if (gpio_sim_bank_has_label(bank))
789 properties[prop_idx++] = PROPERTY_ENTRY_STRING("gpio-sim,label",
790 bank->label);
791
792 line_names_size = gpio_sim_get_line_names_size(bank);
793 if (line_names_size) {
794 line_names = kcalloc(line_names_size, sizeof(*line_names),
795 GFP_KERNEL);
796 if (!line_names)
797 return ERR_PTR(-ENOMEM);
798
799 gpio_sim_set_line_names(bank, line_names);
800
801 properties[prop_idx++] = PROPERTY_ENTRY_STRING_ARRAY_LEN(
802 "gpio-line-names",
803 line_names, line_names_size);
804 }
805
806 ranges_size = gpio_sim_get_reserved_ranges_size(bank);
807 if (ranges_size) {
808 ranges = kcalloc(ranges_size, sizeof(u32), GFP_KERNEL);
809 if (!ranges)
810 return ERR_PTR(-ENOMEM);
811
812 gpio_sim_set_reserved_ranges(bank, ranges);
813
814 properties[prop_idx++] = PROPERTY_ENTRY_U32_ARRAY_LEN(
815 "gpio-reserved-ranges",
816 ranges, ranges_size);
817 }
818
819 return fwnode_create_software_node(properties, parent);
820}
821
822static int gpio_sim_bank_add_hogs(struct gpio_sim_bank *bank)
823{
824 struct property_entry properties[GPIO_SIM_HOG_PROP_MAX];
825 struct fwnode_handle *swnode;
826 struct gpio_sim_line *line;
827 struct gpio_sim_hog *hog;
828 unsigned int idx;
829 u32 gpios[2];
830
831 list_for_each_entry(line, &bank->line_list, siblings) {
832 if (!line->hog)
833 continue;
834
835 hog = line->hog;
836
837 gpios[0] = line->offset;
838 gpios[1] = hog->active_low ? 1 : 0;
839
840 memset(properties, 0, sizeof(properties));
841
842 idx = 0;
843 properties[idx++] = PROPERTY_ENTRY_BOOL("gpio-hog");
844 properties[idx++] = PROPERTY_ENTRY_U32_ARRAY("gpios", gpios);
845 properties[idx++] = PROPERTY_ENTRY_STRING("line-name", hog->name);
846
847 switch (hog->dir) {
848 case GPIOD_IN:
849 properties[idx++] = PROPERTY_ENTRY_BOOL("input");
850 break;
851 case GPIOD_OUT_HIGH:
852 properties[idx++] = PROPERTY_ENTRY_BOOL("output-high");
853 break;
854 case GPIOD_OUT_LOW:
855 properties[idx++] = PROPERTY_ENTRY_BOOL("output-low");
856 break;
857 default:
858 /* Would have been validated at configfs store. */
859 WARN(1, "Unexpected hog direction value: %d", hog->dir);
860 return -EINVAL;
861 }
862
863 swnode = fwnode_create_software_node(properties, bank->swnode);
864 if (IS_ERR(swnode))
865 return PTR_ERR(swnode);
866 }
867
868 return 0;
869}
870
871static void gpio_sim_remove_swnode_recursive(struct fwnode_handle *swnode)
872{
873 struct fwnode_handle *child;
874
875 fwnode_for_each_child_node(swnode, child)
876 gpio_sim_remove_swnode_recursive(child);
877
878 fwnode_remove_software_node(swnode);
879}
880
881static bool gpio_sim_bank_labels_non_unique(struct gpio_sim_device *dev)
882{
883 struct gpio_sim_bank *this, *pos;
884
885 list_for_each_entry(this, &dev->bank_list, siblings) {
886 list_for_each_entry(pos, &dev->bank_list, siblings) {
887 if (this == pos || (!this->label || !pos->label))
888 continue;
889
890 if (strcmp(this->label, pos->label) == 0)
891 return true;
892 }
893 }
894
895 return false;
896}
897
898static int gpio_sim_device_activate(struct gpio_sim_device *dev)
899{
900 struct platform_device_info pdevinfo;
901 struct platform_device *pdev;
902 struct fwnode_handle *swnode;
903 struct gpio_sim_bank *bank;
904 int ret;
905
906 lockdep_assert_held(&dev->lock);
907
908 if (list_empty(&dev->bank_list))
909 return -ENODATA;
910
911 /*
912 * Non-unique GPIO device labels are a corner-case we don't support
913 * as it would interfere with machine hogging mechanism and has little
914 * use in real life.
915 */
916 if (gpio_sim_bank_labels_non_unique(dev))
917 return -EINVAL;
918
919 memset(&pdevinfo, 0, sizeof(pdevinfo));
920
921 swnode = fwnode_create_software_node(NULL, NULL);
922 if (IS_ERR(swnode))
923 return PTR_ERR(swnode);
924
925 list_for_each_entry(bank, &dev->bank_list, siblings) {
926 bank->swnode = gpio_sim_make_bank_swnode(bank, swnode);
927 if (IS_ERR(bank->swnode)) {
928 ret = PTR_ERR(bank->swnode);
929 goto err_remove_swnode;
930 }
931
932 ret = gpio_sim_bank_add_hogs(bank);
933 if (ret)
934 goto err_remove_swnode;
935 }
936
937 pdevinfo.name = "gpio-sim";
938 pdevinfo.fwnode = swnode;
939 pdevinfo.id = dev->id;
940
941 pdev = platform_device_register_full(&pdevinfo);
942 if (IS_ERR(pdev)) {
943 ret = PTR_ERR(pdev);
944 goto err_remove_swnode;
945 }
946
947 wait_for_device_probe();
948 if (!device_is_bound(&pdev->dev)) {
949 ret = -ENXIO;
950 goto err_unregister_pdev;
951 }
952
953 dev->pdev = pdev;
954 return 0;
955
956err_unregister_pdev:
957 platform_device_unregister(pdev);
958err_remove_swnode:
959 gpio_sim_remove_swnode_recursive(swnode);
960
961 return ret;
962}
963
964static void gpio_sim_device_deactivate(struct gpio_sim_device *dev)
965{
966 struct fwnode_handle *swnode;
967
968 lockdep_assert_held(&dev->lock);
969
970 swnode = dev_fwnode(&dev->pdev->dev);
971 platform_device_unregister(dev->pdev);
972 dev->pdev = NULL;
973 gpio_sim_remove_swnode_recursive(swnode);
974}
975
976static void
977gpio_sim_device_lockup_configfs(struct gpio_sim_device *dev, bool lock)
978{
979 struct configfs_subsystem *subsys = dev->group.cg_subsys;
980 struct gpio_sim_bank *bank;
981 struct gpio_sim_line *line;
982 struct config_item *item;
983
984 /*
985 * The device only needs to depend on leaf entries. This is
986 * sufficient to lock up all the configfs entries that the
987 * instantiated, alive device depends on.
988 */
989 list_for_each_entry(bank, &dev->bank_list, siblings) {
990 list_for_each_entry(line, &bank->line_list, siblings) {
991 item = line->hog ? &line->hog->item
992 : &line->group.cg_item;
993
994 if (lock)
995 WARN_ON(configfs_depend_item_unlocked(subsys,
996 item));
997 else
998 configfs_undepend_item_unlocked(item);
999 }
1000 }
1001}
1002
1003static ssize_t
1004gpio_sim_device_config_live_store(struct config_item *item,
1005 const char *page, size_t count)
1006{
1007 struct gpio_sim_device *dev = to_gpio_sim_device(item);
1008 bool live;
1009 int ret;
1010
1011 ret = kstrtobool(page, &live);
1012 if (ret)
1013 return ret;
1014
1015 if (live)
1016 gpio_sim_device_lockup_configfs(dev, true);
1017
1018 scoped_guard(mutex, &dev->lock) {
1019 if (live == gpio_sim_device_is_live(dev))
1020 ret = -EPERM;
1021 else if (live)
1022 ret = gpio_sim_device_activate(dev);
1023 else
1024 gpio_sim_device_deactivate(dev);
1025 }
1026
1027 /*
1028 * Undepend is required only if device disablement (live == 0)
1029 * succeeds or if device enablement (live == 1) fails.
1030 */
1031 if (live == !!ret)
1032 gpio_sim_device_lockup_configfs(dev, false);
1033
1034 return ret ?: count;
1035}
1036
1037CONFIGFS_ATTR(gpio_sim_device_config_, live);
1038
1039static struct configfs_attribute *gpio_sim_device_config_attrs[] = {
1040 &gpio_sim_device_config_attr_dev_name,
1041 &gpio_sim_device_config_attr_live,
1042 NULL
1043};
1044
1045struct gpio_sim_chip_name_ctx {
1046 struct fwnode_handle *swnode;
1047 char *page;
1048};
1049
1050static int gpio_sim_emit_chip_name(struct device *dev, void *data)
1051{
1052 struct gpio_sim_chip_name_ctx *ctx = data;
1053
1054 /* This would be the sysfs device exported in /sys/class/gpio. */
1055 if (dev->class)
1056 return 0;
1057
1058 if (device_match_fwnode(dev, ctx->swnode))
1059 return sprintf(ctx->page, "%s\n", dev_name(dev));
1060
1061 return 0;
1062}
1063
1064static ssize_t gpio_sim_bank_config_chip_name_show(struct config_item *item,
1065 char *page)
1066{
1067 struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
1068 struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
1069 struct gpio_sim_chip_name_ctx ctx = { bank->swnode, page };
1070
1071 guard(mutex)(&dev->lock);
1072
1073 if (gpio_sim_device_is_live(dev))
1074 return device_for_each_child(&dev->pdev->dev, &ctx,
1075 gpio_sim_emit_chip_name);
1076
1077 return sprintf(page, "none\n");
1078}
1079
1080CONFIGFS_ATTR_RO(gpio_sim_bank_config_, chip_name);
1081
1082static ssize_t
1083gpio_sim_bank_config_label_show(struct config_item *item, char *page)
1084{
1085 struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
1086 struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
1087
1088 guard(mutex)(&dev->lock);
1089
1090 return sprintf(page, "%s\n", bank->label ?: "");
1091}
1092
1093static ssize_t gpio_sim_bank_config_label_store(struct config_item *item,
1094 const char *page, size_t count)
1095{
1096 struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
1097 struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
1098 char *trimmed;
1099
1100 guard(mutex)(&dev->lock);
1101
1102 if (gpio_sim_device_is_live(dev))
1103 return -EBUSY;
1104
1105 trimmed = gpio_sim_strdup_trimmed(page, count);
1106 if (!trimmed)
1107 return -ENOMEM;
1108
1109 kfree(bank->label);
1110 bank->label = trimmed;
1111
1112 return count;
1113}
1114
1115CONFIGFS_ATTR(gpio_sim_bank_config_, label);
1116
1117static ssize_t
1118gpio_sim_bank_config_num_lines_show(struct config_item *item, char *page)
1119{
1120 struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
1121 struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
1122
1123 guard(mutex)(&dev->lock);
1124
1125 return sprintf(page, "%u\n", bank->num_lines);
1126}
1127
1128static ssize_t
1129gpio_sim_bank_config_num_lines_store(struct config_item *item,
1130 const char *page, size_t count)
1131{
1132 struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
1133 struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
1134 unsigned int num_lines;
1135 int ret;
1136
1137 ret = kstrtouint(page, 0, &num_lines);
1138 if (ret)
1139 return ret;
1140
1141 if (num_lines == 0)
1142 return -EINVAL;
1143
1144 guard(mutex)(&dev->lock);
1145
1146 if (gpio_sim_device_is_live(dev))
1147 return -EBUSY;
1148
1149 bank->num_lines = num_lines;
1150
1151 return count;
1152}
1153
1154CONFIGFS_ATTR(gpio_sim_bank_config_, num_lines);
1155
1156static struct configfs_attribute *gpio_sim_bank_config_attrs[] = {
1157 &gpio_sim_bank_config_attr_chip_name,
1158 &gpio_sim_bank_config_attr_label,
1159 &gpio_sim_bank_config_attr_num_lines,
1160 NULL
1161};
1162
1163static ssize_t
1164gpio_sim_line_config_name_show(struct config_item *item, char *page)
1165{
1166 struct gpio_sim_line *line = to_gpio_sim_line(item);
1167 struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
1168
1169 guard(mutex)(&dev->lock);
1170
1171 return sprintf(page, "%s\n", line->name ?: "");
1172}
1173
1174static ssize_t gpio_sim_line_config_name_store(struct config_item *item,
1175 const char *page, size_t count)
1176{
1177 struct gpio_sim_line *line = to_gpio_sim_line(item);
1178 struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
1179 char *trimmed;
1180
1181 guard(mutex)(&dev->lock);
1182
1183 if (gpio_sim_device_is_live(dev))
1184 return -EBUSY;
1185
1186 trimmed = gpio_sim_strdup_trimmed(page, count);
1187 if (!trimmed)
1188 return -ENOMEM;
1189
1190 kfree(line->name);
1191 line->name = trimmed;
1192
1193 return count;
1194}
1195
1196CONFIGFS_ATTR(gpio_sim_line_config_, name);
1197
1198static ssize_t
1199gpio_sim_line_config_valid_show(struct config_item *item, char *page)
1200{
1201 struct gpio_sim_line *line = to_gpio_sim_line(item);
1202 struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
1203
1204 guard(mutex)(&dev->lock);
1205
1206 return sprintf(page, "%c\n", line->valid ? '1' : '0');
1207}
1208
1209static ssize_t gpio_sim_line_config_valid_store(struct config_item *item,
1210 const char *page, size_t count)
1211{
1212 struct gpio_sim_line *line = to_gpio_sim_line(item);
1213 struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
1214 bool valid;
1215 int ret;
1216
1217 ret = kstrtobool(page, &valid);
1218 if (ret)
1219 return ret;
1220
1221 guard(mutex)(&dev->lock);
1222
1223 line->valid = valid;
1224
1225 return count;
1226}
1227
1228CONFIGFS_ATTR(gpio_sim_line_config_, valid);
1229
1230static struct configfs_attribute *gpio_sim_line_config_attrs[] = {
1231 &gpio_sim_line_config_attr_name,
1232 &gpio_sim_line_config_attr_valid,
1233 NULL
1234};
1235
1236static ssize_t gpio_sim_hog_config_name_show(struct config_item *item,
1237 char *page)
1238{
1239 struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
1240 struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
1241
1242 guard(mutex)(&dev->lock);
1243
1244 return sprintf(page, "%s\n", hog->name ?: "");
1245}
1246
1247static ssize_t gpio_sim_hog_config_name_store(struct config_item *item,
1248 const char *page, size_t count)
1249{
1250 struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
1251 struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
1252 char *trimmed;
1253
1254 guard(mutex)(&dev->lock);
1255
1256 if (gpio_sim_device_is_live(dev))
1257 return -EBUSY;
1258
1259 trimmed = gpio_sim_strdup_trimmed(page, count);
1260 if (!trimmed)
1261 return -ENOMEM;
1262
1263 kfree(hog->name);
1264 hog->name = trimmed;
1265
1266 return count;
1267}
1268
1269CONFIGFS_ATTR(gpio_sim_hog_config_, name);
1270
1271static ssize_t gpio_sim_hog_config_direction_show(struct config_item *item,
1272 char *page)
1273{
1274 struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
1275 struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
1276 char *repr;
1277 int dir;
1278
1279 scoped_guard(mutex, &dev->lock)
1280 dir = hog->dir;
1281
1282 switch (dir) {
1283 case GPIOD_IN:
1284 repr = "input";
1285 break;
1286 case GPIOD_OUT_HIGH:
1287 repr = "output-high";
1288 break;
1289 case GPIOD_OUT_LOW:
1290 repr = "output-low";
1291 break;
1292 default:
1293 /* This would be a programmer bug. */
1294 WARN(1, "Unexpected hog direction value: %d", dir);
1295 return -EINVAL;
1296 }
1297
1298 return sprintf(page, "%s\n", repr);
1299}
1300
1301static ssize_t
1302gpio_sim_hog_config_direction_store(struct config_item *item,
1303 const char *page, size_t count)
1304{
1305 struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
1306 struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
1307 int dir;
1308
1309 guard(mutex)(&dev->lock);
1310
1311 if (gpio_sim_device_is_live(dev))
1312 return -EBUSY;
1313
1314 if (sysfs_streq(page, "input"))
1315 dir = GPIOD_IN;
1316 else if (sysfs_streq(page, "output-high"))
1317 dir = GPIOD_OUT_HIGH;
1318 else if (sysfs_streq(page, "output-low"))
1319 dir = GPIOD_OUT_LOW;
1320 else
1321 return -EINVAL;
1322
1323 hog->dir = dir;
1324
1325 return count;
1326}
1327
1328CONFIGFS_ATTR(gpio_sim_hog_config_, direction);
1329
1330static ssize_t gpio_sim_hog_config_active_low_show(struct config_item *item,
1331 char *page)
1332{
1333 struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
1334 struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
1335
1336 guard(mutex)(&dev->lock);
1337
1338 return sprintf(page, "%c\n", hog->active_low ? '1' : '0');
1339}
1340
1341static ssize_t
1342gpio_sim_hog_config_active_low_store(struct config_item *item,
1343 const char *page, size_t count)
1344{
1345 struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
1346 struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
1347 bool active_low;
1348 int ret;
1349
1350 guard(mutex)(&dev->lock);
1351
1352 if (gpio_sim_device_is_live(dev))
1353 return -EBUSY;
1354
1355 ret = kstrtobool(page, &active_low);
1356 if (ret)
1357 return ret;
1358
1359 hog->active_low = active_low;
1360
1361 return count;
1362}
1363
1364CONFIGFS_ATTR(gpio_sim_hog_config_, active_low);
1365
1366static struct configfs_attribute *gpio_sim_hog_config_attrs[] = {
1367 &gpio_sim_hog_config_attr_name,
1368 &gpio_sim_hog_config_attr_direction,
1369 &gpio_sim_hog_config_attr_active_low,
1370 NULL
1371};
1372
1373static void gpio_sim_hog_config_item_release(struct config_item *item)
1374{
1375 struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
1376 struct gpio_sim_line *line = hog->parent;
1377 struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
1378
1379 scoped_guard(mutex, &dev->lock)
1380 line->hog = NULL;
1381
1382 kfree(hog->name);
1383 kfree(hog);
1384}
1385
1386static const struct configfs_item_operations gpio_sim_hog_config_item_ops = {
1387 .release = gpio_sim_hog_config_item_release,
1388};
1389
1390static const struct config_item_type gpio_sim_hog_config_type = {
1391 .ct_item_ops = &gpio_sim_hog_config_item_ops,
1392 .ct_attrs = gpio_sim_hog_config_attrs,
1393 .ct_owner = THIS_MODULE,
1394};
1395
1396static struct config_item *
1397gpio_sim_line_config_make_hog_item(struct config_group *group, const char *name)
1398{
1399 struct gpio_sim_line *line = to_gpio_sim_line(&group->cg_item);
1400 struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
1401 struct gpio_sim_hog *hog;
1402
1403 if (strcmp(name, "hog") != 0)
1404 return ERR_PTR(-EINVAL);
1405
1406 guard(mutex)(&dev->lock);
1407
1408 hog = kzalloc_obj(*hog);
1409 if (!hog)
1410 return ERR_PTR(-ENOMEM);
1411
1412 config_item_init_type_name(&hog->item, name,
1413 &gpio_sim_hog_config_type);
1414
1415 hog->dir = GPIOD_IN;
1416 hog->name = NULL;
1417 hog->parent = line;
1418 line->hog = hog;
1419
1420 return &hog->item;
1421}
1422
1423static void gpio_sim_line_config_group_release(struct config_item *item)
1424{
1425 struct gpio_sim_line *line = to_gpio_sim_line(item);
1426 struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
1427
1428 scoped_guard(mutex, &dev->lock)
1429 list_del(&line->siblings);
1430
1431 kfree(line->name);
1432 kfree(line);
1433}
1434
1435static const struct configfs_item_operations gpio_sim_line_config_item_ops = {
1436 .release = gpio_sim_line_config_group_release,
1437};
1438
1439static const struct configfs_group_operations gpio_sim_line_config_group_ops = {
1440 .make_item = gpio_sim_line_config_make_hog_item,
1441};
1442
1443static const struct config_item_type gpio_sim_line_config_type = {
1444 .ct_item_ops = &gpio_sim_line_config_item_ops,
1445 .ct_group_ops = &gpio_sim_line_config_group_ops,
1446 .ct_attrs = gpio_sim_line_config_attrs,
1447 .ct_owner = THIS_MODULE,
1448};
1449
1450static struct config_group *
1451gpio_sim_bank_config_make_line_group(struct config_group *group,
1452 const char *name)
1453{
1454 struct gpio_sim_bank *bank = to_gpio_sim_bank(&group->cg_item);
1455 struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
1456 struct gpio_sim_line *line;
1457 unsigned int offset;
1458 int ret, nchar;
1459
1460 ret = sscanf(name, "line%u%n", &offset, &nchar);
1461 if (ret != 1 || nchar != strlen(name))
1462 return ERR_PTR(-EINVAL);
1463
1464 guard(mutex)(&dev->lock);
1465
1466 if (gpio_sim_device_is_live(dev))
1467 return ERR_PTR(-EBUSY);
1468
1469 line = kzalloc_obj(*line);
1470 if (!line)
1471 return ERR_PTR(-ENOMEM);
1472
1473 config_group_init_type_name(&line->group, name,
1474 &gpio_sim_line_config_type);
1475
1476 line->parent = bank;
1477 line->offset = offset;
1478 line->valid = true;
1479 list_add_tail(&line->siblings, &bank->line_list);
1480
1481 return &line->group;
1482}
1483
1484static void gpio_sim_bank_config_group_release(struct config_item *item)
1485{
1486 struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
1487 struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
1488
1489 scoped_guard(mutex, &dev->lock)
1490 list_del(&bank->siblings);
1491
1492 kfree(bank->label);
1493 kfree(bank);
1494}
1495
1496static const struct configfs_item_operations gpio_sim_bank_config_item_ops = {
1497 .release = gpio_sim_bank_config_group_release,
1498};
1499
1500static const struct configfs_group_operations gpio_sim_bank_config_group_ops = {
1501 .make_group = gpio_sim_bank_config_make_line_group,
1502};
1503
1504static const struct config_item_type gpio_sim_bank_config_group_type = {
1505 .ct_item_ops = &gpio_sim_bank_config_item_ops,
1506 .ct_group_ops = &gpio_sim_bank_config_group_ops,
1507 .ct_attrs = gpio_sim_bank_config_attrs,
1508 .ct_owner = THIS_MODULE,
1509};
1510
1511static struct config_group *
1512gpio_sim_device_config_make_bank_group(struct config_group *group,
1513 const char *name)
1514{
1515 struct gpio_sim_device *dev = to_gpio_sim_device(&group->cg_item);
1516 struct gpio_sim_bank *bank;
1517
1518 guard(mutex)(&dev->lock);
1519
1520 if (gpio_sim_device_is_live(dev))
1521 return ERR_PTR(-EBUSY);
1522
1523 bank = kzalloc_obj(*bank);
1524 if (!bank)
1525 return ERR_PTR(-ENOMEM);
1526
1527 config_group_init_type_name(&bank->group, name,
1528 &gpio_sim_bank_config_group_type);
1529 bank->num_lines = 1;
1530 bank->parent = dev;
1531 INIT_LIST_HEAD(&bank->line_list);
1532 list_add_tail(&bank->siblings, &dev->bank_list);
1533
1534 return &bank->group;
1535}
1536
1537static void gpio_sim_device_config_group_release(struct config_item *item)
1538{
1539 struct gpio_sim_device *dev = to_gpio_sim_device(item);
1540
1541 scoped_guard(mutex, &dev->lock) {
1542 if (gpio_sim_device_is_live(dev))
1543 gpio_sim_device_deactivate(dev);
1544 }
1545
1546 mutex_destroy(&dev->lock);
1547 ida_free(&gpio_sim_ida, dev->id);
1548 kfree(dev);
1549}
1550
1551static const struct configfs_item_operations gpio_sim_device_config_item_ops = {
1552 .release = gpio_sim_device_config_group_release,
1553};
1554
1555static const struct configfs_group_operations gpio_sim_device_config_group_ops = {
1556 .make_group = gpio_sim_device_config_make_bank_group,
1557};
1558
1559static const struct config_item_type gpio_sim_device_config_group_type = {
1560 .ct_item_ops = &gpio_sim_device_config_item_ops,
1561 .ct_group_ops = &gpio_sim_device_config_group_ops,
1562 .ct_attrs = gpio_sim_device_config_attrs,
1563 .ct_owner = THIS_MODULE,
1564};
1565
1566static struct config_group *
1567gpio_sim_config_make_device_group(struct config_group *group, const char *name)
1568{
1569 int id;
1570
1571 struct gpio_sim_device *dev __free(kfree) = kzalloc_obj(*dev);
1572 if (!dev)
1573 return ERR_PTR(-ENOMEM);
1574
1575 id = ida_alloc(&gpio_sim_ida, GFP_KERNEL);
1576 if (id < 0)
1577 return ERR_PTR(id);
1578
1579 config_group_init_type_name(&dev->group, name,
1580 &gpio_sim_device_config_group_type);
1581 dev->id = id;
1582 mutex_init(&dev->lock);
1583 INIT_LIST_HEAD(&dev->bank_list);
1584
1585 return &no_free_ptr(dev)->group;
1586}
1587
1588static const struct configfs_group_operations gpio_sim_config_group_ops = {
1589 .make_group = gpio_sim_config_make_device_group,
1590};
1591
1592static const struct config_item_type gpio_sim_config_type = {
1593 .ct_group_ops = &gpio_sim_config_group_ops,
1594 .ct_owner = THIS_MODULE,
1595};
1596
1597static struct configfs_subsystem gpio_sim_config_subsys = {
1598 .su_group = {
1599 .cg_item = {
1600 .ci_namebuf = "gpio-sim",
1601 .ci_type = &gpio_sim_config_type,
1602 },
1603 },
1604};
1605
1606static int __init gpio_sim_init(void)
1607{
1608 int ret;
1609
1610 ret = platform_driver_register(&gpio_sim_driver);
1611 if (ret) {
1612 pr_err("Error %d while registering the platform driver\n", ret);
1613 return ret;
1614 }
1615
1616 config_group_init(&gpio_sim_config_subsys.su_group);
1617 mutex_init(&gpio_sim_config_subsys.su_mutex);
1618 ret = configfs_register_subsystem(&gpio_sim_config_subsys);
1619 if (ret) {
1620 pr_err("Error %d while registering the configfs subsystem %s\n",
1621 ret, gpio_sim_config_subsys.su_group.cg_item.ci_namebuf);
1622 mutex_destroy(&gpio_sim_config_subsys.su_mutex);
1623 platform_driver_unregister(&gpio_sim_driver);
1624 return ret;
1625 }
1626
1627 return 0;
1628}
1629module_init(gpio_sim_init);
1630
1631static void __exit gpio_sim_exit(void)
1632{
1633 configfs_unregister_subsystem(&gpio_sim_config_subsys);
1634 mutex_destroy(&gpio_sim_config_subsys.su_mutex);
1635 platform_driver_unregister(&gpio_sim_driver);
1636}
1637module_exit(gpio_sim_exit);
1638
1639MODULE_AUTHOR("Bartosz Golaszewski <brgl@bgdev.pl>");
1640MODULE_DESCRIPTION("GPIO Simulator Module");
1641MODULE_LICENSE("GPL");