/*	$NetBSD: autoconf.c,v 1.4 2019/04/15 20:46:10 skrll Exp $	*/

/*	$OpenBSD: autoconf.c,v 1.15 2001/06/25 00:43:10 mickey Exp $	*/

/*
 * 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
 */

/*
 * Copyright (c) 1998-2001 Michael Shalayeff
 *
 * 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. 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.
 *
 *	@(#)autoconf.c	8.4 (Berkeley) 10/1/93
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: autoconf.c,v 1.4 2019/04/15 20:46:10 skrll Exp $");

#include "opt_kgdb.h"
#include "opt_useleds.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/disklabel.h>
#include <sys/conf.h>
#include <sys/kernel.h>
#include <sys/reboot.h>
#include <sys/device.h>
#include <sys/callout.h>
#include <sys/kmem.h>

#ifdef KGDB
#include <sys/kgdb.h>
#endif

#include <machine/pdc.h>
#include <machine/iomod.h>
#include <machine/autoconf.h>

#include <dev/pci/pcivar.h>

#include <dev/scsipi/scsi_all.h>
#include <dev/scsipi/scsipi_all.h>
#include <dev/scsipi/scsiconf.h>

#include <dev/cons.h>

#include <hppa/hppa/machdep.h>
#include <hppa/dev/cpudevs.h>
#include <hppa/gsc/gscbusvar.h>

static TAILQ_HEAD(hppa_pdcmodule_head, hppa_pdcmodule) hppa_pdcmodule_list =
    TAILQ_HEAD_INITIALIZER(hppa_pdcmodule_list);

struct hppa_pdcmodule {
	TAILQ_ENTRY(hppa_pdcmodule) hm_link;
	bool			hm_registered;
	struct pdc_iodc_read	hm_pir;
	struct iodc_data	hm_type;
	struct device_path	hm_dp;
	hppa_hpa_t		hm_hpa;
	u_int			hm_hpasz;
	u_int			hm_naddrs;	/* only PDC_SYSTEM_MAP */
	u_int			hm_modindex;	/* only PDC_SYSTEM_MAP */
};

#define	HPPA_SYSTEMMAPMODULES	256

/*
 * LED blinking thing
 */
#ifdef USELEDS
int _hppa_led_on_cycles[_HPPA_LEDS_BLINKABLE];
static struct callout hppa_led_callout;
static void hppa_led_blinker(void *);
extern int hz;
#endif

void (*cold_hook)(int); /* see below */

struct hppa_pdcmodule *hppa_pdcmodule_create(struct hppa_pdcmodule *,
    const char *);
void hppa_walkbus(struct confargs *ca);
static void hppa_pdc_snake_scan(void);
static void hppa_pdc_system_map_scan(void);

/*
 * cpu_configure:
 * called at boot time, configure all devices on system
 */
void
cpu_configure(void)
{
	/*
	 * Consider stopping for a debugger before
	 * autoconfiguration.
	 */
	if (boothowto & RB_KDB) {
#ifdef KGDB
		extern int hppa_kgdb_attached;
		if (hppa_kgdb_attached)
			kgdb_connect(1);
#elif defined(DDB)
		Debugger();
#endif	/* DDB */
	}

	splhigh();
	if (config_rootfound("mainbus", NULL) == NULL)
		panic("no mainbus found");

	/* Allow interrupts - we're trusting spl* here */
	hppa_intr_enable();
	spl0();

	if (cold_hook)
		(*cold_hook)(HPPA_COLD_HOT);

#ifdef USELEDS
	memset(_hppa_led_on_cycles, 0, sizeof(_hppa_led_on_cycles));
	callout_init(&hppa_led_callout, 0);
	hppa_led_blinker((void *) 0);
#endif
}

#ifdef USELEDS
/*
 * This sets LEDs.
 */
