Merge tag 'asoc-v5.2-5' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[sfrench/cifs-2.6.git] / drivers / gpio / gpio-cadence.c
1 // SPDX-License-Identifier: GPL-2.0
2
3 /*
4  * Copyright 2017-2018 Cadence
5  *
6  * Authors:
7  *  Jan Kotas <jank@cadence.com>
8  *  Boris Brezillon <boris.brezillon@free-electrons.com>
9  */
10
11 #include <linux/gpio/driver.h>
12 #include <linux/clk.h>
13 #include <linux/interrupt.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/platform_device.h>
17 #include <linux/spinlock.h>
18
19 #define CDNS_GPIO_BYPASS_MODE           0x00
20 #define CDNS_GPIO_DIRECTION_MODE        0x04
21 #define CDNS_GPIO_OUTPUT_EN             0x08
22 #define CDNS_GPIO_OUTPUT_VALUE          0x0c
23 #define CDNS_GPIO_INPUT_VALUE           0x10
24 #define CDNS_GPIO_IRQ_MASK              0x14
25 #define CDNS_GPIO_IRQ_EN                0x18
26 #define CDNS_GPIO_IRQ_DIS               0x1c
27 #define CDNS_GPIO_IRQ_STATUS            0x20
28 #define CDNS_GPIO_IRQ_TYPE              0x24
29 #define CDNS_GPIO_IRQ_VALUE             0x28
30 #define CDNS_GPIO_IRQ_ANY_EDGE          0x2c
31
32 struct cdns_gpio_chip {
33         struct gpio_chip gc;
34         struct clk *pclk;
35         void __iomem *regs;
36         u32 bypass_orig;
37 };
38
39 static int cdns_gpio_request(struct gpio_chip *chip, unsigned int offset)
40 {
41         struct cdns_gpio_chip *cgpio = gpiochip_get_data(chip);
42         unsigned long flags;
43
44         spin_lock_irqsave(&chip->bgpio_lock, flags);
45
46         iowrite32(ioread32(cgpio->regs + CDNS_GPIO_BYPASS_MODE) & ~BIT(offset),
47                   cgpio->regs + CDNS_GPIO_BYPASS_MODE);
48
49         spin_unlock_irqrestore(&chip->bgpio_lock, flags);
50         return 0;
51 }
52
53 static void cdns_gpio_free(struct gpio_chip *chip, unsigned int offset)
54 {
55         struct cdns_gpio_chip *cgpio = gpiochip_get_data(chip);
56         unsigned long flags;
57
58         spin_lock_irqsave(&chip->bgpio_lock, flags);
59
60         iowrite32(ioread32(cgpio->regs + CDNS_GPIO_BYPASS_MODE) |
61                   (BIT(offset) & cgpio->bypass_orig),
62                   cgpio->regs + CDNS_GPIO_BYPASS_MODE);
63
64         spin_unlock_irqrestore(&chip->bgpio_lock, flags);
65 }
66
67 static void cdns_gpio_irq_mask(struct irq_data *d)
68 {
69         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
70         struct cdns_gpio_chip *cgpio = gpiochip_get_data(chip);
71
72         iowrite32(BIT(d->hwirq), cgpio->regs + CDNS_GPIO_IRQ_DIS);
73 }
74
75 static void cdns_gpio_irq_unmask(struct irq_data *d)
76 {
77         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
78         struct cdns_gpio_chip *cgpio = gpiochip_get_data(chip);
79
80         iowrite32(BIT(d->hwirq), cgpio->regs + CDNS_GPIO_IRQ_EN);
81 }
82
83 static int cdns_gpio_irq_set_type(struct irq_data *d, unsigned int type)
84 {
85         struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
86         struct cdns_gpio_chip *cgpio = gpiochip_get_data(chip);
87         unsigned long flags;
88         u32 int_value;
89         u32 int_type;
90         u32 mask = BIT(d->hwirq);
91         int ret = 0;
92
93         spin_lock_irqsave(&chip->bgpio_lock, flags);
94
95         int_value = ioread32(cgpio->regs + CDNS_GPIO_IRQ_VALUE) & ~mask;
96         int_type = ioread32(cgpio->regs + CDNS_GPIO_IRQ_TYPE) & ~mask;
97
98         /*
99          * The GPIO controller doesn't have an ACK register.
100          * All interrupt statuses are cleared on a status register read.
101          * Don't support edge interrupts for now.
102          */
103
104         if (type == IRQ_TYPE_LEVEL_HIGH) {
105                 int_type |= mask;
106                 int_value |= mask;
107         } else if (type == IRQ_TYPE_LEVEL_LOW) {
108                 int_type |= mask;
109         } else {
110                 ret = -EINVAL;
111                 goto err_irq_type;
112         }
113
114         iowrite32(int_value, cgpio->regs + CDNS_GPIO_IRQ_VALUE);
115         iowrite32(int_type, cgpio->regs + CDNS_GPIO_IRQ_TYPE);
116
117 err_irq_type:
118         spin_unlock_irqrestore(&chip->bgpio_lock, flags);
119         return ret;
120 }
121
122 static void cdns_gpio_irq_handler(struct irq_desc *desc)
123 {
124         struct gpio_chip *chip = irq_desc_get_handler_data(desc);
125         struct cdns_gpio_chip *cgpio = gpiochip_get_data(chip);
126         struct irq_chip *irqchip = irq_desc_get_chip(desc);
127         unsigned long status;
128         int hwirq;
129
130         chained_irq_enter(irqchip, desc);
131
132         status = ioread32(cgpio->regs + CDNS_GPIO_IRQ_STATUS) &
133                 ~ioread32(cgpio->regs + CDNS_GPIO_IRQ_MASK);
134
135         for_each_set_bit(hwirq, &status, chip->ngpio)
136                 generic_handle_irq(irq_find_mapping(chip->irq.domain, hwirq));
137
138         chained_irq_exit(irqchip, desc);
139 }
140
141 static struct irq_chip cdns_gpio_irqchip = {
142         .name           = "cdns-gpio",
143         .irq_mask       = cdns_gpio_irq_mask,
144         .irq_unmask     = cdns_gpio_irq_unmask,
145         .irq_set_type   = cdns_gpio_irq_set_type
146 };
147
148 static int cdns_gpio_probe(struct platform_device *pdev)
149 {
150         struct cdns_gpio_chip *cgpio;
151         struct resource *res;
152         int ret, irq;
153         u32 dir_prev;
154         u32 num_gpios = 32;
155
156         cgpio = devm_kzalloc(&pdev->dev, sizeof(*cgpio), GFP_KERNEL);
157         if (!cgpio)
158                 return -ENOMEM;
159
160         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
161         cgpio->regs = devm_ioremap_resource(&pdev->dev, res);
162         if (IS_ERR(cgpio->regs))
163                 return PTR_ERR(cgpio->regs);
164
165         of_property_read_u32(pdev->dev.of_node, "ngpios", &num_gpios);
166
167         if (num_gpios > 32) {
168                 dev_err(&pdev->dev, "ngpios must be less or equal 32\n");
169                 return -EINVAL;
170         }
171
172         /*
173          * Set all pins as inputs by default, otherwise:
174          * gpiochip_lock_as_irq:
175          * tried to flag a GPIO set as output for IRQ
176          * Generic GPIO driver stores the direction value internally,
177          * so it needs to be changed before bgpio_init() is called.
178          */
179         dir_prev = ioread32(cgpio->regs + CDNS_GPIO_DIRECTION_MODE);
180         iowrite32(GENMASK(num_gpios - 1, 0),
181                   cgpio->regs + CDNS_GPIO_DIRECTION_MODE);
182
183         ret = bgpio_init(&cgpio->gc, &pdev->dev, 4,
184                          cgpio->regs + CDNS_GPIO_INPUT_VALUE,
185                          cgpio->regs + CDNS_GPIO_OUTPUT_VALUE,
186                          NULL,
187                          NULL,
188                          cgpio->regs + CDNS_GPIO_DIRECTION_MODE,
189                          BGPIOF_READ_OUTPUT_REG_SET);
190         if (ret) {
191                 dev_err(&pdev->dev, "Failed to register generic gpio, %d\n",
192                         ret);
193                 goto err_revert_dir;
194         }
195
196         cgpio->gc.label = dev_name(&pdev->dev);
197         cgpio->gc.ngpio = num_gpios;
198         cgpio->gc.parent = &pdev->dev;
199         cgpio->gc.base = -1;
200         cgpio->gc.owner = THIS_MODULE;
201         cgpio->gc.request = cdns_gpio_request;
202         cgpio->gc.free = cdns_gpio_free;
203
204         cgpio->pclk = devm_clk_get(&pdev->dev, NULL);
205         if (IS_ERR(cgpio->pclk)) {
206                 ret = PTR_ERR(cgpio->pclk);
207                 dev_err(&pdev->dev,
208                         "Failed to retrieve peripheral clock, %d\n", ret);
209                 goto err_revert_dir;
210         }
211
212         ret = clk_prepare_enable(cgpio->pclk);
213         if (ret) {
214                 dev_err(&pdev->dev,
215                         "Failed to enable the peripheral clock, %d\n", ret);
216                 goto err_revert_dir;
217         }
218
219         ret = devm_gpiochip_add_data(&pdev->dev, &cgpio->gc, cgpio);
220         if (ret < 0) {
221                 dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
222                 goto err_disable_clk;
223         }
224
225         /*
226          * irq_chip support
227          */
228         irq = platform_get_irq(pdev, 0);
229         if (irq >= 0) {
230                 ret = gpiochip_irqchip_add(&cgpio->gc, &cdns_gpio_irqchip,
231                                            0, handle_level_irq,
232                                            IRQ_TYPE_NONE);
233                 if (ret) {
234                         dev_err(&pdev->dev, "Could not add irqchip, %d\n",
235                                 ret);
236                         goto err_disable_clk;
237                 }
238                 gpiochip_set_chained_irqchip(&cgpio->gc, &cdns_gpio_irqchip,
239                                              irq, cdns_gpio_irq_handler);
240         }
241
242         cgpio->bypass_orig = ioread32(cgpio->regs + CDNS_GPIO_BYPASS_MODE);
243
244         /*
245          * Enable gpio outputs, ignored for input direction
246          */
247         iowrite32(GENMASK(num_gpios - 1, 0),
248                   cgpio->regs + CDNS_GPIO_OUTPUT_EN);
249         iowrite32(0, cgpio->regs + CDNS_GPIO_BYPASS_MODE);
250
251         platform_set_drvdata(pdev, cgpio);
252         return 0;
253
254 err_disable_clk:
255         clk_disable_unprepare(cgpio->pclk);
256
257 err_revert_dir:
258         iowrite32(dir_prev, cgpio->regs + CDNS_GPIO_DIRECTION_MODE);
259
260         return ret;
261 }
262
263 static int cdns_gpio_remove(struct platform_device *pdev)
264 {
265         struct cdns_gpio_chip *cgpio = platform_get_drvdata(pdev);
266
267         iowrite32(cgpio->bypass_orig, cgpio->regs + CDNS_GPIO_BYPASS_MODE);
268         clk_disable_unprepare(cgpio->pclk);
269
270         return 0;
271 }
272
273 static const struct of_device_id cdns_of_ids[] = {
274         { .compatible = "cdns,gpio-r1p02" },
275         { /* sentinel */ },
276 };
277
278 static struct platform_driver cdns_gpio_driver = {
279         .driver = {
280                 .name = "cdns-gpio",
281                 .of_match_table = cdns_of_ids,
282         },
283         .probe = cdns_gpio_probe,
284         .remove = cdns_gpio_remove,
285 };
286 module_platform_driver(cdns_gpio_driver);
287
288 MODULE_AUTHOR("Jan Kotas <jank@cadence.com>");
289 MODULE_DESCRIPTION("Cadence GPIO driver");
290 MODULE_LICENSE("GPL v2");
291 MODULE_ALIAS("platform:cdns-gpio");