1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/init.h>
22#include <linux/io.h>
23#include <linux/irq.h>
24#include <linux/interrupt.h>
25#include <linux/slab.h>
26
27#include "prm2xxx_3xxx.h"
28#include "prm2xxx.h"
29#include "prm3xxx.h"
30#include "prm44xx.h"
31#include "common.h"
32
33
34
35
36
37
38
39#define OMAP_PRCM_MAX_NR_PENDING_REG 2
40
41
42
43
44
45
46
47static struct irq_chip_generic **prcm_irq_chips;
48
49
50
51
52
53
54static struct omap_prcm_irq_setup *prcm_irq_setup;
55
56
57void __iomem *prm_base;
58
59
60
61
62
63static struct prm_ll_data null_prm_ll_data;
64static struct prm_ll_data *prm_ll_data = &null_prm_ll_data;
65
66
67
68
69
70
71static void omap_prcm_events_filter_priority(unsigned long *events,
72 unsigned long *priority_events)
73{
74 int i;
75
76 for (i = 0; i < prcm_irq_setup->nr_regs; i++) {
77 priority_events[i] =
78 events[i] & prcm_irq_setup->priority_mask[i];
79 events[i] ^= priority_events[i];
80 }
81}
82
83
84
85
86
87
88
89
90
91static void omap_prcm_irq_handler(unsigned int irq, struct irq_desc *desc)
92{
93 unsigned long pending[OMAP_PRCM_MAX_NR_PENDING_REG];
94 unsigned long priority_pending[OMAP_PRCM_MAX_NR_PENDING_REG];
95 struct irq_chip *chip = irq_desc_get_chip(desc);
96 unsigned int virtirq;
97 int nr_irq = prcm_irq_setup->nr_regs * 32;
98
99
100
101
102
103
104
105
106
107
108
109 if (prcm_irq_setup->suspended) {
110 prcm_irq_setup->save_and_clear_irqen(prcm_irq_setup->saved_mask);
111 prcm_irq_setup->suspend_save_flag = true;
112 }
113
114
115
116
117
118 while (!prcm_irq_setup->suspended) {
119 prcm_irq_setup->read_pending_irqs(pending);
120
121
122 if (find_first_bit(pending, nr_irq) >= nr_irq)
123 break;
124
125 omap_prcm_events_filter_priority(pending, priority_pending);
126
127
128
129
130
131
132
133 for_each_set_bit(virtirq, priority_pending, nr_irq)
134 generic_handle_irq(prcm_irq_setup->base_irq + virtirq);
135
136
137 for_each_set_bit(virtirq, pending, nr_irq)
138 generic_handle_irq(prcm_irq_setup->base_irq + virtirq);
139 }
140 if (chip->irq_ack)
141 chip->irq_ack(&desc->irq_data);
142 if (chip->irq_eoi)
143 chip->irq_eoi(&desc->irq_data);
144 chip->irq_unmask(&desc->irq_data);
145
146 prcm_irq_setup->ocp_barrier();
147}
148
149
150
151
152
153
154
155
156
157
158
159int omap_prcm_event_to_irq(const char *name)
160{
161 int i;
162
163 if (!prcm_irq_setup || !name)
164 return -ENOENT;
165
166 for (i = 0; i < prcm_irq_setup->nr_irqs; i++)
167 if (!strcmp(prcm_irq_setup->irqs[i].name, name))
168 return prcm_irq_setup->base_irq +
169 prcm_irq_setup->irqs[i].offset;
170
171 return -ENOENT;
172}
173
174
175
176
177
178
179
180void omap_prcm_irq_cleanup(void)
181{
182 int i;
183
184 if (!prcm_irq_setup) {
185 pr_err("PRCM: IRQ handler not initialized; cannot cleanup\n");
186 return;
187 }
188
189 if (prcm_irq_chips) {
190 for (i = 0; i < prcm_irq_setup->nr_regs; i++) {
191 if (prcm_irq_chips[i])
192 irq_remove_generic_chip(prcm_irq_chips[i],
193 0xffffffff, 0, 0);
194 prcm_irq_chips[i] = NULL;
195 }
196 kfree(prcm_irq_chips);
197 prcm_irq_chips = NULL;
198 }
199
200 kfree(prcm_irq_setup->saved_mask);
201 prcm_irq_setup->saved_mask = NULL;
202
203 kfree(prcm_irq_setup->priority_mask);
204 prcm_irq_setup->priority_mask = NULL;
205
206 irq_set_chained_handler(prcm_irq_setup->irq, NULL);
207
208 if (prcm_irq_setup->base_irq > 0)
209 irq_free_descs(prcm_irq_setup->base_irq,
210 prcm_irq_setup->nr_regs * 32);
211 prcm_irq_setup->base_irq = 0;
212}
213
214void omap_prcm_irq_prepare(void)
215{
216 prcm_irq_setup->suspended = true;
217}
218
219void omap_prcm_irq_complete(void)
220{
221 prcm_irq_setup->suspended = false;
222
223
224 if (!prcm_irq_setup->suspend_save_flag)
225 return;
226
227 prcm_irq_setup->suspend_save_flag = false;
228
229
230
231
232
233
234 prcm_irq_setup->restore_irqen(prcm_irq_setup->saved_mask);
235}
236
237
238
239
240
241
242
243
244
245
246
247int omap_prcm_register_chain_handler(struct omap_prcm_irq_setup *irq_setup)
248{
249 int nr_regs;
250 u32 mask[OMAP_PRCM_MAX_NR_PENDING_REG];
251 int offset, i;
252 struct irq_chip_generic *gc;
253 struct irq_chip_type *ct;
254
255 if (!irq_setup)
256 return -EINVAL;
257
258 nr_regs = irq_setup->nr_regs;
259
260 if (prcm_irq_setup) {
261 pr_err("PRCM: already initialized; won't reinitialize\n");
262 return -EINVAL;
263 }
264
265 if (nr_regs > OMAP_PRCM_MAX_NR_PENDING_REG) {
266 pr_err("PRCM: nr_regs too large\n");
267 return -EINVAL;
268 }
269
270 prcm_irq_setup = irq_setup;
271
272 prcm_irq_chips = kzalloc(sizeof(void *) * nr_regs, GFP_KERNEL);
273 prcm_irq_setup->saved_mask = kzalloc(sizeof(u32) * nr_regs, GFP_KERNEL);
274 prcm_irq_setup->priority_mask = kzalloc(sizeof(u32) * nr_regs,
275 GFP_KERNEL);
276
277 if (!prcm_irq_chips || !prcm_irq_setup->saved_mask ||
278 !prcm_irq_setup->priority_mask) {
279 pr_err("PRCM: kzalloc failed\n");
280 goto err;
281 }
282
283 memset(mask, 0, sizeof(mask));
284
285 for (i = 0; i < irq_setup->nr_irqs; i++) {
286 offset = irq_setup->irqs[i].offset;
287 mask[offset >> 5] |= 1 << (offset & 0x1f);
288 if (irq_setup->irqs[i].priority)
289 irq_setup->priority_mask[offset >> 5] |=
290 1 << (offset & 0x1f);
291 }
292
293 irq_set_chained_handler(irq_setup->irq, omap_prcm_irq_handler);
294
295 irq_setup->base_irq = irq_alloc_descs(-1, 0, irq_setup->nr_regs * 32,
296 0);
297
298 if (irq_setup->base_irq < 0) {
299 pr_err("PRCM: failed to allocate irq descs: %d\n",
300 irq_setup->base_irq);
301 goto err;
302 }
303
304 for (i = 0; i < irq_setup->nr_regs; i++) {
305 gc = irq_alloc_generic_chip("PRCM", 1,
306 irq_setup->base_irq + i * 32, prm_base,
307 handle_level_irq);
308
309 if (!gc) {
310 pr_err("PRCM: failed to allocate generic chip\n");
311 goto err;
312 }
313 ct = gc->chip_types;
314 ct->chip.irq_ack = irq_gc_ack_set_bit;
315 ct->chip.irq_mask = irq_gc_mask_clr_bit;
316 ct->chip.irq_unmask = irq_gc_mask_set_bit;
317
318 ct->regs.ack = irq_setup->ack + i * 4;
319 ct->regs.mask = irq_setup->mask + i * 4;
320
321 irq_setup_generic_chip(gc, mask[i], 0, IRQ_NOREQUEST, 0);
322 prcm_irq_chips[i] = gc;
323 }
324
325 return 0;
326
327err:
328 omap_prcm_irq_cleanup();
329 return -ENOMEM;
330}
331
332
333
334
335
336
337
338void __init omap2_set_globals_prm(void __iomem *prm)
339{
340 prm_base = prm;
341}
342
343
344
345
346
347
348
349
350
351
352
353
354
355u32 prm_read_reset_sources(void)
356{
357 u32 ret = 1 << OMAP_UNKNOWN_RST_SRC_ID_SHIFT;
358
359 if (prm_ll_data->read_reset_sources)
360 ret = prm_ll_data->read_reset_sources();
361 else
362 WARN_ONCE(1, "prm: %s: no mapping function defined for reset sources\n", __func__);
363
364 return ret;
365}
366
367
368
369
370
371
372
373
374
375
376
377
378
379bool prm_was_any_context_lost_old(u8 part, s16 inst, u16 idx)
380{
381 bool ret = true;
382
383 if (prm_ll_data->was_any_context_lost_old)
384 ret = prm_ll_data->was_any_context_lost_old(part, inst, idx);
385 else
386 WARN_ONCE(1, "prm: %s: no mapping function defined\n",
387 __func__);
388
389 return ret;
390}
391
392
393
394
395
396
397
398
399
400
401
402
403void prm_clear_context_loss_flags_old(u8 part, s16 inst, u16 idx)
404{
405 if (prm_ll_data->clear_context_loss_flags_old)
406 prm_ll_data->clear_context_loss_flags_old(part, inst, idx);
407 else
408 WARN_ONCE(1, "prm: %s: no mapping function defined\n",
409 __func__);
410}
411
412
413
414
415
416
417
418
419
420
421
422
423int prm_register(struct prm_ll_data *pld)
424{
425 if (!pld)
426 return -EINVAL;
427
428 if (prm_ll_data != &null_prm_ll_data)
429 return -EEXIST;
430
431 prm_ll_data = pld;
432
433 return 0;
434}
435
436
437
438
439
440
441
442
443
444
445
446
447int prm_unregister(struct prm_ll_data *pld)
448{
449 if (!pld || prm_ll_data != pld)
450 return -EINVAL;
451
452 prm_ll_data = &null_prm_ll_data;
453
454 return 0;
455}
456