drivers/gpio/gpio-kempld.c

   1 /*
   2  * Kontron PLD GPIO driver
   3  *
   4  * Copyright (c) 2010-2013 Kontron Europe GmbH
   5  * Author: Michael Brunner <michael.brunner@kontron.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License 2 as published
   9  * by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/init.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/bitops.h>
  21 #include <linux/errno.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/gpio.h>
  24 #include <linux/mfd/kempld.h>
  25
  26 #define KEMPLD_GPIO_MAX_NUM             16
  27 #define KEMPLD_GPIO_MASK(x)             (1 << ((x) % 8))
  28 #define KEMPLD_GPIO_DIR_NUM(x)          (0x40 + (x) / 8)
  29 #define KEMPLD_GPIO_LVL_NUM(x)          (0x42 + (x) / 8)
  30 #define KEMPLD_GPIO_EVT_LVL_EDGE        0x46
  31 #define KEMPLD_GPIO_IEN                 0x4A
  32
  33 struct kempld_gpio_data {
  34         struct gpio_chip                chip;
  35         struct kempld_device_data       *pld;
  36 };
  37
  38 /*
  39  * Set or clear GPIO bit
  40  * kempld_get_mutex must be called prior to calling this function.
  41  */
  42 static void kempld_gpio_bitop(struct kempld_device_data *pld,
  43                               u8 reg, u8 bit, u8 val)
  44 {
  45         u8 status;
  46
  47         status = kempld_read8(pld, reg);
  48         if (val)
  49                 status |= KEMPLD_GPIO_MASK(bit);
  50         else
  51                 status &= ~KEMPLD_GPIO_MASK(bit);
  52         kempld_write8(pld, reg, status);
  53 }
  54
  55 static int kempld_gpio_get_bit(struct kempld_device_data *pld, u8 reg, u8 bit)
  56 {
  57         u8 status;
  58
  59         kempld_get_mutex(pld);
  60         status = kempld_read8(pld, reg);
  61         kempld_release_mutex(pld);
  62
  63         return !!(status & KEMPLD_GPIO_MASK(bit));
  64 }
  65
  66 static int kempld_gpio_get(struct gpio_chip *chip, unsigned offset)
  67 {
  68         struct kempld_gpio_data *gpio
  69                 = container_of(chip, struct kempld_gpio_data, chip);
  70         struct kempld_device_data *pld = gpio->pld;
  71
  72         return kempld_gpio_get_bit(pld, KEMPLD_GPIO_LVL_NUM(offset), offset);
  73 }
  74
  75 static void kempld_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
  76 {
  77         struct kempld_gpio_data *gpio
  78                 = container_of(chip, struct kempld_gpio_data, chip);
  79         struct kempld_device_data *pld = gpio->pld;
  80
  81         kempld_get_mutex(pld);
  82         kempld_gpio_bitop(pld, KEMPLD_GPIO_LVL_NUM(offset), offset, value);
  83         kempld_release_mutex(pld);
  84 }
  85
  86 static int kempld_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
  87 {
  88         struct kempld_gpio_data *gpio
  89                 = container_of(chip, struct kempld_gpio_data, chip);
  90         struct kempld_device_data *pld = gpio->pld;
  91
  92         kempld_get_mutex(pld);
  93         kempld_gpio_bitop(pld, KEMPLD_GPIO_DIR_NUM(offset), offset, 0);
  94         kempld_release_mutex(pld);
  95
  96         return 0;
  97 }
  98
  99 static int kempld_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
 100                                         int value)
 101 {
 102         struct kempld_gpio_data *gpio
 103                 = container_of(chip, struct kempld_gpio_data, chip);
 104         struct kempld_device_data *pld = gpio->pld;
 105
 106         kempld_get_mutex(pld);
 107         kempld_gpio_bitop(pld, KEMPLD_GPIO_LVL_NUM(offset), offset, value);
 108         kempld_gpio_bitop(pld, KEMPLD_GPIO_DIR_NUM(offset), offset, 1);
 109         kempld_release_mutex(pld);
 110
 111         return 0;
 112 }
 113
 114 static int kempld_gpio_get_direction(struct gpio_chip *chip, unsigned offset)
 115 {
 116         struct kempld_gpio_data *gpio
 117                 = container_of(chip, struct kempld_gpio_data, chip);
 118         struct kempld_device_data *pld = gpio->pld;
 119
 120         return kempld_gpio_get_bit(pld, KEMPLD_GPIO_DIR_NUM(offset), offset);
 121 }
 122
 123 static int kempld_gpio_pincount(struct kempld_device_data *pld)
 124 {
 125         u16 evt, evt_back;
 126
 127         kempld_get_mutex(pld);
 128
 129         /* Backup event register as it might be already initialized */
 130         evt_back = kempld_read16(pld, KEMPLD_GPIO_EVT_LVL_EDGE);
 131         /* Clear event register */
 132         kempld_write16(pld, KEMPLD_GPIO_EVT_LVL_EDGE, 0x0000);
 133         /* Read back event register */
 134         evt = kempld_read16(pld, KEMPLD_GPIO_EVT_LVL_EDGE);
 135         /* Restore event register */
 136         kempld_write16(pld, KEMPLD_GPIO_EVT_LVL_EDGE, evt_back);
 137
 138         kempld_release_mutex(pld);
 139
 140         return evt ? __ffs(evt) : 16;
 141 }
 142
 143 static int kempld_gpio_probe(struct platform_device *pdev)
 144 {
 145         struct device *dev = &pdev->dev;
 146         struct kempld_device_data *pld = dev_get_drvdata(dev->parent);
 147         struct kempld_platform_data *pdata = dev_get_platdata(pld->dev);
 148         struct kempld_gpio_data *gpio;
 149         struct gpio_chip *chip;
 150         int ret;
 151
 152         if (pld->info.spec_major < 2) {
 153                 dev_err(dev,
 154                         "Driver only supports GPIO devices compatible to PLD spec. rev. 2.0 or higher\n");
 155                 return -ENODEV;
 156         }
 157
 158         gpio = devm_kzalloc(dev, sizeof(*gpio), GFP_KERNEL);
 159         if (gpio == NULL)
 160                 return -ENOMEM;
 161
 162         gpio->pld = pld;
 163
 164         platform_set_drvdata(pdev, gpio);
 165
 166         chip = &gpio->chip;
 167         chip->label = "gpio-kempld";
 168         chip->owner = THIS_MODULE;
 169         chip->dev = dev;
 170         chip->can_sleep = true;
 171         if (pdata && pdata->gpio_base)
 172                 chip->base = pdata->gpio_base;
 173         else
 174                 chip->base = -1;
 175         chip->direction_input = kempld_gpio_direction_input;
 176         chip->direction_output = kempld_gpio_direction_output;
 177         chip->get_direction = kempld_gpio_get_direction;
 178         chip->get = kempld_gpio_get;
 179         chip->set = kempld_gpio_set;
 180         chip->ngpio = kempld_gpio_pincount(pld);
 181         if (chip->ngpio == 0) {
 182                 dev_err(dev, "No GPIO pins detected\n");
 183                 return -ENODEV;
 184         }
 185
 186         ret = gpiochip_add(chip);
 187         if (ret) {
 188                 dev_err(dev, "Could not register GPIO chip\n");
 189                 return ret;
 190         }
 191
 192         dev_info(dev, "GPIO functionality initialized with %d pins\n",
 193                  chip->ngpio);
 194
 195         return 0;
 196 }
 197
 198 static int kempld_gpio_remove(struct platform_device *pdev)
 199 {
 200         struct kempld_gpio_data *gpio = platform_get_drvdata(pdev);
 201
 202         return gpiochip_remove(&gpio->chip);
 203 }
 204
 205 static struct platform_driver kempld_gpio_driver = {
 206         .driver = {
 207                 .name = "kempld-gpio",
 208                 .owner = THIS_MODULE,
 209         },
 210         .probe          = kempld_gpio_probe,
 211         .remove         = kempld_gpio_remove,
 212 };
 213
 214 module_platform_driver(kempld_gpio_driver);
 215
 216 MODULE_DESCRIPTION("KEM PLD GPIO Driver");
 217 MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>");
 218 MODULE_LICENSE("GPL");
 219 MODULE_ALIAS("platform:gpio-kempld");