void
hppa_led_ctl(int off, int on, int toggle)
{
	int r;

	if (machine_ledaddr == NULL)
		return;

	/* The mask is reversed when pushed out to the hardware. */
	r = ~(machine_leds = ((machine_leds & ~off) | on) ^ toggle);

	if (machine_ledword)
		*machine_ledaddr = r;
	else {
#define	HPPA_LED_DATA	0x01
#define	HPPA_LED_STROBE	0x02
		int b;
		for (b = 0x80; b; b >>= 1) {
			*machine_ledaddr = (r & b)? HPPA_LED_DATA : 0;
			DELAY(1);
			*machine_ledaddr = ((r & b)? HPPA_LED_DATA : 0) |
			    HPPA_LED_STROBE;
		}
#undef	HPPA_LED_DATA
#undef	HPPA_LED_STROBE
	}
}

/*
 * This callout handler blinks LEDs.
 */
static void
hppa_led_blinker(void *arg)
{
	u_int led_cycle = (u_int) arg;
	int leds, led_i, led;
	int load;

	/*
	 * Blink the heartbeat LED like this:
	 *
	 *   |~| |~|
	 *  _| |_| |_,_,_,_
	 *   0 1 2 3 4 6 7
	 */
#define HPPA_HEARTBEAT_CYCLES	(_HPPA_LED_FREQ / 8)
	if (led_cycle == (0 * HPPA_HEARTBEAT_CYCLES) ||
	    led_cycle == (2 * HPPA_HEARTBEAT_CYCLES)) {
		_hppa_led_on_cycles[HPPA_LED_HEARTBEAT] =
			HPPA_HEARTBEAT_CYCLES;
	}

	/* Form the new LED mask. */
	leds = 0;
	for (led_i = 0, led = (1 << 0);
	     led_i < _HPPA_LEDS_BLINKABLE;
	     led_i++, led <<= 1) {
		if (_hppa_led_on_cycles[led_i] > 0)
			leds |= led;
		if (_hppa_led_on_cycles[led_i] >= 0)
			_hppa_led_on_cycles[led_i]--;
	}

	/* Add in the system load. */
	load = averunnable.ldavg[0] >> FSHIFT;
	if (load >= (1 << (_HPPA_LEDS_COUNT - _HPPA_LEDS_BLINKABLE)))
		load = (1 << (_HPPA_LEDS_COUNT - _HPPA_LEDS_BLINKABLE)) - 1;
	leds |= (load << _HPPA_LEDS_BLINKABLE);

	/* Set the LEDs. */
	hppa_led_ctl(-1, leds, 0);

	/* NB: this assumes _HPPA_LED_FREQ is a power of two. */
	led_cycle = (led_cycle + 1) & (_HPPA_LED_FREQ - 1);
	callout_reset(&hppa_led_callout, hz / _HPPA_LED_FREQ,
		hppa_led_blinker, (void *) led_cycle);

}
#endif /* USELEDS */

/*
 * 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
cpu_dumpconf(void)
{
	extern int dumpsize;
	int nblks, dumpblks;	/* size of dump area */

	if (dumpdev == NODEV)
		goto bad;
	nblks = bdev_size(dumpdev);
	if (nblks <= ctod(1))
		goto bad;
	dumpblks = cpu_dumpsize();
	if (dumpblks < 0)
		goto bad;
	dumpblks += ctod(physmem);

	/* If dump won't fit (incl. room for possible label), punt. */
	if (dumpblks > (nblks - ctod(1)))
		goto bad;

	/* Put dump at end of partition */
	dumplo = nblks - dumpblks;

	/* dumpsize is in page units, and doesn't include headers. */
	dumpsize = physmem;
	return;

bad:
	dumpsize = 0;
	return;
}

/****************************************************************/

device_t boot_device = NULL;


