drivers/char/raspberrypi-gpiomem.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /**
   3  * raspberrypi-gpiomem.c
   4  *
   5  * Provides MMIO access to discontiguous section of Device memory as a linear
   6  * user mapping. Successor to bcm2835-gpiomem.c.
   7  *
   8  * Copyright (c) 2023, Raspberry Pi Ltd.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/of.h>
  14 #include <linux/of_device.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/mm.h>
  17 #include <linux/slab.h>
  18 #include <linux/cdev.h>
  19 #include <linux/pagemap.h>
  20 #include <linux/io.h>
  21
  22 #define DRIVER_NAME "rpi-gpiomem"
  23 #define DEVICE_MINOR 0
  24
  25 /*
  26  * Sensible max for a hypothetical "gpio" controller that splits pads,
  27  * IO controls, GPIO in/out/enable, and function selection into different
  28  * ranges. Most use only one or two.
  29  */
  30 #define MAX_RANGES 4
  31
  32 struct io_windows {
  33         unsigned long phys_base;
  34         unsigned long len;
  35 };
  36
  37 struct rpi_gpiomem_priv {
  38         dev_t devid;
  39         struct class *class;
  40         struct cdev rpi_gpiomem_cdev;
  41         struct device *dev;
  42         const char *name;
  43         unsigned int nr_wins;
  44         struct io_windows iowins[4];
  45 };
  46
  47 static int rpi_gpiomem_open(struct inode *inode, struct file *file)
  48 {
  49         int dev = iminor(inode);
  50         int ret = 0;
  51         struct rpi_gpiomem_priv *priv;
  52
  53         if (dev != DEVICE_MINOR)
  54                 ret = -ENXIO;
  55
  56         priv = container_of(inode->i_cdev, struct rpi_gpiomem_priv,
  57                                 rpi_gpiomem_cdev);
  58         if (!priv)
  59                 return -EINVAL;
  60         file->private_data = priv;
  61         return ret;
  62 }
  63
  64 static int rpi_gpiomem_release(struct inode *inode, struct file *file)
  65 {
  66         int dev = iminor(inode);
  67         int ret = 0;
  68
  69         if (dev != DEVICE_MINOR)
  70                 ret = -ENXIO;
  71
  72         return ret;
  73 }
  74
  75 static const struct vm_operations_struct rpi_gpiomem_vm_ops = {
  76 #ifdef CONFIG_HAVE_IOREMAP_PROT
  77         .access = generic_access_phys
  78 #endif
  79 };
  80
  81 static int rpi_gpiomem_mmap(struct file *file, struct vm_area_struct *vma)
  82 {
  83         int i;
  84         struct rpi_gpiomem_priv *priv;
  85         unsigned long base;
  86         unsigned long len = 0;
  87         unsigned long offset;
  88
  89         priv = file->private_data;
  90         /*
  91          * Userspace must provide a virtual address space at least
  92          * the size of the concatenated ranges.
  93          */
  94         for (i = 0; i < priv->nr_wins; i++)
  95                 len += priv->iowins[i].len;
  96         if (len > vma->vm_end - vma->vm_start + 1)
  97                 return -EINVAL;
  98
  99         vma->vm_ops = &rpi_gpiomem_vm_ops;
 100         offset = vma->vm_start;
 101         for (i = 0; i < priv->nr_wins; i++) {
 102                 base = priv->iowins[i].phys_base >> PAGE_SHIFT;
 103                 len = priv->iowins[i].len;
 104                 vma->vm_page_prot = phys_mem_access_prot(file, base, len,
 105                                                          vma->vm_page_prot);
 106                 if (remap_pfn_range(vma, offset,
 107                             base, len,
 108                             vma->vm_page_prot))
 109                         break;
 110                 offset += len;
 111         }
 112
 113         if (i < priv->nr_wins)
 114                 return -EAGAIN;
 115
 116         return 0;
 117 }
 118
 119 static const struct file_operations rpi_gpiomem_fops = {
 120         .owner = THIS_MODULE,
 121         .open = rpi_gpiomem_open,
 122         .release = rpi_gpiomem_release,
 123         .mmap = rpi_gpiomem_mmap,
 124 };
 125
 126 static const struct of_device_id rpi_gpiomem_of_match[];
 127
 128 static int rpi_gpiomem_probe(struct platform_device *pdev)
 129 {
 130         int err, i;
 131         const struct of_device_id *id;
 132         struct device *dev = &pdev->dev;
 133         struct device_node *node = dev->of_node;
 134         struct resource *ioresource;
 135         struct rpi_gpiomem_priv *priv;
 136
 137         /* Allocate buffers and instance data */
 138
 139         priv = kzalloc(sizeof(struct rpi_gpiomem_priv), GFP_KERNEL);
 140
 141         if (!priv) {
 142                 err = -ENOMEM;
 143                 goto failed_inst_alloc;
 144         }
 145         platform_set_drvdata(pdev, priv);
 146
 147         priv->dev = dev;
 148         id = of_match_device(rpi_gpiomem_of_match, dev);
 149         if (!id)
 150                 return -EINVAL;
 151
 152         /*
 153          * Device node naming - for legacy (bcm2835) DT bindings, the driver
 154          * created the node based on a hardcoded name - for new bindings,
 155          * take the node name from DT.
 156          */
 157         if (id == &rpi_gpiomem_of_match[0]) {
 158                 priv->name = "gpiomem";
 159         } else {
 160                 err = of_property_read_string(node, "chardev-name", &priv->name);
 161                 if (err)
 162                         return -EINVAL;
 163         }
 164
 165         /*
 166          * Go find the register ranges associated with this instance
 167          */
 168         for (i = 0; i < MAX_RANGES; i++) {
 169                 ioresource = platform_get_resource(pdev, IORESOURCE_MEM, i);
 170                 if (!ioresource && i == 0) {
 171                         dev_err(priv->dev, "failed to get IO resource - no ranges available\n");
 172                         err = -ENOENT;
 173                         goto failed_get_resource;
 174                 }
 175                 if (!ioresource)
 176                         break;
 177
 178                 priv->iowins[i].phys_base = ioresource->start;
 179                 priv->iowins[i].len = (ioresource->end + 1) - ioresource->start;
 180                 dev_info(&pdev->dev, "window base 0x%08lx size 0x%08lx\n",
 181                          priv->iowins[i].phys_base, priv->iowins[i].len);
 182                 priv->nr_wins++;
 183         }
 184
 185         /* Create character device entries */
 186
 187         err = alloc_chrdev_region(&priv->devid,
 188                                   DEVICE_MINOR, 1, priv->name);
 189         if (err != 0) {
 190                 dev_err(priv->dev, "unable to allocate device number");
 191                 goto failed_alloc_chrdev;
 192         }
 193         cdev_init(&priv->rpi_gpiomem_cdev, &rpi_gpiomem_fops);
 194         priv->rpi_gpiomem_cdev.owner = THIS_MODULE;
 195         err = cdev_add(&priv->rpi_gpiomem_cdev, priv->devid, 1);
 196         if (err != 0) {
 197                 dev_err(priv->dev, "unable to register device");
 198                 goto failed_cdev_add;
 199         }
 200
 201         /* Create sysfs entries */
 202
 203         priv->class = class_create(priv->name);
 204         if (IS_ERR(priv->class)) {
 205                 err = PTR_ERR(priv->class);
 206                 goto failed_class_create;
 207         }
 208
 209         dev = device_create(priv->class, NULL, priv->devid, NULL, priv->name);
 210         if (IS_ERR(dev)) {
 211                 err = PTR_ERR(dev);
 212                 goto failed_device_create;
 213         }
 214
 215         dev_info(priv->dev, "initialised %u regions as /dev/%s\n",
 216                  priv->nr_wins, priv->name);
 217
 218         return 0;
 219
 220 failed_device_create:
 221         class_destroy(priv->class);
 222 failed_class_create:
 223         cdev_del(&priv->rpi_gpiomem_cdev);
 224 failed_cdev_add:
 225         unregister_chrdev_region(priv->devid, 1);
 226 failed_alloc_chrdev:
 227 failed_get_resource:
 228         kfree(priv);
 229 failed_inst_alloc:
 230         dev_err(&pdev->dev, "could not load rpi_gpiomem");
 231         return err;
 232 }
 233
 234 static int rpi_gpiomem_remove(struct platform_device *pdev)
 235 {
 236         struct device *dev = &pdev->dev;
 237         struct rpi_gpiomem_priv *priv = platform_get_drvdata(pdev);
 238
 239         device_destroy(priv->class, priv->devid);
 240         class_destroy(priv->class);
 241         cdev_del(&priv->rpi_gpiomem_cdev);
 242         unregister_chrdev_region(priv->devid, 1);
 243         kfree(priv);
 244
 245         dev_info(dev, "%s driver removed - OK", priv->name);
 246         return 0;
 247 }
 248
 249 static const struct of_device_id rpi_gpiomem_of_match[] = {
 250         {
 251                 .compatible = "brcm,bcm2835-gpiomem",
 252         },
 253         {
 254                 .compatible = "raspberrypi,gpiomem",
 255         },
 256         { /* sentinel */ },
 257 };
 258
 259 MODULE_DEVICE_TABLE(of, rpi_gpiomem_of_match);
 260
 261 static struct platform_driver rpi_gpiomem_driver = {
 262         .probe = rpi_gpiomem_probe,
 263         .remove = rpi_gpiomem_remove,
 264         .driver = {
 265                    .name = DRIVER_NAME,
 266                    .owner = THIS_MODULE,
 267                    .of_match_table = rpi_gpiomem_of_match,
 268                    },
 269 };
 270
 271 module_platform_driver(rpi_gpiomem_driver);
 272
 273 MODULE_ALIAS("platform:rpi-gpiomem");
 274 MODULE_LICENSE("Dual BSD/GPL");
 275 MODULE_DESCRIPTION("Driver for accessing GPIOs from userspace");
 276 MODULE_AUTHOR("Jonathan Bell <jonathan@raspberrypi.com>");