1bffdb87cSfujita /*
2a3a09ba5Sakito * Copyright (c) 1988 University of Utah.
3bffdb87cSfujita * Copyright (c) 1992 OMRON Corporation.
40c9190d2Sbostic * Copyright (c) 1982, 1986, 1990, 1992, 1993
50c9190d2Sbostic * The Regents of the University of California. All rights reserved.
6bffdb87cSfujita *
7bffdb87cSfujita * This code is derived from software contributed to Berkeley by
8a3a09ba5Sakito * the Systems Programming Group of the University of Utah Computer
9a3a09ba5Sakito * Science Department.
10bffdb87cSfujita *
11bffdb87cSfujita * %sccs.include.redist.c%
12bffdb87cSfujita *
13*cba83470Sakito * from:hp300/hp300/autoconf.c 7.11 (Berkeley) 5/9/93
14a3a09ba5Sakito *
15*cba83470Sakito * @(#)autoconf.c 8.2 (Berkeley) 12/06/93
16bffdb87cSfujita */
17bffdb87cSfujita
18bffdb87cSfujita /*
19bffdb87cSfujita * autoconf.c -- for auto configration
20bffdb87cSfujita * remade by A.Fujita, MAR-24-1992
21bffdb87cSfujita */
22bffdb87cSfujita
23bffdb87cSfujita
24bffdb87cSfujita /*
25bffdb87cSfujita * Setup the system to run on the current machine.
26bffdb87cSfujita *
27bffdb87cSfujita * Configure() is called at boot time. Available
28bffdb87cSfujita * devices are determined (from possibilities mentioned in ioconf.c),
29bffdb87cSfujita * and the drivers are initialized.
30bffdb87cSfujita */
31bffdb87cSfujita
326f6d3673Sakito #include <sys/param.h>
336f6d3673Sakito #include <sys/systm.h>
346f6d3673Sakito #include <sys/dkstat.h>
356f6d3673Sakito #include <sys/conf.h>
366f6d3673Sakito #include <sys/reboot.h>
37bffdb87cSfujita
386f6d3673Sakito #include <machine/cpu.h>
396f6d3673Sakito #include <luna68k/dev/device.h>
40bffdb87cSfujita
41bffdb87cSfujita /*
42bffdb87cSfujita * The following several variables are related to
43bffdb87cSfujita * the configuration process, and are used in initializing
44bffdb87cSfujita * the machine.
45bffdb87cSfujita */
46bffdb87cSfujita int cold; /* if 1, still working on cold-start */
47bffdb87cSfujita int dkn; /* number of iostat dk numbers assigned so far */
48bffdb87cSfujita struct hp_hw sc_table[MAXCTLRS];
49bffdb87cSfujita
50bffdb87cSfujita #ifdef DEBUG
51bffdb87cSfujita int acdebug = 0;
52bffdb87cSfujita #endif
53bffdb87cSfujita
54bffdb87cSfujita /*
55bffdb87cSfujita * Determine mass storage and memory configuration for a machine.
56bffdb87cSfujita */
configure()57bffdb87cSfujita configure()
58bffdb87cSfujita {
59bffdb87cSfujita register struct hp_hw *hw;
60bffdb87cSfujita int found;
61bffdb87cSfujita
62bffdb87cSfujita /*
63bffdb87cSfujita * Look over each hardware device actually found and attempt
64bffdb87cSfujita * to match it with an ioconf.c table entry.
65bffdb87cSfujita */
66bffdb87cSfujita for (hw = sc_table; hw->hw_type; hw++) {
67bffdb87cSfujita if (HW_ISCTLR(hw))
68bffdb87cSfujita found = find_controller(hw);
69bffdb87cSfujita else
70bffdb87cSfujita found = find_device(hw);
71bffdb87cSfujita #ifdef DEBUG
72bffdb87cSfujita if (!found) {
73bffdb87cSfujita printf("unconfigured card id %x ", hw->hw_id);
74bffdb87cSfujita printf("at 0x%x\n", hw->hw_pa);
75bffdb87cSfujita }
76bffdb87cSfujita #endif
77bffdb87cSfujita }
78bffdb87cSfujita
79bffdb87cSfujita #if GENERIC
80bffdb87cSfujita if ((boothowto & RB_ASKNAME) == 0)
81bffdb87cSfujita setroot();
82bffdb87cSfujita setconf();
83bffdb87cSfujita #else
84bffdb87cSfujita setroot();
85bffdb87cSfujita #endif
86a3a09ba5Sakito showroot();
87bffdb87cSfujita swapconf();
88bffdb87cSfujita cold = 0;
89bffdb87cSfujita }
90bffdb87cSfujita
91bffdb87cSfujita #define dr_type(d, s) \
92bffdb87cSfujita (strcmp((d)->d_name, (s)) == 0)
93bffdb87cSfujita
94bffdb87cSfujita #define same_hw_ctlr(hw, hc) \
95bffdb87cSfujita HW_ISSCSI(hw) && dr_type((hc)->hp_driver, "sc")
96bffdb87cSfujita
find_controller(hw)97bffdb87cSfujita find_controller(hw)
98bffdb87cSfujita register struct hp_hw *hw;
99bffdb87cSfujita {
100bffdb87cSfujita register struct hp_ctlr *hc;
101bffdb87cSfujita struct hp_ctlr *match_c;
102bffdb87cSfujita caddr_t oaddr;
103bffdb87cSfujita int sc;
104bffdb87cSfujita
105bffdb87cSfujita #ifdef DEBUG
106bffdb87cSfujita if (acdebug)
107bffdb87cSfujita printf("find_controller: hw: id%x at sc%d (%x), type %x...",
108bffdb87cSfujita hw->hw_id, hw->hw_sc, hw->hw_kva, hw->hw_type);
109bffdb87cSfujita #endif
110bffdb87cSfujita sc = hw->hw_sc;
111bffdb87cSfujita match_c = NULL;
112bffdb87cSfujita for (hc = hp_cinit; hc->hp_driver; hc++) {
113bffdb87cSfujita if (hc->hp_alive)
114bffdb87cSfujita continue;
115bffdb87cSfujita /*
116bffdb87cSfujita * Make sure we are looking at the right
117bffdb87cSfujita * controller type.
118bffdb87cSfujita */
119bffdb87cSfujita if (!same_hw_ctlr(hw, hc))
120bffdb87cSfujita continue;
121bffdb87cSfujita /*
122bffdb87cSfujita * Exact match; all done
123bffdb87cSfujita */
124bffdb87cSfujita if ((int)hc->hp_addr == sc) {
125bffdb87cSfujita match_c = hc;
126bffdb87cSfujita break;
127bffdb87cSfujita }
128bffdb87cSfujita /*
129bffdb87cSfujita * Wildcard; possible match so remember first instance
130bffdb87cSfujita * but continue looking for exact match.
131bffdb87cSfujita */
132bffdb87cSfujita if (hc->hp_addr == NULL && match_c == NULL)
133bffdb87cSfujita match_c = hc;
134bffdb87cSfujita }
135bffdb87cSfujita #ifdef DEBUG
136bffdb87cSfujita if (acdebug) {
137bffdb87cSfujita if (match_c)
138bffdb87cSfujita printf("found %s%d\n",
139bffdb87cSfujita match_c->hp_driver->d_name,
140bffdb87cSfujita match_c->hp_unit);
141bffdb87cSfujita else
142bffdb87cSfujita printf("not found\n");
143bffdb87cSfujita }
144bffdb87cSfujita #endif
145bffdb87cSfujita /*
146bffdb87cSfujita * Didn't find an ioconf entry for this piece of hardware,
147bffdb87cSfujita * just ignore it.
148bffdb87cSfujita */
149bffdb87cSfujita if (match_c == NULL)
150bffdb87cSfujita return(0);
151bffdb87cSfujita /*
152bffdb87cSfujita * Found a match, attempt to initialize and configure all attached
153bffdb87cSfujita * slaves. Note, we can still fail if HW won't initialize.
154bffdb87cSfujita */
155bffdb87cSfujita hc = match_c;
156bffdb87cSfujita oaddr = hc->hp_addr;
157bffdb87cSfujita hc->hp_addr = hw->hw_kva;
158bffdb87cSfujita if ((*hc->hp_driver->d_init)(hc)) {
159bffdb87cSfujita hc->hp_alive = 1;
160bffdb87cSfujita printf("%s%d", hc->hp_driver->d_name, hc->hp_unit);
161bffdb87cSfujita printf(" at 0x%x,", hw->hw_pa);
162bffdb87cSfujita printf(" ipl %d", hc->hp_ipl);
163bffdb87cSfujita if (hc->hp_flags)
164bffdb87cSfujita printf(" flags 0x%x", hc->hp_flags);
165bffdb87cSfujita printf("\n");
166bffdb87cSfujita find_slaves(hc);
167bffdb87cSfujita } else
168bffdb87cSfujita hc->hp_addr = oaddr;
169bffdb87cSfujita return(1);
170bffdb87cSfujita }
171bffdb87cSfujita
find_device(hw)172bffdb87cSfujita find_device(hw)
173bffdb87cSfujita register struct hp_hw *hw;
174bffdb87cSfujita {
175bffdb87cSfujita register struct hp_device *hd;
176bffdb87cSfujita struct hp_device *match_d;
177bffdb87cSfujita caddr_t oaddr;
178bffdb87cSfujita int sc;
179bffdb87cSfujita
180bffdb87cSfujita #ifdef DEBUG
181bffdb87cSfujita if (acdebug)
182bffdb87cSfujita printf("find_device: hw: id%x at sc%d (%x), type %x...",
183bffdb87cSfujita hw->hw_id, hw->hw_sc, hw->hw_kva, hw->hw_type);
184bffdb87cSfujita #endif
185bffdb87cSfujita match_d = NULL;
186bffdb87cSfujita for (hd = hp_dinit; hd->hp_driver; hd++) {
187bffdb87cSfujita if (hd->hp_alive)
188bffdb87cSfujita continue;
189bffdb87cSfujita /* Must not be a slave */
190bffdb87cSfujita if (hd->hp_cdriver)
191bffdb87cSfujita continue;
192bffdb87cSfujita sc = (int) hd->hp_addr;
193bffdb87cSfujita /*
194bffdb87cSfujita * Exact match; all done.
195bffdb87cSfujita */
196bffdb87cSfujita if (sc > 0 && sc == hw->hw_sc) {
197bffdb87cSfujita match_d = hd;
198bffdb87cSfujita break;
199bffdb87cSfujita }
200bffdb87cSfujita /*
201bffdb87cSfujita * Wildcard; possible match so remember first instance
202bffdb87cSfujita * but continue looking for exact match.
203bffdb87cSfujita */
204bffdb87cSfujita if (sc == 0 && same_hw_device(hw, hd) && match_d == NULL)
205bffdb87cSfujita match_d = hd;
206bffdb87cSfujita }
207bffdb87cSfujita #ifdef DEBUG
208bffdb87cSfujita if (acdebug) {
209bffdb87cSfujita if (match_d)
210bffdb87cSfujita printf("found %s%d\n",
211bffdb87cSfujita match_d->hp_driver->d_name,
212bffdb87cSfujita match_d->hp_unit);
213bffdb87cSfujita else
214bffdb87cSfujita printf("not found\n");
215bffdb87cSfujita }
216bffdb87cSfujita #endif
217bffdb87cSfujita /*
218bffdb87cSfujita * Didn't find an ioconf entry for this piece
219bffdb87cSfujita * of hardware, just ignore it.
220bffdb87cSfujita */
221bffdb87cSfujita if (match_d == NULL)
222bffdb87cSfujita return(0);
223bffdb87cSfujita /*
224bffdb87cSfujita * Found a match, attempt to initialize.
225bffdb87cSfujita * Note, we can still fail if HW won't initialize.
226bffdb87cSfujita */
227bffdb87cSfujita hd = match_d;
228bffdb87cSfujita oaddr = hd->hp_addr;
229bffdb87cSfujita hd->hp_addr = hw->hw_kva;
230bffdb87cSfujita if ((*hd->hp_driver->d_init)(hd)) {
231bffdb87cSfujita hd->hp_alive = 1;
232bffdb87cSfujita printf("%s%d", hd->hp_driver->d_name, hd->hp_unit);
233bffdb87cSfujita printf(" at 0x%x", hw->hw_pa);
234bffdb87cSfujita if (hd->hp_ipl)
235bffdb87cSfujita printf(", ipl %d", hd->hp_ipl);
236bffdb87cSfujita if (hd->hp_flags)
237bffdb87cSfujita printf(", flags 0x%x", hd->hp_flags);
238bffdb87cSfujita printf("\n");
239bffdb87cSfujita } else
240bffdb87cSfujita hd->hp_addr = oaddr;
241bffdb87cSfujita return(1);
242bffdb87cSfujita }
243bffdb87cSfujita
244bffdb87cSfujita /*
245bffdb87cSfujita * Search each BUS controller found for slaves attached to it.
246bffdb87cSfujita * The bad news is that we don't know how to uniquely identify all slaves
247bffdb87cSfujita * (e.g. PPI devices on HP-IB). The good news is that we can at least
248bffdb87cSfujita * differentiate those from slaves we can identify. At worst (a totally
249bffdb87cSfujita * wildcarded entry) this will cause us to locate such a slave at the first
250bffdb87cSfujita * unused position instead of where it really is. To save grief, non-
251bffdb87cSfujita * identifing devices should always be fully qualified.
252bffdb87cSfujita */
find_slaves(hc)253bffdb87cSfujita find_slaves(hc)
254bffdb87cSfujita register struct hp_ctlr *hc;
255bffdb87cSfujita {
256bffdb87cSfujita register int s;
257bffdb87cSfujita register struct hp_device *hd;
258bffdb87cSfujita struct hp_device *match_s;
259bffdb87cSfujita int maxslaves = MAXSLAVES - 1;
260bffdb87cSfujita int new_s, new_c, old_s, old_c;
261bffdb87cSfujita int rescan;
262bffdb87cSfujita
263bffdb87cSfujita #ifdef DEBUG
264bffdb87cSfujita if (acdebug)
265bffdb87cSfujita printf("find_busslaves: for %s%d\n",
266bffdb87cSfujita hc->hp_driver->d_name, hc->hp_unit);
267bffdb87cSfujita #endif
268bffdb87cSfujita for (s = 0; s < maxslaves; s++) {
269bffdb87cSfujita rescan = 1;
270bffdb87cSfujita match_s = NULL;
271bffdb87cSfujita for (hd = hp_dinit; hd->hp_driver; hd++) {
272bffdb87cSfujita /*
273bffdb87cSfujita * Rule out the easy ones:
274bffdb87cSfujita * 1. slave already assigned or not a slave
275bffdb87cSfujita * 2. not of the proper type
276bffdb87cSfujita * 3. controller specified but not this one
277bffdb87cSfujita * 4. slave specified but not this one
278bffdb87cSfujita */
279bffdb87cSfujita if (hd->hp_alive || hd->hp_cdriver == NULL)
280bffdb87cSfujita continue;
281bffdb87cSfujita if (!dr_type(hc->hp_driver, hd->hp_cdriver->d_name))
282bffdb87cSfujita continue;
283bffdb87cSfujita if (hd->hp_ctlr >= 0 && hd->hp_ctlr != hc->hp_unit)
284bffdb87cSfujita continue;
285bffdb87cSfujita if (hd->hp_slave >= 0 && hd->hp_slave != s)
286bffdb87cSfujita continue;
287bffdb87cSfujita /*
288bffdb87cSfujita * Case 0: first possible match.
289bffdb87cSfujita * Remember it and keep looking for better.
290bffdb87cSfujita */
291bffdb87cSfujita if (match_s == NULL) {
292bffdb87cSfujita match_s = hd;
293bffdb87cSfujita new_c = hc->hp_unit;
294bffdb87cSfujita new_s = s;
295bffdb87cSfujita continue;
296bffdb87cSfujita }
297bffdb87cSfujita /*
298bffdb87cSfujita * Case 1: exact match.
299bffdb87cSfujita * All done. Note that we do not attempt any other
300bffdb87cSfujita * matches if this one fails. This allows us to
301bffdb87cSfujita * "reserve" locations for dynamic addition of
302bffdb87cSfujita * disk/tape drives by fully qualifing the location.
303bffdb87cSfujita */
304bffdb87cSfujita if (hd->hp_slave == s && hd->hp_ctlr == hc->hp_unit) {
305bffdb87cSfujita match_s = hd;
306bffdb87cSfujita rescan = 0;
307bffdb87cSfujita break;
308bffdb87cSfujita }
309bffdb87cSfujita /*
310bffdb87cSfujita * Case 2: right controller, wildcarded slave.
311bffdb87cSfujita * Remember first and keep looking for an exact match.
312bffdb87cSfujita */
313bffdb87cSfujita if (hd->hp_ctlr == hc->hp_unit &&
314bffdb87cSfujita match_s->hp_ctlr < 0) {
315bffdb87cSfujita match_s = hd;
316bffdb87cSfujita new_s = s;
317bffdb87cSfujita continue;
318bffdb87cSfujita }
319bffdb87cSfujita /*
320bffdb87cSfujita * Case 3: right slave, wildcarded controller.
321bffdb87cSfujita * Remember and keep looking for a better match.
322bffdb87cSfujita */
323bffdb87cSfujita if (hd->hp_slave == s &&
324bffdb87cSfujita match_s->hp_ctlr < 0 && match_s->hp_slave < 0) {
325bffdb87cSfujita match_s = hd;
326bffdb87cSfujita new_c = hc->hp_unit;
327bffdb87cSfujita continue;
328bffdb87cSfujita }
329bffdb87cSfujita /*
330bffdb87cSfujita * OW: we had a totally wildcarded spec.
331bffdb87cSfujita * If we got this far, we have found a possible
332bffdb87cSfujita * match already (match_s != NULL) so there is no
333bffdb87cSfujita * reason to remember this one.
334bffdb87cSfujita */
335bffdb87cSfujita continue;
336bffdb87cSfujita }
337bffdb87cSfujita /*
338bffdb87cSfujita * Found a match. We need to set hp_ctlr/hp_slave properly
339bffdb87cSfujita * for the init routines but we also need to remember all
340bffdb87cSfujita * the old values in case this doesn't pan out.
341bffdb87cSfujita */
342bffdb87cSfujita if (match_s) {
343bffdb87cSfujita hd = match_s;
344bffdb87cSfujita old_c = hd->hp_ctlr;
345bffdb87cSfujita old_s = hd->hp_slave;
346bffdb87cSfujita if (hd->hp_ctlr < 0)
347bffdb87cSfujita hd->hp_ctlr = new_c;
348bffdb87cSfujita if (hd->hp_slave < 0)
349bffdb87cSfujita hd->hp_slave = new_s;
350bffdb87cSfujita #ifdef DEBUG
351bffdb87cSfujita if (acdebug)
352bffdb87cSfujita printf("looking for %s%d at slave %d...",
353bffdb87cSfujita hd->hp_driver->d_name,
354bffdb87cSfujita hd->hp_unit, hd->hp_slave);
355bffdb87cSfujita #endif
356bffdb87cSfujita
357bffdb87cSfujita if ((*hd->hp_driver->d_init)(hd)) {
358bffdb87cSfujita #ifdef DEBUG
359bffdb87cSfujita if (acdebug)
360bffdb87cSfujita printf("found\n");
361bffdb87cSfujita #endif
362bffdb87cSfujita printf("%s%d at %s%d, slave %d",
363bffdb87cSfujita hd->hp_driver->d_name, hd->hp_unit,
364bffdb87cSfujita hc->hp_driver->d_name, hd->hp_ctlr,
365bffdb87cSfujita hd->hp_slave);
366bffdb87cSfujita if (hd->hp_flags)
367bffdb87cSfujita printf(" flags 0x%x", hd->hp_flags);
368bffdb87cSfujita printf("\n");
369bffdb87cSfujita hd->hp_alive = 1;
370bffdb87cSfujita if (hd->hp_dk && dkn < DK_NDRIVE)
371bffdb87cSfujita hd->hp_dk = dkn++;
372bffdb87cSfujita else
373bffdb87cSfujita hd->hp_dk = -1;
374bffdb87cSfujita rescan = 1;
375bffdb87cSfujita } else {
376bffdb87cSfujita #ifdef DEBUG
377bffdb87cSfujita if (acdebug)
378bffdb87cSfujita printf("not found\n");
379bffdb87cSfujita #endif
380bffdb87cSfujita hd->hp_ctlr = old_c;
381bffdb87cSfujita hd->hp_slave = old_s;
382bffdb87cSfujita }
383bffdb87cSfujita /*
384bffdb87cSfujita * XXX: This should be handled better.
385bffdb87cSfujita * Re-scan a slave. There are two reasons to do this.
386bffdb87cSfujita * 1. It is possible to have both a tape and disk
387bffdb87cSfujita * (e.g. 7946) or two disks (e.g. 9122) at the
388bffdb87cSfujita * same slave address. Here we need to rescan
389bffdb87cSfujita * looking only at entries with a different
390bffdb87cSfujita * physical unit number (hp_flags).
391bffdb87cSfujita * 2. It is possible that an init failed because the
392bffdb87cSfujita * slave was there but of the wrong type. In this
393bffdb87cSfujita * case it may still be possible to match the slave
394bffdb87cSfujita * to another ioconf entry of a different type.
395bffdb87cSfujita * Here we need to rescan looking only at entries
396bffdb87cSfujita * of different types.
397bffdb87cSfujita * In both cases we avoid looking at undesirable
398bffdb87cSfujita * ioconf entries of the same type by setting their
399bffdb87cSfujita * alive fields to -1.
400bffdb87cSfujita */
401bffdb87cSfujita if (rescan) {
402bffdb87cSfujita for (hd = hp_dinit; hd->hp_driver; hd++) {
403bffdb87cSfujita if (hd->hp_alive)
404bffdb87cSfujita continue;
405bffdb87cSfujita if (match_s->hp_alive == 1) { /* 1 */
406bffdb87cSfujita if (hd->hp_flags == match_s->hp_flags)
407bffdb87cSfujita hd->hp_alive = -1;
408bffdb87cSfujita } else { /* 2 */
409bffdb87cSfujita if (hd->hp_driver == match_s->hp_driver)
410bffdb87cSfujita hd->hp_alive = -1;
411bffdb87cSfujita }
412bffdb87cSfujita }
413bffdb87cSfujita s--;
414bffdb87cSfujita continue;
415bffdb87cSfujita }
416bffdb87cSfujita }
417bffdb87cSfujita /*
418bffdb87cSfujita * Reset bogon alive fields prior to attempting next slave
419bffdb87cSfujita */
420bffdb87cSfujita for (hd = hp_dinit; hd->hp_driver; hd++)
421bffdb87cSfujita if (hd->hp_alive == -1)
422bffdb87cSfujita hd->hp_alive = 0;
423bffdb87cSfujita }
424bffdb87cSfujita }
425bffdb87cSfujita
426bffdb87cSfujita same_hw_device(hw, hd)
427bffdb87cSfujita struct hp_hw *hw;
428bffdb87cSfujita struct hp_device *hd;
429bffdb87cSfujita {
430bffdb87cSfujita int found = 0;
431bffdb87cSfujita
432bffdb87cSfujita switch (hw->hw_type & ~B_MASK) {
433bffdb87cSfujita case C_SCSI:
434bffdb87cSfujita found = dr_type(hd->hp_driver, "sc");
435bffdb87cSfujita break;
436bffdb87cSfujita case D_LAN:
437bffdb87cSfujita found = dr_type(hd->hp_driver, "le");
438bffdb87cSfujita break;
439bffdb87cSfujita case D_SIO:
440bffdb87cSfujita found = dr_type(hd->hp_driver, "sio");
441bffdb87cSfujita break;
4420aa0d8d8Sakito case D_BMC:
4430aa0d8d8Sakito found = dr_type(hd->hp_driver, "bmc");
4440aa0d8d8Sakito break;
445bffdb87cSfujita default:
446bffdb87cSfujita break;
447bffdb87cSfujita }
448bffdb87cSfujita return(found);
449bffdb87cSfujita }
450bffdb87cSfujita
451bffdb87cSfujita /*
452bffdb87cSfujita * Scan the IO space looking for devices.
453bffdb87cSfujita */
454bffdb87cSfujita
455bffdb87cSfujita #define setup_hw(hw, addr, sc, type, id) \
456bffdb87cSfujita (hw)->hw_pa = addr; \
457bffdb87cSfujita (hw)->hw_kva = addr; \
458bffdb87cSfujita (hw)->hw_id = id; \
459bffdb87cSfujita (hw)->hw_type = type; \
460bffdb87cSfujita (hw)->hw_sc = sc
461bffdb87cSfujita
find_devs()462bffdb87cSfujita find_devs()
463bffdb87cSfujita {
464bffdb87cSfujita register struct hp_hw *hw = sc_table;
465bffdb87cSfujita
46662baf01bSakito #include "bmc.h"
46762baf01bSakito #if NBMC > 0
4680aa0d8d8Sakito setup_hw(hw, (char *) 0x51000004, 0x5, D_BMC, 0x5);
4690aa0d8d8Sakito hw->hw_secid = 0; hw++;
47062baf01bSakito #endif
471bffdb87cSfujita setup_hw(hw, (char *) 0x51000000, 0x5, D_SIO, 0x5);
472bffdb87cSfujita hw->hw_secid = 0; hw++;
47362baf01bSakito #if NBMC == 0
47462baf01bSakito #if NSIO > 1
47562baf01bSakito setup_hw(hw, (char *) 0x51000004, 0x5, D_SIO, 0x5);
47662baf01bSakito hw->hw_secid = 0; hw++;
47762baf01bSakito #endif
47862baf01bSakito #endif
479bffdb87cSfujita
480bffdb87cSfujita setup_hw(hw, (char *) 0xe1000000, 0xe, C_SCSI, 0xe);
481bffdb87cSfujita hw++;
482bffdb87cSfujita
483bffdb87cSfujita if (!badaddr((caddr_t) 0xf1000000)) {
484bffdb87cSfujita setup_hw(hw, (char *) 0xf1000000, 0xf, D_LAN, 0xf);
485bffdb87cSfujita hw++;
486bffdb87cSfujita }
48713d6ce47Sakito
48813d6ce47Sakito #if defined(LUNA2) && defined(notyet)
48913d6ce47Sakito if (machineid == LUNA_II) {
49013d6ce47Sakito setup_hw(hw, (char *) 0xe1000040, 0xe, C_SCSI, 0xe);
49113d6ce47Sakito hw++;
49213d6ce47Sakito
49313d6ce47Sakito if (!badaddr((caddr_t) 0xf1000008)) {
49413d6ce47Sakito setup_hw(hw, (char *) 0xf1000008, 0xf, D_LAN, 0xf);
49513d6ce47Sakito hw++;
49613d6ce47Sakito }
49713d6ce47Sakito }
49813d6ce47Sakito #endif
499bffdb87cSfujita }
500bffdb87cSfujita
501bffdb87cSfujita /*
502bffdb87cSfujita * Configure swap space and related parameters.
503bffdb87cSfujita */
swapconf()504bffdb87cSfujita swapconf()
505bffdb87cSfujita {
506bffdb87cSfujita register struct swdevt *swp;
507bffdb87cSfujita register int nblks;
508bffdb87cSfujita
509a054693bStorek for (swp = swdevt; swp->sw_dev != NODEV; swp++)
510bffdb87cSfujita if (bdevsw[major(swp->sw_dev)].d_psize) {
511bffdb87cSfujita nblks =
512bffdb87cSfujita (*bdevsw[major(swp->sw_dev)].d_psize)(swp->sw_dev);
513bffdb87cSfujita if (nblks != -1 &&
514bffdb87cSfujita (swp->sw_nblks == 0 || swp->sw_nblks > nblks))
515bffdb87cSfujita swp->sw_nblks = nblks;
516bffdb87cSfujita }
517bffdb87cSfujita dumpconf();
518bffdb87cSfujita }
519bffdb87cSfujita
520bffdb87cSfujita #define DOSWAP /* Change swdevt and dumpdev too */
521a3a09ba5Sakito u_long bootdev; /* should be dev_t, but not until 32 bits */
522bffdb87cSfujita
523bffdb87cSfujita static char devname[][2] = {
524bffdb87cSfujita 0,0, /* 0 = ct */
525bffdb87cSfujita 0,0, /* 1 = xx */
526bffdb87cSfujita 'r','d', /* 2 = rd */
527bffdb87cSfujita 0,0, /* 3 = sw */
528bffdb87cSfujita 's','d', /* 4 = rd */
529bffdb87cSfujita };
530bffdb87cSfujita
531bffdb87cSfujita #define PARTITIONMASK 0x7
532bffdb87cSfujita #define PARTITIONSHIFT 3
533bffdb87cSfujita
534bffdb87cSfujita /*
535bffdb87cSfujita * Attempt to find the device from which we were booted.
536bffdb87cSfujita * If we can do so, and not instructed not to do so,
537bffdb87cSfujita * change rootdev to correspond to the load device.
538bffdb87cSfujita */
setroot()539bffdb87cSfujita setroot()
540bffdb87cSfujita {
541bffdb87cSfujita register struct hp_ctlr *hc;
542bffdb87cSfujita register struct hp_device *hd;
543a3a09ba5Sakito int majdev, mindev, unit, part, controller, adaptor;
544bffdb87cSfujita dev_t temp, orootdev;
545bffdb87cSfujita struct swdevt *swp;
546bffdb87cSfujita
547a3a09ba5Sakito if (boothowto & RB_DFLTROOT ||
548a3a09ba5Sakito (bootdev & B_MAGICMASK) != (u_long)B_DEVMAGIC) {
549bffdb87cSfujita printf("Wrong B_DEVMAGIC\n");
550a3a09ba5Sakito return;
551bffdb87cSfujita }
552a3a09ba5Sakito majdev = B_TYPE(bootdev);
553bffdb87cSfujita if (majdev > sizeof(devname) / sizeof(devname[0])) {
554bffdb87cSfujita printf("Wrong Major Number: %d", majdev);
555a3a09ba5Sakito return;
556bffdb87cSfujita }
557a3a09ba5Sakito adaptor = B_ADAPTOR(bootdev);
558a3a09ba5Sakito controller = B_CONTROLLER(bootdev);
559a3a09ba5Sakito part = B_PARTITION(bootdev);
560a3a09ba5Sakito unit = B_UNIT(bootdev);
561bffdb87cSfujita /*
562a3a09ba5Sakito * First, find the controller type which supports this device.
563bffdb87cSfujita */
564bffdb87cSfujita for (hd = hp_dinit; hd->hp_driver; hd++)
565bffdb87cSfujita if (hd->hp_driver->d_name[0] == devname[majdev][0] &&
566bffdb87cSfujita hd->hp_driver->d_name[1] == devname[majdev][1])
567bffdb87cSfujita break;
568bffdb87cSfujita if (hd->hp_driver == 0) {
569bffdb87cSfujita printf("Device type mismatch: %c%c\n",
570bffdb87cSfujita devname[majdev][0], devname[majdev][1]);
571a3a09ba5Sakito return;
572bffdb87cSfujita }
573bffdb87cSfujita /*
574a3a09ba5Sakito * Next, find the "controller" (bus adaptor) of that type
575a3a09ba5Sakito * corresponding to the adaptor number.
576bffdb87cSfujita */
577bffdb87cSfujita for (hc = hp_cinit; hc->hp_driver; hc++)
578bffdb87cSfujita if (hc->hp_alive && hc->hp_unit == adaptor &&
579bffdb87cSfujita hc->hp_driver == hd->hp_cdriver)
580bffdb87cSfujita break;
581bffdb87cSfujita if (hc->hp_driver == 0) {
582bffdb87cSfujita printf("Controller is not available\n");
583a3a09ba5Sakito return;
584bffdb87cSfujita }
585bffdb87cSfujita /*
586a3a09ba5Sakito * Finally, find the "device" (controller or slave) in question
587a3a09ba5Sakito * attached to that "controller".
588bffdb87cSfujita */
589bffdb87cSfujita for (hd = hp_dinit; hd->hp_driver; hd++)
590a3a09ba5Sakito if (hd->hp_alive && hd->hp_slave == controller &&
591bffdb87cSfujita hd->hp_cdriver == hc->hp_driver &&
592bffdb87cSfujita hd->hp_ctlr == hc->hp_unit)
593bffdb87cSfujita break;
594bffdb87cSfujita if (hd->hp_driver == 0) {
595bffdb87cSfujita printf("Device not found\n");
596a3a09ba5Sakito return;
597bffdb87cSfujita }
598bffdb87cSfujita
599bffdb87cSfujita mindev = hd->hp_unit;
600bffdb87cSfujita /*
601bffdb87cSfujita * Form a new rootdev
602bffdb87cSfujita */
603bffdb87cSfujita mindev = (mindev << PARTITIONSHIFT) + part;
604bffdb87cSfujita orootdev = rootdev;
605bffdb87cSfujita rootdev = makedev(majdev, mindev);
606bffdb87cSfujita /*
607bffdb87cSfujita * If the original rootdev is the same as the one
608bffdb87cSfujita * just calculated, don't need to adjust the swap configuration.
609bffdb87cSfujita */
610a3a09ba5Sakito if (rootdev == orootdev)
611bffdb87cSfujita return;
612bffdb87cSfujita
613bffdb87cSfujita printf("Changing root device to %c%c%d%c\n",
614bffdb87cSfujita devname[majdev][0], devname[majdev][1],
615bffdb87cSfujita mindev >> PARTITIONSHIFT, part + 'a');
616bffdb87cSfujita
617bffdb87cSfujita #ifdef DOSWAP
618bffdb87cSfujita mindev &= ~PARTITIONMASK;
619a054693bStorek for (swp = swdevt; swp->sw_dev != NODEV; swp++) {
620bffdb87cSfujita if (majdev == major(swp->sw_dev) &&
621bffdb87cSfujita mindev == (minor(swp->sw_dev) & ~PARTITIONMASK)) {
622bffdb87cSfujita temp = swdevt[0].sw_dev;
623bffdb87cSfujita swdevt[0].sw_dev = swp->sw_dev;
624bffdb87cSfujita swp->sw_dev = temp;
625bffdb87cSfujita break;
626bffdb87cSfujita }
627bffdb87cSfujita }
628a054693bStorek if (swp->sw_dev == NODEV)
629bffdb87cSfujita return;
630bffdb87cSfujita
631bffdb87cSfujita /*
632bffdb87cSfujita * If dumpdev was the same as the old primary swap
633bffdb87cSfujita * device, move it to the new primary swap device.
634bffdb87cSfujita */
635bffdb87cSfujita if (temp == dumpdev)
636bffdb87cSfujita dumpdev = swdevt[0].sw_dev;
637bffdb87cSfujita #endif
638bffdb87cSfujita }
639bffdb87cSfujita
showroot()640a3a09ba5Sakito showroot()
641a3a09ba5Sakito {
642a3a09ba5Sakito register int majdev, mindev;
643a3a09ba5Sakito register struct swdevt *swp;
644a3a09ba5Sakito
645a3a09ba5Sakito majdev = major(rootdev);
646a3a09ba5Sakito mindev = minor(rootdev);
647a3a09ba5Sakito printf("root on %c%c%d%c ",
648a3a09ba5Sakito devname[majdev][0], devname[majdev][1],
649a3a09ba5Sakito mindev >> PARTITIONSHIFT, (mindev & PARTITIONMASK) + 'a');
650a3a09ba5Sakito
651a3a09ba5Sakito swp = swdevt;
652a3a09ba5Sakito majdev = major(swp->sw_dev);
653a3a09ba5Sakito mindev = minor(swp->sw_dev);
654a3a09ba5Sakito printf("swap on %c%c%d%c ",
655a3a09ba5Sakito devname[majdev][0], devname[majdev][1],
656a3a09ba5Sakito mindev >> PARTITIONSHIFT, (mindev & PARTITIONMASK) + 'a');
657a3a09ba5Sakito
658a3a09ba5Sakito swp++;
659a054693bStorek for (; swp->sw_dev != NODEV; swp++) {
660a3a09ba5Sakito majdev = major(swp->sw_dev);
661a3a09ba5Sakito mindev = minor(swp->sw_dev);
662a3a09ba5Sakito printf("and %c%c%d%c ",
663a3a09ba5Sakito devname[majdev][0], devname[majdev][1],
664a3a09ba5Sakito mindev >> PARTITIONSHIFT, (mindev & PARTITIONMASK) + 'a');
665a3a09ba5Sakito }
666a3a09ba5Sakito
667a3a09ba5Sakito majdev = major(dumpdev);
668a3a09ba5Sakito mindev = minor(dumpdev);
669a3a09ba5Sakito printf(" dump on %c%c%d%c\n",
670a3a09ba5Sakito devname[majdev][0], devname[majdev][1],
671a3a09ba5Sakito mindev >> PARTITIONSHIFT, (mindev & PARTITIONMASK) + 'a');
672a3a09ba5Sakito }
strcmp(s1,s2)673bffdb87cSfujita strcmp(s1, s2)
674bffdb87cSfujita register char *s1, *s2;
675bffdb87cSfujita {
676bffdb87cSfujita while (*s1 == *s2++)
677bffdb87cSfujita if (*s1++=='\0')
678bffdb87cSfujita return (0);
679bffdb87cSfujita return (*s1 - *--s2);
680bffdb87cSfujita }
681bffdb87cSfujita
strncmp(s1,s2,n)682bffdb87cSfujita strncmp(s1, s2, n)
683bffdb87cSfujita register char *s1, *s2;
684bffdb87cSfujita register unsigned int n;
685bffdb87cSfujita {
686bffdb87cSfujita
687bffdb87cSfujita if (n == 0)
688bffdb87cSfujita return (0);
689bffdb87cSfujita do {
690bffdb87cSfujita if (*s1 != *s2++)
691bffdb87cSfujita return (*(unsigned char *)s1 - *(unsigned char *)--s2);
692bffdb87cSfujita if (*s1++ == 0)
693bffdb87cSfujita break;
694bffdb87cSfujita } while (--n != 0);
695bffdb87cSfujita return (0);
696bffdb87cSfujita }
697