xics.c revision 255643 
1/*-
2 * Copyright 2011 Nathan Whitehorn
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 *    notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 *    notice, this list of conditions and the following disclaimer in the
11 *    documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
18 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
20 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
21 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23 * SUCH DAMAGE.
24 */
25
26#include <sys/cdefs.h>
27__FBSDID("$FreeBSD: head/sys/powerpc/pseries/xics.c 255643 2013-09-17 17:37:04Z nwhitehorn $");
28
29#include <sys/param.h>
30#include <sys/systm.h>
31#include <sys/module.h>
32#include <sys/bus.h>
33#include <sys/conf.h>
34#include <sys/kernel.h>
35#include <sys/malloc.h>
36#include <sys/smp.h>
37
38#include <vm/vm.h>
39#include <vm/pmap.h>
40
41#include <machine/bus.h>
42#include <machine/intr_machdep.h>
43#include <machine/md_var.h>
44#include <machine/rtas.h>
45
46#include <dev/ofw/ofw_bus.h>
47#include <dev/ofw/ofw_bus_subr.h>
48
49#include "phyp-hvcall.h"
50#include "pic_if.h"
51
52#define XICP_PRIORITY	5	/* Random non-zero number */
53#define XICP_IPI	2
54#define MAX_XICP_IRQS	(1<<24)	/* 24-bit XIRR field */
55
56static int	xicp_probe(device_t);
57static int	xicp_attach(device_t);
58static int	xics_probe(device_t);
59static int	xics_attach(device_t);
60
61static void	xicp_bind(device_t dev, u_int irq, cpuset_t cpumask);
62static void	xicp_dispatch(device_t, struct trapframe *);
63static void	xicp_enable(device_t, u_int, u_int);
64static void	xicp_eoi(device_t, u_int);
65static void	xicp_ipi(device_t, u_int);
66static void	xicp_mask(device_t, u_int);
67static void	xicp_unmask(device_t, u_int);
68
69static device_method_t  xicp_methods[] = {
70	/* Device interface */
71	DEVMETHOD(device_probe,		xicp_probe),
72	DEVMETHOD(device_attach,	xicp_attach),
73
74	/* PIC interface */
75	DEVMETHOD(pic_bind,		xicp_bind),
76	DEVMETHOD(pic_dispatch,		xicp_dispatch),
77	DEVMETHOD(pic_enable,		xicp_enable),
78	DEVMETHOD(pic_eoi,		xicp_eoi),
79	DEVMETHOD(pic_ipi,		xicp_ipi),
80	DEVMETHOD(pic_mask,		xicp_mask),
81	DEVMETHOD(pic_unmask,		xicp_unmask),
82
83	{ 0, 0 },
84};
85
86static device_method_t  xics_methods[] = {
87	/* Device interface */
88	DEVMETHOD(device_probe,		xics_probe),
89	DEVMETHOD(device_attach,	xics_attach),
90
91	{ 0, 0 },
92};
93
94struct xicp_softc {
95	struct mtx sc_mtx;
96
97	int ibm_int_on;
98	int ibm_int_off;
99	int ibm_get_xive;
100	int ibm_set_xive;
101
102	/* XXX: inefficient -- hash table? tree? */
103	struct {
104		int irq;
105		int vector;
106	} intvecs[256];
107	int nintvecs;
108};
109
110static driver_t xicp_driver = {
111	"xicp",
112	xicp_methods,
113	sizeof(struct xicp_softc)
114};
115
116static driver_t xics_driver = {
117	"xics",
118	xics_methods,
119	0
120};
121
122static devclass_t xicp_devclass;
123static devclass_t xics_devclass;
124
125EARLY_DRIVER_MODULE(xicp, nexus, xicp_driver, xicp_devclass, 0, 0,
126    BUS_PASS_INTERRUPT-1);
127EARLY_DRIVER_MODULE(xics, nexus, xics_driver, xics_devclass, 0, 0,
128    BUS_PASS_INTERRUPT);
129
130static int
131xicp_probe(device_t dev)
132{
133	if (ofw_bus_get_name(dev) == NULL || strcmp(ofw_bus_get_name(dev),
134	    "interrupt-controller") != 0)
135		return (ENXIO);
136
137	if (!ofw_bus_is_compatible(dev, "ibm,ppc-xicp"))
138		return (ENXIO);
139
140	device_set_desc(dev, "PAPR virtual interrupt controller");
141	return (BUS_PROBE_GENERIC);
142}
143
144static int
145xics_probe(device_t dev)
146{
147	if (ofw_bus_get_name(dev) == NULL || strcmp(ofw_bus_get_name(dev),
148	    "interrupt-controller") != 0)
149		return (ENXIO);
150
151	if (!ofw_bus_is_compatible(dev, "ibm,ppc-xics"))
152		return (ENXIO);
153
154	device_set_desc(dev, "PAPR virtual interrupt source");
155	return (BUS_PROBE_GENERIC);
156}
157
158static int
159xicp_attach(device_t dev)
160{
161	struct xicp_softc *sc = device_get_softc(dev);
162	phandle_t phandle = ofw_bus_get_node(dev);
163
164	mtx_init(&sc->sc_mtx, "XICP", NULL, MTX_DEF);
165	sc->nintvecs = 0;
166
167	sc->ibm_int_on = rtas_token_lookup("ibm,int-on");
168	sc->ibm_int_off = rtas_token_lookup("ibm,int-off");
169	sc->ibm_set_xive = rtas_token_lookup("ibm,set-xive");
170	sc->ibm_get_xive = rtas_token_lookup("ibm,get-xive");
171
172	if (OF_getproplen(phandle, "ibm,phandle") > 0)
173		OF_getprop(phandle, "ibm,phandle", &phandle, sizeof(phandle));
174
175	powerpc_register_pic(dev, phandle, MAX_XICP_IRQS,
176	    1 /* Number of IPIs */, FALSE);
177	root_pic = dev;
178
179	return (0);
180}
181
182static int
183xics_attach(device_t dev)
184{
185	phandle_t phandle = ofw_bus_get_node(dev);
186
187	if (OF_getproplen(phandle, "ibm,phandle") > 0)
188		OF_getprop(phandle, "ibm,phandle", &phandle, sizeof(phandle));
189
190	/* The XICP (root PIC) will handle all our interrupts */
191	powerpc_register_pic(root_pic, phandle, MAX_XICP_IRQS,
192	    1 /* Number of IPIs */, FALSE);
193
194	return (0);
195}
196
197/*
198 * PIC I/F methods.
199 */
200
201static void
202xicp_bind(device_t dev, u_int irq, cpuset_t cpumask)
203{
204	struct xicp_softc *sc = device_get_softc(dev);
205	cell_t status, cpu;
206
207	/*
208	 * This doesn't appear to actually support affinity groups, so just
209	 * use the first CPU.
210	 */
211	CPU_FOREACH(cpu)
212		if (CPU_ISSET(cpu, &cpumask)) break;
213
214	rtas_call_method(sc->ibm_set_xive, 3, 1, irq, cpu, XICP_PRIORITY,
215	    &status);
216}
217
218static void
219xicp_dispatch(device_t dev, struct trapframe *tf)
220{
221	struct xicp_softc *sc;
222	uint64_t xirr, junk;
223	int i;
224
225	sc = device_get_softc(dev);
226	for (;;) {
227		/* Return value in R4, use the PFT call */
228		phyp_pft_hcall(H_XIRR, 0, 0, 0, 0, &xirr, &junk, &junk);
229		xirr &= 0x00ffffff;
230
231		if (xirr == 0) { /* No more pending interrupts? */
232			phyp_hcall(H_CPPR, (uint64_t)0xff);
233			break;
234		}
235		if (xirr == XICP_IPI) {		/* Magic number for IPIs */
236			xirr = MAX_XICP_IRQS;	/* Map to FreeBSD magic */
237			phyp_hcall(H_IPI, (uint64_t)(PCPU_GET(cpuid)),
238			    0xff); /* Clear IPI */
239		}
240
241		/* XXX: super inefficient */
242		for (i = 0; i < sc->nintvecs; i++) {
243			if (sc->intvecs[i].irq == xirr)
244				break;
245		}
246
247		KASSERT(i < sc->nintvecs, ("Unmapped XIRR"));
248		powerpc_dispatch_intr(sc->intvecs[i].vector, tf);
249	}
250}
251
252static void
253xicp_enable(device_t dev, u_int irq, u_int vector)
254{
255	struct xicp_softc *sc;
256	cell_t status, cpu;
257
258	sc = device_get_softc(dev);
259
260	KASSERT(sc->nintvecs + 1 < sizeof(sc->intvecs)/sizeof(sc->intvecs[0]),
261	    ("Too many XICP interrupts"));
262
263	mtx_lock(&sc->sc_mtx);
264	sc->intvecs[sc->nintvecs].irq = irq;
265	sc->intvecs[sc->nintvecs].vector = vector;
266	mb();
267	sc->nintvecs++;
268	mtx_unlock(&sc->sc_mtx);
269
270	/* IPIs are also enabled */
271	if (irq == MAX_XICP_IRQS)
272		return;
273
274	/* Bind to this CPU to start: distrib. ID is last entry in gserver# */
275	cpu = PCPU_GET(cpuid);
276	rtas_call_method(sc->ibm_set_xive, 3, 1, irq, cpu, XICP_PRIORITY,
277	    &status);
278	xicp_unmask(dev, irq);
279}
280
281static void
282xicp_eoi(device_t dev, u_int irq)
283{
284	uint64_t xirr;
285
286	if (irq == MAX_XICP_IRQS) /* Remap IPI interrupt to internal value */
287		irq = XICP_IPI;
288	xirr = irq | (XICP_PRIORITY << 24);
289
290	phyp_hcall(H_EOI, xirr);
291}
292
293static void
294xicp_ipi(device_t dev, u_int cpu)
295{
296
297	phyp_hcall(H_IPI, (uint64_t)cpu, XICP_PRIORITY);
298}
299
300static void
301xicp_mask(device_t dev, u_int irq)
302{
303	struct xicp_softc *sc = device_get_softc(dev);
304	cell_t status;
305
306	if (irq == MAX_XICP_IRQS)
307		return;
308
309	rtas_call_method(sc->ibm_int_off, 1, 1, irq, &status);
310}
311
312static void
313xicp_unmask(device_t dev, u_int irq)
314{
315	struct xicp_softc *sc = device_get_softc(dev);
316	cell_t status;
317
318	if (irq == MAX_XICP_IRQS)
319		return;
320
321	rtas_call_method(sc->ibm_int_on, 1, 1, irq, &status);
322}
323
324