blob: 13d6a50ca96c49a8b3ce1f55e4324184b105ff31 [file] [log] [blame]
Thomas Abraham43b169d2012-09-07 06:07:19 +09001/*
2 * Exynos specific support for Samsung pinctrl/gpiolib driver with eint support.
3 *
4 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com
6 * Copyright (c) 2012 Linaro Ltd
7 * http://www.linaro.org
8 *
9 * Author: Thomas Abraham <thomas.ab@samsung.com>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This file contains the Samsung Exynos specific information required by the
17 * the Samsung pinctrl/gpiolib driver. It also includes the implementation of
18 * external gpio and wakeup interrupt support.
19 */
20
Thomas Abraham43b169d2012-09-07 06:07:19 +090021#include <linux/device.h>
22#include <linux/interrupt.h>
23#include <linux/irqdomain.h>
24#include <linux/irq.h>
Catalin Marinasde88cbb2013-01-18 15:31:37 +000025#include <linux/irqchip/chained_irq.h>
Krzysztof Kozlowskicfa76dd2017-05-16 20:56:27 +020026#include <linux/of.h>
Thomas Abraham43b169d2012-09-07 06:07:19 +090027#include <linux/of_irq.h>
Thomas Abraham43b169d2012-09-07 06:07:19 +090028#include <linux/slab.h>
Tomasz Figa19846952013-03-18 22:31:50 +010029#include <linux/spinlock.h>
Marek Szyprowski07731012017-01-26 10:29:25 +010030#include <linux/regmap.h>
Thomas Abraham43b169d2012-09-07 06:07:19 +090031#include <linux/err.h>
Marek Szyprowski07731012017-01-26 10:29:25 +010032#include <linux/soc/samsung/exynos-pmu.h>
Thomas Abraham43b169d2012-09-07 06:07:19 +090033
Krzysztof Kozlowski4460dc22017-06-15 17:06:28 +020034#include <dt-bindings/pinctrl/samsung.h>
35
Thomas Abraham43b169d2012-09-07 06:07:19 +090036#include "pinctrl-samsung.h"
37#include "pinctrl-exynos.h"
38
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020039struct exynos_irq_chip {
40 struct irq_chip chip;
41
42 u32 eint_con;
43 u32 eint_mask;
44 u32 eint_pend;
45};
46
47static inline struct exynos_irq_chip *to_exynos_irq_chip(struct irq_chip *chip)
48{
49 return container_of(chip, struct exynos_irq_chip, chip);
50}
Tomasz Figa499147c2013-03-18 22:31:52 +010051
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020052static void exynos_irq_mask(struct irq_data *irqd)
Thomas Abraham43b169d2012-09-07 06:07:19 +090053{
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020054 struct irq_chip *chip = irq_data_get_irq_chip(irqd);
55 struct exynos_irq_chip *our_chip = to_exynos_irq_chip(chip);
Tomasz Figa595be722012-10-11 10:11:16 +020056 struct samsung_pin_bank *bank = irq_data_get_irq_chip_data(irqd);
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020057 unsigned long reg_mask = our_chip->eint_mask + bank->eint_offset;
Krzysztof Kozlowskid0fffdb2021-04-08 21:50:29 +020058 unsigned int mask;
Doug Anderson5ae8cf72013-06-12 10:33:17 -070059 unsigned long flags;
60
61 spin_lock_irqsave(&bank->slock, flags);
Thomas Abraham43b169d2012-09-07 06:07:19 +090062
Chanwoo Choi8b1bd112016-11-09 17:40:10 +090063 mask = readl(bank->eint_base + reg_mask);
Tomasz Figa595be722012-10-11 10:11:16 +020064 mask |= 1 << irqd->hwirq;
Chanwoo Choi8b1bd112016-11-09 17:40:10 +090065 writel(mask, bank->eint_base + reg_mask);
Doug Anderson5ae8cf72013-06-12 10:33:17 -070066
67 spin_unlock_irqrestore(&bank->slock, flags);
Thomas Abraham43b169d2012-09-07 06:07:19 +090068}
69
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020070static void exynos_irq_ack(struct irq_data *irqd)
Thomas Abraham43b169d2012-09-07 06:07:19 +090071{
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020072 struct irq_chip *chip = irq_data_get_irq_chip(irqd);
73 struct exynos_irq_chip *our_chip = to_exynos_irq_chip(chip);
Tomasz Figa595be722012-10-11 10:11:16 +020074 struct samsung_pin_bank *bank = irq_data_get_irq_chip_data(irqd);
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020075 unsigned long reg_pend = our_chip->eint_pend + bank->eint_offset;
Thomas Abraham43b169d2012-09-07 06:07:19 +090076
Chanwoo Choi8b1bd112016-11-09 17:40:10 +090077 writel(1 << irqd->hwirq, bank->eint_base + reg_pend);
Thomas Abraham43b169d2012-09-07 06:07:19 +090078}
79
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020080static void exynos_irq_unmask(struct irq_data *irqd)
Doug Anderson5ace03f2013-06-12 10:33:18 -070081{
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020082 struct irq_chip *chip = irq_data_get_irq_chip(irqd);
83 struct exynos_irq_chip *our_chip = to_exynos_irq_chip(chip);
Doug Anderson5ace03f2013-06-12 10:33:18 -070084 struct samsung_pin_bank *bank = irq_data_get_irq_chip_data(irqd);
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020085 unsigned long reg_mask = our_chip->eint_mask + bank->eint_offset;
Krzysztof Kozlowskid0fffdb2021-04-08 21:50:29 +020086 unsigned int mask;
Doug Anderson5ace03f2013-06-12 10:33:18 -070087 unsigned long flags;
88
Doug Anderson5a68e7a2013-06-17 09:50:43 -070089 /*
90 * Ack level interrupts right before unmask
91 *
92 * If we don't do this we'll get a double-interrupt. Level triggered
93 * interrupts must not fire an interrupt if the level is not
94 * _currently_ active, even if it was active while the interrupt was
95 * masked.
96 */
97 if (irqd_get_trigger_type(irqd) & IRQ_TYPE_LEVEL_MASK)
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +020098 exynos_irq_ack(irqd);
Doug Anderson5a68e7a2013-06-17 09:50:43 -070099
Doug Anderson5ace03f2013-06-12 10:33:18 -0700100 spin_lock_irqsave(&bank->slock, flags);
101
Chanwoo Choi8b1bd112016-11-09 17:40:10 +0900102 mask = readl(bank->eint_base + reg_mask);
Doug Anderson5ace03f2013-06-12 10:33:18 -0700103 mask &= ~(1 << irqd->hwirq);
Chanwoo Choi8b1bd112016-11-09 17:40:10 +0900104 writel(mask, bank->eint_base + reg_mask);
Doug Anderson5ace03f2013-06-12 10:33:18 -0700105
106 spin_unlock_irqrestore(&bank->slock, flags);
107}
108
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200109static int exynos_irq_set_type(struct irq_data *irqd, unsigned int type)
Thomas Abraham43b169d2012-09-07 06:07:19 +0900110{
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200111 struct irq_chip *chip = irq_data_get_irq_chip(irqd);
112 struct exynos_irq_chip *our_chip = to_exynos_irq_chip(chip);
Tomasz Figa595be722012-10-11 10:11:16 +0200113 struct samsung_pin_bank *bank = irq_data_get_irq_chip_data(irqd);
Tomasz Figaf6a82492014-08-09 01:48:05 +0200114 unsigned int shift = EXYNOS_EINT_CON_LEN * irqd->hwirq;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900115 unsigned int con, trig_type;
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200116 unsigned long reg_con = our_chip->eint_con + bank->eint_offset;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900117
118 switch (type) {
119 case IRQ_TYPE_EDGE_RISING:
120 trig_type = EXYNOS_EINT_EDGE_RISING;
121 break;
122 case IRQ_TYPE_EDGE_FALLING:
123 trig_type = EXYNOS_EINT_EDGE_FALLING;
124 break;
125 case IRQ_TYPE_EDGE_BOTH:
126 trig_type = EXYNOS_EINT_EDGE_BOTH;
127 break;
128 case IRQ_TYPE_LEVEL_HIGH:
129 trig_type = EXYNOS_EINT_LEVEL_HIGH;
130 break;
131 case IRQ_TYPE_LEVEL_LOW:
132 trig_type = EXYNOS_EINT_LEVEL_LOW;
133 break;
134 default:
135 pr_err("unsupported external interrupt type\n");
136 return -EINVAL;
137 }
138
139 if (type & IRQ_TYPE_EDGE_BOTH)
Thomas Gleixner40ec1682015-06-23 15:52:57 +0200140 irq_set_handler_locked(irqd, handle_edge_irq);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900141 else
Thomas Gleixner40ec1682015-06-23 15:52:57 +0200142 irq_set_handler_locked(irqd, handle_level_irq);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900143
Chanwoo Choi8b1bd112016-11-09 17:40:10 +0900144 con = readl(bank->eint_base + reg_con);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900145 con &= ~(EXYNOS_EINT_CON_MASK << shift);
146 con |= trig_type << shift;
Chanwoo Choi8b1bd112016-11-09 17:40:10 +0900147 writel(con, bank->eint_base + reg_con);
Tomasz Figaee2f5732012-09-21 07:33:48 +0900148
Tomasz Figaf6a82492014-08-09 01:48:05 +0200149 return 0;
150}
151
152static int exynos_irq_request_resources(struct irq_data *irqd)
153{
Tomasz Figaf6a82492014-08-09 01:48:05 +0200154 struct samsung_pin_bank *bank = irq_data_get_irq_chip_data(irqd);
Tomasz Figa94ce9442014-09-23 21:05:39 +0200155 const struct samsung_pin_bank_type *bank_type = bank->type;
Krzysztof Kozlowskibbed85f2017-07-18 19:43:28 +0200156 unsigned long reg_con, flags;
157 unsigned int shift, mask, con;
Tomasz Figaf6a82492014-08-09 01:48:05 +0200158 int ret;
159
Alexandre Courbote3a2e872014-10-23 17:27:07 +0900160 ret = gpiochip_lock_as_irq(&bank->gpio_chip, irqd->hwirq);
Tomasz Figaf6a82492014-08-09 01:48:05 +0200161 if (ret) {
Linus Walleij58383c72015-11-04 09:56:26 +0100162 dev_err(bank->gpio_chip.parent,
163 "unable to lock pin %s-%lu IRQ\n",
Tomasz Figaf6a82492014-08-09 01:48:05 +0200164 bank->name, irqd->hwirq);
165 return ret;
166 }
167
Tomasz Figa43fc9e72013-03-18 22:31:53 +0100168 reg_con = bank->pctl_offset + bank_type->reg_offset[PINCFG_TYPE_FUNC];
Tomasz Figaf6a82492014-08-09 01:48:05 +0200169 shift = irqd->hwirq * bank_type->fld_width[PINCFG_TYPE_FUNC];
Tomasz Figa499147c2013-03-18 22:31:52 +0100170 mask = (1 << bank_type->fld_width[PINCFG_TYPE_FUNC]) - 1;
Tomasz Figaee2f5732012-09-21 07:33:48 +0900171
Tomasz Figa19846952013-03-18 22:31:50 +0100172 spin_lock_irqsave(&bank->slock, flags);
173
Krzysztof Kozlowskiaf0b0ba2017-06-14 15:18:28 +0200174 con = readl(bank->pctl_base + reg_con);
Tomasz Figaee2f5732012-09-21 07:33:48 +0900175 con &= ~(mask << shift);
Krzysztof Kozlowski4460dc22017-06-15 17:06:28 +0200176 con |= EXYNOS_PIN_FUNC_EINT << shift;
Krzysztof Kozlowskiaf0b0ba2017-06-14 15:18:28 +0200177 writel(con, bank->pctl_base + reg_con);
Tomasz Figaee2f5732012-09-21 07:33:48 +0900178
Tomasz Figa19846952013-03-18 22:31:50 +0100179 spin_unlock_irqrestore(&bank->slock, flags);
180
Thomas Abraham43b169d2012-09-07 06:07:19 +0900181 return 0;
182}
183
Tomasz Figaf6a82492014-08-09 01:48:05 +0200184static void exynos_irq_release_resources(struct irq_data *irqd)
185{
Tomasz Figaf6a82492014-08-09 01:48:05 +0200186 struct samsung_pin_bank *bank = irq_data_get_irq_chip_data(irqd);
Tomasz Figa94ce9442014-09-23 21:05:39 +0200187 const struct samsung_pin_bank_type *bank_type = bank->type;
Krzysztof Kozlowskibbed85f2017-07-18 19:43:28 +0200188 unsigned long reg_con, flags;
189 unsigned int shift, mask, con;
Tomasz Figaf6a82492014-08-09 01:48:05 +0200190
191 reg_con = bank->pctl_offset + bank_type->reg_offset[PINCFG_TYPE_FUNC];
192 shift = irqd->hwirq * bank_type->fld_width[PINCFG_TYPE_FUNC];
193 mask = (1 << bank_type->fld_width[PINCFG_TYPE_FUNC]) - 1;
194
Tomasz Figaf6a82492014-08-09 01:48:05 +0200195 spin_lock_irqsave(&bank->slock, flags);
196
Krzysztof Kozlowskiaf0b0ba2017-06-14 15:18:28 +0200197 con = readl(bank->pctl_base + reg_con);
Tomasz Figaf6a82492014-08-09 01:48:05 +0200198 con &= ~(mask << shift);
Krzysztof Kozlowski4460dc22017-06-15 17:06:28 +0200199 con |= EXYNOS_PIN_FUNC_INPUT << shift;
Krzysztof Kozlowskiaf0b0ba2017-06-14 15:18:28 +0200200 writel(con, bank->pctl_base + reg_con);
Tomasz Figaf6a82492014-08-09 01:48:05 +0200201
202 spin_unlock_irqrestore(&bank->slock, flags);
203
Alexandre Courbote3a2e872014-10-23 17:27:07 +0900204 gpiochip_unlock_as_irq(&bank->gpio_chip, irqd->hwirq);
Tomasz Figaf6a82492014-08-09 01:48:05 +0200205}
206
Thomas Abraham43b169d2012-09-07 06:07:19 +0900207/*
208 * irq_chip for gpio interrupts.
209 */
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200210static struct exynos_irq_chip exynos_gpio_irq_chip = {
211 .chip = {
212 .name = "exynos_gpio_irq_chip",
213 .irq_unmask = exynos_irq_unmask,
214 .irq_mask = exynos_irq_mask,
215 .irq_ack = exynos_irq_ack,
216 .irq_set_type = exynos_irq_set_type,
Tomasz Figaf6a82492014-08-09 01:48:05 +0200217 .irq_request_resources = exynos_irq_request_resources,
218 .irq_release_resources = exynos_irq_release_resources,
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200219 },
220 .eint_con = EXYNOS_GPIO_ECON_OFFSET,
221 .eint_mask = EXYNOS_GPIO_EMASK_OFFSET,
222 .eint_pend = EXYNOS_GPIO_EPEND_OFFSET,
Thomas Abraham43b169d2012-09-07 06:07:19 +0900223};
224
Abhilash Kesavan6f5e41b2014-10-09 19:24:30 +0530225static int exynos_eint_irq_map(struct irq_domain *h, unsigned int virq,
Thomas Abraham43b169d2012-09-07 06:07:19 +0900226 irq_hw_number_t hw)
227{
Tomasz Figa595be722012-10-11 10:11:16 +0200228 struct samsung_pin_bank *b = h->host_data;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900229
Tomasz Figa595be722012-10-11 10:11:16 +0200230 irq_set_chip_data(virq, b);
Abhilash Kesavan0d3d30d2014-10-09 19:24:29 +0530231 irq_set_chip_and_handler(virq, &b->irq_chip->chip,
Thomas Abraham43b169d2012-09-07 06:07:19 +0900232 handle_level_irq);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900233 return 0;
234}
235
Thomas Abraham43b169d2012-09-07 06:07:19 +0900236/*
Abhilash Kesavan6f5e41b2014-10-09 19:24:30 +0530237 * irq domain callbacks for external gpio and wakeup interrupt controllers.
Thomas Abraham43b169d2012-09-07 06:07:19 +0900238 */
Abhilash Kesavan6f5e41b2014-10-09 19:24:30 +0530239static const struct irq_domain_ops exynos_eint_irqd_ops = {
240 .map = exynos_eint_irq_map,
Thomas Abraham43b169d2012-09-07 06:07:19 +0900241 .xlate = irq_domain_xlate_twocell,
242};
243
244static irqreturn_t exynos_eint_gpio_irq(int irq, void *data)
245{
246 struct samsung_pinctrl_drv_data *d = data;
Tomasz Figa1bf00d72014-09-23 21:05:40 +0200247 struct samsung_pin_bank *bank = d->pin_banks;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900248 unsigned int svc, group, pin, virq;
249
Chanwoo Choi8b1bd112016-11-09 17:40:10 +0900250 svc = readl(bank->eint_base + EXYNOS_SVC_OFFSET);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900251 group = EXYNOS_SVC_GROUP(svc);
252 pin = svc & EXYNOS_SVC_NUM_MASK;
253
254 if (!group)
255 return IRQ_HANDLED;
256 bank += (group - 1);
257
Tomasz Figa595be722012-10-11 10:11:16 +0200258 virq = irq_linear_revmap(bank->irq_domain, pin);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900259 if (!virq)
260 return IRQ_NONE;
261 generic_handle_irq(virq);
262 return IRQ_HANDLED;
263}
264
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200265struct exynos_eint_gpio_save {
266 u32 eint_con;
267 u32 eint_fltcon0;
268 u32 eint_fltcon1;
Jonathan Bakkeracac3382020-04-25 16:10:46 -0700269 u32 eint_mask;
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200270};
271
Thomas Abraham43b169d2012-09-07 06:07:19 +0900272/*
273 * exynos_eint_gpio_init() - setup handling of external gpio interrupts.
274 * @d: driver data of samsung pinctrl driver.
275 */
Krzysztof Kozlowskicfa76dd2017-05-16 20:56:27 +0200276int exynos_eint_gpio_init(struct samsung_pinctrl_drv_data *d)
Thomas Abraham43b169d2012-09-07 06:07:19 +0900277{
Tomasz Figa595be722012-10-11 10:11:16 +0200278 struct samsung_pin_bank *bank;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900279 struct device *dev = d->dev;
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200280 int ret;
281 int i;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900282
283 if (!d->irq) {
284 dev_err(dev, "irq number not available\n");
285 return -EINVAL;
286 }
287
288 ret = devm_request_irq(dev, d->irq, exynos_eint_gpio_irq,
289 0, dev_name(dev), d);
290 if (ret) {
291 dev_err(dev, "irq request failed\n");
292 return -ENXIO;
293 }
294
Tomasz Figa1bf00d72014-09-23 21:05:40 +0200295 bank = d->pin_banks;
296 for (i = 0; i < d->nr_banks; ++i, ++bank) {
Tomasz Figa595be722012-10-11 10:11:16 +0200297 if (bank->eint_type != EINT_TYPE_GPIO)
298 continue;
299 bank->irq_domain = irq_domain_add_linear(bank->of_node,
Abhilash Kesavan6f5e41b2014-10-09 19:24:30 +0530300 bank->nr_pins, &exynos_eint_irqd_ops, bank);
Tomasz Figa595be722012-10-11 10:11:16 +0200301 if (!bank->irq_domain) {
302 dev_err(dev, "gpio irq domain add failed\n");
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200303 ret = -ENXIO;
304 goto err_domains;
305 }
306
307 bank->soc_priv = devm_kzalloc(d->dev,
308 sizeof(struct exynos_eint_gpio_save), GFP_KERNEL);
309 if (!bank->soc_priv) {
310 irq_domain_remove(bank->irq_domain);
311 ret = -ENOMEM;
312 goto err_domains;
Tomasz Figa595be722012-10-11 10:11:16 +0200313 }
Abhilash Kesavan0d3d30d2014-10-09 19:24:29 +0530314
315 bank->irq_chip = &exynos_gpio_irq_chip;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900316 }
317
318 return 0;
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200319
320err_domains:
321 for (--i, --bank; i >= 0; --i, --bank) {
322 if (bank->eint_type != EINT_TYPE_GPIO)
323 continue;
324 irq_domain_remove(bank->irq_domain);
325 }
326
327 return ret;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900328}
329
Tomasz Figaad350cd2013-05-17 18:24:27 +0200330static u32 exynos_eint_wake_mask = 0xffffffff;
331
332u32 exynos_get_eint_wake_mask(void)
333{
334 return exynos_eint_wake_mask;
335}
336
337static int exynos_wkup_irq_set_wake(struct irq_data *irqd, unsigned int on)
338{
339 struct samsung_pin_bank *bank = irq_data_get_irq_chip_data(irqd);
340 unsigned long bit = 1UL << (2 * bank->eint_offset + irqd->hwirq);
341
342 pr_info("wake %s for irq %d\n", on ? "enabled" : "disabled", irqd->irq);
343
344 if (!on)
345 exynos_eint_wake_mask |= bit;
346 else
347 exynos_eint_wake_mask &= ~bit;
348
349 return 0;
350}
351
Thomas Abraham43b169d2012-09-07 06:07:19 +0900352/*
353 * irq_chip for wakeup interrupts
354 */
Krzysztof Kozlowski71b96c32017-05-23 20:41:39 +0200355static const struct exynos_irq_chip exynos4210_wkup_irq_chip __initconst = {
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200356 .chip = {
Abhilash Kesavan14c255d2014-10-09 19:24:31 +0530357 .name = "exynos4210_wkup_irq_chip",
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200358 .irq_unmask = exynos_irq_unmask,
359 .irq_mask = exynos_irq_mask,
360 .irq_ack = exynos_irq_ack,
361 .irq_set_type = exynos_irq_set_type,
362 .irq_set_wake = exynos_wkup_irq_set_wake,
Tomasz Figaf6a82492014-08-09 01:48:05 +0200363 .irq_request_resources = exynos_irq_request_resources,
364 .irq_release_resources = exynos_irq_release_resources,
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200365 },
366 .eint_con = EXYNOS_WKUP_ECON_OFFSET,
367 .eint_mask = EXYNOS_WKUP_EMASK_OFFSET,
368 .eint_pend = EXYNOS_WKUP_EPEND_OFFSET,
Thomas Abraham43b169d2012-09-07 06:07:19 +0900369};
370
Krzysztof Kozlowski71b96c32017-05-23 20:41:39 +0200371static const struct exynos_irq_chip exynos7_wkup_irq_chip __initconst = {
Abhilash Kesavan14c255d2014-10-09 19:24:31 +0530372 .chip = {
373 .name = "exynos7_wkup_irq_chip",
374 .irq_unmask = exynos_irq_unmask,
375 .irq_mask = exynos_irq_mask,
376 .irq_ack = exynos_irq_ack,
377 .irq_set_type = exynos_irq_set_type,
378 .irq_set_wake = exynos_wkup_irq_set_wake,
379 .irq_request_resources = exynos_irq_request_resources,
380 .irq_release_resources = exynos_irq_release_resources,
381 },
382 .eint_con = EXYNOS7_WKUP_ECON_OFFSET,
383 .eint_mask = EXYNOS7_WKUP_EMASK_OFFSET,
384 .eint_pend = EXYNOS7_WKUP_EPEND_OFFSET,
385};
386
387/* list of external wakeup controllers supported */
388static const struct of_device_id exynos_wkup_irq_ids[] = {
389 { .compatible = "samsung,exynos4210-wakeup-eint",
390 .data = &exynos4210_wkup_irq_chip },
391 { .compatible = "samsung,exynos7-wakeup-eint",
392 .data = &exynos7_wkup_irq_chip },
393 { }
394};
395
Thomas Abraham43b169d2012-09-07 06:07:19 +0900396/* interrupt handler for wakeup interrupts 0..15 */
Thomas Gleixnerbd0b9ac2015-09-14 10:42:37 +0200397static void exynos_irq_eint0_15(struct irq_desc *desc)
Thomas Abraham43b169d2012-09-07 06:07:19 +0900398{
Jiang Liu5663bb22015-06-04 12:13:16 +0800399 struct exynos_weint_data *eintd = irq_desc_get_handler_data(desc);
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200400 struct samsung_pin_bank *bank = eintd->bank;
Jiang Liu5663bb22015-06-04 12:13:16 +0800401 struct irq_chip *chip = irq_desc_get_chip(desc);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900402 int eint_irq;
403
404 chained_irq_enter(chip, desc);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900405
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200406 eint_irq = irq_linear_revmap(bank->irq_domain, eintd->irq);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900407 generic_handle_irq(eint_irq);
perr perr26fecf02016-08-16 18:45:29 +0800408
Thomas Abraham43b169d2012-09-07 06:07:19 +0900409 chained_irq_exit(chip, desc);
410}
411
Krzysztof Kozlowskid0fffdb2021-04-08 21:50:29 +0200412static inline void exynos_irq_demux_eint(unsigned int pend,
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200413 struct irq_domain *domain)
Thomas Abraham43b169d2012-09-07 06:07:19 +0900414{
415 unsigned int irq;
416
417 while (pend) {
418 irq = fls(pend) - 1;
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200419 generic_handle_irq(irq_find_mapping(domain, irq));
Thomas Abraham43b169d2012-09-07 06:07:19 +0900420 pend &= ~(1 << irq);
421 }
422}
423
424/* interrupt handler for wakeup interrupt 16 */
Thomas Gleixnerbd0b9ac2015-09-14 10:42:37 +0200425static void exynos_irq_demux_eint16_31(struct irq_desc *desc)
Thomas Abraham43b169d2012-09-07 06:07:19 +0900426{
Jiang Liu5663bb22015-06-04 12:13:16 +0800427 struct irq_chip *chip = irq_desc_get_chip(desc);
428 struct exynos_muxed_weint_data *eintd = irq_desc_get_handler_data(desc);
Krzysztof Kozlowskid0fffdb2021-04-08 21:50:29 +0200429 unsigned int pend;
430 unsigned int mask;
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200431 int i;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900432
433 chained_irq_enter(chip, desc);
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200434
435 for (i = 0; i < eintd->nr_banks; ++i) {
436 struct samsung_pin_bank *b = eintd->banks[i];
Chanwoo Choi8b1bd112016-11-09 17:40:10 +0900437 pend = readl(b->eint_base + b->irq_chip->eint_pend
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200438 + b->eint_offset);
Chanwoo Choi8b1bd112016-11-09 17:40:10 +0900439 mask = readl(b->eint_base + b->irq_chip->eint_mask
Tomasz Figa2e4a4fd2014-07-02 17:41:01 +0200440 + b->eint_offset);
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200441 exynos_irq_demux_eint(pend & ~mask, b->irq_domain);
442 }
443
Thomas Abraham43b169d2012-09-07 06:07:19 +0900444 chained_irq_exit(chip, desc);
445}
446
Thomas Abraham43b169d2012-09-07 06:07:19 +0900447/*
448 * exynos_eint_wkup_init() - setup handling of external wakeup interrupts.
449 * @d: driver data of samsung pinctrl driver.
450 */
Krzysztof Kozlowskicfa76dd2017-05-16 20:56:27 +0200451int exynos_eint_wkup_init(struct samsung_pinctrl_drv_data *d)
Thomas Abraham43b169d2012-09-07 06:07:19 +0900452{
453 struct device *dev = d->dev;
Tomasz Figac3ad0562012-09-21 07:34:01 +0900454 struct device_node *wkup_np = NULL;
455 struct device_node *np;
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200456 struct samsung_pin_bank *bank;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900457 struct exynos_weint_data *weint_data;
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200458 struct exynos_muxed_weint_data *muxed_data;
Abhilash Kesavan14c255d2014-10-09 19:24:31 +0530459 struct exynos_irq_chip *irq_chip;
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200460 unsigned int muxed_banks = 0;
461 unsigned int i;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900462 int idx, irq;
463
Tomasz Figac3ad0562012-09-21 07:34:01 +0900464 for_each_child_of_node(dev->of_node, np) {
Abhilash Kesavan14c255d2014-10-09 19:24:31 +0530465 const struct of_device_id *match;
466
467 match = of_match_node(exynos_wkup_irq_ids, np);
468 if (match) {
469 irq_chip = kmemdup(match->data,
470 sizeof(*irq_chip), GFP_KERNEL);
Nishka Dasguptad892c9782019-08-04 21:32:00 +0530471 if (!irq_chip) {
472 of_node_put(np);
Krzysztof Kozlowskia1ea9a42017-05-23 20:41:40 +0200473 return -ENOMEM;
Nishka Dasguptad892c9782019-08-04 21:32:00 +0530474 }
Tomasz Figac3ad0562012-09-21 07:34:01 +0900475 wkup_np = np;
476 break;
477 }
Thomas Abraham43b169d2012-09-07 06:07:19 +0900478 }
Tomasz Figac3ad0562012-09-21 07:34:01 +0900479 if (!wkup_np)
480 return -ENODEV;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900481
Tomasz Figa1bf00d72014-09-23 21:05:40 +0200482 bank = d->pin_banks;
483 for (i = 0; i < d->nr_banks; ++i, ++bank) {
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200484 if (bank->eint_type != EINT_TYPE_WKUP)
485 continue;
486
487 bank->irq_domain = irq_domain_add_linear(bank->of_node,
Abhilash Kesavan6f5e41b2014-10-09 19:24:30 +0530488 bank->nr_pins, &exynos_eint_irqd_ops, bank);
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200489 if (!bank->irq_domain) {
490 dev_err(dev, "wkup irq domain add failed\n");
491 return -ENXIO;
492 }
493
Abhilash Kesavan14c255d2014-10-09 19:24:31 +0530494 bank->irq_chip = irq_chip;
Abhilash Kesavan0d3d30d2014-10-09 19:24:29 +0530495
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200496 if (!of_find_property(bank->of_node, "interrupts", NULL)) {
497 bank->eint_type = EINT_TYPE_WKUP_MUX;
498 ++muxed_banks;
499 continue;
500 }
501
502 weint_data = devm_kzalloc(dev, bank->nr_pins
503 * sizeof(*weint_data), GFP_KERNEL);
Marek Szyprowskifa5c0f42017-01-19 14:48:45 +0100504 if (!weint_data)
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200505 return -ENOMEM;
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200506
507 for (idx = 0; idx < bank->nr_pins; ++idx) {
508 irq = irq_of_parse_and_map(bank->of_node, idx);
509 if (!irq) {
510 dev_err(dev, "irq number for eint-%s-%d not found\n",
511 bank->name, idx);
512 continue;
513 }
514 weint_data[idx].irq = idx;
515 weint_data[idx].bank = bank;
Thomas Gleixnerc21f7842015-06-21 21:11:07 +0200516 irq_set_chained_handler_and_data(irq,
517 exynos_irq_eint0_15,
518 &weint_data[idx]);
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200519 }
Thomas Abraham43b169d2012-09-07 06:07:19 +0900520 }
521
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200522 if (!muxed_banks)
523 return 0;
524
525 irq = irq_of_parse_and_map(wkup_np, 0);
526 if (!irq) {
527 dev_err(dev, "irq number for muxed EINTs not found\n");
528 return 0;
529 }
530
531 muxed_data = devm_kzalloc(dev, sizeof(*muxed_data)
532 + muxed_banks*sizeof(struct samsung_pin_bank *), GFP_KERNEL);
Marek Szyprowskifa5c0f42017-01-19 14:48:45 +0100533 if (!muxed_data)
Thomas Abraham43b169d2012-09-07 06:07:19 +0900534 return -ENOMEM;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900535
Thomas Gleixnerbb56fc32015-06-21 20:16:16 +0200536 irq_set_chained_handler_and_data(irq, exynos_irq_demux_eint16_31,
537 muxed_data);
Thomas Abraham43b169d2012-09-07 06:07:19 +0900538
Tomasz Figa1bf00d72014-09-23 21:05:40 +0200539 bank = d->pin_banks;
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200540 idx = 0;
Tomasz Figa1bf00d72014-09-23 21:05:40 +0200541 for (i = 0; i < d->nr_banks; ++i, ++bank) {
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200542 if (bank->eint_type != EINT_TYPE_WKUP_MUX)
543 continue;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900544
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200545 muxed_data->banks[idx++] = bank;
Thomas Abraham43b169d2012-09-07 06:07:19 +0900546 }
Tomasz Figaa04b07c2012-10-11 10:11:18 +0200547 muxed_data->nr_banks = muxed_banks;
548
Thomas Abraham43b169d2012-09-07 06:07:19 +0900549 return 0;
550}
551
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200552static void exynos_pinctrl_suspend_bank(
553 struct samsung_pinctrl_drv_data *drvdata,
554 struct samsung_pin_bank *bank)
555{
556 struct exynos_eint_gpio_save *save = bank->soc_priv;
Chanwoo Choi8b1bd112016-11-09 17:40:10 +0900557 void __iomem *regs = bank->eint_base;
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200558
559 save->eint_con = readl(regs + EXYNOS_GPIO_ECON_OFFSET
560 + bank->eint_offset);
561 save->eint_fltcon0 = readl(regs + EXYNOS_GPIO_EFLTCON_OFFSET
562 + 2 * bank->eint_offset);
563 save->eint_fltcon1 = readl(regs + EXYNOS_GPIO_EFLTCON_OFFSET
564 + 2 * bank->eint_offset + 4);
Jonathan Bakkeracac3382020-04-25 16:10:46 -0700565 save->eint_mask = readl(regs + bank->irq_chip->eint_mask
566 + bank->eint_offset);
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200567
568 pr_debug("%s: save con %#010x\n", bank->name, save->eint_con);
569 pr_debug("%s: save fltcon0 %#010x\n", bank->name, save->eint_fltcon0);
570 pr_debug("%s: save fltcon1 %#010x\n", bank->name, save->eint_fltcon1);
Jonathan Bakkeracac3382020-04-25 16:10:46 -0700571 pr_debug("%s: save mask %#010x\n", bank->name, save->eint_mask);
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200572}
573
Krzysztof Kozlowskicfa76dd2017-05-16 20:56:27 +0200574void exynos_pinctrl_suspend(struct samsung_pinctrl_drv_data *drvdata)
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200575{
Tomasz Figa1bf00d72014-09-23 21:05:40 +0200576 struct samsung_pin_bank *bank = drvdata->pin_banks;
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200577 int i;
578
Tomasz Figa1bf00d72014-09-23 21:05:40 +0200579 for (i = 0; i < drvdata->nr_banks; ++i, ++bank)
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200580 if (bank->eint_type == EINT_TYPE_GPIO)
581 exynos_pinctrl_suspend_bank(drvdata, bank);
582}
583
584static void exynos_pinctrl_resume_bank(
585 struct samsung_pinctrl_drv_data *drvdata,
586 struct samsung_pin_bank *bank)
587{
588 struct exynos_eint_gpio_save *save = bank->soc_priv;
Chanwoo Choi8b1bd112016-11-09 17:40:10 +0900589 void __iomem *regs = bank->eint_base;
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200590
591 pr_debug("%s: con %#010x => %#010x\n", bank->name,
592 readl(regs + EXYNOS_GPIO_ECON_OFFSET
593 + bank->eint_offset), save->eint_con);
594 pr_debug("%s: fltcon0 %#010x => %#010x\n", bank->name,
595 readl(regs + EXYNOS_GPIO_EFLTCON_OFFSET
596 + 2 * bank->eint_offset), save->eint_fltcon0);
597 pr_debug("%s: fltcon1 %#010x => %#010x\n", bank->name,
598 readl(regs + EXYNOS_GPIO_EFLTCON_OFFSET
599 + 2 * bank->eint_offset + 4), save->eint_fltcon1);
Jonathan Bakkeracac3382020-04-25 16:10:46 -0700600 pr_debug("%s: mask %#010x => %#010x\n", bank->name,
601 readl(regs + bank->irq_chip->eint_mask
602 + bank->eint_offset), save->eint_mask);
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200603
604 writel(save->eint_con, regs + EXYNOS_GPIO_ECON_OFFSET
605 + bank->eint_offset);
606 writel(save->eint_fltcon0, regs + EXYNOS_GPIO_EFLTCON_OFFSET
607 + 2 * bank->eint_offset);
608 writel(save->eint_fltcon1, regs + EXYNOS_GPIO_EFLTCON_OFFSET
609 + 2 * bank->eint_offset + 4);
Jonathan Bakkeracac3382020-04-25 16:10:46 -0700610 writel(save->eint_mask, regs + bank->irq_chip->eint_mask
611 + bank->eint_offset);
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200612}
613
Krzysztof Kozlowskicfa76dd2017-05-16 20:56:27 +0200614void exynos_pinctrl_resume(struct samsung_pinctrl_drv_data *drvdata)
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200615{
Tomasz Figa1bf00d72014-09-23 21:05:40 +0200616 struct samsung_pin_bank *bank = drvdata->pin_banks;
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200617 int i;
618
Tomasz Figa1bf00d72014-09-23 21:05:40 +0200619 for (i = 0; i < drvdata->nr_banks; ++i, ++bank)
Tomasz Figa7ccbc602013-05-22 16:03:17 +0200620 if (bank->eint_type == EINT_TYPE_GPIO)
621 exynos_pinctrl_resume_bank(drvdata, bank);
622}
623
Marek Szyprowski07731012017-01-26 10:29:25 +0100624static void exynos_retention_enable(struct samsung_pinctrl_drv_data *drvdata)
625{
626 if (drvdata->retention_ctrl->refcnt)
627 atomic_inc(drvdata->retention_ctrl->refcnt);
628}
629
630static void exynos_retention_disable(struct samsung_pinctrl_drv_data *drvdata)
631{
632 struct samsung_retention_ctrl *ctrl = drvdata->retention_ctrl;
633 struct regmap *pmu_regs = ctrl->priv;
634 int i;
635
636 if (ctrl->refcnt && !atomic_dec_and_test(ctrl->refcnt))
637 return;
638
639 for (i = 0; i < ctrl->nr_regs; i++)
640 regmap_write(pmu_regs, ctrl->regs[i], ctrl->value);
641}
642
Krzysztof Kozlowskicfa76dd2017-05-16 20:56:27 +0200643struct samsung_retention_ctrl *
Marek Szyprowski07731012017-01-26 10:29:25 +0100644exynos_retention_init(struct samsung_pinctrl_drv_data *drvdata,
645 const struct samsung_retention_data *data)
646{
647 struct samsung_retention_ctrl *ctrl;
648 struct regmap *pmu_regs;
Marek Szyprowski8fe9bf02017-03-23 09:03:22 +0100649 int i;
Marek Szyprowski07731012017-01-26 10:29:25 +0100650
651 ctrl = devm_kzalloc(drvdata->dev, sizeof(*ctrl), GFP_KERNEL);
652 if (!ctrl)
653 return ERR_PTR(-ENOMEM);
654
655 pmu_regs = exynos_get_pmu_regmap();
656 if (IS_ERR(pmu_regs))
657 return ERR_CAST(pmu_regs);
658
659 ctrl->priv = pmu_regs;
660 ctrl->regs = data->regs;
661 ctrl->nr_regs = data->nr_regs;
662 ctrl->value = data->value;
663 ctrl->refcnt = data->refcnt;
664 ctrl->enable = exynos_retention_enable;
665 ctrl->disable = exynos_retention_disable;
666
Marek Szyprowski8fe9bf02017-03-23 09:03:22 +0100667 /* Ensure that retention is disabled on driver init */
668 for (i = 0; i < ctrl->nr_regs; i++)
669 regmap_write(pmu_regs, ctrl->regs[i], ctrl->value);
670
Marek Szyprowski07731012017-01-26 10:29:25 +0100671 return ctrl;
672}