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