1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Configurable virtual GPIO consumer module. 4 * 5 * Copyright (C) 2023-2024 Bartosz Golaszewski <bartosz.golaszewski@linaro.org> 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/array_size.h> 11 #include <linux/atomic.h> 12 #include <linux/bitmap.h> 13 #include <linux/cleanup.h> 14 #include <linux/configfs.h> 15 #include <linux/debugfs.h> 16 #include <linux/device.h> 17 #include <linux/err.h> 18 #include <linux/gpio/consumer.h> 19 #include <linux/gpio/machine.h> 20 #include <linux/idr.h> 21 #include <linux/interrupt.h> 22 #include <linux/irq_work.h> 23 #include <linux/limits.h> 24 #include <linux/list.h> 25 #include <linux/lockdep.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/of.h> 31 #include <linux/overflow.h> 32 #include <linux/platform_device.h> 33 #include <linux/printk.h> 34 #include <linux/property.h> 35 #include <linux/slab.h> 36 #include <linux/string_helpers.h> 37 #include <linux/types.h> 38 39 #include "dev-sync-probe.h" 40 41 #define GPIO_VIRTUSER_NAME_BUF_LEN 32 42 43 static DEFINE_IDA(gpio_virtuser_ida); 44 static struct dentry *gpio_virtuser_dbg_root; 45 46 struct gpio_virtuser_attr_data { 47 union { 48 struct gpio_desc *desc; 49 struct gpio_descs *descs; 50 }; 51 struct dentry *dbgfs_dir; 52 }; 53 54 struct gpio_virtuser_line_array_data { 55 struct gpio_virtuser_attr_data ad; 56 }; 57 58 struct gpio_virtuser_line_data { 59 struct gpio_virtuser_attr_data ad; 60 char consumer[GPIO_VIRTUSER_NAME_BUF_LEN]; 61 struct mutex consumer_lock; 62 unsigned int debounce; 63 atomic_t irq; 64 atomic_t irq_count; 65 }; 66 67 struct gpio_virtuser_dbgfs_attr_descr { 68 const char *name; 69 const struct file_operations *fops; 70 }; 71 72 struct gpio_virtuser_irq_work_context { 73 struct irq_work work; 74 struct completion work_completion; 75 union { 76 struct { 77 struct gpio_desc *desc; 78 int dir; 79 int val; 80 int ret; 81 }; 82 struct { 83 struct gpio_descs *descs; 84 unsigned long *values; 85 }; 86 }; 87 }; 88 89 static struct gpio_virtuser_irq_work_context * 90 to_gpio_virtuser_irq_work_context(struct irq_work *work) 91 { 92 return container_of(work, struct gpio_virtuser_irq_work_context, work); 93 } 94 95 static void 96 gpio_virtuser_init_irq_work_context(struct gpio_virtuser_irq_work_context *ctx) 97 { 98 memset(ctx, 0, sizeof(*ctx)); 99 init_completion(&ctx->work_completion); 100 } 101 102 static void 103 gpio_virtuser_irq_work_queue_sync(struct gpio_virtuser_irq_work_context *ctx) 104 { 105 irq_work_queue(&ctx->work); 106 wait_for_completion(&ctx->work_completion); 107 } 108 109 static void gpio_virtuser_dbgfs_emit_value_array(char *buf, 110 unsigned long *values, 111 size_t num_values) 112 { 113 size_t i; 114 115 for (i = 0; i < num_values; i++) 116 buf[i] = test_bit(i, values) ? '1' : '0'; 117 118 buf[i++] = '\n'; 119 } 120 121 static void gpio_virtuser_get_value_array_atomic(struct irq_work *work) 122 { 123 struct gpio_virtuser_irq_work_context *ctx = 124 to_gpio_virtuser_irq_work_context(work); 125 struct gpio_descs *descs = ctx->descs; 126 127 ctx->ret = gpiod_get_array_value(descs->ndescs, descs->desc, 128 descs->info, ctx->values); 129 complete(&ctx->work_completion); 130 } 131 132 static int gpio_virtuser_get_array_value(struct gpio_descs *descs, 133 unsigned long *values, bool atomic) 134 { 135 struct gpio_virtuser_irq_work_context ctx; 136 137 if (!atomic) 138 return gpiod_get_array_value_cansleep(descs->ndescs, 139 descs->desc, 140 descs->info, values); 141 142 gpio_virtuser_init_irq_work_context(&ctx); 143 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_get_value_array_atomic); 144 ctx.descs = descs; 145 ctx.values = values; 146 147 gpio_virtuser_irq_work_queue_sync(&ctx); 148 149 return ctx.ret; 150 } 151 152 static ssize_t gpio_virtuser_value_array_do_read(struct file *file, 153 char __user *user_buf, 154 size_t size, loff_t *ppos, 155 bool atomic) 156 { 157 struct gpio_virtuser_line_data *data = file->private_data; 158 struct gpio_descs *descs = data->ad.descs; 159 size_t bufsize; 160 int ret; 161 162 unsigned long *values __free(bitmap) = bitmap_zalloc(descs->ndescs, 163 GFP_KERNEL); 164 if (!values) 165 return -ENOMEM; 166 167 ret = gpio_virtuser_get_array_value(descs, values, atomic); 168 if (ret) 169 return ret; 170 171 bufsize = descs->ndescs + 2; 172 173 char *buf __free(kfree) = kzalloc(bufsize, GFP_KERNEL); 174 if (!buf) 175 return -ENOMEM; 176 177 gpio_virtuser_dbgfs_emit_value_array(buf, values, descs->ndescs); 178 179 return simple_read_from_buffer(user_buf, size, ppos, buf, 180 descs->ndescs + 1); 181 } 182 183 static int gpio_virtuser_dbgfs_parse_value_array(const char *buf, 184 size_t len, 185 unsigned long *values) 186 { 187 size_t i; 188 189 for (i = 0; i < len; i++) { 190 if (buf[i] == '0') 191 clear_bit(i, values); 192 else if (buf[i] == '1') 193 set_bit(i, values); 194 else 195 return -EINVAL; 196 } 197 198 return 0; 199 } 200 201 static void gpio_virtuser_set_value_array_atomic(struct irq_work *work) 202 { 203 struct gpio_virtuser_irq_work_context *ctx = 204 to_gpio_virtuser_irq_work_context(work); 205 struct gpio_descs *descs = ctx->descs; 206 207 ctx->ret = gpiod_set_array_value(descs->ndescs, descs->desc, 208 descs->info, ctx->values); 209 complete(&ctx->work_completion); 210 } 211 212 static int gpio_virtuser_set_array_value(struct gpio_descs *descs, 213 unsigned long *values, bool atomic) 214 { 215 struct gpio_virtuser_irq_work_context ctx; 216 217 if (!atomic) 218 return gpiod_multi_set_value_cansleep(descs, values); 219 220 gpio_virtuser_init_irq_work_context(&ctx); 221 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_set_value_array_atomic); 222 ctx.descs = descs; 223 ctx.values = values; 224 225 gpio_virtuser_irq_work_queue_sync(&ctx); 226 227 return ctx.ret; 228 } 229 230 static ssize_t gpio_virtuser_value_array_do_write(struct file *file, 231 const char __user *user_buf, 232 size_t count, loff_t *ppos, 233 bool atomic) 234 { 235 struct gpio_virtuser_line_data *data = file->private_data; 236 struct gpio_descs *descs = data->ad.descs; 237 int ret; 238 239 if (count - 1 != descs->ndescs) 240 return -EINVAL; 241 242 char *buf __free(kfree) = kzalloc(count, GFP_KERNEL); 243 if (!buf) 244 return -ENOMEM; 245 246 ret = simple_write_to_buffer(buf, count, ppos, user_buf, count); 247 if (ret < 0) 248 return ret; 249 250 unsigned long *values __free(bitmap) = bitmap_zalloc(descs->ndescs, 251 GFP_KERNEL); 252 if (!values) 253 return -ENOMEM; 254 255 ret = gpio_virtuser_dbgfs_parse_value_array(buf, count - 1, values); 256 if (ret) 257 return ret; 258 259 ret = gpio_virtuser_set_array_value(descs, values, atomic); 260 if (ret) 261 return ret; 262 263 return count; 264 } 265 266 static ssize_t gpio_virtuser_value_array_read(struct file *file, 267 char __user *user_buf, 268 size_t count, loff_t *ppos) 269 { 270 return gpio_virtuser_value_array_do_read(file, user_buf, count, ppos, 271 false); 272 } 273 274 static ssize_t gpio_virtuser_value_array_write(struct file *file, 275 const char __user *user_buf, 276 size_t count, loff_t *ppos) 277 { 278 return gpio_virtuser_value_array_do_write(file, user_buf, count, ppos, 279 false); 280 } 281 282 static const struct file_operations gpio_virtuser_value_array_fops = { 283 .read = gpio_virtuser_value_array_read, 284 .write = gpio_virtuser_value_array_write, 285 .open = simple_open, 286 .owner = THIS_MODULE, 287 .llseek = default_llseek, 288 }; 289 290 static ssize_t 291 gpio_virtuser_value_array_atomic_read(struct file *file, char __user *user_buf, 292 size_t count, loff_t *ppos) 293 { 294 return gpio_virtuser_value_array_do_read(file, user_buf, count, ppos, 295 true); 296 } 297 298 static ssize_t 299 gpio_virtuser_value_array_atomic_write(struct file *file, 300 const char __user *user_buf, 301 size_t count, loff_t *ppos) 302 { 303 return gpio_virtuser_value_array_do_write(file, user_buf, count, ppos, 304 true); 305 } 306 307 static const struct file_operations gpio_virtuser_value_array_atomic_fops = { 308 .read = gpio_virtuser_value_array_atomic_read, 309 .write = gpio_virtuser_value_array_atomic_write, 310 .open = simple_open, 311 .owner = THIS_MODULE, 312 .llseek = default_llseek, 313 }; 314 315 static void gpio_virtuser_do_get_direction_atomic(struct irq_work *work) 316 { 317 struct gpio_virtuser_irq_work_context *ctx = 318 to_gpio_virtuser_irq_work_context(work); 319 320 ctx->ret = gpiod_get_direction(ctx->desc); 321 complete(&ctx->work_completion); 322 } 323 324 static int gpio_virtuser_get_direction_atomic(struct gpio_desc *desc) 325 { 326 struct gpio_virtuser_irq_work_context ctx; 327 328 gpio_virtuser_init_irq_work_context(&ctx); 329 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_do_get_direction_atomic); 330 ctx.desc = desc; 331 332 gpio_virtuser_irq_work_queue_sync(&ctx); 333 334 return ctx.ret; 335 } 336 337 static ssize_t gpio_virtuser_direction_do_read(struct file *file, 338 char __user *user_buf, 339 size_t size, loff_t *ppos, 340 bool atomic) 341 { 342 struct gpio_virtuser_line_data *data = file->private_data; 343 struct gpio_desc *desc = data->ad.desc; 344 char buf[32]; 345 int dir; 346 347 if (!atomic) 348 dir = gpiod_get_direction(desc); 349 else 350 dir = gpio_virtuser_get_direction_atomic(desc); 351 if (dir < 0) 352 return dir; 353 354 snprintf(buf, sizeof(buf), "%s\n", dir ? "input" : "output"); 355 356 return simple_read_from_buffer(user_buf, size, ppos, buf, strlen(buf)); 357 } 358 359 static int gpio_virtuser_set_direction(struct gpio_desc *desc, int dir, int val) 360 { 361 if (dir) 362 return gpiod_direction_input(desc); 363 364 return gpiod_direction_output(desc, val); 365 } 366 367 static void gpio_virtuser_do_set_direction_atomic(struct irq_work *work) 368 { 369 struct gpio_virtuser_irq_work_context *ctx = 370 to_gpio_virtuser_irq_work_context(work); 371 372 ctx->ret = gpio_virtuser_set_direction(ctx->desc, ctx->dir, ctx->val); 373 complete(&ctx->work_completion); 374 } 375 376 static int gpio_virtuser_set_direction_atomic(struct gpio_desc *desc, 377 int dir, int val) 378 { 379 struct gpio_virtuser_irq_work_context ctx; 380 381 gpio_virtuser_init_irq_work_context(&ctx); 382 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_do_set_direction_atomic); 383 ctx.desc = desc; 384 ctx.dir = dir; 385 ctx.val = val; 386 387 gpio_virtuser_irq_work_queue_sync(&ctx); 388 389 return ctx.ret; 390 } 391 392 static ssize_t gpio_virtuser_direction_do_write(struct file *file, 393 const char __user *user_buf, 394 size_t count, loff_t *ppos, 395 bool atomic) 396 { 397 struct gpio_virtuser_line_data *data = file->private_data; 398 struct gpio_desc *desc = data->ad.desc; 399 char buf[32], *trimmed; 400 int ret, dir, val = 0; 401 402 if (count >= sizeof(buf)) 403 return -EINVAL; 404 405 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count); 406 if (ret < 0) 407 return ret; 408 409 buf[ret] = '\0'; 410 411 trimmed = strim(buf); 412 413 if (strcmp(trimmed, "input") == 0) { 414 dir = 1; 415 } else if (strcmp(trimmed, "output-high") == 0) { 416 dir = 0; 417 val = 1; 418 } else if (strcmp(trimmed, "output-low") == 0) { 419 dir = val = 0; 420 } else { 421 return -EINVAL; 422 } 423 424 if (!atomic) 425 ret = gpio_virtuser_set_direction(desc, dir, val); 426 else 427 ret = gpio_virtuser_set_direction_atomic(desc, dir, val); 428 if (ret) 429 return ret; 430 431 return count; 432 } 433 434 static ssize_t gpio_virtuser_direction_read(struct file *file, 435 char __user *user_buf, 436 size_t size, loff_t *ppos) 437 { 438 return gpio_virtuser_direction_do_read(file, user_buf, size, ppos, 439 false); 440 } 441 442 static ssize_t gpio_virtuser_direction_write(struct file *file, 443 const char __user *user_buf, 444 size_t count, loff_t *ppos) 445 { 446 return gpio_virtuser_direction_do_write(file, user_buf, count, ppos, 447 false); 448 } 449 450 static const struct file_operations gpio_virtuser_direction_fops = { 451 .read = gpio_virtuser_direction_read, 452 .write = gpio_virtuser_direction_write, 453 .open = simple_open, 454 .owner = THIS_MODULE, 455 .llseek = default_llseek, 456 }; 457 458 static ssize_t gpio_virtuser_direction_atomic_read(struct file *file, 459 char __user *user_buf, 460 size_t size, loff_t *ppos) 461 { 462 return gpio_virtuser_direction_do_read(file, user_buf, size, ppos, 463 true); 464 } 465 466 static ssize_t gpio_virtuser_direction_atomic_write(struct file *file, 467 const char __user *user_buf, 468 size_t count, loff_t *ppos) 469 { 470 return gpio_virtuser_direction_do_write(file, user_buf, count, ppos, 471 true); 472 } 473 474 static const struct file_operations gpio_virtuser_direction_atomic_fops = { 475 .read = gpio_virtuser_direction_atomic_read, 476 .write = gpio_virtuser_direction_atomic_write, 477 .open = simple_open, 478 .owner = THIS_MODULE, 479 .llseek = default_llseek, 480 }; 481 482 static int gpio_virtuser_value_get(void *data, u64 *val) 483 { 484 struct gpio_virtuser_line_data *ld = data; 485 int ret; 486 487 ret = gpiod_get_value_cansleep(ld->ad.desc); 488 if (ret < 0) 489 return ret; 490 491 *val = ret; 492 493 return 0; 494 } 495 496 static int gpio_virtuser_value_set(void *data, u64 val) 497 { 498 struct gpio_virtuser_line_data *ld = data; 499 500 if (val > 1) 501 return -EINVAL; 502 503 return gpiod_set_value_cansleep(ld->ad.desc, (int)val); 504 } 505 506 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_value_fops, 507 gpio_virtuser_value_get, 508 gpio_virtuser_value_set, 509 "%llu\n"); 510 511 static void gpio_virtuser_get_value_atomic(struct irq_work *work) 512 { 513 struct gpio_virtuser_irq_work_context *ctx = 514 to_gpio_virtuser_irq_work_context(work); 515 516 ctx->val = gpiod_get_value(ctx->desc); 517 complete(&ctx->work_completion); 518 } 519 520 static int gpio_virtuser_value_atomic_get(void *data, u64 *val) 521 { 522 struct gpio_virtuser_line_data *ld = data; 523 struct gpio_virtuser_irq_work_context ctx; 524 525 gpio_virtuser_init_irq_work_context(&ctx); 526 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_get_value_atomic); 527 ctx.desc = ld->ad.desc; 528 529 gpio_virtuser_irq_work_queue_sync(&ctx); 530 531 if (ctx.val < 0) 532 return ctx.val; 533 534 *val = ctx.val; 535 536 return 0; 537 } 538 539 static void gpio_virtuser_set_value_atomic(struct irq_work *work) 540 { 541 struct gpio_virtuser_irq_work_context *ctx = 542 to_gpio_virtuser_irq_work_context(work); 543 544 ctx->ret = gpiod_set_value(ctx->desc, ctx->val); 545 complete(&ctx->work_completion); 546 } 547 548 static int gpio_virtuser_value_atomic_set(void *data, u64 val) 549 { 550 struct gpio_virtuser_line_data *ld = data; 551 struct gpio_virtuser_irq_work_context ctx; 552 553 if (val > 1) 554 return -EINVAL; 555 556 gpio_virtuser_init_irq_work_context(&ctx); 557 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_set_value_atomic); 558 ctx.desc = ld->ad.desc; 559 ctx.val = (int)val; 560 561 gpio_virtuser_irq_work_queue_sync(&ctx); 562 563 return ctx.ret; 564 } 565 566 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_value_atomic_fops, 567 gpio_virtuser_value_atomic_get, 568 gpio_virtuser_value_atomic_set, 569 "%llu\n"); 570 571 static int gpio_virtuser_debounce_get(void *data, u64 *val) 572 { 573 struct gpio_virtuser_line_data *ld = data; 574 575 *val = READ_ONCE(ld->debounce); 576 577 return 0; 578 } 579 580 static int gpio_virtuser_debounce_set(void *data, u64 val) 581 { 582 struct gpio_virtuser_line_data *ld = data; 583 int ret; 584 585 if (val > UINT_MAX) 586 return -E2BIG; 587 588 ret = gpiod_set_debounce(ld->ad.desc, (unsigned int)val); 589 if (ret) 590 /* Don't propagate errno unknown to user-space. */ 591 return ret == -ENOTSUPP ? -EOPNOTSUPP : ret; 592 593 WRITE_ONCE(ld->debounce, (unsigned int)val); 594 595 return 0; 596 } 597 598 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_debounce_fops, 599 gpio_virtuser_debounce_get, 600 gpio_virtuser_debounce_set, 601 "%llu\n"); 602 603 static ssize_t gpio_virtuser_consumer_read(struct file *file, 604 char __user *user_buf, 605 size_t size, loff_t *ppos) 606 { 607 struct gpio_virtuser_line_data *data = file->private_data; 608 char buf[GPIO_VIRTUSER_NAME_BUF_LEN + 1]; 609 ssize_t ret; 610 611 memset(buf, 0x0, sizeof(buf)); 612 613 scoped_guard(mutex, &data->consumer_lock) 614 ret = snprintf(buf, sizeof(buf), "%s\n", data->consumer); 615 616 return simple_read_from_buffer(user_buf, size, ppos, buf, ret); 617 } 618 619 static ssize_t gpio_virtuser_consumer_write(struct file *file, 620 const char __user *user_buf, 621 size_t count, loff_t *ppos) 622 { 623 struct gpio_virtuser_line_data *data = file->private_data; 624 char buf[GPIO_VIRTUSER_NAME_BUF_LEN + 2]; 625 int ret; 626 627 if (count >= sizeof(buf)) 628 return -EINVAL; 629 630 ret = simple_write_to_buffer(buf, GPIO_VIRTUSER_NAME_BUF_LEN, ppos, 631 user_buf, count); 632 if (ret < 0) 633 return ret; 634 635 buf[ret] = '\0'; 636 637 ret = gpiod_set_consumer_name(data->ad.desc, buf); 638 if (ret) 639 return ret; 640 641 scoped_guard(mutex, &data->consumer_lock) 642 strscpy(data->consumer, buf, sizeof(data->consumer)); 643 644 return count; 645 } 646 647 static const struct file_operations gpio_virtuser_consumer_fops = { 648 .read = gpio_virtuser_consumer_read, 649 .write = gpio_virtuser_consumer_write, 650 .open = simple_open, 651 .owner = THIS_MODULE, 652 .llseek = default_llseek, 653 }; 654 655 static int gpio_virtuser_interrupts_get(void *data, u64 *val) 656 { 657 struct gpio_virtuser_line_data *ld = data; 658 659 *val = atomic_read(&ld->irq_count); 660 661 return 0; 662 } 663 664 static irqreturn_t gpio_virtuser_irq_handler(int irq, void *data) 665 { 666 struct gpio_virtuser_line_data *ld = data; 667 668 atomic_inc(&ld->irq_count); 669 670 return IRQ_HANDLED; 671 } 672 673 static int gpio_virtuser_interrupts_set(void *data, u64 val) 674 { 675 struct gpio_virtuser_line_data *ld = data; 676 int irq, ret; 677 678 if (val > 1) 679 return -EINVAL; 680 681 if (val) { 682 irq = gpiod_to_irq(ld->ad.desc); 683 if (irq < 0) 684 return irq; 685 686 ret = request_threaded_irq(irq, NULL, 687 gpio_virtuser_irq_handler, 688 IRQF_TRIGGER_RISING | 689 IRQF_TRIGGER_FALLING | 690 IRQF_ONESHOT, 691 ld->consumer, data); 692 if (ret) 693 return ret; 694 695 atomic_set(&ld->irq, irq); 696 } else { 697 irq = atomic_xchg(&ld->irq, 0); 698 free_irq(irq, ld); 699 } 700 701 return 0; 702 } 703 704 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_interrupts_fops, 705 gpio_virtuser_interrupts_get, 706 gpio_virtuser_interrupts_set, 707 "%llu\n"); 708 709 static const struct gpio_virtuser_dbgfs_attr_descr 710 gpio_virtuser_line_array_dbgfs_attrs[] = { 711 { 712 .name = "values", 713 .fops = &gpio_virtuser_value_array_fops, 714 }, 715 { 716 .name = "values_atomic", 717 .fops = &gpio_virtuser_value_array_atomic_fops, 718 }, 719 }; 720 721 static const struct gpio_virtuser_dbgfs_attr_descr 722 gpio_virtuser_line_dbgfs_attrs[] = { 723 { 724 .name = "direction", 725 .fops = &gpio_virtuser_direction_fops, 726 }, 727 { 728 .name = "direction_atomic", 729 .fops = &gpio_virtuser_direction_atomic_fops, 730 }, 731 { 732 .name = "value", 733 .fops = &gpio_virtuser_value_fops, 734 }, 735 { 736 .name = "value_atomic", 737 .fops = &gpio_virtuser_value_atomic_fops, 738 }, 739 { 740 .name = "debounce", 741 .fops = &gpio_virtuser_debounce_fops, 742 }, 743 { 744 .name = "consumer", 745 .fops = &gpio_virtuser_consumer_fops, 746 }, 747 { 748 .name = "interrupts", 749 .fops = &gpio_virtuser_interrupts_fops, 750 }, 751 }; 752 753 static int gpio_virtuser_create_debugfs_attrs( 754 const struct gpio_virtuser_dbgfs_attr_descr *attr, 755 size_t num_attrs, struct dentry *parent, void *data) 756 { 757 struct dentry *ret; 758 size_t i; 759 760 for (i = 0; i < num_attrs; i++, attr++) { 761 ret = debugfs_create_file(attr->name, 0644, parent, data, 762 attr->fops); 763 if (IS_ERR(ret)) 764 return PTR_ERR(ret); 765 } 766 767 return 0; 768 } 769 770 static int gpio_virtuser_dbgfs_init_line_array_attrs(struct device *dev, 771 struct gpio_descs *descs, 772 const char *id, 773 struct dentry *dbgfs_entry) 774 { 775 struct gpio_virtuser_line_array_data *data; 776 char *name; 777 778 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 779 if (!data) 780 return -ENOMEM; 781 782 data->ad.descs = descs; 783 784 name = devm_kasprintf(dev, GFP_KERNEL, "gpiod:%s", id); 785 if (!name) 786 return -ENOMEM; 787 788 data->ad.dbgfs_dir = debugfs_create_dir(name, dbgfs_entry); 789 if (IS_ERR(data->ad.dbgfs_dir)) 790 return PTR_ERR(data->ad.dbgfs_dir); 791 792 return gpio_virtuser_create_debugfs_attrs( 793 gpio_virtuser_line_array_dbgfs_attrs, 794 ARRAY_SIZE(gpio_virtuser_line_array_dbgfs_attrs), 795 data->ad.dbgfs_dir, data); 796 } 797 798 static int gpio_virtuser_dbgfs_init_line_attrs(struct device *dev, 799 struct gpio_desc *desc, 800 const char *id, 801 unsigned int index, 802 struct dentry *dbgfs_entry) 803 { 804 struct gpio_virtuser_line_data *data; 805 char *name; 806 int ret; 807 808 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 809 if (!data) 810 return -ENOMEM; 811 812 data->ad.desc = desc; 813 strscpy(data->consumer, id); 814 atomic_set(&data->irq, 0); 815 atomic_set(&data->irq_count, 0); 816 817 name = devm_kasprintf(dev, GFP_KERNEL, "gpiod:%s:%u", id, index); 818 if (!name) 819 return -ENOMEM; 820 821 ret = devm_mutex_init(dev, &data->consumer_lock); 822 if (ret) 823 return ret; 824 825 data->ad.dbgfs_dir = debugfs_create_dir(name, dbgfs_entry); 826 if (IS_ERR(data->ad.dbgfs_dir)) 827 return PTR_ERR(data->ad.dbgfs_dir); 828 829 return gpio_virtuser_create_debugfs_attrs( 830 gpio_virtuser_line_dbgfs_attrs, 831 ARRAY_SIZE(gpio_virtuser_line_dbgfs_attrs), 832 data->ad.dbgfs_dir, data); 833 } 834 835 static void gpio_virtuser_debugfs_remove(void *data) 836 { 837 struct dentry *dbgfs_entry = data; 838 839 debugfs_remove_recursive(dbgfs_entry); 840 } 841 842 static int gpio_virtuser_prop_is_gpio(struct property *prop) 843 { 844 char *dash = strrchr(prop->name, '-'); 845 846 return dash && strcmp(dash, "-gpios") == 0; 847 } 848 849 /* 850 * If this is an OF-based system, then we iterate over properties and consider 851 * all whose names end in "-gpios". For configfs we expect an additional string 852 * array property - "gpio-virtuser,ids" - containing the list of all GPIO IDs 853 * to request. 854 */ 855 static int gpio_virtuser_count_ids(struct device *dev) 856 { 857 struct device_node *of_node = dev_of_node(dev); 858 struct property *prop; 859 int ret = 0; 860 861 if (!of_node) 862 return device_property_string_array_count(dev, 863 "gpio-virtuser,ids"); 864 865 for_each_property_of_node(of_node, prop) { 866 if (gpio_virtuser_prop_is_gpio(prop)) 867 ++ret; 868 } 869 870 return ret; 871 } 872 873 static int gpio_virtuser_get_ids(struct device *dev, const char **ids, 874 int num_ids) 875 { 876 struct device_node *of_node = dev_of_node(dev); 877 struct property *prop; 878 size_t pos = 0, diff; 879 char *dash, *tmp; 880 881 if (!of_node) 882 return device_property_read_string_array(dev, 883 "gpio-virtuser,ids", 884 ids, num_ids); 885 886 for_each_property_of_node(of_node, prop) { 887 if (!gpio_virtuser_prop_is_gpio(prop)) 888 continue; 889 890 dash = strrchr(prop->name, '-'); 891 diff = dash - prop->name; 892 893 tmp = devm_kmemdup(dev, prop->name, diff + 1, 894 GFP_KERNEL); 895 if (!tmp) 896 return -ENOMEM; 897 898 tmp[diff] = '\0'; 899 ids[pos++] = tmp; 900 } 901 902 return 0; 903 } 904 905 static int gpio_virtuser_probe(struct platform_device *pdev) 906 { 907 struct device *dev = &pdev->dev; 908 struct dentry *dbgfs_entry; 909 struct gpio_descs *descs; 910 int ret, num_ids = 0, i; 911 const char **ids; 912 unsigned int j; 913 914 num_ids = gpio_virtuser_count_ids(dev); 915 if (num_ids < 0) 916 return dev_err_probe(dev, num_ids, 917 "Failed to get the number of GPIOs to request\n"); 918 919 if (num_ids == 0) 920 return dev_err_probe(dev, -EINVAL, "No GPIO IDs specified\n"); 921 922 ids = devm_kcalloc(dev, num_ids, sizeof(*ids), GFP_KERNEL); 923 if (!ids) 924 return -ENOMEM; 925 926 ret = gpio_virtuser_get_ids(dev, ids, num_ids); 927 if (ret < 0) 928 return dev_err_probe(dev, ret, 929 "Failed to get the IDs of GPIOs to request\n"); 930 931 dbgfs_entry = debugfs_create_dir(dev_name(dev), gpio_virtuser_dbg_root); 932 ret = devm_add_action_or_reset(dev, gpio_virtuser_debugfs_remove, 933 dbgfs_entry); 934 if (ret) 935 return ret; 936 937 for (i = 0; i < num_ids; i++) { 938 descs = devm_gpiod_get_array(dev, ids[i], GPIOD_ASIS); 939 if (IS_ERR(descs)) 940 return dev_err_probe(dev, PTR_ERR(descs), 941 "Failed to request the '%s' GPIOs\n", 942 ids[i]); 943 944 ret = gpio_virtuser_dbgfs_init_line_array_attrs(dev, descs, 945 ids[i], 946 dbgfs_entry); 947 if (ret) 948 return dev_err_probe(dev, ret, 949 "Failed to setup the debugfs array interface for the '%s' GPIOs\n", 950 ids[i]); 951 952 for (j = 0; j < descs->ndescs; j++) { 953 ret = gpio_virtuser_dbgfs_init_line_attrs(dev, 954 descs->desc[j], ids[i], 955 j, dbgfs_entry); 956 if (ret) 957 return dev_err_probe(dev, ret, 958 "Failed to setup the debugfs line interface for the '%s' GPIOs\n", 959 ids[i]); 960 } 961 } 962 963 return 0; 964 } 965 966 static const struct of_device_id gpio_virtuser_of_match[] = { 967 { .compatible = "gpio-virtuser" }, 968 { } 969 }; 970 MODULE_DEVICE_TABLE(of, gpio_virtuser_of_match); 971 972 static struct platform_driver gpio_virtuser_driver = { 973 .driver = { 974 .name = "gpio-virtuser", 975 .of_match_table = gpio_virtuser_of_match, 976 }, 977 .probe = gpio_virtuser_probe, 978 }; 979 980 struct gpio_virtuser_device { 981 struct dev_sync_probe_data probe_data; 982 struct config_group group; 983 984 int id; 985 struct mutex lock; 986 987 struct gpiod_lookup_table *lookup_table; 988 989 struct list_head lookup_list; 990 }; 991 992 static struct gpio_virtuser_device * 993 to_gpio_virtuser_device(struct config_item *item) 994 { 995 struct config_group *group = to_config_group(item); 996 997 return container_of(group, struct gpio_virtuser_device, group); 998 } 999 1000 static bool 1001 gpio_virtuser_device_is_live(struct gpio_virtuser_device *dev) 1002 { 1003 lockdep_assert_held(&dev->lock); 1004 1005 return !!dev->probe_data.pdev; 1006 } 1007 1008 struct gpio_virtuser_lookup { 1009 struct config_group group; 1010 1011 struct gpio_virtuser_device *parent; 1012 struct list_head siblings; 1013 1014 char *con_id; 1015 1016 struct list_head entry_list; 1017 }; 1018 1019 static struct gpio_virtuser_lookup * 1020 to_gpio_virtuser_lookup(struct config_item *item) 1021 { 1022 struct config_group *group = to_config_group(item); 1023 1024 return container_of(group, struct gpio_virtuser_lookup, group); 1025 } 1026 1027 struct gpio_virtuser_lookup_entry { 1028 struct config_group group; 1029 1030 struct gpio_virtuser_lookup *parent; 1031 struct list_head siblings; 1032 1033 char *key; 1034 /* Can be negative to indicate lookup by name. */ 1035 int offset; 1036 enum gpio_lookup_flags flags; 1037 }; 1038 1039 static struct gpio_virtuser_lookup_entry * 1040 to_gpio_virtuser_lookup_entry(struct config_item *item) 1041 { 1042 struct config_group *group = to_config_group(item); 1043 1044 return container_of(group, struct gpio_virtuser_lookup_entry, group); 1045 } 1046 1047 static ssize_t 1048 gpio_virtuser_lookup_entry_config_key_show(struct config_item *item, char *page) 1049 { 1050 struct gpio_virtuser_lookup_entry *entry = 1051 to_gpio_virtuser_lookup_entry(item); 1052 struct gpio_virtuser_device *dev = entry->parent->parent; 1053 1054 guard(mutex)(&dev->lock); 1055 1056 return sprintf(page, "%s\n", entry->key ?: ""); 1057 } 1058 1059 static ssize_t 1060 gpio_virtuser_lookup_entry_config_key_store(struct config_item *item, 1061 const char *page, size_t count) 1062 { 1063 struct gpio_virtuser_lookup_entry *entry = 1064 to_gpio_virtuser_lookup_entry(item); 1065 struct gpio_virtuser_device *dev = entry->parent->parent; 1066 1067 char *key __free(kfree) = kstrndup(skip_spaces(page), count, 1068 GFP_KERNEL); 1069 if (!key) 1070 return -ENOMEM; 1071 1072 strim(key); 1073 1074 guard(mutex)(&dev->lock); 1075 1076 if (gpio_virtuser_device_is_live(dev)) 1077 return -EBUSY; 1078 1079 kfree(entry->key); 1080 entry->key = no_free_ptr(key); 1081 1082 return count; 1083 } 1084 1085 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, key); 1086 1087 static ssize_t 1088 gpio_virtuser_lookup_entry_config_offset_show(struct config_item *item, 1089 char *page) 1090 { 1091 struct gpio_virtuser_lookup_entry *entry = 1092 to_gpio_virtuser_lookup_entry(item); 1093 struct gpio_virtuser_device *dev = entry->parent->parent; 1094 unsigned int offset; 1095 1096 scoped_guard(mutex, &dev->lock) 1097 offset = entry->offset; 1098 1099 return sprintf(page, "%d\n", offset); 1100 } 1101 1102 static ssize_t 1103 gpio_virtuser_lookup_entry_config_offset_store(struct config_item *item, 1104 const char *page, size_t count) 1105 { 1106 struct gpio_virtuser_lookup_entry *entry = 1107 to_gpio_virtuser_lookup_entry(item); 1108 struct gpio_virtuser_device *dev = entry->parent->parent; 1109 int offset, ret; 1110 1111 ret = kstrtoint(page, 0, &offset); 1112 if (ret) 1113 return ret; 1114 1115 /* 1116 * Negative number here means: 'key' represents a line name to lookup. 1117 * Non-negative means: 'key' represents the label of the chip with 1118 * the 'offset' value representing the line within that chip. 1119 * 1120 * GPIOLIB uses the U16_MAX value to indicate lookup by line name so 1121 * the greatest offset we can accept is (U16_MAX - 1). 1122 */ 1123 if (offset > (U16_MAX - 1)) 1124 return -EINVAL; 1125 1126 guard(mutex)(&dev->lock); 1127 1128 if (gpio_virtuser_device_is_live(dev)) 1129 return -EBUSY; 1130 1131 entry->offset = offset; 1132 1133 return count; 1134 } 1135 1136 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, offset); 1137 1138 static enum gpio_lookup_flags 1139 gpio_virtuser_lookup_get_flags(struct config_item *item) 1140 { 1141 struct gpio_virtuser_lookup_entry *entry = 1142 to_gpio_virtuser_lookup_entry(item); 1143 struct gpio_virtuser_device *dev = entry->parent->parent; 1144 1145 guard(mutex)(&dev->lock); 1146 1147 return entry->flags; 1148 } 1149 1150 static ssize_t 1151 gpio_virtuser_lookup_entry_config_drive_show(struct config_item *item, char *page) 1152 { 1153 enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item); 1154 const char *repr; 1155 1156 if (flags & GPIO_OPEN_DRAIN) 1157 repr = "open-drain"; 1158 else if (flags & GPIO_OPEN_SOURCE) 1159 repr = "open-source"; 1160 else 1161 repr = "push-pull"; 1162 1163 return sprintf(page, "%s\n", repr); 1164 } 1165 1166 static ssize_t 1167 gpio_virtuser_lookup_entry_config_drive_store(struct config_item *item, 1168 const char *page, size_t count) 1169 { 1170 struct gpio_virtuser_lookup_entry *entry = 1171 to_gpio_virtuser_lookup_entry(item); 1172 struct gpio_virtuser_device *dev = entry->parent->parent; 1173 1174 guard(mutex)(&dev->lock); 1175 1176 if (gpio_virtuser_device_is_live(dev)) 1177 return -EBUSY; 1178 1179 if (sysfs_streq(page, "push-pull")) { 1180 entry->flags &= ~(GPIO_OPEN_DRAIN | GPIO_OPEN_SOURCE); 1181 } else if (sysfs_streq(page, "open-drain")) { 1182 entry->flags &= ~GPIO_OPEN_SOURCE; 1183 entry->flags |= GPIO_OPEN_DRAIN; 1184 } else if (sysfs_streq(page, "open-source")) { 1185 entry->flags &= ~GPIO_OPEN_DRAIN; 1186 entry->flags |= GPIO_OPEN_SOURCE; 1187 } else { 1188 count = -EINVAL; 1189 } 1190 1191 return count; 1192 } 1193 1194 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, drive); 1195 1196 static ssize_t 1197 gpio_virtuser_lookup_entry_config_pull_show(struct config_item *item, char *page) 1198 { 1199 enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item); 1200 const char *repr; 1201 1202 if (flags & GPIO_PULL_UP) 1203 repr = "pull-up"; 1204 else if (flags & GPIO_PULL_DOWN) 1205 repr = "pull-down"; 1206 else if (flags & GPIO_PULL_DISABLE) 1207 repr = "pull-disabled"; 1208 else 1209 repr = "as-is"; 1210 1211 return sprintf(page, "%s\n", repr); 1212 } 1213 1214 static ssize_t 1215 gpio_virtuser_lookup_entry_config_pull_store(struct config_item *item, 1216 const char *page, size_t count) 1217 { 1218 struct gpio_virtuser_lookup_entry *entry = 1219 to_gpio_virtuser_lookup_entry(item); 1220 struct gpio_virtuser_device *dev = entry->parent->parent; 1221 1222 guard(mutex)(&dev->lock); 1223 1224 if (gpio_virtuser_device_is_live(dev)) 1225 return -EBUSY; 1226 1227 if (sysfs_streq(page, "pull-up")) { 1228 entry->flags &= ~(GPIO_PULL_DOWN | GPIO_PULL_DISABLE); 1229 entry->flags |= GPIO_PULL_UP; 1230 } else if (sysfs_streq(page, "pull-down")) { 1231 entry->flags &= ~(GPIO_PULL_UP | GPIO_PULL_DISABLE); 1232 entry->flags |= GPIO_PULL_DOWN; 1233 } else if (sysfs_streq(page, "pull-disabled")) { 1234 entry->flags &= ~(GPIO_PULL_UP | GPIO_PULL_DOWN); 1235 entry->flags |= GPIO_PULL_DISABLE; 1236 } else if (sysfs_streq(page, "as-is")) { 1237 entry->flags &= ~(GPIO_PULL_UP | GPIO_PULL_DOWN | 1238 GPIO_PULL_DISABLE); 1239 } else { 1240 count = -EINVAL; 1241 } 1242 1243 return count; 1244 } 1245 1246 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, pull); 1247 1248 static ssize_t 1249 gpio_virtuser_lookup_entry_config_active_low_show(struct config_item *item, 1250 char *page) 1251 { 1252 enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item); 1253 1254 return sprintf(page, "%c\n", flags & GPIO_ACTIVE_LOW ? '1' : '0'); 1255 } 1256 1257 static ssize_t 1258 gpio_virtuser_lookup_entry_config_active_low_store(struct config_item *item, 1259 const char *page, 1260 size_t count) 1261 { 1262 struct gpio_virtuser_lookup_entry *entry = 1263 to_gpio_virtuser_lookup_entry(item); 1264 struct gpio_virtuser_device *dev = entry->parent->parent; 1265 bool active_low; 1266 int ret; 1267 1268 ret = kstrtobool(page, &active_low); 1269 if (ret) 1270 return ret; 1271 1272 guard(mutex)(&dev->lock); 1273 1274 if (gpio_virtuser_device_is_live(dev)) 1275 return -EBUSY; 1276 1277 if (active_low) 1278 entry->flags |= GPIO_ACTIVE_LOW; 1279 else 1280 entry->flags &= ~GPIO_ACTIVE_LOW; 1281 1282 return count; 1283 } 1284 1285 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, active_low); 1286 1287 static ssize_t 1288 gpio_virtuser_lookup_entry_config_transitory_show(struct config_item *item, 1289 char *page) 1290 { 1291 enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item); 1292 1293 return sprintf(page, "%c\n", flags & GPIO_TRANSITORY ? '1' : '0'); 1294 } 1295 1296 static ssize_t 1297 gpio_virtuser_lookup_entry_config_transitory_store(struct config_item *item, 1298 const char *page, 1299 size_t count) 1300 { 1301 struct gpio_virtuser_lookup_entry *entry = 1302 to_gpio_virtuser_lookup_entry(item); 1303 struct gpio_virtuser_device *dev = entry->parent->parent; 1304 bool transitory; 1305 int ret; 1306 1307 ret = kstrtobool(page, &transitory); 1308 if (ret) 1309 return ret; 1310 1311 guard(mutex)(&dev->lock); 1312 1313 if (gpio_virtuser_device_is_live(dev)) 1314 return -EBUSY; 1315 1316 if (transitory) 1317 entry->flags |= GPIO_TRANSITORY; 1318 else 1319 entry->flags &= ~GPIO_TRANSITORY; 1320 1321 return count; 1322 } 1323 1324 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, transitory); 1325 1326 static struct configfs_attribute *gpio_virtuser_lookup_entry_config_attrs[] = { 1327 &gpio_virtuser_lookup_entry_config_attr_key, 1328 &gpio_virtuser_lookup_entry_config_attr_offset, 1329 &gpio_virtuser_lookup_entry_config_attr_drive, 1330 &gpio_virtuser_lookup_entry_config_attr_pull, 1331 &gpio_virtuser_lookup_entry_config_attr_active_low, 1332 &gpio_virtuser_lookup_entry_config_attr_transitory, 1333 NULL 1334 }; 1335 1336 static ssize_t 1337 gpio_virtuser_device_config_dev_name_show(struct config_item *item, 1338 char *page) 1339 { 1340 struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item); 1341 struct platform_device *pdev; 1342 1343 guard(mutex)(&dev->lock); 1344 1345 pdev = dev->probe_data.pdev; 1346 if (pdev) 1347 return sprintf(page, "%s\n", dev_name(&pdev->dev)); 1348 1349 return sprintf(page, "gpio-sim.%d\n", dev->id); 1350 } 1351 1352 CONFIGFS_ATTR_RO(gpio_virtuser_device_config_, dev_name); 1353 1354 static ssize_t gpio_virtuser_device_config_live_show(struct config_item *item, 1355 char *page) 1356 { 1357 struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item); 1358 bool live; 1359 1360 scoped_guard(mutex, &dev->lock) 1361 live = gpio_virtuser_device_is_live(dev); 1362 1363 return sprintf(page, "%c\n", live ? '1' : '0'); 1364 } 1365 1366 static size_t 1367 gpio_virtuser_get_lookup_count(struct gpio_virtuser_device *dev) 1368 { 1369 struct gpio_virtuser_lookup *lookup; 1370 size_t count = 0; 1371 1372 lockdep_assert_held(&dev->lock); 1373 1374 list_for_each_entry(lookup, &dev->lookup_list, siblings) 1375 count += list_count_nodes(&lookup->entry_list); 1376 1377 return count; 1378 } 1379 1380 static int 1381 gpio_virtuser_make_lookup_table(struct gpio_virtuser_device *dev) 1382 { 1383 size_t num_entries = gpio_virtuser_get_lookup_count(dev); 1384 struct gpio_virtuser_lookup_entry *entry; 1385 struct gpio_virtuser_lookup *lookup; 1386 unsigned int i = 0, idx; 1387 1388 lockdep_assert_held(&dev->lock); 1389 1390 struct gpiod_lookup_table *table __free(kfree) = 1391 kzalloc(struct_size(table, table, num_entries + 1), GFP_KERNEL); 1392 if (!table) 1393 return -ENOMEM; 1394 1395 table->dev_id = kasprintf(GFP_KERNEL, "gpio-virtuser.%d", dev->id); 1396 if (!table->dev_id) 1397 return -ENOMEM; 1398 1399 list_for_each_entry(lookup, &dev->lookup_list, siblings) { 1400 idx = 0; 1401 list_for_each_entry(entry, &lookup->entry_list, siblings) { 1402 table->table[i++] = 1403 GPIO_LOOKUP_IDX(entry->key, 1404 entry->offset < 0 ? U16_MAX : entry->offset, 1405 lookup->con_id, idx++, entry->flags); 1406 } 1407 } 1408 1409 gpiod_add_lookup_table(table); 1410 dev->lookup_table = no_free_ptr(table); 1411 1412 return 0; 1413 } 1414 1415 static void 1416 gpio_virtuser_remove_lookup_table(struct gpio_virtuser_device *dev) 1417 { 1418 gpiod_remove_lookup_table(dev->lookup_table); 1419 kfree(dev->lookup_table->dev_id); 1420 kfree(dev->lookup_table); 1421 dev->lookup_table = NULL; 1422 } 1423 1424 static struct fwnode_handle * 1425 gpio_virtuser_make_device_swnode(struct gpio_virtuser_device *dev) 1426 { 1427 struct property_entry properties[2]; 1428 struct gpio_virtuser_lookup *lookup; 1429 unsigned int i = 0; 1430 size_t num_ids; 1431 1432 memset(properties, 0, sizeof(properties)); 1433 1434 num_ids = list_count_nodes(&dev->lookup_list); 1435 char **ids __free(kfree) = kcalloc(num_ids + 1, sizeof(*ids), 1436 GFP_KERNEL); 1437 if (!ids) 1438 return ERR_PTR(-ENOMEM); 1439 1440 list_for_each_entry(lookup, &dev->lookup_list, siblings) 1441 ids[i++] = lookup->con_id; 1442 1443 properties[0] = PROPERTY_ENTRY_STRING_ARRAY_LEN("gpio-virtuser,ids", 1444 ids, num_ids); 1445 1446 return fwnode_create_software_node(properties, NULL); 1447 } 1448 1449 static int 1450 gpio_virtuser_device_activate(struct gpio_virtuser_device *dev) 1451 { 1452 struct platform_device_info pdevinfo; 1453 struct fwnode_handle *swnode; 1454 int ret; 1455 1456 lockdep_assert_held(&dev->lock); 1457 1458 if (list_empty(&dev->lookup_list)) 1459 return -ENODATA; 1460 1461 swnode = gpio_virtuser_make_device_swnode(dev); 1462 if (IS_ERR(swnode)) 1463 return PTR_ERR(swnode); 1464 1465 memset(&pdevinfo, 0, sizeof(pdevinfo)); 1466 pdevinfo.name = "gpio-virtuser"; 1467 pdevinfo.id = dev->id; 1468 pdevinfo.fwnode = swnode; 1469 1470 ret = gpio_virtuser_make_lookup_table(dev); 1471 if (ret) 1472 goto err_remove_swnode; 1473 1474 ret = dev_sync_probe_register(&dev->probe_data, &pdevinfo); 1475 if (ret) 1476 goto err_remove_lookup_table; 1477 1478 return 0; 1479 1480 err_remove_lookup_table: 1481 gpio_virtuser_remove_lookup_table(dev); 1482 err_remove_swnode: 1483 fwnode_remove_software_node(swnode); 1484 1485 return ret; 1486 } 1487 1488 static void 1489 gpio_virtuser_device_deactivate(struct gpio_virtuser_device *dev) 1490 { 1491 struct fwnode_handle *swnode; 1492 1493 lockdep_assert_held(&dev->lock); 1494 1495 swnode = dev_fwnode(&dev->probe_data.pdev->dev); 1496 dev_sync_probe_unregister(&dev->probe_data); 1497 gpio_virtuser_remove_lookup_table(dev); 1498 fwnode_remove_software_node(swnode); 1499 } 1500 1501 static void 1502 gpio_virtuser_device_lockup_configfs(struct gpio_virtuser_device *dev, bool lock) 1503 { 1504 struct configfs_subsystem *subsys = dev->group.cg_subsys; 1505 struct gpio_virtuser_lookup_entry *entry; 1506 struct gpio_virtuser_lookup *lookup; 1507 1508 /* 1509 * The device only needs to depend on leaf lookup entries. This is 1510 * sufficient to lock up all the configfs entries that the 1511 * instantiated, alive device depends on. 1512 */ 1513 list_for_each_entry(lookup, &dev->lookup_list, siblings) { 1514 list_for_each_entry(entry, &lookup->entry_list, siblings) { 1515 if (lock) 1516 WARN_ON(configfs_depend_item_unlocked( 1517 subsys, &entry->group.cg_item)); 1518 else 1519 configfs_undepend_item_unlocked( 1520 &entry->group.cg_item); 1521 } 1522 } 1523 } 1524 1525 static ssize_t 1526 gpio_virtuser_device_config_live_store(struct config_item *item, 1527 const char *page, size_t count) 1528 { 1529 struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item); 1530 int ret = 0; 1531 bool live; 1532 1533 ret = kstrtobool(page, &live); 1534 if (ret) 1535 return ret; 1536 1537 if (live) 1538 gpio_virtuser_device_lockup_configfs(dev, true); 1539 1540 scoped_guard(mutex, &dev->lock) { 1541 if (live == gpio_virtuser_device_is_live(dev)) 1542 ret = -EPERM; 1543 else if (live) 1544 ret = gpio_virtuser_device_activate(dev); 1545 else 1546 gpio_virtuser_device_deactivate(dev); 1547 } 1548 1549 /* 1550 * Undepend is required only if device disablement (live == 0) 1551 * succeeds or if device enablement (live == 1) fails. 1552 */ 1553 if (live == !!ret) 1554 gpio_virtuser_device_lockup_configfs(dev, false); 1555 1556 return ret ?: count; 1557 } 1558 1559 CONFIGFS_ATTR(gpio_virtuser_device_config_, live); 1560 1561 static struct configfs_attribute *gpio_virtuser_device_config_attrs[] = { 1562 &gpio_virtuser_device_config_attr_dev_name, 1563 &gpio_virtuser_device_config_attr_live, 1564 NULL 1565 }; 1566 1567 static void 1568 gpio_virtuser_lookup_entry_config_group_release(struct config_item *item) 1569 { 1570 struct gpio_virtuser_lookup_entry *entry = 1571 to_gpio_virtuser_lookup_entry(item); 1572 struct gpio_virtuser_device *dev = entry->parent->parent; 1573 1574 guard(mutex)(&dev->lock); 1575 1576 list_del(&entry->siblings); 1577 1578 kfree(entry->key); 1579 kfree(entry); 1580 } 1581 1582 static struct 1583 configfs_item_operations gpio_virtuser_lookup_entry_config_item_ops = { 1584 .release = gpio_virtuser_lookup_entry_config_group_release, 1585 }; 1586 1587 static const struct 1588 config_item_type gpio_virtuser_lookup_entry_config_group_type = { 1589 .ct_item_ops = &gpio_virtuser_lookup_entry_config_item_ops, 1590 .ct_attrs = gpio_virtuser_lookup_entry_config_attrs, 1591 .ct_owner = THIS_MODULE, 1592 }; 1593 1594 static struct config_group * 1595 gpio_virtuser_make_lookup_entry_group(struct config_group *group, 1596 const char *name) 1597 { 1598 struct gpio_virtuser_lookup *lookup = 1599 to_gpio_virtuser_lookup(&group->cg_item); 1600 struct gpio_virtuser_device *dev = lookup->parent; 1601 1602 guard(mutex)(&dev->lock); 1603 1604 if (gpio_virtuser_device_is_live(dev)) 1605 return ERR_PTR(-EBUSY); 1606 1607 struct gpio_virtuser_lookup_entry *entry __free(kfree) = 1608 kzalloc(sizeof(*entry), GFP_KERNEL); 1609 if (!entry) 1610 return ERR_PTR(-ENOMEM); 1611 1612 config_group_init_type_name(&entry->group, name, 1613 &gpio_virtuser_lookup_entry_config_group_type); 1614 entry->flags = GPIO_LOOKUP_FLAGS_DEFAULT; 1615 entry->parent = lookup; 1616 list_add_tail(&entry->siblings, &lookup->entry_list); 1617 1618 return &no_free_ptr(entry)->group; 1619 } 1620 1621 static void gpio_virtuser_lookup_config_group_release(struct config_item *item) 1622 { 1623 struct gpio_virtuser_lookup *lookup = to_gpio_virtuser_lookup(item); 1624 struct gpio_virtuser_device *dev = lookup->parent; 1625 1626 guard(mutex)(&dev->lock); 1627 1628 list_del(&lookup->siblings); 1629 1630 kfree(lookup->con_id); 1631 kfree(lookup); 1632 } 1633 1634 static struct configfs_item_operations gpio_virtuser_lookup_config_item_ops = { 1635 .release = gpio_virtuser_lookup_config_group_release, 1636 }; 1637 1638 static struct 1639 configfs_group_operations gpio_virtuser_lookup_config_group_ops = { 1640 .make_group = gpio_virtuser_make_lookup_entry_group, 1641 }; 1642 1643 static const struct config_item_type gpio_virtuser_lookup_config_group_type = { 1644 .ct_group_ops = &gpio_virtuser_lookup_config_group_ops, 1645 .ct_item_ops = &gpio_virtuser_lookup_config_item_ops, 1646 .ct_owner = THIS_MODULE, 1647 }; 1648 1649 static struct config_group * 1650 gpio_virtuser_make_lookup_group(struct config_group *group, const char *name) 1651 { 1652 struct gpio_virtuser_device *dev = 1653 to_gpio_virtuser_device(&group->cg_item); 1654 1655 if (strlen(name) > (GPIO_VIRTUSER_NAME_BUF_LEN - 1)) 1656 return ERR_PTR(-E2BIG); 1657 1658 guard(mutex)(&dev->lock); 1659 1660 if (gpio_virtuser_device_is_live(dev)) 1661 return ERR_PTR(-EBUSY); 1662 1663 struct gpio_virtuser_lookup *lookup __free(kfree) = 1664 kzalloc(sizeof(*lookup), GFP_KERNEL); 1665 if (!lookup) 1666 return ERR_PTR(-ENOMEM); 1667 1668 lookup->con_id = kstrdup(name, GFP_KERNEL); 1669 if (!lookup->con_id) 1670 return ERR_PTR(-ENOMEM); 1671 1672 config_group_init_type_name(&lookup->group, name, 1673 &gpio_virtuser_lookup_config_group_type); 1674 INIT_LIST_HEAD(&lookup->entry_list); 1675 lookup->parent = dev; 1676 list_add_tail(&lookup->siblings, &dev->lookup_list); 1677 1678 return &no_free_ptr(lookup)->group; 1679 } 1680 1681 static void gpio_virtuser_device_config_group_release(struct config_item *item) 1682 { 1683 struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item); 1684 1685 guard(mutex)(&dev->lock); 1686 1687 if (gpio_virtuser_device_is_live(dev)) 1688 gpio_virtuser_device_deactivate(dev); 1689 1690 mutex_destroy(&dev->lock); 1691 ida_free(&gpio_virtuser_ida, dev->id); 1692 kfree(dev); 1693 } 1694 1695 static struct configfs_item_operations gpio_virtuser_device_config_item_ops = { 1696 .release = gpio_virtuser_device_config_group_release, 1697 }; 1698 1699 static struct configfs_group_operations gpio_virtuser_device_config_group_ops = { 1700 .make_group = gpio_virtuser_make_lookup_group, 1701 }; 1702 1703 static const struct config_item_type gpio_virtuser_device_config_group_type = { 1704 .ct_group_ops = &gpio_virtuser_device_config_group_ops, 1705 .ct_item_ops = &gpio_virtuser_device_config_item_ops, 1706 .ct_attrs = gpio_virtuser_device_config_attrs, 1707 .ct_owner = THIS_MODULE, 1708 }; 1709 1710 static struct config_group * 1711 gpio_virtuser_config_make_device_group(struct config_group *group, 1712 const char *name) 1713 { 1714 struct gpio_virtuser_device *dev __free(kfree) = kzalloc(sizeof(*dev), 1715 GFP_KERNEL); 1716 if (!dev) 1717 return ERR_PTR(-ENOMEM); 1718 1719 dev->id = ida_alloc(&gpio_virtuser_ida, GFP_KERNEL); 1720 if (dev->id < 0) 1721 return ERR_PTR(dev->id); 1722 1723 config_group_init_type_name(&dev->group, name, 1724 &gpio_virtuser_device_config_group_type); 1725 mutex_init(&dev->lock); 1726 INIT_LIST_HEAD(&dev->lookup_list); 1727 dev_sync_probe_init(&dev->probe_data); 1728 1729 return &no_free_ptr(dev)->group; 1730 } 1731 1732 static struct configfs_group_operations gpio_virtuser_config_group_ops = { 1733 .make_group = gpio_virtuser_config_make_device_group, 1734 }; 1735 1736 static const struct config_item_type gpio_virtuser_config_type = { 1737 .ct_group_ops = &gpio_virtuser_config_group_ops, 1738 .ct_owner = THIS_MODULE, 1739 }; 1740 1741 static struct configfs_subsystem gpio_virtuser_config_subsys = { 1742 .su_group = { 1743 .cg_item = { 1744 .ci_namebuf = "gpio-virtuser", 1745 .ci_type = &gpio_virtuser_config_type, 1746 }, 1747 }, 1748 }; 1749 1750 static int __init gpio_virtuser_init(void) 1751 { 1752 int ret; 1753 1754 ret = platform_driver_register(&gpio_virtuser_driver); 1755 if (ret) { 1756 pr_err("Failed to register the platform driver: %d\n", ret); 1757 return ret; 1758 } 1759 1760 config_group_init(&gpio_virtuser_config_subsys.su_group); 1761 mutex_init(&gpio_virtuser_config_subsys.su_mutex); 1762 ret = configfs_register_subsystem(&gpio_virtuser_config_subsys); 1763 if (ret) { 1764 pr_err("Failed to register the '%s' configfs subsystem: %d\n", 1765 gpio_virtuser_config_subsys.su_group.cg_item.ci_namebuf, 1766 ret); 1767 goto err_plat_drv_unreg; 1768 } 1769 1770 gpio_virtuser_dbg_root = debugfs_create_dir("gpio-virtuser", NULL); 1771 if (IS_ERR(gpio_virtuser_dbg_root)) { 1772 ret = PTR_ERR(gpio_virtuser_dbg_root); 1773 pr_err("Failed to create the debugfs tree: %d\n", ret); 1774 goto err_configfs_unreg; 1775 } 1776 1777 return 0; 1778 1779 err_configfs_unreg: 1780 configfs_unregister_subsystem(&gpio_virtuser_config_subsys); 1781 err_plat_drv_unreg: 1782 mutex_destroy(&gpio_virtuser_config_subsys.su_mutex); 1783 platform_driver_unregister(&gpio_virtuser_driver); 1784 1785 return ret; 1786 } 1787 module_init(gpio_virtuser_init); 1788 1789 static void __exit gpio_virtuser_exit(void) 1790 { 1791 configfs_unregister_subsystem(&gpio_virtuser_config_subsys); 1792 mutex_destroy(&gpio_virtuser_config_subsys.su_mutex); 1793 platform_driver_unregister(&gpio_virtuser_driver); 1794 debugfs_remove_recursive(gpio_virtuser_dbg_root); 1795 } 1796 module_exit(gpio_virtuser_exit); 1797 1798 MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@linaro.org>"); 1799 MODULE_DESCRIPTION("Virtual GPIO consumer module"); 1800 MODULE_LICENSE("GPL"); 1801