gpio-sim.c

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