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 free_irq(irq, ld); 696 } 697 698 return 0; 699 } 700 701 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_interrupts_fops, 702 gpio_virtuser_interrupts_get, 703 gpio_virtuser_interrupts_set, 704 "%llu\n"); 705 706 static const struct gpio_virtuser_dbgfs_attr_descr 707 gpio_virtuser_line_array_dbgfs_attrs[] = { 708 { 709 .name = "values", 710 .fops = &gpio_virtuser_value_array_fops, 711 }, 712 { 713 .name = "values_atomic", 714 .fops = &gpio_virtuser_value_array_atomic_fops, 715 }, 716 }; 717 718 static const struct gpio_virtuser_dbgfs_attr_descr 719 gpio_virtuser_line_dbgfs_attrs[] = { 720 { 721 .name = "direction", 722 .fops = &gpio_virtuser_direction_fops, 723 }, 724 { 725 .name = "direction_atomic", 726 .fops = &gpio_virtuser_direction_atomic_fops, 727 }, 728 { 729 .name = "value", 730 .fops = &gpio_virtuser_value_fops, 731 }, 732 { 733 .name = "value_atomic", 734 .fops = &gpio_virtuser_value_atomic_fops, 735 }, 736 { 737 .name = "debounce", 738 .fops = &gpio_virtuser_debounce_fops, 739 }, 740 { 741 .name = "consumer", 742 .fops = &gpio_virtuser_consumer_fops, 743 }, 744 { 745 .name = "interrupts", 746 .fops = &gpio_virtuser_interrupts_fops, 747 }, 748 }; 749 750 static int gpio_virtuser_create_debugfs_attrs( 751 const struct gpio_virtuser_dbgfs_attr_descr *attr, 752 size_t num_attrs, struct dentry *parent, void *data) 753 { 754 struct dentry *ret; 755 size_t i; 756 757 for (i = 0; i < num_attrs; i++, attr++) { 758 ret = debugfs_create_file(attr->name, 0644, parent, data, 759 attr->fops); 760 if (IS_ERR(ret)) 761 return PTR_ERR(ret); 762 } 763 764 return 0; 765 } 766 767 static int gpio_virtuser_dbgfs_init_line_array_attrs(struct device *dev, 768 struct gpio_descs *descs, 769 const char *id, 770 struct dentry *dbgfs_entry) 771 { 772 struct gpio_virtuser_line_array_data *data; 773 char *name; 774 775 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 776 if (!data) 777 return -ENOMEM; 778 779 data->ad.descs = descs; 780 781 name = devm_kasprintf(dev, GFP_KERNEL, "gpiod:%s", id); 782 if (!name) 783 return -ENOMEM; 784 785 data->ad.dbgfs_dir = debugfs_create_dir(name, dbgfs_entry); 786 if (IS_ERR(data->ad.dbgfs_dir)) 787 return PTR_ERR(data->ad.dbgfs_dir); 788 789 return gpio_virtuser_create_debugfs_attrs( 790 gpio_virtuser_line_array_dbgfs_attrs, 791 ARRAY_SIZE(gpio_virtuser_line_array_dbgfs_attrs), 792 data->ad.dbgfs_dir, data); 793 } 794 795 static int gpio_virtuser_dbgfs_init_line_attrs(struct device *dev, 796 struct gpio_desc *desc, 797 const char *id, 798 unsigned int index, 799 struct dentry *dbgfs_entry) 800 { 801 struct gpio_virtuser_line_data *data; 802 char *name; 803 int ret; 804 805 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 806 if (!data) 807 return -ENOMEM; 808 809 data->ad.desc = desc; 810 strscpy(data->consumer, id); 811 atomic_set(&data->irq, 0); 812 atomic_set(&data->irq_count, 0); 813 814 name = devm_kasprintf(dev, GFP_KERNEL, "gpiod:%s:%u", id, index); 815 if (!name) 816 return -ENOMEM; 817 818 ret = devm_mutex_init(dev, &data->consumer_lock); 819 if (ret) 820 return ret; 821 822 data->ad.dbgfs_dir = debugfs_create_dir(name, dbgfs_entry); 823 if (IS_ERR(data->ad.dbgfs_dir)) 824 return PTR_ERR(data->ad.dbgfs_dir); 825 826 return gpio_virtuser_create_debugfs_attrs( 827 gpio_virtuser_line_dbgfs_attrs, 828 ARRAY_SIZE(gpio_virtuser_line_dbgfs_attrs), 829 data->ad.dbgfs_dir, data); 830 } 831 832 static void gpio_virtuser_debugfs_remove(void *data) 833 { 834 struct dentry *dbgfs_entry = data; 835 836 debugfs_remove_recursive(dbgfs_entry); 837 } 838 839 static int gpio_virtuser_prop_is_gpio(struct property *prop) 840 { 841 char *dash = strrchr(prop->name, '-'); 842 843 return dash && strcmp(dash, "-gpios") == 0; 844 } 845 846 /* 847 * If this is an OF-based system, then we iterate over properties and consider 848 * all whose names end in "-gpios". For configfs we expect an additional string 849 * array property - "gpio-virtuser,ids" - containing the list of all GPIO IDs 850 * to request. 851 */ 852 static int gpio_virtuser_count_ids(struct device *dev) 853 { 854 struct device_node *of_node = dev_of_node(dev); 855 struct property *prop; 856 int ret = 0; 857 858 if (!of_node) 859 return device_property_string_array_count(dev, 860 "gpio-virtuser,ids"); 861 862 for_each_property_of_node(of_node, prop) { 863 if (gpio_virtuser_prop_is_gpio(prop)) 864 ++ret; 865 } 866 867 return ret; 868 } 869 870 static int gpio_virtuser_get_ids(struct device *dev, const char **ids, 871 int num_ids) 872 { 873 struct device_node *of_node = dev_of_node(dev); 874 struct property *prop; 875 size_t pos = 0, diff; 876 char *dash, *tmp; 877 878 if (!of_node) 879 return device_property_read_string_array(dev, 880 "gpio-virtuser,ids", 881 ids, num_ids); 882 883 for_each_property_of_node(of_node, prop) { 884 if (!gpio_virtuser_prop_is_gpio(prop)) 885 continue; 886 887 dash = strrchr(prop->name, '-'); 888 diff = dash - prop->name; 889 890 tmp = devm_kmemdup(dev, prop->name, diff + 1, 891 GFP_KERNEL); 892 if (!tmp) 893 return -ENOMEM; 894 895 tmp[diff] = '\0'; 896 ids[pos++] = tmp; 897 } 898 899 return 0; 900 } 901 902 static int gpio_virtuser_probe(struct platform_device *pdev) 903 { 904 struct device *dev = &pdev->dev; 905 struct dentry *dbgfs_entry; 906 struct gpio_descs *descs; 907 int ret, num_ids = 0, i; 908 const char **ids; 909 unsigned int j; 910 911 num_ids = gpio_virtuser_count_ids(dev); 912 if (num_ids < 0) 913 return dev_err_probe(dev, num_ids, 914 "Failed to get the number of GPIOs to request\n"); 915 916 if (num_ids == 0) 917 return dev_err_probe(dev, -EINVAL, "No GPIO IDs specified\n"); 918 919 ids = devm_kcalloc(dev, num_ids, sizeof(*ids), GFP_KERNEL); 920 if (!ids) 921 return -ENOMEM; 922 923 ret = gpio_virtuser_get_ids(dev, ids, num_ids); 924 if (ret < 0) 925 return dev_err_probe(dev, ret, 926 "Failed to get the IDs of GPIOs to request\n"); 927 928 dbgfs_entry = debugfs_create_dir(dev_name(dev), gpio_virtuser_dbg_root); 929 ret = devm_add_action_or_reset(dev, gpio_virtuser_debugfs_remove, 930 dbgfs_entry); 931 if (ret) 932 return ret; 933 934 for (i = 0; i < num_ids; i++) { 935 descs = devm_gpiod_get_array(dev, ids[i], GPIOD_ASIS); 936 if (IS_ERR(descs)) 937 return dev_err_probe(dev, PTR_ERR(descs), 938 "Failed to request the '%s' GPIOs\n", 939 ids[i]); 940 941 ret = gpio_virtuser_dbgfs_init_line_array_attrs(dev, descs, 942 ids[i], 943 dbgfs_entry); 944 if (ret) 945 return dev_err_probe(dev, ret, 946 "Failed to setup the debugfs array interface for the '%s' GPIOs\n", 947 ids[i]); 948 949 for (j = 0; j < descs->ndescs; j++) { 950 ret = gpio_virtuser_dbgfs_init_line_attrs(dev, 951 descs->desc[j], ids[i], 952 j, dbgfs_entry); 953 if (ret) 954 return dev_err_probe(dev, ret, 955 "Failed to setup the debugfs line interface for the '%s' GPIOs\n", 956 ids[i]); 957 } 958 } 959 960 return 0; 961 } 962 963 static const struct of_device_id gpio_virtuser_of_match[] = { 964 { .compatible = "gpio-virtuser" }, 965 { } 966 }; 967 MODULE_DEVICE_TABLE(of, gpio_virtuser_of_match); 968 969 static struct platform_driver gpio_virtuser_driver = { 970 .driver = { 971 .name = "gpio-virtuser", 972 .of_match_table = gpio_virtuser_of_match, 973 }, 974 .probe = gpio_virtuser_probe, 975 }; 976 977 struct gpio_virtuser_device { 978 struct platform_device *pdev; 979 struct config_group group; 980 981 int id; 982 struct mutex lock; 983 984 struct gpiod_lookup_table *lookup_table; 985 986 struct list_head lookup_list; 987 }; 988 989 static struct gpio_virtuser_device * 990 to_gpio_virtuser_device(struct config_item *item) 991 { 992 struct config_group *group = to_config_group(item); 993 994 return container_of(group, struct gpio_virtuser_device, group); 995 } 996 997 static bool 998 gpio_virtuser_device_is_live(struct gpio_virtuser_device *dev) 999 { 1000 lockdep_assert_held(&dev->lock); 1001 1002 return !!dev->pdev; 1003 } 1004 1005 struct gpio_virtuser_lookup { 1006 struct config_group group; 1007 1008 struct gpio_virtuser_device *parent; 1009 struct list_head siblings; 1010 1011 char *con_id; 1012 1013 struct list_head entry_list; 1014 }; 1015 1016 static struct gpio_virtuser_lookup * 1017 to_gpio_virtuser_lookup(struct config_item *item) 1018 { 1019 struct config_group *group = to_config_group(item); 1020 1021 return container_of(group, struct gpio_virtuser_lookup, group); 1022 } 1023 1024 struct gpio_virtuser_lookup_entry { 1025 struct config_group group; 1026 1027 struct gpio_virtuser_lookup *parent; 1028 struct list_head siblings; 1029 1030 char *key; 1031 /* Can be negative to indicate lookup by name. */ 1032 int offset; 1033 enum gpio_lookup_flags flags; 1034 }; 1035 1036 static struct gpio_virtuser_lookup_entry * 1037 to_gpio_virtuser_lookup_entry(struct config_item *item) 1038 { 1039 struct config_group *group = to_config_group(item); 1040 1041 return container_of(group, struct gpio_virtuser_lookup_entry, group); 1042 } 1043 1044 static ssize_t 1045 gpio_virtuser_lookup_entry_config_key_show(struct config_item *item, char *page) 1046 { 1047 struct gpio_virtuser_lookup_entry *entry = 1048 to_gpio_virtuser_lookup_entry(item); 1049 struct gpio_virtuser_device *dev = entry->parent->parent; 1050 1051 guard(mutex)(&dev->lock); 1052 1053 return sprintf(page, "%s\n", entry->key ?: ""); 1054 } 1055 1056 static ssize_t 1057 gpio_virtuser_lookup_entry_config_key_store(struct config_item *item, 1058 const char *page, size_t count) 1059 { 1060 struct gpio_virtuser_lookup_entry *entry = 1061 to_gpio_virtuser_lookup_entry(item); 1062 struct gpio_virtuser_device *dev = entry->parent->parent; 1063 1064 char *key __free(kfree) = kstrndup(skip_spaces(page), count, 1065 GFP_KERNEL); 1066 if (!key) 1067 return -ENOMEM; 1068 1069 strim(key); 1070 1071 guard(mutex)(&dev->lock); 1072 1073 if (gpio_virtuser_device_is_live(dev)) 1074 return -EBUSY; 1075 1076 kfree(entry->key); 1077 entry->key = no_free_ptr(key); 1078 1079 return count; 1080 } 1081 1082 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, key); 1083 1084 static ssize_t 1085 gpio_virtuser_lookup_entry_config_offset_show(struct config_item *item, 1086 char *page) 1087 { 1088 struct gpio_virtuser_lookup_entry *entry = 1089 to_gpio_virtuser_lookup_entry(item); 1090 struct gpio_virtuser_device *dev = entry->parent->parent; 1091 unsigned int offset; 1092 1093 scoped_guard(mutex, &dev->lock) 1094 offset = entry->offset; 1095 1096 return sprintf(page, "%d\n", offset); 1097 } 1098 1099 static ssize_t 1100 gpio_virtuser_lookup_entry_config_offset_store(struct config_item *item, 1101 const char *page, size_t count) 1102 { 1103 struct gpio_virtuser_lookup_entry *entry = 1104 to_gpio_virtuser_lookup_entry(item); 1105 struct gpio_virtuser_device *dev = entry->parent->parent; 1106 int offset, ret; 1107 1108 ret = kstrtoint(page, 0, &offset); 1109 if (ret) 1110 return ret; 1111 1112 /* 1113 * Negative number here means: 'key' represents a line name to lookup. 1114 * Non-negative means: 'key' represents the label of the chip with 1115 * the 'offset' value representing the line within that chip. 1116 * 1117 * GPIOLIB uses the U16_MAX value to indicate lookup by line name so 1118 * the greatest offset we can accept is (U16_MAX - 1). 1119 */ 1120 if (offset > (U16_MAX - 1)) 1121 return -EINVAL; 1122 1123 guard(mutex)(&dev->lock); 1124 1125 if (gpio_virtuser_device_is_live(dev)) 1126 return -EBUSY; 1127 1128 entry->offset = offset; 1129 1130 return count; 1131 } 1132 1133 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, offset); 1134 1135 static enum gpio_lookup_flags 1136 gpio_virtuser_lookup_get_flags(struct config_item *item) 1137 { 1138 struct gpio_virtuser_lookup_entry *entry = 1139 to_gpio_virtuser_lookup_entry(item); 1140 struct gpio_virtuser_device *dev = entry->parent->parent; 1141 1142 guard(mutex)(&dev->lock); 1143 1144 return entry->flags; 1145 } 1146 1147 static ssize_t 1148 gpio_virtuser_lookup_entry_config_drive_show(struct config_item *item, char *page) 1149 { 1150 enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item); 1151 const char *repr; 1152 1153 if (flags & GPIO_OPEN_DRAIN) 1154 repr = "open-drain"; 1155 else if (flags & GPIO_OPEN_SOURCE) 1156 repr = "open-source"; 1157 else 1158 repr = "push-pull"; 1159 1160 return sprintf(page, "%s\n", repr); 1161 } 1162 1163 static ssize_t 1164 gpio_virtuser_lookup_entry_config_drive_store(struct config_item *item, 1165 const char *page, size_t count) 1166 { 1167 struct gpio_virtuser_lookup_entry *entry = 1168 to_gpio_virtuser_lookup_entry(item); 1169 struct gpio_virtuser_device *dev = entry->parent->parent; 1170 1171 guard(mutex)(&dev->lock); 1172 1173 if (gpio_virtuser_device_is_live(dev)) 1174 return -EBUSY; 1175 1176 if (sysfs_streq(page, "push-pull")) { 1177 entry->flags &= ~(GPIO_OPEN_DRAIN | GPIO_OPEN_SOURCE); 1178 } else if (sysfs_streq(page, "open-drain")) { 1179 entry->flags &= ~GPIO_OPEN_SOURCE; 1180 entry->flags |= GPIO_OPEN_DRAIN; 1181 } else if (sysfs_streq(page, "open-source")) { 1182 entry->flags &= ~GPIO_OPEN_DRAIN; 1183 entry->flags |= GPIO_OPEN_SOURCE; 1184 } else { 1185 count = -EINVAL; 1186 } 1187 1188 return count; 1189 } 1190 1191 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, drive); 1192 1193 static ssize_t 1194 gpio_virtuser_lookup_entry_config_pull_show(struct config_item *item, char *page) 1195 { 1196 enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item); 1197 const char *repr; 1198 1199 if (flags & GPIO_PULL_UP) 1200 repr = "pull-up"; 1201 else if (flags & GPIO_PULL_DOWN) 1202 repr = "pull-down"; 1203 else if (flags & GPIO_PULL_DISABLE) 1204 repr = "pull-disabled"; 1205 else 1206 repr = "as-is"; 1207 1208 return sprintf(page, "%s\n", repr); 1209 } 1210 1211 static ssize_t 1212 gpio_virtuser_lookup_entry_config_pull_store(struct config_item *item, 1213 const char *page, size_t count) 1214 { 1215 struct gpio_virtuser_lookup_entry *entry = 1216 to_gpio_virtuser_lookup_entry(item); 1217 struct gpio_virtuser_device *dev = entry->parent->parent; 1218 1219 guard(mutex)(&dev->lock); 1220 1221 if (gpio_virtuser_device_is_live(dev)) 1222 return -EBUSY; 1223 1224 if (sysfs_streq(page, "pull-up")) { 1225 entry->flags &= ~(GPIO_PULL_DOWN | GPIO_PULL_DISABLE); 1226 entry->flags |= GPIO_PULL_UP; 1227 } else if (sysfs_streq(page, "pull-down")) { 1228 entry->flags &= ~(GPIO_PULL_UP | GPIO_PULL_DISABLE); 1229 entry->flags |= GPIO_PULL_DOWN; 1230 } else if (sysfs_streq(page, "pull-disabled")) { 1231 entry->flags &= ~(GPIO_PULL_UP | GPIO_PULL_DOWN); 1232 entry->flags |= GPIO_PULL_DISABLE; 1233 } else if (sysfs_streq(page, "as-is")) { 1234 entry->flags &= ~(GPIO_PULL_UP | GPIO_PULL_DOWN | 1235 GPIO_PULL_DISABLE); 1236 } else { 1237 count = -EINVAL; 1238 } 1239 1240 return count; 1241 } 1242 1243 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, pull); 1244 1245 static ssize_t 1246 gpio_virtuser_lookup_entry_config_active_low_show(struct config_item *item, 1247 char *page) 1248 { 1249 enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item); 1250 1251 return sprintf(page, "%c\n", flags & GPIO_ACTIVE_LOW ? '1' : '0'); 1252 } 1253 1254 static ssize_t 1255 gpio_virtuser_lookup_entry_config_active_low_store(struct config_item *item, 1256 const char *page, 1257 size_t count) 1258 { 1259 struct gpio_virtuser_lookup_entry *entry = 1260 to_gpio_virtuser_lookup_entry(item); 1261 struct gpio_virtuser_device *dev = entry->parent->parent; 1262 bool active_low; 1263 int ret; 1264 1265 ret = kstrtobool(page, &active_low); 1266 if (ret) 1267 return ret; 1268 1269 guard(mutex)(&dev->lock); 1270 1271 if (gpio_virtuser_device_is_live(dev)) 1272 return -EBUSY; 1273 1274 if (active_low) 1275 entry->flags |= GPIO_ACTIVE_LOW; 1276 else 1277 entry->flags &= ~GPIO_ACTIVE_LOW; 1278 1279 return count; 1280 } 1281 1282 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, active_low); 1283 1284 static ssize_t 1285 gpio_virtuser_lookup_entry_config_transitory_show(struct config_item *item, 1286 char *page) 1287 { 1288 enum gpio_lookup_flags flags = gpio_virtuser_lookup_get_flags(item); 1289 1290 return sprintf(page, "%c\n", flags & GPIO_TRANSITORY ? '1' : '0'); 1291 } 1292 1293 static ssize_t 1294 gpio_virtuser_lookup_entry_config_transitory_store(struct config_item *item, 1295 const char *page, 1296 size_t count) 1297 { 1298 struct gpio_virtuser_lookup_entry *entry = 1299 to_gpio_virtuser_lookup_entry(item); 1300 struct gpio_virtuser_device *dev = entry->parent->parent; 1301 bool transitory; 1302 int ret; 1303 1304 ret = kstrtobool(page, &transitory); 1305 if (ret) 1306 return ret; 1307 1308 guard(mutex)(&dev->lock); 1309 1310 if (gpio_virtuser_device_is_live(dev)) 1311 return -EBUSY; 1312 1313 if (transitory) 1314 entry->flags |= GPIO_TRANSITORY; 1315 else 1316 entry->flags &= ~GPIO_TRANSITORY; 1317 1318 return count; 1319 } 1320 1321 CONFIGFS_ATTR(gpio_virtuser_lookup_entry_config_, transitory); 1322 1323 static struct configfs_attribute *gpio_virtuser_lookup_entry_config_attrs[] = { 1324 &gpio_virtuser_lookup_entry_config_attr_key, 1325 &gpio_virtuser_lookup_entry_config_attr_offset, 1326 &gpio_virtuser_lookup_entry_config_attr_drive, 1327 &gpio_virtuser_lookup_entry_config_attr_pull, 1328 &gpio_virtuser_lookup_entry_config_attr_active_low, 1329 &gpio_virtuser_lookup_entry_config_attr_transitory, 1330 NULL 1331 }; 1332 1333 static ssize_t 1334 gpio_virtuser_device_config_dev_name_show(struct config_item *item, 1335 char *page) 1336 { 1337 struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item); 1338 struct platform_device *pdev; 1339 1340 guard(mutex)(&dev->lock); 1341 1342 pdev = dev->pdev; 1343 if (pdev) 1344 return sprintf(page, "%s\n", dev_name(&pdev->dev)); 1345 1346 return sprintf(page, "gpio-sim.%d\n", dev->id); 1347 } 1348 1349 CONFIGFS_ATTR_RO(gpio_virtuser_device_config_, dev_name); 1350 1351 static ssize_t gpio_virtuser_device_config_live_show(struct config_item *item, 1352 char *page) 1353 { 1354 struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item); 1355 bool live; 1356 1357 scoped_guard(mutex, &dev->lock) 1358 live = gpio_virtuser_device_is_live(dev); 1359 1360 return sprintf(page, "%c\n", live ? '1' : '0'); 1361 } 1362 1363 static size_t 1364 gpio_virtuser_get_lookup_count(struct gpio_virtuser_device *dev) 1365 { 1366 struct gpio_virtuser_lookup *lookup; 1367 size_t count = 0; 1368 1369 lockdep_assert_held(&dev->lock); 1370 1371 list_for_each_entry(lookup, &dev->lookup_list, siblings) 1372 count += list_count_nodes(&lookup->entry_list); 1373 1374 return count; 1375 } 1376 1377 static int 1378 gpio_virtuser_make_lookup_table(struct gpio_virtuser_device *dev) 1379 { 1380 size_t num_entries = gpio_virtuser_get_lookup_count(dev); 1381 struct gpio_virtuser_lookup_entry *entry; 1382 struct gpio_virtuser_lookup *lookup; 1383 unsigned int i = 0, idx; 1384 1385 lockdep_assert_held(&dev->lock); 1386 1387 struct gpiod_lookup_table *table __free(kfree) = 1388 kzalloc_flex(*table, table, num_entries + 1); 1389 if (!table) 1390 return -ENOMEM; 1391 1392 table->dev_id = kasprintf(GFP_KERNEL, "gpio-virtuser.%d", dev->id); 1393 if (!table->dev_id) 1394 return -ENOMEM; 1395 1396 list_for_each_entry(lookup, &dev->lookup_list, siblings) { 1397 idx = 0; 1398 list_for_each_entry(entry, &lookup->entry_list, siblings) { 1399 table->table[i++] = 1400 GPIO_LOOKUP_IDX(entry->key, 1401 entry->offset < 0 ? U16_MAX : entry->offset, 1402 lookup->con_id, idx++, entry->flags); 1403 } 1404 } 1405 1406 gpiod_add_lookup_table(table); 1407 dev->lookup_table = no_free_ptr(table); 1408 1409 return 0; 1410 } 1411 1412 static void 1413 gpio_virtuser_remove_lookup_table(struct gpio_virtuser_device *dev) 1414 { 1415 gpiod_remove_lookup_table(dev->lookup_table); 1416 kfree(dev->lookup_table->dev_id); 1417 kfree(dev->lookup_table); 1418 dev->lookup_table = NULL; 1419 } 1420 1421 static struct fwnode_handle * 1422 gpio_virtuser_make_device_swnode(struct gpio_virtuser_device *dev) 1423 { 1424 struct property_entry properties[2]; 1425 struct gpio_virtuser_lookup *lookup; 1426 unsigned int i = 0; 1427 size_t num_ids; 1428 1429 memset(properties, 0, sizeof(properties)); 1430 1431 num_ids = list_count_nodes(&dev->lookup_list); 1432 char **ids __free(kfree) = kcalloc(num_ids + 1, sizeof(*ids), 1433 GFP_KERNEL); 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