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

   1 /*
   2  * 74xx MMIO GPIO driver
   3  *
   4  *  Copyright (C) 2014 Alexander Shiyan <shc_work@mail.ru>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11
  12 #include <linux/err.h>
  13 #include <linux/module.h>
  14 #include <linux/of_device.h>
  15 #include <linux/gpio/driver.h>
  16 #include <linux/platform_device.h>
  17
  18 #define MMIO_74XX_DIR_IN        (0 << 8)
  19 #define MMIO_74XX_DIR_OUT       (1 << 8)
  20 #define MMIO_74XX_BIT_CNT(x)    ((x) & 0xff)
  21
  22 struct mmio_74xx_gpio_priv {
  23         struct gpio_chip        gc;
  24         unsigned                flags;
  25 };
  26
  27 static const struct of_device_id mmio_74xx_gpio_ids[] = {
  28         {
  29                 .compatible     = "ti,741g125",
  30                 .data           = (const void *)(MMIO_74XX_DIR_IN | 1),
  31         },
  32         {
  33                 .compatible     = "ti,742g125",
  34                 .data           = (const void *)(MMIO_74XX_DIR_IN | 2),
  35         },
  36         {
  37                 .compatible     = "ti,74125",
  38                 .data           = (const void *)(MMIO_74XX_DIR_IN | 4),
  39         },
  40         {
  41                 .compatible     = "ti,74365",
  42                 .data           = (const void *)(MMIO_74XX_DIR_IN | 6),
  43         },
  44         {
  45                 .compatible     = "ti,74244",
  46                 .data           = (const void *)(MMIO_74XX_DIR_IN | 8),
  47         },
  48         {
  49                 .compatible     = "ti,741624",
  50                 .data           = (const void *)(MMIO_74XX_DIR_IN | 16),
  51         },
  52         {
  53                 .compatible     = "ti,741g74",
  54                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 1),
  55         },
  56         {
  57                 .compatible     = "ti,7474",
  58                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 2),
  59         },
  60         {
  61                 .compatible     = "ti,74175",
  62                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 4),
  63         },
  64         {
  65                 .compatible     = "ti,74174",
  66                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 6),
  67         },
  68         {
  69                 .compatible     = "ti,74273",
  70                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 8),
  71         },
  72         {
  73                 .compatible     = "ti,7416374",
  74                 .data           = (const void *)(MMIO_74XX_DIR_OUT | 16),
  75         },
  76         { }
  77 };
  78 MODULE_DEVICE_TABLE(of, mmio_74xx_gpio_ids);
  79
  80 static int mmio_74xx_get_direction(struct gpio_chip *gc, unsigned offset)
  81 {
  82         struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
  83
  84         return !(priv->flags & MMIO_74XX_DIR_OUT);
  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         return (priv->flags & MMIO_74XX_DIR_OUT) ? -ENOTSUPP : 0;
  92 }
  93
  94 static int mmio_74xx_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
  95 {
  96         struct mmio_74xx_gpio_priv *priv = gpiochip_get_data(gc);
  97
  98         if (priv->flags & MMIO_74XX_DIR_OUT) {
  99                 gc->set(gc, gpio, val);
 100                 return 0;
 101         }
 102
 103         return -ENOTSUPP;
 104 }
 105
 106 static int mmio_74xx_gpio_probe(struct platform_device *pdev)
 107 {
 108         const struct of_device_id *of_id;
 109         struct mmio_74xx_gpio_priv *priv;
 110         struct resource *res;
 111         void __iomem *dat;
 112         int err;
 113
 114         of_id = of_match_device(mmio_74xx_gpio_ids, &pdev->dev);
 115         if (!of_id)
 116                 return -ENODEV;
 117
 118         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 119         if (!priv)
 120                 return -ENOMEM;
 121
 122         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 123         dat = devm_ioremap_resource(&pdev->dev, res);
 124         if (IS_ERR(dat))
 125                 return PTR_ERR(dat);
 126
 127         priv->flags = (uintptr_t) of_id->data;
 128
 129         err = bgpio_init(&priv->gc, &pdev->dev,
 130                          DIV_ROUND_UP(MMIO_74XX_BIT_CNT(priv->flags), 8),
 131                          dat, NULL, NULL, NULL, NULL, 0);
 132         if (err)
 133                 return err;
 134
 135         priv->gc.direction_input = mmio_74xx_dir_in;
 136         priv->gc.direction_output = mmio_74xx_dir_out;
 137         priv->gc.get_direction = mmio_74xx_get_direction;
 138         priv->gc.ngpio = MMIO_74XX_BIT_CNT(priv->flags);
 139         priv->gc.owner = THIS_MODULE;
 140
 141         platform_set_drvdata(pdev, priv);
 142
 143         return gpiochip_add_data(&priv->gc, priv);
 144 }
 145
 146 static int mmio_74xx_gpio_remove(struct platform_device *pdev)
 147 {
 148         struct mmio_74xx_gpio_priv *priv = platform_get_drvdata(pdev);
 149
 150         gpiochip_remove(&priv->gc);
 151         return 0;
 152 }
 153
 154 static struct platform_driver mmio_74xx_gpio_driver = {
 155         .driver = {
 156                 .name           = "74xx-mmio-gpio",
 157                 .of_match_table = mmio_74xx_gpio_ids,
 158         },
 159         .probe  = mmio_74xx_gpio_probe,
 160         .remove = mmio_74xx_gpio_remove,
 161 };
 162 module_platform_driver(mmio_74xx_gpio_driver);
 163
 164 MODULE_LICENSE("GPL");
 165 MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
 166 MODULE_DESCRIPTION("74xx MMIO GPIO driver");