1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * GPIO Testing Device Driver 4 * 5 * Copyright (C) 2014 Kamlakant Patel <kamlakant.patel@broadcom.com> 6 * Copyright (C) 2015-2016 Bamvor Jian Zhang <bamv2005@gmail.com> 7 * Copyright (C) 2017 Bartosz Golaszewski <brgl@bgdev.pl> 8 */ 9 10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 11 12 #include <linux/debugfs.h> 13 #include <linux/gpio/driver.h> 14 #include <linux/interrupt.h> 15 #include <linux/irq.h> 16 #include <linux/irq_sim.h> 17 #include <linux/irqdomain.h> 18 #include <linux/mod_devicetable.h> 19 #include <linux/module.h> 20 #include <linux/platform_device.h> 21 #include <linux/property.h> 22 #include <linux/seq_file.h> 23 #include <linux/slab.h> 24 #include <linux/string_helpers.h> 25 #include <linux/uaccess.h> 26 27 #include "gpiolib.h" 28 29 #define GPIO_MOCKUP_MAX_GC 10 30 /* 31 * We're storing two values per chip: the GPIO base and the number 32 * of GPIO lines. 33 */ 34 #define GPIO_MOCKUP_MAX_RANGES (GPIO_MOCKUP_MAX_GC * 2) 35 /* Maximum of four properties + the sentinel. */ 36 #define GPIO_MOCKUP_MAX_PROP 5 37 38 /* 39 * struct gpio_pin_status - structure describing a GPIO status 40 * @dir: Configures direction of gpio as "in" or "out" 41 * @value: Configures status of the gpio as 0(low) or 1(high) 42 */ 43 struct gpio_mockup_line_status { 44 int dir; 45 int value; 46 int pull; 47 }; 48 49 struct gpio_mockup_chip { 50 struct gpio_chip gc; 51 struct gpio_mockup_line_status *lines; 52 struct irq_domain *irq_sim_domain; 53 struct dentry *dbg_dir; 54 struct mutex lock; 55 }; 56 57 struct gpio_mockup_dbgfs_private { 58 struct gpio_mockup_chip *chip; 59 struct gpio_desc *desc; 60 unsigned int offset; 61 }; 62 63 static int gpio_mockup_ranges[GPIO_MOCKUP_MAX_RANGES]; 64 static int gpio_mockup_num_ranges; 65 module_param_array(gpio_mockup_ranges, int, &gpio_mockup_num_ranges, 0400); 66 67 static bool gpio_mockup_named_lines; 68 module_param_named(gpio_mockup_named_lines, 69 gpio_mockup_named_lines, bool, 0400); 70 71 static struct dentry *gpio_mockup_dbg_dir; 72 73 static int gpio_mockup_range_base(unsigned int index) 74 { 75 return gpio_mockup_ranges[index * 2]; 76 } 77 78 static int gpio_mockup_range_ngpio(unsigned int index) 79 { 80 return gpio_mockup_ranges[index * 2 + 1]; 81 } 82 83 static int __gpio_mockup_get(struct gpio_mockup_chip *chip, 84 unsigned int offset) 85 { 86 return chip->lines[offset].value; 87 } 88 89 static int gpio_mockup_get(struct gpio_chip *gc, unsigned int offset) 90 { 91 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 92 int val; 93 94 mutex_lock(&chip->lock); 95 val = __gpio_mockup_get(chip, offset); 96 mutex_unlock(&chip->lock); 97 98 return val; 99 } 100 101 static int gpio_mockup_get_multiple(struct gpio_chip *gc, 102 unsigned long *mask, unsigned long *bits) 103 { 104 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 105 unsigned int bit, val; 106 107 mutex_lock(&chip->lock); 108 for_each_set_bit(bit, mask, gc->ngpio) { 109 val = __gpio_mockup_get(chip, bit); 110 __assign_bit(bit, bits, val); 111 } 112 mutex_unlock(&chip->lock); 113 114 return 0; 115 } 116 117 static void __gpio_mockup_set(struct gpio_mockup_chip *chip, 118 unsigned int offset, int value) 119 { 120 chip->lines[offset].value = !!value; 121 } 122 123 static void gpio_mockup_set(struct gpio_chip *gc, 124 unsigned int offset, int value) 125 { 126 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 127 128 mutex_lock(&chip->lock); 129 __gpio_mockup_set(chip, offset, value); 130 mutex_unlock(&chip->lock); 131 } 132 133 static void gpio_mockup_set_multiple(struct gpio_chip *gc, 134 unsigned long *mask, unsigned long *bits) 135 { 136 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 137 unsigned int bit; 138 139 mutex_lock(&chip->lock); 140 for_each_set_bit(bit, mask, gc->ngpio) 141 __gpio_mockup_set(chip, bit, test_bit(bit, bits)); 142 mutex_unlock(&chip->lock); 143 } 144 145 static int gpio_mockup_apply_pull(struct gpio_mockup_chip *chip, 146 unsigned int offset, int value) 147 { 148 struct gpio_chip *gc = &chip->gc; 149 struct gpio_desc *desc = gpiochip_get_desc(gc, offset); 150 int curr, irq, irq_type, ret = 0; 151 152 mutex_lock(&chip->lock); 153 154 if (test_bit(FLAG_REQUESTED, &desc->flags) && 155 !test_bit(FLAG_IS_OUT, &desc->flags)) { 156 curr = __gpio_mockup_get(chip, offset); 157 if (curr == value) 158 goto out; 159 160 irq = irq_find_mapping(chip->irq_sim_domain, offset); 161 if (!irq) 162 /* 163 * This is fine - it just means, nobody is listening 164 * for interrupts on this line, otherwise 165 * irq_create_mapping() would have been called from 166 * the to_irq() callback. 167 */ 168 goto set_value; 169 170 irq_type = irq_get_trigger_type(irq); 171 172 if ((value == 1 && (irq_type & IRQ_TYPE_EDGE_RISING)) || 173 (value == 0 && (irq_type & IRQ_TYPE_EDGE_FALLING))) { 174 ret = irq_set_irqchip_state(irq, IRQCHIP_STATE_PENDING, 175 true); 176 if (ret) 177 goto out; 178 } 179 } 180 181 set_value: 182 /* Change the value unless we're actively driving the line. */ 183 if (!test_bit(FLAG_REQUESTED, &desc->flags) || 184 !test_bit(FLAG_IS_OUT, &desc->flags)) 185 __gpio_mockup_set(chip, offset, value); 186 187 out: 188 chip->lines[offset].pull = value; 189 mutex_unlock(&chip->lock); 190 return ret; 191 } 192 193 static int gpio_mockup_set_config(struct gpio_chip *gc, 194 unsigned int offset, unsigned long config) 195 { 196 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 197 198 switch (pinconf_to_config_param(config)) { 199 case PIN_CONFIG_BIAS_PULL_UP: 200 return gpio_mockup_apply_pull(chip, offset, 1); 201 case PIN_CONFIG_BIAS_PULL_DOWN: 202 return gpio_mockup_apply_pull(chip, offset, 0); 203 default: 204 break; 205 } 206 return -ENOTSUPP; 207 } 208 209 static int gpio_mockup_dirout(struct gpio_chip *gc, 210 unsigned int offset, int value) 211 { 212 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 213 214 mutex_lock(&chip->lock); 215 chip->lines[offset].dir = GPIO_LINE_DIRECTION_OUT; 216 __gpio_mockup_set(chip, offset, value); 217 mutex_unlock(&chip->lock); 218 219 return 0; 220 } 221 222 static int gpio_mockup_dirin(struct gpio_chip *gc, unsigned int offset) 223 { 224 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 225 226 mutex_lock(&chip->lock); 227 chip->lines[offset].dir = GPIO_LINE_DIRECTION_IN; 228 mutex_unlock(&chip->lock); 229 230 return 0; 231 } 232 233 static int gpio_mockup_get_direction(struct gpio_chip *gc, unsigned int offset) 234 { 235 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 236 int direction; 237 238 mutex_lock(&chip->lock); 239 direction = chip->lines[offset].dir; 240 mutex_unlock(&chip->lock); 241 242 return direction; 243 } 244 245 static int gpio_mockup_to_irq(struct gpio_chip *gc, unsigned int offset) 246 { 247 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 248 249 return irq_create_mapping(chip->irq_sim_domain, offset); 250 } 251 252 static void gpio_mockup_free(struct gpio_chip *gc, unsigned int offset) 253 { 254 struct gpio_mockup_chip *chip = gpiochip_get_data(gc); 255 256 __gpio_mockup_set(chip, offset, chip->lines[offset].pull); 257 } 258 259 static ssize_t gpio_mockup_debugfs_read(struct file *file, 260 char __user *usr_buf, 261 size_t size, loff_t *ppos) 262 { 263 struct gpio_mockup_dbgfs_private *priv; 264 struct gpio_mockup_chip *chip; 265 struct seq_file *sfile; 266 struct gpio_chip *gc; 267 int val, cnt; 268 char buf[3]; 269 270 if (*ppos != 0) 271 return 0; 272 273 sfile = file->private_data; 274 priv = sfile->private; 275 chip = priv->chip; 276 gc = &chip->gc; 277 278 val = gpio_mockup_get(gc, priv->offset); 279 cnt = snprintf(buf, sizeof(buf), "%d\n", val); 280 281 return simple_read_from_buffer(usr_buf, size, ppos, buf, cnt); 282 } 283 284 static ssize_t gpio_mockup_debugfs_write(struct file *file, 285 const char __user *usr_buf, 286 size_t size, loff_t *ppos) 287 { 288 struct gpio_mockup_dbgfs_private *priv; 289 int rv, val; 290 struct seq_file *sfile; 291 292 if (*ppos != 0) 293 return -EINVAL; 294 295 rv = kstrtoint_from_user(usr_buf, size, 0, &val); 296 if (rv) 297 return rv; 298 if (val != 0 && val != 1) 299 return -EINVAL; 300 301 sfile = file->private_data; 302 priv = sfile->private; 303 rv = gpio_mockup_apply_pull(priv->chip, priv->offset, val); 304 if (rv) 305 return rv; 306 307 return size; 308 } 309 310 static int gpio_mockup_debugfs_open(struct inode *inode, struct file *file) 311 { 312 return single_open(file, NULL, inode->i_private); 313 } 314 315 /* 316 * Each mockup chip is represented by a directory named after the chip's device 317 * name under /sys/kernel/debug/gpio-mockup/. Each line is represented by 318 * a file using the line's offset as the name under the chip's directory. 319 * 320 * Reading from the line's file yields the current *value*, writing to the 321 * line's file changes the current *pull*. Default pull for mockup lines is 322 * down. 323 * 324 * Examples: 325 * - when a line pulled down is requested in output mode and driven high, its 326 * value will return to 0 once it's released 327 * - when the line is requested in output mode and driven high, writing 0 to 328 * the corresponding debugfs file will change the pull to down but the 329 * reported value will still be 1 until the line is released 330 * - line requested in input mode always reports the same value as its pull 331 * configuration 332 * - when the line is requested in input mode and monitored for events, writing 333 * the same value to the debugfs file will be a noop, while writing the 334 * opposite value will generate a dummy interrupt with an appropriate edge 335 */ 336 static const struct file_operations gpio_mockup_debugfs_ops = { 337 .owner = THIS_MODULE, 338 .open = gpio_mockup_debugfs_open, 339 .read = gpio_mockup_debugfs_read, 340 .write = gpio_mockup_debugfs_write, 341 .llseek = no_llseek, 342 .release = single_release, 343 }; 344 345 static void gpio_mockup_debugfs_setup(struct device *dev, 346 struct gpio_mockup_chip *chip) 347 { 348 struct gpio_mockup_dbgfs_private *priv; 349 struct gpio_chip *gc; 350 const char *devname; 351 char *name; 352 int i; 353 354 gc = &chip->gc; 355 devname = dev_name(&gc->gpiodev->dev); 356 357 chip->dbg_dir = debugfs_create_dir(devname, gpio_mockup_dbg_dir); 358 359 for (i = 0; i < gc->ngpio; i++) { 360 name = devm_kasprintf(dev, GFP_KERNEL, "%d", i); 361 if (!name) 362 return; 363 364 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 365 if (!priv) 366 return; 367 368 priv->chip = chip; 369 priv->offset = i; 370 priv->desc = gpiochip_get_desc(gc, i); 371 372 debugfs_create_file(name, 0200, chip->dbg_dir, priv, 373 &gpio_mockup_debugfs_ops); 374 } 375 } 376 377 static void gpio_mockup_debugfs_cleanup(void *data) 378 { 379 struct gpio_mockup_chip *chip = data; 380 381 debugfs_remove_recursive(chip->dbg_dir); 382 } 383 384 static void gpio_mockup_dispose_mappings(void *data) 385 { 386 struct gpio_mockup_chip *chip = data; 387 struct gpio_chip *gc = &chip->gc; 388 int i, irq; 389 390 for (i = 0; i < gc->ngpio; i++) { 391 irq = irq_find_mapping(chip->irq_sim_domain, i); 392 if (irq) 393 irq_dispose_mapping(irq); 394 } 395 } 396 397 static int gpio_mockup_probe(struct platform_device *pdev) 398 { 399 struct gpio_mockup_chip *chip; 400 struct gpio_chip *gc; 401 struct device *dev; 402 const char *name; 403 int rv, base, i; 404 u16 ngpio; 405 406 dev = &pdev->dev; 407 408 rv = device_property_read_u32(dev, "gpio-base", &base); 409 if (rv) 410 base = -1; 411 412 rv = device_property_read_u16(dev, "nr-gpios", &ngpio); 413 if (rv) 414 return rv; 415 416 rv = device_property_read_string(dev, "chip-label", &name); 417 if (rv) 418 name = dev_name(dev); 419 420 chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL); 421 if (!chip) 422 return -ENOMEM; 423 424 mutex_init(&chip->lock); 425 426 gc = &chip->gc; 427 gc->base = base; 428 gc->ngpio = ngpio; 429 gc->label = name; 430 gc->owner = THIS_MODULE; 431 gc->parent = dev; 432 gc->get = gpio_mockup_get; 433 gc->set = gpio_mockup_set; 434 gc->get_multiple = gpio_mockup_get_multiple; 435 gc->set_multiple = gpio_mockup_set_multiple; 436 gc->direction_output = gpio_mockup_dirout; 437 gc->direction_input = gpio_mockup_dirin; 438 gc->get_direction = gpio_mockup_get_direction; 439 gc->set_config = gpio_mockup_set_config; 440 gc->to_irq = gpio_mockup_to_irq; 441 gc->free = gpio_mockup_free; 442 443 chip->lines = devm_kcalloc(dev, gc->ngpio, 444 sizeof(*chip->lines), GFP_KERNEL); 445 if (!chip->lines) 446 return -ENOMEM; 447 448 for (i = 0; i < gc->ngpio; i++) 449 chip->lines[i].dir = GPIO_LINE_DIRECTION_IN; 450 451 chip->irq_sim_domain = devm_irq_domain_create_sim(dev, NULL, 452 gc->ngpio); 453 if (IS_ERR(chip->irq_sim_domain)) 454 return PTR_ERR(chip->irq_sim_domain); 455 456 rv = devm_add_action_or_reset(dev, gpio_mockup_dispose_mappings, chip); 457 if (rv) 458 return rv; 459 460 rv = devm_gpiochip_add_data(dev, &chip->gc, chip); 461 if (rv) 462 return rv; 463 464 gpio_mockup_debugfs_setup(dev, chip); 465 466 return devm_add_action_or_reset(dev, gpio_mockup_debugfs_cleanup, chip); 467 } 468 469 static const struct of_device_id gpio_mockup_of_match[] = { 470 { .compatible = "gpio-mockup", }, 471 {}, 472 }; 473 MODULE_DEVICE_TABLE(of, gpio_mockup_of_match); 474 475 static struct platform_driver gpio_mockup_driver = { 476 .driver = { 477 .name = "gpio-mockup", 478 .of_match_table = gpio_mockup_of_match, 479 }, 480 .probe = gpio_mockup_probe, 481 }; 482 483 static struct platform_device *gpio_mockup_pdevs[GPIO_MOCKUP_MAX_GC]; 484 485 static void gpio_mockup_unregister_pdevs(void) 486 { 487 struct platform_device *pdev; 488 struct fwnode_handle *fwnode; 489 int i; 490 491 for (i = 0; i < GPIO_MOCKUP_MAX_GC; i++) { 492 pdev = gpio_mockup_pdevs[i]; 493 if (!pdev) 494 continue; 495 496 fwnode = dev_fwnode(&pdev->dev); 497 platform_device_unregister(pdev); 498 fwnode_remove_software_node(fwnode); 499 } 500 } 501 502 static int __init gpio_mockup_register_chip(int idx) 503 { 504 struct property_entry properties[GPIO_MOCKUP_MAX_PROP]; 505 struct platform_device_info pdevinfo; 506 struct platform_device *pdev; 507 struct fwnode_handle *fwnode; 508 char **line_names = NULL; 509 char chip_label[32]; 510 int prop = 0, base; 511 u16 ngpio; 512 513 memset(properties, 0, sizeof(properties)); 514 memset(&pdevinfo, 0, sizeof(pdevinfo)); 515 516 snprintf(chip_label, sizeof(chip_label), "gpio-mockup-%c", idx + 'A'); 517 properties[prop++] = PROPERTY_ENTRY_STRING("chip-label", chip_label); 518 519 base = gpio_mockup_range_base(idx); 520 if (base >= 0) 521 properties[prop++] = PROPERTY_ENTRY_U32("gpio-base", base); 522 523 ngpio = base < 0 ? gpio_mockup_range_ngpio(idx) 524 : gpio_mockup_range_ngpio(idx) - base; 525 properties[prop++] = PROPERTY_ENTRY_U16("nr-gpios", ngpio); 526 527 if (gpio_mockup_named_lines) { 528 line_names = kasprintf_strarray(GFP_KERNEL, chip_label, ngpio); 529 if (!line_names) 530 return -ENOMEM; 531 532 properties[prop++] = PROPERTY_ENTRY_STRING_ARRAY_LEN( 533 "gpio-line-names", line_names, ngpio); 534 } 535 536 fwnode = fwnode_create_software_node(properties, NULL); 537 if (IS_ERR(fwnode)) { 538 kfree_strarray(line_names, ngpio); 539 return PTR_ERR(fwnode); 540 } 541 542 pdevinfo.name = "gpio-mockup"; 543 pdevinfo.id = idx; 544 pdevinfo.fwnode = fwnode; 545 546 pdev = platform_device_register_full(&pdevinfo); 547 kfree_strarray(line_names, ngpio); 548 if (IS_ERR(pdev)) { 549 fwnode_remove_software_node(fwnode); 550 pr_err("error registering device"); 551 return PTR_ERR(pdev); 552 } 553 554 gpio_mockup_pdevs[idx] = pdev; 555 556 return 0; 557 } 558 559 static int __init gpio_mockup_init(void) 560 { 561 int i, num_chips, err; 562 563 if ((gpio_mockup_num_ranges % 2) || 564 (gpio_mockup_num_ranges > GPIO_MOCKUP_MAX_RANGES)) 565 return -EINVAL; 566 567 /* Each chip is described by two values. */ 568 num_chips = gpio_mockup_num_ranges / 2; 569 570 /* 571 * The second value in the <base GPIO - number of GPIOS> pair must 572 * always be greater than 0. 573 */ 574 for (i = 0; i < num_chips; i++) { 575 if (gpio_mockup_range_ngpio(i) < 0) 576 return -EINVAL; 577 } 578 579 gpio_mockup_dbg_dir = debugfs_create_dir("gpio-mockup", NULL); 580 581 err = platform_driver_register(&gpio_mockup_driver); 582 if (err) { 583 pr_err("error registering platform driver\n"); 584 debugfs_remove_recursive(gpio_mockup_dbg_dir); 585 return err; 586 } 587 588 for (i = 0; i < num_chips; i++) { 589 err = gpio_mockup_register_chip(i); 590 if (err) { 591 platform_driver_unregister(&gpio_mockup_driver); 592 gpio_mockup_unregister_pdevs(); 593 debugfs_remove_recursive(gpio_mockup_dbg_dir); 594 return err; 595 } 596 } 597 598 return 0; 599 } 600 601 static void __exit gpio_mockup_exit(void) 602 { 603 gpio_mockup_unregister_pdevs(); 604 debugfs_remove_recursive(gpio_mockup_dbg_dir); 605 platform_driver_unregister(&gpio_mockup_driver); 606 } 607 608 module_init(gpio_mockup_init); 609 module_exit(gpio_mockup_exit); 610 611 MODULE_AUTHOR("Kamlakant Patel <kamlakant.patel@broadcom.com>"); 612 MODULE_AUTHOR("Bamvor Jian Zhang <bamv2005@gmail.com>"); 613 MODULE_AUTHOR("Bartosz Golaszewski <brgl@bgdev.pl>"); 614 MODULE_DESCRIPTION("GPIO Testing driver"); 615 MODULE_LICENSE("GPL v2"); 616