drivers/gpio/gpio-74xx-mmio.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * 74xx MMIO GPIO driver
   4  *
   5  *  Copyright (C) 2014 Alexander Shiyan <shc_work@mail.ru>
   6  */
   7
   8 #include <linux/err.h>
   9 #include <linux/gpio/driver.h>
  10 #include <linux/mod_devicetable.h>
  11 #include <linux/module.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/property.h>
  14
  15 #define MMIO_74XX_DIR_IN        (0 << 8)
  16 #define MMIO_74XX_DIR_OUT       (1 << 8)
  17 #define MMIO_74XX_BIT_CNT(x)    ((x) & 0xff)
  18
  19 struct mmio_74xx_gpio_priv {
  20         struct gpio_chip        gc;
  21         unsigned                flags;
  22 };
  23
  24 static const struct of_device_id mmio_74xx_gpio_ids[] = {
  25         {
  26                 .compatible     = "ti,741g125",
  27                 .data           = (const void *)(MMIO_74XX_DIR_IN | 1),
  28         },
  29         {
  30                 .compatible     = "ti,742g125",
  31                 .data           = (const void *)(MMIO_74XX_DIR_IN | 2),
  32         },
  33         {
  34                 .compatible     = "ti,74125",
  35                 .data           = (const void *)(MMIO_74XX_DIR_IN | 4),
  36         },
  37         {
  38                 .compatible     = "ti,74365",
  39                 .data           = (const void *)(MMIO_74XX_DIR_IN | 6),
  40         },
  41         {
  42                 .compatible     = "ti,74244",
  43                 .data           = (const void *)(MMIO_74XX_DIR_IN | 8),
  44         },
  45         {
  46                 .compatible     = "ti,741624",
  47                 .data           = (const void *)(MMIO_74XX_DIR_IN | 16),
  48         },
  49         {
  50                 .compatible     = "ti,741g74",
  51                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 1),
  52         },
  53         {
  54                 .compatible     = "ti,7474",
  55                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 2),
  56         },
  57         {
  58                 .compatible     = "ti,74175",
  59                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 4),
  60         },
  61         {
  62                 .compatible     = "ti,74174",
  63                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 6),
  64         },
  65         {
  66                 .compatible     = "ti,74273",
  67                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 8),
  68         },
  69         {
  70                 .compatible     = "ti,7416374",
  71                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 16),
  72         },
  73         { }
  74 };
  75 MODULE_DEVICE_TABLE(of, mmio_74xx_gpio_ids);
  76
  77 static int mmio_74xx_get_direction(struct gpio_chip *gc, unsigned offset)
  78 {
  79         struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
  80
  81         if (priv->flags & MMIO_74XX_DIR_OUT)
  82                 return GPIO_LINE_DIRECTION_OUT;
  83
  84         return  GPIO_LINE_DIRECTION_IN;
  85 }
  86
  87 static int mmio_74xx_dir_in(struct gpio_chip *gc, unsigned int gpio)
  88 {
  89         struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
  90
  91         if (priv->flags & MMIO_74XX_DIR_IN)
  92                 return 0;
  93
  94         return -ENOTSUPP;
  95 }
  96
  97 static int mmio_74xx_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
  98 {
  99         struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
 100
 101         if (priv->flags & MMIO_74XX_DIR_OUT) {
 102                 gc->set(gc, gpio, val);
 103                 return 0;
 104         }
 105
 106         return -ENOTSUPP;
 107 }
 108
 109 static int mmio_74xx_gpio_probe(struct platform_device *pdev)
 110 {
 111         struct mmio_74xx_gpio_priv *priv;
 112         void __iomem *dat;
 113         int err;
 114
 115         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 116         if (!priv)
 117                 return -ENOMEM;
 118
 119         priv->flags = (uintptr_t)device_get_match_data(&pdev->dev);
 120
 121         dat = devm_platform_ioremap_resource(pdev, 0);
 122         if (IS_ERR(dat))
 123                 return PTR_ERR(dat);
 124
 125         err = bgpio_init(&priv->gc, &pdev->dev,
 126                          DIV_ROUND_UP(MMIO_74XX_BIT_CNT(priv->flags), 8),
 127                          dat, NULL, NULL, NULL, NULL, 0);
 128         if (err)
 129                 return err;
 130
 131         priv->gc.direction_input = mmio_74xx_dir_in;
 132         priv->gc.direction_output = mmio_74xx_dir_out;
 133         priv->gc.get_direction = mmio_74xx_get_direction;
 134         priv->gc.ngpio = MMIO_74XX_BIT_CNT(priv->flags);
 135         priv->gc.owner = THIS_MODULE;
 136
 137         platform_set_drvdata(pdev, priv);
 138
 139         return devm_gpiochip_add_data(&pdev->dev, &priv->gc, priv);
 140 }
 141
 142 static struct platform_driver mmio_74xx_gpio_driver = {
 143         .driver = {
 144                 .name           = "74xx-mmio-gpio",
 145                 .of_match_table = mmio_74xx_gpio_ids,
 146         },
 147         .probe  = mmio_74xx_gpio_probe,
 148 };
 149 module_platform_driver(mmio_74xx_gpio_driver);
 150
 151 MODULE_LICENSE("GPL");
 152 MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
 153 MODULE_DESCRIPTION("74xx MMIO GPIO driver");