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