| // 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"); |