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