/* $OpenBSD: autoconf.c,v 1.63 2022/09/02 20:06:55 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 #include #include #include #include #include #include #include #include #include #include #include #include #if NPCI > 0 #include #include #endif /* device we booted from */ struct device *bootdv; void dumpconf(void); void (*cold_hook)(int); /* see below */ /* * LED blinking thing */ #ifdef USELEDS #include struct timeout heartbeat_tmo; void heartbeat(void *); #endif #include "cd.h" #include "sd.h" #include "st.h" #include "mpath.h" #include #include #if NMPATH > 0 #include #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; struct schedstate_percpu *spc = &(curcpu()->ci_schedstate); timeout_add(&heartbeat_tmo, hz / 16); cp_idle = spc->spc_cp_time[CP_IDLE]; cp_total = spc->spc_cp_time[CP_USER] + spc->spc_cp_time[CP_NICE] + spc->spc_cp_time[CP_SYS] + spc->spc_cp_time[CP_INTR] + spc->spc_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); 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=0x%x spa=0x%x io=0x%x\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(struct device *self, struct confargs *ca, int maxmod, hppa_hpa_t hpa, int cpu_scan) { int start, end, incr, i; /* Scan forwards for CPUs, backwards for everything else. */ if (cpu_scan) { start = 0; incr = 1; end = maxmod; } else { start = maxmod - 1; incr = -1; end = -1; } for (i = start; i != end; i += incr) { 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 + 1)) && 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); } if (cpu_scan && nca.ca_type.iodc_type == HPPA_TYPE_NPROC && nca.ca_type.iodc_sv_model == HPPA_NPROC_HPPA) ncpusfound++; if (cpu_scan && ((nca.ca_type.iodc_type != HPPA_TYPE_NPROC || nca.ca_type.iodc_sv_model != HPPA_NPROC_HPPA) && (nca.ca_type.iodc_type != HPPA_TYPE_MEMORY || nca.ca_type.iodc_sv_model != HPPA_MEMORY_PDEP))) continue; if (!cpu_scan && ((nca.ca_type.iodc_type == HPPA_TYPE_NPROC && nca.ca_type.iodc_sv_model == HPPA_NPROC_HPPA) || (nca.ca_type.iodc_type == HPPA_TYPE_MEMORY && nca.ca_type.iodc_sv_model == HPPA_MEMORY_PDEP))) continue; config_found_sm(self, &nca, mbprint, mbsubmatch); } } const struct hppa_mod_info hppa_knownmods[] = { #include }; 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 #if NCD > 0 || NSD > 0 || NST > 0 extern struct cfdriver scsibus_cd; #endif struct confargs *ca = aux; 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: case DV_DULL: 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. * * We only grok SCSI boot currently. Match on proper device * hierarchy and unit/lun values. */ #if NCD > 0 || NSD > 0 || NST > 0 if (dev->dv_parent && dev->dv_parent->dv_cfdata->cf_driver == &scsibus_cd) { 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->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(); if (cold_hook) (*cold_hook)(HPPA_COLD_HOT); #ifdef USELEDS timeout_set(&heartbeat_tmo, heartbeat, NULL); heartbeat(NULL); #endif cold = 0; } void diskconf(void) { print_devpath("bootpath", &PAGE0->mem_boot); #if NMPATH > 0 if (bootdv != NULL) bootdv = mpath_bootdv(bootdv); #endif setroot(bootdv, 0, RB_USERREQ); dumpconf(); } const struct nam2blk nam2blk[] = { { "vnd", 2 }, { "rd", 3 }, { "sd", 4 }, { "cd", 6 }, { "fd", 7 }, { "wd", 8 }, { NULL, -1 } };