1 /* $NetBSD: tlsb.c,v 1.42 2024/03/06 13:37:35 thorpej Exp $ */
2 /*
3 * Copyright (c) 1997 by Matthew Jacob
4 * NASA AMES Research Center.
5 * All rights reserved.
6 *
7 * Based in part upon a prototype version by Jason Thorpe
8 * Copyright (c) 1996, 1998 by Jason Thorpe.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice immediately at the beginning of the file, without modification,
15 * this list of conditions, and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. The name of the author may not be used to endorse or promote products
20 * derived from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
26 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 /*
36 * Autoconfiguration and support routines for the TurboLaser System Bus
37 * found on AlphaServer 8200 and 8400 systems.
38 */
39
40 #include <sys/cdefs.h> /* RCS ID & Copyright macro defns */
41
42 __KERNEL_RCSID(0, "$NetBSD: tlsb.c,v 1.42 2024/03/06 13:37:35 thorpej Exp $");
43
44 #include "opt_multiprocessor.h"
45
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/device.h>
49
50 #include <machine/autoconf.h>
51 #include <machine/cpu.h>
52 #include <machine/cpuvar.h>
53 #include <machine/rpb.h>
54 #include <machine/pte.h>
55 #include <machine/alpha.h>
56
57 #include <alpha/tlsb/tlsbreg.h>
58 #include <alpha/tlsb/tlsbvar.h>
59
60 #include "locators.h"
61
62 #define KV(_addr) ((void *)ALPHA_PHYS_TO_K0SEG((_addr)))
63
64 static int tlsbmatch(device_t, cfdata_t, void *);
65 static void tlsbattach(device_t, device_t, void *);
66
67 CFATTACH_DECL_NEW(tlsb, 0,
68 tlsbmatch, tlsbattach, NULL, NULL);
69
70 extern struct cfdriver tlsb_cd;
71
72 static int tlsbprint(void *, const char *);
73 static const char *tlsb_node_type_str(uint32_t, char *, size_t);
74
75 /*
76 * There can be only one TurboLaser, and we'll overload it
77 * with a bitmap of found turbo laser nodes. Note that
78 * these are just the actual hard TL node IDS that we
79 * discover here, not the virtual IDs that get assigned
80 * to CPUs. During TLSB specific error handling we
81 * only need to know which actual TLSB slots have boards
82 * in them (irrespective of how many CPUs they have).
83 */
84 int tlsb_found;
85
86 static int
tlsbprint(void * aux,const char * pnp)87 tlsbprint(void *aux, const char *pnp)
88 {
89 struct tlsb_dev_attach_args *tap = aux;
90 char buf[64];
91
92 if (pnp)
93 aprint_normal("%s at %s node %d",
94 tlsb_node_type_str(tap->ta_dtype, buf, sizeof(buf)),
95 pnp, tap->ta_node);
96 else
97 aprint_normal(" node %d: %s", tap->ta_node,
98 tlsb_node_type_str(tap->ta_dtype, buf, sizeof(buf)));
99
100 return (UNCONF);
101 }
102
103 static int
tlsbmatch(device_t parent,cfdata_t cf,void * aux)104 tlsbmatch(device_t parent, cfdata_t cf, void *aux)
105 {
106 struct mainbus_attach_args *ma = aux;
107
108 /* Make sure we're looking for a TurboLaser. */
109 if (strcmp(ma->ma_name, tlsb_cd.cd_name) != 0)
110 return (0);
111
112 /*
113 * Only one instance of TurboLaser allowed,
114 * and only available on 21000 processor type
115 * platforms.
116 */
117 if ((cputype != ST_DEC_21000) || tlsb_found)
118 return (0);
119
120 return (1);
121 }
122
123 static void
tlsbattach(device_t parent,device_t self,void * aux)124 tlsbattach(device_t parent, device_t self, void *aux)
125 {
126 struct tlsb_dev_attach_args ta;
127 uint32_t tldev;
128 int node;
129 int ionodes = 0;
130 int locs[TLSBCF_NLOCS];
131 char buf[64];
132
133 printf("\n");
134
135 /*
136 * Attempt to find all devices on the bus, including
137 * CPUs, memory modules, and I/O modules.
138 */
139
140 /*
141 * Sigh. I would like to just start off nicely,
142 * but I need to treat I/O modules differently-
143 * The highest priority I/O node has to be in
144 * node #8, and I want to find it *first*, since
145 * it will have the primary disks (most likely)
146 * on it.
147 */
148 for (node = 0; node <= TLSB_NODE_MAX; ++node) {
149 /*
150 * Check for invalid address. This may not really
151 * be necessary, but what the heck...
152 */
153 if (badaddr(TLSB_NODE_REG_ADDR(node, TLDEV), sizeof(uint32_t)))
154 continue;
155 tldev = TLSB_GET_NODEREG(node, TLDEV);
156 if (tldev == 0) {
157 /* Nothing at this node. */
158 continue;
159 }
160 /*
161 * Store up that we found something at this node.
162 * We do this so that we don't have to do something
163 * silly at fault time like try a 'baddadr'...
164 */
165 tlsb_found |= __BIT(node);
166 if (TLDEV_ISIOPORT(tldev)) {
167 ionodes |= __BIT(node);
168 continue; /* not interested right now */
169 }
170 ta.ta_node = node;
171 ta.ta_dtype = TLDEV_DTYPE(tldev);
172 ta.ta_swrev = TLDEV_SWREV(tldev);
173 ta.ta_hwrev = TLDEV_HWREV(tldev);
174
175 /*
176 * Deal with hooking CPU instances to TurboLaser nodes.
177 */
178 if (TLDEV_ISCPU(tldev)) {
179 aprint_normal("%s node %d: %s\n", device_xname(self),
180 node,
181 tlsb_node_type_str(tldev, buf, sizeof(buf)));
182 }
183 /*
184 * Attach any children nodes, including a CPU's GBus
185 */
186 locs[TLSBCF_NODE] = node;
187
188 config_found(self, &ta, tlsbprint,
189 CFARGS(.submatch = config_stdsubmatch,
190 .locators = locs));
191 }
192 /*
193 * *Now* attach I/O nodes (in descending order). We don't
194 * need to bother using badaddr() here; we have a cheat sheet
195 * from above.
196 */
197 while (--node >= 0) {
198 if ((ionodes & __BIT(node)) == 0) {
199 continue;
200 }
201 tldev = TLSB_GET_NODEREG(node, TLDEV);
202 if (tldev == 0) {
203 continue;
204 }
205 #if defined(MULTIPROCESSOR)
206 /*
207 * XXX Eventually, we want to select a secondary
208 * XXX processor on which to field interrupts for
209 * XXX this node. However, we just send them to
210 * XXX the primary CPU for now.
211 *
212 * XXX Maybe multiple CPUs? Does the hardware
213 * XXX round-robin, or check the length of the
214 * XXX per-CPU interrupt queue?
215 */
216 printf("%s node %d: routing interrupts to %s\n",
217 device_xname(self), node,
218 device_xname(cpu_info[hwrpb->rpb_primary_cpu_id]->ci_softc->sc_dev));
219 TLSB_PUT_NODEREG(node, TLCPUMASK,
220 (1UL << hwrpb->rpb_primary_cpu_id));
221 #else
222 /*
223 * Make sure interrupts are sent to the primary CPU.
224 */
225 TLSB_PUT_NODEREG(node, TLCPUMASK,
226 (1UL << hwrpb->rpb_primary_cpu_id));
227 #endif /* MULTIPROCESSOR */
228
229 ta.ta_node = node;
230 ta.ta_dtype = TLDEV_DTYPE(tldev);
231 ta.ta_swrev = TLDEV_SWREV(tldev);
232 ta.ta_hwrev = TLDEV_HWREV(tldev);
233
234 locs[TLSBCF_NODE] = node;
235
236 config_found(self, &ta, tlsbprint,
237 CFARGS(.submatch = config_stdsubmatch,
238 .locators = locs));
239 }
240 }
241
242 static const char *
tlsb_node_type_str(uint32_t dtype,char * buf,size_t buflen)243 tlsb_node_type_str(uint32_t dtype, char *buf, size_t buflen)
244 {
245 switch (dtype & TLDEV_DTYPE_MASK) {
246 case TLDEV_DTYPE_KFTHA:
247 return ("KFTHA I/O interface");
248
249 case TLDEV_DTYPE_KFTIA:
250 return ("KFTIA I/O interface");
251
252 case TLDEV_DTYPE_MS7CC:
253 return ("MS7CC Memory Module");
254
255 case TLDEV_DTYPE_SCPU4:
256 return ("Single CPU, 4MB cache");
257
258 case TLDEV_DTYPE_SCPU16:
259 return ("Single CPU, 16MB cache");
260
261 case TLDEV_DTYPE_DCPU4:
262 return ("Dual CPU, 4MB cache");
263
264 case TLDEV_DTYPE_DCPU16:
265 return ("Dual CPU, 16MB cache");
266
267 default:
268 snprintf(buf, buflen, "unknown, dtype 0x%04x", dtype);
269 return (buf);
270 }
271 /* NOTREACHED */
272 }
273