4.4BSD/usr/src/sys/luna68k/luna68k/autoconf.c
/*
* Copyright (c) 1988 University of Utah.
* Copyright (c) 1992 OMRON Corporation.
* Copyright (c) 1982, 1986, 1990, 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* the Systems Programming Group of the University of Utah Computer
* Science Department.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* from:hp300/hp300/autoconf.c 7.9 (Berkeley) 12/27/92
*
* @(#)autoconf.c 8.1 (Berkeley) 6/10/93
*/
/*
* autoconf.c -- for auto configration
* remade by A.Fujita, MAR-24-1992
*/
/*
* Setup the system to run on the current machine.
*
* Configure() is called at boot time. Available
* devices are determined (from possibilities mentioned in ioconf.c),
* and the drivers are initialized.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/dkstat.h>
#include <sys/conf.h>
#include <sys/reboot.h>
#include <machine/cpu.h>
#include <luna68k/dev/device.h>
/*
* The following several variables are related to
* the configuration process, and are used in initializing
* the machine.
*/
int cold; /* if 1, still working on cold-start */
int dkn; /* number of iostat dk numbers assigned so far */
struct hp_hw sc_table[MAXCTLRS];
#ifdef DEBUG
int acdebug = 0;
#endif
/*
* Determine mass storage and memory configuration for a machine.
*/
configure()
{
register struct hp_hw *hw;
int found;
/*
* Look over each hardware device actually found and attempt
* to match it with an ioconf.c table entry.
*/
for (hw = sc_table; hw->hw_type; hw++) {
if (HW_ISCTLR(hw))
found = find_controller(hw);
else
found = find_device(hw);
#ifdef DEBUG
if (!found) {
printf("unconfigured card id %x ", hw->hw_id);
printf("at 0x%x\n", hw->hw_pa);
}
#endif
}
#if GENERIC
if ((boothowto & RB_ASKNAME) == 0)
setroot();
setconf();
#else
setroot();
#endif
showroot();
swapconf();
cold = 0;
}
#define dr_type(d, s) \
(strcmp((d)->d_name, (s)) == 0)
#define same_hw_ctlr(hw, hc) \
HW_ISSCSI(hw) && dr_type((hc)->hp_driver, "sc")
find_controller(hw)
register struct hp_hw *hw;
{
register struct hp_ctlr *hc;
struct hp_ctlr *match_c;
caddr_t oaddr;
int sc;
#ifdef DEBUG
if (acdebug)
printf("find_controller: hw: id%x at sc%d (%x), type %x...",
hw->hw_id, hw->hw_sc, hw->hw_kva, hw->hw_type);
#endif
sc = hw->hw_sc;
match_c = NULL;
for (hc = hp_cinit; hc->hp_driver; hc++) {
if (hc->hp_alive)
continue;
/*
* Make sure we are looking at the right
* controller type.
*/
if (!same_hw_ctlr(hw, hc))
continue;
/*
* Exact match; all done
*/
if ((int)hc->hp_addr == sc) {
match_c = hc;
break;
}
/*
* Wildcard; possible match so remember first instance
* but continue looking for exact match.
*/
if (hc->hp_addr == NULL && match_c == NULL)
match_c = hc;
}
#ifdef DEBUG
if (acdebug) {
if (match_c)
printf("found %s%d\n",
match_c->hp_driver->d_name,
match_c->hp_unit);
else
printf("not found\n");
}
#endif
/*
* Didn't find an ioconf entry for this piece of hardware,
* just ignore it.
*/
if (match_c == NULL)
return(0);
/*
* Found a match, attempt to initialize and configure all attached
* slaves. Note, we can still fail if HW won't initialize.
*/
hc = match_c;
oaddr = hc->hp_addr;
hc->hp_addr = hw->hw_kva;
if ((*hc->hp_driver->d_init)(hc)) {
hc->hp_alive = 1;
printf("%s%d", hc->hp_driver->d_name, hc->hp_unit);
printf(" at 0x%x,", hw->hw_pa);
printf(" ipl %d", hc->hp_ipl);
if (hc->hp_flags)
printf(" flags 0x%x", hc->hp_flags);
printf("\n");
find_slaves(hc);
} else
hc->hp_addr = oaddr;
return(1);
}
find_device(hw)
register struct hp_hw *hw;
{
register struct hp_device *hd;
struct hp_device *match_d;
caddr_t oaddr;
int sc;
#ifdef DEBUG
if (acdebug)
printf("find_device: hw: id%x at sc%d (%x), type %x...",
hw->hw_id, hw->hw_sc, hw->hw_kva, hw->hw_type);
#endif
match_d = NULL;
for (hd = hp_dinit; hd->hp_driver; hd++) {
if (hd->hp_alive)
continue;
/* Must not be a slave */
if (hd->hp_cdriver)
continue;
sc = (int) hd->hp_addr;
/*
* Exact match; all done.
*/
if (sc > 0 && sc == hw->hw_sc) {
match_d = hd;
break;
}
/*
* Wildcard; possible match so remember first instance
* but continue looking for exact match.
*/
if (sc == 0 && same_hw_device(hw, hd) && match_d == NULL)
match_d = hd;
}
#ifdef DEBUG
if (acdebug) {
if (match_d)
printf("found %s%d\n",
match_d->hp_driver->d_name,
match_d->hp_unit);
else
printf("not found\n");
}
#endif
/*
* Didn't find an ioconf entry for this piece
* of hardware, just ignore it.
*/
if (match_d == NULL)
return(0);
/*
* Found a match, attempt to initialize.
* Note, we can still fail if HW won't initialize.
*/
hd = match_d;
oaddr = hd->hp_addr;
hd->hp_addr = hw->hw_kva;
if ((*hd->hp_driver->d_init)(hd)) {
hd->hp_alive = 1;
printf("%s%d", hd->hp_driver->d_name, hd->hp_unit);
printf(" at 0x%x", hw->hw_pa);
if (hd->hp_ipl)
printf(", ipl %d", hd->hp_ipl);
if (hd->hp_flags)
printf(", flags 0x%x", hd->hp_flags);
printf("\n");
} else
hd->hp_addr = oaddr;
return(1);
}
/*
* Search each BUS controller found for slaves attached to it.
* The bad news is that we don't know how to uniquely identify all slaves
* (e.g. PPI devices on HP-IB). The good news is that we can at least
* differentiate those from slaves we can identify. At worst (a totally
* wildcarded entry) this will cause us to locate such a slave at the first
* unused position instead of where it really is. To save grief, non-
* identifing devices should always be fully qualified.
*/
find_slaves(hc)
register struct hp_ctlr *hc;
{
register int s;
register struct hp_device *hd;
struct hp_device *match_s;
int maxslaves = MAXSLAVES - 1;
int new_s, new_c, old_s, old_c;
int rescan;
#ifdef DEBUG
if (acdebug)
printf("find_busslaves: for %s%d\n",
hc->hp_driver->d_name, hc->hp_unit);
#endif
for (s = 0; s < maxslaves; s++) {
rescan = 1;
match_s = NULL;
for (hd = hp_dinit; hd->hp_driver; hd++) {
/*
* Rule out the easy ones:
* 1. slave already assigned or not a slave
* 2. not of the proper type
* 3. controller specified but not this one
* 4. slave specified but not this one
*/
if (hd->hp_alive || hd->hp_cdriver == NULL)
continue;
if (!dr_type(hc->hp_driver, hd->hp_cdriver->d_name))
continue;
if (hd->hp_ctlr >= 0 && hd->hp_ctlr != hc->hp_unit)
continue;
if (hd->hp_slave >= 0 && hd->hp_slave != s)
continue;
/*
* Case 0: first possible match.
* Remember it and keep looking for better.
*/
if (match_s == NULL) {
match_s = hd;
new_c = hc->hp_unit;
new_s = s;
continue;
}
/*
* Case 1: exact match.
* All done. Note that we do not attempt any other
* matches if this one fails. This allows us to
* "reserve" locations for dynamic addition of
* disk/tape drives by fully qualifing the location.
*/
if (hd->hp_slave == s && hd->hp_ctlr == hc->hp_unit) {
match_s = hd;
rescan = 0;
break;
}
/*
* Case 2: right controller, wildcarded slave.
* Remember first and keep looking for an exact match.
*/
if (hd->hp_ctlr == hc->hp_unit &&
match_s->hp_ctlr < 0) {
match_s = hd;
new_s = s;
continue;
}
/*
* Case 3: right slave, wildcarded controller.
* Remember and keep looking for a better match.
*/
if (hd->hp_slave == s &&
match_s->hp_ctlr < 0 && match_s->hp_slave < 0) {
match_s = hd;
new_c = hc->hp_unit;
continue;
}
/*
* OW: we had a totally wildcarded spec.
* If we got this far, we have found a possible
* match already (match_s != NULL) so there is no
* reason to remember this one.
*/
continue;
}
/*
* Found a match. We need to set hp_ctlr/hp_slave properly
* for the init routines but we also need to remember all
* the old values in case this doesn't pan out.
*/
if (match_s) {
hd = match_s;
old_c = hd->hp_ctlr;
old_s = hd->hp_slave;
if (hd->hp_ctlr < 0)
hd->hp_ctlr = new_c;
if (hd->hp_slave < 0)
hd->hp_slave = new_s;
#ifdef DEBUG
if (acdebug)
printf("looking for %s%d at slave %d...",
hd->hp_driver->d_name,
hd->hp_unit, hd->hp_slave);
#endif
if ((*hd->hp_driver->d_init)(hd)) {
#ifdef DEBUG
if (acdebug)
printf("found\n");
#endif
printf("%s%d at %s%d, slave %d",
hd->hp_driver->d_name, hd->hp_unit,
hc->hp_driver->d_name, hd->hp_ctlr,
hd->hp_slave);
if (hd->hp_flags)
printf(" flags 0x%x", hd->hp_flags);
printf("\n");
hd->hp_alive = 1;
if (hd->hp_dk && dkn < DK_NDRIVE)
hd->hp_dk = dkn++;
else
hd->hp_dk = -1;
rescan = 1;
} else {
#ifdef DEBUG
if (acdebug)
printf("not found\n");
#endif
hd->hp_ctlr = old_c;
hd->hp_slave = old_s;
}
/*
* XXX: This should be handled better.
* Re-scan a slave. There are two reasons to do this.
* 1. It is possible to have both a tape and disk
* (e.g. 7946) or two disks (e.g. 9122) at the
* same slave address. Here we need to rescan
* looking only at entries with a different
* physical unit number (hp_flags).
* 2. It is possible that an init failed because the
* slave was there but of the wrong type. In this
* case it may still be possible to match the slave
* to another ioconf entry of a different type.
* Here we need to rescan looking only at entries
* of different types.
* In both cases we avoid looking at undesirable
* ioconf entries of the same type by setting their
* alive fields to -1.
*/
if (rescan) {
for (hd = hp_dinit; hd->hp_driver; hd++) {
if (hd->hp_alive)
continue;
if (match_s->hp_alive == 1) { /* 1 */
if (hd->hp_flags == match_s->hp_flags)
hd->hp_alive = -1;
} else { /* 2 */
if (hd->hp_driver == match_s->hp_driver)
hd->hp_alive = -1;
}
}
s--;
continue;
}
}
/*
* Reset bogon alive fields prior to attempting next slave
*/
for (hd = hp_dinit; hd->hp_driver; hd++)
if (hd->hp_alive == -1)
hd->hp_alive = 0;
}
}
same_hw_device(hw, hd)
struct hp_hw *hw;
struct hp_device *hd;
{
int found = 0;
switch (hw->hw_type & ~B_MASK) {
case C_SCSI:
found = dr_type(hd->hp_driver, "sc");
break;
case D_LAN:
found = dr_type(hd->hp_driver, "le");
break;
case D_SIO:
found = dr_type(hd->hp_driver, "sio");
break;
case D_BMC:
found = dr_type(hd->hp_driver, "bmc");
break;
default:
break;
}
return(found);
}
/*
* Scan the IO space looking for devices.
*/
#define setup_hw(hw, addr, sc, type, id) \
(hw)->hw_pa = addr; \
(hw)->hw_kva = addr; \
(hw)->hw_id = id; \
(hw)->hw_type = type; \
(hw)->hw_sc = sc
find_devs()
{
register struct hp_hw *hw = sc_table;
#include "bmc.h"
#if NBMC > 0
setup_hw(hw, (char *) 0x51000004, 0x5, D_BMC, 0x5);
hw->hw_secid = 0; hw++;
#endif
setup_hw(hw, (char *) 0x51000000, 0x5, D_SIO, 0x5);
hw->hw_secid = 0; hw++;
#if NBMC == 0
#if NSIO > 1
setup_hw(hw, (char *) 0x51000004, 0x5, D_SIO, 0x5);
hw->hw_secid = 0; hw++;
#endif
#endif
setup_hw(hw, (char *) 0xe1000000, 0xe, C_SCSI, 0xe);
hw++;
if (!badaddr((caddr_t) 0xf1000000)) {
setup_hw(hw, (char *) 0xf1000000, 0xf, D_LAN, 0xf);
hw++;
}
#if defined(LUNA2) && defined(notyet)
if (machineid == LUNA_II) {
setup_hw(hw, (char *) 0xe1000040, 0xe, C_SCSI, 0xe);
hw++;
if (!badaddr((caddr_t) 0xf1000008)) {
setup_hw(hw, (char *) 0xf1000008, 0xf, D_LAN, 0xf);
hw++;
}
}
#endif
}
/*
* Configure swap space and related parameters.
*/
swapconf()
{
register struct swdevt *swp;
register int nblks;
for (swp = swdevt; swp->sw_dev != NODEV; swp++)
if (bdevsw[major(swp->sw_dev)].d_psize) {
nblks =
(*bdevsw[major(swp->sw_dev)].d_psize)(swp->sw_dev);
if (nblks != -1 &&
(swp->sw_nblks == 0 || swp->sw_nblks > nblks))
swp->sw_nblks = nblks;
}
dumpconf();
}
#define DOSWAP /* Change swdevt and dumpdev too */
u_long bootdev; /* should be dev_t, but not until 32 bits */
static char devname[][2] = {
0,0, /* 0 = ct */
0,0, /* 1 = xx */
'r','d', /* 2 = rd */
0,0, /* 3 = sw */
's','d', /* 4 = rd */
};
#define PARTITIONMASK 0x7
#define PARTITIONSHIFT 3
/*
* Attempt to find the device from which we were booted.
* If we can do so, and not instructed not to do so,
* change rootdev to correspond to the load device.
*/
setroot()
{
register struct hp_ctlr *hc;
register struct hp_device *hd;
int majdev, mindev, unit, part, controller, adaptor;
dev_t temp, orootdev;
struct swdevt *swp;
if (boothowto & RB_DFLTROOT ||
(bootdev & B_MAGICMASK) != (u_long)B_DEVMAGIC) {
printf("Wrong B_DEVMAGIC\n");
return;
}
majdev = B_TYPE(bootdev);
if (majdev > sizeof(devname) / sizeof(devname[0])) {
printf("Wrong Major Number: %d", majdev);
return;
}
adaptor = B_ADAPTOR(bootdev);
controller = B_CONTROLLER(bootdev);
part = B_PARTITION(bootdev);
unit = B_UNIT(bootdev);
/*
* First, find the controller type which supports this device.
*/
for (hd = hp_dinit; hd->hp_driver; hd++)
if (hd->hp_driver->d_name[0] == devname[majdev][0] &&
hd->hp_driver->d_name[1] == devname[majdev][1])
break;
if (hd->hp_driver == 0) {
printf("Device type mismatch: %c%c\n",
devname[majdev][0], devname[majdev][1]);
return;
}
/*
* Next, find the "controller" (bus adaptor) of that type
* corresponding to the adaptor number.
*/
for (hc = hp_cinit; hc->hp_driver; hc++)
if (hc->hp_alive && hc->hp_unit == adaptor &&
hc->hp_driver == hd->hp_cdriver)
break;
if (hc->hp_driver == 0) {
printf("Controller is not available\n");
return;
}
/*
* Finally, find the "device" (controller or slave) in question
* attached to that "controller".
*/
for (hd = hp_dinit; hd->hp_driver; hd++)
if (hd->hp_alive && hd->hp_slave == controller &&
hd->hp_cdriver == hc->hp_driver &&
hd->hp_ctlr == hc->hp_unit)
break;
if (hd->hp_driver == 0) {
printf("Device not found\n");
return;
}
mindev = hd->hp_unit;
/*
* Form a new rootdev
*/
mindev = (mindev << PARTITIONSHIFT) + part;
orootdev = rootdev;
rootdev = makedev(majdev, mindev);
/*
* If the original rootdev is the same as the one
* just calculated, don't need to adjust the swap configuration.
*/
if (rootdev == orootdev)
return;
printf("Changing root device to %c%c%d%c\n",
devname[majdev][0], devname[majdev][1],
mindev >> PARTITIONSHIFT, part + 'a');
#ifdef DOSWAP
mindev &= ~PARTITIONMASK;
for (swp = swdevt; swp->sw_dev != NODEV; swp++) {
if (majdev == major(swp->sw_dev) &&
mindev == (minor(swp->sw_dev) & ~PARTITIONMASK)) {
temp = swdevt[0].sw_dev;
swdevt[0].sw_dev = swp->sw_dev;
swp->sw_dev = temp;
break;
}
}
if (swp->sw_dev == NODEV)
return;
/*
* If dumpdev was the same as the old primary swap
* device, move it to the new primary swap device.
*/
if (temp == dumpdev)
dumpdev = swdevt[0].sw_dev;
#endif
}
showroot()
{
register int majdev, mindev;
register struct swdevt *swp;
majdev = major(rootdev);
mindev = minor(rootdev);
printf("root on %c%c%d%c ",
devname[majdev][0], devname[majdev][1],
mindev >> PARTITIONSHIFT, (mindev & PARTITIONMASK) + 'a');
swp = swdevt;
majdev = major(swp->sw_dev);
mindev = minor(swp->sw_dev);
printf("swap on %c%c%d%c ",
devname[majdev][0], devname[majdev][1],
mindev >> PARTITIONSHIFT, (mindev & PARTITIONMASK) + 'a');
swp++;
for (; swp->sw_dev != NODEV; swp++) {
majdev = major(swp->sw_dev);
mindev = minor(swp->sw_dev);
printf("and %c%c%d%c ",
devname[majdev][0], devname[majdev][1],
mindev >> PARTITIONSHIFT, (mindev & PARTITIONMASK) + 'a');
}
majdev = major(dumpdev);
mindev = minor(dumpdev);
printf(" dump on %c%c%d%c\n",
devname[majdev][0], devname[majdev][1],
mindev >> PARTITIONSHIFT, (mindev & PARTITIONMASK) + 'a');
}
strcmp(s1, s2)
register char *s1, *s2;
{
while (*s1 == *s2++)
if (*s1++=='\0')
return (0);
return (*s1 - *--s2);
}
strncmp(s1, s2, n)
register char *s1, *s2;
register unsigned int n;
{
if (n == 0)
return (0);
do {
if (*s1 != *s2++)
return (*(unsigned char *)s1 - *(unsigned char *)--s2);
if (*s1++ == 0)
break;
} while (--n != 0);
return (0);
}