Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * TI LP8788 MFD - interrupt handler
4 *
5 * Copyright 2012 Texas Instruments
6 *
7 * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
8 */
9
10#include <linux/delay.h>
11#include <linux/err.h>
12#include <linux/interrupt.h>
13#include <linux/irq.h>
14#include <linux/irqdomain.h>
15#include <linux/device.h>
16#include <linux/mfd/lp8788.h>
17#include <linux/module.h>
18#include <linux/slab.h>
19
20/* register address */
21#define LP8788_INT_1 0x00
22#define LP8788_INTEN_1 0x03
23
24#define BASE_INTEN_ADDR LP8788_INTEN_1
25#define SIZE_REG 8
26#define NUM_REGS 3
27
28/*
29 * struct lp8788_irq_data
30 * @lp : used for accessing to lp8788 registers
31 * @irq_lock : mutex for enabling/disabling the interrupt
32 * @domain : IRQ domain for handling nested interrupt
33 * @enabled : status of enabled interrupt
34 */
35struct lp8788_irq_data {
36 struct lp8788 *lp;
37 struct mutex irq_lock;
38 struct irq_domain *domain;
39 int enabled[LP8788_INT_MAX];
40};
41
42static inline u8 _irq_to_addr(enum lp8788_int_id id)
43{
44 return id / SIZE_REG;
45}
46
47static inline u8 _irq_to_enable_addr(enum lp8788_int_id id)
48{
49 return _irq_to_addr(id) + BASE_INTEN_ADDR;
50}
51
52static inline u8 _irq_to_mask(enum lp8788_int_id id)
53{
54 return 1 << (id % SIZE_REG);
55}
56
57static inline u8 _irq_to_val(enum lp8788_int_id id, int enable)
58{
59 return enable << (id % SIZE_REG);
60}
61
62static void lp8788_irq_enable(struct irq_data *data)
63{
64 struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
65
66 irqd->enabled[data->hwirq] = 1;
67}
68
69static void lp8788_irq_disable(struct irq_data *data)
70{
71 struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
72
73 irqd->enabled[data->hwirq] = 0;
74}
75
76static void lp8788_irq_bus_lock(struct irq_data *data)
77{
78 struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
79
80 mutex_lock(&irqd->irq_lock);
81}
82
83static void lp8788_irq_bus_sync_unlock(struct irq_data *data)
84{
85 struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
86 enum lp8788_int_id irq = data->hwirq;
87 u8 addr, mask, val;
88
89 addr = _irq_to_enable_addr(irq);
90 mask = _irq_to_mask(irq);
91 val = _irq_to_val(irq, irqd->enabled[irq]);
92
93 lp8788_update_bits(irqd->lp, addr, mask, val);
94
95 mutex_unlock(&irqd->irq_lock);
96}
97
98static struct irq_chip lp8788_irq_chip = {
99 .name = "lp8788",
100 .irq_enable = lp8788_irq_enable,
101 .irq_disable = lp8788_irq_disable,
102 .irq_bus_lock = lp8788_irq_bus_lock,
103 .irq_bus_sync_unlock = lp8788_irq_bus_sync_unlock,
104};
105
106static irqreturn_t lp8788_irq_handler(int irq, void *ptr)
107{
108 struct lp8788_irq_data *irqd = ptr;
109 struct lp8788 *lp = irqd->lp;
110 u8 status[NUM_REGS], addr, mask;
111 bool handled = false;
112 int i;
113
114 if (lp8788_read_multi_bytes(lp, LP8788_INT_1, status, NUM_REGS))
115 return IRQ_NONE;
116
117 for (i = 0 ; i < LP8788_INT_MAX ; i++) {
118 addr = _irq_to_addr(i);
119 mask = _irq_to_mask(i);
120
121 /* reporting only if the irq is enabled */
122 if (status[addr] & mask) {
123 handle_nested_irq(irq_find_mapping(irqd->domain, i));
124 handled = true;
125 }
126 }
127
128 return handled ? IRQ_HANDLED : IRQ_NONE;
129}
130
131static int lp8788_irq_map(struct irq_domain *d, unsigned int virq,
132 irq_hw_number_t hwirq)
133{
134 struct lp8788_irq_data *irqd = d->host_data;
135 struct irq_chip *chip = &lp8788_irq_chip;
136
137 irq_set_chip_data(virq, irqd);
138 irq_set_chip_and_handler(virq, chip, handle_edge_irq);
139 irq_set_nested_thread(virq, 1);
140 irq_set_noprobe(virq);
141
142 return 0;
143}
144
145static const struct irq_domain_ops lp8788_domain_ops = {
146 .map = lp8788_irq_map,
147};
148
149int lp8788_irq_init(struct lp8788 *lp, int irq)
150{
151 struct lp8788_irq_data *irqd;
152 int ret;
153
154 if (irq <= 0) {
155 dev_warn(lp->dev, "invalid irq number: %d\n", irq);
156 return 0;
157 }
158
159 irqd = devm_kzalloc(lp->dev, sizeof(*irqd), GFP_KERNEL);
160 if (!irqd)
161 return -ENOMEM;
162
163 irqd->lp = lp;
164 irqd->domain = irq_domain_add_linear(lp->dev->of_node, LP8788_INT_MAX,
165 &lp8788_domain_ops, irqd);
166 if (!irqd->domain) {
167 dev_err(lp->dev, "failed to add irq domain err\n");
168 return -EINVAL;
169 }
170
171 lp->irqdm = irqd->domain;
172 mutex_init(&irqd->irq_lock);
173
174 ret = request_threaded_irq(irq, NULL, lp8788_irq_handler,
175 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
176 "lp8788-irq", irqd);
177 if (ret) {
178 irq_domain_remove(lp->irqdm);
179 dev_err(lp->dev, "failed to create a thread for IRQ_N\n");
180 return ret;
181 }
182
183 lp->irq = irq;
184
185 return 0;
186}
187
188void lp8788_irq_exit(struct lp8788 *lp)
189{
190 if (lp->irq)
191 free_irq(lp->irq, lp->irqdm);
192 if (lp->irqdm)
193 irq_domain_remove(lp->irqdm);
194}
1/*
2 * TI LP8788 MFD - interrupt handler
3 *
4 * Copyright 2012 Texas Instruments
5 *
6 * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 *
12 */
13
14#include <linux/delay.h>
15#include <linux/err.h>
16#include <linux/interrupt.h>
17#include <linux/irq.h>
18#include <linux/irqdomain.h>
19#include <linux/device.h>
20#include <linux/mfd/lp8788.h>
21#include <linux/module.h>
22#include <linux/slab.h>
23
24/* register address */
25#define LP8788_INT_1 0x00
26#define LP8788_INTEN_1 0x03
27
28#define BASE_INTEN_ADDR LP8788_INTEN_1
29#define SIZE_REG 8
30#define NUM_REGS 3
31
32/*
33 * struct lp8788_irq_data
34 * @lp : used for accessing to lp8788 registers
35 * @irq_lock : mutex for enabling/disabling the interrupt
36 * @domain : IRQ domain for handling nested interrupt
37 * @enabled : status of enabled interrupt
38 */
39struct lp8788_irq_data {
40 struct lp8788 *lp;
41 struct mutex irq_lock;
42 struct irq_domain *domain;
43 int enabled[LP8788_INT_MAX];
44};
45
46static inline u8 _irq_to_addr(enum lp8788_int_id id)
47{
48 return id / SIZE_REG;
49}
50
51static inline u8 _irq_to_enable_addr(enum lp8788_int_id id)
52{
53 return _irq_to_addr(id) + BASE_INTEN_ADDR;
54}
55
56static inline u8 _irq_to_mask(enum lp8788_int_id id)
57{
58 return 1 << (id % SIZE_REG);
59}
60
61static inline u8 _irq_to_val(enum lp8788_int_id id, int enable)
62{
63 return enable << (id % SIZE_REG);
64}
65
66static void lp8788_irq_enable(struct irq_data *data)
67{
68 struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
69
70 irqd->enabled[data->hwirq] = 1;
71}
72
73static void lp8788_irq_disable(struct irq_data *data)
74{
75 struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
76
77 irqd->enabled[data->hwirq] = 0;
78}
79
80static void lp8788_irq_bus_lock(struct irq_data *data)
81{
82 struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
83
84 mutex_lock(&irqd->irq_lock);
85}
86
87static void lp8788_irq_bus_sync_unlock(struct irq_data *data)
88{
89 struct lp8788_irq_data *irqd = irq_data_get_irq_chip_data(data);
90 enum lp8788_int_id irq = data->hwirq;
91 u8 addr, mask, val;
92
93 addr = _irq_to_enable_addr(irq);
94 mask = _irq_to_mask(irq);
95 val = _irq_to_val(irq, irqd->enabled[irq]);
96
97 lp8788_update_bits(irqd->lp, addr, mask, val);
98
99 mutex_unlock(&irqd->irq_lock);
100}
101
102static struct irq_chip lp8788_irq_chip = {
103 .name = "lp8788",
104 .irq_enable = lp8788_irq_enable,
105 .irq_disable = lp8788_irq_disable,
106 .irq_bus_lock = lp8788_irq_bus_lock,
107 .irq_bus_sync_unlock = lp8788_irq_bus_sync_unlock,
108};
109
110static irqreturn_t lp8788_irq_handler(int irq, void *ptr)
111{
112 struct lp8788_irq_data *irqd = ptr;
113 struct lp8788 *lp = irqd->lp;
114 u8 status[NUM_REGS], addr, mask;
115 bool handled = false;
116 int i;
117
118 if (lp8788_read_multi_bytes(lp, LP8788_INT_1, status, NUM_REGS))
119 return IRQ_NONE;
120
121 for (i = 0 ; i < LP8788_INT_MAX ; i++) {
122 addr = _irq_to_addr(i);
123 mask = _irq_to_mask(i);
124
125 /* reporting only if the irq is enabled */
126 if (status[addr] & mask) {
127 handle_nested_irq(irq_find_mapping(irqd->domain, i));
128 handled = true;
129 }
130 }
131
132 return handled ? IRQ_HANDLED : IRQ_NONE;
133}
134
135static int lp8788_irq_map(struct irq_domain *d, unsigned int virq,
136 irq_hw_number_t hwirq)
137{
138 struct lp8788_irq_data *irqd = d->host_data;
139 struct irq_chip *chip = &lp8788_irq_chip;
140
141 irq_set_chip_data(virq, irqd);
142 irq_set_chip_and_handler(virq, chip, handle_edge_irq);
143 irq_set_nested_thread(virq, 1);
144 irq_set_noprobe(virq);
145
146 return 0;
147}
148
149static const struct irq_domain_ops lp8788_domain_ops = {
150 .map = lp8788_irq_map,
151};
152
153int lp8788_irq_init(struct lp8788 *lp, int irq)
154{
155 struct lp8788_irq_data *irqd;
156 int ret;
157
158 if (irq <= 0) {
159 dev_warn(lp->dev, "invalid irq number: %d\n", irq);
160 return 0;
161 }
162
163 irqd = devm_kzalloc(lp->dev, sizeof(*irqd), GFP_KERNEL);
164 if (!irqd)
165 return -ENOMEM;
166
167 irqd->lp = lp;
168 irqd->domain = irq_domain_add_linear(lp->dev->of_node, LP8788_INT_MAX,
169 &lp8788_domain_ops, irqd);
170 if (!irqd->domain) {
171 dev_err(lp->dev, "failed to add irq domain err\n");
172 return -EINVAL;
173 }
174
175 lp->irqdm = irqd->domain;
176 mutex_init(&irqd->irq_lock);
177
178 ret = request_threaded_irq(irq, NULL, lp8788_irq_handler,
179 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
180 "lp8788-irq", irqd);
181 if (ret) {
182 dev_err(lp->dev, "failed to create a thread for IRQ_N\n");
183 return ret;
184 }
185
186 lp->irq = irq;
187
188 return 0;
189}
190
191void lp8788_irq_exit(struct lp8788 *lp)
192{
193 if (lp->irq)
194 free_irq(lp->irq, lp->irqdm);
195}