/* $OpenBSD: autoconf.c,v 1.50 2007/06/01 22:40:33 miod Exp $ */
/*
* Copyright (c) 1998-2003 Michael Shalayeff
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This software was developed by the Computer Systems Engineering group
* at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
* contributed to Berkeley.
*
* 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, Lawrence Berkeley Laboratory.
*
* 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. 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.
*
* @(#)autoconf.c 8.4 (Berkeley) 10/1/93
*/
#include "pci.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/disklabel.h>
#include <sys/conf.h>
#include <sys/reboot.h>
#include <sys/device.h>
#include <sys/timeout.h>
#include <uvm/uvm_extern.h>
#include <machine/iomod.h>
#include <machine/autoconf.h>
#include <dev/cons.h>
#include <hppa/dev/cpudevs.h>
#if NPCI > 0
#include <dev/pci/pcivar.h>
#include <dev/pci/pcireg.h>
#endif
/* device we booted from */
struct device *bootdv;
void dumpconf(void);
void (*cold_hook)(int); /* see below */
/*
* LED blinking thing
*/
#ifdef USELEDS
#include <sys/dkstat.h>
#include <sys/kernel.h>
struct timeout heartbeat_tmo;
void heartbeat(void *);
#endif
#include "cd.h"
#include "sd.h"
#include "st.h"
#if NCD > 0 || NSD > 0 || NST > 0
#include <scsi/scsi_all.h>
#include <scsi/scsiconf.h>
#endif
#ifdef USELEDS
/*
* turn the heartbeat alive.
* right thing would be to pass counter to each subsequent timeout
* as an argument to heartbeat() incrementing every turn,
* i.e. avoiding the static hbcnt, but doing timeout_set() on each
* timeout_add() sounds ugly, guts of struct timeout looks ugly
* to ponder in even more.
*/
void
heartbeat(v)
void *v;
{
static u_int hbcnt = 0, ocp_total, ocp_idle;
int toggle, cp_mask, cp_total, cp_idle;
timeout_add(&heartbeat_tmo, hz / 16);
cp_idle = cp_time[CP_IDLE];
cp_total = cp_time[CP_USER] + cp_time[CP_NICE] + cp_time[CP_SYS] +
cp_time[CP_INTR] + cp_time[CP_IDLE];
if (cp_total == ocp_total)
cp_total = ocp_total + 1;
if (cp_idle == ocp_idle)
cp_idle = ocp_idle + 1;
cp_mask = 0xf0 >> (cp_idle - ocp_idle) * 4 / (cp_total - ocp_total);
cp_mask &= 0xf0;
ocp_total = cp_total;
ocp_idle = cp_idle;
/*
* do this:
*
* |~| |~|
* _| |_| |_,_,_,_
* 0 1 2 3 4 6 7
*/
toggle = 0;
if (hbcnt++ < 8 && hbcnt & 1)
toggle = PALED_HEARTBEAT;
hbcnt &= 15;
ledctl(cp_mask,
(~cp_mask & 0xf0) | PALED_NETRCV | PALED_NETSND | PALED_DISK,
toggle);
}
#endif
/*
* This is called by configure to set dumplo and dumpsize.
* Dumps always skip the first CLBYTES of disk space
* in case there might be a disk label stored there.
* If there is extra space, put dump at the end to
* reduce the chance that swapping trashes it.
*/
void
dumpconf(void)
{
extern int dumpsize;
int nblks, dumpblks; /* size of dump area */
if (dumpdev == NODEV ||
(nblks = (bdevsw[major(dumpdev)].d_psize)(dumpdev)) == 0)
return;
if (nblks <= ctod(1))
return;
dumpblks = cpu_dumpsize();
if (dumpblks < 0)
return;
dumpblks += ctod(physmem);
/* If dump won't fit (incl. room for possible label), punt. */
if (dumpblks > (nblks - ctod(1)))
return;
/* Put dump at end of partition */
dumplo = nblks - dumpblks;
/* dumpsize is in page units, and doesn't include headers. */
dumpsize = physmem;
}
void
print_devpath(const char *label, struct pz_device *pz)
{
int i;
printf("%s: ", label);
for (i = 0; i < 6; i++)
if (pz->pz_bc[i] >= 0)
printf("%d/", pz->pz_bc[i]);
printf("%d.%x", pz->pz_mod, pz->pz_layers[0]);
for (i = 1; i < 6 && pz->pz_layers[i]; i++)
printf(".%x", pz->pz_layers[i]);
printf(" class=%d flags=%b hpa=%p spa=%p io=%p\n", pz->pz_class,
pz->pz_flags, PZF_BITS, pz->pz_hpa, pz->pz_spa, pz->pz_iodc_io);
}
struct pdc_memmap pdc_memmap PDC_ALIGNMENT;
struct pdc_sysmap_find pdc_find PDC_ALIGNMENT;
struct pdc_sysmap_addrs pdc_addr PDC_ALIGNMENT;
struct pdc_iodc_read pdc_iodc_read PDC_ALIGNMENT;
void
pdc_scanbus(self, ca, maxmod, hpa)
struct device *self;
struct confargs *ca;
int maxmod;
hppa_hpa_t hpa;
{
int i;
for (i = maxmod; i--; ) {
struct confargs nca;
int error;
bzero(&nca, sizeof(nca));
nca.ca_iot = ca->ca_iot;
nca.ca_dmatag = ca->ca_dmatag;
nca.ca_dp.dp_bc[0] = ca->ca_dp.dp_bc[1];
nca.ca_dp.dp_bc[1] = ca->ca_dp.dp_bc[2];
nca.ca_dp.dp_bc[2] = ca->ca_dp.dp_bc[3];
nca.ca_dp.dp_bc[3] = ca->ca_dp.dp_bc[4];
nca.ca_dp.dp_bc[4] = ca->ca_dp.dp_bc[5];
nca.ca_dp.dp_bc[5] = ca->ca_dp.dp_mod;
nca.ca_dp.dp_mod = i;
nca.ca_hpamask = ca->ca_hpamask;
nca.ca_naddrs = 0;
nca.ca_hpa = 0;
if (hpa) {
nca.ca_hpa = hpa + IOMOD_HPASIZE * i;
nca.ca_dp.dp_mod = i;
} else if ((error = pdc_call((iodcio_t)pdc, 0, PDC_MEMMAP,
PDC_MEMMAP_HPA, &pdc_memmap, &nca.ca_dp)) == 0)
nca.ca_hpa = pdc_memmap.hpa;
else if ((error = pdc_call((iodcio_t)pdc, 0, PDC_SYSMAP,
PDC_SYSMAP_HPA, &pdc_memmap, &nca.ca_dp)) == 0) {
struct device_path path;
int im, ia;
nca.ca_hpa = pdc_memmap.hpa;
for (im = 0; !(error = pdc_call((iodcio_t)pdc, 0,
PDC_SYSMAP, PDC_SYSMAP_FIND,
&pdc_find, &path, im)) &&
pdc_find.hpa != nca.ca_hpa; im++)
;
if (!error)
nca.ca_hpasz = pdc_find.size << PGSHIFT;
if (!error && pdc_find.naddrs) {
nca.ca_naddrs = pdc_find.naddrs;
if (nca.ca_naddrs > 16) {
nca.ca_naddrs = 16;
printf("WARNING: too many (%d) addrs\n",
pdc_find.naddrs);
}
if (autoconf_verbose)
printf(">> ADDRS:");
for (ia = 0; !(error = pdc_call((iodcio_t)pdc,
0, PDC_SYSMAP, PDC_SYSMAP_ADDR, &pdc_addr,
im, ia)) && ia < nca.ca_naddrs; ia++) {
nca.ca_addrs[ia].addr = pdc_addr.hpa;
nca.ca_addrs[ia].size =
pdc_addr.size << PGSHIFT;
if (autoconf_verbose)
printf(" 0x%lx[0x%x]",
nca.ca_addrs[ia].addr,
nca.ca_addrs[ia].size);
}
if (autoconf_verbose)
printf("\n");
}
}
if (!nca.ca_hpa)
continue;
if (autoconf_verbose)
printf(">> HPA 0x%lx[0x%x]\n",
nca.ca_hpa, nca.ca_hpasz);
if ((error = pdc_call((iodcio_t)pdc, 0, PDC_IODC,
PDC_IODC_READ, &pdc_iodc_read, nca.ca_hpa, IODC_DATA,
&nca.ca_type, sizeof(nca.ca_type))) < 0) {
if (autoconf_verbose)
printf(">> iodc_data error %d\n", error);
continue;
}
nca.ca_pdc_iodc_read = &pdc_iodc_read;
nca.ca_name = hppa_mod_info(nca.ca_type.iodc_type,
nca.ca_type.iodc_sv_model);
if (autoconf_verbose) {
printf(">> probing: flags %b bc %d/%d/%d/%d/%d/%d ",
nca.ca_dp.dp_flags, PZF_BITS,
nca.ca_dp.dp_bc[0], nca.ca_dp.dp_bc[1],
nca.ca_dp.dp_bc[2], nca.ca_dp.dp_bc[3],
nca.ca_dp.dp_bc[4], nca.ca_dp.dp_bc[5]);
printf("mod %x hpa %lx type %x sv %x\n",
nca.ca_dp.dp_mod, nca.ca_hpa,
nca.ca_type.iodc_type, nca.ca_type.iodc_sv_model);
}
config_found_sm(self, &nca, mbprint, mbsubmatch);
}
}
const struct hppa_mod_info hppa_knownmods[] = {
#include <hppa/dev/cpudevs_data.h>
};
const char *
hppa_mod_info(type, sv)
int type, sv;
{
const struct hppa_mod_info *mi;
static char fakeid[32];
for (mi = hppa_knownmods; mi->mi_type >= 0 &&
(mi->mi_type != type || mi->mi_sv != sv); mi++);
if (mi->mi_type < 0) {
snprintf(fakeid, sizeof fakeid, "type %x, sv %x", type, sv);
return fakeid;
} else
return mi->mi_name;
}
void
device_register(struct device *dev, void *aux)
{
#if NPCI > 0
extern struct cfdriver pci_cd;
#endif
struct confargs *ca = aux;
char *basename;
static struct device *elder = NULL;
if (bootdv != NULL)
return; /* We already have a winner */
#if NPCI > 0
if (dev->dv_parent &&
dev->dv_parent->dv_cfdata->cf_driver == &pci_cd) {
struct pci_attach_args *pa = aux;
pcireg_t addr;
int reg;
for (reg = PCI_MAPREG_START; reg < PCI_MAPREG_END; reg += 4) {
addr = pci_conf_read(pa->pa_pc, pa->pa_tag, reg);
if (PCI_MAPREG_TYPE(addr) == PCI_MAPREG_TYPE_IO)
addr = PCI_MAPREG_IO_ADDR(addr);
else
addr = PCI_MAPREG_MEM_ADDR(addr);
if (addr == (pcireg_t)PAGE0->mem_boot.pz_hpa) {
elder = dev;
break;
}
}
} else
#endif
if (ca->ca_hpa == (hppa_hpa_t)PAGE0->mem_boot.pz_hpa) {
/*
* If hpa matches, the only thing we know is that the
* booted device is either this one or one of its children.
* And the children will not necessarily have the correct
* hpa value.
* Save this elder for now.
*/
elder = dev;
} else if (elder == NULL) {
return; /* not the device we booted from */
}
/*
* Unfortunately, we can not match on pz_class vs dv_class on
* older snakes netbooting using the rbootd protocol.
* In this case, we'll end up with pz_class == PCL_RANDOM...
* Instead, trust the device class from what the kernel attached
* now...
*/
switch (dev->dv_class) {
case DV_IFNET:
/*
* Netboot is the top elder
*/
if (elder == dev) {
bootdv = dev;
}
return;
case DV_DISK:
if ((PAGE0->mem_boot.pz_class & PCL_CLASS_MASK) != PCL_RANDOM)
return;
break;
case DV_TAPE:
if ((PAGE0->mem_boot.pz_class & PCL_CLASS_MASK) != PCL_SEQU)
return;
break;
default:
/* No idea what we were booted from, but better ask the user */
return;
}
/*
* If control goes here, we are booted from a block device and we
* matched a block device.
*/
basename = dev->dv_cfdata->cf_driver->cd_name;
/*
* We only grok SCSI boot currently. Match on proper device hierarchy,
* name and unit/lun values.
*/
#if NCD > 0 || NSD > 0 || NST > 0
if (strcmp(basename, "sd") == 0 || strcmp(basename, "cd") == 0 ||
strcmp(basename, "st") == 0) {
struct scsi_attach_args *sa = aux;
struct scsi_link *sl = sa->sa_sc_link;
/*
* sd/st/cd is attached to scsibus which is attached to
* the controller. Hence the grandparent here should be
* the elder.
*/
if (dev->dv_parent == NULL ||
dev->dv_parent->dv_parent != elder) {
return;
}
/*
* And now check for proper target and lun values
*/
if (sl->target == PAGE0->mem_boot.pz_layers[0] &&
sl->lun == PAGE0->mem_boot.pz_layers[1]) {
bootdv = dev;
}
}
#endif
}
/*
* cpu_configure:
* called at boot time, configure all devices on system
*/
void
cpu_configure(void)
{
splhigh();
if (config_rootfound("mainbus", "mainbus") == NULL)
panic("no mainbus found");
cpu_intr_init();
spl0();
print_devpath("bootpath", &PAGE0->mem_boot);
if (cold_hook)
(*cold_hook)(HPPA_COLD_HOT);
#ifdef USELEDS
timeout_set(&heartbeat_tmo, heartbeat, NULL);
heartbeat(NULL);
#endif
cold = 0;
}
void
diskconf(void)
{
setroot(bootdv, 0, RB_USERREQ);
dumpconf();
}
struct nam2blk nam2blk[] = {
{ "rd", 3 },
{ "sd", 4 },
{ "st", 5 },
{ "cd", 6 },
{ "fd", 7 },
{ "wd", 8 },
{ NULL, -1 }
};