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