void
device_register(device_t dev, void *aux)
{
	int pagezero_cookie;
	device_t pdev;

	if ((pdev = device_parent(dev)) == NULL ||
	    device_parent(pdev) == NULL)
		return;
	pagezero_cookie = hppa_pagezero_map();

	/*
	 * The boot device is described in PAGE0->mem_boot. We need to do it
	 * this way as the MD device path (DP) information in struct confargs
	 * is only available in hppa MD devices. So boot_device is used to
	 * propagate information down the device tree.
	 *
	 * If the boot device is a GSC network device all we need to compare
	 * is the HPA or device path (DP) to get the boot device.
	 * If the boot device is a SCSI device below a GSC attached SCSI
	 * controller PAGE0->mem_boot.pz_hpa contains the HPA of the SCSI
	 * controller. In that case we remember the pointer to the
	 * controller's struct dev in boot_device. The SCSI device is located
	 * later, see below.
	 */
	if (device_is_a(pdev, "gsc") || device_is_a(pdev, "phantomas") ||
	    device_is_a(pdev, "uturn")) {
		struct confargs *ca = aux;

		if ((hppa_hpa_t)PAGE0->mem_boot.pz_hpa == ca->ca_hpa) {
			/* This is (the controller of) the boot device. */
			boot_device = dev;
		}
	}
	/*
	 * If the boot device is a PCI device the HPA is the address where the
	 * firmware has mapped the PCI memory of the PCI device. This is quite
	 * device dependent, so we compare the DP. It encodes the bus routing
	 * information to the PCI bus bridge in the DP head and the PCI device
	 * and PCI function in the last two DP components. So we compare the
	 * head of the DP when a PCI bridge attaches and remember the struct
	 * dev of the PCI bridge in boot_dev if it machtes. Later, when PCI
	 * devices are attached, we look if this PCI device hangs below the
	 * boot PCI bridge. If yes we compare the PCI device and PCI function
	 * to the DP tail. In case of a network boot we found the boot device
	 * on a match. In case of a SCSI boot device we have to do the same
	 * check when SCSI devices are attached like on GSC SCSI controllers.
	 */
	if (device_is_a(dev, "dino") || device_is_a(dev, "elroy")) {
		struct confargs *ca = (struct confargs *)aux;
		int i, n;

		for (n = 0 ; ca->ca_dp.dp_bc[n] < 0 ; n++) {
			/* Skip unused DP components. */
		}
		for (i = 0 ; i < 6 && n < 6 ; i++) {
			/* Skip unused DP components... */
			if (PAGE0->mem_boot.pz_dp.dp_bc[i] < 0)
				continue;
			/* and compare the rest. */
			if (PAGE0->mem_boot.pz_dp.dp_bc[i]
			    != ca->ca_dp.dp_bc[n]) {
				hppa_pagezero_unmap(pagezero_cookie);
				return;
			}
			n++;
		}
		if (PAGE0->mem_boot.pz_dp.dp_bc[i] != ca->ca_dp.dp_mod) {
			hppa_pagezero_unmap(pagezero_cookie);
			return;
		}
		/* This is the PCI host bridge in front of the boot device. */
		boot_device = dev;

	}
	if (device_is_a(dev, "ppb") && boot_device == device_parent(pdev)) {
		/*
		 * XXX Guesswork. No hardware to test how firmware handles
		 * a ppb.
		 */
		struct pci_attach_args *paa = (struct pci_attach_args*)aux;

		if (paa->pa_device == PAGE0->mem_boot.pz_dp.dp_bc[3] &&
		    paa->pa_function == PAGE0->mem_boot.pz_dp.dp_bc[4]) {
			/*
			 * This is the PCI - PCI bridge in front of the boot
			 * device.
			 */
			boot_device = dev;
		}
	}
	if (device_is_a(pdev, "pci") && boot_device == device_parent(pdev)) {
		struct pci_attach_args *paa = (struct pci_attach_args*)aux;

		if (paa->pa_device == PAGE0->mem_boot.pz_dp.dp_bc[5] &&
		    paa->pa_function == PAGE0->mem_boot.pz_dp.dp_mod) {
			/*
			 * This is (the controller of) the boot device.
			 */
			boot_device = dev;
		}
	}
	/*
	 * When SCSI devices are attached, we look if the SCSI device hangs
	 * below the controller remembered in boot_device. If so, we compare
	 * the SCSI ID and LUN with the DP layer information. If they match
	 * we found the boot device.
	 */
	if (device_is_a(pdev, "scsibus") &&
	    boot_device == device_parent(pdev)) {
		struct scsipibus_attach_args *saa = aux;
		struct scsipi_periph *p = saa->sa_periph;

		if (p->periph_target == PAGE0->mem_boot.pz_dp.dp_layers[0] &&
		    p->periph_lun == PAGE0->mem_boot.pz_dp.dp_layers[1]) {
			/* This is the boot device. */
			boot_device = dev;
		}
	}

	hppa_pagezero_unmap(pagezero_cookie);
	return;
}

