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