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