/*
 * Choose root and swap devices.
 */
void
cpu_rootconf(void)
{
#ifdef DEBUG
	int pagezero_cookie;
	int n;

	pagezero_cookie = hppa_pagezero_map();
	printf("PROM boot device: hpa %p path ", PAGE0->mem_boot.pz_hpa);
	for (n = 0 ; n < 6 ; n++) {
		if (PAGE0->mem_boot.pz_dp.dp_bc[n] >= 0)
			printf("%d/", PAGE0->mem_boot.pz_dp.dp_bc[n]);
	}
	printf("%d dp_layers ", PAGE0->mem_boot.pz_dp.dp_mod);
	for (n = 0 ; n < 6 ; n++) {
		printf( "0x%x%c", PAGE0->mem_boot.pz_dp.dp_layers[n],
		    n < 5 ? '/' : ' ');
	}
	printf("dp_flags 0x%x pz_class 0x%x\n", PAGE0->mem_boot.pz_dp.dp_flags,
	    PAGE0->mem_boot.pz_class);

	hppa_pagezero_unmap(pagezero_cookie);
#endif /* DEBUG */

	if (boot_device != NULL)
		printf("boot device: %s\n", device_xname(boot_device));
	booted_device = boot_device;
	rootconf();
}

void
hppa_walkbus(struct confargs *ca)
{
	struct hppa_pdcmodule nhm, *hm;
	int i;

	if (ca->ca_hpabase == 0)
		return;

	aprint_debug(">> Walking bus at HPA 0x%lx\n", ca->ca_hpabase);

	for (i = 0; i < ca->ca_nmodules; i++) {
		int error;

 		memset(&nhm, 0, sizeof(nhm));
		nhm.hm_dp.dp_bc[0] = ca->ca_dp.dp_bc[1];
		nhm.hm_dp.dp_bc[1] = ca->ca_dp.dp_bc[2];
		nhm.hm_dp.dp_bc[2] = ca->ca_dp.dp_bc[3];
		nhm.hm_dp.dp_bc[3] = ca->ca_dp.dp_bc[4];
		nhm.hm_dp.dp_bc[4] = ca->ca_dp.dp_bc[5];
		nhm.hm_dp.dp_bc[5] = ca->ca_dp.dp_mod;
		nhm.hm_hpa = ca->ca_hpabase + IOMOD_HPASIZE * i;
		nhm.hm_hpasz = 0;
		nhm.hm_dp.dp_mod = i;
		nhm.hm_naddrs = 0;

		error = pdcproc_iodc_read(nhm.hm_hpa, IODC_DATA, NULL,
		    &nhm.hm_pir, sizeof(nhm.hm_pir), &nhm.hm_type,
		    sizeof(nhm.hm_type));
		if (error < 0)
			continue;

		aprint_debug(">> HPA 0x%lx[0x%x]", nhm.hm_hpa,
		    nhm.hm_hpasz);

		TAILQ_FOREACH(hm, &hppa_pdcmodule_list, hm_link) {
			if (nhm.hm_hpa == hm->hm_hpa) {
				aprint_debug(" found by firmware\n");
				break;
			}
		}

		/* If we've found the module move onto the next one. */
		if (hm)
			continue;

		/* Expect PDC to report devices of the following types */
		if (nhm.hm_type.iodc_type == HPPA_TYPE_FIO) {
			aprint_debug(" expected to be missing\n");
			continue;
		}

		hppa_pdcmodule_create(&nhm, "Bus walk");
	}
}

