drivers/gpio/gpio-mockup.c

   1 /*
   2  * GPIO Testing Device Driver
   3  *
   4  * Copyright (C) 2014  Kamlakant Patel <[email protected]>
   5  * Copyright (C) 2015-2016  Bamvor Jian Zhang <[email protected]>
   6  * Copyright (C) 2017 Bartosz Golaszewski <[email protected]>
   7  *
   8  * This program is free software; you can redistribute  it and/or modify it
   9  * under  the terms of  the GNU General  Public License as published by the
  10  * Free Software Foundation;  either version 2 of the  License, or (at your
  11  * option) any later version.
  12  *
  13  */
  14
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/gpio/driver.h>
  18 #include <linux/gpio/consumer.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/slab.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/irq.h>
  23 #include <linux/irq_sim.h>
  24 #include <linux/debugfs.h>
  25 #include <linux/uaccess.h>
  26
  27 #include "gpiolib.h"
  28
  29 #define GPIO_MOCKUP_NAME        "gpio-mockup"
  30 #define GPIO_MOCKUP_MAX_GC      10
  31 /*
  32  * We're storing two values per chip: the GPIO base and the number
  33  * of GPIO lines.
  34  */
  35 #define GPIO_MOCKUP_MAX_RANGES  (GPIO_MOCKUP_MAX_GC * 2)
  36
  37 enum {
  38         GPIO_MOCKUP_DIR_OUT = 0,
  39         GPIO_MOCKUP_DIR_IN = 1,
  40 };
  41
  42 /*
  43  * struct gpio_pin_status - structure describing a GPIO status
  44  * @dir:       Configures direction of gpio as "in" or "out", 0=in, 1=out
  45  * @value:     Configures status of the gpio as 0(low) or 1(high)
  46  */
  47 struct gpio_mockup_line_status {
  48         int dir;
  49         bool value;
  50 };
  51
  52 struct gpio_mockup_chip {
  53         struct gpio_chip gc;
  54         struct gpio_mockup_line_status *lines;
  55         struct irq_sim irqsim;
  56         struct dentry *dbg_dir;
  57 };
  58
  59 struct gpio_mockup_dbgfs_private {
  60         struct gpio_mockup_chip *chip;
  61         struct gpio_desc *desc;
  62         int offset;
  63 };
  64
  65 static int gpio_mockup_ranges[GPIO_MOCKUP_MAX_RANGES];
  66 static int gpio_mockup_params_nr;
  67 module_param_array(gpio_mockup_ranges, int, &gpio_mockup_params_nr, 0400);
  68
  69 static bool gpio_mockup_named_lines;
  70 module_param_named(gpio_mockup_named_lines,
  71                    gpio_mockup_named_lines, bool, 0400);
  72
  73 static const char gpio_mockup_name_start = 'A';
  74 static struct dentry *gpio_mockup_dbg_dir;
  75
  76 static int gpio_mockup_get(struct gpio_chip *gc, unsigned int offset)
  77 {
  78         struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
  79
  80         return chip->lines[offset].value;
  81 }
  82
  83 static void gpio_mockup_set(struct gpio_chip *gc, unsigned int offset,
  84                             int value)
  85 {
  86         struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
  87
  88         chip->lines[offset].value = !!value;
  89 }
  90
  91 static int gpio_mockup_dirout(struct gpio_chip *gc, unsigned int offset,
  92                               int value)
  93 {
  94         struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
  95
  96         gpio_mockup_set(gc, offset, value);
  97         chip->lines[offset].dir = GPIO_MOCKUP_DIR_OUT;
  98
  99         return 0;
 100 }
 101
 102 static int gpio_mockup_dirin(struct gpio_chip *gc, unsigned int offset)
 103 {
 104         struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
 105
 106         chip->lines[offset].dir = GPIO_MOCKUP_DIR_IN;
 107
 108         return 0;
 109 }
 110
 111 static int gpio_mockup_get_direction(struct gpio_chip *gc, unsigned int offset)
 112 {
 113         struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
 114
 115         return chip->lines[offset].dir;
 116 }
 117
 118 static int gpio_mockup_name_lines(struct device *dev,
 119                                   struct gpio_mockup_chip *chip)
 120 {
 121         struct gpio_chip *gc = &chip->gc;
 122         char **names;
 123         int i;
 124
 125         names = devm_kcalloc(dev, gc->ngpio, sizeof(char *), GFP_KERNEL);
 126         if (!names)
 127                 return -ENOMEM;
 128
 129         for (i = 0; i < gc->ngpio; i++) {
 130                 names[i] = devm_kasprintf(dev, GFP_KERNEL,
 131                                           "%s-%d", gc->label, i);
 132                 if (!names[i])
 133                         return -ENOMEM;
 134         }
 135
 136         gc->names = (const char *const *)names;
 137
 138         return 0;
 139 }
 140
 141 static int gpio_mockup_to_irq(struct gpio_chip *gc, unsigned int offset)
 142 {
 143         struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
 144
 145         return irq_sim_irqnum(&chip->irqsim, offset);
 146 }
 147
 148 static ssize_t gpio_mockup_event_write(struct file *file,
 149                                        const char __user *usr_buf,
 150                                        size_t size, loff_t *ppos)
 151 {
 152         struct gpio_mockup_dbgfs_private *priv;
 153         struct gpio_mockup_chip *chip;
 154         struct seq_file *sfile;
 155         struct gpio_desc *desc;
 156         int rv, val;
 157
 158         rv = kstrtoint_from_user(usr_buf, size, 0, &val);
 159         if (rv)
 160                 return rv;
 161         if (val != 0 && val != 1)
 162                 return -EINVAL;
 163
 164         sfile = file->private_data;
 165         priv = sfile->private;
 166         desc = priv->desc;
 167         chip = priv->chip;
 168
 169         gpiod_set_value_cansleep(desc, val);
 170         irq_sim_fire(&chip->irqsim, priv->offset);
 171
 172         return size;
 173 }
 174
 175 static int gpio_mockup_event_open(struct inode *inode, struct file *file)
 176 {
 177         return single_open(file, NULL, inode->i_private);
 178 }
 179
 180 static const struct file_operations gpio_mockup_event_ops = {
 181         .owner = THIS_MODULE,
 182         .open = gpio_mockup_event_open,
 183         .write = gpio_mockup_event_write,
 184         .llseek = no_llseek,
 185 };
 186
 187 static void gpio_mockup_debugfs_setup(struct device *dev,
 188                                       struct gpio_mockup_chip *chip)
 189 {
 190         struct gpio_mockup_dbgfs_private *priv;
 191         struct dentry *evfile;
 192         struct gpio_chip *gc;
 193         char *name;
 194         int i;
 195
 196         gc = &chip->gc;
 197
 198         chip->dbg_dir = debugfs_create_dir(gc->label, gpio_mockup_dbg_dir);
 199         if (!chip->dbg_dir)
 200                 goto err;
 201
 202         for (i = 0; i < gc->ngpio; i++) {
 203                 name = devm_kasprintf(dev, GFP_KERNEL, "%d", i);
 204                 if (!name)
 205                         goto err;
 206
 207                 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 208                 if (!priv)
 209                         goto err;
 210
 211                 priv->chip = chip;
 212                 priv->offset = i;
 213                 priv->desc = &gc->gpiodev->descs[i];
 214
 215                 evfile = debugfs_create_file(name, 0200, chip->dbg_dir, priv,
 216                                              &gpio_mockup_event_ops);
 217                 if (!evfile)
 218                         goto err;
 219         }
 220
 221         return;
 222
 223 err:
 224         dev_err(dev, "error creating debugfs directory\n");
 225 }
 226
 227 static int gpio_mockup_add(struct device *dev,
 228                            struct gpio_mockup_chip *chip,
 229                            const char *name, int base, int ngpio)
 230 {
 231         struct gpio_chip *gc = &chip->gc;
 232         int ret;
 233
 234         gc->base = base;
 235         gc->ngpio = ngpio;
 236         gc->label = name;
 237         gc->owner = THIS_MODULE;
 238         gc->parent = dev;
 239         gc->get = gpio_mockup_get;
 240         gc->set = gpio_mockup_set;
 241         gc->direction_output = gpio_mockup_dirout;
 242         gc->direction_input = gpio_mockup_dirin;
 243         gc->get_direction = gpio_mockup_get_direction;
 244         gc->to_irq = gpio_mockup_to_irq;
 245
 246         chip->lines = devm_kcalloc(dev, gc->ngpio,
 247                                    sizeof(*chip->lines), GFP_KERNEL);
 248         if (!chip->lines)
 249                 return -ENOMEM;
 250
 251         if (gpio_mockup_named_lines) {
 252                 ret = gpio_mockup_name_lines(dev, chip);
 253                 if (ret)
 254                         return ret;
 255         }
 256
 257         ret = devm_irq_sim_init(dev, &chip->irqsim, gc->ngpio);
 258         if (ret)
 259                 return ret;
 260
 261         ret = devm_gpiochip_add_data(dev, &chip->gc, chip);
 262         if (ret)
 263                 return ret;
 264
 265         if (gpio_mockup_dbg_dir)
 266                 gpio_mockup_debugfs_setup(dev, chip);
 267
 268         return 0;
 269 }
 270
 271 static int gpio_mockup_probe(struct platform_device *pdev)
 272 {
 273         int ret, i, base, ngpio, num_chips;
 274         struct device *dev = &pdev->dev;
 275         struct gpio_mockup_chip *chips;
 276         char *chip_name;
 277
 278         if (gpio_mockup_params_nr < 2 || (gpio_mockup_params_nr % 2))
 279                 return -EINVAL;
 280
 281         /* Each chip is described by two values. */
 282         num_chips = gpio_mockup_params_nr / 2;
 283
 284         chips = devm_kcalloc(dev, num_chips, sizeof(*chips), GFP_KERNEL);
 285         if (!chips)
 286                 return -ENOMEM;
 287
 288         platform_set_drvdata(pdev, chips);
 289
 290         for (i = 0; i < num_chips; i++) {
 291                 base = gpio_mockup_ranges[i * 2];
 292
 293                 if (base == -1)
 294                         ngpio = gpio_mockup_ranges[i * 2 + 1];
 295                 else
 296                         ngpio = gpio_mockup_ranges[i * 2 + 1] - base;
 297
 298                 if (ngpio >= 0) {
 299                         chip_name = devm_kasprintf(dev, GFP_KERNEL,
 300                                                    "%s-%c", GPIO_MOCKUP_NAME,
 301                                                    gpio_mockup_name_start + i);
 302                         if (!chip_name)
 303                                 return -ENOMEM;
 304
 305                         ret = gpio_mockup_add(dev, &chips[i],
 306                                               chip_name, base, ngpio);
 307                 } else {
 308                         ret = -EINVAL;
 309                 }
 310
 311                 if (ret) {
 312                         dev_err(dev,
 313                                 "adding gpiochip failed: %d (base: %d, ngpio: %d)\n",
 314                                 ret, base, base < 0 ? ngpio : base + ngpio);
 315
 316                         return ret;
 317                 }
 318         }
 319
 320         return 0;
 321 }
 322
 323 static struct platform_driver gpio_mockup_driver = {
 324         .driver = {
 325                 .name = GPIO_MOCKUP_NAME,
 326         },
 327         .probe = gpio_mockup_probe,
 328 };
 329
 330 static struct platform_device *pdev;
 331 static int __init mock_device_init(void)
 332 {
 333         int err;
 334
 335         gpio_mockup_dbg_dir = debugfs_create_dir("gpio-mockup-event", NULL);
 336         if (!gpio_mockup_dbg_dir)
 337                 pr_err("%s: error creating debugfs directory\n",
 338                        GPIO_MOCKUP_NAME);
 339
 340         pdev = platform_device_alloc(GPIO_MOCKUP_NAME, -1);
 341         if (!pdev)
 342                 return -ENOMEM;
 343
 344         err = platform_device_add(pdev);
 345         if (err) {
 346                 platform_device_put(pdev);
 347                 return err;
 348         }
 349
 350         err = platform_driver_register(&gpio_mockup_driver);
 351         if (err) {
 352                 platform_device_unregister(pdev);
 353                 return err;
 354         }
 355
 356         return 0;
 357 }
 358
 359 static void __exit mock_device_exit(void)
 360 {
 361         debugfs_remove_recursive(gpio_mockup_dbg_dir);
 362         platform_driver_unregister(&gpio_mockup_driver);
 363         platform_device_unregister(pdev);
 364 }
 365
 366 module_init(mock_device_init);
 367 module_exit(mock_device_exit);
 368
 369 MODULE_AUTHOR("Kamlakant Patel <[email protected]>");
 370 MODULE_AUTHOR("Bamvor Jian Zhang <[email protected]>");
 371 MODULE_AUTHOR("Bartosz Golaszewski <[email protected]>");
 372 MODULE_DESCRIPTION("GPIO Testing driver");
 373 MODULE_LICENSE("GPL v2");