Merge branch 'pcmcia' of git://git.kernel.org/pub/scm/linux/kernel/git/brodo/pcmcia
[linux-2.6-microblaze.git] / 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 };
40
41 static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio,
42                              unsigned debounce)
43 {
44         struct men_z127_gpio *priv = gpiochip_get_data(gc);
45         struct device *dev = gc->parent;
46         unsigned int rnd;
47         u32 db_en, db_cnt;
48
49         if (!MEN_Z127_DB_IN_RANGE(debounce)) {
50                 dev_err(dev, "debounce value %u out of range", debounce);
51                 return -EINVAL;
52         }
53
54         if (debounce > 0) {
55                 /* round up or down depending on MSB-1 */
56                 rnd = fls(debounce) - 1;
57
58                 if (rnd && (debounce & BIT(rnd - 1)))
59                         debounce = round_up(debounce, MEN_Z127_DB_MIN_US);
60                 else
61                         debounce = round_down(debounce, MEN_Z127_DB_MIN_US);
62
63                 if (debounce > MEN_Z127_DB_MAX_US)
64                         debounce = MEN_Z127_DB_MAX_US;
65
66                 /* 50us per register unit */
67                 debounce /= 50;
68         }
69
70         spin_lock(&gc->bgpio_lock);
71
72         db_en = readl(priv->reg_base + MEN_Z127_DBER);
73
74         if (debounce == 0) {
75                 db_en &= ~BIT(gpio);
76                 db_cnt = 0;
77         } else {
78                 db_en |= BIT(gpio);
79                 db_cnt = debounce;
80         }
81
82         writel(db_en, priv->reg_base + MEN_Z127_DBER);
83         writel(db_cnt, priv->reg_base + GPIO_TO_DBCNT_REG(gpio));
84
85         spin_unlock(&gc->bgpio_lock);
86
87         return 0;
88 }
89
90 static int men_z127_set_single_ended(struct gpio_chip *gc,
91                                      unsigned offset,
92                                      enum pin_config_param param)
93 {
94         struct men_z127_gpio *priv = gpiochip_get_data(gc);
95         u32 od_en;
96
97         spin_lock(&gc->bgpio_lock);
98         od_en = readl(priv->reg_base + MEN_Z127_ODER);
99
100         if (param == PIN_CONFIG_DRIVE_OPEN_DRAIN)
101                 od_en |= BIT(offset);
102         else
103                 /* Implicitly PIN_CONFIG_DRIVE_PUSH_PULL */
104                 od_en &= ~BIT(offset);
105
106         writel(od_en, priv->reg_base + MEN_Z127_ODER);
107         spin_unlock(&gc->bgpio_lock);
108
109         return 0;
110 }
111
112 static int men_z127_set_config(struct gpio_chip *gc, unsigned offset,
113                                unsigned long config)
114 {
115         enum pin_config_param param = pinconf_to_config_param(config);
116
117         switch (param) {
118         case PIN_CONFIG_DRIVE_OPEN_DRAIN:
119         case PIN_CONFIG_DRIVE_PUSH_PULL:
120                 return men_z127_set_single_ended(gc, offset, param);
121
122         case PIN_CONFIG_INPUT_DEBOUNCE:
123                 return men_z127_debounce(gc, offset,
124                         pinconf_to_config_argument(config));
125
126         default:
127                 break;
128         }
129
130         return -ENOTSUPP;
131 }
132
133 static int men_z127_probe(struct mcb_device *mdev,
134                           const struct mcb_device_id *id)
135 {
136         struct men_z127_gpio *men_z127_gpio;
137         struct device *dev = &mdev->dev;
138         int ret;
139
140         men_z127_gpio = devm_kzalloc(dev, sizeof(struct men_z127_gpio),
141                                      GFP_KERNEL);
142         if (!men_z127_gpio)
143                 return -ENOMEM;
144
145         men_z127_gpio->mem = mcb_request_mem(mdev, dev_name(dev));
146         if (IS_ERR(men_z127_gpio->mem)) {
147                 dev_err(dev, "failed to request device memory");
148                 return PTR_ERR(men_z127_gpio->mem);
149         }
150
151         men_z127_gpio->reg_base = ioremap(men_z127_gpio->mem->start,
152                                           resource_size(men_z127_gpio->mem));
153         if (men_z127_gpio->reg_base == NULL) {
154                 ret = -ENXIO;
155                 goto err_release;
156         }
157
158         mcb_set_drvdata(mdev, men_z127_gpio);
159
160         ret = bgpio_init(&men_z127_gpio->gc, &mdev->dev, 4,
161                          men_z127_gpio->reg_base + MEN_Z127_PSR,
162                          men_z127_gpio->reg_base + MEN_Z127_CTRL,
163                          NULL,
164                          men_z127_gpio->reg_base + MEN_Z127_GPIODR,
165                          NULL, 0);
166         if (ret)
167                 goto err_unmap;
168
169         men_z127_gpio->gc.set_config = men_z127_set_config;
170
171         ret = gpiochip_add_data(&men_z127_gpio->gc, men_z127_gpio);
172         if (ret) {
173                 dev_err(dev, "failed to register MEN 16Z127 GPIO controller");
174                 goto err_unmap;
175         }
176
177         dev_info(dev, "MEN 16Z127 GPIO driver registered");
178
179         return 0;
180
181 err_unmap:
182         iounmap(men_z127_gpio->reg_base);
183 err_release:
184         mcb_release_mem(men_z127_gpio->mem);
185         return ret;
186 }
187
188 static void men_z127_remove(struct mcb_device *mdev)
189 {
190         struct men_z127_gpio *men_z127_gpio = mcb_get_drvdata(mdev);
191
192         gpiochip_remove(&men_z127_gpio->gc);
193         iounmap(men_z127_gpio->reg_base);
194         mcb_release_mem(men_z127_gpio->mem);
195 }
196
197 static const struct mcb_device_id men_z127_ids[] = {
198         { .device = 0x7f },
199         { }
200 };
201 MODULE_DEVICE_TABLE(mcb, men_z127_ids);
202
203 static struct mcb_driver men_z127_driver = {
204         .driver = {
205                 .name = "z127-gpio",
206         },
207         .probe = men_z127_probe,
208         .remove = men_z127_remove,
209         .id_table = men_z127_ids,
210 };
211 module_mcb_driver(men_z127_driver);
212
213 MODULE_AUTHOR("Andreas Werner <andreas.werner@men.de>");
214 MODULE_DESCRIPTION("MEN 16z127 GPIO Controller");
215 MODULE_LICENSE("GPL v2");
216 MODULE_ALIAS("mcb:16z127");