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