void
pdc_scanbus(device_t self, struct confargs *ca,
    device_t (*callback)(device_t, struct confargs *))
{
	struct hppa_pdcmodule *hm;
	struct confargs nca;
	device_t dev;
	int ia;

	hppa_walkbus(ca);

	TAILQ_FOREACH(hm, &hppa_pdcmodule_list, hm_link) {
		char buf[128];
		int error;

		if (hm->hm_registered)
			continue;

		if (!(hm->hm_dp.dp_bc[0] == ca->ca_dp.dp_bc[1] &&
		    hm->hm_dp.dp_bc[1] == ca->ca_dp.dp_bc[2] &&
		    hm->hm_dp.dp_bc[2] == ca->ca_dp.dp_bc[3] &&
		    hm->hm_dp.dp_bc[3] == ca->ca_dp.dp_bc[4] &&
		    hm->hm_dp.dp_bc[4] == ca->ca_dp.dp_bc[5] &&
		    hm->hm_dp.dp_bc[5] == ca->ca_dp.dp_mod))
			continue;

		memset(&nca, 0, sizeof(nca));
		nca.ca_iot = ca->ca_iot;
		nca.ca_dmatag = ca->ca_dmatag;
		nca.ca_pir = hm->hm_pir;
		nca.ca_type = hm->hm_type;
		nca.ca_hpa = hm->hm_hpa;
		nca.ca_dp = hm->hm_dp;
		nca.ca_hpa = hm->hm_hpa;
		nca.ca_hpasz = hm->hm_hpasz;

		if (hm->hm_naddrs) {
			if (hm->hm_naddrs > HPPA_MAXIOADDRS) {
				nca.ca_naddrs = HPPA_MAXIOADDRS;
				aprint_error("WARNING: too many (%d) addrs\n",
				    hm->hm_naddrs);
			} else
				nca.ca_naddrs = hm->hm_naddrs;

			aprint_debug(">> ADDRS[%d/%d]: ", nca.ca_naddrs,
			    hm->hm_modindex);

			KASSERT(hm->hm_modindex != -1);
			for (ia = 0; ia < nca.ca_naddrs; ia++) {
				struct pdc_system_map_find_addr pdc_find_addr;

				error = pdcproc_system_map_find_addr(
				    &pdc_find_addr, hm->hm_modindex, ia + 1);
				if (error < 0)
					break;
				nca.ca_addrs[ia].addr = pdc_find_addr.hpa;
				nca.ca_addrs[ia].size =
				    pdc_find_addr.size << PGSHIFT;

				aprint_debug(" 0x%lx[0x%x]",
				    nca.ca_addrs[ia].addr,
				    nca.ca_addrs[ia].size);
			}
			aprint_debug("\n");
		}

		aprint_debug(">> HPA 0x%lx[0x%x]\n", nca.ca_hpa,
		    nca.ca_hpasz);

		snprintb(buf, sizeof(buf), PZF_BITS, nca.ca_dp.dp_flags);
		aprint_debug(">> probing: flags %s ", buf);
		if (nca.ca_dp.dp_mod >=0) {
			int n;

			aprint_debug(" path ");
			for (n = 0; n < 6; n++) {
				if (nca.ca_dp.dp_bc[n] >= 0)
					aprint_debug("%d/",
					    nca.ca_dp.dp_bc[n]);
			}
			aprint_debug("%d", nca.ca_dp.dp_mod);
		}

		aprint_debug(" type %x sv %x\n",
		    nca.ca_type.iodc_type, nca.ca_type.iodc_sv_model);

		nca.ca_irq = HPPACF_IRQ_UNDEF;
		nca.ca_name = hppa_mod_info(nca.ca_type.iodc_type,
		    nca.ca_type.iodc_sv_model);

		dev = callback(self, &nca);

		if (dev)
			hm->hm_registered = true;
	}
}

