1
2
3
4
5
6
7
8#include <linux/acpi.h>
9#include <linux/irq.h>
10#include <linux/irqdomain.h>
11#include <linux/of.h>
12
13enum acpi_irq_model_id acpi_irq_model;
14
15static struct fwnode_handle *acpi_gsi_domain_id;
16
17
18
19
20
21
22
23
24
25
26
27int acpi_gsi_to_irq(u32 gsi, unsigned int *irq)
28{
29 struct irq_domain *d = irq_find_matching_fwnode(acpi_gsi_domain_id,
30 DOMAIN_BUS_ANY);
31
32 *irq = irq_find_mapping(d, gsi);
33
34
35
36
37 return (*irq > 0) ? 0 : -EINVAL;
38}
39EXPORT_SYMBOL_GPL(acpi_gsi_to_irq);
40
41
42
43
44
45
46
47
48
49
50
51int acpi_register_gsi(struct device *dev, u32 gsi, int trigger,
52 int polarity)
53{
54 struct irq_fwspec fwspec;
55
56 if (WARN_ON(!acpi_gsi_domain_id)) {
57 pr_warn("GSI: No registered irqchip, giving up\n");
58 return -EINVAL;
59 }
60
61 fwspec.fwnode = acpi_gsi_domain_id;
62 fwspec.param[0] = gsi;
63 fwspec.param[1] = acpi_dev_get_irq_type(trigger, polarity);
64 fwspec.param_count = 2;
65
66 return irq_create_fwspec_mapping(&fwspec);
67}
68EXPORT_SYMBOL_GPL(acpi_register_gsi);
69
70
71
72
73
74void acpi_unregister_gsi(u32 gsi)
75{
76 struct irq_domain *d = irq_find_matching_fwnode(acpi_gsi_domain_id,
77 DOMAIN_BUS_ANY);
78 int irq;
79
80 if (WARN_ON(acpi_irq_model == ACPI_IRQ_MODEL_GIC && gsi < 16))
81 return;
82
83 irq = irq_find_mapping(d, gsi);
84 irq_dispose_mapping(irq);
85}
86EXPORT_SYMBOL_GPL(acpi_unregister_gsi);
87
88
89
90
91
92
93
94
95
96
97
98
99static struct fwnode_handle *
100acpi_get_irq_source_fwhandle(const struct acpi_resource_source *source)
101{
102 struct fwnode_handle *result;
103 struct acpi_device *device;
104 acpi_handle handle;
105 acpi_status status;
106
107 if (!source->string_length)
108 return acpi_gsi_domain_id;
109
110 status = acpi_get_handle(NULL, source->string_ptr, &handle);
111 if (WARN_ON(ACPI_FAILURE(status)))
112 return NULL;
113
114 device = acpi_bus_get_acpi_device(handle);
115 if (WARN_ON(!device))
116 return NULL;
117
118 result = &device->fwnode;
119 acpi_bus_put_acpi_device(device);
120 return result;
121}
122
123
124
125
126
127
128struct acpi_irq_parse_one_ctx {
129 int rc;
130 unsigned int index;
131 unsigned long *res_flags;
132 struct irq_fwspec *fwspec;
133};
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149static inline void acpi_irq_parse_one_match(struct fwnode_handle *fwnode,
150 u32 hwirq, u8 triggering,
151 u8 polarity, u8 shareable,
152 struct acpi_irq_parse_one_ctx *ctx)
153{
154 if (!fwnode)
155 return;
156 ctx->rc = 0;
157 *ctx->res_flags = acpi_dev_irq_flags(triggering, polarity, shareable);
158 ctx->fwspec->fwnode = fwnode;
159 ctx->fwspec->param[0] = hwirq;
160 ctx->fwspec->param[1] = acpi_dev_get_irq_type(triggering, polarity);
161 ctx->fwspec->param_count = 2;
162}
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182static acpi_status acpi_irq_parse_one_cb(struct acpi_resource *ares,
183 void *context)
184{
185 struct acpi_irq_parse_one_ctx *ctx = context;
186 struct acpi_resource_irq *irq;
187 struct acpi_resource_extended_irq *eirq;
188 struct fwnode_handle *fwnode;
189
190 switch (ares->type) {
191 case ACPI_RESOURCE_TYPE_IRQ:
192 irq = &ares->data.irq;
193 if (ctx->index >= irq->interrupt_count) {
194 ctx->index -= irq->interrupt_count;
195 return AE_OK;
196 }
197 fwnode = acpi_gsi_domain_id;
198 acpi_irq_parse_one_match(fwnode, irq->interrupts[ctx->index],
199 irq->triggering, irq->polarity,
200 irq->shareable, ctx);
201 return AE_CTRL_TERMINATE;
202 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
203 eirq = &ares->data.extended_irq;
204 if (eirq->producer_consumer == ACPI_PRODUCER)
205 return AE_OK;
206 if (ctx->index >= eirq->interrupt_count) {
207 ctx->index -= eirq->interrupt_count;
208 return AE_OK;
209 }
210 fwnode = acpi_get_irq_source_fwhandle(&eirq->resource_source);
211 acpi_irq_parse_one_match(fwnode, eirq->interrupts[ctx->index],
212 eirq->triggering, eirq->polarity,
213 eirq->shareable, ctx);
214 return AE_CTRL_TERMINATE;
215 }
216
217 return AE_OK;
218}
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236static int acpi_irq_parse_one(acpi_handle handle, unsigned int index,
237 struct irq_fwspec *fwspec, unsigned long *flags)
238{
239 struct acpi_irq_parse_one_ctx ctx = { -EINVAL, index, flags, fwspec };
240
241 acpi_walk_resources(handle, METHOD_NAME__CRS, acpi_irq_parse_one_cb, &ctx);
242 return ctx.rc;
243}
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)
261{
262 struct irq_fwspec fwspec;
263 struct irq_domain *domain;
264 unsigned long flags;
265 int rc;
266
267 rc = acpi_irq_parse_one(handle, index, &fwspec, &flags);
268 if (rc)
269 return rc;
270
271 domain = irq_find_matching_fwnode(fwspec.fwnode, DOMAIN_BUS_ANY);
272 if (!domain)
273 return -EPROBE_DEFER;
274
275 rc = irq_create_fwspec_mapping(&fwspec);
276 if (rc <= 0)
277 return -EINVAL;
278
279 res->start = rc;
280 res->end = rc;
281 res->flags = flags;
282
283 return 0;
284}
285EXPORT_SYMBOL_GPL(acpi_irq_get);
286
287
288
289
290
291
292
293void __init acpi_set_irq_model(enum acpi_irq_model_id model,
294 struct fwnode_handle *fwnode)
295{
296 acpi_irq_model = model;
297 acpi_gsi_domain_id = fwnode;
298}
299
300
301
302
303
304
305
306
307
308
309struct irq_domain *acpi_irq_create_hierarchy(unsigned int flags,
310 unsigned int size,
311 struct fwnode_handle *fwnode,
312 const struct irq_domain_ops *ops,
313 void *host_data)
314{
315 struct irq_domain *d = irq_find_matching_fwnode(acpi_gsi_domain_id,
316 DOMAIN_BUS_ANY);
317
318 if (!d)
319 return NULL;
320
321 return irq_domain_create_hierarchy(d, flags, size, fwnode, ops,
322 host_data);
323}
324EXPORT_SYMBOL_GPL(acpi_irq_create_hierarchy);
325