]> CyberLeo.Net >> Repos - FreeBSD/FreeBSD.git/blob - sys/powerpc/powermac/grackle.c
ssh: Update to OpenSSH 9.3p2
[FreeBSD/FreeBSD.git] / sys / powerpc / powermac / grackle.c
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 __FBSDID("$FreeBSD$");
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/module.h>
36 #include <sys/bus.h>
37 #include <sys/conf.h>
38 #include <sys/kernel.h>
39 #include <sys/proc.h>
40 #include <sys/rman.h>
41
42 #include <dev/ofw/openfirm.h>
43 #include <dev/ofw/ofw_pci.h>
44 #include <dev/ofw/ofw_bus.h>
45 #include <dev/ofw/ofw_bus_subr.h>
46 #include <dev/ofw/ofwpci.h>
47
48 #include <dev/pci/pcivar.h>
49 #include <dev/pci/pcireg.h>
50
51 #include <machine/bus.h>
52 #include <machine/intr_machdep.h>
53 #include <machine/md_var.h>
54 #include <machine/pio.h>
55 #include <machine/resource.h>
56
57 #include <powerpc/powermac/gracklevar.h>
58
59 #include <vm/vm.h>
60 #include <vm/pmap.h>
61
62 #include "pcib_if.h"
63
64 /*
65  * Device interface.
66  */
67 static int              grackle_probe(device_t);
68 static int              grackle_attach(device_t);
69
70 /*
71  * pcib interface.
72  */
73 static u_int32_t        grackle_read_config(device_t, u_int, u_int, u_int,
74                             u_int, int);
75 static void             grackle_write_config(device_t, u_int, u_int, u_int,
76                             u_int, u_int32_t, int);
77
78 /*
79  * Local routines.
80  */
81 static int              grackle_enable_config(struct grackle_softc *, u_int,
82                             u_int, u_int, u_int);
83 static void             grackle_disable_config(struct grackle_softc *);
84 static int              badaddr(void *, size_t);
85
86 /*
87  * Driver methods.
88  */
89 static device_method_t  grackle_methods[] = {
90         /* Device interface */
91         DEVMETHOD(device_probe,         grackle_probe),
92         DEVMETHOD(device_attach,        grackle_attach),
93
94         /* pcib interface */
95         DEVMETHOD(pcib_read_config,     grackle_read_config),
96         DEVMETHOD(pcib_write_config,    grackle_write_config),
97
98         DEVMETHOD_END
99 };
100
101 DEFINE_CLASS_1(pcib, grackle_driver, grackle_methods,
102     sizeof(struct grackle_softc), ofw_pcib_driver);
103 DRIVER_MODULE(grackle, ofwbus, grackle_driver, 0, 0);
104
105 static int
106 grackle_probe(device_t dev)
107 {
108         const char      *type, *compatible;
109
110         type = ofw_bus_get_type(dev);
111         compatible = ofw_bus_get_compat(dev);
112
113         if (type == NULL || compatible == NULL)
114                 return (ENXIO);
115
116         if (strcmp(type, "pci") != 0 || strcmp(compatible, "grackle") != 0)
117                 return (ENXIO);
118
119         device_set_desc(dev, "MPC106 (Grackle) Host-PCI bridge");
120         return (0);
121 }
122
123 static int
124 grackle_attach(device_t dev)
125 {
126         struct          grackle_softc *sc;
127
128         sc = device_get_softc(dev);
129
130         /*
131          * The Grackle PCI config addr/data registers are actually in
132          * PCI space, but since they are needed to actually probe the
133          * PCI bus, use the fact that they are also available directly
134          * on the processor bus and map them
135          */
136         sc->sc_addr = (vm_offset_t)pmap_mapdev(GRACKLE_ADDR, PAGE_SIZE);
137         sc->sc_data = (vm_offset_t)pmap_mapdev(GRACKLE_DATA, PAGE_SIZE);
138
139         return (ofw_pcib_attach(dev));
140 }
141
142 static u_int32_t
143 grackle_read_config(device_t dev, u_int bus, u_int slot, u_int func, u_int reg,
144     int width)
145 {
146         struct          grackle_softc *sc;
147         vm_offset_t     caoff;
148         u_int32_t       retval = 0xffffffff;
149
150         sc = device_get_softc(dev);
151         caoff = sc->sc_data + (reg & 0x03);
152
153         if (grackle_enable_config(sc, bus, slot, func, reg) != 0) {
154                 /*
155                  * Config probes to non-existent devices on the
156                  * secondary bus generates machine checks. Be sure
157                  * to catch these.
158                  */
159                 if (bus > 0) {
160                   if (badaddr((void *)sc->sc_data, 4)) {
161                           return (retval);
162                   }
163                 }
164
165                 switch (width) {
166                 case 1:
167                         retval = (in8rb(caoff));
168                         break;
169                 case 2:
170                         retval = (in16rb(caoff));
171                         break;
172                 case 4:
173                         retval = (in32rb(caoff));
174                         break;
175                 }
176         }
177         grackle_disable_config(sc);
178
179         return (retval);
180 }
181
182 static void
183 grackle_write_config(device_t dev, u_int bus, u_int slot, u_int func,
184     u_int reg, u_int32_t val, int width)
185 {
186         struct          grackle_softc *sc;
187         vm_offset_t     caoff;
188
189         sc = device_get_softc(dev);
190         caoff = sc->sc_data + (reg & 0x03);
191
192         if (grackle_enable_config(sc, bus, slot, func, reg)) {
193                 switch (width) {
194                 case 1:
195                         out8rb(caoff, val);
196                         (void)in8rb(caoff);
197                         break;
198                 case 2:
199                         out16rb(caoff, val);
200                         (void)in16rb(caoff);
201                         break;
202                 case 4:
203                         out32rb(caoff, val);
204                         (void)in32rb(caoff);
205                         break;
206                 }
207         }
208         grackle_disable_config(sc);
209 }
210
211 static int
212 grackle_enable_config(struct grackle_softc *sc, u_int bus, u_int slot,
213     u_int func, u_int reg)
214 {
215         u_int32_t       cfgval;
216
217         /*
218          * Unlike UniNorth, the format of the config word is the same
219          * for local (0) and remote busses.
220          */
221         cfgval = (bus << 16) | (slot << 11) | (func << 8) | (reg & 0xFC)
222             | GRACKLE_CFG_ENABLE;
223
224         out32rb(sc->sc_addr, cfgval);
225         (void) in32rb(sc->sc_addr);
226
227         return (1);
228 }
229
230 static void
231 grackle_disable_config(struct grackle_softc *sc)
232 {
233         /*
234          * Clear the GRACKLE_CFG_ENABLE bit to prevent stray
235          * accesses from causing config cycles
236          */
237         out32rb(sc->sc_addr, 0);
238 }
239
240 static int
241 badaddr(void *addr, size_t size)
242 {
243         struct thread   *td;
244         jmp_buf         env, *oldfaultbuf;
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                 (void)*(volatile int8_t *)addr;
264                 break;
265         case 2:
266                 (void)*(volatile int16_t *)addr;
267                 break;
268         case 4:
269                 (void)*(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
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
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
320 DRIVER_MODULE(grackle_hb, pci, grackle_hb_driver, 0, 0);