1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Configurable virtual GPIO consumer module. 4 * 5 * Copyright (C) 2023-2024 Bartosz Golaszewski <bartosz.golaszewski@linaro.org> 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 9 10 #include <linux/array_size.h> 11 #include <linux/atomic.h> 12 #include <linux/bitmap.h> 13 #include <linux/cleanup.h> 14 #include <linux/configfs.h> 15 #include <linux/debugfs.h> 16 #include <linux/device.h> 17 #include <linux/err.h> 18 #include <linux/gpio/consumer.h> 19 #include <linux/gpio/machine.h> 20 #include <linux/idr.h> 21 #include <linux/interrupt.h> 22 #include <linux/irq_work.h> 23 #include <linux/limits.h> 24 #include <linux/list.h> 25 #include <linux/lockdep.h> 26 #include <linux/mod_devicetable.h> 27 #include <linux/module.h> 28 #include <linux/mutex.h> 29 #include <linux/notifier.h> 30 #include <linux/of.h> 31 #include <linux/overflow.h> 32 #include <linux/platform_device.h> 33 #include <linux/printk.h> 34 #include <linux/property.h> 35 #include <linux/slab.h> 36 #include <linux/string_helpers.h> 37 #include <linux/types.h> 38 39 #define GPIO_VIRTUSER_NAME_BUF_LEN 32 40 41 static DEFINE_IDA(gpio_virtuser_ida); 42 static struct dentry *gpio_virtuser_dbg_root; 43 44 struct gpio_virtuser_attr_data { 45 union { 46 struct gpio_desc *desc; 47 struct gpio_descs *descs; 48 }; 49 struct dentry *dbgfs_dir; 50 }; 51 52 struct gpio_virtuser_line_array_data { 53 struct gpio_virtuser_attr_data ad; 54 }; 55 56 struct gpio_virtuser_line_data { 57 struct gpio_virtuser_attr_data ad; 58 char consumer[GPIO_VIRTUSER_NAME_BUF_LEN]; 59 struct mutex consumer_lock; 60 unsigned int debounce; 61 atomic_t irq; 62 atomic_t irq_count; 63 }; 64 65 struct gpio_virtuser_dbgfs_attr_descr { 66 const char *name; 67 const struct file_operations *fops; 68 }; 69 70 struct gpio_virtuser_irq_work_context { 71 struct irq_work work; 72 struct completion work_completion; 73 union { 74 struct { 75 struct gpio_desc *desc; 76 int dir; 77 int val; 78 int ret; 79 }; 80 struct { 81 struct gpio_descs *descs; 82 unsigned long *values; 83 }; 84 }; 85 }; 86 87 static struct gpio_virtuser_irq_work_context * 88 to_gpio_virtuser_irq_work_context(struct irq_work *work) 89 { 90 return container_of(work, struct gpio_virtuser_irq_work_context, work); 91 } 92 93 static void 94 gpio_virtuser_init_irq_work_context(struct gpio_virtuser_irq_work_context *ctx) 95 { 96 memset(ctx, 0, sizeof(*ctx)); 97 init_completion(&ctx->work_completion); 98 } 99 100 static void 101 gpio_virtuser_irq_work_queue_sync(struct gpio_virtuser_irq_work_context *ctx) 102 { 103 irq_work_queue(&ctx->work); 104 wait_for_completion(&ctx->work_completion); 105 } 106 107 static void gpio_virtuser_dbgfs_emit_value_array(char *buf, 108 unsigned long *values, 109 size_t num_values) 110 { 111 size_t i; 112 113 for (i = 0; i < num_values; i++) 114 buf[i] = test_bit(i, values) ? '1' : '0'; 115 116 buf[i++] = '\n'; 117 } 118 119 static void gpio_virtuser_get_value_array_atomic(struct irq_work *work) 120 { 121 struct gpio_virtuser_irq_work_context *ctx = 122 to_gpio_virtuser_irq_work_context(work); 123 struct gpio_descs *descs = ctx->descs; 124 125 ctx->ret = gpiod_get_array_value(descs->ndescs, descs->desc, 126 descs->info, ctx->values); 127 complete(&ctx->work_completion); 128 } 129 130 static int gpio_virtuser_get_array_value(struct gpio_descs *descs, 131 unsigned long *values, bool atomic) 132 { 133 struct gpio_virtuser_irq_work_context ctx; 134 135 if (!atomic) 136 return gpiod_get_array_value_cansleep(descs->ndescs, 137 descs->desc, 138 descs->info, values); 139 140 gpio_virtuser_init_irq_work_context(&ctx); 141 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_get_value_array_atomic); 142 ctx.descs = descs; 143 ctx.values = values; 144 145 gpio_virtuser_irq_work_queue_sync(&ctx); 146 147 return ctx.ret; 148 } 149 150 static ssize_t gpio_virtuser_value_array_do_read(struct file *file, 151 char __user *user_buf, 152 size_t size, loff_t *ppos, 153 bool atomic) 154 { 155 struct gpio_virtuser_line_data *data = file->private_data; 156 struct gpio_descs *descs = data->ad.descs; 157 size_t bufsize; 158 int ret; 159 160 unsigned long *values __free(bitmap) = bitmap_zalloc(descs->ndescs, 161 GFP_KERNEL); 162 if (!values) 163 return -ENOMEM; 164 165 ret = gpio_virtuser_get_array_value(descs, values, atomic); 166 if (ret) 167 return ret; 168 169 bufsize = descs->ndescs + 2; 170 171 char *buf __free(kfree) = kzalloc(bufsize, GFP_KERNEL); 172 if (!buf) 173 return -ENOMEM; 174 175 gpio_virtuser_dbgfs_emit_value_array(buf, values, descs->ndescs); 176 177 return simple_read_from_buffer(user_buf, size, ppos, buf, 178 descs->ndescs + 1); 179 } 180 181 static int gpio_virtuser_dbgfs_parse_value_array(const char *buf, 182 size_t len, 183 unsigned long *values) 184 { 185 size_t i; 186 187 for (i = 0; i < len; i++) { 188 if (buf[i] == '0') 189 clear_bit(i, values); 190 else if (buf[i] == '1') 191 set_bit(i, values); 192 else 193 return -EINVAL; 194 } 195 196 return 0; 197 } 198 199 static void gpio_virtuser_set_value_array_atomic(struct irq_work *work) 200 { 201 struct gpio_virtuser_irq_work_context *ctx = 202 to_gpio_virtuser_irq_work_context(work); 203 struct gpio_descs *descs = ctx->descs; 204 205 ctx->ret = gpiod_set_array_value(descs->ndescs, descs->desc, 206 descs->info, ctx->values); 207 complete(&ctx->work_completion); 208 } 209 210 static int gpio_virtuser_set_array_value(struct gpio_descs *descs, 211 unsigned long *values, bool atomic) 212 { 213 struct gpio_virtuser_irq_work_context ctx; 214 215 if (!atomic) 216 return gpiod_multi_set_value_cansleep(descs, values); 217 218 gpio_virtuser_init_irq_work_context(&ctx); 219 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_set_value_array_atomic); 220 ctx.descs = descs; 221 ctx.values = values; 222 223 gpio_virtuser_irq_work_queue_sync(&ctx); 224 225 return ctx.ret; 226 } 227 228 static ssize_t gpio_virtuser_value_array_do_write(struct file *file, 229 const char __user *user_buf, 230 size_t count, loff_t *ppos, 231 bool atomic) 232 { 233 struct gpio_virtuser_line_data *data = file->private_data; 234 struct gpio_descs *descs = data->ad.descs; 235 int ret; 236 237 if (count - 1 != descs->ndescs) 238 return -EINVAL; 239 240 char *buf __free(kfree) = kzalloc(count, GFP_KERNEL); 241 if (!buf) 242 return -ENOMEM; 243 244 ret = simple_write_to_buffer(buf, count, ppos, user_buf, count); 245 if (ret < 0) 246 return ret; 247 248 unsigned long *values __free(bitmap) = bitmap_zalloc(descs->ndescs, 249 GFP_KERNEL); 250 if (!values) 251 return -ENOMEM; 252 253 ret = gpio_virtuser_dbgfs_parse_value_array(buf, count - 1, values); 254 if (ret) 255 return ret; 256 257 ret = gpio_virtuser_set_array_value(descs, values, atomic); 258 if (ret) 259 return ret; 260 261 return count; 262 } 263 264 static ssize_t gpio_virtuser_value_array_read(struct file *file, 265 char __user *user_buf, 266 size_t count, loff_t *ppos) 267 { 268 return gpio_virtuser_value_array_do_read(file, user_buf, count, ppos, 269 false); 270 } 271 272 static ssize_t gpio_virtuser_value_array_write(struct file *file, 273 const char __user *user_buf, 274 size_t count, loff_t *ppos) 275 { 276 return gpio_virtuser_value_array_do_write(file, user_buf, count, ppos, 277 false); 278 } 279 280 static const struct file_operations gpio_virtuser_value_array_fops = { 281 .read = gpio_virtuser_value_array_read, 282 .write = gpio_virtuser_value_array_write, 283 .open = simple_open, 284 .owner = THIS_MODULE, 285 .llseek = default_llseek, 286 }; 287 288 static ssize_t 289 gpio_virtuser_value_array_atomic_read(struct file *file, char __user *user_buf, 290 size_t count, loff_t *ppos) 291 { 292 return gpio_virtuser_value_array_do_read(file, user_buf, count, ppos, 293 true); 294 } 295 296 static ssize_t 297 gpio_virtuser_value_array_atomic_write(struct file *file, 298 const char __user *user_buf, 299 size_t count, loff_t *ppos) 300 { 301 return gpio_virtuser_value_array_do_write(file, user_buf, count, ppos, 302 true); 303 } 304 305 static const struct file_operations gpio_virtuser_value_array_atomic_fops = { 306 .read = gpio_virtuser_value_array_atomic_read, 307 .write = gpio_virtuser_value_array_atomic_write, 308 .open = simple_open, 309 .owner = THIS_MODULE, 310 .llseek = default_llseek, 311 }; 312 313 static void gpio_virtuser_do_get_direction_atomic(struct irq_work *work) 314 { 315 struct gpio_virtuser_irq_work_context *ctx = 316 to_gpio_virtuser_irq_work_context(work); 317 318 ctx->ret = gpiod_get_direction(ctx->desc); 319 complete(&ctx->work_completion); 320 } 321 322 static int gpio_virtuser_get_direction_atomic(struct gpio_desc *desc) 323 { 324 struct gpio_virtuser_irq_work_context ctx; 325 326 gpio_virtuser_init_irq_work_context(&ctx); 327 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_do_get_direction_atomic); 328 ctx.desc = desc; 329 330 gpio_virtuser_irq_work_queue_sync(&ctx); 331 332 return ctx.ret; 333 } 334 335 static ssize_t gpio_virtuser_direction_do_read(struct file *file, 336 char __user *user_buf, 337 size_t size, loff_t *ppos, 338 bool atomic) 339 { 340 struct gpio_virtuser_line_data *data = file->private_data; 341 struct gpio_desc *desc = data->ad.desc; 342 char buf[32]; 343 int dir; 344 345 if (!atomic) 346 dir = gpiod_get_direction(desc); 347 else 348 dir = gpio_virtuser_get_direction_atomic(desc); 349 if (dir < 0) 350 return dir; 351 352 snprintf(buf, sizeof(buf), "%s\n", dir ? "input" : "output"); 353 354 return simple_read_from_buffer(user_buf, size, ppos, buf, strlen(buf)); 355 } 356 357 static int gpio_virtuser_set_direction(struct gpio_desc *desc, int dir, int val) 358 { 359 if (dir) 360 return gpiod_direction_input(desc); 361 362 return gpiod_direction_output(desc, val); 363 } 364 365 static void gpio_virtuser_do_set_direction_atomic(struct irq_work *work) 366 { 367 struct gpio_virtuser_irq_work_context *ctx = 368 to_gpio_virtuser_irq_work_context(work); 369 370 ctx->ret = gpio_virtuser_set_direction(ctx->desc, ctx->dir, ctx->val); 371 complete(&ctx->work_completion); 372 } 373 374 static int gpio_virtuser_set_direction_atomic(struct gpio_desc *desc, 375 int dir, int val) 376 { 377 struct gpio_virtuser_irq_work_context ctx; 378 379 gpio_virtuser_init_irq_work_context(&ctx); 380 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_do_set_direction_atomic); 381 ctx.desc = desc; 382 ctx.dir = dir; 383 ctx.val = val; 384 385 gpio_virtuser_irq_work_queue_sync(&ctx); 386 387 return ctx.ret; 388 } 389 390 static ssize_t gpio_virtuser_direction_do_write(struct file *file, 391 const char __user *user_buf, 392 size_t count, loff_t *ppos, 393 bool atomic) 394 { 395 struct gpio_virtuser_line_data *data = file->private_data; 396 struct gpio_desc *desc = data->ad.desc; 397 char buf[32], *trimmed; 398 int ret, dir, val = 0; 399 400 if (count >= sizeof(buf)) 401 return -EINVAL; 402 403 ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, user_buf, count); 404 if (ret < 0) 405 return ret; 406 407 buf[ret] = '\0'; 408 409 trimmed = strim(buf); 410 411 if (strcmp(trimmed, "input") == 0) { 412 dir = 1; 413 } else if (strcmp(trimmed, "output-high") == 0) { 414 dir = 0; 415 val = 1; 416 } else if (strcmp(trimmed, "output-low") == 0) { 417 dir = val = 0; 418 } else { 419 return -EINVAL; 420 } 421 422 if (!atomic) 423 ret = gpio_virtuser_set_direction(desc, dir, val); 424 else 425 ret = gpio_virtuser_set_direction_atomic(desc, dir, val); 426 if (ret) 427 return ret; 428 429 return count; 430 } 431 432 static ssize_t gpio_virtuser_direction_read(struct file *file, 433 char __user *user_buf, 434 size_t size, loff_t *ppos) 435 { 436 return gpio_virtuser_direction_do_read(file, user_buf, size, ppos, 437 false); 438 } 439 440 static ssize_t gpio_virtuser_direction_write(struct file *file, 441 const char __user *user_buf, 442 size_t count, loff_t *ppos) 443 { 444 return gpio_virtuser_direction_do_write(file, user_buf, count, ppos, 445 false); 446 } 447 448 static const struct file_operations gpio_virtuser_direction_fops = { 449 .read = gpio_virtuser_direction_read, 450 .write = gpio_virtuser_direction_write, 451 .open = simple_open, 452 .owner = THIS_MODULE, 453 .llseek = default_llseek, 454 }; 455 456 static ssize_t gpio_virtuser_direction_atomic_read(struct file *file, 457 char __user *user_buf, 458 size_t size, loff_t *ppos) 459 { 460 return gpio_virtuser_direction_do_read(file, user_buf, size, ppos, 461 true); 462 } 463 464 static ssize_t gpio_virtuser_direction_atomic_write(struct file *file, 465 const char __user *user_buf, 466 size_t count, loff_t *ppos) 467 { 468 return gpio_virtuser_direction_do_write(file, user_buf, count, ppos, 469 true); 470 } 471 472 static const struct file_operations gpio_virtuser_direction_atomic_fops = { 473 .read = gpio_virtuser_direction_atomic_read, 474 .write = gpio_virtuser_direction_atomic_write, 475 .open = simple_open, 476 .owner = THIS_MODULE, 477 .llseek = default_llseek, 478 }; 479 480 static int gpio_virtuser_value_get(void *data, u64 *val) 481 { 482 struct gpio_virtuser_line_data *ld = data; 483 int ret; 484 485 ret = gpiod_get_value_cansleep(ld->ad.desc); 486 if (ret < 0) 487 return ret; 488 489 *val = ret; 490 491 return 0; 492 } 493 494 static int gpio_virtuser_value_set(void *data, u64 val) 495 { 496 struct gpio_virtuser_line_data *ld = data; 497 498 if (val > 1) 499 return -EINVAL; 500 501 return gpiod_set_value_cansleep(ld->ad.desc, (int)val); 502 } 503 504 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_value_fops, 505 gpio_virtuser_value_get, 506 gpio_virtuser_value_set, 507 "%llu\n"); 508 509 static void gpio_virtuser_get_value_atomic(struct irq_work *work) 510 { 511 struct gpio_virtuser_irq_work_context *ctx = 512 to_gpio_virtuser_irq_work_context(work); 513 514 ctx->val = gpiod_get_value(ctx->desc); 515 complete(&ctx->work_completion); 516 } 517 518 static int gpio_virtuser_value_atomic_get(void *data, u64 *val) 519 { 520 struct gpio_virtuser_line_data *ld = data; 521 struct gpio_virtuser_irq_work_context ctx; 522 523 gpio_virtuser_init_irq_work_context(&ctx); 524 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_get_value_atomic); 525 ctx.desc = ld->ad.desc; 526 527 gpio_virtuser_irq_work_queue_sync(&ctx); 528 529 if (ctx.val < 0) 530 return ctx.val; 531 532 *val = ctx.val; 533 534 return 0; 535 } 536 537 static void gpio_virtuser_set_value_atomic(struct irq_work *work) 538 { 539 struct gpio_virtuser_irq_work_context *ctx = 540 to_gpio_virtuser_irq_work_context(work); 541 542 ctx->ret = gpiod_set_value(ctx->desc, ctx->val); 543 complete(&ctx->work_completion); 544 } 545 546 static int gpio_virtuser_value_atomic_set(void *data, u64 val) 547 { 548 struct gpio_virtuser_line_data *ld = data; 549 struct gpio_virtuser_irq_work_context ctx; 550 551 if (val > 1) 552 return -EINVAL; 553 554 gpio_virtuser_init_irq_work_context(&ctx); 555 ctx.work = IRQ_WORK_INIT_HARD(gpio_virtuser_set_value_atomic); 556 ctx.desc = ld->ad.desc; 557 ctx.val = (int)val; 558 559 gpio_virtuser_irq_work_queue_sync(&ctx); 560 561 return ctx.ret; 562 } 563 564 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_value_atomic_fops, 565 gpio_virtuser_value_atomic_get, 566 gpio_virtuser_value_atomic_set, 567 "%llu\n"); 568 569 static int gpio_virtuser_debounce_get(void *data, u64 *val) 570 { 571 struct gpio_virtuser_line_data *ld = data; 572 573 *val = READ_ONCE(ld->debounce); 574 575 return 0; 576 } 577 578 static int gpio_virtuser_debounce_set(void *data, u64 val) 579 { 580 struct gpio_virtuser_line_data *ld = data; 581 int ret; 582 583 if (val > UINT_MAX) 584 return -E2BIG; 585 586 ret = gpiod_set_debounce(ld->ad.desc, (unsigned int)val); 587 if (ret) 588 /* Don't propagate errno unknown to user-space. */ 589 return ret == -ENOTSUPP ? -EOPNOTSUPP : ret; 590 591 WRITE_ONCE(ld->debounce, (unsigned int)val); 592 593 return 0; 594 } 595 596 DEFINE_DEBUGFS_ATTRIBUTE(gpio_virtuser_debounce_fops, 597 gpio_virtuser_debounce_get, 598 gpio_virtuser_debounce_set, 599 "%llu\n"); 600 601 static ssize_t gpio_virtuser_consumer_read(struct file *file, 602 char __user *user_buf, 603 size_t size, loff_t *ppos) 604 { 605 struct gpio_virtuser_line_data *data = file->private_data; 606 char buf[GPIO_VIRTUSER_NAME_BUF_LEN + 1]; 607 ssize_t ret; 608 609 memset(buf, 0x0, sizeof(buf)); 610 611 scoped_guard(mutex, &data->consumer_lock) 612 ret = snprintf(buf, sizeof(buf), "%s\n", data->consumer); 613 614 return simple_read_from_buffer(user_buf, size, ppos, buf, ret); 615 } 616 617 static ssize_t gpio_virtuser_consumer_write(struct file *file, 618 const char __user *user_buf, 619 size_t count, loff_t *ppos) 620 { 621 struct gpio_virtuser_line_data *data = file->private_data; 622 char buf[GPIO_VIRTUSER_NAME_BUF_LEN + 2]; 623 int ret; 624 625 if (count >= sizeof(buf)) 626 return -EINVAL; 627 628 ret = simple_write_to_buffer(buf, GPIO_VIRTUSER_NAME_BUF_LEN, ppos, 629 user_buf, count); 630 if (ret < 0) 631 return ret; 632 633 buf[ret] = '\0'; 634 635 ret = gpiod_set_consumer_name(data->ad.desc, buf); 636 if (ret) 637 return ret; 638 639 scoped_guard(mutex, &data->consumer_lock) 640 strscpy(data->consumer, buf, sizeof(data->consumer)); 641 642 return count; 643 } 644 645 static const struct file_operations gpio_virtuser_consumer_fops = { 646 .read = gpio_virtuser_consumer_read, 647 .write = gpio_virtuser_consumer_write, 648 .open = simple_open, 649 .owner = THIS_MODULE, 650 .llseek = default_llseek, 651 }; 652 653 static int gpio_virtuser_interrupts_get(void *data, u64 *val) 654 { 655 struct gpio_virtuser_line_data *ld = data; 656 657 *val = atomic_read(&ld->irq_count); 658 659 return 0; 660 } 661 662 static irqreturn_t gpio_virtuser_irq_handler(int irq, void *data) 663 { 664 struct gpio_virtuser_line_data *ld = data; 665 666 atomic_inc(&ld->irq_count); 667 668 return IRQ_HANDLED; 669 } 670 671 static int gpio_virtuser_interrupts_set(void *data, u64 val) 672 { 673 struct gpio_virtuser_line_data *ld = data; 674 int irq, ret; 675 676 if (val > 1) 677 return -EINVAL; 678 679 if (val) { 680 irq = gpiod_to_irq(ld->ad.desc); 681 if (irq < 0) 682 return irq; 683 684 ret = request_threaded_irq(irq, NULL, 685 gpio_virtuser_irq_handler, 686 IRQF_TRIGGER_RISING | 687 IRQF_TRIGGER_FALLING | 688 IRQF_ONESHOT, 689 ld->consumer, data); 690 if (ret) 691 return ret; 692 693 atomic_set(&ld->irq, irq); 694 } else { 695 irq = atomic_xchg(&ld->irq, 0); 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) = kcalloc(num_ids + 1, sizeof(*ids), 1434 GFP_KERNEL); 1435 if (!ids) 1436 return ERR_PTR(-ENOMEM); 1437 1438 list_for_each_entry(lookup, &dev->lookup_list, siblings) 1439 ids[i++] = lookup->con_id; 1440 1441 properties[0] = PROPERTY_ENTRY_STRING_ARRAY_LEN("gpio-virtuser,ids", 1442 ids, num_ids); 1443 1444 return fwnode_create_software_node(properties, NULL); 1445 } 1446 1447 static int 1448 gpio_virtuser_device_activate(struct gpio_virtuser_device *dev) 1449 { 1450 struct platform_device_info pdevinfo; 1451 struct platform_device *pdev; 1452 struct fwnode_handle *swnode; 1453 int ret; 1454 1455 lockdep_assert_held(&dev->lock); 1456 1457 if (list_empty(&dev->lookup_list)) 1458 return -ENODATA; 1459 1460 swnode = gpio_virtuser_make_device_swnode(dev); 1461 if (IS_ERR(swnode)) 1462 return PTR_ERR(swnode); 1463 1464 memset(&pdevinfo, 0, sizeof(pdevinfo)); 1465 pdevinfo.name = "gpio-virtuser"; 1466 pdevinfo.id = dev->id; 1467 pdevinfo.fwnode = swnode; 1468 1469 ret = gpio_virtuser_make_lookup_table(dev); 1470 if (ret) 1471 goto err_remove_swnode; 1472 1473 pdev = platform_device_register_full(&pdevinfo); 1474 if (IS_ERR(pdev)) { 1475 ret = PTR_ERR(pdev); 1476 goto err_remove_lookup_table; 1477 } 1478 1479 wait_for_device_probe(); 1480 if (!device_is_bound(&pdev->dev)) { 1481 ret = -ENXIO; 1482 goto err_unregister_pdev; 1483 } 1484 1485 dev->pdev = pdev; 1486 return 0; 1487 1488 err_unregister_pdev: 1489 platform_device_unregister(pdev); 1490 err_remove_lookup_table: 1491 gpio_virtuser_remove_lookup_table(dev); 1492 err_remove_swnode: 1493 fwnode_remove_software_node(swnode); 1494 1495 return ret; 1496 } 1497 1498 static void 1499 gpio_virtuser_device_deactivate(struct gpio_virtuser_device *dev) 1500 { 1501 struct fwnode_handle *swnode; 1502 1503 lockdep_assert_held(&dev->lock); 1504 1505 swnode = dev_fwnode(&dev->pdev->dev); 1506 platform_device_unregister(dev->pdev); 1507 dev->pdev = NULL; 1508 gpio_virtuser_remove_lookup_table(dev); 1509 fwnode_remove_software_node(swnode); 1510 } 1511 1512 static void 1513 gpio_virtuser_device_lockup_configfs(struct gpio_virtuser_device *dev, bool lock) 1514 { 1515 struct configfs_subsystem *subsys = dev->group.cg_subsys; 1516 struct gpio_virtuser_lookup_entry *entry; 1517 struct gpio_virtuser_lookup *lookup; 1518 1519 /* 1520 * The device only needs to depend on leaf lookup entries. This is 1521 * sufficient to lock up all the configfs entries that the 1522 * instantiated, alive device depends on. 1523 */ 1524 list_for_each_entry(lookup, &dev->lookup_list, siblings) { 1525 list_for_each_entry(entry, &lookup->entry_list, siblings) { 1526 if (lock) 1527 WARN_ON(configfs_depend_item_unlocked( 1528 subsys, &entry->group.cg_item)); 1529 else 1530 configfs_undepend_item_unlocked( 1531 &entry->group.cg_item); 1532 } 1533 } 1534 } 1535 1536 static ssize_t 1537 gpio_virtuser_device_config_live_store(struct config_item *item, 1538 const char *page, size_t count) 1539 { 1540 struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item); 1541 int ret = 0; 1542 bool live; 1543 1544 ret = kstrtobool(page, &live); 1545 if (ret) 1546 return ret; 1547 1548 if (live) 1549 gpio_virtuser_device_lockup_configfs(dev, true); 1550 1551 scoped_guard(mutex, &dev->lock) { 1552 if (live == gpio_virtuser_device_is_live(dev)) 1553 ret = -EPERM; 1554 else if (live) 1555 ret = gpio_virtuser_device_activate(dev); 1556 else 1557 gpio_virtuser_device_deactivate(dev); 1558 } 1559 1560 /* 1561 * Undepend is required only if device disablement (live == 0) 1562 * succeeds or if device enablement (live == 1) fails. 1563 */ 1564 if (live == !!ret) 1565 gpio_virtuser_device_lockup_configfs(dev, false); 1566 1567 return ret ?: count; 1568 } 1569 1570 CONFIGFS_ATTR(gpio_virtuser_device_config_, live); 1571 1572 static struct configfs_attribute *gpio_virtuser_device_config_attrs[] = { 1573 &gpio_virtuser_device_config_attr_dev_name, 1574 &gpio_virtuser_device_config_attr_live, 1575 NULL 1576 }; 1577 1578 static void 1579 gpio_virtuser_lookup_entry_config_group_release(struct config_item *item) 1580 { 1581 struct gpio_virtuser_lookup_entry *entry = 1582 to_gpio_virtuser_lookup_entry(item); 1583 struct gpio_virtuser_device *dev = entry->parent->parent; 1584 1585 guard(mutex)(&dev->lock); 1586 1587 list_del(&entry->siblings); 1588 1589 kfree(entry->key); 1590 kfree(entry); 1591 } 1592 1593 static struct 1594 configfs_item_operations gpio_virtuser_lookup_entry_config_item_ops = { 1595 .release = gpio_virtuser_lookup_entry_config_group_release, 1596 }; 1597 1598 static const struct 1599 config_item_type gpio_virtuser_lookup_entry_config_group_type = { 1600 .ct_item_ops = &gpio_virtuser_lookup_entry_config_item_ops, 1601 .ct_attrs = gpio_virtuser_lookup_entry_config_attrs, 1602 .ct_owner = THIS_MODULE, 1603 }; 1604 1605 static struct config_group * 1606 gpio_virtuser_make_lookup_entry_group(struct config_group *group, 1607 const char *name) 1608 { 1609 struct gpio_virtuser_lookup *lookup = 1610 to_gpio_virtuser_lookup(&group->cg_item); 1611 struct gpio_virtuser_device *dev = lookup->parent; 1612 1613 guard(mutex)(&dev->lock); 1614 1615 if (gpio_virtuser_device_is_live(dev)) 1616 return ERR_PTR(-EBUSY); 1617 1618 struct gpio_virtuser_lookup_entry *entry __free(kfree) = 1619 kzalloc_obj(*entry); 1620 if (!entry) 1621 return ERR_PTR(-ENOMEM); 1622 1623 config_group_init_type_name(&entry->group, name, 1624 &gpio_virtuser_lookup_entry_config_group_type); 1625 entry->flags = GPIO_LOOKUP_FLAGS_DEFAULT; 1626 entry->parent = lookup; 1627 list_add_tail(&entry->siblings, &lookup->entry_list); 1628 1629 return &no_free_ptr(entry)->group; 1630 } 1631 1632 static void gpio_virtuser_lookup_config_group_release(struct config_item *item) 1633 { 1634 struct gpio_virtuser_lookup *lookup = to_gpio_virtuser_lookup(item); 1635 struct gpio_virtuser_device *dev = lookup->parent; 1636 1637 guard(mutex)(&dev->lock); 1638 1639 list_del(&lookup->siblings); 1640 1641 kfree(lookup->con_id); 1642 kfree(lookup); 1643 } 1644 1645 static const struct configfs_item_operations gpio_virtuser_lookup_config_item_ops = { 1646 .release = gpio_virtuser_lookup_config_group_release, 1647 }; 1648 1649 static struct 1650 configfs_group_operations gpio_virtuser_lookup_config_group_ops = { 1651 .make_group = gpio_virtuser_make_lookup_entry_group, 1652 }; 1653 1654 static const struct config_item_type gpio_virtuser_lookup_config_group_type = { 1655 .ct_group_ops = &gpio_virtuser_lookup_config_group_ops, 1656 .ct_item_ops = &gpio_virtuser_lookup_config_item_ops, 1657 .ct_owner = THIS_MODULE, 1658 }; 1659 1660 static struct config_group * 1661 gpio_virtuser_make_lookup_group(struct config_group *group, const char *name) 1662 { 1663 struct gpio_virtuser_device *dev = 1664 to_gpio_virtuser_device(&group->cg_item); 1665 1666 if (strlen(name) > (GPIO_VIRTUSER_NAME_BUF_LEN - 1)) 1667 return ERR_PTR(-E2BIG); 1668 1669 guard(mutex)(&dev->lock); 1670 1671 if (gpio_virtuser_device_is_live(dev)) 1672 return ERR_PTR(-EBUSY); 1673 1674 struct gpio_virtuser_lookup *lookup __free(kfree) = 1675 kzalloc_obj(*lookup); 1676 if (!lookup) 1677 return ERR_PTR(-ENOMEM); 1678 1679 lookup->con_id = kstrdup(name, GFP_KERNEL); 1680 if (!lookup->con_id) 1681 return ERR_PTR(-ENOMEM); 1682 1683 config_group_init_type_name(&lookup->group, name, 1684 &gpio_virtuser_lookup_config_group_type); 1685 INIT_LIST_HEAD(&lookup->entry_list); 1686 lookup->parent = dev; 1687 list_add_tail(&lookup->siblings, &dev->lookup_list); 1688 1689 return &no_free_ptr(lookup)->group; 1690 } 1691 1692 static void gpio_virtuser_device_config_group_release(struct config_item *item) 1693 { 1694 struct gpio_virtuser_device *dev = to_gpio_virtuser_device(item); 1695 1696 scoped_guard(mutex, &dev->lock) { 1697 if (gpio_virtuser_device_is_live(dev)) 1698 gpio_virtuser_device_deactivate(dev); 1699 } 1700 1701 mutex_destroy(&dev->lock); 1702 ida_free(&gpio_virtuser_ida, dev->id); 1703 kfree(dev); 1704 } 1705 1706 static const struct configfs_item_operations gpio_virtuser_device_config_item_ops = { 1707 .release = gpio_virtuser_device_config_group_release, 1708 }; 1709 1710 static const struct configfs_group_operations gpio_virtuser_device_config_group_ops = { 1711 .make_group = gpio_virtuser_make_lookup_group, 1712 }; 1713 1714 static const struct config_item_type gpio_virtuser_device_config_group_type = { 1715 .ct_group_ops = &gpio_virtuser_device_config_group_ops, 1716 .ct_item_ops = &gpio_virtuser_device_config_item_ops, 1717 .ct_attrs = gpio_virtuser_device_config_attrs, 1718 .ct_owner = THIS_MODULE, 1719 }; 1720 1721 static struct config_group * 1722 gpio_virtuser_config_make_device_group(struct config_group *group, 1723 const char *name) 1724 { 1725 struct gpio_virtuser_device *dev __free(kfree) = kzalloc_obj(*dev); 1726 if (!dev) 1727 return ERR_PTR(-ENOMEM); 1728 1729 dev->id = ida_alloc(&gpio_virtuser_ida, GFP_KERNEL); 1730 if (dev->id < 0) 1731 return ERR_PTR(dev->id); 1732 1733 config_group_init_type_name(&dev->group, name, 1734 &gpio_virtuser_device_config_group_type); 1735 mutex_init(&dev->lock); 1736 INIT_LIST_HEAD(&dev->lookup_list); 1737 1738 return &no_free_ptr(dev)->group; 1739 } 1740 1741 static const struct configfs_group_operations gpio_virtuser_config_group_ops = { 1742 .make_group = gpio_virtuser_config_make_device_group, 1743 }; 1744 1745 static const struct config_item_type gpio_virtuser_config_type = { 1746 .ct_group_ops = &gpio_virtuser_config_group_ops, 1747 .ct_owner = THIS_MODULE, 1748 }; 1749 1750 static struct configfs_subsystem gpio_virtuser_config_subsys = { 1751 .su_group = { 1752 .cg_item = { 1753 .ci_namebuf = "gpio-virtuser", 1754 .ci_type = &gpio_virtuser_config_type, 1755 }, 1756 }, 1757 }; 1758 1759 static int __init gpio_virtuser_init(void) 1760 { 1761 int ret; 1762 1763 ret = platform_driver_register(&gpio_virtuser_driver); 1764 if (ret) { 1765 pr_err("Failed to register the platform driver: %d\n", ret); 1766 return ret; 1767 } 1768 1769 config_group_init(&gpio_virtuser_config_subsys.su_group); 1770 mutex_init(&gpio_virtuser_config_subsys.su_mutex); 1771 ret = configfs_register_subsystem(&gpio_virtuser_config_subsys); 1772 if (ret) { 1773 pr_err("Failed to register the '%s' configfs subsystem: %d\n", 1774 gpio_virtuser_config_subsys.su_group.cg_item.ci_namebuf, 1775 ret); 1776 goto err_plat_drv_unreg; 1777 } 1778 1779 gpio_virtuser_dbg_root = debugfs_create_dir("gpio-virtuser", NULL); 1780 if (IS_ERR(gpio_virtuser_dbg_root)) { 1781 ret = PTR_ERR(gpio_virtuser_dbg_root); 1782 pr_err("Failed to create the debugfs tree: %d\n", ret); 1783 goto err_configfs_unreg; 1784 } 1785 1786 return 0; 1787 1788 err_configfs_unreg: 1789 configfs_unregister_subsystem(&gpio_virtuser_config_subsys); 1790 err_plat_drv_unreg: 1791 mutex_destroy(&gpio_virtuser_config_subsys.su_mutex); 1792 platform_driver_unregister(&gpio_virtuser_driver); 1793 1794 return ret; 1795 } 1796 module_init(gpio_virtuser_init); 1797 1798 static void __exit gpio_virtuser_exit(void) 1799 { 1800 configfs_unregister_subsystem(&gpio_virtuser_config_subsys); 1801 mutex_destroy(&gpio_virtuser_config_subsys.su_mutex); 1802 platform_driver_unregister(&gpio_virtuser_driver); 1803 debugfs_remove_recursive(gpio_virtuser_dbg_root); 1804 } 1805 module_exit(gpio_virtuser_exit); 1806 1807 MODULE_AUTHOR("Bartosz Golaszewski <bartosz.golaszewski@linaro.org>"); 1808 MODULE_DESCRIPTION("Virtual GPIO consumer module"); 1809 MODULE_LICENSE("GPL"); 1810