OSCL-LXR linux-6.0.1/​drivers/​gpio/​gpio-sim.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  * GPIO testing driver based on configfs.
  *
  * Copyright (C) 2021 Bartosz Golaszewski <brgl@bgdev.pl>
  */
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/bitmap.h>
 #include <linux/completion.h>
 #include <linux/configfs.h>
 #include <linux/device.h>
 #include <linux/gpio/driver.h>
 #include <linux/gpio/machine.h>
 #include <linux/idr.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/irq_sim.h>
 #include <linux/list.h>
 #include <linux/mod_devicetable.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/notifier.h>
 #include <linux/platform_device.h>
 #include <linux/property.h>
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/string_helpers.h>
 #include <linux/sysfs.h>
 
 #include "gpiolib.h"
 
 #define GPIO_SIM_PROP_MAX   4 /* Max 3 properties + sentinel. */
 #define GPIO_SIM_NUM_ATTRS  3 /* value, pull and sentinel */
 
 static DEFINE_IDA(gpio_sim_ida);
 
 struct gpio_sim_chip {
     struct gpio_chip gc;
     unsigned long *direction_map;
     unsigned long *value_map;
     unsigned long *pull_map;
     struct irq_domain *irq_sim;
     struct mutex lock;
     const struct attribute_group **attr_groups;
 };
 
 struct gpio_sim_attribute {
     struct device_attribute dev_attr;
     unsigned int offset;
 };
 
 static struct gpio_sim_attribute *
 to_gpio_sim_attr(struct device_attribute *dev_attr)
 {
     return container_of(dev_attr, struct gpio_sim_attribute, dev_attr);
 }
 
 static int gpio_sim_apply_pull(struct gpio_sim_chip *chip,
                    unsigned int offset, int value)
 {
     int irq, irq_type, ret;
     struct gpio_desc *desc;
     struct gpio_chip *gc;
 
     gc = &chip->gc;
     desc = &gc->gpiodev->descs[offset];
 
     mutex_lock(&chip->lock);
 
     if (test_bit(FLAG_REQUESTED, &desc->flags) &&
         !test_bit(FLAG_IS_OUT, &desc->flags)) {
         if (value == !!test_bit(offset, chip->value_map))
             goto set_pull;
 
         /*
          * This is fine - it just means, nobody is listening
          * for interrupts on this line, otherwise
          * irq_create_mapping() would have been called from
          * the to_irq() callback.
          */
         irq = irq_find_mapping(chip->irq_sim, offset);
         if (!irq)
             goto set_value;
 
         irq_type = irq_get_trigger_type(irq);
 
         if ((value && (irq_type & IRQ_TYPE_EDGE_RISING)) ||
             (!value && (irq_type & IRQ_TYPE_EDGE_FALLING))) {
             ret = irq_set_irqchip_state(irq, IRQCHIP_STATE_PENDING,
                             true);
             if (ret)
                 goto set_pull;
         }
     }
 
 set_value:
     /* Change the value unless we're actively driving the line. */
     if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
         !test_bit(FLAG_IS_OUT, &desc->flags))
         __assign_bit(offset, chip->value_map, value);
 
 set_pull:
     __assign_bit(offset, chip->pull_map, value);
     mutex_unlock(&chip->lock);
     return 0;
 }
 
 static int gpio_sim_get(struct gpio_chip *gc, unsigned int offset)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
     int ret;
 
     mutex_lock(&chip->lock);
     ret = !!test_bit(offset, chip->value_map);
     mutex_unlock(&chip->lock);
 
     return ret;
 }
 
 static void gpio_sim_set(struct gpio_chip *gc, unsigned int offset, int value)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
 
     mutex_lock(&chip->lock);
     __assign_bit(offset, chip->value_map, value);
     mutex_unlock(&chip->lock);
 }
 
 static int gpio_sim_get_multiple(struct gpio_chip *gc,
                  unsigned long *mask, unsigned long *bits)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
 
     mutex_lock(&chip->lock);
     bitmap_replace(bits, bits, chip->value_map, mask, gc->ngpio);
     mutex_unlock(&chip->lock);
 
     return 0;
 }
 
 static void gpio_sim_set_multiple(struct gpio_chip *gc,
                   unsigned long *mask, unsigned long *bits)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
 
     mutex_lock(&chip->lock);
     bitmap_replace(chip->value_map, chip->value_map, bits, mask, gc->ngpio);
     mutex_unlock(&chip->lock);
 }
 
 static int gpio_sim_direction_output(struct gpio_chip *gc,
                      unsigned int offset, int value)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
 
     mutex_lock(&chip->lock);
     __clear_bit(offset, chip->direction_map);
     __assign_bit(offset, chip->value_map, value);
     mutex_unlock(&chip->lock);
 
     return 0;
 }
 
 static int gpio_sim_direction_input(struct gpio_chip *gc, unsigned int offset)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
 
     mutex_lock(&chip->lock);
     __set_bit(offset, chip->direction_map);
     mutex_unlock(&chip->lock);
 
     return 0;
 }
 
 static int gpio_sim_get_direction(struct gpio_chip *gc, unsigned int offset)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
     int direction;
 
     mutex_lock(&chip->lock);
     direction = !!test_bit(offset, chip->direction_map);
     mutex_unlock(&chip->lock);
 
     return direction ? GPIO_LINE_DIRECTION_IN : GPIO_LINE_DIRECTION_OUT;
 }
 
 static int gpio_sim_set_config(struct gpio_chip *gc,
                   unsigned int offset, unsigned long config)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
 
     switch (pinconf_to_config_param(config)) {
     case PIN_CONFIG_BIAS_PULL_UP:
         return gpio_sim_apply_pull(chip, offset, 1);
     case PIN_CONFIG_BIAS_PULL_DOWN:
         return gpio_sim_apply_pull(chip, offset, 0);
     default:
         break;
     }
 
     return -ENOTSUPP;
 }
 
 static int gpio_sim_to_irq(struct gpio_chip *gc, unsigned int offset)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
 
     return irq_create_mapping(chip->irq_sim, offset);
 }
 
 static void gpio_sim_free(struct gpio_chip *gc, unsigned int offset)
 {
     struct gpio_sim_chip *chip = gpiochip_get_data(gc);
 
     mutex_lock(&chip->lock);
     __assign_bit(offset, chip->value_map, !!test_bit(offset, chip->pull_map));
     mutex_unlock(&chip->lock);
 }
 
 static ssize_t gpio_sim_sysfs_val_show(struct device *dev,
                        struct device_attribute *attr, char *buf)
 {
     struct gpio_sim_attribute *line_attr = to_gpio_sim_attr(attr);
     struct gpio_sim_chip *chip = dev_get_drvdata(dev);
     int val;
 
     mutex_lock(&chip->lock);
     val = !!test_bit(line_attr->offset, chip->value_map);
     mutex_unlock(&chip->lock);
 
     return sysfs_emit(buf, "%d\n", val);
 }
 
 static ssize_t gpio_sim_sysfs_val_store(struct device *dev,
                     struct device_attribute *attr,
                     const char *buf, size_t count)
 {
     /*
      * Not assigning this function will result in write() returning -EIO
      * which is confusing. Return -EPERM explicitly.
      */
     return -EPERM;
 }
 
 static const char *const gpio_sim_sysfs_pull_strings[] = {
     [0] = "pull-down",
     [1] = "pull-up",
 };
 
 static ssize_t gpio_sim_sysfs_pull_show(struct device *dev,
                     struct device_attribute *attr,
                     char *buf)
 {
     struct gpio_sim_attribute *line_attr = to_gpio_sim_attr(attr);
     struct gpio_sim_chip *chip = dev_get_drvdata(dev);
     int pull;
 
     mutex_lock(&chip->lock);
     pull = !!test_bit(line_attr->offset, chip->pull_map);
     mutex_unlock(&chip->lock);
 
     return sysfs_emit(buf, "%s\n", gpio_sim_sysfs_pull_strings[pull]);
 }
 
 static ssize_t gpio_sim_sysfs_pull_store(struct device *dev,
                      struct device_attribute *attr,
                      const char *buf, size_t len)
 {
     struct gpio_sim_attribute *line_attr = to_gpio_sim_attr(attr);
     struct gpio_sim_chip *chip = dev_get_drvdata(dev);
     int ret, pull;
 
     pull = sysfs_match_string(gpio_sim_sysfs_pull_strings, buf);
     if (pull < 0)
         return pull;
 
     ret = gpio_sim_apply_pull(chip, line_attr->offset, pull);
     if (ret)
         return ret;
 
     return len;
 }
 
 static void gpio_sim_mutex_destroy(void *data)
 {
     struct mutex *lock = data;
 
     mutex_destroy(lock);
 }
 
 static void gpio_sim_sysfs_remove(void *data)
 {
     struct gpio_sim_chip *chip = data;
 
     sysfs_remove_groups(&chip->gc.gpiodev->dev.kobj, chip->attr_groups);
 }
 
 static int gpio_sim_setup_sysfs(struct gpio_sim_chip *chip)
 {
     struct device_attribute *val_dev_attr, *pull_dev_attr;
     struct gpio_sim_attribute *val_attr, *pull_attr;
     unsigned int num_lines = chip->gc.ngpio;
     struct device *dev = chip->gc.parent;
     struct attribute_group *attr_group;
     struct attribute **attrs;
     int i, ret;
 
     chip->attr_groups = devm_kcalloc(dev, sizeof(*chip->attr_groups),
                      num_lines + 1, GFP_KERNEL);
     if (!chip->attr_groups)
         return -ENOMEM;
 
     for (i = 0; i < num_lines; i++) {
         attr_group = devm_kzalloc(dev, sizeof(*attr_group), GFP_KERNEL);
         attrs = devm_kcalloc(dev, GPIO_SIM_NUM_ATTRS, sizeof(*attrs),
                      GFP_KERNEL);
         val_attr = devm_kzalloc(dev, sizeof(*val_attr), GFP_KERNEL);
         pull_attr = devm_kzalloc(dev, sizeof(*pull_attr), GFP_KERNEL);
         if (!attr_group || !attrs || !val_attr || !pull_attr)
             return -ENOMEM;
 
         attr_group->name = devm_kasprintf(dev, GFP_KERNEL,
                           "sim_gpio%u", i);
         if (!attr_group->name)
             return -ENOMEM;
 
         val_attr->offset = pull_attr->offset = i;
 
         val_dev_attr = &val_attr->dev_attr;
         pull_dev_attr = &pull_attr->dev_attr;
 
         sysfs_attr_init(&val_dev_attr->attr);
         sysfs_attr_init(&pull_dev_attr->attr);
 
         val_dev_attr->attr.name = "value";
         pull_dev_attr->attr.name = "pull";
 
         val_dev_attr->attr.mode = pull_dev_attr->attr.mode = 0644;
 
         val_dev_attr->show = gpio_sim_sysfs_val_show;
         val_dev_attr->store = gpio_sim_sysfs_val_store;
         pull_dev_attr->show = gpio_sim_sysfs_pull_show;
         pull_dev_attr->store = gpio_sim_sysfs_pull_store;
 
         attrs[0] = &val_dev_attr->attr;
         attrs[1] = &pull_dev_attr->attr;
 
         attr_group->attrs = attrs;
         chip->attr_groups[i] = attr_group;
     }
 
     ret = sysfs_create_groups(&chip->gc.gpiodev->dev.kobj,
                   chip->attr_groups);
     if (ret)
         return ret;
 
     return devm_add_action_or_reset(dev, gpio_sim_sysfs_remove, chip);
 }
 
 static int gpio_sim_add_bank(struct fwnode_handle *swnode, struct device *dev)
 {
     struct gpio_sim_chip *chip;
     struct gpio_chip *gc;
     const char *label;
     u32 num_lines;
     int ret;
 
     ret = fwnode_property_read_u32(swnode, "ngpios", &num_lines);
     if (ret)
         return ret;
 
     ret = fwnode_property_read_string(swnode, "gpio-sim,label", &label);
     if (ret) {
         label = devm_kasprintf(dev, GFP_KERNEL, "%s-%s",
                        dev_name(dev), fwnode_get_name(swnode));
         if (!label)
             return -ENOMEM;
     }
 
     chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
     if (!chip)
         return -ENOMEM;
 
     chip->direction_map = devm_bitmap_alloc(dev, num_lines, GFP_KERNEL);
     if (!chip->direction_map)
         return -ENOMEM;
 
     /* Default to input mode. */
     bitmap_fill(chip->direction_map, num_lines);
 
     chip->value_map = devm_bitmap_zalloc(dev, num_lines, GFP_KERNEL);
     if (!chip->value_map)
         return -ENOMEM;
 
     chip->pull_map = devm_bitmap_zalloc(dev, num_lines, GFP_KERNEL);
     if (!chip->pull_map)
         return -ENOMEM;
 
     chip->irq_sim = devm_irq_domain_create_sim(dev, NULL, num_lines);
     if (IS_ERR(chip->irq_sim))
         return PTR_ERR(chip->irq_sim);
 
     mutex_init(&chip->lock);
     ret = devm_add_action_or_reset(dev, gpio_sim_mutex_destroy,
                        &chip->lock);
     if (ret)
         return ret;
 
     gc = &chip->gc;
     gc->base = -1;
     gc->ngpio = num_lines;
     gc->label = label;
     gc->owner = THIS_MODULE;
     gc->parent = dev;
     gc->fwnode = swnode;
     gc->get = gpio_sim_get;
     gc->set = gpio_sim_set;
     gc->get_multiple = gpio_sim_get_multiple;
     gc->set_multiple = gpio_sim_set_multiple;
     gc->direction_output = gpio_sim_direction_output;
     gc->direction_input = gpio_sim_direction_input;
     gc->get_direction = gpio_sim_get_direction;
     gc->set_config = gpio_sim_set_config;
     gc->to_irq = gpio_sim_to_irq;
     gc->free = gpio_sim_free;
 
     ret = devm_gpiochip_add_data(dev, gc, chip);
     if (ret)
         return ret;
 
     /* Used by sysfs and configfs callbacks. */
     dev_set_drvdata(&gc->gpiodev->dev, chip);
 
     return gpio_sim_setup_sysfs(chip);
 }
 
 static int gpio_sim_probe(struct platform_device *pdev)
 {
     struct device *dev = &pdev->dev;
     struct fwnode_handle *swnode;
     int ret;
 
     device_for_each_child_node(dev, swnode) {
         ret = gpio_sim_add_bank(swnode, dev);
         if (ret) {
             fwnode_handle_put(swnode);
             return ret;
         }
     }
 
     return 0;
 }
 
 static const struct of_device_id gpio_sim_of_match[] = {
     { .compatible = "gpio-simulator" },
     { }
 };
 MODULE_DEVICE_TABLE(of, gpio_sim_of_match);
 
 static struct platform_driver gpio_sim_driver = {
     .driver = {
         .name = "gpio-sim",
         .of_match_table = gpio_sim_of_match,
     },
     .probe = gpio_sim_probe,
 };
 
 struct gpio_sim_device {
     struct config_group group;
 
     /*
      * If pdev is NULL, the device is 'pending' (waiting for configuration).
      * Once the pointer is assigned, the device has been created and the
      * item is 'live'.
      */
     struct platform_device *pdev;
     int id;
 
     /*
      * Each configfs filesystem operation is protected with the subsystem
      * mutex. Each separate attribute is protected with the buffer mutex.
      * This structure however can be modified by callbacks of different
      * attributes so we need another lock.
      *
      * We use this lock fo protecting all data structures owned by this
      * object too.
      */
     struct mutex lock;
 
     /*
      * This is used to synchronously wait for the driver's probe to complete
      * and notify the user-space about any errors.
      */
     struct notifier_block bus_notifier;
     struct completion probe_completion;
     bool driver_bound;
 
     struct gpiod_hog *hogs;
 
     struct list_head bank_list;
 };
 
 /* This is called with dev->lock already taken. */
 static int gpio_sim_bus_notifier_call(struct notifier_block *nb,
                       unsigned long action, void *data)
 {
     struct gpio_sim_device *simdev = container_of(nb,
                               struct gpio_sim_device,
                               bus_notifier);
     struct device *dev = data;
     char devname[32];
 
     snprintf(devname, sizeof(devname), "gpio-sim.%u", simdev->id);
 
     if (strcmp(dev_name(dev), devname) == 0) {
         if (action == BUS_NOTIFY_BOUND_DRIVER)
             simdev->driver_bound = true;
         else if (action == BUS_NOTIFY_DRIVER_NOT_BOUND)
             simdev->driver_bound = false;
         else
             return NOTIFY_DONE;
 
         complete(&simdev->probe_completion);
         return NOTIFY_OK;
     }
 
     return NOTIFY_DONE;
 }
 
 static struct gpio_sim_device *to_gpio_sim_device(struct config_item *item)
 {
     struct config_group *group = to_config_group(item);
 
     return container_of(group, struct gpio_sim_device, group);
 }
 
 struct gpio_sim_bank {
     struct config_group group;
 
     /*
      * We could have used the ci_parent field of the config_item but
      * configfs is stupid and calls the item's release callback after
      * already having cleared the parent pointer even though the parent
      * is guaranteed to survive the child...
      *
      * So we need to store the pointer to the parent struct here. We can
      * dereference it anywhere we need with no checks and no locking as
      * it's guaranteed to survive the children and protected by configfs
      * locks.
      *
      * Same for other structures.
      */
     struct gpio_sim_device *parent;
     struct list_head siblings;
 
     char *label;
     unsigned int num_lines;
 
     struct list_head line_list;
 
     struct fwnode_handle *swnode;
 };
 
 static struct gpio_sim_bank *to_gpio_sim_bank(struct config_item *item)
 {
     struct config_group *group = to_config_group(item);
 
     return container_of(group, struct gpio_sim_bank, group);
 }
 
 static bool gpio_sim_bank_has_label(struct gpio_sim_bank *bank)
 {
     return bank->label && *bank->label;
 }
 
 static struct gpio_sim_device *
 gpio_sim_bank_get_device(struct gpio_sim_bank *bank)
 {
     return bank->parent;
 }
 
 struct gpio_sim_hog;
 
 struct gpio_sim_line {
     struct config_group group;
 
     struct gpio_sim_bank *parent;
     struct list_head siblings;
 
     unsigned int offset;
     char *name;
 
     /* There can only be one hog per line. */
     struct gpio_sim_hog *hog;
 };
 
 static struct gpio_sim_line *to_gpio_sim_line(struct config_item *item)
 {
     struct config_group *group = to_config_group(item);
 
     return container_of(group, struct gpio_sim_line, group);
 }
 
 static struct gpio_sim_device *
 gpio_sim_line_get_device(struct gpio_sim_line *line)
 {
     struct gpio_sim_bank *bank = line->parent;
 
     return gpio_sim_bank_get_device(bank);
 }
 
 struct gpio_sim_hog {
     struct config_item item;
     struct gpio_sim_line *parent;
 
     char *name;
     int dir;
 };
 
 static struct gpio_sim_hog *to_gpio_sim_hog(struct config_item *item)
 {
     return container_of(item, struct gpio_sim_hog, item);
 }
 
 static struct gpio_sim_device *gpio_sim_hog_get_device(struct gpio_sim_hog *hog)
 {
     struct gpio_sim_line *line = hog->parent;
 
     return gpio_sim_line_get_device(line);
 }
 
 static bool gpio_sim_device_is_live_unlocked(struct gpio_sim_device *dev)
 {
     return !!dev->pdev;
 }
 
 static char *gpio_sim_strdup_trimmed(const char *str, size_t count)
 {
     char *dup, *trimmed;
 
     dup = kstrndup(str, count, GFP_KERNEL);
     if (!dup)
         return NULL;
 
     trimmed = strstrip(dup);
     memmove(dup, trimmed, strlen(trimmed) + 1);
 
     return dup;
 }
 
 static ssize_t gpio_sim_device_config_dev_name_show(struct config_item *item,
                             char *page)
 {
     struct gpio_sim_device *dev = to_gpio_sim_device(item);
     struct platform_device *pdev;
     int ret;
 
     mutex_lock(&dev->lock);
     pdev = dev->pdev;
     if (pdev)
         ret = sprintf(page, "%s\n", dev_name(&pdev->dev));
     else
         ret = sprintf(page, "gpio-sim.%d\n", dev->id);
     mutex_unlock(&dev->lock);
 
     return ret;
 }
 
 CONFIGFS_ATTR_RO(gpio_sim_device_config_, dev_name);
 
 static ssize_t
 gpio_sim_device_config_live_show(struct config_item *item, char *page)
 {
     struct gpio_sim_device *dev = to_gpio_sim_device(item);
     bool live;
 
     mutex_lock(&dev->lock);
     live = gpio_sim_device_is_live_unlocked(dev);
     mutex_unlock(&dev->lock);
 
     return sprintf(page, "%c\n", live ? '1' : '0');
 }
 
 static char **gpio_sim_make_line_names(struct gpio_sim_bank *bank,
                        unsigned int *line_names_size)
 {
     unsigned int max_offset = 0;
     bool has_line_names = false;
     struct gpio_sim_line *line;
     char **line_names;
 
     list_for_each_entry(line, &bank->line_list, siblings) {
         if (line->name) {
             if (line->offset > max_offset)
                 max_offset = line->offset;
 
             /*
              * max_offset can stay at 0 so it's not an indicator
              * of whether line names were configured at all.
              */
             has_line_names = true;
         }
     }
 
     if (!has_line_names)
         /*
          * This is not an error - NULL means, there are no line
          * names configured.
          */
         return NULL;
 
     *line_names_size = max_offset + 1;
 
     line_names = kcalloc(*line_names_size, sizeof(*line_names), GFP_KERNEL);
     if (!line_names)
         return ERR_PTR(-ENOMEM);
 
     list_for_each_entry(line, &bank->line_list, siblings)
         line_names[line->offset] = line->name;
 
     return line_names;
 }
 
 static void gpio_sim_remove_hogs(struct gpio_sim_device *dev)
 {
     struct gpiod_hog *hog;
 
     if (!dev->hogs)
         return;
 
     gpiod_remove_hogs(dev->hogs);
 
     for (hog = dev->hogs; !hog->chip_label; hog++) {
         kfree(hog->chip_label);
         kfree(hog->line_name);
     }
 
     kfree(dev->hogs);
     dev->hogs = NULL;
 }
 
 static int gpio_sim_add_hogs(struct gpio_sim_device *dev)
 {
     unsigned int num_hogs = 0, idx = 0;
     struct gpio_sim_bank *bank;
     struct gpio_sim_line *line;
     struct gpiod_hog *hog;
 
     list_for_each_entry(bank, &dev->bank_list, siblings) {
         list_for_each_entry(line, &bank->line_list, siblings) {
             if (line->hog)
                 num_hogs++;
         }
     }
 
     if (!num_hogs)
         return 0;
 
     /* Allocate one more for the sentinel. */
     dev->hogs = kcalloc(num_hogs + 1, sizeof(*dev->hogs), GFP_KERNEL);
     if (!dev->hogs)
         return -ENOMEM;
 
     list_for_each_entry(bank, &dev->bank_list, siblings) {
         list_for_each_entry(line, &bank->line_list, siblings) {
             if (!line->hog)
                 continue;
 
             hog = &dev->hogs[idx++];
 
             /*
              * We need to make this string manually because at this
              * point the device doesn't exist yet and so dev_name()
              * is not available.
              */
             if (gpio_sim_bank_has_label(bank))
                 hog->chip_label = kstrdup(bank->label,
                               GFP_KERNEL);
             else
                 hog->chip_label = kasprintf(GFP_KERNEL,
                             "gpio-sim.%u-%s",
                             dev->id,
                             fwnode_get_name(
                                 bank->swnode));
             if (!hog->chip_label) {
                 gpio_sim_remove_hogs(dev);
                 return -ENOMEM;
             }
 
             /*
              * We need to duplicate this because the hog config
              * item can be removed at any time (and we can't block
              * it) and gpiolib doesn't make a deep copy of the hog
              * data.
              */
             if (line->hog->name) {
                 hog->line_name = kstrdup(line->hog->name,
                              GFP_KERNEL);
                 if (!hog->line_name) {
                     gpio_sim_remove_hogs(dev);
                     return -ENOMEM;
                 }
             }
 
             hog->chip_hwnum = line->offset;
             hog->dflags = line->hog->dir;
         }
     }
 
     gpiod_add_hogs(dev->hogs);
 
     return 0;
 }
 
 static struct fwnode_handle *
 gpio_sim_make_bank_swnode(struct gpio_sim_bank *bank,
               struct fwnode_handle *parent)
 {
     struct property_entry properties[GPIO_SIM_PROP_MAX];
     unsigned int prop_idx = 0, line_names_size = 0;
     struct fwnode_handle *swnode;
     char **line_names;
 
     memset(properties, 0, sizeof(properties));
 
     properties[prop_idx++] = PROPERTY_ENTRY_U32("ngpios", bank->num_lines);
 
     if (gpio_sim_bank_has_label(bank))
         properties[prop_idx++] = PROPERTY_ENTRY_STRING("gpio-sim,label",
                                    bank->label);
 
     line_names = gpio_sim_make_line_names(bank, &line_names_size);
     if (IS_ERR(line_names))
         return ERR_CAST(line_names);
 
     if (line_names)
         properties[prop_idx++] = PROPERTY_ENTRY_STRING_ARRAY_LEN(
                         "gpio-line-names",
                         line_names, line_names_size);
 
     swnode = fwnode_create_software_node(properties, parent);
     kfree(line_names);
     return swnode;
 }
 
 static void gpio_sim_remove_swnode_recursive(struct fwnode_handle *swnode)
 {
     struct fwnode_handle *child;
 
     fwnode_for_each_child_node(swnode, child)
         fwnode_remove_software_node(child);
 
     fwnode_remove_software_node(swnode);
 }
 
 static bool gpio_sim_bank_labels_non_unique(struct gpio_sim_device *dev)
 {
     struct gpio_sim_bank *this, *pos;
 
     list_for_each_entry(this, &dev->bank_list, siblings) {
         list_for_each_entry(pos, &dev->bank_list, siblings) {
             if (this == pos || (!this->label || !pos->label))
                 continue;
 
             if (strcmp(this->label, pos->label) == 0)
                 return true;
         }
     }
 
     return false;
 }
 
 static int gpio_sim_device_activate_unlocked(struct gpio_sim_device *dev)
 {
     struct platform_device_info pdevinfo;
     struct fwnode_handle *swnode;
     struct platform_device *pdev;
     struct gpio_sim_bank *bank;
     int ret;
 
     if (list_empty(&dev->bank_list))
         return -ENODATA;
 
     /*
      * Non-unique GPIO device labels are a corner-case we don't support
      * as it would interfere with machine hogging mechanism and has little
      * use in real life.
      */
     if (gpio_sim_bank_labels_non_unique(dev))
         return -EINVAL;
 
     memset(&pdevinfo, 0, sizeof(pdevinfo));
 
     swnode = fwnode_create_software_node(NULL, NULL);
     if (IS_ERR(swnode))
         return PTR_ERR(swnode);
 
     list_for_each_entry(bank, &dev->bank_list, siblings) {
         bank->swnode = gpio_sim_make_bank_swnode(bank, swnode);
         if (IS_ERR(bank->swnode)) {
             ret = PTR_ERR(bank->swnode);
             gpio_sim_remove_swnode_recursive(swnode);
             return ret;
         }
     }
 
     ret = gpio_sim_add_hogs(dev);
     if (ret) {
         gpio_sim_remove_swnode_recursive(swnode);
         return ret;
     }
 
     pdevinfo.name = "gpio-sim";
     pdevinfo.fwnode = swnode;
     pdevinfo.id = dev->id;
 
     reinit_completion(&dev->probe_completion);
     dev->driver_bound = false;
     bus_register_notifier(&platform_bus_type, &dev->bus_notifier);
 
     pdev = platform_device_register_full(&pdevinfo);
     if (IS_ERR(pdev)) {
         bus_unregister_notifier(&platform_bus_type, &dev->bus_notifier);
         gpio_sim_remove_hogs(dev);
         gpio_sim_remove_swnode_recursive(swnode);
         return PTR_ERR(pdev);
     }
 
     wait_for_completion(&dev->probe_completion);
     bus_unregister_notifier(&platform_bus_type, &dev->bus_notifier);
 
     if (!dev->driver_bound) {
         /* Probe failed, check kernel log. */
         platform_device_unregister(pdev);
         gpio_sim_remove_hogs(dev);
         gpio_sim_remove_swnode_recursive(swnode);
         return -ENXIO;
     }
 
     dev->pdev = pdev;
 
     return 0;
 }
 
 static void gpio_sim_device_deactivate_unlocked(struct gpio_sim_device *dev)
 {
     struct fwnode_handle *swnode;
 
     swnode = dev_fwnode(&dev->pdev->dev);
     platform_device_unregister(dev->pdev);
     gpio_sim_remove_swnode_recursive(swnode);
     dev->pdev = NULL;
     gpio_sim_remove_hogs(dev);
 }
 
 static ssize_t
 gpio_sim_device_config_live_store(struct config_item *item,
                   const char *page, size_t count)
 {
     struct gpio_sim_device *dev = to_gpio_sim_device(item);
     bool live;
     int ret;
 
     ret = kstrtobool(page, &live);
     if (ret)
         return ret;
 
     mutex_lock(&dev->lock);
 
     if ((!live && !gpio_sim_device_is_live_unlocked(dev)) ||
         (live && gpio_sim_device_is_live_unlocked(dev)))
         ret = -EPERM;
     else if (live)
         ret = gpio_sim_device_activate_unlocked(dev);
     else
         gpio_sim_device_deactivate_unlocked(dev);
 
     mutex_unlock(&dev->lock);
 
     return ret ?: count;
 }
 
 CONFIGFS_ATTR(gpio_sim_device_config_, live);
 
 static struct configfs_attribute *gpio_sim_device_config_attrs[] = {
     &gpio_sim_device_config_attr_dev_name,
     &gpio_sim_device_config_attr_live,
     NULL
 };
 
 struct gpio_sim_chip_name_ctx {
     struct fwnode_handle *swnode;
     char *page;
 };
 
 static int gpio_sim_emit_chip_name(struct device *dev, void *data)
 {
     struct gpio_sim_chip_name_ctx *ctx = data;
 
     /* This would be the sysfs device exported in /sys/class/gpio. */
     if (dev->class)
         return 0;
 
     if (device_match_fwnode(dev, ctx->swnode))
         return sprintf(ctx->page, "%s\n", dev_name(dev));
 
     return 0;
 }
 
 static ssize_t gpio_sim_bank_config_chip_name_show(struct config_item *item,
                            char *page)
 {
     struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
     struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
     struct gpio_sim_chip_name_ctx ctx = { bank->swnode, page };
     int ret;
 
     mutex_lock(&dev->lock);
     if (gpio_sim_device_is_live_unlocked(dev))
         ret = device_for_each_child(&dev->pdev->dev, &ctx,
                         gpio_sim_emit_chip_name);
     else
         ret = sprintf(page, "none\n");
     mutex_unlock(&dev->lock);
 
     return ret;
 }
 
 CONFIGFS_ATTR_RO(gpio_sim_bank_config_, chip_name);
 
 static ssize_t
 gpio_sim_bank_config_label_show(struct config_item *item, char *page)
 {
     struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
     struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
     int ret;
 
     mutex_lock(&dev->lock);
     ret = sprintf(page, "%s\n", bank->label ?: "");
     mutex_unlock(&dev->lock);
 
     return ret;
 }
 
 static ssize_t gpio_sim_bank_config_label_store(struct config_item *item,
                         const char *page, size_t count)
 {
     struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
     struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
     char *trimmed;
 
     mutex_lock(&dev->lock);
 
     if (gpio_sim_device_is_live_unlocked(dev)) {
         mutex_unlock(&dev->lock);
         return -EBUSY;
     }
 
     trimmed = gpio_sim_strdup_trimmed(page, count);
     if (!trimmed) {
         mutex_unlock(&dev->lock);
         return -ENOMEM;
     }
 
     kfree(bank->label);
     bank->label = trimmed;
 
     mutex_unlock(&dev->lock);
     return count;
 }
 
 CONFIGFS_ATTR(gpio_sim_bank_config_, label);
 
 static ssize_t
 gpio_sim_bank_config_num_lines_show(struct config_item *item, char *page)
 {
     struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
     struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
     int ret;
 
     mutex_lock(&dev->lock);
     ret = sprintf(page, "%u\n", bank->num_lines);
     mutex_unlock(&dev->lock);
 
     return ret;
 }
 
 static ssize_t
 gpio_sim_bank_config_num_lines_store(struct config_item *item,
                      const char *page, size_t count)
 {
     struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
     struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
     unsigned int num_lines;
     int ret;
 
     ret = kstrtouint(page, 0, &num_lines);
     if (ret)
         return ret;
 
     if (num_lines == 0)
         return -EINVAL;
 
     mutex_lock(&dev->lock);
 
     if (gpio_sim_device_is_live_unlocked(dev)) {
         mutex_unlock(&dev->lock);
         return -EBUSY;
     }
 
     bank->num_lines = num_lines;
 
     mutex_unlock(&dev->lock);
     return count;
 }
 
 CONFIGFS_ATTR(gpio_sim_bank_config_, num_lines);
 
 static struct configfs_attribute *gpio_sim_bank_config_attrs[] = {
     &gpio_sim_bank_config_attr_chip_name,
     &gpio_sim_bank_config_attr_label,
     &gpio_sim_bank_config_attr_num_lines,
     NULL
 };
 
 static ssize_t
 gpio_sim_line_config_name_show(struct config_item *item, char *page)
 {
     struct gpio_sim_line *line = to_gpio_sim_line(item);
     struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
     int ret;
 
     mutex_lock(&dev->lock);
     ret = sprintf(page, "%s\n", line->name ?: "");
     mutex_unlock(&dev->lock);
 
     return ret;
 }
 
 static ssize_t gpio_sim_line_config_name_store(struct config_item *item,
                            const char *page, size_t count)
 {
     struct gpio_sim_line *line = to_gpio_sim_line(item);
     struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
     char *trimmed;
 
     mutex_lock(&dev->lock);
 
     if (gpio_sim_device_is_live_unlocked(dev)) {
         mutex_unlock(&dev->lock);
         return -EBUSY;
     }
 
     trimmed = gpio_sim_strdup_trimmed(page, count);
     if (!trimmed) {
         mutex_unlock(&dev->lock);
         return -ENOMEM;
     }
 
     kfree(line->name);
     line->name = trimmed;
 
     mutex_unlock(&dev->lock);
 
     return count;
 }
 
 CONFIGFS_ATTR(gpio_sim_line_config_, name);
 
 static struct configfs_attribute *gpio_sim_line_config_attrs[] = {
     &gpio_sim_line_config_attr_name,
     NULL
 };
 
 static ssize_t gpio_sim_hog_config_name_show(struct config_item *item,
                          char *page)
 {
     struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
     struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
     int ret;
 
     mutex_lock(&dev->lock);
     ret = sprintf(page, "%s\n", hog->name ?: "");
     mutex_unlock(&dev->lock);
 
     return ret;
 }
 
 static ssize_t gpio_sim_hog_config_name_store(struct config_item *item,
                           const char *page, size_t count)
 {
     struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
     struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
     char *trimmed;
 
     mutex_lock(&dev->lock);
 
     if (gpio_sim_device_is_live_unlocked(dev)) {
         mutex_unlock(&dev->lock);
         return -EBUSY;
     }
 
     trimmed = gpio_sim_strdup_trimmed(page, count);
     if (!trimmed) {
         mutex_unlock(&dev->lock);
         return -ENOMEM;
     }
 
     kfree(hog->name);
     hog->name = trimmed;
 
     mutex_unlock(&dev->lock);
 
     return count;
 }
 
 CONFIGFS_ATTR(gpio_sim_hog_config_, name);
 
 static ssize_t gpio_sim_hog_config_direction_show(struct config_item *item,
                           char *page)
 {
     struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
     struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
     char *repr;
     int dir;
 
     mutex_lock(&dev->lock);
     dir = hog->dir;
     mutex_unlock(&dev->lock);
 
     switch (dir) {
     case GPIOD_IN:
         repr = "input";
         break;
     case GPIOD_OUT_HIGH:
         repr = "output-high";
         break;
     case GPIOD_OUT_LOW:
         repr = "output-low";
         break;
     default:
         /* This would be a programmer bug. */
         WARN(1, "Unexpected hog direction value: %d", dir);
         return -EINVAL;
     }
 
     return sprintf(page, "%s\n", repr);
 }
 
 static ssize_t
 gpio_sim_hog_config_direction_store(struct config_item *item,
                     const char *page, size_t count)
 {
     struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
     struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
     char *trimmed;
     int dir;
 
     mutex_lock(&dev->lock);
 
     if (gpio_sim_device_is_live_unlocked(dev)) {
         mutex_unlock(&dev->lock);
         return -EBUSY;
     }
 
     trimmed = gpio_sim_strdup_trimmed(page, count);
     if (!trimmed) {
         mutex_unlock(&dev->lock);
         return -ENOMEM;
     }
 
     if (strcmp(trimmed, "input") == 0)
         dir = GPIOD_IN;
     else if (strcmp(trimmed, "output-high") == 0)
         dir = GPIOD_OUT_HIGH;
     else if (strcmp(trimmed, "output-low") == 0)
         dir = GPIOD_OUT_LOW;
     else
         dir = -EINVAL;
 
     kfree(trimmed);
 
     if (dir < 0) {
         mutex_unlock(&dev->lock);
         return dir;
     }
 
     hog->dir = dir;
 
     mutex_unlock(&dev->lock);
 
     return count;
 }
 
 CONFIGFS_ATTR(gpio_sim_hog_config_, direction);
 
 static struct configfs_attribute *gpio_sim_hog_config_attrs[] = {
     &gpio_sim_hog_config_attr_name,
     &gpio_sim_hog_config_attr_direction,
     NULL
 };
 
 static void gpio_sim_hog_config_item_release(struct config_item *item)
 {
     struct gpio_sim_hog *hog = to_gpio_sim_hog(item);
     struct gpio_sim_line *line = hog->parent;
     struct gpio_sim_device *dev = gpio_sim_hog_get_device(hog);
 
     mutex_lock(&dev->lock);
     line->hog = NULL;
     mutex_unlock(&dev->lock);
 
     kfree(hog->name);
     kfree(hog);
 }
 
 static struct configfs_item_operations gpio_sim_hog_config_item_ops = {
     .release    = gpio_sim_hog_config_item_release,
 };
 
 static const struct config_item_type gpio_sim_hog_config_type = {
     .ct_item_ops    = &gpio_sim_hog_config_item_ops,
     .ct_attrs   = gpio_sim_hog_config_attrs,
     .ct_owner   = THIS_MODULE,
 };
 
 static struct config_item *
 gpio_sim_line_config_make_hog_item(struct config_group *group, const char *name)
 {
     struct gpio_sim_line *line = to_gpio_sim_line(&group->cg_item);
     struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
     struct gpio_sim_hog *hog;
 
     if (strcmp(name, "hog") != 0)
         return ERR_PTR(-EINVAL);
 
     mutex_lock(&dev->lock);
 
     hog = kzalloc(sizeof(*hog), GFP_KERNEL);
     if (!hog) {
         mutex_unlock(&dev->lock);
         return ERR_PTR(-ENOMEM);
     }
 
     config_item_init_type_name(&hog->item, name,
                    &gpio_sim_hog_config_type);
 
     hog->dir = GPIOD_IN;
     hog->name = NULL;
     hog->parent = line;
     line->hog = hog;
 
     mutex_unlock(&dev->lock);
 
     return &hog->item;
 }
 
 static void gpio_sim_line_config_group_release(struct config_item *item)
 {
     struct gpio_sim_line *line = to_gpio_sim_line(item);
     struct gpio_sim_device *dev = gpio_sim_line_get_device(line);
 
     mutex_lock(&dev->lock);
     list_del(&line->siblings);
     mutex_unlock(&dev->lock);
 
     kfree(line->name);
     kfree(line);
 }
 
 static struct configfs_item_operations gpio_sim_line_config_item_ops = {
     .release    = gpio_sim_line_config_group_release,
 };
 
 static struct configfs_group_operations gpio_sim_line_config_group_ops = {
     .make_item  = gpio_sim_line_config_make_hog_item,
 };
 
 static const struct config_item_type gpio_sim_line_config_type = {
     .ct_item_ops    = &gpio_sim_line_config_item_ops,
     .ct_group_ops   = &gpio_sim_line_config_group_ops,
     .ct_attrs   = gpio_sim_line_config_attrs,
     .ct_owner       = THIS_MODULE,
 };
 
 static struct config_group *
 gpio_sim_bank_config_make_line_group(struct config_group *group,
                      const char *name)
 {
     struct gpio_sim_bank *bank = to_gpio_sim_bank(&group->cg_item);
     struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
     struct gpio_sim_line *line;
     unsigned int offset;
     int ret, nchar;
 
     ret = sscanf(name, "line%u%n", &offset, &nchar);
     if (ret != 1 || nchar != strlen(name))
         return ERR_PTR(-EINVAL);
 
     mutex_lock(&dev->lock);
 
     if (gpio_sim_device_is_live_unlocked(dev)) {
         mutex_unlock(&dev->lock);
         return ERR_PTR(-EBUSY);
     }
 
     line = kzalloc(sizeof(*line), GFP_KERNEL);
     if (!line) {
         mutex_unlock(&dev->lock);
         return ERR_PTR(-ENOMEM);
     }
 
     config_group_init_type_name(&line->group, name,
                     &gpio_sim_line_config_type);
 
     line->parent = bank;
     line->offset = offset;
     list_add_tail(&line->siblings, &bank->line_list);
 
     mutex_unlock(&dev->lock);
 
     return &line->group;
 }
 
 static void gpio_sim_bank_config_group_release(struct config_item *item)
 {
     struct gpio_sim_bank *bank = to_gpio_sim_bank(item);
     struct gpio_sim_device *dev = gpio_sim_bank_get_device(bank);
 
     mutex_lock(&dev->lock);
     list_del(&bank->siblings);
     mutex_unlock(&dev->lock);
 
     kfree(bank->label);
     kfree(bank);
 }
 
 static struct configfs_item_operations gpio_sim_bank_config_item_ops = {
     .release    = gpio_sim_bank_config_group_release,
 };
 
 static struct configfs_group_operations gpio_sim_bank_config_group_ops = {
     .make_group = gpio_sim_bank_config_make_line_group,
 };
 
 static const struct config_item_type gpio_sim_bank_config_group_type = {
     .ct_item_ops    = &gpio_sim_bank_config_item_ops,
     .ct_group_ops   = &gpio_sim_bank_config_group_ops,
     .ct_attrs   = gpio_sim_bank_config_attrs,
     .ct_owner   = THIS_MODULE,
 };
 
 static struct config_group *
 gpio_sim_device_config_make_bank_group(struct config_group *group,
                        const char *name)
 {
     struct gpio_sim_device *dev = to_gpio_sim_device(&group->cg_item);
     struct gpio_sim_bank *bank;
 
     mutex_lock(&dev->lock);
 
     if (gpio_sim_device_is_live_unlocked(dev)) {
         mutex_unlock(&dev->lock);
         return ERR_PTR(-EBUSY);
     }
 
     bank = kzalloc(sizeof(*bank), GFP_KERNEL);
     if (!bank) {
         mutex_unlock(&dev->lock);
         return ERR_PTR(-ENOMEM);
     }
 
     config_group_init_type_name(&bank->group, name,
                     &gpio_sim_bank_config_group_type);
     bank->num_lines = 1;
     bank->parent = dev;
     INIT_LIST_HEAD(&bank->line_list);
     list_add_tail(&bank->siblings, &dev->bank_list);
 
     mutex_unlock(&dev->lock);
 
     return &bank->group;
 }
 
 static void gpio_sim_device_config_group_release(struct config_item *item)
 {
     struct gpio_sim_device *dev = to_gpio_sim_device(item);
 
     mutex_lock(&dev->lock);
     if (gpio_sim_device_is_live_unlocked(dev))
         gpio_sim_device_deactivate_unlocked(dev);
     mutex_unlock(&dev->lock);
 
     mutex_destroy(&dev->lock);
     ida_free(&gpio_sim_ida, dev->id);
     kfree(dev);
 }
 
 static struct configfs_item_operations gpio_sim_device_config_item_ops = {
     .release    = gpio_sim_device_config_group_release,
 };
 
 static struct configfs_group_operations gpio_sim_device_config_group_ops = {
     .make_group = gpio_sim_device_config_make_bank_group,
 };
 
 static const struct config_item_type gpio_sim_device_config_group_type = {
     .ct_item_ops    = &gpio_sim_device_config_item_ops,
     .ct_group_ops   = &gpio_sim_device_config_group_ops,
     .ct_attrs   = gpio_sim_device_config_attrs,
     .ct_owner   = THIS_MODULE,
 };
 
 static struct config_group *
 gpio_sim_config_make_device_group(struct config_group *group, const char *name)
 {
     struct gpio_sim_device *dev;
     int id;
 
     dev = kzalloc(sizeof(*dev), GFP_KERNEL);
     if (!dev)
         return ERR_PTR(-ENOMEM);
 
     id = ida_alloc(&gpio_sim_ida, GFP_KERNEL);
     if (id < 0) {
         kfree(dev);
         return ERR_PTR(id);
     }
 
     config_group_init_type_name(&dev->group, name,
                     &gpio_sim_device_config_group_type);
     dev->id = id;
     mutex_init(&dev->lock);
     INIT_LIST_HEAD(&dev->bank_list);
 
     dev->bus_notifier.notifier_call = gpio_sim_bus_notifier_call;
     init_completion(&dev->probe_completion);
 
     return &dev->group;
 }
 
 static struct configfs_group_operations gpio_sim_config_group_ops = {
     .make_group = gpio_sim_config_make_device_group,
 };
 
 static const struct config_item_type gpio_sim_config_type = {
     .ct_group_ops   = &gpio_sim_config_group_ops,
     .ct_owner   = THIS_MODULE,
 };
 
 static struct configfs_subsystem gpio_sim_config_subsys = {
     .su_group = {
         .cg_item = {
             .ci_namebuf = "gpio-sim",
             .ci_type    = &gpio_sim_config_type,
         },
     },
 };
 
 static int __init gpio_sim_init(void)
 {
     int ret;
 
     ret = platform_driver_register(&gpio_sim_driver);
     if (ret) {
         pr_err("Error %d while registering the platform driver\n", ret);
         return ret;
     }
 
     config_group_init(&gpio_sim_config_subsys.su_group);
     mutex_init(&gpio_sim_config_subsys.su_mutex);
     ret = configfs_register_subsystem(&gpio_sim_config_subsys);
     if (ret) {
         pr_err("Error %d while registering the configfs subsystem %s\n",
                ret, gpio_sim_config_subsys.su_group.cg_item.ci_namebuf);
         mutex_destroy(&gpio_sim_config_subsys.su_mutex);
         platform_driver_unregister(&gpio_sim_driver);
         return ret;
     }
 
     return 0;
 }
 module_init(gpio_sim_init);
 
 static void __exit gpio_sim_exit(void)
 {
     configfs_unregister_subsystem(&gpio_sim_config_subsys);
     mutex_destroy(&gpio_sim_config_subsys.su_mutex);
     platform_driver_unregister(&gpio_sim_driver);
 }
 module_exit(gpio_sim_exit);
 
 MODULE_AUTHOR("Bartosz Golaszewski <brgl@bgdev.pl");
 MODULE_DESCRIPTION("GPIO Simulator Module");
 MODULE_LICENSE("GPL");

This page was automatically generated by the 2.1.0 LXR engine. The LXR team