static const struct hppa_mod_info hppa_knownmods[] = {
#include <hppa/dev/cpudevs_data.h>
};

const char *
hppa_mod_info(int type, int sv)
{
	const struct hppa_mod_info *mi;
	static char fakeid[32];
	int i;

	for (i = 0, mi = hppa_knownmods; i < __arraycount(hppa_knownmods);
	    i++, mi++) {
		if (mi->mi_type == type && mi->mi_sv == sv) {
			break;
		}
	}

	if (i == __arraycount(hppa_knownmods)) {
		snprintf(fakeid, sizeof(fakeid), "type %x, sv %x", type, sv);
		return fakeid;
	}

	return mi->mi_name;
}

/*
 * Create the device on our device list.  Keep the devices in order. */
struct hppa_pdcmodule *
hppa_pdcmodule_create(struct hppa_pdcmodule *hm, const char *who)
{
	struct hppa_pdcmodule *nhm, *ahm;
	int i;

	nhm = kmem_zalloc(sizeof(*nhm), KM_SLEEP);

	nhm->hm_registered = false;
	nhm->hm_pir = hm->hm_pir;
	nhm->hm_type = hm->hm_type;
	nhm->hm_dp = hm->hm_dp;
	nhm->hm_hpa = hm->hm_hpa;
	nhm->hm_hpasz = hm->hm_hpasz;
	nhm->hm_naddrs = hm->hm_naddrs;
	nhm->hm_modindex = hm->hm_modindex;

	/* Find start of new path */
	for (i = 0; i < 6; i++) {
		if (hm->hm_dp.dp_bc[i] != -1)
			break;
	}

	/*
	 * Look, in reverse, for the first device that has a path before our
	 * new one.  In reverse because PDC reports most (all?) devices in path
	 * order and therefore the common case is to add to the end of the
	 * list.
	 */
	TAILQ_FOREACH_REVERSE(ahm, &hppa_pdcmodule_list, hppa_pdcmodule_head,
	    hm_link) {
		int check;
		int j, k;

		for (j = 0; j < 6; j++) {
			if (ahm->hm_dp.dp_bc[j] != -1)
				break;
		}

		for (check = 0, k = i; j < 7 && k < 7; j++, k++) {
			char nid, aid;

			nid = (k == 6) ? hm->hm_dp.dp_mod : hm->hm_dp.dp_bc[k];
			aid = (j == 6) ? ahm->hm_dp.dp_mod : ahm->hm_dp.dp_bc[j];

			if (nid == aid)
				continue;
			check = nid - aid;
			break;
		}
		if (check >= 0)
			break;
		else if (check < 0)
			continue;
	}
	if (ahm == NULL)
		TAILQ_INSERT_HEAD(&hppa_pdcmodule_list, nhm, hm_link);
	else
		TAILQ_INSERT_AFTER(&hppa_pdcmodule_list, ahm, nhm, hm_link);

	if (hm->hm_dp.dp_mod >= 0) {
		int n;

		aprint_debug(">> %s device at path ", who);
		for (n = 0; n < 6; n++) {
			if (hm->hm_dp.dp_bc[n] >= 0)
				aprint_debug("%d/", hm->hm_dp.dp_bc[n]);
		}
		aprint_debug("%d addrs %d\n", hm->hm_dp.dp_mod,
		    hm->hm_naddrs);
	}

	return nhm;
}

