blob: 7638a50a7c389a182453c9b568e818bb8817a353 [file] [log] [blame]
Thomas Gleixner2874c5f2019-05-27 08:55:01 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
Uwe Zeisbergerf30c2262006-10-03 23:01:26 +02003 * arch/powerpc/sysdev/ipic.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
5 * IPIC routines implementations.
6 *
7 * Copyright 2005 Freescale Semiconductor, Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
9#include <linux/kernel.h>
10#include <linux/init.h>
11#include <linux/errno.h>
12#include <linux/reboot.h>
13#include <linux/slab.h>
14#include <linux/stddef.h>
15#include <linux/sched.h>
16#include <linux/signal.h>
Rafael J. Wysockif5a592f2011-04-26 19:14:57 +020017#include <linux/syscore_ops.h>
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -050018#include <linux/device.h>
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -050019#include <linux/spinlock.h>
Scott Woodd49747b2007-10-09 12:37:13 -050020#include <linux/fsl_devices.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <asm/irq.h>
22#include <asm/io.h>
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -050023#include <asm/prom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <asm/ipic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26#include "ipic.h"
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028static struct ipic * primary_ipic;
Li Yang77d43092007-12-04 19:01:40 +080029static struct irq_chip ipic_level_irq_chip, ipic_edge_irq_chip;
Thomas Gleixnera9e8bf22010-02-18 02:23:14 +000030static DEFINE_RAW_SPINLOCK(ipic_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32static struct ipic_info ipic_info[] = {
Li Yangf03ca952007-10-19 19:38:43 +080033 [1] = {
Li Yangf03ca952007-10-19 19:38:43 +080034 .mask = IPIC_SIMSR_H,
35 .prio = IPIC_SIPRR_C,
36 .force = IPIC_SIFCR_H,
37 .bit = 16,
38 .prio_mask = 0,
39 },
40 [2] = {
Li Yangf03ca952007-10-19 19:38:43 +080041 .mask = IPIC_SIMSR_H,
42 .prio = IPIC_SIPRR_C,
43 .force = IPIC_SIFCR_H,
44 .bit = 17,
45 .prio_mask = 1,
46 },
John Rigbya7267d62008-01-17 17:05:32 -070047 [3] = {
48 .mask = IPIC_SIMSR_H,
49 .prio = IPIC_SIPRR_C,
50 .force = IPIC_SIFCR_H,
51 .bit = 18,
52 .prio_mask = 2,
53 },
Li Yangf03ca952007-10-19 19:38:43 +080054 [4] = {
Li Yangf03ca952007-10-19 19:38:43 +080055 .mask = IPIC_SIMSR_H,
56 .prio = IPIC_SIPRR_C,
57 .force = IPIC_SIFCR_H,
58 .bit = 19,
59 .prio_mask = 3,
60 },
John Rigbya7267d62008-01-17 17:05:32 -070061 [5] = {
62 .mask = IPIC_SIMSR_H,
63 .prio = IPIC_SIPRR_C,
64 .force = IPIC_SIFCR_H,
65 .bit = 20,
66 .prio_mask = 4,
67 },
68 [6] = {
69 .mask = IPIC_SIMSR_H,
70 .prio = IPIC_SIPRR_C,
71 .force = IPIC_SIFCR_H,
72 .bit = 21,
73 .prio_mask = 5,
74 },
75 [7] = {
76 .mask = IPIC_SIMSR_H,
77 .prio = IPIC_SIPRR_C,
78 .force = IPIC_SIFCR_H,
79 .bit = 22,
80 .prio_mask = 6,
81 },
82 [8] = {
83 .mask = IPIC_SIMSR_H,
84 .prio = IPIC_SIPRR_C,
85 .force = IPIC_SIFCR_H,
86 .bit = 23,
87 .prio_mask = 7,
88 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 [9] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 .mask = IPIC_SIMSR_H,
91 .prio = IPIC_SIPRR_D,
92 .force = IPIC_SIFCR_H,
93 .bit = 24,
94 .prio_mask = 0,
95 },
96 [10] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 .mask = IPIC_SIMSR_H,
98 .prio = IPIC_SIPRR_D,
99 .force = IPIC_SIFCR_H,
100 .bit = 25,
101 .prio_mask = 1,
102 },
103 [11] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 .mask = IPIC_SIMSR_H,
105 .prio = IPIC_SIPRR_D,
106 .force = IPIC_SIFCR_H,
107 .bit = 26,
108 .prio_mask = 2,
109 },
Li Yangf03ca952007-10-19 19:38:43 +0800110 [12] = {
Li Yangf03ca952007-10-19 19:38:43 +0800111 .mask = IPIC_SIMSR_H,
112 .prio = IPIC_SIPRR_D,
113 .force = IPIC_SIFCR_H,
114 .bit = 27,
115 .prio_mask = 3,
116 },
117 [13] = {
Li Yangf03ca952007-10-19 19:38:43 +0800118 .mask = IPIC_SIMSR_H,
119 .prio = IPIC_SIPRR_D,
120 .force = IPIC_SIFCR_H,
121 .bit = 28,
122 .prio_mask = 4,
123 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 [14] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 .mask = IPIC_SIMSR_H,
126 .prio = IPIC_SIPRR_D,
127 .force = IPIC_SIFCR_H,
128 .bit = 29,
129 .prio_mask = 5,
130 },
131 [15] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 .mask = IPIC_SIMSR_H,
133 .prio = IPIC_SIPRR_D,
134 .force = IPIC_SIFCR_H,
135 .bit = 30,
136 .prio_mask = 6,
137 },
138 [16] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 .mask = IPIC_SIMSR_H,
140 .prio = IPIC_SIPRR_D,
141 .force = IPIC_SIFCR_H,
142 .bit = 31,
143 .prio_mask = 7,
144 },
145 [17] = {
Li Yang77d43092007-12-04 19:01:40 +0800146 .ack = IPIC_SEPNR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 .mask = IPIC_SEMSR,
148 .prio = IPIC_SMPRR_A,
149 .force = IPIC_SEFCR,
150 .bit = 1,
151 .prio_mask = 5,
152 },
153 [18] = {
Li Yang77d43092007-12-04 19:01:40 +0800154 .ack = IPIC_SEPNR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 .mask = IPIC_SEMSR,
156 .prio = IPIC_SMPRR_A,
157 .force = IPIC_SEFCR,
158 .bit = 2,
159 .prio_mask = 6,
160 },
161 [19] = {
Li Yang77d43092007-12-04 19:01:40 +0800162 .ack = IPIC_SEPNR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 .mask = IPIC_SEMSR,
164 .prio = IPIC_SMPRR_A,
165 .force = IPIC_SEFCR,
166 .bit = 3,
167 .prio_mask = 7,
168 },
169 [20] = {
Li Yang77d43092007-12-04 19:01:40 +0800170 .ack = IPIC_SEPNR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 .mask = IPIC_SEMSR,
172 .prio = IPIC_SMPRR_B,
173 .force = IPIC_SEFCR,
174 .bit = 4,
175 .prio_mask = 4,
176 },
177 [21] = {
Li Yang77d43092007-12-04 19:01:40 +0800178 .ack = IPIC_SEPNR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 .mask = IPIC_SEMSR,
180 .prio = IPIC_SMPRR_B,
181 .force = IPIC_SEFCR,
182 .bit = 5,
183 .prio_mask = 5,
184 },
185 [22] = {
Li Yang77d43092007-12-04 19:01:40 +0800186 .ack = IPIC_SEPNR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 .mask = IPIC_SEMSR,
188 .prio = IPIC_SMPRR_B,
189 .force = IPIC_SEFCR,
190 .bit = 6,
191 .prio_mask = 6,
192 },
193 [23] = {
Li Yang77d43092007-12-04 19:01:40 +0800194 .ack = IPIC_SEPNR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 .mask = IPIC_SEMSR,
196 .prio = IPIC_SMPRR_B,
197 .force = IPIC_SEFCR,
198 .bit = 7,
199 .prio_mask = 7,
200 },
201 [32] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 .mask = IPIC_SIMSR_H,
203 .prio = IPIC_SIPRR_A,
204 .force = IPIC_SIFCR_H,
205 .bit = 0,
206 .prio_mask = 0,
207 },
208 [33] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 .mask = IPIC_SIMSR_H,
210 .prio = IPIC_SIPRR_A,
211 .force = IPIC_SIFCR_H,
212 .bit = 1,
213 .prio_mask = 1,
214 },
215 [34] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 .mask = IPIC_SIMSR_H,
217 .prio = IPIC_SIPRR_A,
218 .force = IPIC_SIFCR_H,
219 .bit = 2,
220 .prio_mask = 2,
221 },
222 [35] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 .mask = IPIC_SIMSR_H,
224 .prio = IPIC_SIPRR_A,
225 .force = IPIC_SIFCR_H,
226 .bit = 3,
227 .prio_mask = 3,
228 },
229 [36] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 .mask = IPIC_SIMSR_H,
231 .prio = IPIC_SIPRR_A,
232 .force = IPIC_SIFCR_H,
233 .bit = 4,
234 .prio_mask = 4,
235 },
236 [37] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 .mask = IPIC_SIMSR_H,
238 .prio = IPIC_SIPRR_A,
239 .force = IPIC_SIFCR_H,
240 .bit = 5,
241 .prio_mask = 5,
242 },
243 [38] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 .mask = IPIC_SIMSR_H,
245 .prio = IPIC_SIPRR_A,
246 .force = IPIC_SIFCR_H,
247 .bit = 6,
248 .prio_mask = 6,
249 },
250 [39] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 .mask = IPIC_SIMSR_H,
252 .prio = IPIC_SIPRR_A,
253 .force = IPIC_SIFCR_H,
254 .bit = 7,
255 .prio_mask = 7,
256 },
John Rigbya7267d62008-01-17 17:05:32 -0700257 [40] = {
258 .mask = IPIC_SIMSR_H,
259 .prio = IPIC_SIPRR_B,
260 .force = IPIC_SIFCR_H,
261 .bit = 8,
262 .prio_mask = 0,
263 },
264 [41] = {
265 .mask = IPIC_SIMSR_H,
266 .prio = IPIC_SIPRR_B,
267 .force = IPIC_SIFCR_H,
268 .bit = 9,
269 .prio_mask = 1,
270 },
Li Yangf03ca952007-10-19 19:38:43 +0800271 [42] = {
Li Yangf03ca952007-10-19 19:38:43 +0800272 .mask = IPIC_SIMSR_H,
273 .prio = IPIC_SIPRR_B,
274 .force = IPIC_SIFCR_H,
275 .bit = 10,
276 .prio_mask = 2,
277 },
John Rigbya7267d62008-01-17 17:05:32 -0700278 [43] = {
279 .mask = IPIC_SIMSR_H,
280 .prio = IPIC_SIPRR_B,
281 .force = IPIC_SIFCR_H,
282 .bit = 11,
283 .prio_mask = 3,
284 },
Li Yangf03ca952007-10-19 19:38:43 +0800285 [44] = {
Li Yangf03ca952007-10-19 19:38:43 +0800286 .mask = IPIC_SIMSR_H,
287 .prio = IPIC_SIPRR_B,
288 .force = IPIC_SIFCR_H,
289 .bit = 12,
290 .prio_mask = 4,
291 },
292 [45] = {
Li Yangf03ca952007-10-19 19:38:43 +0800293 .mask = IPIC_SIMSR_H,
294 .prio = IPIC_SIPRR_B,
295 .force = IPIC_SIFCR_H,
296 .bit = 13,
297 .prio_mask = 5,
298 },
299 [46] = {
Li Yangf03ca952007-10-19 19:38:43 +0800300 .mask = IPIC_SIMSR_H,
301 .prio = IPIC_SIPRR_B,
302 .force = IPIC_SIFCR_H,
303 .bit = 14,
304 .prio_mask = 6,
305 },
306 [47] = {
Li Yangf03ca952007-10-19 19:38:43 +0800307 .mask = IPIC_SIMSR_H,
308 .prio = IPIC_SIPRR_B,
309 .force = IPIC_SIFCR_H,
310 .bit = 15,
311 .prio_mask = 7,
312 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 [48] = {
Scott Wood446183e2017-06-24 21:39:05 -0500314 .ack = IPIC_SEPNR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 .mask = IPIC_SEMSR,
316 .prio = IPIC_SMPRR_A,
317 .force = IPIC_SEFCR,
318 .bit = 0,
319 .prio_mask = 4,
320 },
321 [64] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 .mask = IPIC_SIMSR_L,
323 .prio = IPIC_SMPRR_A,
324 .force = IPIC_SIFCR_L,
325 .bit = 0,
326 .prio_mask = 0,
327 },
328 [65] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 .mask = IPIC_SIMSR_L,
330 .prio = IPIC_SMPRR_A,
331 .force = IPIC_SIFCR_L,
332 .bit = 1,
333 .prio_mask = 1,
334 },
335 [66] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 .mask = IPIC_SIMSR_L,
337 .prio = IPIC_SMPRR_A,
338 .force = IPIC_SIFCR_L,
339 .bit = 2,
340 .prio_mask = 2,
341 },
342 [67] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 .mask = IPIC_SIMSR_L,
344 .prio = IPIC_SMPRR_A,
345 .force = IPIC_SIFCR_L,
346 .bit = 3,
347 .prio_mask = 3,
348 },
349 [68] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 .mask = IPIC_SIMSR_L,
351 .prio = IPIC_SMPRR_B,
352 .force = IPIC_SIFCR_L,
353 .bit = 4,
354 .prio_mask = 0,
355 },
356 [69] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 .mask = IPIC_SIMSR_L,
358 .prio = IPIC_SMPRR_B,
359 .force = IPIC_SIFCR_L,
360 .bit = 5,
361 .prio_mask = 1,
362 },
363 [70] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 .mask = IPIC_SIMSR_L,
365 .prio = IPIC_SMPRR_B,
366 .force = IPIC_SIFCR_L,
367 .bit = 6,
368 .prio_mask = 2,
369 },
370 [71] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 .mask = IPIC_SIMSR_L,
372 .prio = IPIC_SMPRR_B,
373 .force = IPIC_SIFCR_L,
374 .bit = 7,
375 .prio_mask = 3,
376 },
377 [72] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 .mask = IPIC_SIMSR_L,
379 .prio = 0,
380 .force = IPIC_SIFCR_L,
381 .bit = 8,
382 },
383 [73] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 .mask = IPIC_SIMSR_L,
385 .prio = 0,
386 .force = IPIC_SIFCR_L,
387 .bit = 9,
388 },
389 [74] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 .mask = IPIC_SIMSR_L,
391 .prio = 0,
392 .force = IPIC_SIFCR_L,
393 .bit = 10,
394 },
395 [75] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 .mask = IPIC_SIMSR_L,
397 .prio = 0,
398 .force = IPIC_SIFCR_L,
399 .bit = 11,
400 },
401 [76] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 .mask = IPIC_SIMSR_L,
403 .prio = 0,
404 .force = IPIC_SIFCR_L,
405 .bit = 12,
406 },
407 [77] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 .mask = IPIC_SIMSR_L,
409 .prio = 0,
410 .force = IPIC_SIFCR_L,
411 .bit = 13,
412 },
413 [78] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 .mask = IPIC_SIMSR_L,
415 .prio = 0,
416 .force = IPIC_SIFCR_L,
417 .bit = 14,
418 },
419 [79] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 .mask = IPIC_SIMSR_L,
421 .prio = 0,
422 .force = IPIC_SIFCR_L,
423 .bit = 15,
424 },
425 [80] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 .mask = IPIC_SIMSR_L,
427 .prio = 0,
428 .force = IPIC_SIFCR_L,
429 .bit = 16,
430 },
Li Yangf03ca952007-10-19 19:38:43 +0800431 [81] = {
Li Yangf03ca952007-10-19 19:38:43 +0800432 .mask = IPIC_SIMSR_L,
433 .prio = 0,
434 .force = IPIC_SIFCR_L,
435 .bit = 17,
436 },
437 [82] = {
Li Yangf03ca952007-10-19 19:38:43 +0800438 .mask = IPIC_SIMSR_L,
439 .prio = 0,
440 .force = IPIC_SIFCR_L,
441 .bit = 18,
442 },
John Rigbya7267d62008-01-17 17:05:32 -0700443 [83] = {
444 .mask = IPIC_SIMSR_L,
445 .prio = 0,
446 .force = IPIC_SIFCR_L,
447 .bit = 19,
448 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 [84] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 .mask = IPIC_SIMSR_L,
451 .prio = 0,
452 .force = IPIC_SIFCR_L,
453 .bit = 20,
454 },
455 [85] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 .mask = IPIC_SIMSR_L,
457 .prio = 0,
458 .force = IPIC_SIFCR_L,
459 .bit = 21,
460 },
Li Yangf03ca952007-10-19 19:38:43 +0800461 [86] = {
Li Yangf03ca952007-10-19 19:38:43 +0800462 .mask = IPIC_SIMSR_L,
463 .prio = 0,
464 .force = IPIC_SIFCR_L,
465 .bit = 22,
466 },
467 [87] = {
Li Yangf03ca952007-10-19 19:38:43 +0800468 .mask = IPIC_SIMSR_L,
469 .prio = 0,
470 .force = IPIC_SIFCR_L,
471 .bit = 23,
472 },
473 [88] = {
Li Yangf03ca952007-10-19 19:38:43 +0800474 .mask = IPIC_SIMSR_L,
475 .prio = 0,
476 .force = IPIC_SIFCR_L,
477 .bit = 24,
478 },
479 [89] = {
Li Yangf03ca952007-10-19 19:38:43 +0800480 .mask = IPIC_SIMSR_L,
481 .prio = 0,
482 .force = IPIC_SIFCR_L,
483 .bit = 25,
484 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 [90] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 .mask = IPIC_SIMSR_L,
487 .prio = 0,
488 .force = IPIC_SIFCR_L,
489 .bit = 26,
490 },
491 [91] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 .mask = IPIC_SIMSR_L,
493 .prio = 0,
494 .force = IPIC_SIFCR_L,
495 .bit = 27,
496 },
Kim Phillips8cf6b1952008-01-24 20:46:50 -0600497 [94] = {
498 .mask = IPIC_SIMSR_L,
499 .prio = 0,
500 .force = IPIC_SIFCR_L,
501 .bit = 30,
502 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503};
504
505static inline u32 ipic_read(volatile u32 __iomem *base, unsigned int reg)
506{
507 return in_be32(base + (reg >> 2));
508}
509
510static inline void ipic_write(volatile u32 __iomem *base, unsigned int reg, u32 value)
511{
512 out_be32(base + (reg >> 2), value);
513}
514
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500515static inline struct ipic * ipic_from_irq(unsigned int virq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516{
517 return primary_ipic;
518}
519
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000520static void ipic_unmask_irq(struct irq_data *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000522 struct ipic *ipic = ipic_from_irq(d->irq);
Grant Likely476eb492011-05-04 15:02:15 +1000523 unsigned int src = irqd_to_hwirq(d);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500524 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 u32 temp;
526
Thomas Gleixnera9e8bf22010-02-18 02:23:14 +0000527 raw_spin_lock_irqsave(&ipic_lock, flags);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 temp = ipic_read(ipic->regs, ipic_info[src].mask);
530 temp |= (1 << (31 - ipic_info[src].bit));
531 ipic_write(ipic->regs, ipic_info[src].mask, temp);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500532
Thomas Gleixnera9e8bf22010-02-18 02:23:14 +0000533 raw_spin_unlock_irqrestore(&ipic_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534}
535
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000536static void ipic_mask_irq(struct irq_data *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000538 struct ipic *ipic = ipic_from_irq(d->irq);
Grant Likely476eb492011-05-04 15:02:15 +1000539 unsigned int src = irqd_to_hwirq(d);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500540 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 u32 temp;
542
Thomas Gleixnera9e8bf22010-02-18 02:23:14 +0000543 raw_spin_lock_irqsave(&ipic_lock, flags);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500544
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 temp = ipic_read(ipic->regs, ipic_info[src].mask);
546 temp &= ~(1 << (31 - ipic_info[src].bit));
547 ipic_write(ipic->regs, ipic_info[src].mask, temp);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500548
Li Yang77d43092007-12-04 19:01:40 +0800549 /* mb() can't guarantee that masking is finished. But it does finish
550 * for nearly all cases. */
551 mb();
552
Thomas Gleixnera9e8bf22010-02-18 02:23:14 +0000553 raw_spin_unlock_irqrestore(&ipic_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554}
555
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000556static void ipic_ack_irq(struct irq_data *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000558 struct ipic *ipic = ipic_from_irq(d->irq);
Grant Likely476eb492011-05-04 15:02:15 +1000559 unsigned int src = irqd_to_hwirq(d);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500560 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 u32 temp;
562
Thomas Gleixnera9e8bf22010-02-18 02:23:14 +0000563 raw_spin_lock_irqsave(&ipic_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
dayu@datangmobile.cn30c40462009-02-18 13:47:42 +0800565 temp = 1 << (31 - ipic_info[src].bit);
Li Yang77d43092007-12-04 19:01:40 +0800566 ipic_write(ipic->regs, ipic_info[src].ack, temp);
567
568 /* mb() can't guarantee that ack is finished. But it does finish
569 * for nearly all cases. */
570 mb();
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500571
Thomas Gleixnera9e8bf22010-02-18 02:23:14 +0000572 raw_spin_unlock_irqrestore(&ipic_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573}
574
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000575static void ipic_mask_irq_and_ack(struct irq_data *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576{
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000577 struct ipic *ipic = ipic_from_irq(d->irq);
Grant Likely476eb492011-05-04 15:02:15 +1000578 unsigned int src = irqd_to_hwirq(d);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500579 unsigned long flags;
580 u32 temp;
581
Thomas Gleixnera9e8bf22010-02-18 02:23:14 +0000582 raw_spin_lock_irqsave(&ipic_lock, flags);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500583
584 temp = ipic_read(ipic->regs, ipic_info[src].mask);
585 temp &= ~(1 << (31 - ipic_info[src].bit));
586 ipic_write(ipic->regs, ipic_info[src].mask, temp);
587
dayu@datangmobile.cn30c40462009-02-18 13:47:42 +0800588 temp = 1 << (31 - ipic_info[src].bit);
Li Yang77d43092007-12-04 19:01:40 +0800589 ipic_write(ipic->regs, ipic_info[src].ack, temp);
590
591 /* mb() can't guarantee that ack is finished. But it does finish
592 * for nearly all cases. */
593 mb();
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500594
Thomas Gleixnera9e8bf22010-02-18 02:23:14 +0000595 raw_spin_unlock_irqrestore(&ipic_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596}
597
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000598static int ipic_set_irq_type(struct irq_data *d, unsigned int flow_type)
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500599{
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000600 struct ipic *ipic = ipic_from_irq(d->irq);
Grant Likely476eb492011-05-04 15:02:15 +1000601 unsigned int src = irqd_to_hwirq(d);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500602 unsigned int vold, vnew, edibit;
603
604 if (flow_type == IRQ_TYPE_NONE)
605 flow_type = IRQ_TYPE_LEVEL_LOW;
606
607 /* ipic supports only low assertion and high-to-low change senses
608 */
609 if (!(flow_type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_EDGE_FALLING))) {
610 printk(KERN_ERR "ipic: sense type 0x%x not supported\n",
611 flow_type);
612 return -EINVAL;
613 }
Li Yang77d43092007-12-04 19:01:40 +0800614 /* ipic supports only edge mode on external interrupts */
615 if ((flow_type & IRQ_TYPE_EDGE_FALLING) && !ipic_info[src].ack) {
616 printk(KERN_ERR "ipic: edge sense not supported on internal "
617 "interrupts\n");
618 return -EINVAL;
Thomas Gleixnerecf4b192011-03-25 16:16:30 +0100619
Li Yang77d43092007-12-04 19:01:40 +0800620 }
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500621
Thomas Gleixnerecf4b192011-03-25 16:16:30 +0100622 irqd_set_trigger_type(d, flow_type);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500623 if (flow_type & IRQ_TYPE_LEVEL_LOW) {
Thomas Gleixner9758a7b2015-06-23 15:52:34 +0200624 irq_set_handler_locked(d, handle_level_irq);
Thomas Gleixnerecf4b192011-03-25 16:16:30 +0100625 d->chip = &ipic_level_irq_chip;
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500626 } else {
Thomas Gleixner9758a7b2015-06-23 15:52:34 +0200627 irq_set_handler_locked(d, handle_edge_irq);
Thomas Gleixnerecf4b192011-03-25 16:16:30 +0100628 d->chip = &ipic_edge_irq_chip;
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500629 }
630
631 /* only EXT IRQ senses are programmable on ipic
632 * internal IRQ senses are LEVEL_LOW
633 */
634 if (src == IPIC_IRQ_EXT0)
635 edibit = 15;
636 else
637 if (src >= IPIC_IRQ_EXT1 && src <= IPIC_IRQ_EXT7)
638 edibit = (14 - (src - IPIC_IRQ_EXT1));
639 else
640 return (flow_type & IRQ_TYPE_LEVEL_LOW) ? 0 : -EINVAL;
641
642 vold = ipic_read(ipic->regs, IPIC_SECNR);
643 if ((flow_type & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_FALLING) {
644 vnew = vold | (1 << edibit);
645 } else {
646 vnew = vold & ~(1 << edibit);
647 }
648 if (vold != vnew)
649 ipic_write(ipic->regs, IPIC_SECNR, vnew);
Thomas Gleixnerecf4b192011-03-25 16:16:30 +0100650 return IRQ_SET_MASK_OK_NOCOPY;
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500651}
652
Li Yang77d43092007-12-04 19:01:40 +0800653/* level interrupts and edge interrupts have different ack operations */
654static struct irq_chip ipic_level_irq_chip = {
Anton Blanchardfc380c02010-01-31 20:33:41 +0000655 .name = "IPIC",
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000656 .irq_unmask = ipic_unmask_irq,
657 .irq_mask = ipic_mask_irq,
658 .irq_mask_ack = ipic_mask_irq,
659 .irq_set_type = ipic_set_irq_type,
Li Yang77d43092007-12-04 19:01:40 +0800660};
661
662static struct irq_chip ipic_edge_irq_chip = {
Anton Blanchardfc380c02010-01-31 20:33:41 +0000663 .name = "IPIC",
Lennert Buytenhek687228a2011-03-07 13:59:58 +0000664 .irq_unmask = ipic_unmask_irq,
665 .irq_mask = ipic_mask_irq,
666 .irq_mask_ack = ipic_mask_irq_and_ack,
667 .irq_ack = ipic_ack_irq,
668 .irq_set_type = ipic_set_irq_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669};
670
Marc Zyngierad3aedf2015-07-28 14:46:08 +0100671static int ipic_host_match(struct irq_domain *h, struct device_node *node,
672 enum irq_domain_bus_token bus_token)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673{
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500674 /* Exact match, unless ipic node is NULL */
Marc Zyngier5d4c9bc2015-10-13 12:51:29 +0100675 struct device_node *of_node = irq_domain_get_of_node(h);
676 return of_node == NULL || of_node == node;
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500677}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
Grant Likelybae1d8f2012-02-14 14:06:50 -0700679static int ipic_host_map(struct irq_domain *h, unsigned int virq,
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500680 irq_hw_number_t hw)
681{
682 struct ipic *ipic = h->host_data;
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500683
Thomas Gleixnerec775d02011-03-25 16:45:20 +0100684 irq_set_chip_data(virq, ipic);
685 irq_set_chip_and_handler(virq, &ipic_level_irq_chip, handle_level_irq);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500686
687 /* Set default irq type */
Thomas Gleixnerec775d02011-03-25 16:45:20 +0100688 irq_set_irq_type(virq, IRQ_TYPE_NONE);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500689
690 return 0;
691}
692
Krzysztof Kozlowski202648a2015-04-27 21:48:47 +0900693static const struct irq_domain_ops ipic_host_ops = {
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500694 .match = ipic_host_match,
695 .map = ipic_host_map,
Grant Likelyff8c3ab2012-01-24 17:09:13 -0700696 .xlate = irq_domain_xlate_onetwocell,
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500697};
698
Kumar Gala126186a2007-01-26 01:45:32 -0600699struct ipic * __init ipic_init(struct device_node *node, unsigned int flags)
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500700{
701 struct ipic *ipic;
702 struct resource res;
703 u32 temp = 0, ret;
704
Michael Ellerman84f1c1e2008-05-26 12:12:30 +1000705 ret = of_address_to_resource(node, 0, &res);
706 if (ret)
707 return NULL;
708
Anton Vorontsovea960252009-07-01 10:59:57 +0000709 ipic = kzalloc(sizeof(*ipic), GFP_KERNEL);
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500710 if (ipic == NULL)
Kumar Gala126186a2007-01-26 01:45:32 -0600711 return NULL;
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500712
Grant Likelya8db8cf2012-02-14 14:06:54 -0700713 ipic->irqhost = irq_domain_add_linear(node, NR_IPIC_INTS,
714 &ipic_host_ops, ipic);
Julia Lawall7a626b62009-08-02 10:44:53 +0200715 if (ipic->irqhost == NULL) {
716 kfree(ipic);
Kumar Gala126186a2007-01-26 01:45:32 -0600717 return NULL;
Julia Lawall7a626b62009-08-02 10:44:53 +0200718 }
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500719
Joe Perches28f65c112011-06-09 09:13:32 -0700720 ipic->regs = ioremap(res.start, resource_size(&res));
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500721
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500722 /* init hw */
723 ipic_write(ipic->regs, IPIC_SICNR, 0x0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
725 /* default priority scheme is grouped. If spread mode is required
726 * configure SICFR accordingly */
727 if (flags & IPIC_SPREADMODE_GRP_A)
728 temp |= SICFR_IPSA;
Li Yangf03ca952007-10-19 19:38:43 +0800729 if (flags & IPIC_SPREADMODE_GRP_B)
730 temp |= SICFR_IPSB;
731 if (flags & IPIC_SPREADMODE_GRP_C)
732 temp |= SICFR_IPSC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 if (flags & IPIC_SPREADMODE_GRP_D)
734 temp |= SICFR_IPSD;
735 if (flags & IPIC_SPREADMODE_MIX_A)
736 temp |= SICFR_MPSA;
737 if (flags & IPIC_SPREADMODE_MIX_B)
738 temp |= SICFR_MPSB;
739
Li Yangf03ca952007-10-19 19:38:43 +0800740 ipic_write(ipic->regs, IPIC_SICFR, temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
742 /* handle MCP route */
743 temp = 0;
744 if (flags & IPIC_DISABLE_MCP_OUT)
745 temp = SERCR_MCPR;
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500746 ipic_write(ipic->regs, IPIC_SERCR, temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
748 /* handle routing of IRQ0 to MCP */
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500749 temp = ipic_read(ipic->regs, IPIC_SEMSR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751 if (flags & IPIC_IRQ0_MCP)
752 temp |= SEMSR_SIRQ0;
753 else
754 temp &= ~SEMSR_SIRQ0;
755
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500756 ipic_write(ipic->regs, IPIC_SEMSR, temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500758 primary_ipic = ipic;
759 irq_set_default_host(primary_ipic->irqhost);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Sebastian Andrzej Siewior8640d3b2009-08-05 21:41:12 +0200761 ipic_write(ipic->regs, IPIC_SIMSR_H, 0);
762 ipic_write(ipic->regs, IPIC_SIMSR_L, 0);
763
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500764 printk ("IPIC (%d IRQ sources) at %p\n", NR_IPIC_INTS,
765 primary_ipic->regs);
Kumar Gala126186a2007-01-26 01:45:32 -0600766
767 return ipic;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768}
769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770void ipic_set_default_priority(void)
771{
Li Yangf03ca952007-10-19 19:38:43 +0800772 ipic_write(primary_ipic->regs, IPIC_SIPRR_A, IPIC_PRIORITY_DEFAULT);
773 ipic_write(primary_ipic->regs, IPIC_SIPRR_B, IPIC_PRIORITY_DEFAULT);
774 ipic_write(primary_ipic->regs, IPIC_SIPRR_C, IPIC_PRIORITY_DEFAULT);
775 ipic_write(primary_ipic->regs, IPIC_SIPRR_D, IPIC_PRIORITY_DEFAULT);
776 ipic_write(primary_ipic->regs, IPIC_SMPRR_A, IPIC_PRIORITY_DEFAULT);
777 ipic_write(primary_ipic->regs, IPIC_SMPRR_B, IPIC_PRIORITY_DEFAULT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778}
779
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780u32 ipic_get_mcp_status(void)
781{
Christophe Leroy6beb3382018-08-27 08:27:27 +0000782 return primary_ipic ? ipic_read(primary_ipic->regs, IPIC_SERSR) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783}
784
785void ipic_clear_mcp_status(u32 mask)
786{
Christophe Leroy6b148a72017-10-18 11:16:47 +0200787 ipic_write(primary_ipic->regs, IPIC_SERSR, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788}
789
Michael Ellermanef24ba72016-09-06 21:53:24 +1000790/* Return an interrupt vector or 0 if no interrupt is pending. */
Olaf Hering35a84c22006-10-07 22:08:26 +1000791unsigned int ipic_get_irq(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792{
793 int irq;
794
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500795 BUG_ON(primary_ipic == NULL);
796
797#define IPIC_SIVCR_VECTOR_MASK 0x7f
798 irq = ipic_read(primary_ipic->regs, IPIC_SIVCR) & IPIC_SIVCR_VECTOR_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
800 if (irq == 0) /* 0 --> no irq is pending */
Michael Ellermanef24ba72016-09-06 21:53:24 +1000801 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
Kim Phillipsb9f0f1b2006-08-25 11:59:07 -0500803 return irq_linear_revmap(primary_ipic->irqhost, irq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804}
805
Michael Neulinge2a02ba2009-02-06 11:10:27 +1100806#ifdef CONFIG_SUSPEND
Scott Woodd49747b2007-10-09 12:37:13 -0500807static struct {
808 u32 sicfr;
809 u32 siprr[2];
810 u32 simsr[2];
811 u32 sicnr;
812 u32 smprr[2];
813 u32 semsr;
814 u32 secnr;
815 u32 sermr;
816 u32 sercr;
817} ipic_saved_state;
818
Rafael J. Wysockif5a592f2011-04-26 19:14:57 +0200819static int ipic_suspend(void)
Scott Woodd49747b2007-10-09 12:37:13 -0500820{
821 struct ipic *ipic = primary_ipic;
822
823 ipic_saved_state.sicfr = ipic_read(ipic->regs, IPIC_SICFR);
824 ipic_saved_state.siprr[0] = ipic_read(ipic->regs, IPIC_SIPRR_A);
825 ipic_saved_state.siprr[1] = ipic_read(ipic->regs, IPIC_SIPRR_D);
826 ipic_saved_state.simsr[0] = ipic_read(ipic->regs, IPIC_SIMSR_H);
827 ipic_saved_state.simsr[1] = ipic_read(ipic->regs, IPIC_SIMSR_L);
828 ipic_saved_state.sicnr = ipic_read(ipic->regs, IPIC_SICNR);
829 ipic_saved_state.smprr[0] = ipic_read(ipic->regs, IPIC_SMPRR_A);
830 ipic_saved_state.smprr[1] = ipic_read(ipic->regs, IPIC_SMPRR_B);
831 ipic_saved_state.semsr = ipic_read(ipic->regs, IPIC_SEMSR);
832 ipic_saved_state.secnr = ipic_read(ipic->regs, IPIC_SECNR);
833 ipic_saved_state.sermr = ipic_read(ipic->regs, IPIC_SERMR);
834 ipic_saved_state.sercr = ipic_read(ipic->regs, IPIC_SERCR);
835
836 if (fsl_deep_sleep()) {
837 /* In deep sleep, make sure there can be no
838 * pending interrupts, as this can cause
839 * problems on 831x.
840 */
841 ipic_write(ipic->regs, IPIC_SIMSR_H, 0);
842 ipic_write(ipic->regs, IPIC_SIMSR_L, 0);
843 ipic_write(ipic->regs, IPIC_SEMSR, 0);
844 ipic_write(ipic->regs, IPIC_SERMR, 0);
845 }
846
847 return 0;
848}
849
Rafael J. Wysockif5a592f2011-04-26 19:14:57 +0200850static void ipic_resume(void)
Scott Woodd49747b2007-10-09 12:37:13 -0500851{
852 struct ipic *ipic = primary_ipic;
853
854 ipic_write(ipic->regs, IPIC_SICFR, ipic_saved_state.sicfr);
855 ipic_write(ipic->regs, IPIC_SIPRR_A, ipic_saved_state.siprr[0]);
856 ipic_write(ipic->regs, IPIC_SIPRR_D, ipic_saved_state.siprr[1]);
857 ipic_write(ipic->regs, IPIC_SIMSR_H, ipic_saved_state.simsr[0]);
858 ipic_write(ipic->regs, IPIC_SIMSR_L, ipic_saved_state.simsr[1]);
859 ipic_write(ipic->regs, IPIC_SICNR, ipic_saved_state.sicnr);
860 ipic_write(ipic->regs, IPIC_SMPRR_A, ipic_saved_state.smprr[0]);
861 ipic_write(ipic->regs, IPIC_SMPRR_B, ipic_saved_state.smprr[1]);
862 ipic_write(ipic->regs, IPIC_SEMSR, ipic_saved_state.semsr);
863 ipic_write(ipic->regs, IPIC_SECNR, ipic_saved_state.secnr);
864 ipic_write(ipic->regs, IPIC_SERMR, ipic_saved_state.sermr);
865 ipic_write(ipic->regs, IPIC_SERCR, ipic_saved_state.sercr);
Scott Woodd49747b2007-10-09 12:37:13 -0500866}
867#else
868#define ipic_suspend NULL
869#define ipic_resume NULL
870#endif
871
Rafael J. Wysockif5a592f2011-04-26 19:14:57 +0200872static struct syscore_ops ipic_syscore_ops = {
Scott Woodd49747b2007-10-09 12:37:13 -0500873 .suspend = ipic_suspend,
874 .resume = ipic_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875};
876
Rafael J. Wysockif5a592f2011-04-26 19:14:57 +0200877static int __init init_ipic_syscore(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878{
Olaf Hering1428a9f2008-03-18 06:53:05 +1100879 if (!primary_ipic || !primary_ipic->regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
Rafael J. Wysockif5a592f2011-04-26 19:14:57 +0200882 printk(KERN_DEBUG "Registering ipic system core operations\n");
883 register_syscore_ops(&ipic_syscore_ops);
884
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 return 0;
886}
887
Rafael J. Wysockif5a592f2011-04-26 19:14:57 +0200888subsys_initcall(init_ipic_syscore);