drivers/gpio/gpio-menz127.c

   1 /*
   2  * MEN 16Z127 GPIO driver
   3  *
   4  * Copyright (C) 2016 MEN Mikroelektronik GmbH (www.men.de)
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; version 2 of the License.
   9  */
  10
  11 #include <linux/kernel.h>
  12 #include <linux/module.h>
  13 #include <linux/io.h>
  14 #include <linux/err.h>
  15 #include <linux/mcb.h>
  16 #include <linux/bitops.h>
  17 #include <linux/gpio/driver.h>
  18
  19 #define MEN_Z127_CTRL   0x00
  20 #define MEN_Z127_PSR    0x04
  21 #define MEN_Z127_IRQR   0x08
  22 #define MEN_Z127_GPIODR 0x0c
  23 #define MEN_Z127_IER1   0x10
  24 #define MEN_Z127_IER2   0x14
  25 #define MEN_Z127_DBER   0x18
  26 #define MEN_Z127_ODER   0x1C
  27 #define GPIO_TO_DBCNT_REG(gpio) ((gpio * 4) + 0x80)
  28
  29 #define MEN_Z127_DB_MIN_US      50
  30 /* 16 bit compare register. Each bit represents 50us */
  31 #define MEN_Z127_DB_MAX_US      (0xffff * MEN_Z127_DB_MIN_US)
  32 #define MEN_Z127_DB_IN_RANGE(db)        ((db >= MEN_Z127_DB_MIN_US) && \
  33                                          (db <= MEN_Z127_DB_MAX_US))
  34
  35 struct men_z127_gpio {
  36         struct gpio_chip gc;
  37         void __iomem *reg_base;
  38         struct resource *mem;
  39         spinlock_t lock;
  40 };
  41
  42 static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio,
  43                              unsigned debounce)
  44 {
  45         struct men_z127_gpio *priv = gpiochip_get_data(gc);
  46         struct device *dev = gc->parent;
  47         unsigned int rnd;
  48         u32 db_en, db_cnt;
  49
  50         if (!MEN_Z127_DB_IN_RANGE(debounce)) {
  51                 dev_err(dev, "debounce value %u out of range", debounce);
  52                 return -EINVAL;
  53         }
  54
  55         if (debounce > 0) {
  56                 /* round up or down depending on MSB-1 */
  57                 rnd = fls(debounce) - 1;
  58
  59                 if (rnd && (debounce & BIT(rnd - 1)))
  60                         debounce = round_up(debounce, MEN_Z127_DB_MIN_US);
  61                 else
  62                         debounce = round_down(debounce, MEN_Z127_DB_MIN_US);
  63
  64                 if (debounce > MEN_Z127_DB_MAX_US)
  65                         debounce = MEN_Z127_DB_MAX_US;
  66
  67                 /* 50us per register unit */
  68                 debounce /= 50;
  69         }
  70
  71         spin_lock(&priv->lock);
  72
  73         db_en = readl(priv->reg_base + MEN_Z127_DBER);
  74
  75         if (debounce == 0) {
  76                 db_en &= ~BIT(gpio);
  77                 db_cnt = 0;
  78         } else {
  79                 db_en |= BIT(gpio);
  80                 db_cnt = debounce;
  81         }
  82
  83         writel(db_en, priv->reg_base + MEN_Z127_DBER);
  84         writel(db_cnt, priv->reg_base + GPIO_TO_DBCNT_REG(gpio));
  85
  86         spin_unlock(&priv->lock);
  87
  88         return 0;
  89 }
  90
  91 static int men_z127_set_single_ended(struct gpio_chip *gc,
  92                                      unsigned offset,
  93                                      enum single_ended_mode mode)
  94 {
  95         struct men_z127_gpio *priv = gpiochip_get_data(gc);
  96         u32 od_en;
  97
  98         if (mode != LINE_MODE_OPEN_DRAIN &&
  99             mode != LINE_MODE_PUSH_PULL)
 100                 return -ENOTSUPP;
 101
 102         spin_lock(&priv->lock);
 103         od_en = readl(priv->reg_base + MEN_Z127_ODER);
 104
 105         if (mode == LINE_MODE_OPEN_DRAIN)
 106                 od_en |= BIT(offset);
 107         else
 108                 /* Implicitly LINE_MODE_PUSH_PULL */
 109                 od_en &= ~BIT(offset);
 110
 111         writel(od_en, priv->reg_base + MEN_Z127_ODER);
 112         spin_unlock(&priv->lock);
 113
 114         return 0;
 115 }
 116
 117 static int men_z127_probe(struct mcb_device *mdev,
 118                           const struct mcb_device_id *id)
 119 {
 120         struct men_z127_gpio *men_z127_gpio;
 121         struct device *dev = &mdev->dev;
 122         int ret;
 123
 124         men_z127_gpio = devm_kzalloc(dev, sizeof(struct men_z127_gpio),
 125                                      GFP_KERNEL);
 126         if (!men_z127_gpio)
 127                 return -ENOMEM;
 128
 129         men_z127_gpio->mem = mcb_request_mem(mdev, dev_name(dev));
 130         if (IS_ERR(men_z127_gpio->mem)) {
 131                 dev_err(dev, "failed to request device memory");
 132                 return PTR_ERR(men_z127_gpio->mem);
 133         }
 134
 135         men_z127_gpio->reg_base = ioremap(men_z127_gpio->mem->start,
 136                                           resource_size(men_z127_gpio->mem));
 137         if (men_z127_gpio->reg_base == NULL) {
 138                 ret = -ENXIO;
 139                 goto err_release;
 140         }
 141
 142         mcb_set_drvdata(mdev, men_z127_gpio);
 143
 144         ret = bgpio_init(&men_z127_gpio->gc, &mdev->dev, 4,
 145                          men_z127_gpio->reg_base + MEN_Z127_PSR,
 146                          men_z127_gpio->reg_base + MEN_Z127_CTRL,
 147                          NULL,
 148                          men_z127_gpio->reg_base + MEN_Z127_GPIODR,
 149                          NULL, 0);
 150         if (ret)
 151                 goto err_unmap;
 152
 153         men_z127_gpio->gc.set_debounce = men_z127_debounce;
 154         men_z127_gpio->gc.set_single_ended = men_z127_set_single_ended;
 155
 156         ret = gpiochip_add_data(&men_z127_gpio->gc, men_z127_gpio);
 157         if (ret) {
 158                 dev_err(dev, "failed to register MEN 16Z127 GPIO controller");
 159                 goto err_unmap;
 160         }
 161
 162         dev_info(dev, "MEN 16Z127 GPIO driver registered");
 163
 164         return 0;
 165
 166 err_unmap:
 167         iounmap(men_z127_gpio->reg_base);
 168 err_release:
 169         mcb_release_mem(men_z127_gpio->mem);
 170         return ret;
 171 }
 172
 173 static void men_z127_remove(struct mcb_device *mdev)
 174 {
 175         struct men_z127_gpio *men_z127_gpio = mcb_get_drvdata(mdev);
 176
 177         gpiochip_remove(&men_z127_gpio->gc);
 178         iounmap(men_z127_gpio->reg_base);
 179         mcb_release_mem(men_z127_gpio->mem);
 180 }
 181
 182 static const struct mcb_device_id men_z127_ids[] = {
 183         { .device = 0x7f },
 184         { }
 185 };
 186 MODULE_DEVICE_TABLE(mcb, men_z127_ids);
 187
 188 static struct mcb_driver men_z127_driver = {
 189         .driver = {
 190                 .name = "z127-gpio",
 191                 .owner = THIS_MODULE,
 192         },
 193         .probe = men_z127_probe,
 194         .remove = men_z127_remove,
 195         .id_table = men_z127_ids,
 196 };
 197 module_mcb_driver(men_z127_driver);
 198
 199 MODULE_AUTHOR("Andreas Werner <andreas.werner@men.de>");
 200 MODULE_DESCRIPTION("MEN 16z127 GPIO Controller");
 201 MODULE_LICENSE("GPL v2");
 202 MODULE_ALIAS("mcb:16z127");