/*
 * This is used for Snake machines
 */
static struct hppa_pdcmodule *
hppa_memmap_query(struct device_path *devp)
{
	static struct hppa_pdcmodule nhm;
	struct pdc_memmap pdc_memmap;
	int error;

	error = pdcproc_memmap(&pdc_memmap, devp);

	if (error < 0)
		return NULL;

	memset(&nhm, 0, sizeof(nhm));
	nhm.hm_dp = *devp;
	nhm.hm_hpa = pdc_memmap.hpa;
	nhm.hm_hpasz = pdc_memmap.morepages;
	nhm.hm_naddrs = 0;
	nhm.hm_modindex = -1;

	error = pdcproc_iodc_read(nhm.hm_hpa, IODC_DATA, NULL, &nhm.hm_pir,
	    sizeof(nhm.hm_pir), &nhm.hm_type, sizeof(nhm.hm_type));

	if (error < 0)
		return NULL;

	return hppa_pdcmodule_create(&nhm, "PDC (memmap)");
}


static void
hppa_pdc_snake_scan(void)
{
	struct device_path path;
	struct hppa_pdcmodule *hm;
	int im, ba;

	memset(&path, 0, sizeof(path));
	for (im = 0; im < 16; im++) {
		path.dp_bc[0] = path.dp_bc[1] = path.dp_bc[2] =
		path.dp_bc[3] = path.dp_bc[4] = path.dp_bc[5] = -1;
		path.dp_mod = im;

		hm = hppa_memmap_query(&path);

		if (!hm)
			continue;

		if (hm->hm_type.iodc_type != HPPA_TYPE_BHA)
			continue;

		path.dp_bc[0] = path.dp_bc[1] =
		path.dp_bc[2] = path.dp_bc[3] = -1;
		path.dp_bc[4] = im;
		path.dp_bc[5] = 0;

		for (ba = 0; ba < 16; ba++) {
			path.dp_mod = ba;
			hppa_memmap_query(&path);
		}
	}
}

static void
hppa_pdc_system_map_scan(void)
{
	struct pdc_system_map_find_mod pdc_find_mod;
	struct device_path path;
	struct hppa_pdcmodule hm;
	int error;
	int im;

	for (im = 0; im < HPPA_SYSTEMMAPMODULES; im++) {
		memset(&path, 0, sizeof(path));
		error = pdcproc_system_map_find_mod(&pdc_find_mod, &path, im);
		if (error == PDC_ERR_NMOD)
			break;

		if (error < 0)
			continue;

		memset(&hm, 0, sizeof(hm));
		hm.hm_dp = path;
		hm.hm_hpa = pdc_find_mod.hpa;
		hm.hm_hpasz = pdc_find_mod.size << PGSHIFT;
		hm.hm_naddrs = pdc_find_mod.naddrs;
		hm.hm_modindex = im;

		error = pdcproc_iodc_read(hm.hm_hpa, IODC_DATA, NULL,
		    &hm.hm_pir, sizeof(hm.hm_pir), &hm.hm_type,
		    sizeof(hm.hm_type));
		if (error < 0)
			continue;

		hppa_pdcmodule_create(&hm, "PDC (system map)");
	}
}

void
hppa_modules_scan(void)
{
	switch (pdc_gettype()) {
	case PDC_TYPE_SNAKE:
		hppa_pdc_snake_scan();
		break;

	case PDC_TYPE_UNKNOWN:
		hppa_pdc_system_map_scan();
	}
}

void
hppa_modules_done(void)
{
	struct hppa_pdcmodule *hm, *nhm;

	TAILQ_FOREACH_SAFE(hm, &hppa_pdcmodule_list, hm_link, nhm) {
		TAILQ_REMOVE(&hppa_pdcmodule_list, hm, hm_link);
		kmem_free(hm, sizeof(*hm));
	}
}
