FreeBSD/Linux Kernel Cross Reference
sys/mips/cavium/ciu.c
1 /*-
2 * Copyright (c) 2010 Juli Mallett <jmallett@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD: releng/8.4/sys/mips/cavium/ciu.c 215938 2010-11-27 12:26:40Z jchandra $
27 */
28
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD: releng/8.4/sys/mips/cavium/ciu.c 215938 2010-11-27 12:26:40Z jchandra $");
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/bus.h>
35 #include <sys/interrupt.h>
36 #include <sys/kernel.h>
37 #include <sys/module.h>
38 #include <sys/rman.h>
39 #include <sys/malloc.h>
40
41 #include <machine/bus.h>
42 #include <machine/intr_machdep.h>
43
44 #include <contrib/octeon-sdk/cvmx.h>
45 #include <contrib/octeon-sdk/cvmx-interrupt.h>
46
47 /*
48 * This bus sits between devices/buses and nexus and handles CIU interrupts
49 * and passes everything else through. It should really be a nexus subclass
50 * or something, but for now this will be sufficient.
51 */
52
53 #define CIU_IRQ_HARD (0)
54
55 #define CIU_IRQ_EN0_BEGIN CVMX_IRQ_WORKQ0
56 #define CIU_IRQ_EN0_END CVMX_IRQ_BOOTDMA
57 #define CIU_IRQ_EN0_COUNT ((CIU_IRQ_EN0_END - CIU_IRQ_EN0_BEGIN) + 1)
58
59 #define CIU_IRQ_EN1_BEGIN CVMX_IRQ_WDOG0
60 #define CIU_IRQ_EN1_END CVMX_IRQ_WDOG15
61 #define CIU_IRQ_EN1_COUNT ((CIU_IRQ_EN1_END - CIU_IRQ_EN1_BEGIN) + 1)
62
63 struct ciu_softc {
64 struct rman irq_rman;
65 struct resource *ciu_irq;
66 };
67
68 static mips_intrcnt_t ciu_en0_intrcnt[CIU_IRQ_EN0_COUNT];
69 static mips_intrcnt_t ciu_en1_intrcnt[CIU_IRQ_EN1_COUNT];
70
71 static struct intr_event *ciu_en0_intr_events[CIU_IRQ_EN0_COUNT];
72 static struct intr_event *ciu_en1_intr_events[CIU_IRQ_EN1_COUNT];
73
74 static int ciu_probe(device_t);
75 static int ciu_attach(device_t);
76 static struct resource *ciu_alloc_resource(device_t, device_t, int, int *,
77 u_long, u_long, u_long, u_int);
78 static int ciu_setup_intr(device_t, device_t, struct resource *,
79 int, driver_filter_t *, driver_intr_t *,
80 void *, void **);
81 static int ciu_teardown_intr(device_t, device_t,
82 struct resource *, void *);
83 static void ciu_hinted_child(device_t, const char *, int);
84
85 static void ciu_en0_intr_mask(void *);
86 static void ciu_en0_intr_unmask(void *);
87
88 static void ciu_en1_intr_mask(void *);
89 static void ciu_en1_intr_unmask(void *);
90
91 static int ciu_intr(void *);
92
93 static int
94 ciu_probe(device_t dev)
95 {
96 if (device_get_unit(dev) != 0)
97 return (ENXIO);
98
99 device_set_desc(dev, "Cavium Octeon Central Interrupt Unit");
100 return (0);
101 }
102
103 static int
104 ciu_attach(device_t dev)
105 {
106 char name[MAXCOMLEN + 1];
107 struct ciu_softc *sc;
108 unsigned i;
109 int error;
110 int rid;
111
112 sc = device_get_softc(dev);
113
114 rid = 0;
115 sc->ciu_irq = bus_alloc_resource(dev, SYS_RES_IRQ, &rid, CIU_IRQ_HARD,
116 CIU_IRQ_HARD, 1, RF_ACTIVE);
117 if (sc->ciu_irq == NULL) {
118 device_printf(dev, "could not allocate irq%d\n", CIU_IRQ_HARD);
119 return (ENXIO);
120 }
121
122 error = bus_setup_intr(dev, sc->ciu_irq, INTR_TYPE_MISC, ciu_intr,
123 NULL, sc, NULL);
124 if (error != 0) {
125 device_printf(dev, "bus_setup_intr failed: %d\n", error);
126 return (error);
127 }
128
129 sc->irq_rman.rm_type = RMAN_ARRAY;
130 sc->irq_rman.rm_descr = "CIU IRQ";
131
132 error = rman_init(&sc->irq_rman);
133 if (error != 0)
134 return (error);
135
136 /*
137 * We have two contiguous IRQ regions, use a single rman.
138 */
139 error = rman_manage_region(&sc->irq_rman, CIU_IRQ_EN0_BEGIN,
140 CIU_IRQ_EN1_END);
141 if (error != 0)
142 return (error);
143
144 for (i = 0; i < CIU_IRQ_EN0_COUNT; i++) {
145 snprintf(name, sizeof name, "int%d:", i + CIU_IRQ_EN0_BEGIN);
146 ciu_en0_intrcnt[i] = mips_intrcnt_create(name);
147 }
148
149 for (i = 0; i < CIU_IRQ_EN1_COUNT; i++) {
150 snprintf(name, sizeof name, "int%d:", i + CIU_IRQ_EN1_BEGIN);
151 ciu_en1_intrcnt[i] = mips_intrcnt_create(name);
152 }
153
154 bus_generic_probe(dev);
155 bus_generic_attach(dev);
156
157 return (0);
158 }
159
160 static struct resource *
161 ciu_alloc_resource(device_t bus, device_t child, int type, int *rid,
162 u_long start, u_long end, u_long count, u_int flags)
163 {
164 struct resource *res;
165 struct ciu_softc *sc;
166
167 sc = device_get_softc(bus);
168
169 switch (type) {
170 case SYS_RES_IRQ:
171 break;
172 default:
173 return (bus_alloc_resource(device_get_parent(bus), type, rid,
174 start, end, count, flags));
175 }
176
177 /*
178 * One interrupt at a time for now.
179 */
180 if (start != end)
181 return (NULL);
182
183 res = rman_reserve_resource(&sc->irq_rman, start, end, count, flags,
184 child);
185 if (res != NULL)
186 return (res);
187
188 return (NULL);
189 }
190
191 static int
192 ciu_setup_intr(device_t bus, device_t child, struct resource *res, int flags,
193 driver_filter_t *filter, driver_intr_t *intr, void *arg,
194 void **cookiep)
195 {
196 struct intr_event *event, **eventp;
197 void (*mask_func)(void *);
198 void (*unmask_func)(void *);
199 mips_intrcnt_t intrcnt;
200 int error;
201 int irq;
202
203 irq = rman_get_start(res);
204 if (irq <= CIU_IRQ_EN0_END) {
205 eventp = &ciu_en0_intr_events[irq - CIU_IRQ_EN0_BEGIN];
206 intrcnt = ciu_en0_intrcnt[irq - CIU_IRQ_EN0_BEGIN];
207 mask_func = ciu_en0_intr_mask;
208 unmask_func = ciu_en0_intr_unmask;
209 } else {
210 eventp = &ciu_en1_intr_events[irq - CIU_IRQ_EN1_BEGIN];
211 intrcnt = ciu_en1_intrcnt[irq - CIU_IRQ_EN1_BEGIN];
212 mask_func = ciu_en1_intr_mask;
213 unmask_func = ciu_en1_intr_unmask;
214 }
215
216 if ((event = *eventp) == NULL) {
217 error = intr_event_create(eventp, (void *)(uintptr_t)irq, 0,
218 irq, mask_func, unmask_func, NULL, NULL, "int%d", irq);
219 if (error != 0)
220 return (error);
221
222 event = *eventp;
223
224 unmask_func((void *)(uintptr_t)irq);
225 }
226
227 intr_event_add_handler(event, device_get_nameunit(child),
228 filter, intr, arg, intr_priority(flags), flags, cookiep);
229
230 mips_intrcnt_setname(intrcnt, event->ie_fullname);
231
232 return (0);
233 }
234
235 static int
236 ciu_teardown_intr(device_t bus, device_t child, struct resource *res,
237 void *cookie)
238 {
239 int error;
240
241 error = intr_event_remove_handler(cookie);
242 if (error != 0)
243 return (error);
244
245 return (0);
246 }
247
248 static void
249 ciu_hinted_child(device_t bus, const char *dname, int dunit)
250 {
251 BUS_ADD_CHILD(bus, 0, dname, dunit);
252 }
253
254 static void
255 ciu_en0_intr_mask(void *arg)
256 {
257 uint64_t mask;
258 int irq;
259
260 irq = (uintptr_t)arg;
261 mask = cvmx_read_csr(CVMX_CIU_INTX_EN0(cvmx_get_core_num()*2));
262 mask &= ~(1ull << (irq - CIU_IRQ_EN0_BEGIN));
263 cvmx_write_csr(CVMX_CIU_INTX_EN0(cvmx_get_core_num()*2), mask);
264 }
265
266 static void
267 ciu_en0_intr_unmask(void *arg)
268 {
269 uint64_t mask;
270 int irq;
271
272 irq = (uintptr_t)arg;
273 mask = cvmx_read_csr(CVMX_CIU_INTX_EN0(cvmx_get_core_num()*2));
274 mask |= 1ull << (irq - CIU_IRQ_EN0_BEGIN);
275 cvmx_write_csr(CVMX_CIU_INTX_EN0(cvmx_get_core_num()*2), mask);
276 }
277
278 static void
279 ciu_en1_intr_mask(void *arg)
280 {
281 uint64_t mask;
282 int irq;
283
284 irq = (uintptr_t)arg;
285 mask = cvmx_read_csr(CVMX_CIU_INTX_EN1(cvmx_get_core_num()*2));
286 mask &= ~(1ull << (irq - CIU_IRQ_EN1_BEGIN));
287 cvmx_write_csr(CVMX_CIU_INTX_EN1(cvmx_get_core_num()*2), mask);
288 }
289
290 static void
291 ciu_en1_intr_unmask(void *arg)
292 {
293 uint64_t mask;
294 int irq;
295
296 irq = (uintptr_t)arg;
297 mask = cvmx_read_csr(CVMX_CIU_INTX_EN1(cvmx_get_core_num()*2));
298 mask |= 1ull << (irq - CIU_IRQ_EN1_BEGIN);
299 cvmx_write_csr(CVMX_CIU_INTX_EN1(cvmx_get_core_num()*2), mask);
300 }
301
302 static int
303 ciu_intr(void *arg)
304 {
305 struct ciu_softc *sc;
306 uint64_t en0_sum, en1_sum;
307 uint64_t en0_mask, en1_mask;
308 int irq_index;
309 int error;
310
311 sc = arg;
312 (void)sc;
313
314 en0_sum = cvmx_read_csr(CVMX_CIU_INTX_SUM0(cvmx_get_core_num()*2));
315 en1_sum = cvmx_read_csr(CVMX_CIU_INT_SUM1);
316
317 en0_mask = cvmx_read_csr(CVMX_CIU_INTX_EN0(cvmx_get_core_num()*2));
318 en1_mask = cvmx_read_csr(CVMX_CIU_INTX_EN1(cvmx_get_core_num()*2));
319
320 en0_sum &= en0_mask;
321 en1_sum &= en1_mask;
322
323 if (en0_sum == 0 && en1_sum == 0)
324 return (FILTER_STRAY);
325
326 irq_index = 0;
327 for (irq_index = 0; en0_sum != 0; irq_index++, en0_sum >>= 1) {
328 if ((en0_sum & 1) == 0)
329 continue;
330
331 mips_intrcnt_inc(ciu_en0_intrcnt[irq_index]);
332
333 error = intr_event_handle(ciu_en0_intr_events[irq_index], NULL);
334 if (error != 0)
335 printf("%s: stray en0 irq%d\n", __func__, irq_index);
336 }
337
338 irq_index = 0;
339 for (irq_index = 0; en1_sum != 0; irq_index++, en1_sum >>= 1) {
340 if ((en1_sum & 1) == 0)
341 continue;
342
343 mips_intrcnt_inc(ciu_en1_intrcnt[irq_index]);
344
345 error = intr_event_handle(ciu_en1_intr_events[irq_index], NULL);
346 if (error != 0)
347 printf("%s: stray en1 irq%d\n", __func__, irq_index);
348 }
349
350 return (FILTER_HANDLED);
351 }
352
353 static device_method_t ciu_methods[] = {
354 DEVMETHOD(device_probe, ciu_probe),
355 DEVMETHOD(device_attach, ciu_attach),
356
357 DEVMETHOD(bus_alloc_resource, ciu_alloc_resource),
358 DEVMETHOD(bus_activate_resource,bus_generic_activate_resource),
359 DEVMETHOD(bus_setup_intr, ciu_setup_intr),
360 DEVMETHOD(bus_teardown_intr, ciu_teardown_intr),
361
362 DEVMETHOD(bus_add_child, bus_generic_add_child),
363 DEVMETHOD(bus_hinted_child, ciu_hinted_child),
364
365 { 0, 0 }
366 };
367
368 static driver_t ciu_driver = {
369 "ciu",
370 ciu_methods,
371 sizeof(struct ciu_softc),
372 };
373 static devclass_t ciu_devclass;
374 DRIVER_MODULE(ciu, nexus, ciu_driver, ciu_devclass, 0, 0);
Cache object: 58e450a16e703d68838e34454cd48a08
|