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