1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright 2003 by Peter Grehan. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
22 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
24 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30 #include <sys/cdefs.h>
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/module.h>
34 #include <sys/bus.h>
35 #include <sys/conf.h>
36 #include <sys/kernel.h>
37 #include <sys/proc.h>
38 #include <sys/rman.h>
39
40 #include <dev/ofw/openfirm.h>
41 #include <dev/ofw/ofw_pci.h>
42 #include <dev/ofw/ofw_bus.h>
43 #include <dev/ofw/ofw_bus_subr.h>
44 #include <dev/ofw/ofwpci.h>
45
46 #include <dev/pci/pcivar.h>
47 #include <dev/pci/pcireg.h>
48
49 #include <machine/bus.h>
50 #include <machine/intr_machdep.h>
51 #include <machine/md_var.h>
52 #include <machine/pio.h>
53 #include <machine/resource.h>
54
55 #include <powerpc/powermac/gracklevar.h>
56
57 #include <vm/vm.h>
58 #include <vm/pmap.h>
59
60 #include "pcib_if.h"
61
62 /*
63 * Device interface.
64 */
65 static int grackle_probe(device_t);
66 static int grackle_attach(device_t);
67
68 /*
69 * pcib interface.
70 */
71 static u_int32_t grackle_read_config(device_t, u_int, u_int, u_int,
72 u_int, int);
73 static void grackle_write_config(device_t, u_int, u_int, u_int,
74 u_int, u_int32_t, int);
75
76 /*
77 * Local routines.
78 */
79 static int grackle_enable_config(struct grackle_softc *, u_int,
80 u_int, u_int, u_int);
81 static void grackle_disable_config(struct grackle_softc *);
82 static int badaddr(void *, size_t);
83
84 /*
85 * Driver methods.
86 */
87 static device_method_t grackle_methods[] = {
88 /* Device interface */
89 DEVMETHOD(device_probe, grackle_probe),
90 DEVMETHOD(device_attach, grackle_attach),
91
92 /* pcib interface */
93 DEVMETHOD(pcib_read_config, grackle_read_config),
94 DEVMETHOD(pcib_write_config, grackle_write_config),
95
96 DEVMETHOD_END
97 };
98
99 static devclass_t grackle_devclass;
100 DEFINE_CLASS_1(pcib, grackle_driver, grackle_methods,
101 sizeof(struct grackle_softc), ofw_pci_driver);
102 DRIVER_MODULE(grackle, ofwbus, grackle_driver, grackle_devclass, 0, 0);
103
104 static int
grackle_probe(device_t dev)105 grackle_probe(device_t dev)
106 {
107 const char *type, *compatible;
108
109 type = ofw_bus_get_type(dev);
110 compatible = ofw_bus_get_compat(dev);
111
112 if (type == NULL || compatible == NULL)
113 return (ENXIO);
114
115 if (strcmp(type, "pci") != 0 || strcmp(compatible, "grackle") != 0)
116 return (ENXIO);
117
118 device_set_desc(dev, "MPC106 (Grackle) Host-PCI bridge");
119 return (0);
120 }
121
122 static int
grackle_attach(device_t dev)123 grackle_attach(device_t dev)
124 {
125 struct grackle_softc *sc;
126
127 sc = device_get_softc(dev);
128
129 /*
130 * The Grackle PCI config addr/data registers are actually in
131 * PCI space, but since they are needed to actually probe the
132 * PCI bus, use the fact that they are also available directly
133 * on the processor bus and map them
134 */
135 sc->sc_addr = (vm_offset_t)pmap_mapdev(GRACKLE_ADDR, PAGE_SIZE);
136 sc->sc_data = (vm_offset_t)pmap_mapdev(GRACKLE_DATA, PAGE_SIZE);
137
138 return (ofw_pci_attach(dev));
139 }
140
141 static u_int32_t
grackle_read_config(device_t dev,u_int bus,u_int slot,u_int func,u_int reg,int width)142 grackle_read_config(device_t dev, u_int bus, u_int slot, u_int func, u_int reg,
143 int width)
144 {
145 struct grackle_softc *sc;
146 vm_offset_t caoff;
147 u_int32_t retval = 0xffffffff;
148
149 sc = device_get_softc(dev);
150 caoff = sc->sc_data + (reg & 0x03);
151
152 if (grackle_enable_config(sc, bus, slot, func, reg) != 0) {
153 /*
154 * Config probes to non-existent devices on the
155 * secondary bus generates machine checks. Be sure
156 * to catch these.
157 */
158 if (bus > 0) {
159 if (badaddr((void *)sc->sc_data, 4)) {
160 return (retval);
161 }
162 }
163
164 switch (width) {
165 case 1:
166 retval = (in8rb(caoff));
167 break;
168 case 2:
169 retval = (in16rb(caoff));
170 break;
171 case 4:
172 retval = (in32rb(caoff));
173 break;
174 }
175 }
176 grackle_disable_config(sc);
177
178 return (retval);
179 }
180
181 static void
grackle_write_config(device_t dev,u_int bus,u_int slot,u_int func,u_int reg,u_int32_t val,int width)182 grackle_write_config(device_t dev, u_int bus, u_int slot, u_int func,
183 u_int reg, u_int32_t val, int width)
184 {
185 struct grackle_softc *sc;
186 vm_offset_t caoff;
187
188 sc = device_get_softc(dev);
189 caoff = sc->sc_data + (reg & 0x03);
190
191 if (grackle_enable_config(sc, bus, slot, func, reg)) {
192 switch (width) {
193 case 1:
194 out8rb(caoff, val);
195 (void)in8rb(caoff);
196 break;
197 case 2:
198 out16rb(caoff, val);
199 (void)in16rb(caoff);
200 break;
201 case 4:
202 out32rb(caoff, val);
203 (void)in32rb(caoff);
204 break;
205 }
206 }
207 grackle_disable_config(sc);
208 }
209
210 static int
grackle_enable_config(struct grackle_softc * sc,u_int bus,u_int slot,u_int func,u_int reg)211 grackle_enable_config(struct grackle_softc *sc, u_int bus, u_int slot,
212 u_int func, u_int reg)
213 {
214 u_int32_t cfgval;
215
216 /*
217 * Unlike UniNorth, the format of the config word is the same
218 * for local (0) and remote busses.
219 */
220 cfgval = (bus << 16) | (slot << 11) | (func << 8) | (reg & 0xFC)
221 | GRACKLE_CFG_ENABLE;
222
223 out32rb(sc->sc_addr, cfgval);
224 (void) in32rb(sc->sc_addr);
225
226 return (1);
227 }
228
229 static void
grackle_disable_config(struct grackle_softc * sc)230 grackle_disable_config(struct grackle_softc *sc)
231 {
232 /*
233 * Clear the GRACKLE_CFG_ENABLE bit to prevent stray
234 * accesses from causing config cycles
235 */
236 out32rb(sc->sc_addr, 0);
237 }
238
239 static int
badaddr(void * addr,size_t size)240 badaddr(void *addr, size_t size)
241 {
242 struct thread *td;
243 jmp_buf env, *oldfaultbuf;
244 int x;
245
246 /* Get rid of any stale machine checks that have been waiting. */
247 __asm __volatile ("sync; isync");
248
249 td = curthread;
250
251 oldfaultbuf = td->td_pcb->pcb_onfault;
252 td->td_pcb->pcb_onfault = &env;
253 if (setjmp(env)) {
254 td->td_pcb->pcb_onfault = oldfaultbuf;
255 __asm __volatile ("sync");
256 return 1;
257 }
258
259 __asm __volatile ("sync");
260
261 switch (size) {
262 case 1:
263 x = *(volatile int8_t *)addr;
264 break;
265 case 2:
266 x = *(volatile int16_t *)addr;
267 break;
268 case 4:
269 x = *(volatile int32_t *)addr;
270 break;
271 default:
272 panic("badaddr: invalid size (%zd)", size);
273 }
274
275 /* Make sure we took the machine check, if we caused one. */
276 __asm __volatile ("sync; isync");
277
278 td->td_pcb->pcb_onfault = oldfaultbuf;
279 __asm __volatile ("sync"); /* To be sure. */
280
281 return (0);
282 }
283
284 /*
285 * Driver to swallow Grackle host bridges from the PCI bus side.
286 */
287 static int
grackle_hb_probe(device_t dev)288 grackle_hb_probe(device_t dev)
289 {
290
291 if (pci_get_devid(dev) == 0x00021057) {
292 device_set_desc(dev, "Grackle Host to PCI bridge");
293 device_quiet(dev);
294 return (0);
295 }
296
297 return (ENXIO);
298 }
299
300 static int
grackle_hb_attach(device_t dev)301 grackle_hb_attach(device_t dev)
302 {
303
304 return (0);
305 }
306
307 static device_method_t grackle_hb_methods[] = {
308 /* Device interface */
309 DEVMETHOD(device_probe, grackle_hb_probe),
310 DEVMETHOD(device_attach, grackle_hb_attach),
311 { 0, 0 }
312 };
313
314 static driver_t grackle_hb_driver = {
315 "grackle_hb",
316 grackle_hb_methods,
317 1,
318 };
319 static devclass_t grackle_hb_devclass;
320
321 DRIVER_MODULE(grackle_hb, pci, grackle_hb_driver, grackle_hb_devclass, 0, 0);
322