1 /* $NetBSD: tc.c,v 1.60 2024/05/13 00:01:53 msaitoh Exp $ */
2
3 /*
4 * Copyright (c) 1994, 1995 Carnegie-Mellon University.
5 * All rights reserved.
6 *
7 * Author: Chris G. Demetriou
8 *
9 * Permission to use, copy, modify and distribute this software and
10 * its documentation is hereby granted, provided that both the copyright
11 * notice and this permission notice appear in all copies of the
12 * software, derivative works or modified versions, and any portions
13 * thereof, and that both notices appear in supporting documentation.
14 *
15 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
16 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
17 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
18 *
19 * Carnegie Mellon requests users of this software to return to
20 *
21 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
22 * School of Computer Science
23 * Carnegie Mellon University
24 * Pittsburgh PA 15213-3890
25 *
26 * any improvements or extensions that they make and grant Carnegie the
27 * rights to redistribute these changes.
28 */
29
30 #include <sys/cdefs.h>
31 __KERNEL_RCSID(0, "$NetBSD: tc.c,v 1.60 2024/05/13 00:01:53 msaitoh Exp $");
32
33 #include "opt_tcverbose.h"
34
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/device.h>
38
39 #include <machine/cpu.h> /* for badaddr */
40
41 #include <dev/tc/tcreg.h>
42 #include <dev/tc/tcvar.h>
43 #include <dev/tc/tcdevs.h>
44
45 #include "locators.h"
46
47 /* Definition of the driver for autoconfig. */
48 static int tcmatch(device_t, cfdata_t, void *);
49
50 CFATTACH_DECL_NEW(tc, sizeof(struct tc_softc),
51 tcmatch, tcattach, NULL, NULL);
52
53 extern struct cfdriver tc_cd;
54
55 static int tcprint(void *, const char *);
56 static void tc_devinfo(const char *, char *, size_t);
57
58 static int
tcmatch(device_t parent,cfdata_t cf,void * aux)59 tcmatch(device_t parent, cfdata_t cf, void *aux)
60 {
61 struct tcbus_attach_args *tba = aux;
62
63 if (strcmp(tba->tba_busname, cf->cf_name))
64 return (0);
65
66 return (1);
67 }
68
69 void
tcattach(device_t parent,device_t self,void * aux)70 tcattach(device_t parent, device_t self, void *aux)
71 {
72 struct tc_softc *sc = device_private(self);
73 struct tcbus_attach_args *tba = aux;
74 struct tc_attach_args ta;
75 const struct tc_builtin *builtin;
76 const struct tc_slotdesc *slot;
77 tc_addr_t tcaddr;
78 int i;
79 int locs[TCCF_NLOCS];
80
81 sc->sc_dev = self;
82
83 printf(": %s MHz clock\n",
84 tba->tba_speed == TC_SPEED_25_MHZ ? "25" : "12.5");
85
86 /*
87 * Save important CPU/chipset information.
88 */
89 sc->sc_speed = tba->tba_speed;
90 sc->sc_nslots = tba->tba_nslots;
91 sc->sc_slots = tba->tba_slots;
92 sc->sc_intr_evcnt = tba->tba_intr_evcnt;
93 sc->sc_intr_establish = tba->tba_intr_establish;
94 sc->sc_intr_disestablish = tba->tba_intr_disestablish;
95 sc->sc_get_dma_tag = tba->tba_get_dma_tag;
96
97 /*
98 * Try to configure each built-in device
99 */
100 for (i = 0; i < tba->tba_nbuiltins; i++) {
101 builtin = &tba->tba_builtins[i];
102
103 /* sanity check! */
104 if (builtin->tcb_slot > sc->sc_nslots)
105 panic("tcattach: builtin %d slot > nslots", i);
106
107 /*
108 * Make sure device is really there, because some
109 * built-in devices are really optional.
110 */
111 tcaddr = sc->sc_slots[builtin->tcb_slot].tcs_addr +
112 builtin->tcb_offset;
113 if (tc_badaddr(tcaddr))
114 continue;
115
116 /*
117 * Set up the device attachment information.
118 */
119 strncpy(ta.ta_modname, builtin->tcb_modname, TC_ROM_LLEN);
120 ta.ta_memt = tba->tba_memt;
121 ta.ta_dmat = (*sc->sc_get_dma_tag)(builtin->tcb_slot);
122 ta.ta_modname[TC_ROM_LLEN] = '\0';
123 ta.ta_slot = builtin->tcb_slot;
124 ta.ta_offset = builtin->tcb_offset;
125 ta.ta_addr = tcaddr;
126 ta.ta_cookie = builtin->tcb_cookie;
127 ta.ta_busspeed = sc->sc_speed;
128
129 /*
130 * Mark the slot as used, so we don't check it later.
131 */
132 KASSERT(builtin->tcb_slot >=0 && builtin->tcb_slot <= 31);
133 sc->sc_slots_used |= __BIT(builtin->tcb_slot);
134
135 locs[TCCF_SLOT] = builtin->tcb_slot;
136 locs[TCCF_OFFSET] = builtin->tcb_offset;
137 /*
138 * Attach the device.
139 */
140 config_found(self, &ta, tcprint,
141 CFARGS(.submatch = config_stdsubmatch,
142 .locators = locs));
143 }
144
145 /*
146 * Try to configure each unused slot, last to first.
147 */
148 for (i = sc->sc_nslots - 1; i >= 0; i--) {
149 slot = &sc->sc_slots[i];
150
151 /* If already checked above, don't look again now. */
152 if (sc->sc_slots_used & __BIT(i))
153 continue;
154
155 /*
156 * Make sure something is there, and find out what it is.
157 */
158 tcaddr = slot->tcs_addr;
159 if (tc_badaddr(tcaddr))
160 continue;
161 if (tc_checkslot(tcaddr, ta.ta_modname, NULL) == 0)
162 continue;
163
164 /*
165 * Set up the rest of the attachment information.
166 */
167 ta.ta_memt = tba->tba_memt;
168 ta.ta_dmat = (*sc->sc_get_dma_tag)(i);
169 ta.ta_slot = i;
170 ta.ta_offset = 0;
171 ta.ta_addr = tcaddr;
172 ta.ta_cookie = slot->tcs_cookie;
173 ta.ta_busspeed = sc->sc_speed;
174
175 /*
176 * Mark the slot as used.
177 */
178 sc->sc_slots_used |= __BIT(i);
179
180 locs[TCCF_SLOT] = i;
181 locs[TCCF_OFFSET] = 0;
182 /*
183 * Attach the device.
184 */
185 config_found(self, &ta, tcprint,
186 CFARGS(.submatch = config_stdsubmatch,
187 .locators = locs));
188 }
189 }
190
191 static int
tcprint(void * aux,const char * pnp)192 tcprint(void *aux, const char *pnp)
193 {
194 struct tc_attach_args *ta = aux;
195 char devinfo[256];
196
197 if (pnp) {
198 tc_devinfo(ta->ta_modname, devinfo, sizeof(devinfo));
199 aprint_normal("%s at %s", devinfo, pnp);
200 }
201 aprint_normal(" slot %d offset 0x%x", ta->ta_slot, ta->ta_offset);
202 return (UNCONF);
203 }
204
205
206 static const tc_offset_t tc_slot_romoffs[] = {
207 TC_SLOT_ROM,
208 TC_SLOT_PROTOROM,
209 };
210
211 static int
tc_check_romp(const struct tc_rommap * romp)212 tc_check_romp(const struct tc_rommap *romp)
213 {
214
215 switch (romp->tcr_width.v) {
216 case 1:
217 case 2:
218 case 4:
219 break;
220
221 default:
222 return 0;
223 }
224
225 if (romp->tcr_stride.v != 4)
226 return 0;
227
228 for (size_t j = 0; j < romp->tcr_width.v; j++) {
229 if (romp->tcr_test[j + 0 * romp->tcr_stride.v] != 0x55 ||
230 romp->tcr_test[j + 1 * romp->tcr_stride.v] != 0x00 ||
231 romp->tcr_test[j + 2 * romp->tcr_stride.v] != 0xaa ||
232 romp->tcr_test[j + 3 * romp->tcr_stride.v] != 0xff)
233 return 0;
234 }
235 return 1;
236 }
237
238 int
tc_checkslot(tc_addr_t slotbase,char * namep,struct tc_rommap ** rompp)239 tc_checkslot(tc_addr_t slotbase, char *namep, struct tc_rommap **rompp)
240 {
241 struct tc_rommap *romp;
242 int i, j;
243
244 for (i = 0; i < __arraycount(tc_slot_romoffs); i++) {
245 romp = (struct tc_rommap *)
246 (slotbase + tc_slot_romoffs[i]);
247
248 if (!tc_check_romp(romp))
249 continue;
250
251 if (namep != NULL) {
252 for (j = 0; j < TC_ROM_LLEN; j++)
253 namep[j] = romp->tcr_modname[j].v;
254 namep[j] = '\0';
255 }
256 if (rompp != NULL)
257 *rompp = romp;
258 return (1);
259 }
260 return (0);
261 }
262
263 const struct evcnt *
tc_intr_evcnt(device_t dev,void * cookie)264 tc_intr_evcnt(device_t dev, void *cookie)
265 {
266 struct tc_softc *sc = device_lookup_private(&tc_cd, 0);
267
268 return ((*sc->sc_intr_evcnt)(dev, cookie));
269 }
270
271 void
tc_intr_establish(device_t dev,void * cookie,int level,int (* handler)(void *),void * arg)272 tc_intr_establish(device_t dev, void *cookie, int level,
273 int (*handler)(void *), void *arg)
274 {
275 struct tc_softc *sc = device_lookup_private(&tc_cd, 0);
276
277 (*sc->sc_intr_establish)(dev, cookie, level, handler, arg);
278 }
279
280 void
tc_intr_disestablish(device_t dev,void * cookie)281 tc_intr_disestablish(device_t dev, void *cookie)
282 {
283 struct tc_softc *sc = device_lookup_private(&tc_cd, 0);
284
285 (*sc->sc_intr_disestablish)(dev, cookie);
286 }
287
288 #ifdef TCVERBOSE
289 /*
290 * Descriptions of known devices.
291 */
292 struct tc_knowndev {
293 const char *id, *driver, *description;
294 };
295
296 #include <dev/tc/tcdevs_data.h>
297 #endif /* TCVERBOSE */
298
299 static void
tc_devinfo(const char * id,char * cp,size_t l)300 tc_devinfo(const char *id, char *cp, size_t l)
301 {
302 const char *driver, *description;
303 #ifdef TCVERBOSE
304 const struct tc_knowndev *tdp;
305 int match;
306 const char *unmatched = "unknown ";
307 #else
308 const char *unmatched = "";
309 #endif
310
311 driver = NULL;
312 description = id;
313
314 #ifdef TCVERBOSE
315 /* find the device in the table, if possible. */
316 tdp = tc_knowndevs;
317 while (tdp->id != NULL) {
318 /* check this entry for a match */
319 match = !strcmp(tdp->id, id);
320 if (match) {
321 driver = tdp->driver;
322 description = tdp->description;
323 break;
324 }
325 tdp++;
326 }
327 #endif
328
329 if (driver == NULL)
330 snprintf(cp, l, "%sdevice %s", unmatched, id);
331 else
332 snprintf(cp, l, "%s (%s)", driver, description);
333 }
334